240 lines
11 KiB
C
240 lines
11 KiB
C
|
#pragma once
|
||
|
|
|
||
|
|
#include <vector>
|
||
|
|
#include <query/Command.h>
|
||
|
|
#include <Error.h>
|
||
|
|
#include <PermissionManager.h>
|
||
|
|
#include <src/client/ConnectedClient.h>
|
||
|
|
#include "./helpers.h"
|
||
|
|
|
||
|
|
namespace ts::command::bulk_parser {
|
||
|
|
template <bool kParseValue>
|
||
|
|
class PermissionBulkParser {
|
||
|
|
public:
|
||
|
|
explicit PermissionBulkParser(ts::ParameterBulk& bulk) {
|
||
|
|
if(bulk.has("permid")) {
|
||
|
|
auto type = bulk["permid"].as<permission::PermissionType>();
|
||
|
|
if ((type & PERM_ID_GRANT) != 0) {
|
||
|
|
type &= ~PERM_ID_GRANT;
|
||
|
|
}
|
||
|
|
|
||
|
|
this->permission_ = permission::resolvePermissionData(type);
|
||
|
|
} else if(bulk.has("permsid")) {
|
||
|
|
auto permission_name = bulk["permsid"].string();
|
||
|
|
this->permission_ = permission::resolvePermissionData(permission_name);
|
||
|
|
this->grant_ = this->permission_->grantName() == permission_name;;
|
||
|
|
} else {
|
||
|
|
this->error_.reset(ts::command_result{error::parameter_missing, "permid"});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(this->permission_->is_invalid()) {
|
||
|
|
this->error_.reset(ts::command_result{error::parameter_invalid});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(kParseValue) {
|
||
|
|
if(!bulk.has("permvalue")) {
|
||
|
|
this->error_.reset(ts::command_result{error::parameter_missing, "permvalue"});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this->value_ = bulk["permvalue"].as<permission::PermissionValue>();
|
||
|
|
this->flag_skip_ = bulk.has("permskip") && bulk["permskip"].as<bool>();
|
||
|
|
this->flag_negated_ = bulk.has("permnegated") && bulk["permnegated"].as<bool>();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PermissionBulkParser(const PermissionBulkParser&) = delete;
|
||
|
|
PermissionBulkParser(PermissionBulkParser&&) = default;
|
||
|
|
|
||
|
|
~PermissionBulkParser() {
|
||
|
|
this->error_.release_data();
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] inline bool has_error() const {
|
||
|
|
assert(!this->error_released_);
|
||
|
|
return this->error_.has_error();
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] inline bool has_value() const { return this->value_ != permission::undefined; }
|
||
|
|
[[nodiscard]] inline bool is_grant_permission() const { return this->grant_; }
|
||
|
|
|
||
|
|
[[nodiscard]] inline const auto& permission() const { return this->permission_; }
|
||
|
|
[[nodiscard]] inline auto permission_type() const { return this->permission_->type; }
|
||
|
|
|
||
|
|
[[nodiscard]] inline auto value() const { return this->value_; }
|
||
|
|
[[nodiscard]] inline auto flag_skip() const { return this->flag_skip_; }
|
||
|
|
[[nodiscard]] inline auto flag_negated() const { return this->flag_negated_; }
|
||
|
|
|
||
|
|
[[nodiscard]] inline ts::command_result release_error() {
|
||
|
|
assert(!std::exchange(this->error_released_, true));
|
||
|
|
return std::move(this->error_);
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void emplace_custom_error(ts::command_result&& result) {
|
||
|
|
assert(!this->error_released_);
|
||
|
|
this->error_.reset(std::forward<ts::command_result>(result));
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void apply_to(const std::shared_ptr<permission::v2::PermissionManager>& manager, permission::v2::PermissionUpdateType mode) const {
|
||
|
|
if(this->is_grant_permission()) {
|
||
|
|
manager->set_permission(this->permission_type(), permission::v2::empty_permission_values, permission::v2::PermissionUpdateType::do_nothing, mode);
|
||
|
|
} else {
|
||
|
|
manager->set_permission(
|
||
|
|
this->permission_type(),
|
||
|
|
{ this->value(), true },
|
||
|
|
mode,
|
||
|
|
permission::v2::PermissionUpdateType::do_nothing
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void apply_to_channel(const std::shared_ptr<permission::v2::PermissionManager>& manager, permission::v2::PermissionUpdateType mode, ChannelId channel_id) const {
|
||
|
|
if(this->is_grant_permission()) {
|
||
|
|
manager->set_channel_permission(this->permission_type(), channel_id, permission::v2::empty_permission_values, permission::v2::PermissionUpdateType::do_nothing, mode);
|
||
|
|
} else {
|
||
|
|
manager->set_channel_permission(
|
||
|
|
this->permission_type(),
|
||
|
|
channel_id,
|
||
|
|
{ this->value(), true },
|
||
|
|
mode,
|
||
|
|
permission::v2::PermissionUpdateType::do_nothing
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] inline bool is_group_property() const {
|
||
|
|
return permission_is_group_property(this->permission_type());
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] inline bool is_client_view_property() const {
|
||
|
|
return permission_is_client_property(this->permission_type());
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
std::shared_ptr<permission::PermissionTypeEntry> permission_{nullptr};
|
||
|
|
bool grant_{false};
|
||
|
|
|
||
|
|
bool flag_skip_{false};
|
||
|
|
bool flag_negated_{false};
|
||
|
|
|
||
|
|
permission::PermissionValue value_{0};
|
||
|
|
ts::command_result error_{error::ok};
|
||
|
|
|
||
|
|
#ifndef NDEBUG
|
||
|
|
bool error_released_{false};
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
|
||
|
|
template <bool kParseValue>
|
||
|
|
class PermissionBulksParser {
|
||
|
|
public:
|
||
|
|
PermissionBulksParser(const PermissionBulksParser&) = delete;
|
||
|
|
PermissionBulksParser(PermissionBulksParser&&) = default;
|
||
|
|
|
||
|
|
template <typename base_iterator>
|
||
|
|
struct FilteredPermissionIterator : public base_iterator {
|
||
|
|
public:
|
||
|
|
FilteredPermissionIterator() = default;
|
||
|
|
explicit FilteredPermissionIterator(base_iterator position, base_iterator end = {}) : base_iterator{position}, end_{end} {
|
||
|
|
if(*this != this->end_) {
|
||
|
|
const auto& entry = **this;
|
||
|
|
if(entry.has_error())
|
||
|
|
this->operator++();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
FilteredPermissionIterator& operator++() {
|
||
|
|
while(true) {
|
||
|
|
base_iterator::operator++();
|
||
|
|
if(*this == this->end_) break;
|
||
|
|
|
||
|
|
const auto& entry = **this;
|
||
|
|
if(!entry.has_error()) break;
|
||
|
|
}
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] FilteredPermissionIterator operator++(int) const {
|
||
|
|
FilteredPermissionIterator copy = *this;
|
||
|
|
++*this;
|
||
|
|
return copy;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
base_iterator end_;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct FilteredPermissionListIterable {
|
||
|
|
typedef typename std::vector<PermissionBulkParser<kParseValue>>::const_iterator const_iterator;
|
||
|
|
public:
|
||
|
|
FilteredPermissionListIterable(const_iterator begin, const_iterator end) noexcept : begin_{begin}, end_{end} {}
|
||
|
|
|
||
|
|
FilteredPermissionIterator<const_iterator> begin() const {
|
||
|
|
return FilteredPermissionIterator{this->begin_, this->end_};
|
||
|
|
}
|
||
|
|
|
||
|
|
FilteredPermissionIterator<const_iterator> end() const {
|
||
|
|
return FilteredPermissionIterator{this->end_, this->end_};
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
const_iterator begin_;
|
||
|
|
const_iterator end_;
|
||
|
|
};
|
||
|
|
|
||
|
|
explicit PermissionBulksParser(ts::Command& command) {
|
||
|
|
this->permissions_.reserve(command.bulkCount());
|
||
|
|
for(size_t index{0}; index < command.bulkCount(); index++)
|
||
|
|
this->permissions_.emplace_back(command[index]);
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] inline bool validate(const std::shared_ptr<server::ConnectedClient>& issuer, ChannelId channel_id) {
|
||
|
|
auto ignore_granted_values = permission::v2::permission_granted(1, issuer->calculate_permission(permission::b_permission_modify_power_ignore, channel_id));
|
||
|
|
if(!ignore_granted_values) {
|
||
|
|
auto max_value = issuer->calculate_permission(permission::i_permission_modify_power, channel_id, false);
|
||
|
|
if(!max_value.has_value) {
|
||
|
|
for(PermissionBulkParser<kParseValue>& permission : this->permissions_) {
|
||
|
|
if(permission.has_error()) continue;
|
||
|
|
|
||
|
|
permission.emplace_custom_error(ts::command_result{permission::i_permission_modify_power});
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
for(size_t index{0}; index < this->permissions_.size(); index++) {
|
||
|
|
PermissionBulkParser<kParseValue>& permission = this->permissions_[index];
|
||
|
|
if(permission.has_error()) continue;
|
||
|
|
|
||
|
|
if(kParseValue && permission_require_granted_value(permission.permission_type()) && !permission::v2::permission_granted(permission.value(), max_value)) {
|
||
|
|
permission.emplace_custom_error(ts::command_result{permission::i_permission_modify_power});
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!permission::v2::permission_granted(1, issuer->calculate_permission(permission.permission_type(), channel_id, true))) {
|
||
|
|
permission.emplace_custom_error(ts::command_result{permission::i_permission_modify_power});
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] inline FilteredPermissionListIterable iterate_valid_permissions() const {
|
||
|
|
return FilteredPermissionListIterable{this->permissions_.begin(), this->permissions_.end()};
|
||
|
|
}
|
||
|
|
|
||
|
|
[[nodiscard]] inline ts::command_result build_command_result() {
|
||
|
|
assert(!std::exchange(this->result_created_, true));
|
||
|
|
ts::command_result_bulk result{};
|
||
|
|
|
||
|
|
for(auto& permission : this->permissions_)
|
||
|
|
result.insert_result(std::forward<ts::command_result>(permission.release_error()));
|
||
|
|
|
||
|
|
return ts::command_result{std::move(result)};
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
std::vector<PermissionBulkParser<kParseValue>> permissions_{};
|
||
|
|
#ifndef NDEBUG
|
||
|
|
bool result_created_{false};
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
}
|