pricelist.h

Go to the documentation of this file.

// OSB Library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.56 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */

#ifndef _PRICELIST_H_
#define _PRICELIST_H_

// *********************************************************************
// included header files
// + standard includes
#include <string>
#include <list>
#include <map>
#include <iosfwd>                    // ToDo: remove when no more needed

// + local headers
#include "osbid.h"
#include "chrono.h"
#include "chargetraits.h"
#include "decimal.h"
#include "status.h"
#include "osbunit.h"

// *********************************************************************
// class declarations
namespace OSB_DB {
    class PricelistGw;
}

// ToDo: get the real event-id, this is a quick hack!
namespace OSB_LIB {
    class ProductCatalogue;
}

// *********************************************************************
// namespace extensions
namespace OSB_LIB {

// *********************************************************************
// class definitions

    struct SubsChargeDef {
        typedef Id<SubsChargeDef> Oid;

        SubsChargeDef(const Oid&,
                      const Status&,
                      const Decimal&,
                      const ChargeTraits::Oid&);

        Oid               id;            
        Status            status;        
        Decimal           charge;        
        ChargeTraits::Oid ctId;          
    };

    enum SubsFuncType { sfSubFuncOnce = 1 };

    class SubsFuncCfg {
        friend class OSB_DB::PricelistGw;
        friend class ProductCatalogue;
    protected:
        typedef std::list<SubsChargeDef> ChargeList;
    public:
        typedef Id<SubsFuncCfg> Oid;

        SubsFuncCfg(const Oid& id, SubsFuncType sft) :
            id_(id), name_(), des_(), sfType_(sft),
            status_('\0'), periodLength_(0) {}
        virtual ~SubsFuncCfg() {}

        const Oid& oid() const { return id_; }
        const std::string& name() const { return name_; }

        SubsFuncType sfType() const { return sfType_; }

        uint periodLength() const { return periodLength_; }
        Unit::Oid unitId() const { return unitId_; }

        void addSubsChargeDef(const SubsChargeDef&);
        void delSubsChargeDef(const SubsChargeDef::Oid&);

        const SubsChargeDef*
        findSubsChargeDef(const SubsChargeDef::Oid&) const;

        const SubsChargeDef*
        findSubsChargeDef(const Status&) const;

        const SubsChargeDef*
        findSubsChargeDef(const StatusValue& sv) const
        {
            StatusReason::Oid reason;
            return findSubsChargeDef(Status(sv, reason));
        }

    protected:
        SubsFuncCfg(const SubsFuncCfg& rhs) :
            id_(rhs.id_), charges_(rhs.charges_) {}

    protected:
        Oid           id_;              
        std::string   name_;            
        std::string   des_;             
        SubsFuncType  sfType_;          
        // ToDo: use CfgStatus
        char          status_;          
        uint          periodLength_;    
        Unit::Oid     unitId_;          

        ChargeList    charges_;         

    private:
        SubsFuncCfg& operator=(const SubsFuncCfg& rhs);

    // ToDo: remove all below (useful only for development)
    public:
        friend std::ostream&
            operator<<(std::ostream&,
                       const SubsFuncCfg&);
        virtual std::ostream& prInfo(std::ostream&) const;
    };

    typedef std::vector<SubsFuncCfg*> SubsFuncCfgs;

    class OnetimeChargeDef {
        friend class OSB_DB::PricelistGw;
    public:
        typedef Id<OnetimeChargeDef> Oid;

        OnetimeChargeDef() {}

        OnetimeChargeDef(
             const Oid& oid,
             const Decimal& charge,
             const ChargeTraits::Oid& ctId
        ) : id_(oid), charge_(charge), ctId_(ctId) {}

        bool operator==(const OnetimeChargeDef& rhs) const
        {
            return id_ == rhs.id_;
        }

        bool operator==(const Oid& id) const { return id_ == id; }

        bool operator <(const OnetimeChargeDef& rhs) const
        {
            return id_ < rhs.id_;
        }

        bool operator<(const Oid& id) const { return id_ < id; }

        const Oid& oid() const { return id_; }

        Decimal charge() const { return charge_; }

        const ChargeTraits::Oid& ctId() const { return ctId_; }

        void setCharge(const Decimal& charge);

        void setChargeTraitsId(
            const ChargeTraits::Oid& ctId
        );

        bool read(const OSB_DB::Session& session);

        bool insert(const OSB_DB::Session& session);
    private:
        Oid              id_;           
        Decimal          charge_;       
        ChargeTraits::Oid ctId_;        
    };

    class EventCharges {
        friend class OSB_DB::PricelistGw;
    public:
        enum EventId {
            eventUnknown = 0,    
            eventBilling = 1     
        };

        static EventId toEventId(long ei);

        static long toLong(EventId ei);

        typedef std::list<OnetimeChargeDef::Oid> ChargeList;

        typedef std::map<EventId, ChargeList> EventChargeList;
    public:
        EventCharges() : chargeList_() {}

        int addEventCharge(
                  EventId                eventId,
            const OnetimeChargeDef::Oid& ocd);

        int removeEventCharge(EventId eventId);

        const EventChargeList& eventChargeList() const
        {
            return chargeList_;
        }
    private:
        EventChargeList chargeList_;
    };

    class Pricelist {
        friend class ProductCatalogue;
        friend class OSB_DB::PricelistGw;
    public:
        typedef Id<Pricelist> Oid;

        Pricelist() {}

        Pricelist(
            const Oid&         id,
            const std::string& name,
            const std::string& des
        ) : id_(id), name_(name), des_(des), objVs_(0) {}



        const Oid& oid() const { return id_; }
        const std::string& name() const { return name_; }
        const std::string& desc() const { return des_; }
        long objVs() const { return objVs_; }



        void setName(const std::string& name) { name_ = name; }
        void setDesc(const std::string& desc) { des_ = desc; }
    private:
        void checkObjVs(const OSB_DB::Session& session);

        bool read(const OSB_DB::Session& session);

        bool insert(const OSB_DB::Session& session);

        bool update(const OSB_DB::Session& session);

        bool remove(const OSB_DB::Session& session);
    private:
        Oid         id_;             
        std::string name_;           
        std::string des_;            
        long        objVs_;          
    };

    typedef std::vector<Pricelist> Pricelists;

    class PricelistCfg {
        friend class ProductCatalogue;
        friend class OSB_DB::PricelistGw;

    public:
        typedef std::list<OnetimeChargeDef> OnetimeChargeDefs;

        typedef Id<Pricelist> PricelistId;

        typedef Id2<PricelistCfg> Oid;

        explicit PricelistCfg(const Oid&, const std::string& name = "");
        ~PricelistCfg() {}

    public:
        const Oid& oid() const { return id_; }

        const std::string& name() const { return name_; }

        long objVs() const { return objVs_; }

        const EventCharges& eventCharges() const { return eventCharges_; }

        CfgStatus status() const { return status_; }

        const Date& releaseDate() const { return releaseDate_; }

        const PricelistId pricelistId() const
        {
            return PricelistId(id_.id1_);
        }

        const SubsFuncCfg::Oid subsFuncCfgId() const
        {
            return subsFuncCfgId_;
        }

        const OnetimeChargeDef* findOnetimeChargeDef(
            const OnetimeChargeDef::Oid& chargeId
        ) const;

        const OnetimeChargeDefs& getOnetimeChargeDefs() const
        {
            return onetimeCharges_;
        }

        OnetimeChargeDefs& onetimeChargeDefs()
        {
            return onetimeCharges_;
        }

        void setSubsFuncCfg(const SubsFuncCfg::Oid pCfg)
        {
            subsFuncCfgId_ = pCfg;
        }

        bool addOnetimeChargeDef(
            OSB_DB::Session& session,
            OnetimeChargeDef& otc);

        int removeEventCharge(EventCharges::EventId eventId);

        int addEventCharge(EventCharges::EventId        eventId,
                           const OnetimeChargeDef::Oid& chargeId);
    private:
        void checkObjVs(const OSB_DB::Session& session);

        bool read(const OSB_DB::Session& session);

        bool insert(const OSB_DB::Session& session);

        bool update(const OSB_DB::Session& session);

        bool remove(const OSB_DB::Session& session);

        bool check(const OSB_DB::Session& session);

        bool release(const OSB_DB::Session& session);

        bool revoke(const OSB_DB::Session& session);

        bool unfreeze(const OSB_DB::Session& session);
    private:
        Oid               id_;            

        std::string       name_;          
        long              objVs_;         
        SubsFuncCfg::Oid  subsFuncCfgId_; 
        CfgStatus         status_;        

        Date              releaseDate_;
        OnetimeChargeDefs onetimeCharges_;
        EventCharges eventCharges_;
    };

    typedef std::vector<PricelistCfg> PricelistCfgs;

// *********************************************************************
// inline definitions
    inline bool operator==(const OnetimeChargeDef::Oid& id,
                           const OnetimeChargeDef& rhs)
    {
        return rhs == id;
    }

    inline bool operator<(const OnetimeChargeDef::Oid& id,
                          const OnetimeChargeDef& rhs)
    {
        // id is NOT minor than rhs if a) rhs == id or b) rhs < id
        return !(rhs == id || rhs < id);
    }

}                                       // namespace OSB_LIB
#endif                                  // #ifndef _PRICELIST_H_

---