def return_rest2acc(Order, AccumSumToSell):
Account2Sell = get_account(user=Order.user, currency=Order.currency1)
add_trans2(Account2Sell,
AccumSumToSell,
Order,
"deal_return")
system_notify(order_return_unused(Order, Account2Sell.currency(), AccumSumToSell), Order.user)
def liqpay_transfer_withdraw(Req, CurrencyTitle, Amnt):
amnt = Decimal(Amnt)
if amnt < 10:
raise TransError("pay_requirments")
if CurrencyTitle != "UAH":
raise TransError("pay_requirments")
Dict = {}
CurrencyIn = Currency.objects.get(title=CurrencyTitle)
Account = get_account(user=Req.user, currency=CurrencyIn)
Acc = Account.acc()
if Acc.reference is None or len(Acc.reference) == 0:
Account.reference = generate_key(settings.BANK_KEY_SALT)
Account.save()
Dict["amnt"] = str(Amnt)
Dict["currency"] = "UAH"
try:
Last = LiqPayTrans.objects.filter(user=Req.user, status="processed").order_by('-id')[0]
Dict["phone"] = Last.phone
except:
pass
t = loader.get_template("ajax_form.html")
Dict["action"] = "/finance/liqpay_transfer_withdraw_submit"
Dict["action_title"] = settings.withdraw_transfer
Dict["common_help_text"] = settings.liqpay_attention_be_aware
Form = LiqPayTransferForm(initial=Dict, user=Req.user)
Dict["form"] = Form.as_p()
return tmpl_context(Req, t, Dict)
def liqpay_transfer_withdraw(Req, CurrencyTitle, Amnt):
amnt = Decimal(Amnt)
if amnt < 10:
raise TransError("pay_requirments")
if CurrencyTitle != "UAH":
raise TransError("pay_requirments")
Dict = {}
CurrencyIn = Currency.objects.get(title=CurrencyTitle)
Account = get_account(user=Req.user, currency=CurrencyIn)
if Account.reference is None or len(Account.reference) == 0:
Account.reference = generate_key(settings.BANK_KEY_SALT)
Account.save()
Dict["amnt"] = str(Amnt)
Dict["currency"] = "UAH"
try:
Last = LiqPayTrans.objects.filter(user=Req.user, status="processed").order_by('-id')[0]
Dict["phone"] = Last.phone
except:
pass
t = loader.get_template("ajax_form.html")
Dict["action"] = "/finance/liqpay_transfer_withdraw_submit"
Dict["action_title"] = settings.withdraw_transfer
Dict["common_help_text"] = settings.liqpay_attention_be_aware
Form = LiqPayTransferForm(initial=Dict, user=Req.user)
Dict["form"] = Form.as_p()
return tmpl_context(Req, t, Dict)
def __inner_remove_order(Order, User):
Order2Remove = OrdersMem.objects.get(user=User.id, id=int(Order), status="processing")
if not Order2Remove.verify(str(User.id)) :
return False
Market = TradePairs.objects.get(id=Order2Remove.trade_pair)
Order2Remove.status = "canceled"
Order2Remove.save()
Title = Market.url_title
LOCK = "trades" + Title
TradeLock = my_lock(LOCK)
try:
Account = get_account(user=User, currency_id=Order2Remove.currency1)
add_trans2(Account,
Order2Remove.sum1,
Order2Remove.currency1,
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 client_orders(Req, User_id, Title):
Dict = {}
Current = None
try:
Current = TradePairs.objects.get(url_title=Title)
except:
return json_false500(Req)
Dict["auth"] = True
MyOrders = OrdersMem.objects.fitler(user = User_id,
trade_pair = Current,
status='processing')
MyOrdersList = []
c = getcontext()
c.prec = settings.TRANS_PREC
for i in MyOrders:
MyOrdersDict = {}
MyOrdersDict["pub_date"] = formats.date_format(i.pub_date, "DATETIME_FORMAT")
MyOrdersDict["id"] = i.id
MyOrdersDict["sum1"] = str(i.sum1)
if i.currency1 == Current.currency_on.id:
MyOrdersDict["type"] = "sell"
MyOrdersDict["price"] = format_numbers10(i.price)
MyOrdersDict["amnt_trade"] = format_numbers10(i.sum1)
MyOrdersDict["amnt_base"] = format_numbers10(i.sum1*i.price)
else:
MyOrdersDict["type"] = "buy"
MyOrdersDict["price"] = format_numbers10(i.price)
MyOrdersDict["amnt_base"] = format_numbers10(i.sum1)
MyOrdersDict["amnt_trade"] = format_numbers10(i.sum1/i.price)
MyOrdersList.append(MyOrdersDict)
balance_sell = get_account(user_id=User_id, currency=Current.currency_on)
balance_buy = get_account(user_id=User_id, currency=Current.currency_from)
Dict["balance_buy"] = format_numbers_strong(balance_buy.balance)
Dict["balance_sell"] = format_numbers_strong(balance_sell.balance)
Dict["your_open_orders"] = MyOrdersList
RespJ = json.JSONEncoder().encode(Dict)
return RespJ
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,
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.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_emoney_withdraw_email(Form.cleaned_data, Key),
settings.EMAIL_HOST_USER,
[Req.user.email],
fail_silently=False)
def process_deal_order(item):
(Type, Trans, Market, Order) = item
From = Trans[1]
if Trans[3] == Market.currency_on.id:
# type sell
Comission = get_account(user_id=settings.COMISSION_USER,
currency_id=Market.currency_on.id)
add_fake_trans(Trans[0], Market.transit_on, -1 * Trans[2], Trans[3],
From, Order.id, 'deal')
add_fake_trans(Trans[0], From, -1 * Trans[0].comission, Trans[3],
Comission.acc(), Order.id, 'comission')
else:
Comission = get_account(user_id=settings.COMISSION_USER,
currency_id=Market.currency_from.id)
add_fake_trans(Trans[0], Market.transit_from, -1 * Trans[2], Trans[3],
From, Order.id, 'deal')
add_fake_trans(Trans[0], From, -1 * Trans[0].comission, Trans[3],
Comission.acc(), Order.id, 'comission')
print "process deal"
print "=" * 60
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 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(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.acc(), 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 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 p2p_deposit(Req, Cur, Amnt):
amnt = Decimal(Amnt)
if amnt < 1:
raise TransError("pay_requirments")
Dict = {}
t = loader.get_template("p2p_transfer_req.html")
CurrencyIn = Currency.objects.get(title=Cur)
Account = get_account(user=Req.user, currency=CurrencyIn)
Dict["account"] = P2P_DEPOSIT_OPTS[Cur]
if Account.reference is None or len(Account.reference) == 0:
Account.reference = generate_key("bank_pp", 16)
Account.save()
Dict["description"] = _(u"Оплата информационных услуг в счет публичного договора #" + Account.reference)
Dict["amnt"] = str(Amnt)
return tmpl_context(Req, t, Dict)
def p2p_deposit(Req, Cur, Amnt):
amnt = Decimal(Amnt)
if amnt < 1:
raise TransError("pay_requirments")
Dict = {}
t = loader.get_template("p2p_transfer_req.html")
CurrencyIn = Currency.objects.get(title=Cur)
Account = get_account(user=Req.user, currency=CurrencyIn)
Dict["account"] = P2P_DEPOSIT_OPTS[Cur]
Acc = Account.acc()
if Acc.acc().reference is None or len(Acc.acc().reference) == 0:
Account.reference = generate_key("bank_pp", 16)
Account.save()
Dict["description"] = _(u"Оплата информационных услуг в счет публичного договора #" + Acc.reference)
Dict["amnt"] = str(Amnt)
return tmpl_context(Req, t, Dict)
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 check_funds(self):
check = False
try:
amnt = Decimal(self.cleaned_data.get('amnt'))
except:
return False
## we must got mail
Account = get_account(currency=self.currency_instance,
user=self.__user)
if Account.get_balance < amnt:
check = True
else:
self.__balance = Account.get_balance
check = False
if check:
raise forms.ValidationError(_(u"Недостаточно средств"))
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,
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.acc(), 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 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 = 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,
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, 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 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,
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()
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_sell(AccountSeller, AccumSumToSell, OrderBuy, OrderSell, TradePair):
## TODO move to settings for every user
logging.debug("=========================================================================================")
logging.debug(OrderSell)
logging.debug("%s" % (AccumSumToSell))
logging.debug(OrderBuy)
logging.debug("=========================================================================================")
if not item.verify(str(OrderBuy.user)):
logging.debug("Sign FAILED %s" % str(OrderBuy))
return AccumSumToSell
# 7000/3600 = 1.9 BTC
OrderBuySum = OrderBuy.sum1/OrderBuy.price
if OrderBuySum > AccumSumToSell:
## a danger of low overflow
TransSum = AccumSumToSell*OrderBuy.price
AccountBuyer = get_account(user=OrderBuy.user, currency=OrderSell.currency1)
##comission
add_trans2(AccountBuyer,
AccumSumToSell*-1,
OrderSell.currency1,
OrderSell,
"deal")
add_trans2(AccountSeller,
TransSum*-1,
OrderBuy.currency1,
OrderBuy,
"deal")
try:
system_notify_async(order_description_sell(AccumSum, TransSum, OrderBuy, TradePair),
AccountSeller.get_user())
system_notify_async(order_description_buy(TransSum, AccumSum, Order, item, TradePair),
AccountBuyer.get_user())
except:
logging.info("something gooing wrong with notification")
pass
OrderBuy.make2processed()
return 0
if OrderBuySum <= AccumSumToSell:
TransSum = OrderBuy.sum1
AccountBuyer = get_account(user=OrderBuy.user, currency=OrderSell.currency1)
##comission
add_trans2(AccountBuyer,
OrderBuySum*-1,
OrderSell.currency1,
OrderSell,
"deal")
add_trans2(AccountSeller,
TransSum*-1,
OrderBuy.currency1,
OrderBuy,
"deal")
try:
system_notify_async(order_description_sell(NotifySum, TransSum, item, TradePair), AccountSeller.get_user())
system_notify_async(order_description_buy(TransSum, NotifySum, Order, item, TradePair),
AccountBuyer.get_user())
system_notify_async(order_finish(item), AccountSeller.get_user())
except:
logging.info("somthing gooing wrong with notification")
pass
return AccumSumToSell - OrderBuySum
def make_auto_trade(OrderSell, TradePair, Price, Currency1, Sum1, Currency2):
# if we sell
# Query = "SELECT * FROM main_ordersmem WHERE trade_pair_id=%i" % (TradePair.id)
if int(TradePair.currency_on.id) == int(Currency1.id):
Query = "SELECT * FROM main_ordersmem WHERE currency1=%i AND trade_pair.id=%i \
AND status='processing' AND price >= %s \
AND user!=%i ORDER BY price DESC, id DESC" % (Currency2.id,
TradePair.id,
format_numbers_strong(Price), OrderSell.user)
else:
Query = "SELECT * FROM main_ordersmem WHERE currency1=%i AND trade_pair=%i \
AND status='processing' AND price <= %s \
AND user!=%i ORDER BY price, id DESC " % (Currency2.id,
TradePair.id,
format_numbers_strong(Price), OrderSell.user )
List = OrdersMem.objects.raw(Query)
# ##work on first case
# CommissionSell = get_account(settings.COMISSION_USER, Currency1)
# ComnissionBuy = get_account(settings.COMISSION_USER, Currency2)
AccumSumToSell = Sum1
AccountBuyer = get_account(user_id=Order.user, currency_id=Currency2.id)
UserDeals = [int(Order.user)]
process_order = None
if TradePair.currency_on.id == Currency1.id :
process_order = lambda AccountBuyer, AccumSumToSell, OrderBuy, OrderSell, TradePair: process_order_sell(AccountBuyer, AccumSumToSell, OrderBuy, OrderSell, TradePair)
else:
process_order = lambda AccountBuyer, AccumSumToSell, OrderBuy, OrderSell, TradePair: process_order_buy(AccountBuyer, AccumSumToSell, OrderBuy, OrderSell, TradePair)
# TODO in case of exception block OrderSell and OrderBuy and interrupt the cycle
for OrderBuy in List:
UserDeals.append(int(OrderBy.user))
try :
AccumSumToSell = process_order(AccountBuyer, AccumSumToSell, OrderBuy, OrderSell, TradePair)
except TransError as e:
OrderBuy.status = "core_error"
OrderSell.status = "core_error"
OrderBuy.save()
OrderSell.save()
admin_system_notify_async((OrderBuy, OrderSell))
ResultSum = finish_create_order(TradePair, AccumSumToSell, OrderSell)
return {"start_sum": Sum1, "status":False, "last_sum": ResultSum, "users_bothered": UserDeals}
if AccumSumToSell > 0.00000001:
continue
else:
break
ResultSum = finish_create_order(TradePair, AccumSumToSell, OrderSell)
Order.sum1 = AccumSumToSell
if ResultSum < 0.00000001:
return_rest2acc(Order, AccumSumToSell)
Order.sum1 = 0
Order.make2processed()
else:
Order.save()
return {"start_sum": Sum1, "status":True, "last_sum": ResultSum, "users_bothered": UserDeals}
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 = OrdersMem(user=Req.user.id,
currency1=CurrencyBase.id,
sum1_history=Amnt1,
price=Price,
sum1=Decimal("0.0"),
trade_pair=TradePair.id,
comission=Comission,
status="created")
order.save()
i = order.id
try:
FromAccount = get_account(user=Req.user, currency=CurrencyBase)
system_notify_async(deposit_funds(order, CurrencyBase), Req.user.id)
# TODO Order to Encrypted object
add_trans2(FromAccount, Amnt1, CurrencyBase, order, "deposit")
order.status = "processing"
order.save()
ResAuto = make_auto_trade(order, TradePair, order.price, CurrencyBase, Amnt1, CurrencyOn)
Response = HttpResponse(process_auto(ResAuto, TradePair))
my_release(TradeLock)
Response['Content-Type'] = 'application/json'
End = time.time()
measure = OrderTimer(order=i, time_work=str(End - Start), error="")
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()
tb = traceback.format_exc()
measure = OrderTimer(order=i, time_work=str(End - Start), error=tb)
measure.save()
return Response
