tariffcatalogue.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.216.2.1 $

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

// ************************************************************************
// included header files
// + standard includes

// + local headers
#include "osberror.h"
#include "chrono.h"
#include "tariffperiod-gw.h"
#include "serviceclass.h"
#include "tariffsystem.h"
#include "tariff.h"
#include "nwaddress.h"
#include "cpmapper.h"
#include "tcdist.h"
#include "cgi.h"
#include "e164.h"
#include "e164map.h"
#include "roundrule.h"
#include "ratedservice.h"

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

namespace OSB_LIB {
    class ConnectionPt;
    class CpTree;
    class SeTree;
    class TcatLockManager;
    class TcatReadMonitor;
    class UsageTypeList;
}

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

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

    enum LockObjects {
        lckTs = 10,

        lckSc = 20,

        lckTcs = 30,

        lckTp = 40,

        lckTf = 50
    };

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

    // ********************************************************************
    // TariffCatalogue
    class TariffCatalogue {
        friend class TcatLockManager;

    public:
        TariffCatalogue();
        ~TariffCatalogue();

    private:

        TariffCatalogue(const TariffCatalogue& rhs);
        TariffCatalogue& operator=(const TariffCatalogue& rhs);

        TcatLockManager* tcatlm_;

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

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

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

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

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

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

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

        void sortTsLists();

        void sortScLists();

        void sortTcsLists();

        void sortTpsLists();

        void sortTfLists();

    public:
        void setLock(TcatLockManager& tcatlm)
        {
            tcatlm_ = &tcatlm;
        };

        void read(
            OSB_DB::Session& session,
            bool             noWait   = false,
            TcatReadMonitor* monitor  = 0
        );

        std::ostream& tariffInfo(std::ostream&);

        size_t info(std::string& st);

        // ***************
        // Grace Period
        long gracePeriod() const { return gracePeriod_; }

        const UsageTypeList& usageTypeList() const;



        bool creSpecialDate(
            OSB_DB::Session& session,
            SpecialDate&     sd,
            bool             noWait
        );

        void delSpecialDate(
                  OSB_DB::Session&  session,
            const SpecialDate::Oid& sdId,
                  bool              noWait
        );

        OsbError updSpecialDate(
            OSB_DB::Session& session,
            SpecialDate&     sd,
            bool             noWait
        );

        SpecialDate* specialDate(
            const SpecialDate::Oid& sdId
        );

        const SpecialDate* findSpecialDate(
            const SpecialDate::Oid& sdId
        ) const;

        const SpecialDate* searchActiveSpecialDate(
            const Date& date
        ) const;

        const SpecialDate& getSpecialDate(
            const SpecialDate::Oid& sdId
        ) const;

        const SpecialDates& specialDates() const { return specialDates_; }

        bool changeSdStatus(
                  OSB_DB::Session&  session,
            const SpecialDate::Oid& sdId,
                  CfgStatus         reqStatus,
                  OsbErrors&        errors,
            const bool              noWait
        );

    private:
        bool changeSdStatus(
            OSB_DB::Session& session,
            SpecialDate&     sd,
            CfgStatus        reqStatus,
            OsbErrors&       errors,
            bool             noWait
        );

    public:
        void sortSpecialDates();

        // ***************
        // Day Class


        DayClass* dayClass(const DayClass::Oid& oid);

        const DayClass* findDayClass(const DayClass::Oid& dcId) const;

        const DayClass& getDayClass(const DayClass::Oid& oid) const;

        const DayClass* getDayClass(
            const DayClass::Oid& oid,
            const Weekday&       weekday
        ) const;

        DayClass::Oid creDayClass(
            OSB_DB::Session& session,
            DayClass&        dc,
            bool             noWait
        );

        void delDayClass(
            OSB_DB::Session& session,
            DayClass::Oid&   oid,
            bool             noWait
        );

        OsbError updDayClass(
            OSB_DB::Session& session,
            DayClass&        dc,
            bool             noWait
        );

        const DayClasses& dayClasses() const { return dayClasses_; }

        bool changeDcStatus(
                  OSB_DB::Session& session,
            const DayClass::Oid&   dcId,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

    public:
        void sortDayClasses();

        // ***************
        // Tariff Period


        TariffPeriod* tariffPeriod(const TariffPeriod::Oid& oid);

        const TariffPeriod* findTariffPeriod(
            const TariffPeriod::Oid& oid
        ) const;

        const TariffPeriod& getTariffPeriod(
            const TariffPeriod::Oid& oid
        ) const;

        TariffPeriod::Oid creTariffPeriod(
            OSB_DB::Session& session,
            TariffPeriod&    tp,
            bool             noWait
        );

        OsbError updTariffPeriod(
            OSB_DB::Session& session,
            TariffPeriod&    tp,
            bool             noWait
        );

        void delTariffPeriod(
                  OSB_DB::Session&   session,
            const TariffPeriod::Oid& oid,
                  bool               noWait
        );

        const TariffPeriod::Oid& getTariffPeriod(
            const DayClass::Oid& dcId,
            const Time&          time
        );

        TariffPeriods& tariffPeriods() { return tariffPeriods_; }

        void sortTariffPeriods();

        // ****************************
        // Tariff Period System Version


        const TpsVersions& tpsVersions() const { return tpsVersions_; }

        const TpsVersion* searchTpsVersion(
            const TpSystem::Oid& oid,
            const DateTime&      ts
        ) const;

        const TpsVersion* findTpsVersion(
            const TpsVersion::Oid& oid
        ) const;

        const TpsVersion& getTpsVersion(const TpsVersion::Oid& oid);

        const TpsVersion& getReleasedTpsVersion(
            const TpSystem::Oid& tpsOid,
            const DateTime&      startDateTime
        )const ;

        TpsVersion* tpsVersion (const TpsVersion::Oid& oid);

        TpsVersion::Oid creTpsVersion (
            OSB_DB::Session& session,
            TpsVersion&      tpsVs,
            bool             noWait
        );

        void delTpsVersion (
                  OSB_DB::Session& session,
            const TpsVersion::Oid& oid,
                  bool             noWait
        );

        OsbError updTpsVersion (
            OSB_DB::Session& session,
            TpsVersion&      tpsVs,
            bool             noWait
        );

        bool changeTpsVsStatus(
                  OSB_DB::Session& session,
            const TpsVersion::Oid& tpsVsId,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        void sortTpsVersions();

        // ********************
        // Tariff Period System


        TpSystems& tpSystems() { return tpSystems_; }

        TpSystem::Oid creTpSystem(
            OSB_DB::Session& session,
            TpSystem&        tps,
            bool             noWait
        );

        OsbError updTpSystem(
            OSB_DB::Session& session,
            TpSystem&        tps,
            bool             noWait
        );

        TpSystem* tpSystem(const TpSystem::Oid& oid);

        const TpSystem* findTpSystem(const TpSystem::Oid& oid) const;

        const TpSystem& getTpSystem(const TpSystem::Oid& oid) const;

        void delTpSystem(
                  OSB_DB::Session& session,
            const TpSystem::Oid&   oid,
                  bool             noWait
        );

        void sortTpSystems();

        // *************
        // ConnectionPt

    private:
        ConnectionPt* connectionPt(const Id<ConnectionPt>& oid);

    public:
        const ConnectionPt* findConnectionPt(
            const Id<ConnectionPt>& oid
        ) const;

        const ConnectionPt& getConnectionPt(
            const Id<ConnectionPt>& oid
        ) const;

        Id<ConnectionPt> creConnectionPt(
            OSB_DB::Session& session,
            ConnectionPt&    cp,
            bool             noWait
        );

        void delConnectionPt(
            OSB_DB::Session&   session,
            Id<ConnectionPt>&  oid,
            bool               noWait
        );

        OsbError updConnectionPt(
            OSB_DB::Session& session,
            ConnectionPt&    cp,
            bool             noWait
        );

        const CpTree& cpTree() const;

        const CpMapperList&
        cpMapperList() const { return cpMapperList_; }

        bool changeCpStatus(
                  OSB_DB::Session&  session,
            const Id<ConnectionPt>& cpId,
                  CfgStatus         reqStatus,
                  OsbErrors&        errors,
            const bool              noWait
        );

        // ***********
        // CGI


        Cgi* cgi(const Cgi::Oid& oid);

        const Cgi* findCgi(const Cgi::Oid& oid) const;

        const Cgi& getCgi(const Cgi::Oid& oid) const;

        Cgi::Oid creCgi(
                  OSB_DB::Session&  session,
            const Id<ConnectionPt>& cpId,
            const std::string&      name,
            const std::string&      val,
                  bool              noWait
        );

        void delCgi(
            OSB_DB::Session& session,
            Cgi::Oid&        oid,
            bool             noWait
        );

        OsbError updCgi(
            OSB_DB::Session& session,
            Cgi&             cgi,
            bool             noWait
        );

        size_t checkCgi(
                  OSB_DB::Session& session,
            const Cgi::Oid&        oid,
                  OsbErrors&       errors,
            const bool             noWait
        );

        size_t unfreezeCgi(
                  OSB_DB::Session& session,
            const Cgi::Oid&        oid,
                  OsbErrors&       errors,
            const bool             noWait
        );

        size_t releaseCgi(
                  OSB_DB::Session& session,
            const Cgi::Oid&        oid,
                  OsbErrors&       errors,
            const bool             noWait
        );

        size_t revokeCgi(
                  OSB_DB::Session& session,
            const Cgi::Oid&        oid,
                  OsbErrors&       errors,
            const bool             noWait
        );

        bool cgiTzConfigEditable(const Cgi::Oid& oid);

        const Cgis& cgis() const { return cgis_; }

        void sortCgis();

        const CgiMap& cgiMap() const;

        // ***********
        // E164


        E164* e164(const E164::Oid& oid);

        const E164* findE164(const E164::Oid& oid) const;

        const E164& getE164(const E164::Oid& oid) const;

        E164::Oid creE164(
            OSB_DB::Session& session,
            E164&            e164,
            bool             noWait
        );

        void delE164(
            OSB_DB::Session& session,
            E164::Oid&       oid,
            bool             noWait
        );

        OsbError updE164(
            OSB_DB::Session& session,
            E164&            e164,
            bool             noWait
        );

        bool changeE164Status(
                  OSB_DB::Session& session,
            const E164::Oid&       e164Id,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        bool e164TzConfigEditable(const E164::Oid& oid);

        const E164s& e164s() const { return e164s_; }

        void sortE164s();

        const E164Map& e164Map() const;

        // *******************
        // TariffClass


        TariffClass* tariffClass(const TariffClass::Oid& oid);

        const TariffClass* findTariffClass(
            const TariffClass::Oid& oid
        ) const;

        const TariffClass& getTariffClass(
            const TariffClass::Oid& oid
        ) const;

        TariffClass::Oid creTariffClass(
            OSB_DB::Session& session,
            TariffClass&     tc,
            bool             noWait
        );

        void delTariffClass(
            OSB_DB::Session&  session,
            TariffClass::Oid& oid,
            bool              noWait
        );

        OsbError updTariffClass(
            OSB_DB::Session& session,
            TariffClass&     tc,
            bool             noWait
        );

        const TariffClasses& tariffClasses() const
        {
            return tariffClasses_;
        }

        void sortTariffClasses();

        // *******************
        // TariffZone


        TariffZone* tariffZone(const TariffZone::Oid& oid);

        const TariffZone* findTariffZone(
            const TariffZone::Oid& oid
        ) const;

        const TariffZone& getTariffZone(
            const TariffZone::Oid& oid
        ) const;

        TariffZone::Oid creTariffZone(
            OSB_DB::Session& session,
            TariffZone&      tz,
            bool             noWait
        );

        void delTariffZone(
            OSB_DB::Session& session,
            TariffZone::Oid& oid,
            bool             force,
            bool             noWait
        );

        OsbError updTariffZone(
            OSB_DB::Session& session,
            TariffZone&      tz,
            bool             noWait
        );

        bool isTzInConfig(const TariffZone::Oid& oid);

        const TariffZones& tariffZones() const
        {
            return tariffZones_;
        }

        void sortTariffZones();

        // ****************************
        // Tariff Classification System


        TcSystem* tcSystem(const TcSystem::Oid& oid);

        const TcSystem* findTcSystem(const TcSystem::Oid& oid) const;

        const TcSystem& getTcSystem(const TcSystem::Oid& oid) const;

        TcSystem::Oid creTcSystem(
            OSB_DB::Session& session,
            TcSystem&        tcs,
            bool             noWait
        );

        void delTcSystem(
            OSB_DB::Session& session,
            TcSystem::Oid&   oid,
            bool             noWait
        );

        OsbError updTcSystem(
            OSB_DB::Session& session,
            TcSystem&        tcs,
            bool             noWait
        );

        const TcSystems& tcSystems() const
        {
            return tcSystems_;
        }

        void sortTcSystems();

        // *************************
        // Tariff Zone Configuration


        const TzConfigs getTzConfigs(const TariffZone::Oid& oid) const;

        TzConfig* tzConfig(const TzConfig::Oid& oid);

        const TzConfig* findTzConfig(const TzConfig::Oid& oid) const;

        const TzConfig& getTzConfig(const TzConfig::Oid& oid) const;

        bool creTzConfig(
            OSB_DB::Session& session,
            TzConfig&        tzCfg,
            bool             noWait
        );

        void delTzConfig(
                  OSB_DB::Session& session,
            const TzConfig::Oid&   oid,
            bool                   noWait
        );

        OsbError updTzConfig(
            OSB_DB::Session& session,
            TzConfig&        tzcfg,
            bool             noWait
        );

        const TzConfigs& tzConfigs() const
        {
            return tzConfigs_;
        }

        bool changeTzCfgStatus(
                  OSB_DB::Session& session,
            const TzConfig::Oid&   tzConfigId,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        void sortTzCfgByStartDate();

        // ***************************************
        // Tariff system


        TariffSystem* tariffSystem(const TariffSystem::Oid& oid);

        const TariffSystem* findTariffSystem(
            const TariffSystem::Oid& oid
        ) const;

        const TariffSystem& getTariffSystem(
            const TariffSystem::Oid& oid
        ) const;

        TariffSystem::Oid creTariffSystem(
            OSB_DB::Session& session,
            TariffSystem&    ts,
            bool             noWait
        );

        void delTariffSystem(
            OSB_DB::Session&   session,
            TariffSystem::Oid& oid,
            bool               noWait
        );

        OsbError updTariffSystem(
            OSB_DB::Session& session,
            TariffSystem&    ts,
            bool             noWait
        );

        const TariffSystems&
            tariffSystems() const { return tariffSystems_; }

        void sortTariffSystems();

        // **********************
        // Tariff System Version


        TsVersion* tsVersion(const TsVersion::Oid& oid);

        const TsVersion* findTsVersion(const TsVersion::Oid& oid) const;

        const TsVersion& getTsVersion(const TsVersion::Oid& oid) const;

        const TsVersion& getReleasedTsVersion(
            const TariffSystem::Oid& tsId,
            const DateTime&          startDt
        ) const;

        TsVersion::Oid creTsVersion(
            OSB_DB::Session& session,
            TsVersion&       tsVs,
            bool             noWait
        );

        void delTsVersion(
                  OSB_DB::Session& session,
            const TsVersion::Oid   oid,
                  bool             noWait
        );

        OsbError updTsVersion(
            OSB_DB::Session& session,
            TsVersion&       tsv,
            bool             noWait
        );

        const TsVersions& tsVersions() const
        {
            return tsVersions_;
        }

        bool changeTsVsStatus(
                  OSB_DB::Session& session,
            const TsVersion::Oid&  tsVsId,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        void sortTsVersions();

        void sortScOfTsVersion(
            const ServiceClass::Oid& oid
        );

        void sortTcOfTsVersion(
            const TariffClass::Oid& oid
        );

        // ***************
        // Service Class

    private:
        ServiceClass* serviceClass(const ServiceClass::Oid& oid);

    public:
        const ServiceClass*
        findServiceClass(const ServiceClass::Oid& oid) const;

        const ServiceClass&
        getServiceClass(const ServiceClass::Oid& oid) const;

        ServiceClass::Oid creServiceClass(
                  OSB_DB::Session& session,
                  ServiceClass&    sc,
            const bool             noWait
        );

        OsbError updServiceClass(
                  OSB_DB::Session& session,
                  ServiceClass&    sc,
            const bool             noWait);

        void delServiceClass(
                  OSB_DB::Session&   session,
            const ServiceClass::Oid& oid,
            const bool               noWait
        );

        const ServiceClasses& serviceClasses()
        {
            return serviceClasses_;
        }

        void sortServiceClasses();

        // *********************
        // Service Class System

    private:
        ScSystem* scSystem(const ScSystem::Oid& oid);

    public:
        const ScSystem* findScSystem(const ScSystem::Oid& oid) const;

        const ScSystem& getScSystem(const ScSystem::Oid& oid) const;

        ScSystem::Oid creScSystem(
                  OSB_DB::Session& session,
                  ScSystem&        scs,
            const bool             noWait
        );

        OsbError updScSystem(
                  OSB_DB::Session& session,
                  ScSystem&        scs,
            const bool             noWait
        );

        void delScSystem(
                  OSB_DB::Session& session,
            const ScSystem::Oid&   oid,
            const bool             noWait
        );

        const ScSystems& scSystems() const { return scSystems_; }

        void sortScSystems();

        // *****************************
        // Service Class System Version

    private:
        ScsVersion* scsVersion(const ScsVersion::Oid& oid);

    public:
        const ScsVersion* findScsVersion(const ScsVersion::Oid& oid) const;

        const ScsVersion& getScsVersion(const ScsVersion::Oid& oid) const;

        const ScsVersion& getReleasedScsVersion(
            const ScSystem::Oid& oid,
            const DateTime&      startDateTime
        ) const ;

        ScsVersion::Oid creScsVersion(
            OSB_DB::Session& session,
            ScsVersion&      scsVs,
            bool             noWait
        );

        OsbError updScsVersion(
                  OSB_DB::Session& session,
                  ScsVersion&      scsVs,
            const bool             noWait
        );

        void delScsVersion(
                  OSB_DB::Session& session,
            const ScsVersion::Oid& oid,
            const bool             noWait
        );

        const ScsVersions& scsVersions() const { return scsVersions_; }

        bool changeScsVsStatus(
                  OSB_DB::Session& session,
            const ScsVersion::Oid& scsVs,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        void sortScsVersions();

        // ************
        // TcsVersion

    private:
        TcsVersion* tcsVersion(const TcsVersion::Oid& oid);

    public:
        const TcsVersion* findTcsVersion(
            const TcsVersion::Oid& oid
        ) const;

        const TcsVersion& getTcsVersion(
            const TcsVersion::Oid& oid
        ) const;

        const TcsVersion* findReleasedTcsVersion(
            const TcSystem::Oid& tcsId,
            const DateTime&      ts
        ) const;

        const TcsVersion& getReleasedTcsVersion(
            const TcSystem::Oid& tcsId,
            const DateTime&      ts
        ) const;

        TcsVersion::Oid creTcsVersion(
                  OSB_DB::Session& session,
                  TcsVersion&      tcsVs,
            const bool             noWait
        );

        OsbError updTcsVersion(
                  OSB_DB::Session& session,
                  TcsVersion&      tcsVs,
            const bool             noWait
        );

        void delTcsVersion(
                  OSB_DB::Session& session,
            const TcsVersion::Oid& oid,
            const bool             noWait
        );

        const TcsVersions& tcsVersions() const;

        bool changeTcsVsStatus(
                  OSB_DB::Session& session,
            const TcsVersion::Oid& tcsVsId,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        void sortTcsVersions();

        void sortCfgOfTcsVersion(
            const TariffZone::Oid& oid
        );

        // ************
        // Tariff

    private:
        Tariff* tariff(const Tariff::Oid& oid);

    public:
        const Tariff* findTariff(const Tariff::Oid& oid) const;

        const Tariff& getTariff(const Tariff::Oid& oid) const;

        bool isTariffUsed(const Tariff::Oid& oid);

        Tariff::Oid creTariff(
            OSB_DB::Session& session,
            Tariff&          tf,
            bool             noWait
        );

        OsbError updTariff(
            OSB_DB::Session& session,
            Tariff&          tf,
            bool             noWait
        );

        void delTariff(
                  OSB_DB::Session& session,
            const Tariff::Oid&     oid,
            const bool             noWait
        );

        Tariffs& tariffs() { return tariffs_; }

        void sortTariffs();

        // ****************
        // Tariff Version

    private:
        TfVersion* tfVersion(const TfVersion::Oid& oid);

    public:
        const TfVersion* findTfVersion(const TfVersion::Oid& oid) const;

        const TfVersion& getTfVersion(const TfVersion::Oid& oid) const;

        const TfVersion& getReleasedTfVersion(
            const Tariff::Oid& tf,
            const DateTime&    ts
        ) const;

        TfVersion::Oid creTfVersion(
                  OSB_DB::Session& session,
                  TfVersion&       tfVs,
            const bool             noWait
        );

        bool patchTfVersion(
                  OSB_DB::Session&       session,
            const TfVersion::Oid&        oid,
            const TfVersion::Oid&        replacing,
                  std::vector<OsbError>& err,
            const bool                   noWait);

        OsbError updTfVersion(
                  OSB_DB::Session& session,
                  TfVersion&       tfVs,
            const bool             noWait
        );

        void delTfVersion(
                  OSB_DB::Session& session,
            const TfVersion::Oid&  oid,
                  bool             noWait
        );

        const TfVersions& tfVersions() const;

        bool changeTfVsStatus(
                  OSB_DB::Session& session,
            const TfVersion::Oid&  tfVsId,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        bool canRevokeTfVersion(
                  OSB_DB::Session& session,
            const TfVersion::Oid&  oid
        );
        void sortTfVersions();

    private:
        bool changeToCfgStatus(
            OSB_DB::Session& session,
            ToCfgBase&       toCfg,
            CfgStatus        reqStatus,
            OsbErrors&       errors
        );

        // ****************
        // Rating function

    public:
        RatingFn* ratingFn(const RatingFn::Oid& oid) const;

        const RatingFn* findRatingFn(const RatingFn::Oid& oid) const;

        const RatingFn& getRatingFn(const RatingFn::Oid& oid) const;

        bool creRatingFn(
                  OSB_DB::Session& session,
                  RatingFn&        rf,
            const bool             noWait
        );

        OsbError updRatingFn(
                  OSB_DB::Session& session,
                  RatingFn&        rf,
            const bool             noWait
        );

        void delRatingFn(
                  OSB_DB::Session& session,
            const RatingFn::Oid&   oid,
            const bool             noWait
        );

        const RatingFns& ratingFns();

        bool changeRfStatus(
                  OSB_DB::Session& session,
            const RatingFn::Oid&   rfId,
                  CfgStatus        reqStatus,
                  OsbErrors&       errors,
            const bool             noWait
        );

        void sortRatingFns();

    public:
        // ****************
        // Service Element


        const SeTree& seTree() const;

        const ServiceElement*
        findServiceElement(const ServiceElement::Oid& seId) const;

        const ServiceElement* findServiceElement(
            const ServiceElement& se
        ) const;

        const ServiceElement&
        getServiceElement(const ServiceElement::Oid& seId) const;

        // **************
        // Rated services

    private:
        RatedServices::iterator
        ratedService(const RatedService::Oid& oid);

    public:
        const RatedService*
        findRatedService(const RatedService::Oid& oid) const;

        const RatedService&
        getRatedService(const RatedService::Oid& oid) const;

        const RatedServices& ratedServices() const;

        RatedService::Oid findRatedService(const ServiceTuple& st) const;

        RatedService::Oid creRatedService(
            OSB_DB::Session& session,
            RatedService&    service,
            bool             noWait
        );

        void updRatedService(
            OSB_DB::Session& session,
            RatedService&    service,
            bool             noWait
        );

        /*
          @brief Delete a rated service.

          @param session Database session.
          @param rsId    Object id of rated service to delete.
          @param noWait  Wait if locked by another session?
         */
        void delRatedService(
                  OSB_DB::Session&   session,
            const RatedService::Oid& rsId,
                  bool               noWait
        );

        bool changeRsStatus(
                  OSB_DB::Session&   session,
            const RatedService::Oid& rsId,
                  CfgStatus          reqStatus,
                  OsbErrors&         errors,
            const bool               noWait
        );

    private:
        long gracePeriod_;
        UsageTypeList* usageTypeList_;



        SpecialDates specialDates_;
        DayClasses dayClasses_;
        TariffPeriods tariffPeriods_;
        TpSystems tpSystems_;
        TpsVersions tpsVersions_;



        Cgis             cgis_;
        mutable CgiMap   cgiMap_;

        E164s            e164s_;
        mutable E164Map* e164Map_;

        TariffClasses    tariffClasses_;
        TariffZones      tariffZones_;
        TcSystems        tcSystems_;
        TcsVersions      tcsVersions_;
        TzConfigs        tzConfigs_;
        CpTree*          cpTree_;
        CpMapperList cpMapperList_;


        TariffSystems tariffSystems_; 
        TsVersions    tsVersions_;    




        ServiceClasses serviceClasses_;
        ScSystems scSystems_;
        ScsVersions    scsVersions_;



        Tariffs        tariffs_;
        TfVersions     tfVersions_;
        RatingFns      ratingFns_;



        SeTree* seTree_;

        RatedServices ratedServices_;

        /* NOTICE:
         *         If there is an additional master list here, please
         *         also add it to "long info(string& st)" function.
         */

    };                                  // class TariffCatalogue
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _TARIFFCATALOGUE_H_

---