158 lines
8.3 KiB
C++
158 lines
8.3 KiB
C++
#pragma once
|
|
|
|
#include "Variable.h"
|
|
#include <string>
|
|
#include <utility>
|
|
#include <query/Command.h>
|
|
#include <BasicChannel.h>
|
|
#include <Error.h>
|
|
#include <netinet/in.h>
|
|
#include "../TSServer.h"
|
|
#include "../Group.h"
|
|
|
|
#define DEBUG_PERMISSION
|
|
|
|
namespace ts {
|
|
namespace music {
|
|
class MusicBotManager;
|
|
}
|
|
namespace server {
|
|
class TSServer;
|
|
|
|
class DataClient {
|
|
friend class TSServer;
|
|
friend class QueryServer;
|
|
friend class music::MusicBotManager;
|
|
public:
|
|
struct PropertyWrapper {
|
|
std::shared_ptr<Properties> handle;
|
|
|
|
Properties* operator->() {
|
|
return handle.get();
|
|
}
|
|
|
|
const Properties* operator->() const {
|
|
return handle.get();
|
|
}
|
|
|
|
template<class F>
|
|
std::result_of_t<F(Properties &)> operator->*(F &&f) {
|
|
return std::forward<F>(f)(*handle);
|
|
}
|
|
|
|
template<class F>
|
|
std::result_of_t<F(Properties const &)> operator->*(F &&f) const {
|
|
return std::forward<F>(f)(*handle);
|
|
}
|
|
|
|
template <typename T>
|
|
ts::PropertyWrapper operator[](T type) {
|
|
return (*handle)[type];
|
|
}
|
|
};
|
|
|
|
DataClient(sql::SqlManager*, const std::shared_ptr<TSServer>&);
|
|
virtual ~DataClient();
|
|
|
|
|
|
PropertyWrapper properties(){ return { this->_properties }; }
|
|
|
|
virtual std::deque<std::pair<permission::PermissionType, permission::PermissionValue>> permissionValues(permission::PermissionTestType test,
|
|
const std::deque<permission::PermissionType>&,
|
|
const std::shared_ptr<BasicChannel>& channel = nullptr,
|
|
std::shared_ptr<CalculateCache> cache = nullptr,
|
|
std::shared_ptr<TSServer> server = nullptr,
|
|
bool server_defined = false);
|
|
inline permission::PermissionValue permissionValue(permission::PermissionType type, const std::shared_ptr<BasicChannel>& targetChannel = nullptr) {
|
|
return this->permissionValue(permission::PERMTEST_ORDERED, type, targetChannel);
|
|
}
|
|
|
|
virtual permission::PermissionValue permissionValue(permission::PermissionTestType test,
|
|
permission::PermissionType,
|
|
const std::shared_ptr<BasicChannel>& channel = nullptr,
|
|
std::shared_ptr<CalculateCache> cache = nullptr,
|
|
std::shared_ptr<TSServer> server = nullptr,
|
|
bool server_defined = false);
|
|
|
|
virtual permission::v2::PermissionFlaggedValue permissionValueFlagged(
|
|
permission::PermissionType,
|
|
const std::shared_ptr<BasicChannel>& channel = nullptr,
|
|
std::shared_ptr<CalculateCache> cache = nullptr,
|
|
std::shared_ptr<TSServer> server = nullptr,
|
|
bool server_defined = false
|
|
);
|
|
|
|
virtual bool permissionGranted(permission::PermissionTestType test,
|
|
permission::PermissionType,
|
|
permission::PermissionValue,
|
|
const std::shared_ptr<BasicChannel>& channel = nullptr,
|
|
bool required = true,
|
|
std::shared_ptr<CalculateCache> cache = nullptr,
|
|
std::shared_ptr<TSServer> server = nullptr,
|
|
bool server_defined = false);
|
|
|
|
inline permission::PermissionValue getPermissionGrantValue(permission::PermissionType type, const std::shared_ptr<BasicChannel>& targetChannel = nullptr) {
|
|
return this->getPermissionGrantValue(permission::PERMTEST_ORDERED, type, targetChannel);
|
|
}
|
|
|
|
virtual permission::PermissionValue getPermissionGrantValue(permission::PermissionTestType test, permission::PermissionType, const std::shared_ptr<BasicChannel>& targetChannel = nullptr);
|
|
virtual bool permissionGrantGranted(permission::PermissionTestType test, permission::PermissionType, permission::PermissionValue, const std::shared_ptr<BasicChannel>& targetChannel = nullptr, bool required = true);
|
|
|
|
template <typename T>
|
|
inline bool permission_granted(T, permission::PermissionValue, bool = false) = delete; /* only permission values */
|
|
[[deprecated]] __always_inline bool permission_granted(ts::permission::PermissionValue value, ts::permission::PermissionValue required, bool enforce_required = true) {
|
|
return DataClient::permission_granted({value, value != permNotGranted}, required, enforce_required);
|
|
}
|
|
|
|
static inline bool permission_granted(ts::permission::v2::PermissionFlaggedValue value, ts::permission::PermissionValue required, bool enforce_required = true) {
|
|
if(required == permNotGranted || required == 0) {
|
|
if(enforce_required)
|
|
return value.value == -1 || value.value > 0;
|
|
else
|
|
return true;
|
|
} else if(!value.has_value) {
|
|
return false;
|
|
} else {
|
|
if(value.value == -1)
|
|
return true;
|
|
else if(value.value >= required)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
virtual std::vector<std::shared_ptr<GroupAssignment>> assignedServerGroups();
|
|
virtual std::shared_ptr<GroupAssignment> assignedChannelGroup(const std::shared_ptr<BasicChannel> &);
|
|
virtual bool serverGroupAssigned(const std::shared_ptr<Group> &);
|
|
virtual bool channelGroupAssigned(const std::shared_ptr<Group> &, const std::shared_ptr<BasicChannel> &);
|
|
|
|
virtual std::string getDisplayName() { return this->properties()[property::CLIENT_NICKNAME]; }
|
|
virtual std::string getLoginName() { return this->properties()[property::CLIENT_LOGIN_NAME]; }
|
|
virtual void setDisplayName(std::string displayName) { this->properties()[property::CLIENT_NICKNAME] = displayName; }
|
|
|
|
|
|
virtual ClientType getExternalType(){
|
|
uint8_t type = this->properties()[property::CLIENT_TYPE];
|
|
return (ClientType) type;
|
|
}
|
|
|
|
virtual ClientType getType(){
|
|
uint8_t type = this->properties()[property::CLIENT_TYPE_EXACT];
|
|
return (ClientType) type;
|
|
}
|
|
|
|
virtual std::string getUid() { return this->properties()[property::CLIENT_UNIQUE_IDENTIFIER]; }
|
|
virtual std::string getAvatarId();
|
|
virtual ClientDbId getClientDatabaseId() { return this->properties()[property::CLIENT_DATABASE_ID]; }
|
|
|
|
|
|
virtual bool loadDataForCurrentServer();
|
|
protected:
|
|
sql::SqlManager* sql;
|
|
std::shared_ptr<TSServer> server;
|
|
|
|
std::shared_ptr<permission::v2::PermissionManager> clientPermissions = nullptr;
|
|
std::shared_ptr<Properties> _properties;
|
|
};
|
|
}
|
|
} |