Group.h

/*
 Copyright © CloudBackend AB 2020-2023.
 */
#ifndef INCLUDE_CBE_GROUP_H_
#define INCLUDE_CBE_GROUP_H_
 
#include <string>
#include "cbe/util/Context.h"
#include "cbe/Member.h"
#include "cbe/Types.h"
 
#include "cbe/delegate/Error.h"
#include "cbe/delegate/CreateGroupDelegate.h"
#include "cbe/delegate/CreateRoleDelegate.h"
#include "cbe/delegate/LeaveDelegate.h"
#include "cbe/delegate/ListMembersDelegate.h"
#include "cbe/delegate/ListRolesDelegate.h"
#include "cbe/delegate/RemoveRoleDelegate.h"
 
#include "cbe/delegate/group/JoinDelegate.h"
#include "cbe/delegate/group/RemoveDelegate.h"
#include "cbe/delegate/group/RenameDelegate.h"
 
#include "cbe/delegate/Error.h"
#include "cbe/util/ErrorInfo.h"
#include "cbe/util/Exception.h"
#include "cbe/util/Optional.h"
 
namespace CBI {
class Group;
using GroupPtr = std::shared_ptr<CBI::Group>;
class GroupEventProtocol;
using GroupDelegatePtr = std::shared_ptr<GroupEventProtocol>;
} // namespace CBI
 
namespace cbe {
 
class Group {
public:
  std::string name() const;
 
  cbe::GroupId id() const;
 
  cbe::GroupId parentId() const;
 
  cbe::Container groupContainer() const;
 
  cbe::Visibility getVisibility() const;
 
  bool joined() const;
 
  using Requests = std::vector<cbe::Request>;
  Requests requests() const;
  using CreateGroupDelegatePtr = delegate::CreateGroupDelegatePtr;
  cbe::Group createGroup(std::string            name,
                         std::string            memberAlias,
                         cbe::Visibility        visibility, 
                         CreateGroupDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using CreateGroupException = delegate::CreateGroupDelegate::Exception;
  cbe::Group createGroup(
                           std::string            name,
                           std::string            memberAlias,
                           cbe::Visibility        visibility);
 
  using CreateGroupError = delegate::CreateGroupDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Group> createGroup(
                                            std::string            name,
                                            std::string            memberAlias,
                                            cbe::Visibility        visibility,
                                            CreateGroupError&  error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using JoinDelegatePtr = delegate::group::JoinDelegatePtr;
  void join(std::string           alias,
            cbe::Visibility       memberVisibility,
            std::string           applicationComment,
            JoinDelegatePtr       delegate);
 
#ifndef CBE_NO_SYNC
  using JoinException = delegate::group::JoinDelegate::Exception;
  cbe::Group join(
            std::string           alias,
            cbe::Visibility       memberVisibility,
            std::string           applicationComment);
 
  using JoinError = delegate::group::JoinDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Group> join(
            std::string           alias,
            cbe::Visibility       memberVisibility,
            std::string           applicationComment,
            JoinError&            error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using LeaveDelegatePtr = delegate::LeaveDelegatePtr;  
  void leave(LeaveDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using LeaveException = delegate::LeaveDelegate::Exception;
  delegate::LeaveSuccess leave();
 
  using LeaveError = delegate::LeaveDelegate::ErrorInfo;
  cbe::util::Optional<delegate::LeaveSuccess> leave(LeaveError&           error);
 
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using RemoveDelegatePtr = delegate::group::RemoveDelegatePtr;
  void remove(RemoveDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using RemoveException = delegate::group::RemoveDelegate::Exception;
  delegate::group::RemoveSuccess remove();
 
  using RemoveError = delegate::group::RemoveDelegate::ErrorInfo;
  cbe::util::Optional<delegate::group::RemoveSuccess> remove(RemoveError& error);
 
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using RenameDelegatePtr = delegate::group::RenameDelegatePtr;
  void rename(std::string newName, RenameDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using RenameException = delegate::group::RenameDelegate::Exception;
  delegate::group::RenameSuccess rename(std::string newName);
 
  using RenameError = delegate::group::RenameDelegate::ErrorInfo;
  cbe::util::Optional<delegate::group::RenameSuccess> rename(
                                              std::string newName, 
                                              RenameError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using ListMembersDelegatePtr = delegate::ListMembersDelegatePtr;
  void listMembers(ListMembersDelegatePtr delegate);
  
#ifndef CBE_NO_SYNC
  using ListMembersException = delegate::ListMembersDelegate::Exception;
  delegate::ListMembersDelegate::Members listMembers();
 
  using ListMembersError = delegate::ListMembersDelegate::ErrorInfo;
  cbe::util::Optional<delegate::ListMembersDelegate::Members> listMembers(
                                             ListMembersError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using ListBannedMembersDelegatePtr = delegate::ListMembersDelegatePtr;
  void listBannedMembers(ListBannedMembersDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using ListBannedMembersException = delegate::ListMembersDelegate::Exception;
  std::vector<cbe::Member> listBannedMembers();
 
  using ListBannedMembersError = delegate::ListMembersDelegate::ErrorInfo;
  cbe::util::Optional<std::vector<cbe::Member>> listBannedMembers(
                                                  ListBannedMembersError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using ListRolesDelegatePtr = delegate::ListRolesDelegatePtr;
  void listRoles(ListRolesDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using ListRolesException = delegate::ListRolesDelegate::Exception;
  delegate::ListRolesDelegate::Roles listRoles();
 
  using ListRolesError = delegate::ListRolesDelegate::ErrorInfo;
  cbe::util::Optional<delegate::ListRolesDelegate::Roles> listRoles(
                                              ListRolesError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using CreateRoleDelegatePtr = delegate::CreateRoleDelegatePtr;
  void createRole(std::string name, CreateRoleDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using CreateRoleException = delegate::CreateRoleDelegate::Exception;
  cbe::Role createRole(std::string name);
 
  using CreateRoleError = delegate::CreateRoleDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Role> createRole(std::string name,
                                            CreateRoleError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using RemoveRoleDelegatePtr = delegate::RemoveRoleDelegatePtr;
  void removeRole(RoleId roleId, RemoveRoleDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using RemoveRoleException = delegate::RemoveRoleDelegate::Exception;
  cbe::RoleId removeRole(RoleId roleId);
 
  using RemoveRoleError = delegate::RemoveRoleDelegate::ErrorInfo;
  cbe::util::Optional<cbe::RoleId> removeRole(RoleId roleId,
                                            RemoveRoleError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
  Group(cbe::DefaultCtor);
  ~Group();
 
  explicit operator bool() const;
 
private:
  struct Impl;
  std::shared_ptr<Impl> pImpl{};
  friend class GroupManager;
  friend class GroupQueryResult;
  Group(CBI::GroupPtr cbiPeerPtr);
  CBI::Group& getCbiPeer() const;
}; // class Group
 
} // namespace cbe
 
#endif  // INCLUDE_CBE_GROUP_H_