def handle(self, *args, **options):
from sdk.liqpay import liqpay
for DebCred in LiqPayTrans.objects.filter(status='processing', debit_credit='in'):
order = DebCred.order
OrderId = order.id
d = liqpay("ru", "UAH")
Dict = d.api("payment/status", {"version": "2", "order_id": str(OrderId)})
print Dict
if Dict["status"] == "success":
if order.status != "processing":
DebCred.status = 'canceled'
DebCred.save()
continue
order.status = "processing2"
order.save()
OutOrderId = Dict["liqpay_order_id"]
from main.models import check_holds
check_holds(order)
add_trans(order.transit_1, order.sum1, d.currency,
order.transit_2, order,
"payin", OutOrderId, False)
#hack if privat is wrong
Comission = Decimal(Dict["receiver_commission"])
Phone = Dict['sender_phone']
Desc = Dict['description']
Signature = Dict['liqpay_order_id']
Amount = Dict['amount']
add_trans(order.transit_2, Comission, d.currency,
order.transit_1, order,
"comission", OutOrderId, False)
DebCred.status = 'processed'
DebCred.save()
order.status = "processed"
order.save()
#notify_email(order.user, "deposit_notify", DebCred )
else:
DebCred.status = 'canceled'
DebCred.save()
def __inner_remove_order(Order, User):
Order2Remove = Orders.objects.get(user = User, id = int(Order), status="processing" )
Title = Order2Remove.trade_pair.url_title
LOCK = "trades" + Title
TradeLock = my_lock(LOCK)
try :
Order2Remove.status = "canceled"
Order2Remove.save()
Account = Accounts.objects.get(user = User, currency = Order2Remove.currency1)
add_trans(Order2Remove.transit_1,
Order2Remove.sum1,
Order2Remove.currency1,
Account,
Order2Remove,
"order_cancel")
cache = caching()
cache.delete_many(["buy_list_" + Title,
"sell_list_" + Title,
"balance_" + str(User.id),
'client_orders_' + str(User.id) + "_" + Title])
my_release(TradeLock)
return True
except:
my_release(TradeLock)
return False
def confirm_withdraw_p2p(Req, S, PrivateKey):
Transfer = CardP2PTransfers.objects.get(user=Req.user, confirm_key=S, status="created")
IsCancel = Req.REQUEST.get("do", None)
if (
Transfer.status == "processing" or Transfer.status == "auto" or Transfer.status == "created"
) and IsCancel is not None:
Transfer.status = "order_cancel"
Transfer.save()
order = Transfer.order
order.status = "order_cancel"
order.save()
add_trans(order.transit_2, Transfer.amnt, Transfer.currency, order.transit_1, order, "order_cancel", S, True)
t = loader.get_template("simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_cancel
Dict["simple_msg"] = settings.withdraw_msg_cancel
caching().delete("balance_" + str(Req.user.id))
return tmpl_context(Req, t, Dict)
if Transfer.status != "created":
raise TransError("hacker " + Req.user.username)
##add trans may be there
Transfer.status = "processing"
Transfer.sign_record(PrivateKey)
Transfer.save()
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
notify_admin_withdraw(withdraw_p2p(Transfer))
return tmpl_context(Req, t, Dict)
def confirm_withdraw_emoney(Req, S, PrivateKey):
Transfer = TransOut.objects.get(user=Req.user,
confirm_key=S,
status='created')
IsCancel = Req.REQUEST.get("do", None)
if Transfer.status == "created" and IsCancel is not None:
Transfer.status = "canceled"
Transfer.save()
order = Transfer.order
order.status = "canceled"
order.save()
add_trans(order.transit_2, Transfer.amnt, Transfer.currency, order.transit_1,
order, "canceled", S, False)
t = loader.get_template("simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_cancel
Dict["simple_msg"] = settings.withdraw_msg_cancel
caching().delete("balance_" + str(Req.user.id))
return tmpl_context(Req, t, Dict)
if Transfer.status != "created":
raise TransError("hacker " + Req.user.username)
##add trans may be there
Transfer.status = "processing"
Transfer.sign_record(PrivateKey)
Transfer.save()
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
return tmpl_context(Req, t, Dict)
def __inner_remove_order(Order, User):
Order2Remove = Orders.objects.get(user=User,
id=int(Order),
status="processing")
Title = Order2Remove.trade_pair.url_title
LOCK = "trades" + Title
TradeLock = my_lock(LOCK)
try:
Order2Remove.status = "canceled"
Order2Remove.save()
Account = Accounts.objects.get(user=User,
currency=Order2Remove.currency1)
add_trans(Order2Remove.transit_1, Order2Remove.sum1,
Order2Remove.currency1, Account, Order2Remove,
"order_cancel")
cache = caching()
cache.delete_many([
"buy_list_" + Title, "sell_list_" + Title,
"balance_" + str(User.id),
'client_orders_' + str(User.id) + "_" + Title
])
my_release(TradeLock)
return True
except:
my_release(TradeLock)
return False
def get(self, order_id):
start = time.time()
order = Orders.objects.get(id=order_id, status="processing")
s = TornadoServer.get_instance()
try:
with transaction.atomic():
add_trans(order.transit_1, order.sum1,
order.currency1, order.transit_2, order, "withdraw",
str(order), False)
order.status = "processed"
order.save()
try:
i = order.user_id
s.keys4delete.append("balance_" + str(i))
print "got trans from %i" % i
except:
traceback.print_exc()
print "problem in working with cache"
end = time.time()
print "add trans payin timing"
print end - start
self.write({"status": True, "time": end - start})
except:
traceback.print_exc()
order.status = "core_error"
print "add trans withdraw timing"
end = time.time()
print end - start
order.save()
self.set_status(500)
def return_rest2acc(Order, AccumSumToSell):
Account2Sell = get_account(Order.user, Order.currency1)
add_trans(Order.transit_1,
AccumSumToSell,
Order.currency1,
Account2Sell,
Order,
"deal_return")
system_notify( order_return_unused( Order, AccumSumToSell ), Order.user )
def cancel_trans(obj):
add_trans(obj.user2,
obj.amnt,
obj.currency,
obj.user1,
None,
"canceled",
obj.id,
False)
def return_rest2acc(Order, AccumSumToSell):
Account2Sell = get_account(Order.user, Order.currency1)
add_trans(Order.transit_1,
AccumSumToSell,
Order.currency1,
Account2Sell,
Order,
"deal_return")
system_notify( order_return_unused( Order, AccumSumToSell ), Order.user )
def confirm_withdraw_currency(Req, S, PrivateKey):
S = S.replace("\n", "").replace(" ", "")
Transfer = CryptoTransfers.objects.get(status="created", confirm_key=S)
##add trans may be there
AccountTo = Accounts.objects.get(user=Transfer.user, currency=Transfer.currency)
## if not by reference, but by users
TradePair = TradePairs.objects.get(currency_on=Transfer.currency, currency_from=Transfer.currency)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response["Content-Type"] = "application/json"
return Response
order = Orders(
user=Transfer.user,
currency1=Transfer.currency,
currency2=Transfer.currency,
price=Transfer.amnt,
sum1_history=Transfer.amnt + Transfer.comission,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt + Transfer.comission,
sum2=Transfer.amnt,
transit_1=AccountTo,
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created",
)
order.save()
order.status = "processing"
order.save()
Transfer.order = order
Transfer.status = "processing"
Transfer.sign_record(PrivateKey)
Transfer.save()
# TODO add process exception in withdraw crypto currency
add_trans(
AccountTo,
Transfer.amnt + Transfer.comission,
Transfer.currency,
TradePair.transit_from,
order,
"withdraw",
S,
True,
)
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
caching().delete("balance_" + str(Transfer.user.id))
notify_admin_withdraw(withdraw_crypto(Transfer))
return tmpl_context(Req, t, Dict)
def process_in2(OrderId, Comis, FactAmnt):
order = Orders.objects.get(id=int(OrderId), status="processing2")
add_trans(order.transit_1, FactAmnt, order.currency1, order.transit_2, order, "payin", None, False)
if Comis > 0:
add_trans(order.transit_2, Comis, order.currency1, order.transit_1, order, "comission", None, False)
order.status = "processed"
order.save()
return True
def emoney_transfer_withdraw_secure(Req, Form, provider):
Key = generate_key("p2p_ahuihui")
Wallet = Form.cleaned_data["wallet"]
Wallet = Wallet.replace(" ", "")
Transfer = TransOut(
wallet=Wallet,
currency=Form.currency_instance,
amnt=Form.cleaned_data["amnt"],
user=Req.user,
pub_date=datetime.datetime.now(),
confirm_key=Key,
provider=provider,
)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response["Content-Type"] = "application/json"
return Response
Transfer.save()
AccountTo = Accounts.objects.get(user=Req.user, currency=Transfer.currency)
## if not by reference, but by users
trade_pair_title = provider + "_" + Form.currency_instance.title.lower()
TradePair = TradePairs.objects.get(url_title=trade_pair_title)
order = Orders(
user=Req.user,
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
price=Decimal("1"),
sum2=Transfer.amnt,
transit_1=AccountTo,
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created",
)
order.save()
# TODO add process exception in withdraw p2p
add_trans(AccountTo, Transfer.amnt, Transfer.currency, TradePair.transit_from, order, "withdraw", Key, True)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.save()
# if settings.DEBUG is False:
send_mail(
_(u"Подтверждение вывода ") + settings.BASE_HOST,
confirm_emoney_withdraw_email(Form.cleaned_data, Key),
settings.EMAIL_HOST_USER,
[Req.user.email],
fail_silently=False,
)
def handle(self, *args, **options):
##hardcode UAH income
CurIns = Currency.objects.get(id = 1)
AccountFrom = Accounts.objects.get(user = PARTNERSHIP,
currency = CurIns)
for icome in Partnership.objects.filter(status = "processing"):
AccountTo = Accounts.objects.get(user = income.user,
currency = CurIns)
income.status="processed"
income.save()
add_trans( AccountFrom, income.income, CurIns, AccountTo, None, "payin", str(income.id), False)
def process_in2(OrderId, Comis, FactAmnt):
order = Orders.objects.get(id=int(OrderId), status='processing2')
add_trans(order.transit_1, FactAmnt, order.currency1, order.transit_2,
order, "payin", None, False)
if Comis > 0:
add_trans(order.transit_2, Comis, order.currency1, order.transit_1,
order, "comission", None, False)
order.status = "processed"
order.save()
return True
def p2p_transfer_withdraw_secure(Req, Form):
Key = generate_key("p2p_ahuihui")
CardNumber = Form.cleaned_data["CardNumber"]
CardNumber = CardNumber.replace(" ", "")
Transfer = CardP2PTransfers(
debit_credit="out",
CardName=Form.cleaned_data["CardName"],
CardNumber=CardNumber,
currency=Form.currency_instance,
amnt=Form.cleaned_data["amnt"],
user=Req.user,
pub_date=datetime.datetime.now(),
confirm_key=Key
)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
Transfer.save()
AccountTo = get_account(user=Req.user, currency=Transfer.currency)
## if not by reference, but by users
TradePair = TradePairs.objects.get(url_title="p2p_transfers")
order = Orders(user=Req.user,
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
sum2=Transfer.amnt,
transit_1=AccountTo,
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created"
)
order.save()
# TODO add process exception in withdraw p2p
add_trans(AccountTo.acc(), Transfer.amnt, Transfer.currency, TradePair.transit_from,
order, "withdraw", Key, True)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.save()
#if settings.DEBUG is False:
send_mail(_(u'Подтверждение вывода ') + settings.BASE_HOST,
confirm_p2p_withdraw_email(Form.cleaned_data, Key),
settings.EMAIL_HOST_USER,
[Req.user.email],
fail_silently=False)
def emoney_transfer_withdraw_secure(Req, Form, provider):
Key = generate_key("p2p_ahuihui")
Wallet = Form.cleaned_data["wallet"]
Wallet = Wallet.replace(" ", "")
Transfer = TransOut(
wallet=Wallet,
currency=Form.currency_instance,
amnt=Form.cleaned_data["amnt"],
user=Req.user,
pub_date=datetime.datetime.now(),
confirm_key=Key,
provider=provider
)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
Transfer.save()
AccountTo = get_account(user=Req.user, currency=Transfer.currency)
## if not by reference, but by users
trade_pair_title = provider + "_" + Form.currency_instance.title.lower()
TradePair = TradePairs.objects.get(url_title=trade_pair_title)
order = Orders(user=Req.user,
price=Decimal("1"),
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
sum2=Transfer.amnt,
transit_1=AccountTo.acc(),
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created"
)
order.save()
# TODO add process exception in withdraw p2p
add_trans(AccountTo.acc(), Transfer.amnt, Transfer.currency, TradePair.transit_from,
order, "withdraw", Key, False)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.save()
#if settings.DEBUG is False:
send_mail(_(u'Подтверждение вывода ') + settings.BASE_HOST,
confirm_emoney_withdraw_email(Form.cleaned_data, Key),
[Req.user.email],
fail_silently=False)
def process_perfect_in2(OrderId, Comission):
order = Orders.objects.get(id = int(OrderId), status='processing2' )
add_trans( order.transit_1 , order.sum1, order.currency1,
order.transit_2, order,
"payin", None , False)
if Comission>0:
add_trans(order.transit_2 , Comission, order.currency1,
order.transit_1, order,
"comission", None, False)
order.status = "processed"
order.save()
return True
def confirm_withdraw_currency(Req, S, PrivateKey=''):
S = S.replace("\n", "").replace(" ", "")
Transfer = CryptoTransfers.objects.get(status="created", confirm_key=S)
##add trans may be there
AccountTo = get_account(user=Transfer.user, currency=Transfer.currency)
## if not by reference, but by users
TradePair = TradePairs.objects.get(currency_on=Transfer.currency,
currency_from=Transfer.currency)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
order = Orders(price=Decimal("1"),
user=Transfer.user,
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt + Transfer.comission,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt + Transfer.comission,
sum2=Transfer.amnt,
transit_1=AccountTo.acc(),
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created",
)
order.save()
order.status = "processing"
order.save()
Transfer.order = order
Transfer.status = "processing"
Transfer.sign_record(PrivateKey)
Transfer.save()
# TODO add process exception in withdraw crypto currency
add_trans(AccountTo.acc(), Transfer.amnt + Transfer.comission, Transfer.currency, TradePair.transit_from,
order, "withdraw", S, False)
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
caching().delete("balance_" + str(Transfer.user.id))
notify_admin_withdraw(withdraw_crypto(Transfer))
return tmpl_context(Req, t, Dict)
def process_deal(deal, t, cache):
s = TornadoServer.get_instance()
print "process order deal %i" % deal.id
order = None
try:
order = deal.order2
except:
print "i cant find order %i" % deal.order2_id
deal.status = "core_error"
deal.save()
return
try:
Title = order.trade_pair.url_title
s.keys4delete.append("balance_" + str(order.user_id))
s.keys4delete.append("sell_list_" + Title)
s.keys4delete.append("deals_list_" + Title)
Account = Accounts.objects.get(user_id=order.user_id,
currency_id=order.currency2_id)
add_trans(order.transit_2, deal.amnt, order.currency2, Account, order,
"deal", str(deal.order1_id))
add_trans(Account, deal.amnt * Decimal("0.0005"), order.currency2,
order.transit_2, order, "comission", str(deal.order1_id))
if order.sum1 / order.sum1_history < 0.0001:
order.status = 'processed'
order.save()
deal.trade_pair_id = order.trade_pair.id
deal.user2_id = order.user_id
deal.user1_id = deal.order1.user_id
deal.status = "processed"
deal.save()
except:
deal.status = "core_error"
deal.save()
delete_user_state(order.user_id, cache)
try:
session = cache.get("user_" + str(order.user_id))
if not session is None:
s.keys4delete.append("balance_" + session)
# cache.delete("session_"+str(order.user_id), t, 60000)
except:
traceback.print_exc()
def confirm_withdraw_liqpay(Req, S):
Transfer = LiqPayTrans.objects.get(user = Req.user,
status = "created",
confirm_key = S)
liqpay_class = liqpay("ru", Transfer.currency.title)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3) :
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
##add trans may be there
AccountTo = Accounts.objects.get(user = Req.user, currency = Transfer.currency)
## if not by reference, but by users
TradePair = liqpay_class.get_traid_pair()
order = Orders( user = Req.user,
currency1 = Transfer.currency,
currency2 = Transfer.currency,
sum1_history = Transfer.amnt,
sum2_history = Transfer.amnt,
sum1 = Transfer.amnt,
sum2 = Transfer.amnt,
transit_1 = AccountTo,
transit_2 = TradePair.transit_from ,
trade_pair = TradePair,
status = "created"
)
order.save()
add_trans(AccountTo, Transfer.amnt, Transfer.currency, TradePair.transit_from,
order, "withdraw", S, True)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.status = "processing"
Transfer.save()
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
caching().delete("balance_" + str(Req.user.id) )
return tmpl_context(Req, t, Dict)
def get(self, order_id):
start = time.time()
order = Orders.objects.get(id=order_id, status="created")
s = TornadoServer.get_instance()
try:
with transaction.atomic():
FromAccount = Accounts.objects.get(user=order.user,
currency=order.currency1)
add_trans(FromAccount, order.sum1_history, order.currency1,
order.transit_1, order, "deposit")
order.status = "processing"
order.save()
cache = caching()
try:
i = order.user_id
s.keys4delete.append("balance_" + str(i))
delete_user_state(i, start)
print "got trans from %i" % i
Title = order.trade_pair.url_title
CachedKey1 = 'client_orders_' + str(i) + "_" + Title
CachedKey2 = 'balance_' + str(i)
s.keys4delete.append(CachedKey1)
s.keys4delete.append(CachedKey2)
s.keys4delete.append("buy_list_" + Title)
s.keys4delete.append("sell_list_" + Title)
except:
traceback.print_exc()
print "problem in working with cache"
end = time.time()
print "add trans timing"
print end - start
self.write({"status": True, "time": end - start})
except:
traceback.print_exc()
order.status = "core_error"
print "add trans timing"
end = time.time()
print end - start
order.save()
self.set_status(500)
def confirm_withdraw_liqpay(Req, S):
Transfer = LiqPayTrans.objects.get(user=Req.user,
status="created",
confirm_key=S)
liqpay_class = liqpay("ru", Transfer.currency.title)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
##add trans may be there
AccountTo = get_account(user=Req.user, currency=Transfer.currency)
## if not by reference, but by users
TradePair = liqpay_class.get_traid_pair()
order = Orders(user=Req.user,
price=Decimal("1"),
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
sum2=Transfer.amnt,
transit_1=AccountTo.acc(),
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created"
)
order.save()
add_trans(AccountTo.acc(), Transfer.amnt, Transfer.currency, TradePair.transit_from,
order, "withdraw", S, False)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.status = "processing"
Transfer.save()
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
caching().delete("balance_" + str(Req.user.id))
return tmpl_context(Req, t, Dict)
def process_out(CurrencyTitle):
Crypton = CryptoAccount(CurrencyTitle, "trade_stock")
user_system = User.objects.get(id = 1)
CurrencyInstance = Currency.objects.get(title = CurrencyTitle)
if not check_crypto_currency(CurrencyInstance) :
raise LockBusyException("global check crypto currency has raised")
#sys.exit(0)
getcontext().prec = crypton.settings.TRANS_PREC
for obj in CryptoTransfers.objects.filter(status="processing",
debit_credit ="out",
currency = CurrencyInstance):
print "sending funds of %s to %s amount %s" % (obj.user.username, obj.account, obj.amnt)
obj.status = "processed"
obj.user_accomplished = user_system
obj.save()
obj.order.status = "processed"
obj.order.save()
Txid = None
try:
InnerAccount = Accounts.objects.get( reference = obj.account )
Txid = "Move between accounts"
add_trans( obj.order.transit_1 , obj.order.sum1, obj.order.currency1,
InnerAccount, order,
"payin", None )
except Accounts.DoesNotExist:
Txid = Crypton.sendto(obj.account, float(obj.amnt))
print "txid %s" % (Txid)
obj.crypto_txid = Txid
obj.save()
notify_email(obj.user, "withdraw_notify", obj)
def confirm_withdraw_bank(Req, S):
Transfer = BankTransfers.objects.get(user=Req.user, status="created", confirm_key=S)
##add trans may be there
AccountTo = get_account(user=Req.user, currency=Transfer.currency)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 2):
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
## if not by reference, but by users
TradePair = TradePairs.objects.get(url_title="bank_transfers")
order = Orders(user=Req.user,
price=Decimal("1"),
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
sum2=Transfer.amnt,
transit_1=AccountTo.acc(),
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created"
)
order.save()
# TODO add process exception in withdraw crypto currency
add_trans(AccountTo.acc(), Transfer.amnt, Transfer.currency,
TradePair.transit_from, order, "withdraw", S, False)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.status = "processing"
Transfer.save()
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
return tmpl_context(Req, t, Dict)
def confirm_withdraw_bank(Req, S):
Transfer = BankTransfers.objects.get(user=Req.user, status="created", confirm_key=S)
##add trans may be there
AccountTo = Accounts.objects.get(user=Req.user, currency=Transfer.currency)
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 2):
Response = HttpResponse('{"status":false}')
Response["Content-Type"] = "application/json"
return Response
## if not by reference, but by users
TradePair = TradePairs.objects.get(url_title="bank_transfers")
order = Orders(
user=Req.user,
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
sum2=Transfer.amnt,
transit_1=AccountTo,
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created",
)
order.save()
# TODO add process exception in withdraw crypto currency
add_trans(AccountTo, Transfer.amnt, Transfer.currency, TradePair.transit_from, order, "withdraw", S, True)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.status = "processing"
Transfer.save()
t = loader.get_template("ajax_simple_msg.html")
Dict = {}
Dict["title"] = settings.withdraw_ok
Dict["simple_msg"] = settings.withdraw_msg_ok
return tmpl_context(Req, t, Dict)
def __inner_remove_order(Order2Remove):
if Order2Remove.trade_pair.status != 'processing':
return False
s = TornadoServer.get_instance()
start = time.time()
count_up = Orders.objects.filter(
id=Order2Remove.id, status="canceling").update(status='canceled')
if count_up < 1:
return False
Title = Order2Remove.trade_pair.url_title
i = Order2Remove.user.id
delete_user_state(i, start)
CachedKey1 = 'client_orders_' + str(i) + "_" + Title
CachedKey2 = 'balance_' + str(i)
s.keys4delete.append(CachedKey1)
s.keys4delete.append(CachedKey2)
s.keys4delete.append("buy_list_" + Title)
s.keys4delete.append("sell_list_" + Title)
Account = Accounts.objects.get(user=Order2Remove.user,
currency=Order2Remove.currency1)
add_trans(Order2Remove.transit_1, Order2Remove.sum1,
Order2Remove.currency1, Account, Order2Remove, "order_cancel")
def process_order(AccountBuyer, ComisBuy, AccumSum, AccumSumToSell, item,
Order, TradePair, ComisSell):
##TODO move to settings for every user
ComisPercentSeller = item.comission
ComisPercentBuyer = Order.comission
if item.sum1 > AccumSum:
## a danger of low overflow
Diff = AccumSum / item.sum1
TransSum = item.sum2 * Diff
#TransSum = AccumSumToSell
AccountSeller = get_account(item.user, item.currency2)
add_trans(item.transit_2,
TransSum,
item.currency2,
AccountSeller,
item,
"deal",
Out_order_id=Order.id)
add_trans(AccountSeller,
TransSum * ComisPercentSeller,
item.currency2,
ComisSell,
item,
"comission",
Out_order_id=Order.id)
add_trans(item.transit_1,
AccumSum,
item.currency1,
AccountBuyer,
item,
"deal",
Out_order_id=Order.id)
add_trans(AccountBuyer,
AccumSum * ComisPercentBuyer,
item.currency1,
ComisBuy,
Order,
"comission",
Out_order_id=Order.id)
##comission
item.sum1 = item.sum1 - AccumSum
item.sum2 = item.sum2 - TransSum
item.save()
try:
system_notify(
order_description_sell(AccumSum, TransSum, item, TradePair),
AccountSeller.user)
system_notify(
order_description_buy(TransSum, AccumSum, Order, item,
TradePair), AccountBuyer.user)
except:
pass
return (0, AccumSumToSell - TransSum)
if item.sum1 <= AccumSum:
TransSum = item.sum2
NotifySum = item.sum1
AccountSeller = get_account(item.user, item.currency2)
add_trans(item.transit_2,
TransSum,
item.currency2,
AccountSeller,
item,
"deal",
Out_order_id=Order.id)
add_trans(AccountSeller,
TransSum * ComisPercentSeller,
item.currency2,
ComisSell,
item,
"comission",
Out_order_id=Order.id)
add_trans(item.transit_1,
NotifySum,
item.currency1,
AccountBuyer,
item,
"deal",
Out_order_id=Order.id)
add_trans(AccountBuyer,
NotifySum * ComisPercentBuyer,
item.currency1,
ComisBuy,
Order,
"comission",
Out_order_id=Order.id)
##comission
item.status = "processed"
item.sum1 = 0
item.sum2 = 0
item.save()
try:
system_notify(
order_description_sell(NotifySum, TransSum, item, TradePair),
AccountSeller.user)
system_notify(
order_description_buy(TransSum, NotifySum, Order, item,
TradePair), AccountBuyer.user)
system_notify(order_finish(item), AccountSeller.user)
except:
pass
return (AccumSum - NotifySum, AccumSumToSell - TransSum)
def api_callback_pay(self, Params):
PublicKey = Params["public_key"]
Amount = Params["amount"]
CurrencyStr = Params["currency"]
Desc = Params["description"]
Type = Params["type"]
OrderId = Params["order_id"]
Status = Params["status"]
OutOrderId = Params["transaction_id"]
Phone = Params["sender_phone"]
Signature = Params["signature"]
Comission = Decimal(Params["receiver_commission"])
m = hashlib.sha1(self.__private_key +
Amount +
CurrencyStr +
self.__public_key +
OrderId +
self.__type +
self.__description +
Status +
OutOrderId +
Phone
)
signature = b64encode( m.digest() )
if signature != Signature:
raise TransError("Invalid Signature")
if Status == "failure":
order = Orders.objects.get( id = int(OrderId) )
order.status = "order_cancel"
order.save()
Response = HttpResponse( json.JSONEncoder().encode({"status":True,"signature":True}) )
Response['Content-Type'] = 'application/json'
return Response
if Status == "wait_secure":
order = Orders.objects.get( id = int(OrderId), status="created" )
order.status = "wait_secure"
order.save()
Response = HttpResponse( json.JSONEncoder().encode({"status":True,"signature":True}) )
Response['Content-Type'] = 'application/json'
return Response
##TODO add system message
if Status == "success":
order = Orders.objects.get(id = int(OrderId) )
if order.status !="created" and order.status !="wait_secure":
raise TransError("Invalid order")
order.status="processing"
order.save()
from main.models import check_holds
check_holds(order)
DebCred = LiqPayTrans( phone = Phone,
description = Desc,
#pib = ,
currency = self.__currency,
amnt = Decimal(Amount) ,
user = order.user,
pub_date = datetime.now(),
comission = self.__comis,
user_accomplished_id = 1,
status = "processed",
debit_credit = "in",
confirm_key = Signature,
order = order
)
DebCred.sign_record(self.__private_key)
DebCred.save()
add_trans(order.transit_1 , order.sum1, self.__currency,
order.transit_2, order,
"payin", DebCred.id, False)
#hack if privat is wrong
HackComis = order.sum1 * self.__comis
if Comission < HackComis:
Comission = HackComis
add_trans( order.transit_2 , Comission, self.__currency,
order.transit_1, order,
"comission", OutOrderId, False)
order.status = "processed"
order.save()
notify_email(order.user, "deposit_notify", DebCred )
Response = HttpResponse( json.JSONEncoder().encode({"status":True,"signature":True}) )
Response['Content-Type'] = 'application/json'
return Response
if Status == "sandbox":
raise TransError("hacker ")
order = Orders.objects.get(id = int(OrderId), status = "created")
order.status="processing"
order.save()
check_holds(order)
add_trans(order.transit_1, order.sum1, self.__currency,
order.transit_2, order, "payin", OutOrderId, False )
#Comission = order.sum1 * self.__comis
add_trans( order.transit_2, Comission , self.__currency,
order.transit_1, order,
"comission", OutOrderId, False)
DebCred = LiqPayTrans(
phone = Phone,
description = Desc,
currency = self.__currency,
amnt = Decimal(Amount) ,
user = order.user ,
pub_date = datetime.now(),
comission = self.__comis,
user_accomplished_id = 1,
status = "processed",
debit_credit = "in",
confirm_key = Signature,
order = order
)
DebCred.save()
order.status = "processed"
order.save()
Response = HttpResponse( json.JSONEncoder().encode({"status":True,"signature":True}) )
Response['Content-Type'] = 'application/json'
return Response
def p2p_transfer_withdraw_common_operation(Req, Form):
Key = generate_key("p2p_ahuihui")
CardNumber = Form.cleaned_data["CardNumber"]
CardNumber = CardNumber.replace(" ", "")
Amnt = Form.cleaned_data["amnt"]
NewAmnt = get_comisP2P(CardNumber, Decimal(Amnt))
Transfer = None
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response["Content-Type"] = "application/json"
return Response
if NewAmnt < 0:
Transfer = CardP2PTransfers(
debit_credit="out",
CardName=Form.cleaned_data["CardName"],
CardNumber=CardNumber,
currency=Form.currency_instance,
amnt=Amnt,
pub_date=datetime.datetime.now(),
user=Req.user,
confirm_key=Key,
status="processing2",
)
Transfer.sign_record(settings.COMMON_SALT)
if NewAmnt > 0:
Transfer = CardP2PTransfers(
debit_credit="out",
CardName=Form.cleaned_data["CardName"],
CardNumber=CardNumber,
currency=Form.currency_instance,
amnt=Amnt,
pub_date=datetime.datetime.now(),
user=Req.user,
confirm_key=Key,
status="auto",
)
Transfer.sign_record(settings.COMMON_SALT)
AccountTo = Accounts.objects.get(user=Req.user, currency=Transfer.currency)
## if not by reference, but by users
TradePair = TradePairs.objects.get(url_title="p2p_transfers")
order = Orders(
user=Req.user,
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
sum2=Transfer.amnt,
transit_1=AccountTo,
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created",
)
order.save()
# TODO add process exception in withdraw p2p
add_trans(AccountTo, Transfer.amnt, Transfer.currency, TradePair.transit_from, order, "withdraw", Key, True)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.save()
notify_admin_withdraw(withdraw_p2p_auto(Transfer))
send_mail(
_(u"Подтверждение вывода ") + settings.BASE_HOST,
confirm_p2p_withdraw_email_common(Form.cleaned_data, Key),
settings.EMAIL_HOST_USER,
[Req.user.email],
fail_silently=False,
)
def p2p_transfer_withdraw_common_operation(Req, Form):
Key = generate_key("p2p_ahuihui")
CardNumber = Form.cleaned_data["CardNumber"]
CardNumber = CardNumber.replace(" ", "")
Amnt = Form.cleaned_data["amnt"]
NewAmnt = get_comisP2P(CardNumber, Decimal(Amnt))
Transfer = None
FreqKey = "orders" + str(Req.user.id)
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
if NewAmnt < 0:
Transfer = CardP2PTransfers(
debit_credit="out",
CardName=Form.cleaned_data["CardName"],
CardNumber=CardNumber,
currency=Form.currency_instance,
amnt=Amnt,
pub_date=datetime.datetime.now(),
user=Req.user,
confirm_key=Key,
status="processing2")
Transfer.sign_record(settings.COMMON_SALT)
if NewAmnt > 0:
Transfer = CardP2PTransfers(
debit_credit="out",
CardName=Form.cleaned_data["CardName"],
CardNumber=CardNumber,
currency=Form.currency_instance,
amnt=Amnt,
pub_date=datetime.datetime.now(),
user=Req.user,
confirm_key=Key,
status="auto"
)
Transfer.sign_record(settings.COMMON_SALT)
AccountTo = get_account(user=Req.user, currency=Transfer.currency)
## if not by reference, but by users
TradePair = TradePairs.objects.get(url_title="p2p_transfers")
order = Orders(user=Req.user,
price=Decimal("1"),
currency1=Transfer.currency,
currency2=Transfer.currency,
sum1_history=Transfer.amnt,
sum2_history=Transfer.amnt,
sum1=Transfer.amnt,
sum2=Transfer.amnt,
transit_1=AccountTo.acc(),
transit_2=TradePair.transit_from,
trade_pair=TradePair,
status="created"
)
order.save()
# TODO add process exception in withdraw p2p
add_trans(AccountTo.acc(), Transfer.amnt, Transfer.currency, TradePair.transit_from,
order, "withdraw", Key, False)
order.status = "processing"
order.save()
Transfer.order = order
Transfer.save()
notify_admin_withdraw(withdraw_p2p_auto(Transfer))
send_mail(_(u'Подтверждение вывода ') + settings.BASE_HOST,
confirm_p2p_withdraw_email_common(Form.cleaned_data, Key),
[Req.user.email],
fail_silently=False)
def process_order(AccountBuyer, ComisBuy, AccumSum, AccumSumToSell, item, Order, TradePair, ComisSell ):
##TODO move to settings for every user
ComisPercentSeller = item.comission
ComisPercentBuyer = Order.comission
if item.sum1 > AccumSum :
## a danger of low overflow
Diff = AccumSum / item.sum1
TransSum = item.sum2*Diff
#TransSum = AccumSumToSell
AccountSeller = get_account(item.user, item.currency2)
add_trans(item.transit_2,
TransSum,
item.currency2,
AccountSeller,
item,
"deal",
Out_order_id = Order.id
)
add_trans(AccountSeller ,
TransSum*ComisPercentSeller,
item.currency2,
ComisSell,
item,
"comission",
Out_order_id = Order.id
)
add_trans(item.transit_1,
AccumSum,
item.currency1,
AccountBuyer,
item,
"deal",
Out_order_id = Order.id
)
add_trans(AccountBuyer,
AccumSum*ComisPercentBuyer,
item.currency1,
ComisBuy,
Order,
"comission",
Out_order_id = Order.id)
##comission
item.sum1 = item.sum1 - AccumSum
item.sum2 = item.sum2 - TransSum
item.save()
try:
system_notify(order_description_sell(AccumSum, TransSum, item, TradePair), AccountSeller.user)
system_notify(order_description_buy(TransSum, AccumSum, Order, item, TradePair), AccountBuyer.user)
except :
pass
return (0, AccumSumToSell - TransSum )
if item.sum1 <= AccumSum :
TransSum = item.sum2
NotifySum = item.sum1
AccountSeller = get_account(item.user, item.currency2)
add_trans(item.transit_2,
TransSum,
item.currency2,
AccountSeller,
item,
"deal",
Out_order_id = Order.id)
add_trans(AccountSeller ,
TransSum*ComisPercentSeller,
item.currency2,
ComisSell,
item,
"comission",
Out_order_id = Order.id)
add_trans(item.transit_1,
NotifySum,
item.currency1,
AccountBuyer,
item,
"deal",
Out_order_id = Order.id)
add_trans(AccountBuyer,
NotifySum*ComisPercentBuyer,
item.currency1,
ComisBuy,
Order,
"comission",
Out_order_id = Order.id)
##comission
item.status = "processed"
item.sum1 = 0
item.sum2 = 0
item.save()
try :
system_notify(order_description_sell(NotifySum, TransSum, item, TradePair), AccountSeller.user)
system_notify(order_description_buy(TransSum, NotifySum, Order, item, TradePair), AccountBuyer.user)
system_notify(order_finish(item), AccountSeller.user)
except :
pass
return (AccumSum - NotifySum, AccumSumToSell - TransSum )
def buy(Req, Trade_pair):
FreqKey = "orders" + str(Req.user.id)
Start = time.time()
if not check_freq(FreqKey, 3) :
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
getcontext().prec = settings.TRANS_PREC
try :
Count = Req.REQUEST.get("count")
Price = Req.REQUEST.get("price")
Count = Decimal( Count.replace(",",".").strip() )
Price = Decimal( Price.replace(",",".").strip() )
Count = to_prec(Count, settings.TRANS_PREC )
Price = to_prec(Price, settings.TRANS_PREC )
except:
Response = HttpResponse(process_mistake(Req, "invalid_params"))
Response['Content-Type'] = 'application/json'
return Response
if Price <= 0:
Response = HttpResponse(process_mistake(Req, "SumLess0"))
Response['Content-Type'] = 'application/json'
return Response
if Count<=0:
Response = HttpResponse(process_mistake(Req, "CountLess0"))
Response['Content-Type'] = 'application/json'
return Response
TradePair = TradePairs.objects.get(url_title = Trade_pair)
LOCK = "trades" + TradePair.url_title
if TradePair.min_trade_base > Count:
Response = HttpResponse(process_mistake(Req, "MinCount"))
Response['Content-Type'] = 'application/json'
return Response
Custom = "0.0005"# Req.session["deal_comission"]
Comission = Decimal(Custom)
CurrencyOnS = Req.REQUEST.get("currency")
CurrencyBaseS = Req.REQUEST.get("currency1")
Amnt1 = Price * Count
Amnt2 = Count
CurrencyBase = Currency.objects.get(title = CurrencyBaseS )
CurrencyOn = Currency.objects.get(title = CurrencyOnS )
TradeLock = my_lock(LOCK)
order = Orders(user = Req.user,
currency1 = CurrencyBase,
currency2 = CurrencyOn,
price = Price,
sum1_history = Amnt1,
sum2_history = Amnt2,
sum1 = Amnt1,
sum2 = Amnt2,
transit_1 = TradePair.transit_from,
transit_2 = TradePair.transit_on,
trade_pair = TradePair,
comission = Comission
)
order.save()
try:
FromAccount = Accounts.objects.get(user = Req.user, currency = CurrencyBase)
add_trans(FromAccount, Amnt1, CurrencyBase, TradePair.transit_from, order, "deposit")
order.status = "processing"
order.save()
system_notify(deposit_funds(order), Req.user)
ResAuto = make_auto_trade(order, TradePair, order.price, CurrencyBase, Amnt1, CurrencyOn, Amnt2)
Response = HttpResponse(process_auto(Req, ResAuto, TradePair))
my_release(TradeLock)
Response['Content-Type'] = 'application/json'
End = time.time()
measure = OrderTimer(order = order,time_work = str(End - Start))
measure.save()
return Response
except TransError as e:
order.status = "canceled"
order.save()
Status = e.value
Response = HttpResponse(process_mistake(Req, Status))
Response['Content-Type'] = 'application/json'
my_release(TradeLock)
End = time.time()
measure = OrderTimer(order = order,time_work = str(End - Start))
measure.save()
return Response
def buy(Req, Trade_pair):
FreqKey = "orders" + str(Req.user.id)
Start = time.time()
if not check_freq(FreqKey, 3):
Response = HttpResponse('{"status":false}')
Response['Content-Type'] = 'application/json'
return Response
getcontext().prec = settings.TRANS_PREC
try:
Count = Req.REQUEST.get("count")
Price = Req.REQUEST.get("price")
Count = Decimal(Count.replace(",", ".").strip())
Price = Decimal(Price.replace(",", ".").strip())
Count = to_prec(Count, settings.TRANS_PREC)
Price = to_prec(Price, settings.TRANS_PREC)
except:
Response = HttpResponse(process_mistake(Req, "invalid_params"))
Response['Content-Type'] = 'application/json'
return Response
if Price <= 0:
Response = HttpResponse(process_mistake(Req, "SumLess0"))
Response['Content-Type'] = 'application/json'
return Response
if Count <= 0:
Response = HttpResponse(process_mistake(Req, "CountLess0"))
Response['Content-Type'] = 'application/json'
return Response
TradePair = TradePairs.objects.get(url_title=Trade_pair)
LOCK = "trades" + TradePair.url_title
if TradePair.min_trade_base > Count:
Response = HttpResponse(process_mistake(Req, "MinCount"))
Response['Content-Type'] = 'application/json'
return Response
Custom = "0.0005" # Req.session["deal_comission"]
Comission = Decimal(Custom)
CurrencyOnS = Req.REQUEST.get("currency")
CurrencyBaseS = Req.REQUEST.get("currency1")
Amnt1 = Price * Count
Amnt2 = Count
CurrencyBase = Currency.objects.get(title=CurrencyBaseS)
CurrencyOn = Currency.objects.get(title=CurrencyOnS)
TradeLock = my_lock(LOCK)
order = Orders(user=Req.user,
currency1=CurrencyBase,
currency2=CurrencyOn,
price=Price,
sum1_history=Amnt1,
sum2_history=Amnt2,
sum1=Amnt1,
sum2=Amnt2,
transit_1=TradePair.transit_from,
transit_2=TradePair.transit_on,
trade_pair=TradePair,
comission=Comission)
order.save()
try:
FromAccount = Accounts.objects.get(user=Req.user,
currency=CurrencyBase)
add_trans(FromAccount, Amnt1, CurrencyBase, TradePair.transit_from,
order, "deposit")
order.status = "processing"
order.save()
system_notify(deposit_funds(order), Req.user)
ResAuto = make_auto_trade(order, TradePair, order.price, CurrencyBase,
Amnt1, CurrencyOn, Amnt2)
Response = HttpResponse(process_auto(Req, ResAuto, TradePair))
my_release(TradeLock)
Response['Content-Type'] = 'application/json'
End = time.time()
measure = OrderTimer(order=order, time_work=str(End - Start))
measure.save()
return Response
except TransError as e:
order.status = "canceled"
order.save()
Status = e.value
Response = HttpResponse(process_mistake(Req, Status))
Response['Content-Type'] = 'application/json'
my_release(TradeLock)
End = time.time()
measure = OrderTimer(order=order, time_work=str(End - Start))
measure.save()
return Response
def buy(Req, Trade_pair):
getcontext().prec = settings.TRANS_PREC
try :
Count = Req.REQUEST.get("count")
Price = Req.REQUEST.get("price")
Count = Decimal( Count.replace(",",".").strip() )
Price = Decimal( Price.replace(",",".").strip() )
Count = to_prec(Count, settings.TRANS_PREC )
Price = to_prec(Price, settings.TRANS_PREC )
except:
Response = HttpResponse(process_mistake(Req, "invalid_params"))
Response['Content-Type'] = 'application/json'
return Response
if Price <= 0:
Response = HttpResponse(process_mistake(Req, "SumLess0"))
Response['Content-Type'] = 'application/json'
return Response
if Count<=0:
Response = HttpResponse(process_mistake(Req, "CountLess0"))
Response['Content-Type'] = 'application/json'
return Response
TradePair = TradePairs.objects.get(url_title = Trade_pair)
if TradePair.min_trade_base > Count:
Response = HttpResponse(process_mistake(Req, "MinCount"))
Response['Content-Type'] = 'application/json'
return Response
CurrencyOnS = Req.REQUEST.get("currency")
CurrencyBaseS = Req.REQUEST.get("currency1")
Amnt1 = Price * Count
Amnt2 = Count
CurrencyBase = Currency.objects.get(title = CurrencyBaseS )
CurrencyOn = Currency.objects.get(title = CurrencyOnS )
order = Orders(user = Req.user,
currency1 = CurrencyBase,
currency2 = CurrencyOn,
price = Price,
sum1_history = Amnt1,
sum2_history = Amnt2,
sum1 = Amnt1,
sum2 = Amnt2,
transit_1 = TradePair.transit_from,
transit_2 = TradePair.transit_on,
trade_pair = TradePair
)
order.save()
try:
FromAccount = Accounts.objects.get(user = Req.user, currency = CurrencyBase)
add_trans(FromAccount, Amnt1, CurrencyBase, TradePair.transit_from, order, "deposit")
order.status = "processing"
order.save()
system_notify(deposit_funds(order), Req.user)
ResAuto = make_auto_trade(order, TradePair, order.price, CurrencyBase, Amnt1, CurrencyOn, Amnt2)
Response = HttpResponse(process_auto(Req, ResAuto, TradePair))
Response['Content-Type'] = 'application/json'
return Response
except TransError as e:
order.status = "canceled"
order.save()
Status = e.value
Response = HttpResponse(process_mistake(Req, Status))
Response['Content-Type'] = 'application/json'
return Response
