subsfunc.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.26 $

  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 _SUBSFUNC_H_
#define _SUBSFUNC_H_

// *********************************************************************
// included header files
// + standard includes
#include <string>

// + local headers
#include "balancesheet.h"

// *********************************************************************
// class declarations
namespace OSB_DB {
    class Session;
}
namespace OSB_LIB {
    class Date;
    class Contract;
    class ProductCatalogue;
    class PersProduct;
    class PersNode;
    class StatusChanges;
}

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

// *********************************************************************
// type definitions

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

    // *****************************************************************
    // CLASS:     SubsChargeList
    class SubsChargeList {
    public:
        SubsChargeList(
            const PersProduct::Oid& ppId,
            const ProductNode::Oid& pNodeId,
            const Date&             billedFrom,
            const Date&             billedTo,
            const Date&             chargedFrom,
            const Date&             chargedTo
        ) : persProductId_(ppId), productNodeId_(pNodeId),
            billedFrom_(billedFrom), billedTo_(billedTo),
            chargedFrom_(chargedFrom), chargedTo_(chargedTo) {}

        SubsCharge& newSubsCharge(
            const SubsFuncCfg&   cfg,
            const SubsChargeDef& scd,
            const bool flag = true
        );

        void setBaseSubsCharge(
            SubsCharge&          sc,
            const SubsFuncCfg&   cfg,
            const SubsChargeDef& scd
        );


        const Date& billedFrom() const { return billedFrom_; }
        const Date& billedTo() const { return billedTo_; }
        const Date& chargedFrom() const { return chargedFrom_; }
        const Date& chargedTo() const { return chargedTo_; }

        SubsCharges& subsCharges() { return subsCharges_; }

    private:
        const PersProduct::Oid& persProductId_;  
        const ProductNode::Oid& productNodeId_;  

        const Date&             billedFrom_;     
        const Date&             billedTo_;       

        const Date&             chargedFrom_;    
        const Date&             chargedTo_;      

        SubsCharges             subsCharges_;    

    };

    // *****************************************************************
    // CLASS:     SubsFuncBase, compute subscription charges

    class SubsFuncBase {
    public:
        SubsFuncBase() {}
        virtual ~SubsFuncBase() {}

        virtual std::string
        typeName() const { return std::string("SubsFuncBase"); }

        virtual void chargeSubscription(
            SubsChargeList& scList,
            const StatusChanges& statusList
        ) const = 0;
    };

    // *****************************************************************
    // CLASS:     SubFuncOnce, charge each status once

    class SubFuncOnce : public SubsFuncBase {
    public:
        SubFuncOnce(const SubsFuncCfg& cfg) : cfg_(cfg) {}
        virtual ~SubFuncOnce() {}

        virtual std::string
        typeName() const { return std::string("SubFuncOnce"); }

        virtual void chargeSubscription(
            SubsChargeList& scList,
            const StatusChanges& statusList
        ) const;

    private:
        SubFuncOnce(const SubFuncOnce&);
        void operator=(const SubFuncOnce&);

    private:
        const SubsFuncCfg& cfg_;        
    };

    // *****************************************************************
    // CLASS:     ChargeSubscription, charge subscription fees

    class ChargeSubscription {
    public:
        ChargeSubscription() {}

        void operator()(
            const Contract& co,
            SubsCharges& subsCharges,
            const Date& periodStart,
            const Date& periodEnd
        );

        void chargeProduct(
                  SubsCharges& subsCharges,
            const PersProduct& persProduct,
            const Date&        periodStart,
            const Date&        periodEnd
        );

        SubsFuncBase*
        mkSubsFunc(const SubsFuncCfg&);

    private:
        SubsFuncBase* getSubsFunc(
            const Pricelist::Oid& plId,
            const Date& refDate
        );
    };

}                                       // namespace OSB_LIB
#endif                                  // #ifndef _SUBSFUNC_H_

---