def accept():
import common
if common.not_is_local(): raise HTTP(200, T('ERROR'))
id = request.args(0)
shop_add = id and db.shops_add[id]
res = CAT()
if not shop_add:
res = SQLFORM.smartgrid(db.shops_add)
return dict(res=res)
res = SQLFORM(db.shops_add, shop_add)
if res.accepts(request.vars, session):
#response.flash = T('new record inserted')
# берем ИД новой записи
new_shop_id = res.vars.id
shop = db(db.shops.name == res.vars.name).select().first()
shop = shop or db(db.shops.url == res.vars.url).select().first()
shop = shop or db(db.shops.email == res.vars.email).select().first()
if shop:
raise HTTP(
500,
T('Запись с такими данными уже есть, обратитесь к администратору для решения вопроса.'
))
pars = res.vars.copy()
id_old = pars['id']
# удалим лишние поля!
for k in ['id', 'CMS']:
_ = pars.pop(k)
addr1 = pars.pop('wallet_BTC')
addr2 = pars.pop('wallet_LTC')
print pars
new_shop_id = db.shops.insert(**pars)
# теперь добавим кошельки
import db_common
if addr1:
_, xcurr, _ = db_common.get_currs_by_addr(db, addr1)
db.shops_xwallets.insert(shop_id=new_shop_id,
xcurr_id=xcurr.id,
addr=addr1)
if addr2:
_, xcurr, _ = db_common.get_currs_by_addr(db, addr2)
db.shops_xwallets.insert(shop_id=new_shop_id,
xcurr_id=xcurr.id,
addr=addr2)
del db.shops_add[id_old]
print 'accepted'
response.flash = ' ACCEPTED!'
# надо сбросить параметр - редиректом
redirect(URL('accept'))
return dict(res=res)
def found_pay_ins_addr(T, db, addr, shop_order_id_in=None):
pays =[]
# все зачтенные за последний месяц
# сначала выдадим все неоплоченные входы - они в стеке
curr_in = xcurr_in = _ =None
if shop_order_id_in:
shop_order = db.shop_orders[shop_order_id_in]
pp = shop_order.payed_soft + shop_order.payed_hard + shop_order.payed_true
if pp == 0: pp ='0'
pays.append({ T('Всего оплачено'):
'%s' % pp })
#mess_pays = 'SOFT:%s, HARD:%s, TRUE:%s.' % \
# (shop_order.payed_soft, shop_order.payed_hard, shop_order.payed_true)
#pays.append({'по статусам': mess_pays})
if addr:
curr_in, xcurr_in, _ = db_common.get_currs_by_addr(db, addr)
# если задан адрес то ищем проводки по нему
for pay in db(
(db.pay_ins.id == db.pay_ins_stack.ref_id)
& (db.pay_ins.shop_order_addr_id == db.shop_order_addrs.id)
& (db.shop_order_addrs.addr==addr)
).select(orderby=~db.pay_ins.created_on):
xcurr = xcurr_in or db.xcurrs[pay.shop_order_addrs.xcurr_id]
#if xcurr_in and xcurr_in.id != xcurr.id: continue
curr_in = curr_in or db.currs[xcurr.curr_id]
shop_order = shop_order or db.shop_orders[pay.shop_order_addrs.shop_order_id]
shop = db.shops[shop_order.shop_id]
curr_out = db.currs[shop_order.curr_id]
curr_out = db.currs[shop_order.curr_id]
####################
shop_name = db_common.get_shop_name(shop)
status = pay.pay_ins.status
#print '1pay.pay_ins.amo_out:', pay.pay_ins.amo_out
amo_out = pay.pay_ins.amo_out
if not amo_out or amo_out == 0: amo_out = '??'
mess_in = '%s [%s] <- %s [%s] %s %s' % ( amo_out, curr_out.abbrev, pay.pay_ins.amount, curr_in.abbrev, status, pay.pay_ins.created_on)
if pay.pay_ins.rate_order_id:
rate_order = db.rate_orders[pay.pay_ins.rate_order_id]
if rate_order:
mess_in = mess_in + T(' (курс по счету: %s)') % common.rnd_8(rate_order.volume_out / rate_order.volume_in)
elif pay.pay_ins.amo_out and pay.pay_ins.amo_out != pay.pay_ins.amount:
mess_in = mess_in + ' (по текущему курсу: %s)' % common.rnd_8(pay.pay_ins.amo_out / pay.pay_ins.amount)
pays.append({
T('Вход'): mess_in,
})
#print '2pay.pay_ins.amo_out:', pay.pay_ins.amo_out
return pays
def parse_mess(db, mess, creator):
if not mess:
return None
args = mess.strip().split('\n')[0].split(':')
print 'parse_mess:', mess, args
import db_common
arg1 = args[0].strip()
if len(arg1) < 20:
# as ABBREV
curr_out, xcurr_out, _ = db_common.get_currs_by_abbrev(db, arg1)
if xcurr_out:
if len(args) > 1:
addr = args[1].strip()
if addr[0] == '[':
addr = addr[1:]
if addr[-1] == ']':
addr = addr[:-1]
return curr_out.abbrev + ':' + addr
else:
return curr_out.abbrev + ':' + creator
# may be here only ADDRESS
if len(arg1) > 30:
from db_common import get_currs_by_addr
curr_out, xcurr_out, _ = get_currs_by_addr(db, arg1)
if xcurr_out:
return curr_out.abbrev + ':' + arg1
try:
token_id = int(arg1)
if len(args) > 1:
addr = args[1].strip()
if addr[0] == '[':
addr = addr[1:]
if addr[-1] == ']':
addr = addr[:-1]
return arg1 + ':' + addr
else:
return arg1 + ':' + creator
except:
pass
def validate_addr():
time.sleep(1)
addr = len(
request.args) > 0 and request.args[0] or request.vars.get('addr')
if not addr:
return {'error': "need addr: /validate_addr.json/[addr]"}
from db_common import get_currs_by_addr
curr, xcurr, _ = get_currs_by_addr(db, addr)
if not xcurr:
return {"error": "invalid curr"}
from crypto_client import conn
conn = conn(curr, xcurr)
if not conn:
return {"error": "not connected to wallet [%s]" % curr.abbrev}
valid = conn.validateaddress(addr)
if not valid.get('isvalid'):
return {"error": "invalid for [%s]" % curr.abbrev}
return {'curr': curr.abbrev, 'ismine': valid.get('ismine')}
def is_simple_shop(db, vars, shop_id):
shop = None
if len(shop_id) > 30:
# это адрес криптовалюты куда выводить - тут магазин неизвестен
curr, xcurr, _ = db_common.get_currs_by_addr(db, shop_id)
if not xcurr:
return None, None
cc = crypto_client.conn(curr, xcurr)
if not cc or crypto_client.is_not_valid_addr(cc, shop_id):
return None, None
# поиска магазина еще не было - False
shop = make_simple_shop(db, shop_id, vars, False, curr, xcurr)
if not shop:
# мгазин не найден и не создан
return None, None
shop_id = shop.id
elif not shop_id.isdigit():
return None, None
shop = shop or db.shops[shop_id]
return shop, shop_id
def for_addr():
session.forget(response)
addr = request.vars and request.vars.get('addr')
#print addr
if not addr or len(addr) < 24: return dict(pays=T('ошибочный адрес [%s]') % addr)
pays = where.found_buys(db, addr)
if len(pays)>0:
return dict(pays=pays)
pays=[]
# все еще не подтвержденные
curr, xcurr, _, = db_common.get_currs_by_addr(db, addr)
#print curr, '\n', xcurr
if not curr or not curr.used: return dict(pays=T('ошибочный адрес по первой букве [%s]') % addr)
where.found_unconfirmed(db, curr, xcurr, addr, pays)
where.found_pay_ins(db, curr, xcurr, addr, pays, None)
if len(pays)==0: pays = T('Входов не найдено...')
return dict(pays=pays)
def register_simple():
time.sleep(1)
addr = request.args(0)
if not addr or len(addr) < 30:
time.sleep(3)
return 'len(addr) < 30'
from db_common import get_currs_by_addr
curr, xcurr, _ = get_currs_by_addr(db, addr)
if not curr:
time.sleep(3)
return 'addr[1] not valid'
from crypto_client import is_not_valid_addr, conn
cc = conn(curr, xcurr)
if not cc:
return 'Connection to ' + curr.abbrev + ' wallet is lost. Try later'
if is_not_valid_addr(cc, addr):
time.sleep(3)
return 'Address is not valid for [' + curr.abbrev + ']'
url = request.vars['shop_url']
if url and url in [
'http://localhost', 'http://127.0.0.1', 'https://localhost',
'https://127.0.0.1'
]:
time.sleep(1)
return 'cant use [localhost] !'
shop = db(db.shops.name == addr).select().first()
if shop:
return -shop.id # already registered
# жестко зададим валюту конвертации
from shops_lib import make_simple_shop
shop = make_simple_shop(db, addr, request.vars, True, curr, xcurr)
if not shop:
time.sleep(2)
return 'Error on making registration. Please connect to support'
return shop.id
def bills_draw_insert(db, shop_order, curr, amo, desc):
# сначала подсчет общего веса
tab = shop_order.addrs
vol = 0
for (k, v) in tab.iteritems():
v = float(v)
vol += v
tab[k] = v
# теперь вычислим курсы обмена для данной крипты входа
rates = rates_lib.get_best_rates(
db, curr) # загодя возьмем курсы обмена для этой крипты
amo = float(amo)
# посмотрим что оставить магазину в резерв
amo_keep = 0
keep = shop_order.keep
if keep and keep > 0:
if keep > 1: keep = 1
amo_keep = amo * float(keep)
# новое АМО берем
amo = amo - amo_keep
for (addr, v) in tab.iteritems():
amo_out = rnd_8(v / vol * amo)
# найдем курс обмена
curr2, x, e = db_common.get_currs_by_addr(db, addr)
if curr2.id != curr.id:
rate = rates_lib.get_best_rate(rates, curr2, amo_out)
amo_out = rate * amo_out
_id = db.bills_draws.insert(
shop_order_id=shop_order.id,
curr_id=curr2.id,
addr=addr,
amo=amo_out,
)
db.commit() # гаче там потом берется неизмененый баланс
return Decimal(amo_keep)
def bank_check():
import time
addr = request.vars.get('addr')
ref = request.vars.get('ref')
amo = request.vars.get('amo')
if not addr: return mess('Адрес кошелька пуст') # Wallet address is empty
if not ref: return mess('Номер платежа пуст') # Reference address is empty
if not amo: return mess('Сумма не задана') # Amount is empty
if not amo.replace('.', '').isdigit(): return mess('Amount Error')
time.sleep(2)
rec = db((db.buys_stack.ref_ == db.buys.id)
& (db.buys.amount == amo)
& (db.buys.buyer.startswith(ref + ' '))).select().first()
# если вводился не номер платежа а номер платежа [op_id]
rec = rec or db((db.buys_stack.ref_ == db.buys.id)
& (db.buys.amount == amo)
& (db.buys.operation_id == ref)).select().first()
if not rec:
return mess('Платеж не найден') # Records not founded
if rec.buys.addr:
return mess('Адрес уже задан') # This payment already assigned!!!
from db_common import get_currs_by_addr
curr, xcurr, _ = get_currs_by_addr(db, addr)
if not xcurr:
return mess("Неверный адрес") # Invalid wallet address
conn = crypto_client.conn(curr, xcurr)
if not conn:
return mess("Нет связи с [%s]" %
curr.abbrev) # Not connected to wallet [%s]
valid = conn.validateaddress(addr)
if not valid.get('isvalid'):
return mess("Неверный адрес для [%s]" %
curr.abbrev) # Invalid wallet address for [%s]
rec.buys.update_record(xcurr_id=xcurr.id, addr=addr)
return mess('Задан для %s' % curr.name, 'info-bg')
def is_payment_for_buy(db, dealer_acc, info):
#log(db, 'INFO %s' % json.dumps(info))
'''
amount :99.5
u'expires - это значит платеж подвис - надо его принять - внести данные паспорта
codepro :False
datetime :2013-11-14T13:47:27Z
details :CLR Cdv7iZEbvxYNte8T6WNgE5gq149WFqZ994
direction :in
message :CLR Cdv7iZEbvxYNte8T6WNgE5gq149WFqZ994
operation_id :875504095892034017
pattern_id :p2p
sender :410011949054154
status :success
title :Перевод от 410011949054154
'''
mess = is_bank = None
#log(db, json.dumps(info or ''))
if not info:
mess = 'income_YD: get_payment_info - NOT INFO'
elif 'error' in info:
mess = 'income_YD: get_payment_info - %s' % info['error']
elif info['status'] != 'success':
mess = 'income_YD: get_payment_info - NOT success'
elif info.get('direction') != 'in':
mess = 'income_YD: get_payment_info - direction not input'
elif info.get('codepro'):
# защита кодом - такие возвращаем назад
mess = 'income_YD: get_payment_info - protected=True'
elif False and info.get('expires'):
## у платежжа который пропихнули ве равно остается этот параметр (
mess = 'income_YD: get_payment_info - expires: %s' % info.get(
'expires')
elif 'pattern_id' not in info:
# платеж из АЛЬФА-БАНКА так приходит - без pattern
# print info
if info.get('type') == 'deposition':
# это пополнение кошелька из банка
# если там нет ошибок то в INFO положим новые данные
#print info
mess = is_payment_for_buy_from_bank(db, dealer_acc, info)
if not mess:
is_bank = True
#print 'is_payment_for_buy_from_bank: \n', mess or info
else:
mess = 'not "pattern_id" in info'
elif info['pattern_id'] != 'p2p':
mess = 'income_YD: get_payment_info - NOT p2p'
elif not 'message' in info:
# это нен аш платеж log(db, 'income_YD: get_payment_info - message=None' )
mess = 'not mess'
if mess:
#log(db, mess)
return None, mess
'''
buy_ = db( (db.buys.dealer_acc_id==dealer_acc.id)
& (db.buys.operation_id == info['operation_id'])
).select().first()
if buy_:
# такая операция уже была выплочена
mess = 'income_YD: - operation_id %s already buyed' % info['operation_id']
#log(db, mess)
return None, mess
'''
curr = xcurr = partner = addr = None
info_message = info.get('message')
##if info_message and not is_bank:
if info_message:
ss = info_message
ss = ss.encode('utf8') ## иначе русские буквы при печати ошибку делают
##ss = str(ss).decode('cp1251')
#print ss
abbrev, addr_0, addr = ss.partition(' ')
print 'abbrev=%s\naddr_0=%s\naddr=%s' % (abbrev, addr_0, addr)
if abbrev and not addr:
xcurr, addr = ed_common.is_order_addr(db, abbrev)
if not xcurr:
addr = abbrev
abbrev = db_common.get_currs_by_addr(db, addr, True)
log(db, 'try use %s as ADDR' % addr)
#print abbrev, addr
if not abbrev:
mess = 'xcurr or wallet addr not in payments message [%s]' % info[
'message']
log(db, mess)
#print mess
return None, mess
# это наж платеж - его в крипту перегнать надо
# запомним это в базе чтобы если ошибка будет то потом попытаться еще раз
if not xcurr:
if len(abbrev) == 3:
# это абревиатура крипты
curr, xcurr, e = db_common.get_currs_by_abbrev(db, abbrev)
elif len(abbrev) == 5:
# это код партнера
curr, xcurr, e = db_common.get_currs_by_addr(db, addr)
partner = abbrev
if not xcurr:
mess = 'income_YD: xcurr [%s] not found or adr[%s] invalid' % (
abbrev, addr)
log(db, mess)
##return None, mess
pass ## а пусть все платежи отражаются в необработанных
else:
# тут нет адреса в примечании к платежу
# вручную его запросим у пользоваеля
pass
##print xcurr
return {
'sender': info['sender'],
'operation_id': info['operation_id'],
'amo': info['amount'],
'curr': curr,
'xcurr': xcurr,
'addr': addr and addr.strip() or None,
'ecurr_abbrev': 'RUB',
'partner': partner,
}, None
def is_payment_for_buy(db, dealer_acc, info):
#log(db, 'INFO %s' % json.dumps(info))
'''
amount :
99.5
codepro :
False
datetime :
2013-11-14T13:47:27Z
details :
CLR Cdv7iZEbvxYNte8T6WNgE5gq149WFqZ994
direction :
in
message :
CLR Cdv7iZEbvxYNte8T6WNgE5gq149WFqZ994
operation_id :
875504095892034017
pattern_id :
p2p
sender :
410011949054154
status :
success
title :
Перевод от 410011949054154
'''
mess = None
#log(db, json.dumps(info or ''))
if not info:
mess = 'income_YD: get_payment_info - NOT INFO'
elif 'error' in info:
mess = 'income_YD: get_payment_info - %s' % info['error']
elif info['status'] != 'success':
mess = 'income_YD: get_payment_info - NOT success'
elif 'pattern_id' not in info:
# платеж из АЛЬФА-БАНКА так приходит - без pattern
# print info
mess = 'not "pattern_id" in info'
elif info['pattern_id'] != 'p2p':
mess = 'income_YD: get_payment_info - NOT p2p'
elif info.get('direction') != 'in':
mess = 'income_YD: get_payment_info - direction not input'
elif info.get('codepro'):
# защита кодом - такие возвращаем назад
mess = 'income_YD: get_payment_info - protected=True'
elif not 'message' in info:
# это нен аш платеж log(db, 'income_YD: get_payment_info - message=None' )
mess = 'not mess'
if mess:
#log(db, mess)
return None, mess
buy_ = db((db.buys.dealer_acc_id == dealer_acc.id)
&
(db.buys.operation_id == info['operation_id'])).select().first()
if buy_:
# такая операция уже была выплочена
mess = 'income_YD: - operation_id %s already buyed' % info[
'operation_id']
#log(db, mess)
return None, mess
abbrev, addr_0, addr = info['message'].partition(' ')
print 'abbrev, addr_0, addr', abbrev, addr_0, addr
if abbrev and not addr:
addr = abbrev
abbrev = db_common.get_currs_by_addr(db, addr, True)
log(db, 'try use %s as ADDR' % addr)
print abbrev, addr
if not abbrev:
mess = 'xcurr or wallet addr not in payments message [%s]' % info[
'message']
log(db, mess)
print mess
return None, mess
curr = xcurr = partner = None
# это наж платеж - его в крипту перегнать надо
# запомним это в базе чтобы если ошибка будет то потом попытаться еще раз
if len(abbrev) == 3:
# это абревиатура крипты
curr, xcurr, e = db_common.get_currs_by_abbrev(db, abbrev)
elif len(abbrev) == 5:
# это код партнера
curr, xcurr, e = db_common.get_currs_by_addr(db, addr)
partner = abbrev
if not xcurr:
mess = 'income_YD: xcurr [%s] not found or adr[%s] invalid' % (abbrev,
addr)
log(db, mess)
return None, mess
return {
'sender': info['sender'],
'operation_id': info['operation_id'],
'amo': info['amount'],
'curr': curr,
'xcurr': xcurr,
'addr': addr,
'ecurr_abbrev': 'RUB',
'partner': partner,
}, None
def make(db, request):
shop_id = request.args(0)
if not shop_id:
return {'error': 'request.args is empty'}, None
# проверка на "просто" магазин - без регистраций
# если да -то там будет вставлены параметры: public=1 conv_curr=ADDRESS_CURR
shop, _ = shops_lib.is_simple_shop(db, request.vars, shop_id)
if not shop:
return {'error': 'shop [%s] not found' % shop_id}, None
price = request.vars.get('price', 0)
if price and price < 0: price = 0
abbrev = request.vars.get('curr', 'BTC') # по умолчанию BTC
curr, _x, _e = db_common.get_currs_by_abbrev(db, abbrev)
if not curr:
# тут пока может быть любая валюта и фиат тоже
# попробуем ее у Пай Пал стянуть
import rates_yahoo
err, pair_base = rates_yahoo.set_curr(db, abbrev)
if err:
# PayPal ну его нафиг
#import rates_paypal
#err, res = rates_paypal.set_curr(db, abbrev)
#if err:
log(
db, 'make', {
'error': '[%s] not found as a currency' % abbrev,
'mess': '%s' % err
})
return {'error': '[%s] not found as a currency' % abbrev}, None
curr = db.currs[pair_base.curr1_id]
# обязательные параметры все норм
conv_curr = shop.simple_curr and db.currs[shop.simple_curr]
conv_curr_abbr = request.vars.get('conv_curr')
if not conv_curr and conv_curr_abbr:
conv_curr, x, e = db_common.get_currs_by_abbrev(db, conv_curr_abbr)
if not x:
return {
'error':
'[conv_curr=%s] not found as crypto-currency' % conv_curr_abbr
}, None
###''' это тут нельзя делать а то за магазин счета будут создавать мошеники - и пользоваться как ширмой магазином
# соберем параметр - выплата на адреса с весовыми коэффициентами а не в магазин
addrs = {}
addr_curr = None
for (k, v) in request.vars.iteritems():
if len(k) > 30:
try:
v = float(v)
except: # Exception as e:
continue
addrs[k] = v
if not addr_curr:
addr_curr, x, e = db_common.get_currs_by_addr(db, k)
#print addr_curr
if len(addrs) == 0: addrs = None
# валюту конвертации поменяем если заданы авто-адреса выплат
conv_curr = addr_curr or conv_curr
###'''
# если надо что-то сохранить на сервисе и не переводить автоматом в магазин - то задаем:
keep = request.vars.get('keep') or 0.0
try:
keep = float(keep)
except: # Exception as e:
keep = 0.0
keep = keep > 1 and 1.0 or keep < 0 and 0.0 or keep
# если задан Публичный параметр, то не делать секрет
secr = None
if 'public' not in request.vars:
#secr = '%s %s %s' % (shop.id, order_id, datetime.now() )
#secr = abs(hash( secr ))
secr = base64.b64encode(os.urandom(6), '_-')[:8]
# номер заказа может быть тоже пустой - тогда генерим свой случайный
order_id = request.vars.get('order') or base64.b64encode(
os.urandom(6), '_-')[:8]
expire = None
if price:
expire = request.vars.get('expire')
if expire:
expire = int(expire)
if expire < 10: expire = 20
elif expire > EXPIRE_MAX: expire = EXPIRE_MAX
shop_order_pars = dict(
shop_id=shop.id,
curr_id=curr.id,
order_id=order_id,
price=price,
conv_curr_id=conv_curr and conv_curr.id or None,
keep=keep,
expire=expire,
exchanging=request.vars.get('exchanging') and True or False,
mess=request.vars.get('mess'),
secr=
secr, # секретный ключ если счет не публичный - чтобы другие его не могли смотреть в АПИ
lang=request.vars.get('lang'),
not_convert='not_convert'
in request.vars, # если задан то не конвертировать
curr_in=request.vars.get(
'curr_in'), # curr_in and json.dumps(curr_in) or None,
curr_in_stop=request.vars.get(
'curr_in_stop'), #curr_in and json.dumps(curr_in) or None,
back_url=request.vars.get('back_url'),
note_on=request.vars.get('note_on') or shop.note_on,
vol_default=request.vars.get('vol'),
email=request.vars.get(
'email'), # можно сразу задать емайл для уведомлений
# тут нельзя - только по команде от магазина! addrs = addrs,
)
#print shop_order_pars
#log(db, 'make vars', request.vars)
#log(db, 'make fields', shop_order_pars)
shop_order_id = db.shop_orders.insert(**shop_order_pars)
if price and Decimal(price) > 0: # преобразуем в число
# для ордеров с ценой - стек на просрочку добавим
expire_on = get_expire_on(datetime.datetime.now(), expire)
db.shop_orders_stack.insert(ref_id=shop_order_id, expire_on=expire_on)
#####################################################
# преобразуем в строчку иначе ошибка тут
res = '%s' % shop_order_id
if secr:
res += '.%s' % secr
return None, res
def validate_addr():
import time
time.sleep(1)
xcurr = None
curr_abbrev = request.vars.get('curr')
addr = request.vars.get('addr')
if len(request.args) == 1:
addr = request.args[0]
if len(request.args) == 2:
curr_abbrev = request.args[0]
addr = addr or request.args[1]
if not addr:
return {
'error':
'need addr or curr_abbrev, example: /validate_addr.json/[addr] or /validate_addr.json/[curr_abbrev]/[addr]'
}
if addr and not curr_abbrev:
from db_common import get_currs_by_addr
curr, xcurr, _ = get_currs_by_addr(db, addr)
if curr_abbrev:
from db_common import get_currs_by_abbrev
curr, xcurr, _ = get_currs_by_abbrev(db, curr_abbrev)
if not xcurr:
return {"error": "invalid curr_abbrev"}
token_system_out = None
token_key = xcurr.as_token
if token_key:
token = db.tokens[token_key]
token_system = db.systems[token.system_id]
import rpc_erachain
curr_block = rpc_erachain.get_info(token_system.connect_url)
if type(curr_block) != type(1):
return {
'error': 'Connection to [%s] is lost, try later ' % curr.name
}
if rpc_erachain.is_not_valid_addr(token_system.connect_url, addr):
return {
'error': 'address not valid for ' + curr.name + ' - ' + addr
}
return {'curr': curr.abbrev, 'ismine': token_system.account == addr}
else:
from crypto_client import conn
try:
conn = conn(curr, xcurr)
except:
conn = None
if not conn:
return {
'error': 'Connection to [%s] is lost, try later ' % curr.name
}
valid = conn.validateaddress(addr)
#import crypto_client
#if crypto_client.is_not_valid_addr(conn, addr):
# return { 'error': 'address not valid for - ' + curr.abbrev}
if not valid.get('isvalid'):
return {
"error": "invalid for [%s]" % curr.abbrev,
'mess': '%s' % valid
}
return {
'curr': curr.abbrev,
'ismine': valid.get('ismine'),
'mess': '%s' % valid
}
def history():
if len(request.args) == 1:
acc = request.args(0)
if not acc or len(acc) > 200:
return mess('wrong account. Use ABBREV/ACCOUNT')
curr, xcurr, _, = db_common.get_currs_by_addr(db, acc)
if not xcurr:
return mess('Use ABBREV/ACCOUNT')
curr_out_abbrev = curr.abbrev
elif len(request.args) == 2:
curr_out_abbrev = request.args(0)
if not curr_out_abbrev or len(curr_out_abbrev) > 10:
return mess('wrong currency ABBREV. Use ABBREV/ACCOUNT')
acc = request.args(1)
if not acc or len(acc) > 200:
return mess('wrong account. Use ABBREV/ACCOUNT')
else:
return mess('Use ABBREV/ACCOUNT')
deal_acc = db((db.deal_accs.acc == acc)
& (db.deal_accs.curr_id == db.currs.id)
& (db.currs.abbrev == curr_out_abbrev)).select().first()
if not deal_acc:
return mess('Deal ACCOUNT not found. Use ABBREV/ACCOUNT')
deal_acc = deal_acc.deal_accs
deal = db.deals[deal_acc.deal_id]
from pytz import utc, timezone
from time import mktime
import where3
############ UNCONFIRMED ############
pays_unconf = []
## found income ADDRS
## not TOKENS system
for r in db((db.currs.used)
& (db.currs.id == db.xcurrs.curr_id)
& (db.deal_acc_addrs.deal_acc_id == deal_acc.id)
& (db.xcurrs.id == db.deal_acc_addrs.xcurr_id)).select():
if r.xcurrs.as_token > 0:
continue
xcurr_in = r.xcurrs
curr_in = r.currs
addr = r.deal_acc_addrs.addr
pays_unconf_curr = where3.found_unconfirmed_coins(
db, curr_in, xcurr_in)
for item in pays_unconf_curr:
if item[8] == addr:
pays_unconf.append(item)
## SSE all TOKEN SYSTEMS
for token_system in db(db.systems).select():
# add ALL incomes
pays_unconf_curr = where3.found_unconfirmed_tokens(db, token_system)
for item in pays_unconf_curr:
pays_unconf.append(item)
####################### IN PROCCESS ##############
in_proc = []
for r in db((db.pay_ins_stack.ref_ == db.pay_ins.id)
& (db.pay_ins.ref_ == db.deal_acc_addrs.id)
& (db.deal_acc_addrs.deal_acc_id == deal_acc.id)
& (db.deal_accs.id == deal_acc.id)
& (db.xcurrs.id == db.deal_acc_addrs.xcurr_id)
& (db.currs.id == db.xcurrs.curr_id)).select(
orderby=~db.pay_ins.created_on):
result = histoty_result(db, r)
in_proc.append(result)
expired = datetime.datetime.now() - datetime.timedelta(40, 0)
done = []
for r in db((db.pay_ins.ref_ == db.deal_acc_addrs.id)
& (db.deal_acc_addrs.deal_acc_id == deal_acc.id)
& (db.deal_accs.id == deal_acc.id)
& (db.xcurrs.id == db.deal_acc_addrs.xcurr_id)
& (db.currs.id == db.xcurrs.curr_id)
& (db.pay_ins.created_on > expired)).select(
orderby=~db.pay_ins.created_on):
if db(db.pay_ins.id == db.pay_ins_stack.ref_).select().first():
continue
result = histoty_result(db, r)
pay_in = r.pay_ins
if pay_in.payout_id:
pay_out = db.pay_outs[pay_in.payout_id]
if pay_out:
pay_put_result = dict(
amo_gift=float(pay_out.amo_gift),
amo_in=float(pay_out.amo_in),
amo_partner=float(pay_out.amo_partner),
amo_taken=float(pay_out.amo_taken),
amo_to_pay=float(pay_out.amo_to_pay),
amount=float(pay_out.amount),
created_on=pay_out.created_on,
created_ts=mktime(
utc.localize(pay_out.created_on).utctimetuple()),
id=pay_out.id,
info=pay_out.info,
status=pay_out.status,
tax_mess=pay_out.tax_mess,
txid=pay_out.txid,
vars=pay_out.vars)
if pay_out.dealer_acc_id:
#deal_acc = db.deal_accs[pay_out.ref_]
#deal = db.deals[deal_acc.deal_id]
pay_put_result[
'dealer_acc'] = dealer_acc = db.dealers_accs[
pay_out.dealer_acc_id]
#curr_out = db.currs[dealer_acc.curr_id]
pay_put_result['dealer'] = db.dealers[dealer_acc.dealer_id]
#rec_vals['dealer_deal'] = db((db.dealer_deals.deal_id == deal.id)
# & (db.dealer_deals.dealer_id == dealer.id)).select().first()
result['pay_out'] = pay_put_result
elif pay_in.clients_tran_id:
# это выплатата клиенту
cl_tr = db.clients_trans[pay_in.clients_tran_id]
client = db.clients[cl_tr.client_id]
result['client'] = dict(id=client.id,
transaction=pay_in.clients_tran_id)
done.append(result)
deal_res = dict(id=deal.id, name=deal.name, MAX=float(deal.MAX_pay))
import gifts_lib
if 'to COIN' in deal.name:
rnd = 8
else:
rnd = 2
deal_acc_mess = XML(gifts_lib.adds_mess(deal_acc, PARTNER_MIN, T, rnd))
deal_acc_res = dict(
id=deal_acc.id,
name=deal_acc.acc,
to_pay=float(deal_acc.to_pay or Decimal(0)),
payed_month=float(not deal.is_shop and deal_acc.payed_month
or Decimal(0)),
payed=float(deal_acc.payed or Decimal(0)),
price=float(deal_acc.price or Decimal(0)),
gift_amount=float(deal_acc.gift_amount),
gift_payed=float(deal_acc.gift_payed),
gift_pick=float(deal_acc.gift_pick),
curr_out_id=deal_acc.curr_id,
message=deal_acc_mess)
#print 'pays:', pays
out_res = dict(deal=deal_res,
deal_acc=deal_acc_res,
unconfirmed=pays_unconf,
in_process=in_proc,
done=done)
return request.extension == 'html' and dict(
h=DIV(BEAUTIFY(out_res), _class='container')) or out_res
