def group_delete(fxtype):
try:
group_data = request.json['group']
upper_fxtype = fxtype.upper()
if upper_fxtype in ('SPOT', 'NDF'):
for gr in group_data:
databus.delete('LegalEntitiesRelationships/Groups_Spreads/FX' + upper_fxtype + '/' + gr)
databus.delete('ClientSpreads/GroupSpreads/' + gr + '/FX' + upper_fxtype)
with open(get_data_path('RobotFX_LegalEntitiesRelationships.json'), 'w') as json_file_out:
json_file_out.write(json.dumps(databus.get_dict('LegalEntitiesRelationships'), indent=2))
with open(get_data_path('RobotFX_Client_Spreads.json'), 'w') as json_file_out:
json_file_out.write(json.dumps(databus.get_dict('ClientSpreads'), indent=2))
return jsonify({'status': 'ok - group - ' + fxtype.lower() + ' - delete'})
else:
raise KeyError()
except KeyError:
exc_info = sys.exc_info()
return jsonify(
{
'status': 'error - group - ' + fxtype.lower() + ' - delete',
'exception': ''.join(traceback.format_exception(*exc_info)),
}
)
def trading_parameters_ndf():
trading_parameters = databus.get_dict('TradingParameters')
engine_parameters = json.dumps(
trading_parameters["Engine_Global_Parameters"]["FXNDF"])
currency_keys = json.dumps(trading_parameters["CurrencyKeys"])
counterparty_list = []
leg_entities = databus.get_dict('LegalEntities')
if leg_entities is None:
leg_entities = {}
trad_counterparties = trading_parameters['CounterpartyKeys']
common_cp_keys = tuple(k for k, v in leg_entities.items()
if 'FXNDF' in v['Products'])
for cp_key in common_cp_keys:
trad_value = trad_counterparties[cp_key]['FXNDF']
validate_kyc_rule = update_validate_rule(trad_value['ValidateKYC'],
'KYC', cp_key, True)
validate_isda_rule = update_validate_rule(trad_value['ValidateISDA'],
'ISDA', cp_key, True)
counterparty_list.append({
'cter_prty_id':
cp_key,
'counterparty':
leg_entities[cp_key]["CounterpartyName"],
'upper_limit_dc':
trad_value['UpperLimitDays2Maturity'],
'automatic_flow':
trad_value['AutoFlow'],
'validate_kyc':
validate_kyc_rule,
'validate_isda':
validate_isda_rule,
})
with open(get_data_path('RobotFX_Users.json')) as json_file:
user_data = json.load(json_file)
user_id = session.get("user_id", None)
username = get_username(user_id)
if username not in user_data:
return render_template('404.html')
response_data = user_data[username]
allow_validate = response_data['allow_validate'].lower() == 'yes'
validate_parameters = get_validate_parameters()
json_sorted_currencies = get_currencies_sorted()
return render_template(
'trading-parameters-ndf.html',
engine_parameters=engine_parameters,
currency_keys=currency_keys,
counterparty_data=json.dumps(counterparty_list),
sorted_currencies=json_sorted_currencies,
allow_validate=json.dumps(allow_validate),
validate_parameters=json.dumps(validate_parameters),
)
def halt_spot():
if request.method == 'GET':
status_trading_spot = databus.get_dict('System/Status/Trading/SPOT')
status_supplier = databus.get_dict('System/Status/Quoting')
status_trading_spot.update(status_supplier)
return jsonify(status_trading_spot)
if request.method == 'PUT':
spot_key = databus.get_dict('System/Status/General/Spot')
if spot_key:
databus.update_from_dict(json.loads(request.data),
"System/Status/Trading")
return jsonify({'status': 'ok'})
else:
return jsonify({'status': 'ok - halted'})
def halt_ndf():
if request.method == 'GET':
status_trading_ndf = databus.get_dict('System/Status/Trading/NDF')
status_supplier = databus.get_dict('System/Status/Quoting')
status_trading_ndf.update(status_supplier)
return jsonify(status_trading_ndf)
if request.method == 'PUT':
ndf_key = databus.get_dict('System/Status/General/NDF')
if ndf_key:
databus.update_from_dict(json.loads(request.data),
"System/Status/Trading")
return jsonify({'status': 'ok'})
else:
return jsonify({'status': 'ok - halted'})
def halt_quoting():
if request.method == 'GET':
return jsonify(databus.get_dict('System/Status/Quoting'))
if request.method == 'PUT':
spot_key = databus.get_dict('System/Status/General/Spot')
ndf_key = databus.get_dict('System/Status/General/NDF')
data = (json.loads(request.data))['Quoting']
allow_clicking_NDF = 'Spot' not in data and 'NDF' in data and ndf_key
allow_clicking_Spot = 'Spot' in data and 'NDF' not in data and spot_key
allow_clicking_All = 'Spot' in data and 'NDF' in data and spot_key and ndf_key
if allow_clicking_NDF or allow_clicking_Spot or allow_clicking_All:
databus.update_from_dict(json.loads(request.data), "System/Status")
return jsonify({'status': 'ok'})
else:
return jsonify({'status': 'ok - halted'})
def get_currencies_sorted():
dic = databus.get_dict('Currencies')
result = sorted(dic.keys(), key=lambda x: dic[x]['ViewPriority'])
try:
result.remove('BRL')
except ValueError:
pass
return json.dumps(result)
def get_currencies_sorted_list():
currencies = databus.get_dict('Currencies')
currencies_sorted = sorted(currencies.keys(),
key=lambda x: currencies[x]['ViewPriority'])
try:
currencies_sorted.remove('BRL')
except ValueError:
pass
return currencies_sorted
def risk_data(user_id):
risk_dict = databus.get_dict('RiskData/CURVE')
def sort(elem):
return elem[1]['ViewPriority']
sorted_dict = {k: v for k, v in sorted(risk_dict.items(), key=sort)}
return json.dumps(sorted_dict)
def fxsupplier_transactions():
max_num_days_transaction = 3 # Constante de número total de dias de uma transação.
accounting_status = databus.get_dict('Balance/SPOT')
for currency, dict_value in accounting_status.items():
del dict_value['TotalRevenue']
accounting_status[currency] = dict_value['TotalAmount']
accounting_status[currency]['BuyTotal'] = sum(
accounting_status[currency]['BuyD' + str(i)]
for i in range(max_num_days_transaction))
accounting_status[currency]['SellTotal'] = sum(
accounting_status[currency]['SellD' + str(i)]
for i in range(max_num_days_transaction))
accounting_status[currency]['Net'] = (
accounting_status[currency]['BuyTotal'] -
accounting_status[currency]['SellTotal'])
return json.dumps(accounting_status)
def market_data():
return json.dumps(databus.get_dict('MarketData/Curves'))
def counterparty_config_put():
try:
cp = json.loads(request.data)['counterparty']
cnpj = cp['Cnpj']
del cp['Cnpj']
sel_spot = json.loads(request.data)['selected_spot']
sel_ndf = json.loads(request.data)['selected_ndf']
update_case = json.loads(request.data)['update_case']
if "FXSPOT" not in cp['Products']:
cp['FXMarketType'] = 1
cp['DefaultFXTransaction'] = ''
sel_spot = ''
if "FXNDF" not in cp['Products']:
sel_ndf = ''
with open(get_data_path('RobotFX_LegalEntities.json')) as json_file:
old_obj = json.load(json_file)
if not update_case and cnpj in old_obj:
return jsonify({'status': 'already_taken'})
old_obj[cnpj] = cp
with open(get_data_path('RobotFX_LegalEntities.json'), "w") as json_file_out:
json_file_out.write(json.dumps(old_obj, indent=2))
databus.update_from_file(get_data_path('RobotFX_LegalEntities.json'), 'LegalEntities')
with open(get_data_path('RobotFX_TradingParameters.json')) as json_file:
old_obj = json.load(json_file)
cp = old_obj['CounterpartyKeys']
with open(get_data_path('RobotFX_TradingParameters.json'), "w") as json_file_out:
new_counterparty_default = {
cnpj: {
"FXSPOT": {"ValidateKYC": "YES", "AutoFlow": "ENABLED"},
"FXNDF": {
"UpperLimitDays2Maturity": 720,
"AutoFlow": "ENABLED",
"ValidateKYC": "YES",
"ValidateISDA": "YES",
},
}
}
cp.update(new_counterparty_default)
old_obj['CounterpartyKeys'] = cp
json_file_out.write(json.dumps(old_obj, sort_keys=True, indent=4))
databus.update_from_file(get_data_path('RobotFX_TradingParameters.json'), 'TradingParameters')
currencies = list(databus.get_dict('Currencies').keys())
currencies.remove('BRL')
time_buckets = []
with open(get_data_path('RobotFX_NDFTimeBuckets.json')) as json_file:
old_obj = json.load(json_file)
tb = old_obj['TimeBuckets']
for elem in tb:
time_buckets.append(elem['EndDay'])
with open(get_data_path('RobotFX_Client_Spreads.json')) as json_file:
old_client_spreads = json.load(json_file)
old_client_spreads['CounterpartySpreads'][cnpj] = {
'FXSPOT': {},
'FXNDF': {'Buckets': time_buckets, 'Spreads': {}},
}
for cur in currencies:
old_client_spreads['CounterpartySpreads'][cnpj]['FXSPOT'][cur] = {'BUY': [None] * 3, 'SELL': [None] * 3}
old_client_spreads['CounterpartySpreads'][cnpj]['FXNDF']['Spreads'][cur] = {
'BUYSELL': [None] * len(time_buckets)
}
with open(get_data_path('RobotFX_Client_Spreads.json'), 'w') as json_file_out:
json_file_out.write(json.dumps(old_client_spreads, indent=2))
databus.update_from_file(get_data_path('RobotFX_Client_Spreads.json'), 'ClientSpreads')
with open(get_data_path('RobotFX_LegalEntitiesRelationships.json')) as json_file:
groups_data = json.load(json_file)
groups_data["Groups_Spreads_FXSPOT_Memberships"][cnpj] = sel_spot
groups_data["Groups_Spreads_FXNDF_Memberships"][cnpj] = sel_ndf
with open(get_data_path('RobotFX_LegalEntitiesRelationships.json'), "w") as json_file_out:
json_file_out.write(json.dumps(groups_data, indent=2))
databus.update_from_file(get_data_path('RobotFX_LegalEntitiesRelationships.json'), 'LegalEntitiesRelationships')
return jsonify({'status': 'ok'})
except KeyError:
exc_info = sys.exc_info()
return jsonify({'status': 'error', 'exception': ''.join(traceback.format_exception(*exc_info))})
except json.decoder.JSONDecodeError:
return jsonify({'status': 'fail because JSONDecoderError!'})
def update_transaction_with_blotter_like_info(session, quote_req_id):
q = session.query(
tables.Transaction).filter_by(quote_req_id=quote_req_id).first()
if q is not None:
fx_product = q.fx_product
blotter_info = json.loads(databus.get_dict(f"Blotter/{quote_req_id}"))
blotter_info_keys = blotter_info.keys()
if "symbol" in blotter_info_keys:
symbol = blotter_info["symbol"]
update_transaction_column(session, quote_req_id, "symbol", symbol)
if "buy" in blotter_info_keys:
buy = blotter_info["buy"]
if isinstance(buy, float):
update_transaction_column(session, quote_req_id, "buy", buy)
if "sell" in blotter_info_keys:
sell = blotter_info["sell"]
if isinstance(sell, float):
update_transaction_column(session, quote_req_id, "sell", sell)
if "spread" in blotter_info_keys:
spread = blotter_info["spread"]
update_transaction_column(session, quote_req_id, "spread", spread)
if "s_cost" in blotter_info_keys:
s_cost = blotter_info["s_cost"]
update_transaction_column(session, quote_req_id, "s_cost", s_cost)
if "validate_kyc" in blotter_info_keys:
validate_kyc = blotter_info["validate_kyc"]
update_transaction_column(session, quote_req_id, "validate_kyc",
validate_kyc)
if "rejected_text" in blotter_info.keys():
reject_text = blotter_info["rejected_text"]
update_transaction_column(session, quote_req_id, "reject_text",
reject_text)
if fx_product == "SPOT":
# client_side = blotter_info["client_side"]
if "settlement_ccy" in blotter_info_keys:
settlement_ccy = datetime.datetime.strptime(
blotter_info["settlement_ccy"], "%Y-%m-%d").date()
update_transaction_column(session, quote_req_id,
"settlement_ccy", settlement_ccy)
if "settlement_brl" in blotter_info_keys:
settlement_brl = datetime.datetime.strptime(
blotter_info["settlement_brl"], "%Y-%m-%d").date()
update_transaction_column(session, quote_req_id,
"settlement_brl", settlement_brl)
if "settlement_ccy_dn" in blotter_info_keys:
settlement_ccy_dn = blotter_info["settlement_ccy_dn"]
update_transaction_column(session, quote_req_id,
"settlement_ccy_dn",
settlement_ccy_dn)
if "settlement_brl_dn" in blotter_info_keys:
settlement_brl_dn = blotter_info["settlement_brl_dn"]
update_transaction_column(session, quote_req_id,
"settlement_brl_dn",
settlement_brl_dn)
# timestamp = blotter_info["timestamp"]
# revenue = blotter_info["revenue"]
elif fx_product == "NDF":
if "maturity" in blotter_info_keys:
maturity = datetime.datetime.strptime(blotter_info["maturity"],
"%Y-%m-%d").date()
update_transaction_column(session, quote_req_id, "maturity",
maturity)
if "dc" in blotter_info_keys:
dc = blotter_info["dc"]
update_transaction_column(session, quote_req_id, "dc", dc)
if "du" in blotter_info_keys:
du = blotter_info["du"]
update_transaction_column(session, quote_req_id, "du", du)
if "pre_brl" in blotter_info_keys:
pre_brl = blotter_info["pre_brl"]
update_transaction_column(session, quote_req_id, "pre_brl",
pre_brl)
if "cupom_ccy" in blotter_info_keys:
cupom_ccy = blotter_info["cupom_ccy"]
update_transaction_column(session, quote_req_id, "cupom_ccy",
cupom_ccy)
if "brl_risk" in blotter_info_keys:
brl_risk = blotter_info["brl_risk"]
update_transaction_column(session, quote_req_id, "brl_risk",
brl_risk)
if "spread_risk" in blotter_info_keys:
spread_risk = blotter_info["spread_risk"]
update_transaction_column(session, quote_req_id, "spread_risk",
spread_risk)
if "spread_notional" in blotter_info_keys:
spread_notional = blotter_info["spread_notional"]
update_transaction_column(session, quote_req_id,
"spread_notional", spread_notional)
if "f_cost" in blotter_info_keys:
f_cost = blotter_info["f_cost"]
update_transaction_column(session, quote_req_id, "f_cost",
f_cost)
if "fwd_points" in blotter_info_keys:
fwd_points = blotter_info["fwd_points"]
update_transaction_column(session, quote_req_id, "fwd_points",
fwd_points)
if "y_ccy" in blotter_info_keys:
y_ccy = blotter_info["y_ccy"]
update_transaction_column(session, quote_req_id, "y_ccy",
y_ccy)
if "y_ccy_client" in blotter_info_keys:
y_ccy_client = blotter_info["y_ccy_client"]
update_transaction_column(session, quote_req_id,
"y_ccy_client", y_ccy_client)
if "f_pfe" in blotter_info_keys:
f_pfe = blotter_info["f_pfe"]
update_transaction_column(session, quote_req_id, "f_pfe",
f_pfe)
if "validate_isda" in blotter_info_keys:
validate_isda = blotter_info["validate_isda"]
update_transaction_column(session, quote_req_id,
"validate_isda", validate_isda)
if "adj_maturity" in blotter_info_keys:
adj_maturity = datetime.datetime.strptime(
blotter_info["adj_maturity"], "%Y-%m-%d").date()
update_transaction_column(session, quote_req_id,
"adj_maturity", adj_maturity)
if "present_value_ccy" in blotter_info_keys:
present_value_ccy = blotter_info["present_value_ccy"]
update_transaction_column(session, quote_req_id,
"present_value_ccy",
present_value_ccy)
else:
pass
def balance_spot():
data = databus.get_dict('Balance')['SPOT']
return json.dumps(data)
def trading_parameters_spot():
cash_limits_initialized = databus.get(
'System/Status/Trading/SPOT/Initialized')
trading_parameters = databus.get_dict('TradingParameters')
engine_parameters = trading_parameters["Engine_Global_Parameters"][
"FXSPOT"]
currency_keys = trading_parameters["CurrencyKeys"]
leg_entities = databus.get_dict('LegalEntities')
if leg_entities is None:
leg_entities = {}
trad_counterparties = trading_parameters['CounterpartyKeys']
common_cp_keys = tuple(k for k, v in leg_entities.items()
if 'FXSPOT' in v['Products'])
counterparty_list = []
for cp_key in common_cp_keys:
trad_value = trad_counterparties[cp_key]['FXSPOT']
validate_kyc_rule = update_validate_rule(trad_value['ValidateKYC'],
'KYC', cp_key, False)
counterparty_list.append({
'cter_prty_id':
cp_key,
'counterparty':
leg_entities[cp_key]["CounterpartyName"],
'automatic_flow':
trad_value['AutoFlow'],
'validate_kyc':
validate_kyc_rule,
})
json_sorted_currencies = get_currencies_sorted()
cash_limits_logs = {}
if cash_limits_initialized:
cash_limits_logs = databus.get_dict('CashLimits/Logs')
pre_trading_ini_bal = {}
for currency, maturity_value in cash_limits_logs.items():
pre_trading_ini_bal[currency] = {}
for maturity, value in maturity_value.items():
if isinstance(value, list) and len(value) > 0:
pre_trading_ini_bal[currency][maturity] = value[0]
else:
cash_limits_logs = {}
pre_trading_ini_bal = trading_parameters['PreTradingInitialBalance']
with open(get_data_path('RobotFX_Users.json')) as json_file:
user_data = json.load(json_file)
user_id = session.get("user_id", None)
username = get_username(user_id)
if username not in user_data:
return render_template('404.html')
response_data = user_data[username]
allow_validate = response_data['allow_validate'].lower() == 'yes'
validate_parameters = get_validate_parameters()
return render_template(
'trading-parameters-spot.html',
engine_parameters=json.dumps(engine_parameters),
currency_keys=json.dumps(currency_keys),
pre_trading_ini_bal=json.dumps(pre_trading_ini_bal),
counterparty_data=json.dumps(counterparty_list),
sorted_currencies=json_sorted_currencies,
spot_initialized=cash_limits_initialized,
cash_limits_logs=cash_limits_logs,
allow_validate=json.dumps(allow_validate),
validate_parameters=json.dumps(validate_parameters),
)
def balance_ndf():
data = databus.get_dict('Balance/NDF')
return json.dumps(data)
