position flattener
This commit is contained in:
1 parent
50ec2f14f7
commit
2e51aebc94
4 files changed
+458
-2
No files matched your search
@@ -66,7 +66,10 @@ message CustomFormatIceSecurities{
|
||||
message IgnoreNansInDayPnL {
|
||||
optional bool enabled = 1 [default = true];
|
||||
}
|
||||
|
||||
message SendLimitOrderForPositionFlattener {
|
||||
optional bool enabled = 1 [default = true];
|
||||
optional uint32 quantity = 2 [default = 0];
|
||||
}
|
||||
message DynamicAlgos{
|
||||
optional bool enable_dorman = 1 [default = false];
|
||||
optional bool enable_pyramid = 2 [default = false];
|
||||
|
||||
@@ -0,0 +1,400 @@
|
||||
#include "lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.h"
|
||||
#include "lib/api/services/OrderService.pb.h"
|
||||
#include "lib/config/config.h"
|
||||
#include "lib/config/protos/toggles.pb.h"
|
||||
#include "lib/domain_model/Security.h"
|
||||
#include "lib/domain_model/Security.pb.h"
|
||||
#include "lib/domain_model/SecurityKey.h"
|
||||
#include "lib/domain_model/common.h"
|
||||
#include "lib/logging/logging.h"
|
||||
#include "lib/md/IntPrice.h"
|
||||
#include "lib/md/PriceSize.h"
|
||||
#include "lib/orderman/actors/SODPosition.h"
|
||||
#include "lib/orderman/order_factory/IOrderFactory.h"
|
||||
#include "lib/orderman/orderman_utils/Book.h"
|
||||
#include "lib/orderman/orderman_utils/orderman_common.h"
|
||||
#include "lib/orderman/orderman_utils/orderman_utils.h"
|
||||
#include "lib/orderman/orders/algo/DynamicHelpers.h"
|
||||
#include "lib/orderman/orders/algo/IAlgoOrder.h"
|
||||
#include "lib/orderman/orders/algo/IAlgoServices.h"
|
||||
#include "lib/orderman/orders/algo/algo_orders/MomentumAlgo.h"
|
||||
#include "lib/os/os.h"
|
||||
#include "lib/utils/PBUtils.h"
|
||||
#include "lib/utils/bts_assert.h"
|
||||
#include "lib/utils/bts_chrono.h"
|
||||
#include "lib/utils/datetime.h"
|
||||
#include <algorithm>
|
||||
#include <bits/stdint-intn.h>
|
||||
#include <bits/stdint-uintn.h>
|
||||
#include <boost/circular_buffer.hpp>
|
||||
#include <boost/none.hpp>
|
||||
#include <boost/tokenizer.hpp>
|
||||
#include <c++/7/bits/c++config.h>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <ctime>
|
||||
#include <fstream>
|
||||
#include <functional>
|
||||
#include <google/protobuf/util/time_util.h>
|
||||
#include <iostream>
|
||||
#include <math.h>
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
#include <ostream>
|
||||
#include <set>
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
namespace bts {
|
||||
namespace orderman {
|
||||
|
||||
using namespace api::orderman;
|
||||
using namespace google::protobuf;
|
||||
|
||||
enum class PositionFlattenerAlgo::AlgoStatus {
|
||||
PAUSED,
|
||||
WORKING,
|
||||
WAITING_FOR_CXL_ACK,
|
||||
WAITING_FOR_FLATTEN,
|
||||
CANCELLED
|
||||
};
|
||||
enum class PositionFlattenerAlgo::ExitPath { CANCEL, ERR, COMPLETE };
|
||||
ChildTemplate *_get_Terimnator_child_template(IBeforeLaunchAlgoServices &serv,
|
||||
const CustomOrderDefinition &cod,
|
||||
SecurityKey key, api::Side side) {
|
||||
OrderDefinition rv = serv.definition();
|
||||
rv.set_security_key(key.value());
|
||||
rv.set_side(side);
|
||||
rv.mutable_custom_def()->CopyFrom(cod);
|
||||
return &(serv.make_child_template(rv));
|
||||
}
|
||||
struct PositionFlattenerAlgoLegData {
|
||||
const SecurityKey sec_key;
|
||||
ChildTemplate *order_template = nullptr;
|
||||
OrderKey order_key;
|
||||
ChildState order_state;
|
||||
ChildStatus status;
|
||||
PositionFlattenerAlgoLegData(SecurityKey sec_key_a,
|
||||
ChildTemplate *order_template_a)
|
||||
: sec_key(sec_key_a), order_template(order_template_a),
|
||||
order_key(null_order_key()), order_state(), status() {}
|
||||
};
|
||||
struct PositionFlattenerAlgoParams {
|
||||
SecurityKey security_key_id;
|
||||
std::string security_name_str;
|
||||
std::vector<PositionFlattenerAlgoLegData> legs;
|
||||
bool dont_flatten;
|
||||
PositionFlattenerAlgoParams(SecurityKey key, std::string sec_name,
|
||||
std::vector<PositionFlattenerAlgoLegData> lgs,
|
||||
bool dont_flatten)
|
||||
: security_key_id(key), security_name_str(sec_name), legs(lgs),
|
||||
dont_flatten(dont_flatten) {}
|
||||
};
|
||||
struct PositionFlattenerAlgo::PImpl {
|
||||
IAlgoServices *algo;
|
||||
std::vector<PositionFlattenerAlgoLegData> legs;
|
||||
AlgoStatus status = AlgoStatus::PAUSED;
|
||||
std::unique_ptr<PositionFlattenerAlgoParams> algo_params;
|
||||
OrderKey flatten_child_key = null_order_key();
|
||||
AccountID acc_id;
|
||||
int order_distance = 0;
|
||||
// std::unordered_set<OrderKey> flatten_child_keys_sim;
|
||||
ChildTemplate *flatten_template_buy = nullptr;
|
||||
ChildTemplate *flatten_template_sell = nullptr;
|
||||
double pos = 0;
|
||||
bool is_sim;
|
||||
};
|
||||
bool _convert_params(IBeforeLaunchAlgoServices &serv,
|
||||
const CustomOrderDefinition &cod,
|
||||
std::unique_ptr<PositionFlattenerAlgoParams> &out_p) {
|
||||
LOG(OrderMan, Diag, "PositionFlattenerAlgo::_convert_params");
|
||||
const DynamicOrderDefinition &def = cod.dynamic();
|
||||
const auto ¶ms = def.order_params();
|
||||
std::vector<PositionFlattenerAlgoLegData> prs;
|
||||
auto sec_key = SecurityKey(serv.security().id());
|
||||
size_t n_child_ords = 5;
|
||||
for (size_t i = 0; i < n_child_ords; i++) {
|
||||
auto idx = std::to_string(i + 1);
|
||||
auto order = get_if<CustomOrderDefinition>(params, "Order " + idx);
|
||||
if (!order.has_value()) {
|
||||
continue;
|
||||
}
|
||||
ChildTemplate *child_template = _get_Terimnator_child_template(
|
||||
serv, order.value(), sec_key, api::Side::SIDE_BUY);
|
||||
prs.push_back(PositionFlattenerAlgoLegData(sec_key, child_template));
|
||||
}
|
||||
|
||||
auto flatten = get_if<bool>(params, "Dont Flatten");
|
||||
if (!flatten.has_value()) {
|
||||
return false;
|
||||
}
|
||||
out_p = std::make_unique<PositionFlattenerAlgoParams>(
|
||||
PositionFlattenerAlgoParams(sec_key,
|
||||
serv.security().glbx().security_desc(), prs,
|
||||
flatten.value()));
|
||||
|
||||
return true;
|
||||
}
|
||||
PositionFlattenerAlgo::PositionFlattenerAlgo() : me(new PImpl()) {}
|
||||
PositionFlattenerAlgo::~PositionFlattenerAlgo() {}
|
||||
IAlgoServices &PositionFlattenerAlgo::algo() const { return *me->algo; }
|
||||
|
||||
ChildTemplate *_get_limit_template(IBeforeLaunchAlgoServices &serv,
|
||||
SecurityKey key, api::Side side) {
|
||||
OrderDefinition rv = serv.definition();
|
||||
rv.set_security_key(key.value());
|
||||
rv.set_side(side);
|
||||
rv.mutable_custom_def()->mutable_limit()->MergeFrom(
|
||||
api::orderman::LimitOrderDefinition());
|
||||
return &(serv.make_child_template(rv));
|
||||
}
|
||||
ChildTemplate *_get_market_template(IBeforeLaunchAlgoServices &serv,
|
||||
SecurityKey key, api::Side side) {
|
||||
OrderDefinition rv = serv.definition();
|
||||
rv.set_security_key(key.value());
|
||||
rv.set_side(side);
|
||||
rv.mutable_custom_def()->mutable_market()->MergeFrom(
|
||||
api::orderman::MarketOrderDefinition());
|
||||
return &(serv.make_child_template(rv));
|
||||
}
|
||||
OrderOpResult
|
||||
PositionFlattenerAlgo::do_before_launch(IBeforeLaunchAlgoServices &serv) {
|
||||
LOG(OrderMan, Diag, "PositionFlattenerAlgo::do_before_launch");
|
||||
OrderDefinition def = serv.definition();
|
||||
|
||||
if (def.has_custom_def() && def.custom_def().has_dynamic() &&
|
||||
_convert_params(serv, def.custom_def(), me->algo_params)) {
|
||||
me->acc_id = AccountID(def.account_id());
|
||||
me->is_sim =
|
||||
config::get<config::toggles::SendLimitOrderForPositionFlattener>()
|
||||
.enabled();
|
||||
me->order_distance =
|
||||
config::get<config::toggles::SendLimitOrderForPositionFlattener>()
|
||||
.quantity();
|
||||
me->legs =
|
||||
std::vector<PositionFlattenerAlgoLegData>(me->algo_params->legs);
|
||||
me->flatten_template_buy =
|
||||
me->is_sim
|
||||
? _get_limit_template(serv, SecurityKey(serv.security().id()),
|
||||
api::Side::SIDE_BUY)
|
||||
: _get_market_template(serv, SecurityKey(serv.security().id()),
|
||||
api::Side::SIDE_BUY);
|
||||
me->flatten_template_sell =
|
||||
me->is_sim
|
||||
? _get_limit_template(serv, SecurityKey(serv.security().id()),
|
||||
api::Side::SIDE_SELL)
|
||||
: _get_market_template(serv, SecurityKey(serv.security().id()),
|
||||
api::Side::SIDE_SELL);
|
||||
return {};
|
||||
}
|
||||
|
||||
return {OrderError::ORDER_ERROR_INVALID_PARAMETER,
|
||||
std::string("Parameters are not well formed")};
|
||||
}
|
||||
void PositionFlattenerAlgo::on_position(PositionUpdate const &pos) {
|
||||
if (pos.security->id() != me->algo->security().id() ||
|
||||
pos.account_id != me->acc_id) {
|
||||
return; //|| pos.account_id != me->algo-> add this
|
||||
}
|
||||
me->pos =
|
||||
double(pos.long_quantity.value()) - double(pos.short_quantity.value());
|
||||
LOG(OrderMan, Diag,
|
||||
"PositionFlattenerAlgo::on_cancel state {}, pos: {}, long: {}, short: "
|
||||
"{}",
|
||||
me->status, me->pos, pos.long_quantity.value(),
|
||||
pos.short_quantity.value());
|
||||
}
|
||||
void PositionFlattenerAlgo::do_launch(IAlgoServices &algo) {
|
||||
LOG(OrderMan, Diag, "PositionFlattenerAlgo::do_launch");
|
||||
me->algo = &algo;
|
||||
me->status = PositionFlattenerAlgo::AlgoStatus::WORKING;
|
||||
// LUANCH CHILD ORDERS
|
||||
me->algo->subscribe_position();
|
||||
for (size_t i = 0; i < me->legs.size(); i++) {
|
||||
me->legs[i].order_key = me->algo->launch_child(
|
||||
*me->legs[i].order_template, me->algo->price(), bts::Quantity(1));
|
||||
}
|
||||
}
|
||||
|
||||
void PositionFlattenerAlgo::do_launch_attached(IAlgoServices &algo, OrderKey,
|
||||
ChildState) {
|
||||
me->algo = &algo;
|
||||
_cxl_and_end(true,
|
||||
"PositionFlattener Algo can not be attached to working orders");
|
||||
}
|
||||
|
||||
void PositionFlattenerAlgo::do_update(api::orderman::Update const &update) {
|
||||
if (!update.has_custom() || !update.custom().has_dynamic()) {
|
||||
return;
|
||||
}
|
||||
const DynamicOrderDefinition &def = update.custom().dynamic();
|
||||
const auto ¶ms = def.order_params();
|
||||
auto dont_flatten = get_if<bool>(params, "Dont Flatten");
|
||||
if (!dont_flatten.has_value()) {
|
||||
return;
|
||||
}
|
||||
me->algo_params->dont_flatten = dont_flatten.value();
|
||||
LOG(OrderMan, Diag,
|
||||
"PositionFlattenerAlgo order {} receiving update: {} UPDATES NOT "
|
||||
"ALLOWED",
|
||||
algo().order_key().value(), utils::pb::to_string(update));
|
||||
}
|
||||
std::optional<size_t>
|
||||
find_leg_index(std::vector<PositionFlattenerAlgoLegData> legs, OrderKey k) {
|
||||
for (size_t index = 0; index < legs.size(); index++) {
|
||||
|
||||
if (legs[index].order_key == k) {
|
||||
return index;
|
||||
}
|
||||
}
|
||||
return std::nullopt;
|
||||
}
|
||||
void PositionFlattenerAlgo::on_child_change(OrderKey k,
|
||||
ChildState const &state) {
|
||||
if (me->flatten_child_key == k) {
|
||||
// bts_assert(state.status != ChildStatus::CANCELED);
|
||||
if (state.status == ChildStatus::COMPLETED) {
|
||||
me->status = PositionFlattenerAlgo::AlgoStatus::PAUSED;
|
||||
_cxl_and_end(false, "POSITION FLATTENED");
|
||||
return;
|
||||
}
|
||||
}
|
||||
auto maybe_leg_index = find_leg_index(me->legs, k);
|
||||
if (!maybe_leg_index.has_value()) {
|
||||
return;
|
||||
}
|
||||
auto leg_index = maybe_leg_index.value();
|
||||
me->legs[leg_index].status = state.status;
|
||||
switch (me->status) {
|
||||
case PositionFlattenerAlgo::AlgoStatus::WORKING:
|
||||
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN:
|
||||
break;
|
||||
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK:
|
||||
if (state.status != ChildStatus::WORKING) {
|
||||
_cxl_and_end(false, "");
|
||||
}
|
||||
break;
|
||||
case PositionFlattenerAlgo::AlgoStatus::CANCELLED:
|
||||
case PositionFlattenerAlgo::AlgoStatus::PAUSED:
|
||||
bts_assert(false);
|
||||
};
|
||||
}
|
||||
Price get_price(double algo_price, api::Side side, bool is_sim, int quantity,
|
||||
double tick_val) {
|
||||
if (!is_sim) {
|
||||
return Price(algo_price);
|
||||
}
|
||||
if (side == api::Side::SIDE_BUY) {
|
||||
return Price(algo_price + tick_val * std::abs(quantity));
|
||||
}
|
||||
return Price(algo_price - tick_val * std::abs(quantity));
|
||||
}
|
||||
void PositionFlattenerAlgo::_fire_orders(size_t count, api::Side side) {
|
||||
bts_assert(me->status ==
|
||||
PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN);
|
||||
LOG(OrderMan, Diag, "PositionFlattenerAlgo::_fire_orders count: {} side: {}",
|
||||
count, side);
|
||||
ChildTemplate &ct = side == api::Side::SIDE_BUY ? *me->flatten_template_buy
|
||||
: *me->flatten_template_sell;
|
||||
double tick_size = me->algo->security().contract_spec().low_tick();
|
||||
auto price = get_price(me->algo->price().value(), side, me->is_sim,
|
||||
me->order_distance, tick_size);
|
||||
me->flatten_child_key =
|
||||
me->algo->launch_child(ct, price, bts::Quantity(count));
|
||||
return;
|
||||
}
|
||||
// this only gets called on am explicit algo cancel
|
||||
// from the outside
|
||||
IAlgoOrder::OnCancelResponse PositionFlattenerAlgo::on_cancel() {
|
||||
LOG(OrderMan, Diag,
|
||||
"PositionFlattenerAlgo::"
|
||||
"on_cancel state {}",
|
||||
me->status);
|
||||
// cancel top spread, let
|
||||
// hedges work, cancel algo
|
||||
switch (me->status) {
|
||||
case PositionFlattenerAlgo::AlgoStatus::WORKING:
|
||||
_cxl_and_end(false, "Algo cancelled");
|
||||
break;
|
||||
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN:
|
||||
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK:
|
||||
case PositionFlattenerAlgo::AlgoStatus::CANCELLED:
|
||||
case PositionFlattenerAlgo::AlgoStatus::PAUSED:
|
||||
break;
|
||||
};
|
||||
return IAlgoOrder::OnCancelResponse::IGNORE;
|
||||
}
|
||||
void PositionFlattenerAlgo::_cxl_leg(bool is_error,
|
||||
const std::string &err_msg) {
|
||||
LOG(OrderMan, Diag,
|
||||
"PositionFlattenerAlgo::_"
|
||||
"cxl_leg legs {}",
|
||||
me->legs.size());
|
||||
if (me->legs.size()) {
|
||||
switch (me->legs.back().status) {
|
||||
case ChildStatus::CANCELED:
|
||||
case ChildStatus::COMPLETED:
|
||||
me->legs.pop_back();
|
||||
_cxl_and_end(is_error, err_msg);
|
||||
break;
|
||||
case ChildStatus::WORKING:
|
||||
me->algo->cancel_child(me->legs.back().order_key);
|
||||
};
|
||||
}
|
||||
}
|
||||
void PositionFlattenerAlgo::_flatten_pos() {
|
||||
LOG(OrderMan, Diag,
|
||||
"PositionFlattenerAlgo::_"
|
||||
"flatten_pos state {}",
|
||||
me->status);
|
||||
bts_assert(me->status ==
|
||||
PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN);
|
||||
if (me->algo_params->dont_flatten || me->pos == 0) {
|
||||
me->status = PositionFlattenerAlgo::AlgoStatus::PAUSED;
|
||||
return;
|
||||
}
|
||||
if (me->pos < 0) {
|
||||
_fire_orders(abs(me->pos), api::Side::SIDE_BUY);
|
||||
return;
|
||||
}
|
||||
if (me->pos > 0) {
|
||||
_fire_orders(abs(me->pos), api::Side::SIDE_SELL);
|
||||
return;
|
||||
}
|
||||
}
|
||||
void PositionFlattenerAlgo::_cxl_and_end(bool is_error,
|
||||
const std::string &err_msg) {
|
||||
LOG(OrderMan, Diag,
|
||||
"PositionFlattenerAlgo::_"
|
||||
"cxl_and_end state {} "
|
||||
"legs size {}",
|
||||
me->status, me->legs.size());
|
||||
if (is_error) {
|
||||
me->algo->cancel();
|
||||
}
|
||||
switch (me->status) {
|
||||
case PositionFlattenerAlgo::AlgoStatus::WORKING:
|
||||
me->status = AlgoStatus::WAITING_FOR_CXL_ACK;
|
||||
_cxl_and_end(is_error, err_msg);
|
||||
break;
|
||||
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK:
|
||||
if (me->legs.size()) {
|
||||
_cxl_leg(is_error, err_msg);
|
||||
break;
|
||||
} else {
|
||||
me->status = AlgoStatus::WAITING_FOR_FLATTEN;
|
||||
_flatten_pos();
|
||||
_cxl_and_end(is_error, err_msg);
|
||||
break;
|
||||
}
|
||||
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN:
|
||||
break;
|
||||
case PositionFlattenerAlgo::AlgoStatus::CANCELLED:
|
||||
case PositionFlattenerAlgo::AlgoStatus::PAUSED:
|
||||
me->algo->cancel();
|
||||
};
|
||||
}
|
||||
|
||||
} // namespace orderman
|
||||
} // namespace bts
|
||||
@@ -0,0 +1,39 @@
|
||||
#pragma once
|
||||
|
||||
#include "lib/orderman/orders/algo/IAlgoOrder.h"
|
||||
|
||||
namespace bts {
|
||||
namespace orderman {
|
||||
|
||||
// PositionFlattener runs set child algos and flattens state
|
||||
|
||||
class PositionFlattenerAlgo : public IAlgoOrder {
|
||||
public:
|
||||
PositionFlattenerAlgo();
|
||||
~PositionFlattenerAlgo();
|
||||
|
||||
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
|
||||
void do_launch(IAlgoServices &) override;
|
||||
void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override;
|
||||
void do_update(api::orderman::Update const &) override;
|
||||
void on_child_change(OrderKey, ChildState const &) override;
|
||||
void on_position(PositionUpdate const &) override;
|
||||
enum class AlgoStatus;
|
||||
|
||||
private:
|
||||
enum class ExitPath;
|
||||
struct PImpl;
|
||||
std::unique_ptr<PImpl> me;
|
||||
|
||||
IAlgoServices &algo() const;
|
||||
IAlgoOrder::OnCancelResponse on_cancel() override;
|
||||
void _cxl_leg(bool is_error, const std::string &err_msg);
|
||||
void init_child_template(IBeforeLaunchAlgoServices &,
|
||||
api::orderman::CustomOrderDefinition const &);
|
||||
void _cxl_and_end(bool is_error, const std::string &err_msg);
|
||||
void _fire_orders(size_t count, api::Side side);
|
||||
void _flatten_pos();
|
||||
};
|
||||
|
||||
} // namespace orderman
|
||||
} // namespace bts
|
||||
@@ -4,6 +4,7 @@
|
||||
#include "MomentumAlgo.h"
|
||||
#include "MomentumRecorder.h"
|
||||
#include "OnSignalAlgo.h"
|
||||
#include "PositionFlattenerAlgo.h"
|
||||
#include "PyramidAlgo.h"
|
||||
#include "TASAlgo.h"
|
||||
#include "TASCounterAlgo.h"
|
||||
@@ -230,7 +231,19 @@ extern "C" void init_limit_cover(bts::SparkServices &srv) {
|
||||
srv.register_dynamic_algo_order(
|
||||
lc_desc, []() { return std::make_unique<orderman::LimitCoverAlgo>(); });
|
||||
}
|
||||
|
||||
extern "C" void init_position_flattener(bts::SparkServices &srv) {
|
||||
DynamicOrderDescriptor term;
|
||||
term.set_dynamic_order_type("PositionFlattener");
|
||||
size_t n_child_ords = 5;
|
||||
*term.add_param_desc() = param_bool("Dont Flatten");
|
||||
for (size_t i = 0; i < n_child_ords; i++) {
|
||||
auto idx = std::to_string(i + 1);
|
||||
*term.add_param_desc() = param_order("Order " + idx);
|
||||
}
|
||||
srv.register_dynamic_algo_order(term, []() {
|
||||
return std::make_unique<orderman::PositionFlattenerAlgo>();
|
||||
});
|
||||
}
|
||||
extern "C" void init_on_signal_plugin(bts::SparkServices &srv) {
|
||||
DynamicOrderDescriptor on_signal;
|
||||
on_signal.set_dynamic_order_type("OnSignal");
|
||||
@@ -325,6 +338,7 @@ extern "C" void init_spark_plugin(bts::SparkServices &srv) {
|
||||
init_on_signal_plugin(srv);
|
||||
init_momentum_algo_plugin(srv);
|
||||
init_momentum_recorder_plugin(srv);
|
||||
init_position_flattener(srv);
|
||||
init_file_runner_plugin(srv);
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user