balancesheet.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Vipul Gupta (vg)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.115 $

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

// *********************************************************************
// included header files
// + standard includes
#include <iosfwd>
#include <vector>
#include <list>

// + local headers
#include "cdrlist.h"
#include "osbid.h"
#include "contract.h"
#include "billcycle.h"
#include "osbunit.h"
#include "chargetraits.h"

// + class declarations
namespace OSB_DB {
    class  Session;
    struct BalanceSheetGw;
}

namespace OSB_LIB {
    class Asn1Writer;
    class CdrIo;
    class ChargeDetail;
    class SumCdrList;
    class Udr;
}

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

// *********************************************************************
// forward declarations
    class BsPage;
    class BalanceSheet;

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

    // *****************************************************************
    // struct SubsCharge
    struct SubsCharge {
        SubsCharge(
            const PersProduct::Oid& persId,
            const ProductNode::Oid& nodeId
        ) : persProductId(persId), productNodeId(nodeId),
            periodLength(0), numDays(-1), daysCharged(-1) {}

        typedef std::pair<Date, Date> Period;

        PersProduct::Oid persProductId;
        ProductNode::Oid productNodeId;



        Decimal baseCharge;
        size_t periodLength;
        // Period unit.
        Unit::Oid unitId;
        long numDays;



        Decimal charge;
        ChargeTraits::Oid ctId;
        Status status;
        Decimal baseFractions;
        long daysCharged;
        std::vector<Period> periods;
    };

    typedef std::vector<SubsCharge> SubsCharges;
    typedef SubsCharges::iterator SubsChargesI;

    // *****************************************************************
    // struct AdvanceCharge
    struct AdvanceCharge {
        typedef Id<AdvanceCharge> Oid;

        Oid oid;
        Id<BsPage> pageId;
        PersProduct::Oid persProductId;
        ProductNode::Oid productNodeId;
        Decimal amount;
        ChargeTraits::Oid chargeTraitsId;
        Date periodStart;
        Date periodEnd;
        DateTime assigned;
        std::string remark;

        AdvanceCharge() {}
    };

    typedef std::vector<AdvanceCharge> AdvanceCharges;

    // *****************************************************************
    // struct OnetimeCharge
    struct OnetimeCharge {
        friend class BsPage;

        typedef Id<OnetimeCharge> Oid;

        Oid oid;
        Id<BsPage> pageId;
        PersProduct::Oid persProductId;
        ProductNode::Oid productNodeId;
        StatusChange::Oid statusChangeId;
        Money charge;
        ChargeTraits::Oid chargeTraitsId;
        DateTime assigned;
        std::string remark;
        EditStatus::Status editStatus() const
        {
            return status_.status();
        }
    private:
        EditStatus status_;
    };

    typedef std::vector<OnetimeCharge> OnetimeCharges;

    // *****************************************************************
    // class BsTotal
    class BsTotal {
        friend class BsPage;

        friend struct OSB_DB::BalanceSheetGw;

    public:
        struct SubTotal {
            Currency::Oid currency_;
            Decimal curUsg_;
            Decimal curOtc_;
            Decimal curAdv_;
            Decimal deltaUsg_;
            Decimal deltaOtc_;
            Decimal deltaAdv_;
        };

        typedef std::map<Currency::Oid, SubTotal> List;

    public:

        const List& list() const { return list_; }
        List::size_type size() const { return list_.size(); }
        List::const_iterator begin() const { return list_.begin(); }
        List::const_iterator end() const { return list_.end(); }

        BsTotal& operator+=(const BsTotal& rhs);

    private:


        SubTotal& operator[](const Currency::Oid& cc);
        void clear() { list_.clear(); }

        void resetCurrentCharges();

        void add(const std::vector<ChargeDetail>& cd);

        void substractCurrentUsage();

    private:
        List list_;
    };                                  // class BsTotal

    // *****************************************************************
    // class BsPage
    class BsPage {
        friend struct OSB_DB::BalanceSheetGw;

        friend class BalanceSheet;

    public:
        typedef Id<BsPage> Oid;

        // class specific exceptions: defined and documented below
        class NotFound;
        class ChargesAssigned;
        class PageClosed;
        class NoEndDate;
        class CdrRecoveryNeeded;
        class SetRecoveryFailed;
        class UpdateUsageFailed;
        class CommitCdrFailed;

    public:
        enum Status {
            bpUnknown       = 0,
            bpNormal        = 1,
            bpRerate        = 2,
            bpDontBill      = 4,

            bpBillingFailed = 3
        };

        enum CdrFileStatus {
            fsUnchanged,
            fsPending,
            fsDbCommitted
        };

    public:
        static long toLong(
            Status status
        );

        static Status toStatus(
            long status
        );

        explicit BsPage(const Oid& oid = Oid());

        BsPage(
            const Contract::Oid&  coId,
            const Billcycle::Oid& bcId
        );

    private:
        void initialize();

    public:
        BsPage(const BsPage& rhs);
        BsPage& operator=(const BsPage& rhs);
        ~BsPage();



        const Oid& oid() const { return oid_; }
        const Contract::Oid& coId() const { return coId_; }
        const Date& startDate() const { return startDate_; }
        const Date endDate() const
        {
            if (Date::max() == endDate_) return Date();
            return endDate_;
        }
        const Billcycle::Oid& billcycleId() const
        {
            return billcycleId_;
        }
        const DateTime& opened()  const { return opened_; }
        const DateTime& closed()  const { return closed_; }
        bool isOpen() const { return closed_.notSet(); }
        bool justBilled() const { return justBilled_; }
        bool rerating() const { return rerating_; }
        const DateTime& lastCharged() const { return lastCharged_; }
        const Status& status() const { return status_; }
        long recoveryId() const { return recoveryId_; }
        const BsTotal& charges() const { return charges_; }
        const SubsCharges& subsCharges() const { return subsCharges_; }
        const AdvanceCharges& advanceCharges() const
        {
            return advanceCharges_;
        }
        const OnetimeCharges& onetimeCharges() const
        {
            return onetimeCharges_;
        }
        const SumCdrList* sumCdrList() const;
        const CdrList& cdrList() const;

        bool usageModified() const;

        void setEndDate(const Date& endDate);

        void setBilled() { justBilled_ = true; }

        void setRerating();

        OnetimeCharges& getOnetimeCharges() { return onetimeCharges_; }

        SubsCharges& getSubsCharges() { return subsCharges_; }

        bool setStatus(
            const OSB_DB::Session& session,
            const Status&          status
        );



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

        bool readAll(
            const OSB_DB::Session& session,
                  bool             withCdr
        );

        void readCharges(
            const OSB_DB::Session& session,
                  bool             withCdr
        );

        void readUsageCharges(
            const OSB_DB::Session& session,
                  bool             withCdr
        );

        void readCdrs();

        void readCdrs(CdrList& dest);

        void readOnetimeCharges(
            const OSB_DB::Session& session
        );

        void readAdvanceCharges(
            const OSB_DB::Session& session
        );

    public:
        void addCdr(const Cdr& cdr);

    private:
        void updateUsage(
            const OSB_DB::Session& session
        );

        void writeCdrs(
            long             recoveryId,
            OSB_DB::Session& session,
            Asn1Writer&      writer
        );

        void clearRecoveryId(
            const OSB_DB::Session& session
        );

        void commitCdrs();

        void removeUsage(const OSB_DB::Session& session);

        bool restoreCdrs(OSB_DB::Session& session);

    private:
        bool restoreCdrFiles(OSB_DB::Session& session);

    public:
        const OnetimeCharge* findOtc(const OnetimeCharge::Oid& otcId);
        void addOtc(const OnetimeCharge& otc);
        bool delOtc(const OnetimeCharge::Oid& otcId);
    private:
        bool saveOtCharges(const OSB_DB::Session& session);

    public:
        void addAdvCharge(const Money& charge);
    private:
        bool saveAdvCharges(const OSB_DB::Session& session);

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

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

        void close(
            const OSB_DB::Session& session
        );

        bool remove(OSB_DB::Session& session);

    private:
        Oid oid_;
        Contract::Oid coId_;
        Date startDate_;
        Date endDate_;
        Billcycle::Oid billcycleId_;
        DateTime opened_;
        DateTime closed_;
        bool justBilled_;
        bool rerating_;
        DateTime lastCharged_;

        Status status_;

        bool usageChanged_;

        CdrFileStatus cdrFileStatus_;
        long recoveryId_;

        BsTotal charges_;
        SumCdrList* sumCdrs_;
        CdrList cdrs_;

        mutable CdrIo* cdrIo_;

    private:


        SubsCharges subsCharges_;
        AdvanceCharges advanceCharges_;
        OnetimeCharges onetimeCharges_;

    private:
        OnetimeCharge* find(const OnetimeCharge::Oid& otcId);
        CdrIo& cdrIo() const;
    };                                  // class BsPage

    // *****************************************************************
    // exceptions of BsPage
    class BsPage::NotFound : public OsbException {
    public:
        static const ErrorNo errNo = 588;
        NotFound(const BsPage& page);
    };

    class BsPage::ChargesAssigned : public OsbException {
    public:
        static const ErrorNo errNo = 589;
        ChargesAssigned(const BsPage& page);
    };

    class BsPage::PageClosed : public OsbException {
    public:
        static const ErrorNo errNo = 590;
        PageClosed(const BsPage& page);
    };

    class BsPage::NoEndDate : public OsbException {
    public:
        static const ErrorNo errNo = 591;
        NoEndDate(const BsPage& page);
    };

    class BsPage::CdrRecoveryNeeded : public OsbException {
    public:
        static const ErrorNo errNo = 592;
        CdrRecoveryNeeded(const BsPage& page);
    };

    class BsPage::SetRecoveryFailed : public OsbException {
    public:
        static const ErrorNo errNo = 621;
        SetRecoveryFailed(const BsPage& page, long recoveryId);
    };

    class BsPage::UpdateUsageFailed : public OsbException {
    public:
        static const ErrorNo errNo = 650;
        UpdateUsageFailed(const BsPage& page);
    };

    class BsPage::CommitCdrFailed : public OsbException {
    public:
        static const ErrorNo errNo = 651;
        CommitCdrFailed(const BsPage& page);
    };

    // *****************************************************************
    // class BalanceSheet
    class BalanceSheet {
        friend struct OSB_DB::BalanceSheetGw;

    public:
        typedef std::list<BsPage> Pages;

    public:                             // class specific exceptions
        // defined and documented after the class definition
        class NotLocked;
        class NoOpenPage;
        class Deadlock;
        class LockFailed;
        class BillcycleInvalid;
        class PageNotFound;

    public:
        explicit BalanceSheet(
            const Contract::Oid& coId = Contract::Oid()
        ) : coId_(coId), locked_(false), objVs_(0),
            allPages_(false) {}



        const Contract::Oid& coId() const { return coId_; }
        bool locked() const { return locked_; }
        long objVs() const { return objVs_; }
        bool usageModified() const;
        bool allPages() const { return allPages_; }
        const Pages& pages() const { return pages_; }
        void totalCharges(BsTotal& dest, bool openOnly) const;

        Pages& getPages() { return pages_; }

        BsPage* findPage(const BsPage::Oid& pageId);

        bool read(
            const OSB_DB::Session& session,
                  bool             readAll = false
        );

        void sortPages(bool desc = true);

        bool readCharges(
            const OSB_DB::Session& session,
                  bool             withUsg,
                  bool             withCdr,
                  bool             withOtc,
                  bool             withAdv
        );

        void readCdrs();

        void getCdrsToRerate(
            CdrList& dest
        );

        ObjectStatus lock(
            const OSB_DB::Session& session,
                  bool             noWait = false
        );

        bool setUnlocked();

        BsPage* getOpenPage(const DateTime& ts);

    private:
        bool createPage(
            const OSB_DB::Session& session,
            const Date&            tsDate
        );

    public:


        void addUsage(
            const Cdr&             cdr,
            const OSB_DB::Session& session
        );

        void addUsage(
            const CdrList&         cdrs,
            const OSB_DB::Session& session
        );

        void updateUsage(
            const OSB_DB::Session& session
        );

        void writeCdrs(
            long             recoveryId,
            OSB_DB::Session& session,
            Asn1Writer&      writer
        );

        bool restoreCdrs(OSB_DB::Session& session);

        void removeUsage(const OSB_DB::Session& session);

        void clearRecoveryId(
            const OSB_DB::Session& session
        );

        void commitCdrs();



        BsPage::Oid addOtc(
            const OnetimeCharge&   otc,
            const OSB_DB::Session& session
        );

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



        void addAdvCharge(
            const Money&           charge,
            const DateTime&        valueDate,
            const OSB_DB::Session& session
        );
        bool saveAdvCharges(const OSB_DB::Session& session);

        void closeBilledPages(
            const OSB_DB::Session& session,
            const DateTime&        billed,
            const Contract&        contract
        );

        bool openPage(
            const OSB_DB::Session& session,
            const DateTime&        ts,
            const Contract&        contract
        );

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

        ObjectStatus checkObjVs(
            const OSB_DB::Session& session
        ) const;

    private:
        Contract::Oid coId_;
        bool locked_;
        long objVs_;
        bool allPages_;
        Pages pages_;
        Date nextPageStart_;

        Billcycle::Oid bcId_;
        Billcycle::Type bcType_;
    };                                  // class BalanceSheet

    // *****************************************************************
    // exceptions of BalanceSheet

    class BalanceSheet::NotLocked : public OsbException {
    public:
        static const ErrorNo errNo = 582;
        NotLocked(const BalanceSheet& bs);
    };

    class BalanceSheet::NoOpenPage : public OsbException {
    public:
        static const ErrorNo errNo = 586;
        NoOpenPage(
            const BalanceSheet& bs,
            const DateTime&     ts
        );
    };

    class BalanceSheet::Deadlock : public OsbException {
    public:
        static const ErrorNo errNo = 584;
        Deadlock(const BalanceSheet& bs);
    };

    class BalanceSheet::LockFailed : public OsbException {
    public:
        static const ErrorNo errNo = 583;
        LockFailed(const BalanceSheet& bs);
    };

    class BalanceSheet::BillcycleInvalid : public OsbException {
    public:
        static const ErrorNo errNo = 585;
        BillcycleInvalid(
            const BalanceSheet&   bs,
            const Billcycle::Oid& bcId,
                  Billcycle::Type bcType
        );
    };

    class BalanceSheet::PageNotFound : public OsbException {
    public:
        static const ErrorNo errNo = 587;
        PageNotFound(
            const BalanceSheet& bs,
            const BsPage::Oid&  pageId
        );
    };
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _BALANCESHEET_H_

---