persproduct.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.166 $

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

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

// + local headers
#include "chrono.h"
#include "osbid.h"
#include "persitem.h"
#include "persitems.h"
#include "product.h"
#include "status.h"
#include "statuschange.h"
#include "statusrequest.h"

// + class declarations
namespace OSB_DB {
    class PersProductGw;
}

namespace OSB_LIB {
    class Associate;
    class Contract;
    class OsbErrors;
    class PersCredit;
    class RequestHandler;
    class TariffSystem;
}

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

    // forwards
    class PersProduct;

    class PersProductNode {
        friend class OSB_DB::PersProductGw;
        friend class PersProduct;

    public:
        typedef Id2<PersProductNode> Oid;

    public:
        PersProductNode(const Oid& id) : oid_(id) {}

    public:


        const Oid& oid() const { return oid_; }
        Id<PersProduct> persProductId() const;
        ProductNode::Oid productNodeId() const;
        const PersProductItems& persItems() const
        {
            return persItems_;
        }

        const DateTime& created() const
        {
            return created_;
        }

        const Status& effStatus() const
        {
            return effStatus_;
        }

        const DateTime& effStatusDate() const
        {
            return effStatusDate_;
        }

        const Status& prefStatus() const
        {
            return prefStatus_;
        }

        const DateTime& prefStatusDate() const
        {
            return prefStatusDate_;
        }

        const StatusChanges& statusChanges() const
        {
            return chngs_;
        }

        const StatusRequests& statusRequests() const
        {
            return reqs_;
        }


        void assignItem(
            std::auto_ptr<PersProductItem> persItem
        );



        const PersProductItem* findPersItem(
            const Id<PersProductItem>& ppiId
        ) const;

        const PersProductItem& getPersItem(
            const Id<PersProductItem>& ppiId
        ) const;

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



        void readStatusChanges(
            const OSB_DB::Session& session,
            const Period&          period
        );

        void readStatusRequests(
            const OSB_DB::Session& session,
            const Period&          period
        );

    private:
        bool requestStatus(
            const OSB_DB::Session& session,
            const ProductNode&     node,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );

        OsbError setPrefStatus(
            const OSB_DB::Session& session,
            const StatusRequest&   request
        );

        bool changeStatus(          // pers. product only
            const OSB_DB::Session& session,
                  StatusChange&    change,
                  OsbErrors&       errors
        );



        const Id<PersProductItem> addPersItem(
            const OSB_DB::Session&               session,
                  std::auto_ptr<PersProductItem> apPpi
        );

        bool delPersItem(
            const OSB_DB::Session&     session,
            const Id<PersProductItem>& ppiId
        );

        Id<PersProductItem> updPersItem(
            const OSB_DB::Session& session,
                  PersProductItem& ppi
        );

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

    private:
        Oid oid_;
        DateTime created_;
        Status prefStatus_;
        DateTime prefStatusDate_;
        Status effStatus_;
        DateTime effStatusDate_;
        StatusChanges chngs_;
        StatusRequests reqs_;
        PersProductItems persItems_;
    };                                  // class PersProductNode

    typedef std::list<PersProductNode> PersProductNodes;

    class PersPart;
    typedef std::vector<PersPart> PersParts;

    class PersPart {
        friend class PersProduct;
    public:
        PersPart()
          : pProductNode_(0),
            pPersNode_(0),
            isSubscribed_(false)
        {
            // empty
        }

        int mandatory() const
        {
            return pProductNode_->mandatory();
        }

        const ProductNode* pProductNode() const
        {
            return pProductNode_;
        }

        const PersProductNode* pPersNode() const
        {
            return pPersNode_;
        }

        const PersParts& persParts() const
        {
            return persParts_;
        }

        bool isSubscribed() const
        {
            return isSubscribed_;
        }


    private:
        const ProductNode*     pProductNode_;
        const PersProductNode* pPersNode_;
        PersParts persParts_;
        bool isSubscribed_;
    };

    class PersProduct {
        friend class OSB_DB::PersProductGw;
        friend class Contract;
        friend class RequestHandler;

        typedef Id<Product>     ProductId;
        typedef Id<Contract>    ContractId;

    public:
        typedef Id<PersProduct> Oid;
        typedef Id<Associate>   UserId;

    public:
        PersProduct(const Oid& oid)
          : oid_(oid), objVs_(0)
        {
            // empty
        }

        PersProduct(const Oid&         oid,
                    const ProductId&   productId,
                    const ContractId&  contractId,
                    const UserId&      userId
        ) : oid_(oid), objVs_(0), productId_(productId),
            contractId_(contractId), userId_(userId)
        {
            // empty
        }

        PersProduct(const PersProduct& rhs);

        PersProduct& operator=(const PersProduct& rhs);

    public:


        inline const Oid& oid() const;
        inline long objVs() const;
        inline const ProductId& productId() const;
        inline const ContractId& contractId() const;
        inline const UserId& userId() const;
        inline const DateTime& created() const;
        inline const Status& effStatus() const;
        inline const DateTime& effStatusDate() const;
        inline const Status& prefStatus() const;
        inline const DateTime& prefStatusDate() const;
        inline const StatusChanges& statusChanges() const;
        inline const StatusRequests& statusRequests() const;
        inline const PersProductNodes& persNodes() const;
        inline const PersParts& persParts() const;

        const Product& getProduct() const;
        const StatusChanges& statusChanges(
            const ProductNode::Oid& pnId
        ) const;



        void setUserId(const UserId& userId);

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

        void readStatusChanges(
            const OSB_DB::Session& session,
            const Period&          period
        );

        void readStatusRequests(
            const OSB_DB::Session& session,
            const Period&          period
        );


        void updProductUser(OSB_DB::Session& session);



        const PersProductNode* findPersNode(
            const ProductNode::Oid& pnId
        ) const;

        PersProductNode* persNode(
            const ProductNode::Oid& pnId
        );

        const PersProductNode& getPersNode(
            const ProductNode::Oid& pnId
        ) const;

        bool addPersNode(
                  OSB_DB::Session&  session,
            const ProductNode::Oid& pnId
        );

        bool delPersNode(
                  OSB_DB::Session&  session,
            const ProductNode::Oid& oid
        );



        bool buildPersParts();

        const PersPart* findPersPart(
            const ProductNode::Oid& pnId
        ) const;

        PersPart* persPart(
            const ProductNode::Oid& pnId
        );

        const PersPart& getPersPart(
            const ProductNode::Oid& pnId
        ) const;

        void sortPersPartByName(bool desc = false);

        void sortPersPartByName(
            PersParts& persParts,
            bool       desc = false
        );

        PersCredit* getCredit(
            const DateTime& dt = DateTime::now()
        );

        Id<TariffSystem> getTariffSystem(
            const DateTime& dt = DateTime::now()
        ) const;

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



        bool requestStatus(
            const OSB_DB::Session& session,
                  StatusRequest&   request,
                  OsbErrors&       errors,
                  bool             noWait
        );

        bool subscribe(
                  OSB_DB::Session&  session,
            const ProductNode::Oid& nodeId
        );



        PersProductItem::Oid addPersItem(
                  OSB_DB::Session&         session,
                  PersProductItem::AutoPtr apPpi,
            const ProductNode::Oid&        pnId
        );

        bool delPersItem(
                  OSB_DB::Session&      session,
            const PersProductItem::Oid& ppiId,
            const ProductNode::Oid&     pnId
        );

        PersProductItem::Oid updPersItem(
                  OSB_DB::Session&  session,
                  PersProductItem&  ppi,
            const ProductNode::Oid& pnId
        );



        bool requestStatus(
            const OSB_DB::Session&  session,
            const ProductNode::Oid& pnId,
                  StatusRequest&    request,
                  OsbErrors&        errors,
                  bool              noWait
        );

    private:


        static void handleObjectStatus(
                  ObjectStatus      os,
            const PersProduct::Oid& id
        );

        static void lock(
            const OSB_DB::Session&  session,
            const PersProduct::Oid& id,
                  bool              noWait
        );

        void lock(
            const OSB_DB::Session& session,
                  bool             noWait
        ) const;

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

    private:


        OsbError setPrefStatus(
            const OSB_DB::Session& session,
            const StatusRequest&   request
        );

        bool changeStatus(
            const OSB_DB::Session& session,
                  StatusChange&    change,
                  OsbErrors&       errors
        );

        bool applyChange(
            const OSB_DB::Session& session,
            const StatusChange&    change,
                  OsbErrors&       errors
        );

        OsbError setPrefStatus(
            const OSB_DB::Session&  session,
            const ProductNode::Oid& pnId,
            const StatusRequest&    request
        );

        bool changeStatus(
            const OSB_DB::Session&  session,
            const ProductNode::Oid& pnId,
                  StatusChange&     change,
                  OsbErrors&        errors
        );

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

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

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

        void buildPersParts(
                  PersParts&        partList,
            const ProductNodeParts& parts,
                  bool              parentSubscribed
        );

        const StatusChanges* statusChanges(
            const ProductNode::Oid& pnId,
            const StatusChanges*    pParentChanges,
            const PersParts&        persParts
        ) const;

        const PersPart* findPersPart(
            const PersParts&        persParts,
            const ProductNode::Oid& oid
        ) const;

        void setPersPart(
            const ProductNode::Oid& pnId,
                  bool              add
        );

        bool parentNodeAvail(
            const Product&          product,
            const ProductNode::Oid& pnId
        ) const;

        bool childSubscribed(
            const Product&          product,
            const ProductNode::Oid& pnId
        ) const;

        bool delPpn(
            const OSB_DB::Session&  session,
            const ProductNode::Oid& oid
        );

        bool schTsInPersParts(
            const DateTime&         dt,
            const PersParts&        persParts,
                  Id<TariffSystem>& oid
        ) const;

    private:
        Oid oid_;
    public:

        long objVs_;
    private:
        ProductId productId_;
        ContractId contractId_;
        UserId userId_;

        DateTime created_;
        Status   prefStatus_;
        DateTime prefStatusDate_;

        Status effStatus_;
        DateTime effStatusDate_;

        StatusChanges chngs_;
        StatusRequests reqs_;

        PersProductNodes persNodes_;
        PersParts persParts_;

    private:
        void constructFrom(const PersProduct& rhs);

        void setNodePointers();
        void setNodePointers(PersParts& parts);
    };                                  // class PersProduct

    typedef std::list<PersProduct> PersProducts;


// ************************************************************************
// inline definitions

    // ********************************************************************
    // PersProduct
    inline const PersProduct::Oid& PersProduct::oid() const
    {
        return oid_;
    }

    inline long PersProduct::objVs() const
    {
        return objVs_;
    }

    inline const PersProduct::ProductId& PersProduct::productId() const
    {
        return productId_;
    }

    inline const PersProduct::ContractId& PersProduct::contractId() const
    {
        return contractId_;
    }

    inline const PersProduct::UserId& PersProduct::userId() const
    {
        return userId_;
    }

    inline const DateTime& PersProduct::created() const
    {
        return created_;
    }

    inline const Status& PersProduct::effStatus() const
    {
        return effStatus_;
    }

    inline const DateTime& PersProduct::effStatusDate() const
    {
        return effStatusDate_;
    }

    inline const Status& PersProduct::prefStatus() const
    {
        return prefStatus_;
    }

    inline const DateTime& PersProduct::prefStatusDate() const
    {
        return prefStatusDate_;
    }

    inline const StatusChanges& PersProduct::statusChanges() const
    {
        return chngs_;
    }

    inline const StatusRequests& PersProduct::statusRequests() const
    {
        return reqs_;
    }

    inline const PersProductNodes& PersProduct::persNodes() const
    {
        return persNodes_;
    }

    inline const PersParts& PersProduct::persParts() const
    {
        return persParts_;
    }

    // ********************************************************************
    // PersProductNode
    inline PersProduct::Oid
    PersProductNode::persProductId() const
    {
        return PersProduct::Oid(oid_.id1_);
    }

    inline ProductNode::Oid
    PersProductNode::productNodeId() const
    {
        return ProductNode::Oid(oid_.id2_);
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _PERSPRODUCT_H_

---