def get_bals():
import db_client
abbrev = request.args(0)
out_res = {}
for r in db((db.currs.used == True)
& (db.currs.id == db.xcurrs.curr_id)
& (not abbrev or db.currs.abbrev == abbrev)).select(
orderby=~db.currs.uses):
free_bal = db_client.curr_free_bal(r.currs)
if abbrev:
return free_bal
out_res[r.currs.abbrev] = float(free_bal)
return request.extension == 'html' and dict(
h=DIV(BEAUTIFY(out_res), _class='container')) or out_res
def index():
#common.page_stats(db, response['view'])
#print request.args
response.title=T("Обмен биткоинов, догикоинов и других криптовалют между собой")
response.subtitle = T('Bitcoin Dogecoin Litecoin NEXT')
abbrev = request.args(0)
addr = request.args(1)
vol = request.args(2)
title = abbrev and addr and T('Ваш кошелек') + ': ' + abbrev + ' ' + addr[:5] + '***' + addr[-3:] or response.title
subtitle = session.date_log and (T('Дата посещения %s') % session.date_log) or response.subtitle
try:
session.date_log = request.now
except:
print 'to_coin session error .date_log:', type(request.now), request.now
if request.vars:
abberv = abbrev or request.vars.get('curr')
addr = addr or request.vars.get('addr')
vol = vol or request.vars.get('vol')
inp_currs = []
for r in db(
(db.currs.used == True)
& (db.currs.id == db.xcurrs.curr_id)
& (not abbrev or db.currs.abbrev == abbrev)
).select(orderby=~db.currs.uses):
free_bal = db_client.curr_free_bal(r.currs)
inp_currs.append([r.currs.id, r.currs.abbrev, r.currs.name, free_bal])
if len(inp_currs)==0:
return err_dict(
T('ОШИБКА: Нет доступных криптовалют для обмена')
+ (abbrev and (' ' + T('или неправильно задано имя [%s] нужной криптовалюты!') % abbrev) or ''))
return dict(title=title, subtitle=subtitle, inp_currs=inp_currs,
abbrev=abbrev, addr=addr, vol=vol)
def make_edealer_payment(db,
geted_pays,
curr_in,
xcurr,
curr_out,
ecurr,
vol_in,
volume_out,
deal_acc_addr,
rate,
order_stack_id=None,
dealer=None,
dealer_acc=None,
dealer_deal=None):
#print 'try payout rub:', vol_in, curr_in.abbrev, volume_out , curr_out.abbrev, deal_acc_addr.addr, '\n', geted_pays
# заодно проверим не занята ли база is loocked
# сейчас копим на счету услуги if volume_out>13:
# # но это не для мелких платежей
# log_commit( db, 'try payout: make_edealer_payment %s[%s] -> %s[%s] %s \n geted_pays: %s' % ( vol_in, curr_in.abbrev, volume_out, curr_out.abbrev, deal_acc_addr.addr, geted_pays))
#return
## проверим запасы - если есть ограничение по баласу то откажем в выплатах
max_bal = Decimal(curr_in.max_bal or 0)
##print 'types:', type(curr_in.balance), type(curr_in.deposit)
## float - Decimal - хотя в базе поле описано как ДЕЦИМАЛ
bal_dep = Decimal(curr_in.balance or 0) - Decimal(curr_in.deposit or 0)
if max_bal and max_bal > 0 and max_bal - bal_dep < 0: ##vol_in: тут уже в баланс упал вход
mark_pay_ins(
db, geted_pays, 'wait',
current.T('Превышен запас монет: %s + %s > %s') %
(bal_dep, vol_in, max_bal))
db.commit()
return
deal_acc = db.deal_accs[deal_acc_addr.deal_acc_id]
deal = db.deals[deal_acc.deal_id]
in_proc = random.randint(1, 99999)
desc = []
for id in geted_pays:
inp_stk = db.pay_ins_stack[id]
# запомним что мы обрабатываем этот вход
inp_stk.update_record(in_proc=in_proc)
inp_rec = db.pay_ins[inp_stk.ref_]
desc.append({'txid': inp_rec.txid, 'vout': inp_rec.vout})
# сохраним базу - чтобы все процессы видели что мы обрабатываем записи стека
db.commit()
#print 'make_edealer_payment', deal_acc.acc, volume_out, curr_out.abbrev, '%s' % desc
# теперь ждем чтобы записи в базк записались
# - так чтобы пораллельно их не обработали
sleep(1)
pay_error = None # если мы не заплатили то не вносить изменения баланса и пр
# если уже идет обработка стека то выход
# и она не наша
for id in geted_pays:
inp_stk = db.pay_ins_stack[id]
if inp_stk.in_proc and inp_stk.in_proc != in_proc:
# если этот вход в стеке уже вобработке то удалим его
# нет просто выход нажмем - чтобы не было свалки обработки входов
log(db, ' input_stack.in_proc == True : return')
return
print '\ntry payout:', vol_in, curr_in.abbrev, '-->', volume_out, curr_out.abbrev, deal_acc_addr.addr, '\n', 'geted_pays:', geted_pays
#log(db, '%s %s %s %s %s %s %s %s %s' % ('try payout:', vol_in, curr_in.abbrev, '-->', volume_out, curr_out.abbrev, deal_acc_addr.addr, ' - geted_pays:', geted_pays))
if ecurr:
MIN = deal.MIN_pay
else:
xcurr_out = db(db.xcurrs.curr_id == curr_out.id).select().first()
MIN = (xcurr_out.txfee or curr_out.fee_in or curr_out.fee_out) * 3
#log(db, 'volume_out %s, MIN %s' % (volume_out, MIN))
if volume_out <= 0 or MIN > 0 and volume_out < MIN:
print volume_out, ' <<< ', MIN
#Теперь добавляем к переплате на счет услуги
# так как в volume_out есть вычета абсолютные мзды то оно меньше нуля
if order_stack_id:
# если есть заказ на курс то по этому курсу
volume_out = vol_in * rate
print 'volume_out by ORDER', order_stack_id, rate, ' ->', volume_out
else:
# иначе возьмем просто по курсу без абсолютных добавок
if ecurr and not dealer_deal:
volume_out = vol_in * rate
# лимиты диллера не учитываем
dealer, dealer_acc, dealer_deal = ed_common.select_ed_acc(
db, deal, ecurr, volume_out, unlim=USE_UNLIM)
# и возьмем таксу без fee
# тут берем без учета что еще на нас начислит диллер за эту услугу (учет в ed_common.pay)
volume_out, _ = db_client.calc_fees(db,
deal,
dealer_deal_NONE,
curr_in,
curr_out,
vol_in,
rate,
is_order=None,
note=None,
only_tax=1)
print 'volume_out by TAX', volume_out
print 'add to_pay', volume_out
deal_acc.update_record(to_pay=(deal_acc.to_pay or 0) + volume_out)
pay_ins_recs = get_pay_ins_recs(db, geted_pays)
# и запомним на что потратили входы
for pay_in in pay_ins_recs:
## None pay_in.payout_id = pay_out_id
if pay_in.amount == vol_in:
volume_out_it = volume_out
else:
volume_out_it = round(
float(volume_out * pay_in.amount / vol_in), 8)
pay_in.status = 'added'
pay_in.status_mess = volume_out_it
## Njne еще не определили заказ pay_in.order_id = order_id # запомним использованный заказ
pay_in.update_record()
db.commit()
return
client = db(db.clients.deal_id == deal.id).select().first()
if client:
# это наш клиент- магазин, у него не делаем перебор
# и не делаем платеж вообще, а учитываем его просто в своей базе
print 'make_edealer_payment ist my CLIENT:', deal.id, 'client:', client
# здесь валюта выходя есть авлюта входа для клиента - так как он
# вообще не должен знать чем нам пользователь наш заплатил
clients_tran_id, client_bal = clients_lib.mem_input(
db, client, deal_acc.acc, volume_out, curr_out, '%s' % desc)
#mark_pay_ins(db, geted_pays, 'client', 'client_trans: %s' % clients_tran_id)
res = None
order_id = check_order(db, order_stack_id)
# и запомним на что потратили входы
# удалим все взятые входы крипты для этого вывода
# имеено ТУТ чтобы ошибки ниже уже не повлияли на ошибочный повторный вывод
# а то иногда ошибки ниже не дают запомнить что мы уже выплатили все тут
pay_ins_recs = get_pay_ins_recs(db, geted_pays)
for pay_in in pay_ins_recs:
print 'clients_tran_id:', clients_tran_id
pay_in.clients_tran_id = clients_tran_id
pay_in.status = 'ok'
pay_in.order_id = order_id # запомним использованный заказ
pay_in.update_record()
db.commit()
else:
# здесь выплаты только электронными деньгами
gift_amo = 0
if deal_acc.gift_amount and deal_acc.gift_amount > 0 and deal_acc.gift_pick > 0:
# если есть подарок у аккаунта то его включим
gift_amo = Decimal(deal_acc.gift_amount < deal_acc.gift_pick
and deal_acc.gift_amount or deal_acc.gift_pick)
##print type(Decimal(0.3)), type(volume_out)
if gift_amo > Decimal(0.3) * volume_out:
gift_amo = Decimal(0.3) * volume_out
rrr = random.randint(1, 100)
# вероятность берем
# сделаем случайны подарок - чем меньше сумма остатка тем меньше вероятность подарка
pick_ver = gifts_lib.pick_ver(deal_acc.gift_amount, gift_amo)
if rrr > int(pick_ver * 100):
gift_amo = 0
#print 'NOT lucky'
else:
# подарок выпал
deal_acc.gift_amount = deal_acc.gift_amount - gift_amo
deal_acc.gift_payed = deal_acc.gift_payed and deal_acc.gift_payed + gift_amo or gift_amo
#print 'gift_amo:', gift_amo
# проверим бонус патртнера - если он больше 100 то выплатим его
partner_sum = Decimal(deal_acc.partner_sum or 0)
if partner_sum: ## тут разные валюты и разные значения! and partner_sum > current.PARTNER_MIN:
#print 'PARTNER -> deal_acc.partner_sum:', partner_sum
deal_acc.partner_sum = 0
deal_acc.partner_payed = (deal_acc.partner_payed
or 0) + partner_sum
else:
# Сбросим а то оно прибавится ниже
partner_sum = 0
amo_to_pay = Decimal(deal_acc.to_pay or 0)
add_vol = gift_amo + partner_sum + amo_to_pay
volume_out_full = volume_out + add_vol
# тут ищем акккаунт с еще не превышенным лимитом на платежи и максим балансом среди разных диллеров
if ecurr:
# это фиат с аккаунтами разными у диллера
##dealer_acc = None ## тут могут добавиться на счету недоплаты! поэтому новый нужно выбрать счет диллера
if dealer_acc and dealer_acc.balance > volume_out_full:
print 'preselected dealer_acc:', dealer_acc.acc, dealer_acc.balance
else:
dealer, dealer_acc, dealer_deal = ed_common.select_ed_acc(
db, deal, ecurr, volume_out_full, unlim=USE_UNLIM)
if dealer_acc:
print 'select_ed_acc -> dealer_acc:', dealer_acc.acc, dealer_acc.balance
else:
mark_pay_ins(db, geted_pays, 'try',
(dealer and dealer.name or 'dealer=None') +
': dealer_acc not found')
db.commit()
print 'ERROR: make_edealer_payment - dealer_acc=', dealer_acc, 'deal id:', deal.id, 'ecurr id:', ecurr.id
return
balance = dealer_acc.balance
if not balance:
balance = ed_common.get_balance(dealer, dealer_acc)
if not balance or balance < 0:
mark_pay_ins(db, geted_pays, 'wait',
dealer.name + ': balance=None')
db.commit()
print 'ERROR: make_edealer_payment - not balance', dealer_acc
return
#print 'make_edealer_payment', dealer.name, ':', dealer_acc.acc, 'balance:', balance
###############################################################
# теперь надо посмотреть насколько превышен лимит платежа за месяц для этого аккаунта этого дела
if not deal_acc.payed_month_num or datetime.date.today(
).month != deal_acc.payed_month_num:
# если новый месяц то сбросим в ноль
deal_acc.payed_month_num = datetime.date.today().month
deal_acc.payed_month = 0
if deal.is_shop:
# для сайтов и обмена - без изменения величины оплаты так как там жесткая величина
over_turns = 0
else:
over_turns = (deal_acc.payed_month or 0) / (deal.MAX_pay
or 777)
if over_turns > 5:
volume_out_full = volume_out_full * Decimal(
0.98) # если превышение боле чем в 6 раза то 2% себе сразу
elif over_turns > 4:
volume_out_full = volume_out_full * Decimal(
0.99) # если превышение боле чем в 4 раза то 1% себе сразу
elif over_turns > 3:
volume_out_full = volume_out_full * Decimal(
0.995
) # если превышение боле чем в 2 раза то 0.5% себе сразу
elif over_turns > 2:
volume_out_full = volume_out_full * Decimal(
0.9925
) # если превышение боле чем в 1 раза то 0.25% себе сразу
else:
# это обмен на другую крипту
# тут баланс просто у крипты берем
balance = db_client.curr_free_bal(curr_out)
######################################################
print 'volume_out_full > balance', volume_out_full, balance
if volume_out_full > balance:
if len(geted_pays) == 1:
pay_error = 'out of balance'
res = {'error': pay_error}
#print pay_error, volume_out_full, balance, curr_out.abbrev
else:
for id in geted_pays:
p_i_s = db.pay_ins_stack[id]
pay_in = db.pay_ins[p_i_s.ref_]
vol_in_one = pay_in.amount
volume_out_one = vol_in_one / vol_in * volume_out
# размарозим вход - чтобы его могли обработать
p_i_s.update_record(in_proc=False)
db.commit()
# тут dealer_acc, dealer_deal не передаем - там новые берем
make_edealer_payment(db, [id], curr_in, xcurr, curr_out,
ecurr, vol_in_one, volume_out_one,
deal_acc_addr, rate, order_stack_id)
return
elif ecurr:
# надо проверить величину выплат в месяц - не более 60тыс можно
# только для фиата
if deal_acc.payed_month and deal_acc.payed_month + volume_out_full > MAX_PAYMENT_IN_MONTH:
# переплата - включаем задержку
pay_error = 'monthly_limit_60_exceeded'
res = {
'status': 'wait',
'error': 'wait',
'error_description': pay_error
}
else:
####################
#res = {'status':'success', 'balance': 123, 'payment_id': 'sldkflsfj3', 'invoice_id': '78676654',
# 'sum_taken': volume_out_full}
#res = {'status':'testedd', 'error':'test', 'error_description':'tst_descr', }
log_on = None # None - log some, False - notg, True - log all
res = ed_common.pay(db, deal, dealer, dealer_acc, dealer_deal,
deal_acc.acc, volume_out_full, log_on)
log(db, 'PAYed ecurr - res: %s' % res)
else:
# сюда пришло значит баланса хватает и это на выходе криптовалюта
dealer_acc = None
## ыше уже задали xcurr_out = db(db.xcurrs.curr_id == curr_out.id).select().first()
res, bal = crypto_client.send(db, curr_out, xcurr_out,
deal_acc.acc, volume_out_full)
#print bal, res
if bal:
curr_out.update_record(balance=bal)
if type(res) == type(u' '):
# прошла транзакция, создадим массив инфо
res = {'payment_id': res, 'status': 'success'}
log(db, 'PAYed xcurr - res: %s' % res)
####################
if not res or 'error' in res or res.get('status') != 'success':
## res = { 'status': 'error', 'error':'so_small','error_description': '%s < txfee %s' % (amo, txfee) }
# платежа не произошло - выход
pay_error = res.get('error_description')
if not pay_error or pay_error == u'':
pay_error = res.get('error', 'dealer error')
elif ecurr:
# только для фиата с дилерами
if pay_error == 'limit_exceeded':
# тут превышен лимит в день или даже в месяц - надо брать другой счет
# причем сумму в месяц не меняем - чтобы знать сколько в месяц прошло
dealer_acc.day_limit = datetime.date.today().day
dealer_acc.day_limit_sum = -dealer_acc.day_limit_sum
dealer_acc.update_record()
elif pay_error == 'monthly_limit_60_exceeded':
# тут превышен лимит в день или даже в месяц - надо брать другой счет
# причем сумму в месяц не меняем - чтобы знать сколько в месяц прошло
dealer_acc.mon_limit = datetime.date.today().month
dealer_acc.mon_limit_sum = -dealer_acc.mon_limit_sum
dealer_acc.update_record()
elif pay_error == 'not_enough_funds':
# баланс кошелька поменялся - видимо вручную политили с него
balance = ed_common.get_balance(dealer, dealer_acc)
dealer_acc.update_record(balance=balance or 0)
else:
ed_common.dealer_deal_errs_add(db, dealer_deal,
deal_acc.acc, '%s' % res)
# нельзя менять так как не будет возврата pay_error = pay_error + ' (%s ... %s)' % (round(volume_out_full,2), dealer_acc.acc[-5:])
if pay_error == 'technical_error' or pay_error == 'payment_refused':
mark_pay_ins(db, geted_pays, 'try', pay_error)
elif 'Unknown operator for phone' in pay_error:
## Unknown operator for phone-number=PhoneNumber{79016661485 (RU)}
## тут сразу возврат и написать туда чтобы оператора нашел сам
pay_error = 'Unknown operator. Please find this operator in list of services'
mark_pay_ins(db,
geted_pays,
'refuse',
pay_error,
to_refuse=True)
pass
else:
mark_pay_ins(db, geted_pays, 'wait', pay_error)
db.commit()
print 'serv to pay **** - ERROR: make_edealer_payment ', pay_error, 'RES:', res
return
# удалим все взятые входы крипты для этого вывода
# имеено ТУТ чтобы ошибки ниже уже не повлияли на ошибочный повторный вывод
# а то иногда ошибки ниже не дают запомнить что мы уже выплатили все тут
# запомним платеж фиата
amo_taken = Decimal(res.get('sum_taken', volume_out_full))
pay_out_id = db.pay_outs.insert(
ref_=deal_acc.id, # за какое дело и за какого клиента
dealer_acc_id=dealer_acc
and dealer_acc.id, # с какого моего аккаунта дилера оплачено
amount=volume_out,
amo_taken=amo_taken,
amo_to_pay=amo_to_pay,
amo_in=vol_in,
amo_gift=gift_amo,
amo_partner=partner_sum,
created_on=datetime.datetime.now(),
#info=json.dumps({'payment_id'res['payment_id'], 'invoice_id': res['invoice_id'] })
#info = res and json.dumps(res) or None
vars=res,
## возможно что нет выплаты - то добавим ссобщение об ошибке
txid=res.get('payment_id', pay_error),
)
order_id = check_order(db, order_stack_id)
# тут внутри commit сразу
pay_ins_recs = get_pay_ins_recs(db, geted_pays)
# и запомним на что потратили входы
for pay_in in pay_ins_recs:
pay_in.payout_id = pay_out_id
pay_in.status = 'ok'
pay_in.status_mess = pay_in.status_mess and (
'(%s)' % pay_in.status_mess) or ''
pay_in.order_id = order_id # запомним использованный заказ
pay_in.update_record()
db.commit()
# тут же в ответе приходит новый баланс
# запомним суммарно по этому счету
if ecurr:
if res and 'balance' in res:
dealer_acc.balance = Decimal(res['balance'])
# лимиты дневные - месячные подправим
dealer_acc.day_limit_sum = dealer_acc.day_limit_sum + amo_taken
dealer_acc.mon_limit_sum = dealer_acc.mon_limit_sum + amo_taken
dealer_acc.update_record()
#print 'payed, new balance:', dealer_acc.balance
# сразу таксу дилера на это дело запомним
tax = res.get('tax')
# причем только если они еще не заданы вообще
# и число использований меньше 3
if not dealer_deal.tax and dealer_deal.fee and tax and dealer_deal.taken and dealer_deal.taken < 3:
# для ПРИН английское имя только чтобы ошибок конверт не было
print 'dealer new TAX:', deal.name2, tax
# если уже много раз использовано то не изменяем таксу - мож она вручную уже выставлена
dealer_deal.tax = tax
dealer_deal.taken += 1
dealer_deal.update_record()
# теперь надо заплатить нашему партнеру
# если это дело партнерам оплачивается
if deal_acc.gift and not deal.not_gifted: # and not deal_acc.partner: # andl en(deal_acc.gift) > 5:
try:
partners_lib.calc(db, deal, curr_out, deal_acc, volume_out)
except:
print 'except partners_lib.calc(db, deal, curr_out, deal_acc, volume_out)'
# запомним месячную выплату - ее надо ограничивать
deal_acc.payed_month = deal_acc.payed_month and deal_acc.payed_month + volume_out or volume_out
# запомним всего оплачено по этому заказу - и для клиентов тоже
deal_acc.payed = deal_acc.payed and deal_acc.payed + volume_out or volume_out
# надо запомнить если недоплатили или переплатили
#print res
#print 'deal_acc.to_pay = volume_out_full - amo_taken'
#print deal_acc.to_pay, volume_out_full, amo_taken
try:
# дадим на следующий платеж ему от нас 0,5%!
# TO_COIN_ID != deal.id
add_bonus = 0
deal_tax = deal.tax
if deal_tax and deal_tax > 0:
##if deal.id == TO_COIN_ID:
## add_bonus = 0.001
if deal_tax > 1.9:
add_bonus = 0.005
elif deal_tax > 0.9:
add_bonus = 0.002
else:
add_bonus = 0.001
add_bonus = Decimal(add_bonus) * volume_out_full
## найденнный бонус начислим или как партнерские или как подарок
if deal_acc.partner:
deal_acc.partner_sum = (deal_acc.partner_sum or 0) + add_bonus
else:
deal_acc.gift_amount = (deal_acc.gift_amount or 0) + add_bonus
## и если кусочек меньше намного то увеличим кусочек
if deal_acc.gift_pick * 7 < deal_acc.gift_amount:
deal_acc.gift_pick = deal_acc.gift_amount / 7
deal_acc.to_pay = volume_out_full - amo_taken
except:
print 'deal_acc.to_pay = volume_out_full - amo_taken:', type(
deal_acc.to_pay), type(volume_out_full), type(amo_taken)
deal_acc.update_record()
# запомниим статисткиу по делу
count = deal.count_ or 0
average = deal.average_ or 0
if volume_out:
deal.average_ = count / (count + 1) * average + volume_out / (count +
1)
deal.count_ = count + 1
deal.update_record()
####################
# заплмним сатиститку для крипты по этому делу
if volume_out:
db_common.currs_stats_update(db, curr_in.id, deal.id, volume_out)
# обновим балансы дилеров и валюты
# поидее это в ed_common YD_ все проходит
##if not client: db_common.update_balances(curr_out, -amo_taken, dealer)
#if gift_amo and gift_amo > 0:
# print 'gift_amo', gift_amo
#print 'Payed!'
log(db, 'Payed! geted_pays: %s' % geted_pays)
db.commit()
def index():
#common.page_stats(db, response['view'])
#print request.args
response.title = T("Exchange Bitcoin and ERA, COMPU")
response.subtitle = T('Bitcoin Erachain Gate')
abbrev = request.args(0)
addr = request.args(1)
vol = request.args(2)
title = abbrev and addr and T(
'Ваш кошелек'
) + ': ' + abbrev + ' ' + addr[:5] + '***' + addr[-3:] or response.title
subtitle = session.date_log and (T('Дата посещения %s') %
session.date_log) or response.subtitle
try:
session.date_log = request.now
except:
print 'to_coin session error .date_log:', type(
request.now), request.now
if request.vars:
abberv = abbrev or request.vars.get('curr') or session.toCoin
addr = addr or request.vars.get('addr') or session.toCoinAddr
vol = vol or request.vars.get('vol') or session.vol
input_currs = []
output_currs = []
inp_currs = []
otpions_currs = []
for r in db((db.currs.used == True)
& (db.currs.id == db.xcurrs.curr_id)
& (not abbrev or db.currs.abbrev == abbrev)).select(
orderby=~db.currs.uses):
free_bal = db_client.curr_free_bal(r.currs)
inp_currs.append([r.currs.id, r.currs.abbrev, r.currs.name, free_bal])
input_currs.append((
## need DIV insead SPAN
DIV(
IMG(_src=URL('static',
'images/currs/' + r.currs.abbrev + '.png'),
_width=30,
_alt=''),
' ',
SPAN(r.currs.name, _style='font-size:22px'),
_onclick='$("#curr_in").val("' + r.currs.abbrev +
'");', # _style='margin: 0px -20px; padding: 10px 40px 10px 30px;'
_style=
'margin: 0px -20px; padding: 5px 20px 5px 20px; font-size:22px'
),
False,
''))
output_currs.append((
DIV(
IMG(_src=URL('static',
'images/currs/' + r.currs.abbrev + '.png'),
_width=30,
_alt=''),
' ',
SPAN(r.currs.name, _style='font-size:22px'),
' ',
free_bal,
_onclick='$("#curr_out").val("' + r.currs.abbrev +
'");', # _style='margin: 0px -20px; padding: 10px 40px 10px 30px;'
_style=
'margin: 0px -20px; padding: 5px 20px 5px 20px; font-size:24px'
),
False,
''))
if len(inp_currs) == 0:
return err_dict(
T('ОШИБКА: Нет доступных криптовалют для обмена') +
(abbrev and
(' ' + T('или неправильно задано имя [%s] нужной криптовалюты!') %
abbrev) or ''))
input_currs = [(
#TAG.i(_class='fa fa-search go-btn- button- ll-blue-bgc- center', _style='width:20px;font-size:20px;'),
XML('<input name="curr_in" value=BTC id="curr_in" type="text" placeholder="'
+ T('I Sell') + '"/>'),
False,
None,
input_currs)]
output_currs = [(
#TAG.i(_class='fa fa-search go-btn- button- ll-blue-bgc- center', _style='width:20px;font-size:20px;'),
XML('<input name="curr_out" value=COMPU id="curr_out" type="text" placeholder="'
+ T('I Bye') + '"/>'),
False,
None,
output_currs)]
amo_in = INPUT(_name='amo_in')
return dict(title=title,
subtitle=subtitle,
inp_currs=inp_currs,
abbrev=abbrev,
addr=addr,
vol=vol,
input_currs=input_currs,
output_currs=output_currs)
def get_rate_for_api_out(db,
curr_id,
curr_out_id,
vol_out,
deal=None,
dealer_deal=None,
get_limits=None,
get_currs=None):
import common
if not curr_id:
return mess('curr in id...')
try:
curr_id = int(curr_id)
curr_in = db.currs[curr_id]
except:
curr_in = db(db.currs.abbrev == curr_id).select().first()
if not curr_in:
return mess('curr in id...')
curr_id = curr_in.id
if not curr_out_id:
return mess('curr out id...')
try:
curr_out_id = int(curr_out_id)
curr_out = db.currs[curr_out_id]
except:
curr_out = db(db.currs.abbrev == curr_out_id).select().first()
if not curr_out:
return mess('curr out id...')
curr_out_id = curr_out.id
try:
vol_out = float(vol_out)
except:
return mess('vol digs...')
#xcurr_in = db(db.xcurrs.curr_id == curr_id).select().first()
#if not xcurr_in: return mess('xcurr...')
#xcurr_out = db(db.xcurrs.curr_id == curr_out.id).select().first()
#if not xcurr_out: return mess('xcurr out...')
curr_out_abbrev = curr_out.abbrev
out_res = dict(volume_out=vol_out,
curr_in=curr_in.abbrev,
curr_out=curr_out.abbrev)
if get_currs:
out_res['curr_in_rec'] = curr_in
out_res['curr_out_rec'] = curr_out
pr_b, pr_s, pr_avg = get_average_rate_bsa(db, curr_in.id, curr_out.id,
None)
if pr_avg:
vol_in = vol_out / pr_b
amo_out, _, base_rate = get_rate(db, curr_in, curr_out, vol_in)
else:
base_rate = None
if base_rate:
is_order = False
deal = deal or db.deals[current.TO_COIN_ID]
xcurr_out = db(db.xcurrs.curr_id == curr_out_id).select().first()
if not xcurr_out: return mess('xcurr...')
txfee = float(xcurr_out.txfee or 0.0001)
vol_out += txfee
vol_in, mess_in = db_client.calc_fees_back(db,
deal,
dealer_deal,
curr_in,
curr_out,
vol_out,
base_rate,
is_order=0,
note=0,
only_tax=0)
## vol_out - is Decimal
vol_in = common.rnd_8(vol_in)
rate_in = vol_out / vol_in
out_res['volume_in'] = vol_in
out_res['rate_in'] = rate_in
out_res['base_rate'] = base_rate
else:
out_res["wrong"] = "rate not found"
if get_limits:
lim_bal, may_pay = db_client.is_limited_ball(curr_in)
free_bal = db_client.curr_free_bal(curr_out)
out_res['lim_bal'] = lim_bal
out_res['may_pay'] = may_pay
out_res['free_bal'] = float(free_bal)
return out_res
def get():
args = request.args
##print args, '\n', request.vars
if len(args) < 2: return mess('err...')
deal_id = args(0)
curr_id = args(1)
if not deal_id.isdigit() or not curr_id.isdigit(): return mess('dig...')
# теперь можно задать открытие кнопки
scr = "$('#cvr%s').css('display','none');$('#tag%s').show('slow');" % (curr_id, curr_id)
response.js = scr
vol = request.vars.vol
if not vol or len(vol) > 20: return mess(T('ОШИБКА') + ': ' + T('Задайте количество'))
try:
vol = float(vol)
curr_id = int(curr_id)
except:
return mess('digs...')
addr_out = request.vars.addr
#print request.vars
if not addr_out:
return mess(T('ОШИБКА: Задайте кошелек'))
try:
if len(addr_out) < 25 or len(addr_out) > 40:
##проверка на счет - если это не емайл и не ттелефон то надо длинну и на циифры
return mess(T('ОШИБКА: неверный кошелек'))
except:
return mess(T('ОШИБКА: неверный кошелек 2'))
deal = db.deals[ deal_id ]
if not deal: return mess(T('deal...'))
curr_in = db.currs[ curr_id ]
if not curr_in: return mess(T('curr...'))
xcurr_in = db(db.xcurrs.curr_id == curr_id).select().first()
if not xcurr_in: return mess(T('xcurr...'))
#print request.vars
curr_out = db.currs[ request.vars.curr_out ]
xcurr_out = db(db.xcurrs.curr_id == curr_out.id).select().first()
curr_out_abbrev = curr_out.abbrev
curr_out_name = curr_out.name
#print request.application[-5:]
if request.application[:-3] != '_dvlp':
# чето конфликт если из ipay3_dvlp вызывать то кошелек на ipay3 не коннектится
import crypto_client
cc = crypto_client.conn(curr_out, xcurr_out)
if not cc:
return mess(T('Connection to [%s] id lost, try lates ') % curr_out_name)
if crypto_client.is_not_valid_addr(cc, addr_out):
return mess(T('address not valid for ') + curr_out_name)
try:
session.toCoin = curr_out_abbrev
session.toCoinA = addr_out
except:
print 'to_coin session error .toCoinA:', type(addr_out), addr_out
try:
session.vol = vol
except:
print 'to_coin session error .vol:', type(vol), vol
curr_in_name = curr_in.name
x_acc_label = db_client.make_x_acc(deal, addr_out, curr_out_abbrev)
# найдем ранее созданный адресс для этого телефона, этой крипты и этого фиата
# сначала найтем аккаунт у дела
deal_acc_id = db_client.get_deal_acc_id(db, deal, addr_out, curr_out)
# теперь найдем кошелек для данной крипты
deal_acc_addr = db_client.get_deal_acc_addr_for_xcurr(db, deal_acc_id, curr_in, xcurr_in, x_acc_label)
if not deal_acc_addr:
return mess((T('Связь с сервером %s прервана') % curr_in_name) + '. ' + T('Невозможно получить адрес для платежа') + '. ' + T('Пожалуйста попробуйте позже'), 'warning')
addr = deal_acc_addr.addr
h = CAT()
okIN = session.okWt
h += sect(DIV(
okIN and DIV(H3(A(T('Правила оплаты'), _onclick='$(".okIN").show("fast");', _class='button warn right'),
_class='pull-right-'), _class='col-sm-12') or '',
DIV(okIN and ' ' or H3(T('ПРАВИЛА ОПЛАТЫ'), _class='center'),
P(T('При оплате необходимо соблюдать следующие правила:')),
UL(
T('Желательно задать обратный адрес для возврата монет на случай если наша служба по каким-либо причинам не сможет совершить оплату по делу [%s]') % deal.name,
T('Если Вы не задали обратный адрес для возврата монет, то необходимо платить биткоины и другую криптовалюту только со своего кошелька, задав адреса входов, которыми Вы действительно обладаете, а не с кошельков бирж, пулов или разных онлайн-кошельков. Так как монеты, в случае если платеж будет отвергнут нашим партнёром, могут автоматически вернуться только на адрес отправителя.'),
T('Комиссия сети добавляется к сумме для обмена, о чем указывается ниже.'),
T('Если Вы оплатите другую сумму, то курс обмена может немножко измениться'),
T('Если Вы платите регулярно, то можете платить на тот же адрес кошелька криптовалюты, что получили ранее. Хотя желательно заходить на нашу службу для получения новостей хотябы раз в пол года или подписаться на важные новости и сообщения оставив свой емайл.'),
),
H4(A(T('Понятно'), _onclick='$(".okIN").hide("fast");ajax("%s")'
% URL('aj','ok_to',args=['Wt']), _class='button warn'), _class='center'),
_class='col-sm-12 okIN',
_style='color:chocolate;display:%s;' % (okIN and 'none' or 'block')),
_class='row'),
'bg-warning pb-10')
# если есть скрытый партнерский код то его забьем пользователю
deal_acc = db.deal_accs[deal_acc_id]
if not deal_acc.partner:
try:
_ = GIFT_CODE
except:
GIFT_CODE = session.gc
#from gifts_lib import gift_proc
#GIFT_CODE, gift_mess = gift_proc(db, T, deal, deal_acc, request, session, GIFT_CODE)
#if GIFT_CODE:
# h += sect(XML(gift_mess), 'gift-bgc pb-10 pb-10')
import gifts_lib
adds_mess = XML(gifts_lib.add_mess_curr(deal_acc, curr_out, T))
if adds_mess:
h += sect(XML(adds_mess), 'gift-bgc pb-10 pb-10')
volume_out = vol
hh = CAT(H2('3. ' + T('Оплатите по данным реквизитам'), _class='center'))
# используем быстрый поиск курса по формуле со степенью на количество входа
# только надо найти кол-во входа от выхода
pr_b, pr_s, pr_avg = rates_lib.get_average_rate_bsa(db, curr_in.id, curr_out.id, None)
if pr_avg:
vol_in = volume_out / pr_b
amo_out, _, best_rate = rates_lib.get_rate(db, curr_in, curr_out, vol_in)
else:
best_rate = None
if best_rate:
is_order = True
dealer_deal = None
# сначала открутим обратную таксу
txfee = float(xcurr_out.txfee or 0.0001)
volume_out += txfee
volume_in, mess_in = db_client.calc_fees_back(db, deal, dealer_deal, curr_in, curr_out, volume_out,
best_rate, is_order, note=0)
## теперь таксы для человека получим и должна та же цифра выйти
vol_out_new, tax_rep = db_client.calc_fees(db, deal, dealer_deal, curr_in, curr_out, volume_in,
best_rate, is_order, note=1)
vol_out_new = common.rnd_8(vol_out_new)
if common.rnd_8(volume_out) != vol_out_new:
print 'to_phone error_in_fees: volume_out != vol_out_new', volume_out, vol_out_new
volume_in = common.rnd_8(volume_in)
rate_out = volume_out / volume_in
# new make order
order_id = db.orders.insert(
ref_ = deal_acc_addr.id,
volume_in = volume_in,
volume_out = volume_out,
)
# теперь стек добавим, который будем удалять потом
db.orders_stack.insert( ref_ = order_id )
hh += DIV(
T('Создан заказ №%s') % order_id,' ',
T('на заморозку обменного курса по'), ' ', rate_out,
' (',T('обратный курс'), ' ', round(1.0/float(rate_out),8),') ',
T('для объема'),' ',volume_out, ' ', curr_out_abbrev, ' (', T('с учётом комиссии сети'),' ',txfee,').',
H5('*',T('Данный курс будет заморожен для Вас на 20 минут для объёма криптовалюты не больше указанного. Проверить можно по номеру заказа в списке платежей.')),
_class='row')
else:
volume_in = rate_out = tax_rep = None
hh += mess('[' + curr_in_name + '] -> [' + curr_out_name + ']' + T(' - лучшая цена не доступна.') + T('Но Вы можете оплатить вперед'), 'warning pb-10')
_, url_uri = common.uri_make( curr_in.name2, addr, {'amount':volume_in, 'label': db_client.make_x_acc_label(deal, addr_out, curr_out_abbrev)})
curr_in_abbrev = curr_in.abbrev
lim_bal, may_pay = db_client.is_limited_ball(curr_in)
if lim_bal:
if may_pay> 0:
lim_bal_mess = P(
T('Внимание! Для криптовалюты %s существует предел запаса и поэтому наша служба может принять только %s [%s], Просьба не превышать это ограничение') % (curr_in.name, may_pay, curr_in_abbrev), '.',
_style='color:black;'
)
else:
lim_bal_mess = P(
T('ВНИМАНИЕ! Наша служба НЕ может сейчас принимать %s, так как уже достугнут предел запаса её у нас. Просьба попробовать позже, после того как запасы [%s] снизятся благодаря покупке её другими пользователями') % (curr_in.name, curr_in_abbrev),
'. ', T('Иначе Ваш платеж будет ожидать момента когда запасы снизятся ниже %s') % lim_bal,'.',
_style='color:brown;')
else:
lim_bal_mess = ''
free_bal = db_client.curr_free_bal(curr_out)
hh += DIV(
P(
T('Оплата обмена на'), ' ',curr_out_abbrev, ' ', T('с выплатой монет на адрес'), ': ',
addr_out, '. ', T('Текущая сумма обмена'), ' ', volume_out, ' ', curr_out_abbrev,' (',
T('с учётом комиссии сети'),') ',
' ', T('из доступных в службе'), ' ', free_bal, '. ',
T('Так же Вы можете делать ещё платежи на созданый %s адрес для совершения автоматического обмена %s на %s по текущему курсу.') % (curr_in_name, curr_in_name, curr_out_name),
),
volume_out > free_bal and P(
H3(T('Сейчас средств на балансе меньше чем Вам надо'), _style='color:crimson;'),
SPAN(T('Поэтому Ваш заказ будет исполнен позже'), BR(),
T('когда на балансе службы появится достаточно средств'), _style='color:black;'), BR(),
) or '',
lim_bal_mess,
DIV(CENTER(
A(SPAN(T('Оплатить'),' ', volume_in or '', ' ',
IMG(_src=URL('static','images/currs/' + curr_in_abbrev + '.png'), _width=50)),
_class='block button blue-bgc', _style='font-size:x-large; max-width:500px; margin:0px 7px;',
_href=url_uri),
),
_class='row'
),
BR(),
DIV(
A(T('Показать QR-код'), _class='btn btn-info',
##_onclick="jQuery(this).parent().html('%s')" % IMG(_src=URL('static','images/loading.gif'), _width=64),
_onclick="jQuery(this).parent().html('<i class=\"fa fa-spin fa-refresh\" />')",
callback=URL('plugins','qr', vars={'mess': url_uri}),
target='tag0',
#delete='div#tag0'
),
_id='tag0'),
T('или'), BR(),
T('Оплатите вручную'), ': ',
FORM( ## ВНИМАНИЕ !!! тут имена полей надр друние указывать или
# FORM в основной делать тоже иначе они складываются
INPUT(_name='v', value=volume_in, _class="pay_val", _readonly=''), curr_in_abbrev, BR(),
T("Для этого скопируйте сумму и адрес (двойной клик по полю для выделения) и вставьте их в платеж на вашем кошельке"), ': ',
INPUT(_name='addr_in', _value=addr, _class='wallet', _readonly=''), BR(),
#T('Резервы службы'), ' ', B(free_bal), ' ', T('рублей'), BR(),
#LOAD('where', 'for_addr', vars={'addr': addr}, ajax=True, times=100, timeout=20000,
# content=IMG(_src=URL('static','images/loading.gif'), _width=48)),
INPUT( _type='submit',
_class='button blue-bgc',
_value=T('Подробный просмотр платежей'),
_size=6,
),
_action=URL('where', 'index'), _method='post',
)
)
h += sect(hh, 'bg-info pb-10')
h += sect(DIV(DIV(
H3(T('Почему получился такой курс?')),
tax_rep, BR(),
T('При этом Вы получаете следующие преимущества при обмене криптовалют у нас'),':',
UL(
[
T('Вы можете теперь постоянно делать обмен со своего кошелька на полученный адрес даже не заходя на наш сайт'),
T('не нужно нигде регистрироваться'),
T('не нужно делать подтверждения по СМС или по емайл'),
T('обмен производится быстро и автоматически'),
T('Вам не нужно хранить свои деньги у нас'),
]
),
T('Время - деньги!'),
_class='col-sm-12'), _class='row'))
h += SCRIPT('''
$('html, body').animate( { scrollTop: $('#cvr%s').offset().top - $('#aside1').height() }, 500 );
''' % (curr_id))
return h
def rates():
import time
time.sleep(1)
if 'wp' in request.args:
# это переделать имена параметров под http://web-payment.ru/ стандарт
WPnames = request.args.index('wp')
deal_sel = WPnames and request.args(0) or request.args(1)
WPnames = True
else:
deal_sel = request.args(0)
WPnames = False
#print deal_sel
if deal_sel and deal_sel.upper() == 'HELP':
return 'rates/[deal] - deal = PH_7RUB | TO_YDRUB | IN_YDRUB | TO_COIN | None - all'
import rates_lib, db_client, ed_common
rub_curr, x, ecurr_out = db_common.get_currs_by_abbrev(db, "RUB")
ecurr_out_id = ecurr_out.id
vol_rub = 1000
res = []
currs_in_max = {}
currs_to_max = {}
dealer_deal = None
to_abbrev = 'PH_7RUB'
if not deal_sel or deal_sel.upper() == to_abbrev:
## сначала длля телефона
if TO_PHONE7_ID:
deal = db.deals[TO_PHONE7_ID]
else:
deal = db(db.deals.name == 'phone +7').select().first()
dealer, dealer_acc, dealer_deal = ed_common.select_ed_acc(
db, deal, ecurr_out)
#print deal.name, 'dealer:', dealer_deal
to_max = round(float(db_common.get_balance_dealer_acc(dealer_acc)), 8)
for r in db((db.currs.id == db.xcurrs.curr_id)
& (db.currs.used == True)).select():
curr_in = r.currs
# теперь курс и мзду нашу найдем
pr_b, pr_s, rate = rates_lib.get_average_rate_bsa(
db, curr_in.id, rub_curr.id, None)
if not rate: continue
vol_out = vol_rub # в рублях
in_max = curr_in.max_bal or 0
if in_max > 0:
bal = db_client.curr_free_bal(curr_in)
in_max = round(float(in_max - bal), 8)
in_abbrev = curr_in.abbrev
currs_in_max[in_abbrev] = in_max
is_order = True
vol_in, tax_rep = db_client.calc_fees_back(db,
deal,
dealer_deal,
curr_in,
rub_curr,
vol_out,
rate,
is_order,
note=0)
##rate = vol_out_new / vol_in
'''
<rates>
<item>
<from>PMEUR</from>
<to>PMUSD</to>
<in>1</in>
<out>1.07</out>
<amount>4322.79649</amount>
<param>manual</param>
<minamount>0 EUR</minamount>
</item>
'''
if WPnames:
item = {
'from': in_abbrev,
'to': to_abbrev,
'in': round(float(vol_in), 8),
'out': vol_out,
'amount': to_max
}
else:
item = {
'in': in_abbrev,
'to': to_abbrev,
'in_vol': round(float(vol_in), 8),
'to_vol': vol_out,
'to_max': to_max
}
if in_max: item['in_max'] = in_max
res.append(item)
###############
## теперь на ЯД кошелек
to_abbrev = 'YDRUB'
if not deal_sel or deal_sel.upper() == 'TO_YDRUB':
if TO_WALLET_ID:
deal = db.deals[TO_WALLET_ID]
else:
deal = db(db.deals.name == 'BUY').select().first()
dealer, dealer_acc, dealer_deal = ed_common.select_ed_acc(
db, deal, ecurr_out)
#print deal.name, 'dealer:', dealer_deal
to_max = dealer_max = round(
float(db_common.get_balance_dealer_acc(dealer_acc)), 8)
for r in db((db.currs.id == db.xcurrs.curr_id)
& (db.currs.used == True)).select():
curr_in = r.currs
# теперь курс и мзду нашу найдем
pr_b, pr_s, rate = rates_lib.get_average_rate_bsa(
db, curr_in.id, rub_curr.id, None)
if not rate: continue
vol_out = vol_rub # в рублях
is_order = True
vol_in, tax_rep = db_client.calc_fees_back(db,
deal,
dealer_deal,
curr_in,
rub_curr,
vol_out,
rate,
is_order,
note=0)
in_abbrev = curr_in.abbrev
if WPnames:
item = {
'from': in_abbrev,
'to': to_abbrev,
'in': round(float(vol_in), 8),
'out': vol_out,
'amount': to_max
}
else:
item = {
'in': in_abbrev,
'to': to_abbrev,
'in_vol': round(float(vol_in), 8),
'to_vol': vol_out,
'to_max': to_max
}
## вытащим из кеша если он там есть
in_max = currs_in_max.get(in_abbrev)
if in_max == None:
in_max = curr_in.max_bal or 0
if in_max > 0:
bal = db_client.curr_free_bal(curr_in)
in_max = round(float(in_max - bal), 8)
if in_max: item['in_max'] = in_max
res.append(item)
###### покупка через ЯДеньги
if not deal_sel or deal_sel.upper() == 'IN_YDRUB':
in_abbrev = 'YDRUB'
if TO_BUY_ID:
deal = db.deals[TO_BUY_ID]
else:
deal = db(db.deals.name == 'BUY').select().first()
# тут пустой %% dealer, dealer_acc, dealer_deal = ed_common.select_ed_acc(db, deal, ecurr_out)
#print deal.name, 'dealer:', dealer_deal
dealer_deal = None
in_max = 57000 # у фиатного диллера одну покупку ограничим
for r in db((db.currs.id == db.xcurrs.curr_id)
& (db.currs.used == True)).select():
curr_out = r.currs
vol_in = vol_rub # в рублях
to_abbrev = curr_out.abbrev
currs_to_max[to_abbrev] = to_max = round(
float(db_client.curr_free_bal(curr_out)), 8)
# теперь курс и мзду нашу найдем
pr_b, pr_s, rate = rates_lib.get_average_rate_bsa(
db, rub_curr.id, curr_out.id, None)
if not rate: continue
is_order = True
vol_out, tax_rep = db_client.calc_fees(db,
deal,
dealer_deal,
rub_curr,
curr_out,
vol_in,
rate,
is_order,
note=0)
if WPnames:
item = {
'from': in_abbrev,
'to': to_abbrev,
'in': vol_in,
'out': round(float(vol_out), 8),
'amount': to_max,
'in_max': in_max
}
else:
item = {
'in': in_abbrev,
'to': to_abbrev,
'in_vol': vol_in,
'to_vol': round(float(vol_out), 8),
'to_max': to_max,
'in_max': in_max
}
res.append(item)
#########
# обмен крипты
if not deal_sel or deal_sel.upper() == 'TO_COIN':
if TO_COIN_ID:
deal = db.deals[TO_COIN_ID]
else:
deal = db(db.deals.name == 'to COIN').select().first()
for r_in in db((db.currs.id == db.xcurrs.curr_id)
& (db.currs.used == True)).select():
curr_in = r_in.currs
in_abbrev = curr_in.abbrev
vol_in = vol_rub * rates_lib.get_avr_rate_or_null(
db, rub_curr.id, curr_in.id)
vol_out = vol_rub # в рублях
to_max = 0
in_max = currs_in_max.get(in_abbrev)
if in_max == None:
in_max = curr_in.max_bal or 0
if in_max > 0:
bal = db_client.curr_free_bal(curr_in)
in_max = round(float(in_max - bal), 8)
#print curr_in.abbrev, ' to RUB', vol_in
for r_out in db((db.currs.id == db.xcurrs.curr_id)
& (db.currs.used == True)).select():
curr_out = r_out.currs
if curr_in.id == curr_out.id: continue
# теперь курс и мзду нашу найдем
pr_b, pr_s, rate = rates_lib.get_average_rate_bsa(
db, curr_in.id, curr_out.id, None)
if not rate: continue
to_abbrev = curr_out.abbrev
to_max = currs_to_max.get(
to_abbrev,
round(float(db_client.curr_free_bal(curr_out)), 8))
# для каждого направление - свое дело
is_order = True
vol_out, tax_rep = db_client.calc_fees(db,
deal,
dealer_deal,
curr_in,
curr_out,
vol_in,
rate,
is_order,
note=0)
if WPnames:
item = {
'from': in_abbrev,
'to': to_abbrev,
'in': round(float(vol_in), 8),
'out': round(float(vol_out), 8),
'amount': to_max
}
else:
item = {
'in': in_abbrev,
'to': to_abbrev,
'in_vol': round(float(vol_in), 8),
'to_vol': round(float(vol_out), 8),
'to_max': to_max
}
if in_max: item['in_max'] = in_max
res.append(item)
return request.extension == 'html' and dict(
h=DIV(BEAUTIFY({'rates': res}), _class='container')) or {
'rates': res
}
def get():
args = request.args
if len(args) != 1: return mess('err...')
curr_id = args(0)
##scr = "$('#cvr%s').css('z-index',-1);$('#tag%s').show('slow');" % (curr_id, curr_id)
scr = "$('#cvr%s').css('display','none');$('#tag%s').show('slow');" % (
curr_id, curr_id)
response.js = scr
if not curr_id.isdigit(): return mess('dig...')
vol = request.vars['vol']
if not vol or len(vol) > 20:
return mess(T('ОШИБКА') + ': ' + T('Задайте количество'))
try:
vol = float(vol)
curr_id = int(curr_id)
except:
return mess('digs...')
addr = request.vars['wallet']
if not addr or len(addr) < 30 or len(addr) > 35:
return mess(
T('ОШИБКА') + ': ' + T('Введите адрес кошелька криптовалют'))
curr_out = db.currs[curr_id]
if not curr_out: return mess(T('curr...'))
xcurr_out = db(db.xcurrs.curr_id == curr_id).select().first()
if not xcurr_out: return mess(T('xcurr...'))
curr_out_name = curr_out.name
amo_in = vol
_amo_out, rate_order, best_rate = rates_lib.get_rate(
db, curr_in, curr_out, amo_in)
try:
dealer_id = request.vars['dealer']
dealer = db.dealers[dealer_id]
except:
return mess('digs...')
MIN = db_common.gMIN(deal, dealer)
if vol < MIN:
try:
vol = MIN
session.vol = vol
except:
print 'to_buy session error .vol:', type(addr), addr
return mess(
T('ОШИБКА: Слишком маленькая сумма платежа %s < %s') % (vol, MIN))
dealer_acc = ed_common.sel_acc_min(db, dealer, ecurr, amo_in)
if not dealer_acc:
return mess(
(T('Электронные деньги [%s] не доступны сейчас.' % dealer.name) +
' ' + T('Попробуйте позже')), 'warning')
if not best_rate:
response.title = T("ОШИБКА")
return mess(T('Курс не найден'), 'warning')
try:
session.buyAddr = addr
session.buyVol = vol
except:
print 'list session error .buyAddr:', type(addr), vol
print 'list session error .buyVol:', type(vol), vol
#print best_rate
if request.application[:-3] != '_dvlp':
# чето конфликт если из ipay3_dvlp вызывать то кошелек на ipay3 не коннектится
cc = crypto_client.conn(curr_out, xcurr_out)
if cc:
if crypto_client.is_not_valid_addr(cc, addr):
#return mess(T('address not valid for ') + curr_out_name)
return mess(
T('ОШИБКА') + ': ' +
T('Адрес кошелька не подходит для выбранной криптовалюты %s'
) % curr_out_name)
else:
# ЕСЛИ НЕТ СВЯЗИ - пусть пллатит - потом связь появится
#return mess(T('Connection to [%s] is lost, try later ') % curr_out_name)
##return mess(T('Связь с кошельком ') + curr_out_name + T(' прервана.') + ' ' + T('Пожалуйста попробуйте позже'), 'warning')
pass
volume_in = vol
is_order = True
dealer_deal = db(
(db.dealer_deals.deal_id == deal.id)
& (db.dealer_deals.dealer_id == dealer_id)).select().first()
## теперь таксы для человека получим и должна та же цифра выйти
vol_out, tax_rep = db_client.calc_fees(db,
deal,
dealer_deal,
curr_in,
curr_out,
volume_in,
best_rate,
is_order,
note=1)
volume_out = common.rnd_8(vol_out)
volume_in = common.rnd_8(volume_in)
rate_end = volume_in / volume_out
##print 'buy:', volume_in, vol_out, rate_end
h = CAT()
okIN = session.okBu
h += sect(
DIV(okIN and DIV(H3(A('Правила оплаты',
_onclick='$(".okIN").show("fast");',
_class='button warn right'),
_class='pull-right-'),
_class='col-sm-12') or '',
DIV(okIN and ' ' or H3('ПРАВИЛА ОПЛАТЫ', _class='center'),
P(T('При оплате необходимо соблюдать следующие правила:')),
UL(
T('Если Вы хотите оплатить большую сумму, то нужно делать платежи небольшими суммами по 2000-3000 рублей и получать разные счета - просто еще раз нажмите на кнопку выбора необходимой валюты'
),
T('Если Вы оплатите другую сумму, то курс обмена может немножко измениться'
),
T('Если Вы платите регулярно, то просьба каждый раз получать счет нажатием на кнопку выбора валюты - возможно счет будет выбран другой, а ранее полученный счет может быть перегружен и заморожен на сутки и более'
),
),
H4(A('Понятно',
_onclick='$(".okIN").hide("fast");ajax("%s")' %
URL('aj', 'ok_to', args=['Bu']),
_class='button warn'),
_class='center'),
_class='col-sm-12 okIN',
_style='color:chocolate;display:%s;' %
(okIN and 'none' or 'block')),
_class='row'), 'bg-warning pb-10')
# создадим номер заказа чтобы не показывать что мы на крипту принимаем платеж
order = db((db.addr_orders.xcurr_id == xcurr_out.id)
& (db.addr_orders.addr == addr)).select().first()
if not order:
order_id = db.addr_orders.insert(xcurr_id=xcurr_out.id, addr=addr)
else:
order_id = order.id
amo_in = round(amo_in * 1.005, 2) # добавим таксу яндекса 0.5%
destination = '7pb%s' % order_id # + ' ' + T('или') +' ' + curr_out.abbrev + ' ' + addr
free_bal = db_client.curr_free_bal(curr_out)
h += sect(
DIV(DIV(
H2(T('3. Оплатите по данным реквизитам покупку %s') %
curr_out_name,
_class='center'),
P(
T('курс обмена: %s (обратный курс: %s)') %
(round(rate_end, 8), round(1 / rate_end, 8)),
BR(),
T('Вы получите'),
' ',
B(round(volume_out, 8)),
IMG(_src=URL('static',
'images/currs/' + curr_out.abbrev + '.png'),
_width=36),
' ',
T('из доступных'),
' ',
free_bal,
),
P(
volume_out > free_bal and CAT(
H3(T('Сейчас средств на балансе меньше чем Вам надо'),
_style='color:crimson;'),
SPAN(
T('Поэтому Ваш заказ будет исполнен позже'),
BR(),
T('когда на балансе службы появится достаточно средств'
),
_style='color:black;'),
BR(),
) or '', ),
DIV(CENTER(
A(SPAN(
T('Оплатить'), ' ', amo_in, ' ',
IMG(_src=URL('static',
'images/currs/' + curr_in.abbrev + '.png'),
_width=50)),
_class='block button blue-bgc',
_style='font-size:x-large; max-width:500px; margin:0px 7px;',
_href=
'https://money.yandex.ru/direct-payment.xml?scid=767&receiver=%s&sum=%s&destination=%s&FormComment=buy %s on '
+ DOMEN %
(dealer_acc.acc, amo_in, destination, curr_out.abbrev)), ),
_class='row'),
BR(),
P(
T('Или сделайте платеж вручную на %s кошелек %s') %
(dealer.name, dealer_acc.acc),
BR(),
T('указав в назначении платежа код оплаты'),
':',
BR(),
B(destination),
),
tax_rep,
FORM(INPUT(_name='addr', _value=addr, _type='hidden'),
INPUT(
_type='submit',
_class='button blue-bgc',
_value=T('Подробный просмотр платежей'),
_size=6,
),
_action=URL('where', 'index'),
_method='post'),
_class='center',
_style='color:blue;'),
_class='row'), 'bg-info pb-10')
h += sect(
CAT(
DIV(H3(T('Так же Вы можете пополнить этот %s кошелек') %
dealer.name,
':',
_class='center'),
_class='row'),
DIV(DIV(
IMG(_src=URL('static', 'images/m-cards.png'),
_style='float:left;margin:10px;'),
T('С любой банковской карточки, указав в сообщении получателю код оплаты (как показано выше)'
),
_class='col-lg-8 col-lg-offset-2 col-sm-12',
_style='black;padding: 5px;'),
_class='row'),
DIV(DIV(
IMG(_src=URL('static', 'images/m-banks.png'),
_style='float:left;margin:10px;'),
T('Из любого банка, например Альфа-Банк (пока Сбербанк не даёт такие данные)'
),
'. ',
T('После чего'),
' ',
A(B(T('ПОДТВЕРДИТЬ')), _href=URL('to_buy', 'bank')),
' ',
T('покупку биткоинов по банковским реквизитам платежа (сумме и референсу платёжки)'
),
_class='col-lg-8 col-lg-offset-2 col-sm-12',
_style='black;padding: 5px;'),
_class='row'),
),
#_style='background-color:#FFF47D;color:black;'
'gold-bgc pb-10')
h += SCRIPT('''
$('html, body').animate( { scrollTop: $('#cvr%s').offset().top - $('#aside1').height() }, 500 );
''' % (curr_id))
return h
def get_uri():
import rates_lib, common
args = request.args
##print args, '\n', request.vars
if len(args) < 2: return mess('err...')
deal_id = args(0)
curr_id = args(1) or vars.get('curr_in')
if not curr_id or len(curr_id) > 20:
return mess('error curr_in')
try:
curr_id = int(curr_id)
curr_in = db.currs[curr_id]
if not curr_in:
return mess('curr in id...')
except:
curr_in = db(db.currs.abbrev == curr_id).select().first()
curr_id = curr_in.id
if not curr_in:
return mess('curr in id...')
curr_id = curr_in.id
curr_out_id = args(2) or vars.get('curr_out')
if not curr_out_id or len(curr_out_id) > 20:
return mess('error curr_out')
try:
curr_out_id = int(curr_out_id)
curr_out = db.currs[curr_out_id]
if not curr_out:
return mess('curr out id...')
except:
curr_out = db(db.currs.abbrev == curr_out_id).select().first()
if not curr_out:
return mess('curr out id...')
curr_out_id = curr_out.id
addr_out = args(3)
#if not deal_id.isdigit() or not curr_id.isdigit():
# return mess('dig...')
vol = args(4)
if not vol or len(vol) > 20:
return mess('error amount')
try:
vol = float(vol)
except:
return mess('digs...')
if not addr_out:
return mess('error address')
try:
if len(addr_out) < 25 or len(addr_out) > 40:
return mess('error address')
except:
return mess('error address')
deal = db.deals[deal_id]
if not deal: return mess('deal...')
xcurr_in = db(db.xcurrs.curr_id == curr_id).select().first()
if not xcurr_in: return mess('xcurr...')
xcurr_out = db(db.xcurrs.curr_id == curr_out.id).select().first()
if not xcurr_out: return mess('xcurr out...')
curr_out_abbrev = curr_out.abbrev
curr_out_name = curr_out.name
token_system_in = None
token_key_in = xcurr_in.as_token
if token_key_in:
token_in = db.tokens[token_key_in]
token_system_in = db.systems[token_in.system_id]
import rpc_erachain
token_system_out = None
token_key_out = xcurr_out.as_token
if token_key_out:
token_out = db.tokens[token_key_out]
token_system_out = db.systems[token_out.system_id]
import rpc_erachain
#print request.application[-5:]
if request.application[:-3] != '_dvlp':
# conflicts to call if from [ipay3_dvlp] - wallet not in connection...
if token_system_out:
curr_block = rpc_erachain.get_info(token_system_out.connect_url)
if type(curr_block) != type(1):
return mess('Connection to [%s] is lost, try later ' %
curr_out_name)
if rpc_erachain.is_not_valid_addr(token_system_out.connect_url,
addr_out):
return mess('address not valid for ' + curr_out_name + ' - ' +
addr_out)
pass
else:
import crypto_client
try:
cc = crypto_client.conn(curr_out, xcurr_out)
except:
cc = None
if not cc:
return mess('Connection to [%s] is lost, try later ' %
curr_out_name)
if crypto_client.is_not_valid_addr(cc, addr_out):
return mess('address not valid for - ' + curr_out_name +
' - ' + addr_out)
curr_in_name = curr_in.name
if token_system_in:
deal_acc_id, deal_acc_addr = rpc_erachain.get_deal_acc_addr(
db, deal_id, curr_out, addr_out, token_system_in.account, xcurr_in)
addr_in = token_system_in.account
pass
else:
x_acc_label = db_client.make_x_acc(deal, addr_out, curr_out_abbrev)
deal_acc_id = db_client.get_deal_acc_id(db, deal, addr_out, curr_out)
deal_acc_addr = db_client.get_deal_acc_addr_for_xcurr(
db, deal_acc_id, curr_in, xcurr_in, x_acc_label)
if not deal_acc_addr:
return mess('Connection to [%s] is lost, try later ' %
curr_in_name)
addr_in = deal_acc_addr.addr
deal_acc = db.deal_accs[deal_acc_id]
volume_out = vol
# fast search of RATE first
#
pr_b, pr_s, pr_avg = rates_lib.get_average_rate_bsa(
db, curr_in.id, curr_out.id, None)
if pr_avg:
vol_in = volume_out / pr_b
amo_out, _, best_rate = rates_lib.get_rate(db, curr_in, curr_out,
vol_in)
else:
best_rate = None
if best_rate:
is_order = True
dealer_deal = None
# first add TAX
txfee = float(xcurr_out.txfee or 0.0001)
volume_out += txfee
volume_in, mess_in = db_client.calc_fees_back(db,
deal,
dealer_deal,
curr_in,
curr_out,
volume_out,
best_rate,
is_order,
note=0)
volume_in = common.rnd_8(volume_in)
rate_out = volume_out / volume_in
# new make order
order_id = db.orders.insert(
ref_=deal_acc_addr.id,
volume_in=volume_in,
volume_out=volume_out,
)
db.orders_stack.insert(ref_=order_id)
else:
volume_in = rate_out = tax_rep = None
_, uri = common.uri_make(
curr_in.name2, addr_in, {
'amount': volume_in,
'label': db_client.make_x_acc_label(deal, addr_out,
curr_out_abbrev)
})
curr_in_abbrev = curr_in.abbrev
#
lim_bal, may_pay = db_client.is_limited_ball(curr_in)
free_bal = db_client.curr_free_bal(curr_out)
if token_system_in:
addr_out_full = (token_system_out and ('%d' % token_out.token_key)
or curr_out.abbrev) + ':' + addr_out
else:
addr_out_full = addr_out
out_res = dict(curr_out_abbrev=curr_out_abbrev,
addr_out=addr_out,
volume_out=volume_out,
bal=float(free_bal / 2),
rate=rate_out,
curr_in_name=curr_in_name,
volume_in=volume_in,
curr_in_abbrev=curr_in_abbrev,
addr_in=addr_in,
uri=uri)
if lim_bal > 0:
out_res['may_pay'] = float(may_pay / 2)
if not volume_in:
out_res['wrong'] = 'rate not found'
if token_system_in:
out_res['addr_out_full'] = addr_out_full
return request.extension == 'html' and dict(
h=DIV(BEAUTIFY(out_res), _class='container')) or out_res
def get_currs():
import db_client
out_res = {'icon_url': URL('static', 'images/currs'), 'in': {}, 'out': {}}
for r in db((db.currs.used == True)
& (db.currs.id == db.xcurrs.curr_id)).select(
orderby=~db.currs.uses):
free_bal = db_client.curr_free_bal(r.currs)
lim_bal, may_pay = db_client.is_limited_ball(r.currs)
fee = r.currs.fee_in
if fee and fee > 0:
min = float(fee * 10)
else:
fee = r.xcurrs.txfee
if fee and fee > 0:
min = float(fee * 10)
else:
min = 0.0001
out_res['in'][r.currs.abbrev] = {
'id': int(r.currs.id),
'name': r.currs.name,
'name2': r.currs.name2,
'min': min,
'icon': r.currs.abbrev + '.png'
}
if lim_bal > 0:
out_res['in'][r.currs.abbrev]['may_pay'] = float(may_pay)
fee = r.currs.fee_out
if fee and fee > 0:
min = float(fee * 10)
else:
fee = r.xcurrs.txfee
if fee and fee > 0:
min = float(fee * 10)
else:
min = 0.0001
out_res['out'][r.currs.abbrev] = {
'id': int(r.currs.id),
'bal': float(free_bal),
'name': r.currs.name,
'name2': r.currs.name2,
'min': min,
'icon': r.currs.abbrev + '.png'
}
token_id = r.xcurrs.as_token
if token_id:
token = db.tokens[token_id]
token_system = db.systems[token.system_id]
out_res['in'][r.currs.abbrev]['system'] = token_system.name2
out_res['out'][r.currs.abbrev]['system'] = token_system.name2
out_res['in'][r.currs.abbrev]['token_key'] = token.token_key
out_res['out'][r.currs.abbrev]['token_key'] = token.token_key
return request.extension == 'html' and dict(
h=DIV(BEAUTIFY(out_res), _class='container')) or out_res
def bills_withdraw(db, curr, xcurr, cn):
addrs = {}
bills = {}
amo_total = 0
# возьмем резерв который для магазинов есть (за минусом моего резерва)
bal_free = db_common.get_reserve(curr)
# тут без учета что в магазинах есть - только свободные деньги db_common.get_shops_reserve( curr )
#print '\n bills_withdraw, bal_free:', bal_free, curr.abbrev
# берем заданные крипту и все балансы по ней
for rec in db(db.bills_draws.curr_id == curr.id).select():
amo = rnd_8(rec.amo) # за вычетом комиссии сети
if amo <= 0: continue
addr = rec.addr
if not addr or len(addr) < 20:
continue
# тут может быть несколько выплат на один адрес - суммируем
addrs[addr] = addrs.get(addr, 0) + amo
shop_order_ids = '%s' % rec.shop_order_id
#print 'update', amo, rec.addr, shop_order_ids
# накопим сумму для каждого счета отдельно
bills[shop_order_ids] = bills.get(shop_order_ids, 0) + amo
amo_total += amo
#print addrs
if len(addrs) == 0: return # ничего не собрали
#addrs_outs =
bal_free = db_client.curr_free_bal(curr)
print 'bal_free:', bal_free, ' amo_total to send:', amo_total
if amo_total >= bal_free:
log(db, 'bills_withdraw',
'ERROR: bal_free < amo_total - %s <' % (bal_free, amo_total))
return
# теперь надо выплату сделать разовую всем за раз
# отлько таксу здесь повыше сделаем чтобы быстро перевелось
#{ 'txid': res, 'tx_hex': tx_hex, 'txfee': transFEE }
#print 'bills:', bills
#print 'addrs', addrs
#return
#!!! вдруг база залочена - проверим это
log(db, 'bills_withdraw', 'try for addrs:%s' % addrs)
res = crypto_client.send_to_many(db, curr, xcurr, addrs,
float(xcurr.txfee or 0.0001), cn)
if not res or 'txid' not in res:
log(db, 'bills_withdraw',
'ERROR: crypto_client.send_to_many = %s' % res)
return
# удалим сразу
db(db.bills_draws.curr_id == curr.id).delete()
# деньги перевелись нужно зачесть это по счетам
txid = res['txid']
# а то вдруг база залочена - проверим это
log(db, 'bills_withdraw', 'txid:%s for addrs:%s' % (txid, addrs))
# запоним а какой транзакции и сколько выплочено по этому счету
for (bill_id, amo) in bills.iteritems():
db.bills_draws_trans.insert(
shop_order_id=bill_id,
curr_id=curr.id,
txid=txid,
amo=amo,
)
#curr.update_record( balance - в serv_block_proc.run_once() один раз делается после блока
# сохраним сразу данные!
db.commit()
def buy_free(db, deal, curr_in, ecurr, volume_in, curr_out, xcurr, addr, conn, mess_in=None):
volume_in = float(volume_in)
print 'try buy_free %s [%s] -> %s %s' % (volume_in, curr_in.abbrev, curr_out.abbrev, addr)
if not conn:
mess = '[' + curr_out.name + '] not connection'
print mess
return { 'error': mess }, None
ecurr_id = ecurr.id
xcurr_id = xcurr.id
_, _, best_rate = rates_lib.get_rate(db, curr_in, curr_out, volume_in)
if not best_rate:
mess = '[' + curr_in.name + '] -> [' + curr_out.name + ']' + current.T(' - лучший КУРС не найден!')
print mess
return { 'error': mess }, None
##print best_rate, '1/r=', round(1/best_rate,8)
# возьмем таксы все
dealer_deal = None
# там входной оброк не берется - так как он берется с заказов только
# тоесть со входа фиата рубль не берется
#deal_fee = dealer_deal_fee = None
#volume_out, tax_mess = db_client.use_fees_for_in(db, deal_fee, dealer_deal_fee, curr_in, curr_out, volume_in, best_rate)
is_order = True
try:
volume_out, tax_mess = db_client.calc_fees(db, deal, dealer_deal, curr_in, curr_out, volume_in, best_rate, is_order, note=1)
except Exception as e:
print 'BUY error db_client.calc_fees %s' % e
volume_out, tax_mess = volume_in * best_rate * 0.99, 'error in fees [%s], get rate 0.99' % e
volume_out = common.rnd_8(volume_out)
print volume_in, curr_in.abbrev, '--> - tax - fee -->', volume_out, curr_out.abbrev, '\n mess:', tax_mess
#log_commit(db, tax_mess)
#################################################
bal_free = db_client.curr_free_bal(curr_out)
print '\nsend:', volume_out, curr_out.abbrev, 'bal_free:', bal_free, addr
if bal_free < volume_out:
res = {'error': 'out off free funds', 'not_log': True}
bal = None #curr_out.balance
#log(db, res)
else:
# внутри там еще вычтется комиссия сети
res, bal = crypto_client.send(db, curr_out, xcurr, addr, volume_out, conn)
print 'buy_free RES:', res, bal
log(db, res)
#log(db, bal)
if type(res) == type(u' '):
# прошла транзакция, создадим массив инфо
res = { 'txid': res }
#if 'mess' in res: res['txid'] = res['mess']
if res:
err = res.get('error')
if err:
code = err.get('code')
if code == -3:
# нехваватило монет - они еще не вернулись в кошелек
pass
else:
if res.get('mess'): volume_out = 0
res['amo_out'] = volume_out
res['tax_mess'] = tax_mess
print res
return res, bal