requesthandler.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.24 $

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

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

// + libraries

// + local headers
#include "osbid.h"
#include "statusrequest.h"

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

namespace OSB_LIB {
    class AnCList;
    class Associate;
    class Contract;
    class OsbErrors;
    class PersProduct;
    class PersProductNode;
    class ProductNode;
}

namespace {
    struct LockList;                    // in requesthandler.cc only
};

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

// ************************************************************************
// forward declarations
    struct RequestLinkInfo;
    struct RequestLinks;

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

// ************************************************************************
// class definitions
    class RequestHandler {
    public:
        enum Result {
            resOk       = 0,
            resProcessed,
            resSkipped,
            resError
        };

        // defined below
        class Tracker;

    public:
        explicit RequestHandler(
            AnCList* ancList = 0
        );

        ~RequestHandler();

    private:
        RequestHandler(const RequestHandler&);
        RequestHandler& operator=(const RequestHandler&);

    public:


        Result process(
            const OSB_DB::Session& session,
                  StatusRequest&   request,
                  OsbErrors&       errors,
                  Tracker*         tracker = 0
        );

        bool delRequest(
            const OSB_DB::Session&   session,
            const Id<StatusRequest>& srqId
        );

    private:                            // 1st level support for process
        Result lockRequest(
            const OSB_DB::Session& session,
                  StatusRequest&   request
        );

        Result checkEntities(
            const StatusRequest& request,
                  OsbErrors&     errors
        );
        Result setPrefStatus(
            const OSB_DB::Session& session,
                  StatusRequest&   request,
                  OsbErrors&       errors,
                  Tracker*         tracker
        );

        Result changeStatus(
            const OSB_DB::Session& session,
                  StatusRequest&   request,
                  OsbErrors&       errors,
                  Tracker*         tracker
        );

        void finalizeRequest(
            const OSB_DB::Session& session,
            const Result           result,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );

    private:                            // utils for 1st level functions
        Associate& lockAs(
            const OSB_DB::Session& session,
                  Id<Associate>    asId,
                  bool             lockParent
        );
        Contract& lockCo(
            const OSB_DB::Session& session,
                  Id<Contract>     coId,
                  bool             lockParent
        );
        PersProduct& lockPp(
            const OSB_DB::Session& session,
                  Id<PersProduct>  ppId,
                  bool             lockParent
        );

        Result setAsPrefStatus(
            const OSB_DB::Session& session,
                  Associate&       as,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );
        Result setCoPrefStatus(
            const OSB_DB::Session& session,
                  Contract&        co,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );
        Result setPpPrefStatus(
            const OSB_DB::Session& session,
                  PersProduct&     pp,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );
        Result setPpnPrefStatus(
            const OSB_DB::Session& session,
                  PersProduct&     pp,
            const Id<ProductNode>& pnId,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );

        bool changeAsStatus(
            const OSB_DB::Session& session,
                  Associate&       assoc,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );

        bool changeCoStatus(
            const OSB_DB::Session& session,
                  Contract&        co,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );

        bool changePpStatus(
            const OSB_DB::Session& session,
                  PersProduct&     pp,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );

        bool changePpnStatus(
            const OSB_DB::Session& session,
                  PersProduct&     pp,
            const Id<ProductNode>& pnId,
                  StatusRequest&   request,
                  OsbErrors&       errors
        );

    private:
        AnCList* ancList_;
        bool ownAncList_;
        RequestLinks* rqLinks_;
        LockList* locks_;
    };                                  // class RequestHandler

    struct RequestHandler::Tracker {
    public:
        enum Stage {
            setPref,
            chngStatus,
        };
    public:
        Tracker();
        virtual ~Tracker();
    protected:
        Tracker(const Tracker& rhs);
        Tracker& operator=(const Tracker& rhs);
    public:
        virtual void entityStart(
            const Stage            stage,
            const StatusRequest&   request,
            const RequestLinkInfo& info
        ) = 0;

        virtual void entityEnd(
            const Stage            stage,
            const StatusRequest&   request,
            const RequestLinkInfo& info,
                  Result           result
        ) = 0;
    };                                  // class RequestHandler::Tracker

    struct RequestLinkInfo {
        Id<Associate>        asId_;
        Id<Contract>         coId_;
        Id<PersProduct>      ppId_;
        Id2<PersProductNode> ppnId_;
        StatusRequest::Cascade cascade_;
    public:
        RequestLinkInfo();
        bool operator<(const RequestLinkInfo& rhs) const;
    };                                  // struct RequestLinkInfo

    struct RequestLinks {
        typedef std::set<RequestLinkInfo> Entries;
        typedef Entries::const_iterator ConstIter;

        ConstIter begin() const;
        ConstIter end() const;
        void clear();

        void addAs(
            const Id<Associate>&         asId,
                  StatusRequest::Cascade cscd
        );
        void addCo(
            const Id<Contract>&          coId,
                  StatusRequest::Cascade cscd
        );
        void addPp(
            const Id<PersProduct>&       ppId,
                  StatusRequest::Cascade cscd
        );
        void addPpn(
            const Id2<PersProductNode>&  ppnId,
                  StatusRequest::Cascade cscd
        );

        // Container with all entries.
        Entries entries_;
    };                                  // struct RequestLinks
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _REQUESTHANDLER_H_

---