associate.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)
             Lilian Qin Lan (lan)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.110 $

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

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

// + local headers
#include "address.h"
#include "osbid.h"
#include "status.h"
#include "statuschange.h"
#include "statusrequest.h"
#include "taxkey.h"
#include "account.h"

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

namespace OSB_LIB {
    class AnCList;
    class Contract;
    class OsbErrors;
}

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

    class Associate {
        friend class OSB_DB::AssociateGw;
        friend class AnCList;
        friend class RequestHandler;

    public:
        enum Type {
            atUnknown  = '\0',
            atCustomer = 'c'
        };

        typedef Id<Associate> Oid;
        typedef std::map<Oid, Type> ChildrenList;
        typedef Id<Contract> ContractId;
        typedef std::set<ContractId> ContractIds;

        typedef std::auto_ptr<Associate> AutoPtr;

    public:
        Associate(const Oid& id)
          : oid_(id), levelId_(0), pAncList_(0)
        {
        }

        virtual ~Associate();

    protected:
        // unfortunately this does not prevent assignments from within the
        // class: commented out
        // Copying for derived classes only.
        // Associate(const Associate& rhs);
        // Assignment for derived classes only.
        // Associate& operator=(const Associate& rhs);

    public:
        static char toChar(Type at);
        static Type type(char at);

    public:


        virtual Type typeId() const = 0;

        const Oid&            oid()            const;
        const std::string&    name()           const;
        const Oid&            parentId()       const;
        unsigned int          levelId()        const;
        const TaxKey::Oid&    taxkey()         const;
        const Account&        salesLedger()    const;
        const Account&        purchaseLedger() const;
        const std::string&    accountNo()      const;
        const Status&         effStatus()      const;
        const DateTime&       effStatusDate()  const;
        const Status&         prefStatus()     const;
        const DateTime&       prefStatusDate() const;
        long                  objVs()          const;
        const StatusChanges&  statusChanges()  const;
        const StatusRequests& statusRequests() const;
        const AddressList&    addressList()    const;
        const ChildrenList&   childrenList()   const;
        const ContractIds&    contractIds()    const;


        void setName(const std::string& name);
        void setTaxKey(const TaxKey::Oid& tkId);
        void setSalesLedger(const Account& sl);
        void setPurchaseLedger(const Account& pl);
        void setAccountNo(const std::string& accountNo);

        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 update(OSB_DB::Session& session);

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

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

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

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



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

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

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



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

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

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

        void addressListErase(AddressType type);

    public:


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



        bool addAddress(
                  OSB_DB::Session& session,
            const Address&         addr
        );

        bool updAddress(
                  OSB_DB::Session& session,
            const Address&         addr
        );

        bool delAddress(
            OSB_DB::Session& session,
            AddressType      type,
            OsbErrors&       errors
        );

        bool linkAddressType(
            OSB_DB::Session& session,
            AddressType      type,
            AddressType      newType
        );

        bool unlinkAddressType(
            OSB_DB::Session& session,
            AddressType      type
        );

        const Address* findAddress(AddressType at) const;

        Address* address(AddressType at);

        const Address& getAddress(AddressType at) const;



        void addChild(
            OSB_DB::Session& session,
            Associate&       child
        );

        void delChild(
            OSB_DB::Session& session,
            Associate&       child
        );

        AutoPtr clone() const;

        template<typename A> A* isa(A*& ptr);
        template<typename A> const A* isa(const A*& ptr) const;

    private:
        virtual Associate* clone_() const = 0;



        bool addContract(
            const OSB_DB::Session& session,
            const ContractId&      coId
        );

        void delContract(
            const OSB_DB::Session& session,
            const ContractId&      coId
        );

        void getChildEffStatus(
            const OSB_DB::Session& session,
                  StatusChanges&   dest
        );

    protected:
        Oid oid_;
        std::string name_;
        Oid parentId_;
        unsigned int levelId_;
        Account salesLedger_;
        Account purchaseLedger_;
        std::string accountNo_;
        TaxKey::Oid taxkey_;
        Status effStatus_;
        DateTime effStatusDate_;
        Status prefStatus_;
        DateTime prefStatusDate_;
        long objVs_;
        StatusChanges chngs_;
        StatusRequests reqs_;
        AddressList addressList_;
        ChildrenList childrenList_;
        ContractIds contractIds_;
        AnCList* pAncList_;
    };                                  // class Associate

    class Customer : public Associate {
        static const Type typeId_ = atCustomer;
    public:
        // Documentation from base class.
        typedef std::auto_ptr<Customer> AutoPtr;

        Customer(const Oid& id) : Associate(id) {}

        // Documentation from base class.
        AutoPtr clone() const;

    private:
        // Documentation from base class.
        virtual Associate* clone_() const;
        virtual Type typeId() const { return typeId_; }
    };


    // *****************************************************************
    // AssociateFactory
    class AssociateFactory {
    public:
        static Associate::AutoPtr create(
                  Associate::Type  type,
            const Associate::Oid&  oid
        );

    private:
        AssociateFactory();
        AssociateFactory(const AssociateFactory& rhs);
    };
}                                       // namespace OSB_LIB

// ************************************************************************
// template and inline definitions
namespace OSB_LIB {

    // *****************************************************************
    // Associate
    template<typename A>
    inline A* Associate::isa(A*& ptr)
    {
        ptr = dynamic_cast<A*>(this);
        return ptr;
    }

    template<typename A>
    inline const A* Associate::isa(const A*& ptr) const
    {
        ptr = dynamic_cast<const A*>(this);
        return ptr;
    }

    inline const Associate::Oid& Associate::oid() const
    {
        return oid_;
    }

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

    inline const Associate::Oid& Associate::parentId() const
    {
        return parentId_;
    }

    inline unsigned int Associate::levelId() const
    {
        return levelId_;
    }

    inline const TaxKey::Oid& Associate::taxkey() const
    {
        return taxkey_;
    }

    inline const Account& Associate::salesLedger() const
    {
        return salesLedger_;
    }

    inline const Account& Associate::purchaseLedger() const
    {
        return purchaseLedger_;
    }

    inline const std::string& Associate::accountNo() const
    {
        return accountNo_;
    }

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

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

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

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

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

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

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

    inline const AddressList& Associate::addressList() const
    {
        return addressList_;
    }

    inline const Associate::ChildrenList& Associate::childrenList() const
    {
        return childrenList_;
    }

    inline const Associate::ContractIds& Associate::contractIds() const
    {
        return contractIds_;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _ASSOCIATE_H_

---