Member.h

/*
     Copyright © CloudBackend AB 2023.
*/
 
#ifndef CBE_MEMBER_H
#define CBE_MEMBER_H
 
#include "cbe/Types.h"
 
#include "cbe/delegate/KickDelegate.h"
#include "cbe/delegate/BanDelegate.h"
#include "cbe/delegate/UnBanDelegate.h"
 
#include "cbe/delegate/Error.h"
#include "cbe/util/ErrorInfo.h"
#include "cbe/util/Exception.h"
#include "cbe/util/Optional.h"
namespace CBI {
class Member;
using MemberPtr = std::shared_ptr<CBI::Member>;
class GroupEventProtocol;
using GroupDelegatePtr = std::shared_ptr<GroupEventProtocol>;
} // namespace CBI
 
namespace cbe {
 
struct Request {
  cbe::UserId userId{};
  std::string alias{};
  std::string applicationComment{};
  cbe::Date   date{};
 
  Request(cbe::UserId userId, std::string alias, std::string applicationComment,
          cbe::Date date)
      : userId{userId}, alias{std::move(alias)},
        applicationComment{std::move(applicationComment)}, date{date} {}
};
 
class Member {
public:
  using KickDelegatePtr = delegate::KickDelegatePtr;
  void kick(std::string kickComment, KickDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using KickException = delegate::KickDelegate::Exception;
  delegate::KickSuccess kick(
                           std::string kickComment);
 
  using KickError = delegate::KickDelegate::ErrorInfo;
  cbe::util::Optional<delegate::KickSuccess> kick(
                                              std::string kickComment,
                                              KickError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
  using BanDelegatePtr = delegate::BanDelegatePtr;
  void ban(std::string banComment, BanDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using BanException = delegate::BanDelegate::Exception;
  delegate::BanSuccess ban(std::string banComment);
 
  using BanError = delegate::BanDelegate::ErrorInfo;
  cbe::util::Optional<delegate::BanSuccess> ban(std::string         banComment,
                                                BanError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
  using UnBanDelegatePtr = delegate::UnBanDelegatePtr;
  void unBan(UnBanDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using UnBanException = delegate::UnBanDelegate::Exception;
  delegate::UnBanSuccess unBan();
 
  using UnBanError = delegate::UnBanDelegate::ErrorInfo;
  cbe::util::Optional<delegate::UnBanSuccess> unBan(UnBanError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
  cbe::MemberId memberId() const;
 
  std::string name() const;
 
  cbe::Visibility visibility() const;
 
  cbe::GroupId    groupId() const;
 
  cbe::MemberBanInfo getMemberBanInfo();
 
  Member(cbe::DefaultCtor);
  ~Member();
 
  explicit operator bool() const;
private:
  struct Impl;
 
  std::shared_ptr<Impl> pImpl{};
 
  friend class Group;
  friend class Role;
  Member(CBI::MemberPtr cbiPeerPtr);
  CBI::Member& getCbiPeer() const;
}; // class Member
 
} // namespace cbe
 
#endif //CBE_MEMBER_H