osbaccess.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.8 $

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

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

// + libraries

// + local headers
#include "osbid.h"
#include "osbconst.h"
#include "osbutils.h"

// + class declarations
namespace OSB_LIB {
    class UserGroup;
}

namespace OSB_DB {
    class GrpAccessGw;
    class ModAccessGw;
    class Session;
}

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

// ************************************************************************
// forward declarations

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

// ************************************************************************
// class definitions
    class ModAccess {
        friend class OSB_DB::ModAccessGw;
        friend class UserMgmtCfg;
    public:
        typedef Id<ModAccess> Oid;

    public:
        explicit ModAccess(const Oid& oid = Oid());
        ModAccess(
            const ModuleId module,
            const Oid&     parent  = Oid()
        );

    public:
        ModuleId module() const;
        const Oid& oid() const;
        const Oid& parentId() const;
        const std::string& tag() const;

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

        void setTag(
            const std::string& tag
        );

    private:                            // user management only
        void save(
            const OSB_DB::Session& session
        );

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

    private:
        ModuleId module_;
        Oid oid_;
        Oid parent_;
        std::string tag_;
    };                                  // class ModAccess

    class ModAccessMap {
        friend class OSB_DB::ModAccessGw;
        friend class UserMgmtCfg;
    public:
        typedef std::map<ModAccess::Oid, ModAccess> Entries;
    public:
        explicit ModAccessMap(
            const ModuleId module = mdUnknown
        );

    public:
        ModuleId module() const;

        const ModAccess* find(
            const ModAccess::Oid& maId
        ) const;

        const ModAccess& get(
            const ModAccess::Oid& maId
        ) const;

        void accessRights(
                  std::list<ModAccess>& dest,
            const ModAccess::Oid&       parId = ModAccess::Oid()
        ) const;

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

    private:                            // for UserMgmtCfg only
        void check(
            const ModAccess& access
        ) const;

        void insert(
            const ModAccess& access
        );

    private:
        ModuleId module_;
        Entries entries_;
    };                                  // class ModAccessMap

    class GrpAccess {
        friend class OSB_DB::GrpAccessGw;
        friend class UserMgmtCfg;
    public:
        typedef Id<GrpAccess> Oid;
        typedef Id<UserGroup> GrpId;
        typedef Id<ModAccess> MaId;

    public:
        explicit GrpAccess(
            const Oid& oid = Oid()
        );
        GrpAccess(
            const GrpId& grpId,
            const Oid&   parent = Oid()
        );
    public:
        const Oid& oid() const;
        const GrpId& grpId() const;
        const MaId& maId() const;
        const Oid& parentId() const;
        const std::string& tag() const;

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

        void setModAccess(
            const ModAccess& modAccess
        );

    private:                            // user management only
        void save(
            const OSB_DB::Session& session
        );

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

    private:
        Oid oid_;
        GrpId grpId_;
        MaId maId_;
        Oid parent_;
        std::string tag_;
    };                                  // class GrpAccess

    class GrpAccessMap {
        friend class OSB_DB::GrpAccessGw;
        friend class UserMgmtCfg;

    public:
        explicit GrpAccessMap(
            const Id<UserGroup> grpId
        );

    public:
        class Key {
        public:
            explicit Key(const GrpAccess& grpAccess);
            Key(
                const GrpAccess::Oid& parentId,
                const std::string&    accessTag
            );

        public:
            const GrpAccess::Oid& parentId() const;
            const std::string& accessTag() const;

            bool operator<(const Key& rhs) const;

        private:
            GrpAccess::Oid parent_;
            std::string accessTag_;
        };                              // class Key

        typedef std::map<Key, GrpAccess> Entries;

        typedef std::list<Key> Path;

    public:
        const Id<UserGroup>& grpId() const;
        const GrpAccess& get(
            const GrpAccess::Oid& gaId
        ) const;
        const GrpAccess& get(const Key& key) const;
        const GrpAccess* find(const Key& key) const;

        void accessRights(
                  std::list<GrpAccess>& dest,
            const GrpAccess::Oid&       parId = GrpAccess::Oid()
        ) const;

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



        bool allowed(
            const std::string& rootTag
        ) const;

    private:                        // UserGroup only


        void check(
            const GrpAccess& access
        ) const;

        void insert(
            GrpAccess& access
        );

    private:
        GrpAccess* find(const Key& key);
        GrpAccess* find(
            const GrpAccess::Oid& gaId
        );

    private:
        Id<UserGroup> grpId_;
        Entries entries_;
    };                                  // class GrpAccessMap
}                                       // namespace OSB_LIB

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

---