def calc(db, deal, curr_out, deal_acc, vol_out, probe=None):
# найдем партнера по подарочному коду
deal_acc_partner = deal_acc.gift and db(db.deal_accs.partner==deal_acc.gift).select().first()
if not deal_acc_partner: return
##vol_out = Decimal(vol_out)
if probe:
partner_deal_curr = db.currs[ deal_acc_partner.curr_id ]
fee_d = deal.fee or 0
if fee_d:
if probe:
print 'for partner deal_fee', fee_d
# преобразуем выходную мзду Дела в валюту аккаунта партнера
fee_rate = Decimal(rates_lib.get_avr_rate_or_null(db, deal.fee_curr_id, deal_acc_partner.curr_id))
fee_d *= fee_rate / 2
if probe:
partner_deal_curr = db.currs[ deal_acc_partner.curr_id ]
print 'for partner curr - rate -> deal_fee', fee_rate, fee_d, curr_out.abbrev, partner_deal_curr.abbrev
deal_acc_partner.partner_sum = (deal_acc_partner.partner_sum or 0) + fee_d
fee_c = curr_out.fee_out or 0
if fee_c:
if probe:
print 'for partner curr_fee_out', fee_c
# преобразуем выходную мзду валюты выхода в валюту аккаунта партнера
fee_rate = Decimal(rates_lib.get_avr_rate_or_null(db, curr_out.id, deal_acc_partner.curr_id))
fee_c *= fee_rate / 2
if probe:
print 'for partner curr - rate -> curr_fee_out', fee_rate, fee_c, curr_out.abbrev, partner_deal_curr.abbrev
deal_acc_partner.partner_sum = (deal_acc_partner.partner_sum or 0) + fee_c
if probe:
return dict(fee_d=fee_d , fee_c=fee_c, curr=partner_deal_curr.abbrev)
if fee_d or fee_c:
deal_acc_partner.update_record()
def calc_new(db, deal, curr_out, deal_acc, vol_out, probe=None):
# найдем партнера по подарочному коду
deal_acc_partner = deal_acc.gift and db(db.deal_accs.partner==deal_acc.gift).select().first()
if not deal_acc_partner: return
vol_out = Decimal(vol_out)
fee_curr = db.currs[ deal.fee_curr_id ]
# возьмем курс для валюты в котрой такса дела записана
fee_curr_rate = Decimal(rates_lib.get_avr_rate_or_null(db, fee_curr.id, curr_out.id))
if fee_curr_rate:
tax = deal.tax or 0
if tax:
# приведем к валюте дела
tax = vol_out * tax * fee_curr_rate
fee_max = deal.fee_max
fee_min = deal.fee_min
if fee_max and tax > fee_max: tax = fee_max
elif fee_min and tax < fee_min: tax = fee_min
fee = fee_rub = 3 * (fee_curr_rate(curr_out.fee_out or 0) + (deal.fee or 0) + tax) /10
if fee > PARTNER_MAX_EARN: fee_rub = PARTNER_MAX_EARN
## тут могут на обмене мизер накидать а партнерские начислятся по 1рублю
## elif fee_rub < PARTNER_MIN_EARN: fee_rub = PARTNER_MIN_EARN
# приведем таксу в валюте выхода
fee = fee / fee_curr_rate
# теперь к валюте дела пратнера приведем
# возьмем курс для валюты в котрой такса дела записана
fee_curr_rate = Decimal(rates_lib.get_avr_rate_or_null(db, fee_curr, curr_out))
if current.CURR_RUB.id != deal_acc_partner.curr_id:
pr_b, pr_s, pr_avg = rates_lib.get_average_rate_bsa(db, current.CURR_RUB.id, deal_acc_partner.curr_id)
if pr_avg:
fee = fee_rub * Decimal(pr_avg)
else:
fee = 0
if probe: return dict(fee=fee, curr=partner_deal_curr.abbrev)
deal_acc_partner.partner_sum = (deal_acc_partner.partner_sum or 0) + fee
deal_acc_partner.update_record()
def b1_sel():
try:
ii = int(request.args(0))
except:
return 'err arg0'
bonus = db.bonus[ii]
if not bonus: return 'err bonus_id'
try:
ii = int(request.vars.b1_sel)
except:
return 'err b1_sel'
### RUBLES ###
vol = b1_VOL
vol_pick = 5
## SATOSHIS ###
dis_vol = b1_BNS_need
if bonus.payed and bonus.payed > vol_pick: return 'already payed'
deal_acc = db.deal_accs[ii]
if not deal_acc: return 'err del_acc'
if deal_acc.partner:
return 'Вы являетесь партнером, а партнерам подарки не положены'
curr = db.currs[deal_acc.curr_id]
gift_curr_abbrev = 'RUB'
if curr.abbrev != gift_curr_abbrev:
rub_curr = db(db.currs.abbrev == 'RUB').select().first()
if not rub_curr:
return 'deal RUB CURR wrong'
import rates_lib
rate = Decimal(
rates_lib.get_avr_rate_or_null(db, rub_curr.id, deal_acc.curr_id))
# преобразуем рубли в валюту делла
vol_pick *= rate
vol *= rate
gift_curr_abbrev = curr.abbrev
if not deal_acc.gift_pick or deal_acc.gift_pick < vol_pick:
deal_acc.gift_pick = vol_pick
deal_acc.gift_amount = (deal_acc.gift_amount or 0) + vol
deal_acc.update_record()
deal = db.deals[deal_acc.deal_id]
import gifts_lib
gifts_lib.bonus_payout(
db,
bonus,
dis_vol,
today=None,
memo='[%s][%s] + %s[%s]' %
(deal.name, '***' + deal_acc.acc[-3:], vol, gift_curr_abbrev))
#redirect( #request.env.http_web2py_component_location,
# URL('index'), client_side=True)
return '+%s добавлено!' % vol
def get():
#common.page_stats(db, response['view'])
#print request.vars
args = request.args
if len(args) < 2: return mess('args<2 err...')
curr_id = args(0)
if len(curr_id) > 5 or not curr_id.isdigit(): return mess('curr_id dig...')
# теперь можно задать открытие кнопки
scr = "$('#cvr%s').css('display','none');$('#tag%s').show('slow');" % (
curr_id, curr_id)
response.js = scr
deal_id = args(1)
if not deal_id or len(deal_id) > 10 or not deal_id.isdigit():
return mess('deal_id vars..')
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
try:
# если русский язык то выдаст ошибку в if v.find(c) >-1:
for k, v in request.vars.items():
#print k, v
for c in u'\\/<>\'"':
if v.find(c) > -1:
return mess('error in pars <script>')
except:
pass
client = db(db.clients.deal_id == deal_id).select().first()
if client:
redirect(URL('to_shop', 'index', args=[client.id], vars={}))
volume_out = test_vol(request.vars.vol)
if not volume_out: return mess('volume_out error...')
deal = db.deals[deal_id]
vol = (deal.MIN_pay or 100) * 2
dealer, dealer_acc, dealer_deal = ed_common.select_ed_acc(
db, deal, ecurr_out, vol, True)
if not dealer:
return mess('ERROR: not found dealer for "%s"' % deal.name)
dealer_acc = ed_common.sel_acc_max_for_balance(db,
dealer,
ecurr_out,
vol,
unlim=True)
MIN = db_common.gMIN(deal, dealer)
#MAX = deal.MAX_ or 777
if MIN > volume_out:
return mess('ОШИБКА: Слишком маленькая сумма платежа, меньше чем: %s' %
MIN)
################################################
# соберем аккаунт для оплаты из введенных данных
################################################
if dealer_deal.grab_form:
deal_pars = {}
#print request.post_vars
# удалим наши параметры
for key in ['xcurr', 'volume', 'deal_id']:
deal_pars[key] = request.post_vars.pop(key)
# парамтеры что ввел пользователь обрежем чтобы скрипты не писали
for (k, v) in request.post_vars.iteritems():
if len(v) > 20:
request.post_vars[k] = v[:20]
acc = request.post_vars #.list.sort()
if len(acc) > 10:
m = 'ОШИБКА: параметров слишком много: %s, свяжитесь с администратором' % acc
print m
return mess(m)
acc = json.dumps(acc)
#print 'ACC:', acc
else:
# проверку параметров
# и собрем из параметров счет клиента
acc_pars = []
if dealer_deal.p2p:
if deal.template_ == '--':
pay_pars_deal = []
pay_pars_dealer = []
acc_pars.append('main')
else:
pay_pars_deal = ed_common.PAY_PARS_P2P
pay_pars_dealer = ed_YD.PAY_PARS_P2P
else:
pay_pars_deal = deal.template_ and json.loads(
deal.template_) or ed_common.PAY_PARS
pay_pars_dealer = dealer_deal.template_ and json.loads(
dealer_deal.template_) or ed_YD.PAY_PARS
#print request.vars
for par in pay_pars_deal:
## par - параметры от ДЕЛА
if 'calc' in par:
continue
p_n_name = par.get('n')
if not p_n_name: continue
val = request.vars[p_n_name] or ''
p = pay_pars_dealer[p_n_name]
#print p, val
if 'f' in par:
# фильтр регулярный
#regular = re.compile(p['f'])
#val = regular.sub("","%s" % val)
val = re.sub(p['f'], "", "%s" % val)
if 'ln' in p:
# проверка длинны
ln = (p['ln'] + 0)
if len(val) != ln:
l = p['l']
db.deal_errs.insert(deal_id=deal.id,
err='len!=%s - %s = %s' % (ln, l, val))
l = l.encode('utf8')
return mess('ОШИБКА: Проверьте введенные данные!')
acc_pars.append(val)
#все прошло
# теперь проверку на правильность лицевого счета и прочего для дилера электронных платежей
#dealer_acc
#print pars
if len(acc_pars) > 10:
m = 'ОШИБКА: параметров слишком много: %s, свяжитесь с администратором' % acc_pars
print m
return mess(m)
acc = ' '.join(
acc_pars).rstrip() # и удалим пробелы справа от калькуляторов
#print 'ACCOUNT:',acc
if not acc or len(acc) < 3:
return mess('ОШИБКА: Аккаунт слишком короткий: %s' % acc)
# запомним что это дело кто-то захотел оплатить
dealer_deal.update_record(wanted=dealer_deal.wanted + 1)
pattern_id = dealer_deal.scid
res = ed_common.pay_test(
db,
deal,
dealer,
dealer_acc,
dealer_deal,
acc,
#(deal.MIN_pay or dealer.pay_out_MIN or 10)*2,
volume_out,
False)
err_mess = '%s' % res
if res['status'] != 'success':
ed_common.dealer_deal_errs_add(db, dealer_deal, acc, err_mess)
response.title = T("ОШИБКА")
#print res
mm = 'error_description' in res and res['error_description'] or res[
'error'] or 'dealer error'
mm = T('Платежная система %s отвергла платеж, потому что: %s') % (
dealer.name, mm)
return mess(mm)
dealer_info = json.loads(dealer.info)
if deal.url and len(deal.url) > 0:
shops_url = deal.url
else:
shops_url = dealer_info['shops_url'] + "%s" % dealer_deal.scid
deal_img = make_img(deal, dealer_info, shops_url)
# get new or old adress for payment
x_acc_label = db_client.make_x_acc(deal, acc, curr_out.abbrev)
#print x_acc_label
# найдем ранее созданный адресс для этого телефона, этой крипты и этого фиата
# сначала найтем аккаунт у дела
deal_acc_id = db_client.get_deal_acc_id(db, deal, acc, curr_out)
#print 'deal_acc_id',deal_acc_id
#return
# теперь найдем кошелек для данной крипты
#print x_acc_label
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(' связь с кошельком ') + curr_in.name + T(' прервана.'))
addr = deal_acc_addr.addr
deal_name = deal.name
# если есть скрытый партнерский код то его забьем пользователю
deal_acc = db.deal_accs[deal_acc_id]
import gifts_lib
adds_mess = XML(gifts_lib.adds_mess(deal_acc, PARTNER_MIN, T))
deal_url = A(deal.name, _href=shops_url, _target="_blank")
e_bal, MAX = get_e_bal(deal, dealer, dealer_acc)
if MAX and volume_out > MAX: volume_out = MAX
# используем быстрый поиск курса по формуле со степенью на количество входа
# только надо найти кол-во входа от выхода
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 not best_rate:
return mess('[' + curr_in.name + '] -> [' + curr_out.name + ']' +
T(' - лучшая цена не доступна.'))
is_order = True
# сначала открутим обратную таксу
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 volume_out != vol_out_new:
print 'to_phone error_in_fees: volume_out != vol_out_new', volume_out, vol_out_new
# теперь для заказ на курс уберем комиссию диллера - просто пересчитаем вход с наченкой диллера
fee_curr = db.currs[deal.fee_curr_id]
fee_rate = Decimal(
rates_lib.get_avr_rate_or_null(db, fee_curr.id, curr_out.id))
vol_out_dd_neg, _ = db_client.dealer_deal_tax_neg(db, T, fee_rate,
dealer_deal, '',
Decimal(volume_out), '')
#print vol_out_dd_neg
# причем тут учитываем уже накрутку диллера за дело - в заказе курс будет с учетом накрутки автоматом
volume_in = common.rnd_8(volume_in)
rate_out = volume_out / volume_in
# new make order
order_rate_id = db.orders.insert(
ref_=deal_acc_addr.id,
volume_in=volume_in,
volume_out=vol_out_dd_neg,
)
# теперь стек добавим, который будем удалять потом
db.orders_stack.insert(ref_=order_rate_id)
addr_return = deal_acc_addr.addr_return
if addr_return:
addr_ret = DIV(
DIV(T('Адрес для возвратов'),
': ',
B(addr_return[:5] + '...' + addr_return[-5:]),
_class='col-sm-12'),
_class='row success',
)
else:
addr_ret = LOAD(
'aj',
'addr_ret',
#args=[deal_acc_addr.addr_return or 0, deal_acc_addr.id, ],
# лучше передавать через переменные - чтобы там по кругу они гонялись
# в request
args=[deal_acc_addr.id],
ajax=
False, # тут без асинхронной подгрузки модуля - вместе со страницей сразу грузим модуль
)
_uri, uri_url = common.uri_make(
curr_in.name2, addr, {
'amount': volume_in,
'label': db_client.make_x_acc_label(deal, acc, curr_out.abbrev)
})
qr = DIV(DIV(DIV(P(T('Показать QR-код'), _class='btn_mc2'),
_class='btn_mc1'),
_onclick='''
jQuery(this).html('%s');
ajax("%s", [], 'tag_qr');
''' % (IMG(_src=URL('static', 'images/loading.gif'),
_width=64), URL('plugins', 'qr', vars={'mess': uri_url})),
_id='tag_qr',
_class='btn_mc col-sm-6'),
_class='row')
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(
'Внимание! Для криптовалюты %s существует предел запаса и поэтому наша служба может принять только %s [%s], Просьба не превышать это ограничение'
% (curr_in.name, may_pay, curr_in_abbrev),
'.',
_style='color:black;')
else:
lim_bal_mess = P(
'ВНИМАНИЕ! Наша служба НЕ может сейчас принимать %s, так как уже достугнут предел запаса её у нас. Просьба попробовать позже, после того как запасы [%s] снизятся благодаря покупке её другими пользователями'
% (curr_in.name, curr_in_abbrev),
'. ',
'Иначе Ваш платеж будет ожидать момента когда запасы снизятся ниже %s'
% lim_bal,
'.',
_style='color:brown;')
else:
lim_bal_mess = ''
return dict(deal_name=deal_name,
adds_mess=adds_mess,
MIN=MIN,
MAX=MAX,
acc=acc,
order_rate_id=order_rate_id,
rate_out=rate_out,
curr_in_name=curr_in_abbrev,
curr_out_name=curr_out.abbrev,
e_bal=e_bal,
deal_url=deal_url,
volume_in=volume_in,
volume_out=volume_out,
tax_rep=tax_rep,
deal_img=deal_img,
uri_url=uri_url,
addr=addr,
addr_ret=addr_ret,
qr=qr,
curr_id=curr_id,
lim_bal_mess=lim_bal_mess)
def calc_fees(db,
deal,
dealer_deal,
curr_in,
curr_out,
vol_in,
rate,
is_order=None,
note=None,
only_tax=None):
vol_in = Decimal(vol_in)
use_fee = not only_tax
rate = Decimal(rate)
mess = ''
## нет! таксы считаем все рравно if curr_in.id == curr_out.id:
## return vol_in, mess
fee_curr = db.currs[deal.fee_curr_id]
fee_rate = Decimal(
rates_lib.get_avr_rate_or_null(db, fee_curr.id, curr_out.id))
##print 'fee_rate', fee_rate
abbrev_in = curr_in.abbrev
# это такса за создание заказа и столбление курса в заказе
fee = use_fee and curr_in.fee_in or 0
if fee:
vol_in -= fee
if note:
if fee > 0:
m = '-' + T('Взято с входа')
else:
m = '+' + T('Скидка с входа')
mess += m + ' %s[%s]. ' % (abs(float(fee)), abbrev_in
) #+ ' %s ' % vol_in
# тепеь добавим таксы на вход - в обратном порядке от выхода накрутки
tax = curr_in.tax_in or 0
if tax:
vol_in -= vol_in * tax * Decimal(0.01)
if note:
if tax > 0:
m = '-' + T('Взято за вход')
else:
m = '+' + T('Дар за вход')
mess += m + ' [' + abbrev_in + ']: %s' % abs(
float(tax)) + '%. ' #+ ' %s ' % vol_in
# теперь посмотрим сколько получили выхода:
vol = vol_in * rate
if note:
mess += T('Прямой курс') + ': x%s' % float(rate) + ', ' + T(
'Обратный курс') + ': /%s. ' % float(1 / rate)
# добавим наш оброк на вывод
abbrev_out = curr_out.abbrev
# теперь доход нам за это дело
# добавим таксу нашу на вывод валюты
tax = curr_out.tax_out or 0
if tax:
vol -= vol * tax * Decimal(0.01)
if note:
if tax > 0:
m = ' -' + T('Взято за выход')
else:
m = ' +' + T('Дар за выход')
mess += m + ' [' + abbrev_out + ']: %s' % abs(
float(tax)) + '%. ' #+ ' %s ' % vol
fee = use_fee and curr_out.fee_out or 0
if fee:
vol -= fee
if note:
if fee > 0:
m = '-' + T('Взято с выхода')
else:
m = '+' + T('Скидка с выхода')
mess += m + ' %s[%s]. ' % (abs(float(fee)), abbrev_out
) #+ ' %s ' % vol
# добавим наш заработок с этого дела
tax = deal.tax or 0
if tax:
if note:
if tax > 0:
m = '-' + T('Взято за это дело')
else:
m = '+' + T('Дар на это дело')
mess += m + ': %s' % abs(float(tax)) + '% '
# хдесь относительное поэтому без приведения к курсу fee_rate
tax_fee = vol * tax * Decimal(0.01)
# тут валюта мзды может быть другой
fee_min = use_fee and deal.fee_min or 0
fee_max = use_fee and deal.fee_max or 0
if fee_min:
# приведем к валюте выхода
fee_min *= fee_rate
if fee_max:
# приведем к валюте выхода
fee_max *= fee_rate
# теперь проверим на превышения
if fee_min and abs(tax_fee) < abs(fee_min):
tax_fee = fee_min
if note:
mess += ' (' + T('ограничено снизу') + ': %s[%s])' % (abs(
round(float(tax_fee), 8)), abbrev_out)
elif fee_max and abs(tax_fee) > abs(fee_max):
tax_fee = fee_max
if note:
mess += '(' + T('ограничено сверху') + ': %s[%s])' % (abs(
round(float(tax_fee), 8)), abbrev_out)
else:
if note:
mess += ' (=%s[%s])' % (abs(round(float(tax_fee),
8)), abbrev_out)
vol -= tax_fee
if note:
mess += '. '
#mess += ' %s ' % vol
fee = use_fee and deal.fee or 0
if fee:
# приведем к валюте выхода
fee *= fee_rate # для отображения тоже пересчет тут
vol -= fee
if note:
if fee > 0:
m = '-' + T('Взято за эту услугу')
else:
m = '+' + T('Дар на эту услугу')
mess += m + ': %s[%s]. ' % (abs(float(fee)), abbrev_out
) #+ ' %s ' % vol
# мзда диллера - то что он снимает с нас свыше суммы платежа
if dealer_deal:
vol, mess = dealer_deal_tax_add(db, T, fee_rate, dealer_deal,
abbrev_out, vol, mess, note, only_tax)
return vol, mess
def calc_fees_back(db,
deal,
dealer_deal,
curr_in,
curr_out,
vol_out,
rate,
is_order=None,
note=None,
only_tax=None):
vol_out = Decimal(vol_out)
rate = Decimal(rate)
use_fee = not only_tax
mess = ''
## НЕТ таксы все равно считаем if curr_in.id == curr_out.id:
## return vol_out, mess
abbrev_out = curr_out.abbrev
fee_curr = db.currs[deal.fee_curr_id]
fee_rate = Decimal(
rates_lib.get_avr_rate_or_null(db, fee_curr.id, curr_out.id))
##print 'back - fee_rate', fee_rate, fee_curr.abbrev, abbrev_out
################ BACK ##################################
## сделано перестановкой от оригинала и - на + поменял
# мзда диллера - то что он снимает с нас свыше суммы платежа
if dealer_deal:
vol_out, mess = dealer_deal_tax_neg(db, T, fee_rate, dealer_deal,
abbrev_out, vol_out, mess, note,
only_tax)
fee = use_fee and deal.fee or 0
if fee:
fee *= fee_rate
vol_out += fee
if note:
if fee > 0:
m = '-' + T('Взято за эту услугу')
else:
m = '+' + T('Дар на эту услугу')
mess += m + ': %s[%s]. ' % (abs(float(fee)), abbrev_out
) #+ ' %s ' % vol_out
# добавим наш заработок с этого дела
tax = deal.tax or 0
if tax:
if note:
if tax > 0:
m = '-' + T('Взято за это дело')
else:
m = '+' + T('Дар на это дело')
mess += m + ': %s' % abs(float(tax)) + '% '
fee_min = use_fee and deal.fee_min or 0
fee_max = use_fee and deal.fee_max or 0
# Приведем к валюте Мзды Дела
if fee_min: fee_min *= fee_rate
if fee_max: fee_max *= fee_rate
## тут берем функуию MU
tax_fee = vol_out / (1 - tax * Decimal(0.01)) - vol_out
if fee_min and abs(tax_fee) < abs(fee_min):
tax_fee = fee_min
if note:
mess += ' (' + T('ограничено снизу') + ': %s[%s])' % (abs(
float(tax_fee)), abbrev_out)
elif fee_max and abs(tax_fee) > abs(fee_max):
tax_fee = fee_max
if note:
mess += '(' + T('ограничено сверху') + ': %s[%s])' % (abs(
float(tax_fee)), abbrev_out)
else:
if note:
mess += ' (=%s[%s])' % (abs(float(tax_fee)), abbrev_out)
vol_out += tax_fee
if note:
mess += '. '
#mess += ' %s ' % vol_out
# добавим наш оброк на вывод
fee = use_fee and curr_out.fee_out or 0
if fee:
vol_out += fee
if note:
if fee > 0:
m = '-' + T('Взято с выхода')
else:
m = '+' + T('Скидка с выхода')
mess += m + ' %s[%s]. ' % (abs(float(fee)), abbrev_out
) #+ ' %s ' % vol_out
# теперь доход нам за это дело
# добавим таксу нашу на вывод валюты
tax = curr_out.tax_out or 0
if tax:
## тут берем функуию MU
vol_out = vol_out / (1 - tax * Decimal(0.01)
) ## vol_out*tax*Decimal(0.01)
if note:
if tax > 0:
m = ' -' + T('Взято за выход')
else:
m = ' +' + T('Дар за выход')
mess += m + ' [' + abbrev_out + ']: %s' % abs(
float(tax)) + '%. ' #+ ' %s ' % vol_out
# теперь посмотрим сколько получили выхода:
vol = vol_out / rate
if note:
mess += T('Прямой курс') + ': x%s' % float(rate) + ', ' + T(
'Обратный курс') + ': /%s. ' % float(1 / rate)
abbrev_in = curr_in.abbrev
# тепеь добавим таксы на вход - в обратном порядке от выхода накрутки
tax = curr_in.tax_in or 0
if tax:
## тут берем функуию MU
vol = vol / (1 - tax * Decimal(0.01)) ## vol*tax*Decimal(0.01)
if note:
if tax > 0:
m = '-' + T('Взято за вход')
else:
m = '+' + T('Дар за вход')
mess += m + ' [' + abbrev_in + ']: %s' % abs(
float(tax)) + '%. ' #+ ' %s ' % vol
# это такса за создание заказа и столбление курса в заказе
fee = use_fee and curr_in.fee_in or 0
if fee:
vol += fee
if note:
if fee > 0:
m = '-' + T('Взято с входа')
else:
m = '+' + T('Скидка с входа')
mess += m + ' %s[%s]. ' % (abs(float(fee)), abbrev_in)
return vol, mess
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 pay(db,
deal,
dealer,
dealer_acc,
dealer_deal,
acc,
volume_out_full,
log_on=None,
pars_in=None):
fee_curr = db.currs[deal.fee_curr_id]
curr_out, x, ecurr_out = db_common.get_currs_by_abbrev(db, "RUB")
if fee_curr.id == curr_out.id:
fee_rate = 1
else:
import rates_lib
fee_rate = Decimal(
rates_lib.get_avr_rate_or_null(db, fee_curr.id, curr_out.id))
## проверка тут http://127.0.0.1:8000/ipay3_dvlp/tool_deal/fees/BTC/4049/100/1
volume_out, _ = db_client.dealer_deal_tax_add(db, None, fee_rate,
dealer_deal, '',
Decimal(volume_out_full), '')
volume_out = round(float(volume_out), 2)
if dealer.name == 'Yandex':
res = ed_YD.pay(db, deal, dealer, dealer_acc, dealer_deal, acc,
volume_out, None, None, log_on, pars_in)
if res['status'] == u'refused' and res.get(
'error') == u'authorization_reject':
# авторизация кончилась - надо этот счет выключить
print 'pay - authorization_reject for', dealer_acc.acc
dealer_acc.update_record(used=False)
#print 'authorization_reject'
else:
res = {
'status': 'refused',
'error': 'no dealer',
'error_description': dealer.name + ' not scripted',
}
if res and res['status'] == 'success':
sum_taken = res.get('sum_taken')
# платеж прошел и было взято с нас, запомним
if log_on != False:
print 'ed_common pay() res:', res
add_trans(
db,
dict(dealer_acc_id=dealer_acc.id,
info='%s' % res,
vars=res,
balance=res.get('balance'),
amo=-sum_taken,
op_id=res.get('payment_id')))
update_balances(db, dealer, dealer_acc,
-sum_taken) #, res.get('balance'))
else:
try:
db_common.pay_err_store(db, dealer, dealer_acc, deal, acc,
res.get('error'))
except Exception as e:
log(db, e)
pass
return res
