def decode_key(key, interface_map):
inf, carrier, area = key.split(':')
inf_carrier = inf + '-' + carrier
inf_name = []
for _inf in inf.split('+'):
inf_name.append(interface_map.get(_inf, _inf))
carrier = escape_carrier(carrier)
area = escape_area(area)
return '+'.join(inf_name), carrier, area, inf_carrier
def decode_product(p):
'''
copy & decode
'''
p1 = p.copy()
p1['type_n'] = PRODUCT_TYPE.get(p1['type'])
p1['carrier_n'] = escape.escape_carrier(str(p1['carrier']))
p1['area_n'] = escape.escape_area(p1['area'])
p1['use_area_n'] = escape.escape_area(p1['use_area'])
p1['status_n'] = STATUS.get(p1['status'])
return p1
def get_product(self):
p = re.compile('1\d{6}')
mobile = self.get_argument('m', None)
user_id = self.current_user['partner_id']
if mobile is None or not p.match(mobile):
return self.finish(json.dumps({'status': 'fail'}))
head = int(mobile[0:7])
o, a = self.application.classifier.search(head)
name = '%s%s' % (escape_area(a), escape_carrier(str(o)))
slave = self.slave
if 'master' in self.application.config['downstream'][user_id]:
master_id = self.application.config['downstream'][user_id]['master']
else:
master_id = user_id
plist = []
prods = slave.keys('product:{master_id}:data:{carrier}:{area}:*'.format(master_id=master_id, carrier=o, area=a))
if len(prods) == 0:
a = 'CN'
prods = slave.keys('product:{master_id}:data:{carrier}:CN:*'.format(master_id=master_id, carrier=o))
for k in prods:
prod = self.slave.hmget(k, ['carrier', 'value', 'name', 'discount', 'scope'])
value = float(prod[1]) * int(prod[3]) / 10000
scope = prod[4] or '0'
offer = '%s:%s:%s' % (prod[0], a, prod[1])
if scope != '0':
offer = offer + ':' + scope
plist.append({
'offer': offer,
'name': '%s' % prod[2],
'value': '%0.3f' % value,
'face': int(prod[1]),
'scope': scope,
})
plist = sorted(plist, key=lambda p: '%s %05d' % (p['scope'], p['face']))
self.finish(json.dumps({'status': 'ok',
'name': name,
'prod': plist}, indent=4))
def get(self):
slave = self.slave
user_id = self.current_user['partner_id']
d = self.application.config['downstream'][user_id]
master_id = d.get('master', user_id)
product_key = slave.keys('product:%s:*' % master_id)
product_list = {'1': [], '2': [], '3': []}
for pid in product_key:
info = slave.hmget(
pid, ['offer', 'carrier', 'value', 'discount', 'name'])
area = pid.split(':')[4]
carrier = info[1]
product_list[carrier].append({
'offer':
info[0],
'carrier':
carrier,
'carrier_name':
escape_carrier(carrier),
'price':
info[2],
'value': (float(info[2]) * float(info[3]) / 10000),
'name':
info[4],
'area':
area,
'area_name':
escape_area(area),
})
self.finish(json.dumps({'msg': 'ok', 'product': product_list}))
def post_list(self):
domain_id = self.json_args.get('domain_id')
up_domain_id = self.json_args.get('up_domain_id')
filter_id = self.json_args.get('id', None)
filter_price = self.json_args.get('price', None)
filter_name = self.json_args.get('name', None)
filter_type = self.json_args.get('type', None)
filter_carrier = self.json_args.get('carrier', None)
filter_area = self.json_args.get('area', None)
filter_status = self.json_args.get('status', None)
page = int(self.json_args['page'])
size = int(self.json_args['size'])
session = self.session('repo')
try:
if up_domain_id:
up_domain = session.query(RepoDomain).filter(
RepoDomain.domain_id == domain_id).filter(
RepoDomain.up_domain == up_domain_id).first()
if up_domain is None:
raise RuntimeError('CANNOT FOUND %s <= %s' %
(domain_id, up_domain_id))
q = session.query(RepoProduct).filter(
RepoProduct.domain_id == domain_id)
if filter_id:
q = q.filter(RepoProduct.product_id.like('%' + filter_id +
'%'))
if filter_price:
q = q.filter(RepoProduct.price == filter_price)
if filter_name:
q = q.filter(RepoProduct.name.like('%' + filter_name + '%'))
if filter_type:
q = q.filter(RepoProduct.type == filter_type)
if filter_carrier:
q = q.filter(RepoProduct.carrier == filter_carrier)
if filter_area:
q = q.filter(RepoProduct.area == filter_area)
if filter_status:
q = q.filter(RepoProduct.status == filter_status)
count = q.count()
max_page = int(math.ceil(count / size))
product_list = []
q = q.order_by(RepoProduct.carrier, RepoProduct.area,
RepoProduct.scope, RepoProduct.value).offset(
(page - 1) * size).limit(size)
for p in q.all():
product_list.append({
'id':
p.product_id,
'name':
p.name,
'type':
p.type,
'carrier':
p.carrier,
'price':
p.price,
'area':
p.area,
'use_area':
p.use_area,
'status':
p.status,
'value':
p.value,
'notes':
p.notes,
'tsp':
str(p.update_time),
'p1':
p.p1,
'p2':
p.p2,
'p3':
p.p3,
'p4':
p.p4,
'p5':
p.p5,
'scope':
p.scope,
'legacy':
p.legacy_id,
'routing':
p.routing,
'type_n':
PRODUCT_TYPE.get(p.type),
'carrier_n':
escape.escape_carrier(str(p.carrier)),
'area_n':
escape.escape_area(p.area),
'use_area_n':
escape.escape_area(p.use_area),
'status_n':
STATUS.get(p.status),
})
self.finish(
json.dumps({
'status': 'success',
'page': page,
'max': max_page,
'list': product_list
}))
except Exception as e:
self.finish(json.dumps({'status': 'fail', 'msg': str(e)}))
finally:
session.close()
def get_list(self):
domain_id = self.get_argument('domain_id')
session = self.session('repo')
try:
product_list = []
q = session.query(RepoProduct).filter(
RepoProduct.domain_id == domain_id).order_by(
RepoProduct.carrier, RepoProduct.area, RepoProduct.scope,
RepoProduct.value).all()
for p in q:
product_list.append({
'id':
p.product_id,
'name':
p.name,
'type':
p.type,
'carrier':
p.carrier,
'price':
p.price,
'area':
p.area,
'use_area':
p.use_area,
'status':
p.status,
'value':
p.value,
'notes':
p.notes,
'tsp':
str(p.update_time),
'p1':
p.p1,
'p2':
p.p2,
'p3':
p.p3,
'p4':
p.p4,
'p5':
p.p5,
'scope':
p.scope,
'legacy':
p.legacy_id,
'routing':
p.routing,
'type_n':
PRODUCT_TYPE.get(p.type),
'carrier_n':
escape.escape_carrier(str(p.carrier)),
'area_n':
escape.escape_area(p.area),
'use_area_n':
escape.escape_area(p.use_area),
'status_n':
STATUS.get(p.status),
})
self.finish(json.dumps(product_list))
finally:
session.close()
def post(self):
args = self.json_args
page = args.get('page')
size = args.get('size')
interface_map = self.application.config.get('interface')
try:
# find
order_collection = self.application.glados_client.GLaDOS.order
filter_dict = {}
#订单类型
if 'supply_type' in args and args['supply_type']:
filter_dict['truman_order.supply_type'] = args['supply_type']
#订单编号
if 'id' in args and args['id']:
filter_dict['_id'] = args['id']
# 采购商
if 'user_id' in args and args['user_id']:
filter_dict['user_id'] = args['user_id']
#供货商
if 'supply_user_id' in args and args['supply_user_id']:
filter_dict['truman_order.user_id'] = args['supply_user_id']
#产品 [流量，话费，油卡]
if 'product' in args and args['product']:
filter_dict['product'] = args['product']
#充值账号
if 'phone' in args and args['phone']:
filter_dict['mobile'] = args['phone']
#起始与结束时间
if 'start' in args and 'end' in args and args['start'] and args[
'end']:
# 2015/08/02 09:49:32
start = datetime.datetime.strptime(args['start'],
'%Y/%m/%d %H:%M:%S')
end = datetime.datetime.strptime(args['end'],
'%Y/%m/%d %H:%M:%S')
filter_dict['req_time'] = {'$gte': start, '$lte': end}
#订单状态
if 'state' in args and args['state']:
# -1 and processing
if args['state'] == 'processing':
filter_dict['$and'] = [{
'result': {
'$in': ['00000', '0']
}
}, {
'back_result': None
}]
# 1 and finish
elif args['state'] == 'success':
filter_dict['$or'] = [{
'back_result': '1'
}, {
'result': '1'
}, {
'back_result': '00000'
}]
# fail
elif args['state'] == 'fail':
filter_dict['$or'] = [{
'$and': [{
'back_result': None
}, {
'result': {
'$nin': ['00000', '0']
}
}]
}, {
'back_result': {
'$nin': [None, '00000', '1']
}
}]
#运营商
if 'carrier' in args and args['carrier']:
if 'area' in args and args['area']:
filter_dict['area'] = '%s:%s' % (args['carrier'],
args['area'])
else:
filter_dict['area'] = {
'$regex': ('^' + args['carrier'] + ':.{2}')
}
else:
if 'area' in args and args['area']:
filter_dict['area'] = {
'$regex': ('.:' + args['area'] + '$')
}
#上游路由
if args.get('route'):
filter_dict['up_order.route'] = args.get('route')
if len(filter_dict) == 0:
return self.write(
json.dumps({
'status': 'fail',
'msg': '您未选择任何过滤条件，请至少输入一个'
}))
count = yield order_collection.find(filter_dict).count()
max_page = int(math.ceil(count / int(args['size'])))
cursor = order_collection.find(filter_dict).sort([
('req_time', pymongo.DESCENDING)
]).skip((page - 1) * size).limit(size)
data_list = []
product_cache = dict() # per-handler cache
while (yield cursor.fetch_next):
order_doc = cursor.next_object()
# 订单编号 手机号 产品名称 运营商 面值 采购金额 开始时间 状态时间 批次号 订单状态 备注
o = {
'id':
order_doc.get('_id'),
'sp_id':
order_doc.get('sp_order_id'),
'shard':
order_doc.get('shard'),
'phone':
order_doc.get('mobile'),
# 'value': (order_doc.get('value') is not None and '%.3f' % (order_doc.get('value') / 10000)) or '-',
'create':
str(order_doc.get('req_time')),
'update':
order_doc.get('back_time')
and str(order_doc.get('back_time')),
# 'balance': (order_doc.get('balance') is not None and '%0.03f' % (
# order_doc.get('balance') / 10000)) or '-',
'product':
order_doc.get('product'),
'result':
order_doc.get('result'),
'price':
order_doc.get('price'),
'scope':
order_doc.get('scope'),
'back_result':
order_doc.get('back_result'),
'area':
order_doc.get('area'),
'user_id':
order_doc.get('user_id'), #采购商
'supply_user_id':
order_doc.get('truman_order', {}).get('user_id'), #供货商
'value':
order_doc.get('value'), #采购价
'sell_value':
order_doc.get('truman_order', {}).get('sell_price'), #供货价
}
if order_doc.get('up_order'):
route = order_doc.get('up_order')[-1].get('route')
o['route'] = interface_map.get(route, route)
user_id = order_doc.get('user_id')
supply_user_id = o['supply_user_id']
if 'user_id' in self.application.config['downstream'] and 'master' in \
self.application.config['downstream'][user_id]:
master_id = self.application.config['downstream'][user_id][
'master']
else:
master_id = user_id
carrier = ''
carrier_name = ''
area = ''
if order_doc.get('area') and ':' in order_doc.get('area'):
carrier, area = order_doc['area'].split(':')
carrier_name = escape_carrier(carrier)
area_name = escape_area(area)
o['result'] = decode_status(order_doc)
o['name'] = decode_name(self.slave, order_doc, carrier,
carrier_name, area, area_name,
master_id, product_cache)
o['carrier'] = area_name + carrier_name
service_url = None
if user_id in self.application.config['downstream']:
o['user_name'] = self.application.config['downstream'][
user_id]['name']
service_url = self.application.config['downstream'][
user_id]['shard']
if supply_user_id in self.application.config['downstream']:
o['supply_user_name'] = self.application.config[
'downstream'][supply_user_id]['name']
if not o.get('route') and service_url:
_id = order_doc.get('_id')
url = 'http://%s/admin/info?order_id=%s' % (service_url,
_id)
result = yield get_route(url)
if result:
route = result.get('route/1')
if route:
o['route'] = '_' + str(
interface_map.get(route, route))
data_list.append(o)
self.finish(
json.dumps({
'data': data_list,
'max': max_page,
'page': page,
'size': size
}))
except Exception:
request_log.exception('QUERY CHAIN')
self.send_error(500)
def post_update(self):
domain_id = self.json_args.get('domain_id')
product_id = self.json_args.get('id')
value = self.json_args.get('value', None)
status = self.json_args.get('status', None)
p1 = self.json_args.get('p1', None)
p2 = self.json_args.get('p2', None)
p3 = self.json_args.get('p3', None)
p4 = self.json_args.get('p4', None)
p5 = self.json_args.get('p5', None)
session = self.session('repo')
try:
q = session.query(RepoProduct).filter(
RepoProduct.domain_id == domain_id).filter(
RepoProduct.product_id == product_id)
product = q.first()
if product is None:
raise ValueError('NOT FOUND')
if value:
product.value = value
if status:
product.status = status
if p1:
product.p1 = p1
if p2:
product.p2 = p2
if p3:
product.p3 = p3
if p4:
product.p4 = p4
if p5:
product.p5 = p5
session.add(product)
session.commit()
self.finish(
json.dumps({
'status': 'ok',
'msg': 'update',
'product': {
'id': product.product_id,
'name': product.name,
'type': product.type,
'carrier': product.carrier,
'price': product.price,
'area': product.area,
'use_area': product.use_area,
'status': product.status,
'value': product.value,
'notes': product.notes,
'tsp': str(product.update_time),
'p1': product.p1,
'p2': product.p2,
'p3': product.p3,
'p4': product.p4,
'p5': product.p5,
'scope': product.scope,
'legacy': product.legacy_id,
'routing': product.routing,
'type_n': PRODUCT_TYPE.get(product.type),
'carrier_n':
escape.escape_carrier(str(product.carrier)),
'area_n': escape.escape_area(product.area),
'use_area_n': escape.escape_area(product.use_area),
'status_n': STATUS.get(product.status),
}
}))
# yield core.sync_pricing(session, domain_id, filter_product=product_id)
self.master.lpush(
'list:sync:pricing',
'{domain_id},{product_id},{user_id}'.format(
domain_id=domain_id, product_id=product_id, user_id=''))
except Exception as e:
self.finish(json.dumps({'status': 'fail', 'msg': str(e)}))
finally:
session.close()
def escape_carrier(carrier_str):
carrier_list = []
for carrier in carrier_str.split(','):
carrier_list.append(escape.escape_carrier(carrier))
return ', '.join(carrier_list)
def post(self, path):
if 'admin-routing' not in self.current_user['roles']:
self.finish()
return
if path == '/all':
user_id = self.json_args.get('user_id')
carrier = self.json_args.get('carrier')
area = self.json_args.get('area')
price = self.json_args.get('price')
cfg = self.application.config['madeira']
r = redis.Redis(host=cfg['ip'], port=cfg['port'], db=cfg['db'], decode_responses=True)
routing_list = []
try:
session = self.session('purus')
q = session.query(Routing).filter(
Routing.carrier == carrier)
if user_id:
q = q.filter(Routing.user_id == user_id)
if price:
q = q.filter(Routing.price == price)
if area:
q = q.filter(Routing.area == area)
q = q.order_by(Routing.user_id, Routing.area, Routing.price)
for routing in q.all():
k = 'route:{user_id}:fee:{carrier}:{area}:{price}'.format(
user_id=routing.user_id,
carrier=routing.carrier,
area=routing.area,
price=routing.price)
v = r.get(k)
request_log.info('GET %s = %s', k, v)
if v is None:
status = 'OFF'
elif v == routing.routing:
status = 'ON'
else:
status = 'UNKNOWN(%s)' % v
carrier_name = escape_carrier(str(routing.carrier))
area_name = escape_area(routing.area)
routing_list.append({'id': routing.id,
'user_id': routing.user_id,
'carrier': carrier_name,
'area': area_name,
'price': routing.price,
'routing': routing.routing,
'status': status})
session.close()
self.finish(json.dumps({'status': 'ok', 'routing': routing_list}))
except Exception as e:
self.finish(json.dumps({'status': 'fail', 'msg': repr(e)}))
elif path == '/set':
routing_id = self.json_args['id']
func = self.json_args['func']
cfg = self.application.config['madeira']
r = redis.Redis(host=cfg['ip'], port=cfg['port'], db=cfg['db'], decode_responses=True)
try:
session = self.session('purus')
routing = session.query(Routing).filter(Routing.id == routing_id).one()
session.close()
k = 'route:{user_id}:fee:{carrier}:{area}:{price}'.format(
user_id=routing.user_id,
carrier=routing.carrier,
area=routing.area,
price=routing.price)
if func == 'ON':
request_log.debug('SET %s %s' % (k, routing.routing))
r.set(k, routing.routing)
elif func == 'OFF':
request_log.debug('DEL %s' % k)
r.delete(k)
self.finish(json.dumps({'status': 'ok'}))
except Exception as e:
self.finish(json.dumps({'status': 'fail', 'msg': repr(e)}))
elif path == '/setall':
user_id = self.json_args.get('user_id')
carrier = self.json_args.get('carrier')
price = self.json_args.get('price')
area = self.json_args.get('area')
func = self.json_args['func']
cfg = self.application.config['madeira']
r = redis.Redis(host=cfg['ip'], port=cfg['port'], db=cfg['db'], decode_responses=True)
try:
session = self.session('purus')
q = session.query(Routing).filter(Routing.carrier == carrier)
if user_id:
q = q.filter(Routing.user_id == user_id)
if area:
q = q.filter(Routing.area == area)
if price:
q = q.filter(Routing.price == price)
q = q.order_by(Routing.user_id, Routing.area, Routing.price)
for routing in q.all():
k = 'route:{user_id}:fee:{carrier}:{area}:{price}'.format(
user_id=routing.user_id,
carrier=routing.carrier,
area=routing.area,
price=routing.price)
if func == 'ON':
request_log.debug('SET %s %s' % (k, routing.routing))
r.set(k, routing.routing)
elif func == 'OFF':
request_log.debug('DEL %s' % k)
r.delete(k)
session.close()
self.finish(json.dumps({'status': 'ok'}))
except Exception as e:
self.finish(json.dumps({'status': 'fail', 'msg': repr(e)}))
else:
self.finish('')
def post_list_supply(self):
domain_id = self.json_args.get('domain_id')
user_id = self.json_args.get('user_id', None)
product_id = self.json_args.get('product_id', None)
area = self.json_args.get('area', None)
carrier = self.json_args.get('carrier', None)
page = int(self.json_args['page'])
size = int(self.json_args['size'])
session = self.session('repo')
try:
q = session.query(RepoSpecial, RepoProduct, RepoRouteSupply, RepoUser).filter(
RepoProduct.domain_id == domain_id).filter(
RepoSpecial.product_id == RepoProduct.product_id).filter(
RepoSpecial.user_id == RepoUser.user_id).filter(
RepoSpecial.supply == RepoRouteSupply.id).filter(
RepoSpecial.supply != None)
if area:
q = q.filter(RepoProduct.area == area)
if carrier:
q = q.filter(RepoProduct.carrier == carrier)
if user_id:
q = q.filter(RepoSpecial.user_id == user_id)
if product_id:
q = q.filter(RepoSpecial.product_id == product_id)
count = q.count()
max_page = int(math.ceil(count / size))
product_list = []
q = q.order_by(RepoProduct.carrier, RepoProduct.area, RepoProduct.scope, RepoProduct.value).offset(
(page - 1) * size).limit(
size)
for sp, pr, su, ur in q:
product_list.append({
'id': pr.product_id,
'name': pr.name,
'type': pr.type,
'carrier': pr.carrier,
'price': pr.price,
'area': pr.area,
'use_area': pr.use_area,
'status': pr.status,
'p1': pr.p1,
'p2': pr.p2,
'p3': pr.p3,
'p4': pr.p4,
'p5': pr.p5,
'scope': pr.scope,
'legacy': pr.legacy_id,
'routing': sp.supply,
'routing_n': su.name,
'type_n': PRODUCT_TYPE.get(pr.type),
'carrier_n': escape.escape_carrier(str(pr.carrier)),
'area_n': escape.escape_area(pr.area),
'use_area_n': escape.escape_area(pr.use_area),
'status_n': STATUS.get(pr.status),
'product_value': sp.value,
'user_id': sp.user_id,
'user_name': ur.name,
'product_id': pr.product_id,
'value': pr.value,
'tsp': str(sp.update_time),
'tsp_status': str(sp.update_status_time),
'tsp_supply': str(sp.update_supply_time),
'tsp_value': str(sp.update_value_time),
'notes': sp.notes
})
self.finish(json.dumps({
'status': 'success',
'page': page,
'max': max_page,
'list': product_list
}))
finally:
session.close()
def post(self, product):
args = self.json_args
page = args.get('page')
size = args.get('size')
max_page = 0
product_cache = dict()
result = []
try:
if 'admin' not in self.current_user['roles']:
user_id = self.current_user['partner_id']
else:
user_id = args.get('user_id')
criteria = {'product': product}
if user_id:
criteria['user_id'] = user_id
if args.get('account'):
criteria['mobile'] = args.get('account')
if args.get('start') and args.get('end'):
start = datetime.strptime(args.get('start'), '%Y/%m/%d %H:%M:%S')
end = datetime.strptime(args.get('end'), '%Y/%m/%d %H:%M:%S')
criteria['req_time'] = {'$gte': start, '$lt': end}
if args.get('result'):
if args.get('result') == 'processing':
criteria['$and'] = [{'result': {'$in': ['00000', '0']}}, {'back_result': None}]
# 1 and finish
elif args.get('result') == 'success':
criteria['$or'] = [{'back_result': '1'}, {'result': '1'}, {'back_result': '00000'}]
# fail
elif args.get('result') == 'fail':
criteria['$or'] = [{'$and': [{'back_result': None}, {'result': {'$nin': ['00000', '0']}}]},
{'back_result': {'$nin': [None, '00000', '1']}}]
if args.get('id'):
criteria['_id'] = args.get('id')
if args.get('sp_id'):
criteria['sp_order_id'] = args.get('sp_id')
if args.get('carrier'):
if args.get('area'):
criteria['area'] = '%s:%s' % (args.get('carrier'), args.get('area'))
else:
criteria['area'] = {'$regex': ('^' + args.get('carrier') + ':.{2}')}
elif args.get('area'):
criteria['area'] = {'$regex': ('.:' + args.get('area') + '$')}
if len(criteria) <= 1:
return self.write(json.dumps({'status': 'fail', 'msg': '您未选择任何过滤条件，请至少输入一个'}))
order_collection = self.application.glados_client.GLaDOS.order
count = yield order_collection.find(criteria).count()
max_page = int(math.ceil(count / int(args['size'])))
cursor = order_collection.find(criteria).sort([('req_time', pymongo.DESCENDING)]).skip(
(page - 1) * size).limit(size)
# 订单编号 手机号 产品名称 运营商 面值 采购金额 开始时间 状态时间 批次号 订单状态 备注
while (yield cursor.fetch_next):
order_doc = cursor.next_object()
carrier = ''
carrier_name = ''
area = order_doc.get('area')
if area and ':' in area:
carrier, area = area.split(':')
carrier_name = escape_carrier(carrier)
area_name = escape_area(area)
if user_id in self.application.config['downstream']:
master_id = self.application.config['downstream'][user_id].get('master')
else:
master_id = user_id
o = {
'id': order_doc.get('_id'),
'sp_id': order_doc.get('sp_order_id'),
'account': order_doc.get('mobile'),
'price': str(order_doc.get('price') or '-'),
'value': (order_doc.get('value') and '%.3f' % (order_doc.get('value') / 10000)) or '-',
'create': str(order_doc.get('req_time')),
'update': str(order_doc.get('back_time') or ''),
'result': decode_status(order_doc),
'name': decode_name(self.slave, order_doc, carrier, carrier_name, area, area_name, master_id,
product_cache),
'carrier': area_name + carrier_name,
'balance': (order_doc.get('balance') and '%0.03f' % (order_doc.get('balance') / 10000)) or '-',
}
result.append(o)
except:
request_log.exception('FAIL ON QUERY2')
self.write(json.dumps({
'count': count,
'data': result,
'max': max_page,
'page': page,
'size': size
}))
def post(self):
args = self.json_args
page = int(args['page'])
size = int(args['size'])
# if 'admin' in self.current_user['roles'] and 'user_id' in args:
# user_id = args['user_id']
# else:
# user_id = self.current_user['partner_id']
user_id = args['user_id']
session = self.session('madeira')
result = []
if 'shard_id' in self.application.config['downstream'][user_id]:
master_id = self.application.config['downstream'][user_id][
'shard_id']
elif 'master' in self.application.config['downstream'][user_id]:
master_id = self.application.config['downstream'][user_id][
'master']
else:
master_id = user_id
trans_cls = get_trans_shard(master_id)
q = session.query(trans_cls).filter(trans_cls.user_id == user_id)
f = False
# filter
if args['account']:
q = q.filter(trans_cls.account == args['account'])
f = True
if args['start'] and args['end']:
start = time.strptime(args['start'], '%Y/%m/%d %H:%M:%S')
end = time.strptime(args['end'], '%Y/%m/%d %H:%M:%S')
q = q.filter(trans_cls.create_time >= start) \
.filter(trans_cls.create_time < end)
f = True
# if args['name']:
# q = q.filter(trans_cls.status == args['name'])
# f = True
if args['type']:
q = q.filter(trans_cls.type == args['type'])
f = True
if not f:
return self.write(
json.dumps({
'status': 'fail',
'msg': '您未选择任何过滤条件，请至少输入一个'
}))
count = q.count()
# print(count)
max_page = int(math.ceil(count / int(args['size'])))
q = q.order_by(desc(trans_cls.create_time), desc(trans_cls.id)) \
.offset((page - 1) * size) \
.limit(size)
# 订单编号 手机号 产品名称 运营商 面值 采购金额 开始时间 状态时间 批次号 订单状态 备注
'''
id = Column(Integer, primary_key=True)
trans_id = Column(String)
type = Column(String)
income = Column(Integer)
outcome = Column(Integer)
balance = Column(Integer)
order_id = Column(String)
user_id = Column(String)
account = Column(String)
name = Column(String)
create_time = Column(DateTime)
notes = Column(String)
'''
for trans in q:
name = ''
if trans.name:
n = trans.name.split(':')
if len(n) == 3:
c = escape_carrier(n[0])
p = escape_area(n[1])
v = n[2]
name = '%s%s%s元直充' % (p, c, v)
o = {
'id': trans.trans_id,
'type': escape_finance_type(trans.type),
'value': '%.3f' % ((trans.income - trans.outcome) / 10000),
'balance': '%.3f' % (trans.balance / 10000),
'order_id': trans.order_id,
'account': trans.account,
'time': str(trans.create_time),
'name': name,
'notes': trans.notes or '',
}
result.append(o)
session.close()
self.write(
json.dumps({
'data': result,
'max': max_page,
'page': page,
'size': size
}))
def post_product_supply_list(self):
domain_id = self.json_args.get('domain_id')
product_list = list()
supply_list = list()
filter_id = self.json_args.get('id', None)
filter_price = self.json_args.get('price', None)
filter_name = self.json_args.get('name', None)
filter_type = self.json_args.get('type', None)
filter_carrier = self.json_args.get('carrier', None)
filter_area = self.json_args.get('area', None)
filter_status = self.json_args.get('status', None)
page = int(self.json_args['page'])
size = int(self.json_args['size'])
session = self.session('repo')
try:
#
supply_map = {}
q = session.query(RepoRouteSupply).filter(
RepoRouteSupply.domain_id == domain_id).order_by(
RepoRouteSupply.id)
for supply in q.all():
supply_map[str(supply.id)] = supply.name
supply_list.append({'id': supply.id, 'name': supply.name})
q = session.query(RepoProduct).filter(
RepoProduct.domain_id == domain_id)
if filter_id:
q = q.filter(RepoProduct.product_id == filter_id)
if filter_price:
q = q.filter(RepoProduct.price == filter_price)
if filter_name:
q = q.filter(RepoProduct.name == filter_name)
if filter_type:
q = q.filter(RepoProduct.type == filter_type)
if filter_carrier:
q = q.filter(RepoProduct.carrier == filter_carrier)
if filter_area:
q = q.filter(RepoProduct.area == filter_area)
if filter_status:
q = q.filter(RepoProduct.status == filter_status)
count = q.count()
max_page = int(math.ceil(count / size))
q = q.order_by(RepoProduct.carrier, RepoProduct.area,
RepoProduct.scope, RepoProduct.value).offset(
(page - 1) * size).limit(size)
for p in q:
product_list.append({
'id':
p.product_id,
'name':
p.name,
'type':
p.type,
'carrier':
p.carrier,
'price':
p.price,
'area':
p.area,
'use_area':
p.use_area,
'status':
p.status,
'value':
p.value,
'notes':
p.notes,
'tsp':
str(p.update_time),
'p1':
p.p1,
'p2':
p.p2,
'p3':
p.p3,
'p4':
p.p4,
'p5':
p.p5,
'scope':
p.scope,
'legacy':
p.legacy_id,
'routing':
p.routing,
'routing_n':
supply_map.get(p.routing, '(无效的货源)'),
'type_n':
PRODUCT_TYPE.get(p.type),
'carrier_n':
escape.escape_carrier(str(p.carrier)),
'area_n':
escape.escape_area(p.area),
'use_area_n':
escape.escape_area(p.use_area),
'status_n':
STATUS.get(p.status),
})
resp = json.dumps({
'status': 'success',
'page': page,
'max': max_page,
'product': product_list,
'supply': supply_list
})
except:
request_log.exception('LIST PRODUCT-SUPPLY FAIL')
resp = json.dumps({'status': 'fail'})
finally:
session.close()
self.finish(resp)
def post(self):
args = self.json_args
page = int(args['page'])
size = int(args['size'])
user_id = args['user_id']
try:
# find
#db = self.mongo.GLaDOS.transaction
db = self.application.mongo1.GLaDOS.transaction
f = False
filter_dict = {}
#filter_dict['user_id'] = user_id
if args['account']:
filter_dict['account'] = args['account']
f = True
if args['start'] and args['end']:
import datetime
start = time.strptime(args['start'], '%Y/%m/%d %H:%M:%S')
start = datetime.datetime(start.tm_year, start.tm_mon,
start.tm_mday, start.tm_hour,
start.tm_min)
end = time.strptime(args['end'], '%Y/%m/%d %H:%M:%S')
end = datetime.datetime(end.tm_year, end.tm_mon, end.tm_mday,
end.tm_hour, end.tm_min)
filter_dict['create_time'] = {'$gte': start, '$lte': end}
f = True
if args['type']:
filter_dict['type'] = args['type']
f = True
if not f:
return self.write(
json.dumps({
'status': 'fail',
'msg': '您未选择任何过滤条件，请至少输入一个'
}))
count = db.find(filter_dict).count()
max_page = int(math.ceil(count / int(args['size'])))
orders = db.find(filter_dict) \
.sort([('req_time', pymongo.DESCENDING)]) \
.skip((page - 1) * size) \
.limit(size)
# 订单编号 手机号 产品名称 运营商 面值 采购金额 开始时间 状态时间 批次号 订单状态 备注
'''
id = Column(Integer, primary_key=True)
trans_id = Column(String)
type = Column(String)
income = Column(Integer)
outcome = Column(Integer)
balance = Column(Integer)
order_id = Column(String)
user_id = Column(String)
account = Column(String)
name = Column(String)
create_time = Column(DateTime)
notes = Column(String)
'''
result = []
if orders:
for order in orders:
name = ''
if order.get('name'):
n = order.get('name').split(':')
if len(n) == 4:
p = n[0]
if p == 'data':
p = '流量'
elif p == 'fee':
p = '话费'
c = escape_carrier(n[1])
a = escape_area(n[2])
v = n[3]
name = '%s%s%s元%s充值' % (a, c, v, p)
o = {
'id':
order.get('_id'),
'type':
escape_finance_type(order.get('type')),
'value':
'%.3f' %
((order.get('income') - order.get('outcome')) / 10000),
'balance':
'%.3f' % (order.get('balance') / 10000),
'order_id':
order.get('order_id'),
'account':
order.get('account'),
'time':
str(order.get('create_time')),
'name':
name,
'notes':
order.get('notes') or '',
}
result.append(o)
except Exception:
request_log.exception('QUERY MONGO ERROR')
self.send_error(500)
return
finally:
print(
'--------------------------------finish---------------------------------------'
)
self.write(
json.dumps({
'data': result,
'max': max_page,
'page': page,
'size': size
}))
def post(self, product):
#### SAFTY ######
safety = self.application.config.get('safety')
if safety is None:
request_log.error('CONFIG FAIL (NO SAFETY)')
return self.send_error(500)
# verify ip in white list
if self.request.remote_ip not in safety['white_list']:
request_log.error("CONFIG FAIL ('%s' NOT IN WHITELIST)",
self.request.remote_ip)
return self.send_error(500)
#### SAFTY ######
if product not in PRODUCT_LIST:
return self.finish()
product_cache = dict()
args = self.json_args
user_id = args['user_id']
if 'master' in self.application.config['downstream'][user_id]:
master_id = self.application.config['downstream'][user_id][
'master']
else:
master_id = user_id
if 'shard_id' in self.application.config['downstream'][user_id]:
shard_id = self.application.config['downstream'][user_id][
'shard_id']
else:
shard_id = master_id
session = self.session('madeira')
order_cls = get_order_shard(shard_id)
q = session.query(order_cls).filter(
order_cls.product == product).filter(order_cls.user_id == user_id)
f = False
# filter
if 'number' in args and args['number']:
q = q.filter(order_cls.mobile == args['number'])
f = True
if 'start' in args and 'end' in args and args['start'] and args['end']:
start = time.strptime(args['start'], '%Y/%m/%d %H:%M:%S')
end = time.strptime(args['end'], '%Y/%m/%d %H:%M:%S')
q = q.filter(order_cls.req_time >= start).filter(
order_cls.req_time < end)
f = True
if 'result' in args and args['result']:
if product == 'fee':
if args['result'] == '-1':
q = q.filter(
and_(order_cls.result == '0',
order_cls.back_result == None))
else:
q = q.filter(
or_(order_cls.back_result == args['result'],
order_cls.result == args['result']))
elif product == 'data':
if args['result'] == 'finish':
q = q.filter(
or_(order_cls.back_result == '00000',
order_cls.back_result == '1'))
elif args['result'] == 'processing':
q = q.filter(
and_(order_cls.result == '00000',
order_cls.back_result == None))
elif args['result'] == 'fail':
q = q.filter(
or_(
and_(order_cls.back_result == None,
order_cls.result != '00000'),
and_(order_cls.back_result != None,
order_cls.back_result != '00000',
order_cls.back_result != '1')))
f = True
if 'id' in args and args['id']:
q = q.filter(order_cls.order_id == args['id'])
f = True
if 'sp_id' in args and args['sp_id']:
q = q.filter(order_cls.sp_order_id == args['sp_id'])
f = True
if not f:
return self.write(
json.dumps({
'status': 'fail',
'msg': '您未选择任何过滤条件，请至少输入一个'
}))
q = q.order_by(desc(order_cls.req_time)).limit(100000)
path = 'exports/export_%s.xlsx' % user_id
workbook = xlsxwriter.Workbook(path, {'constant_memory': True})
worksheet = workbook.add_worksheet()
worksheet.write(0, 0, '订单编号')
worksheet.write(0, 1, '代理商订单编号')
worksheet.write(0, 2, '手机号')
worksheet.write(0, 3, '产品名称')
worksheet.write(0, 4, '运营商')
worksheet.write(0, 5, '面值')
worksheet.write(0, 6, '采购金额')
worksheet.write(0, 7, '开始时间')
worksheet.write(0, 8, '订单状态')
worksheet.write(0, 9, '状态时间')
worksheet.write(0, 10, '余额')
row = 1
# 订单编号 手机号 产品名称 运营商 面值 采购金额 开始时间 状态时间 批次号 订单状态 备注
for order in q:
carrier = ''
carrier_name = ''
area = ''
if order.area and ':' in order.area:
carrier, area = order.area.split(':')
carrier_name = escape_carrier(carrier)
area_name = escape_area(area)
worksheet.write(row, 0, order.order_id)
worksheet.write(row, 1, order.sp_order_id)
worksheet.write(row, 2, order.mobile)
worksheet.write(
row, 3,
decode_name(self.slave, order, carrier, carrier_name, area,
area_name, master_id, product_cache))
worksheet.write(row, 4, area_name + carrier_name)
worksheet.write(row, 5, int(order.price))
worksheet.write(row, 6,
(order.value is not None and (order.value / 10000))
or '-')
worksheet.write(row, 7, str(order.req_time))
worksheet.write(row, 8, decode_status(order))
worksheet.write(row, 9, order.back_time and str(order.back_time)
or '')
worksheet.write(row, 10, (order.balance is not None and
(order.balance / 10000)) or '-')
row += 1
if row % 1000 == 0:
yield gen.moment
workbook.close()
session.close()
self.write(json.dumps({'status': 'ok', 'path': path}))
def post(self, product):
#### SAFTY ######
safety = self.application.config.get('safety')
if safety is None:
request_log.error('CONFIG FAIL (NO SAFETY)')
return self.send_error(500)
# verify ip in white list
if self.direct is None and self.request.remote_ip not in safety[
'white_list']:
request_log.error("CONFIG FAIL ('%s'NOT IN WHITELIST)",
self.request.remote_ip)
return self.send_error(500)
#### SAFTY ######
if product not in PRODUCT_LIST:
return self.finish()
product_cache = dict()
args = self.json_args
page = int(args['page'])
size = int(args['size'])
user_id = args['user_id']
### RELOAD ###
if user_id not in self.application.config['downstream']:
cfg = yaml.load(open('downstream.yaml', 'r', encoding='utf8'))
self.application.config['downstream'] = cfg['downstream']
if user_id not in self.application.config['downstream']:
return self.send_error(500)
session = self.session('madeira')
try:
result = []
if 'master' in self.application.config['downstream'][user_id]:
master_id = self.application.config['downstream'][user_id][
'master']
else:
master_id = user_id
if 'shard_id' in self.application.config['downstream'][user_id]:
shard_id = self.application.config['downstream'][user_id][
'shard_id']
else:
shard_id = master_id
order_cls = get_order_shard(shard_id)
q = session.query(order_cls).filter(
order_cls.product == product).filter(
order_cls.user_id == user_id)
f = False
# filter
if 'number' in args and args['number']:
q = q.filter(order_cls.mobile == args['number'])
f = True
if 'start' in args and 'end' in args and args['start'] and args[
'end']:
start = time.strptime(args['start'], '%Y/%m/%d %H:%M:%S')
end = time.strptime(args['end'], '%Y/%m/%d %H:%M:%S')
q = q.filter(order_cls.req_time >= start).filter(
order_cls.req_time < end)
f = True
if 'result' in args and args['result']:
if product == 'fee' or product == 'sinopec':
if args['result'] == '-1':
q = q.filter(
and_(order_cls.result == '0',
order_cls.back_result == None))
else:
q = q.filter(
or_(order_cls.back_result == args['result'],
order_cls.result == args['result']))
elif product == 'data':
if args['result'] == 'finish':
q = q.filter(
or_(order_cls.back_result == '00000',
order_cls.back_result == '1'))
elif args['result'] == 'processing':
q = q.filter(
and_(order_cls.result == '00000',
order_cls.back_result == None))
elif args['result'] == 'fail':
q = q.filter(
or_(
and_(order_cls.back_result == None,
order_cls.result != '00000'),
and_(order_cls.back_result != None,
order_cls.back_result != '00000',
order_cls.back_result != '1')))
f = True
if 'id' in args and args['id']:
q = q.filter(order_cls.order_id == args['id'])
f = True
if 'sp_id' in args and args['sp_id']:
q = q.filter(order_cls.sp_order_id == args['sp_id'])
f = True
if 'carrier' in args and args['carrier']:
if 'area' in args and args['area']:
q = q.filter(order_cls.area == '%s:%s' %
(args['carrier'], args['area']))
else:
q = q.filter(order_cls.area.like(args['carrier'] + ':%'))
f = True
else:
if 'area' in args and args['area']:
q = q.filter(order_cls.area.like('%:' + args['area']))
f = True
if not f and not (page == 1 and size <= 10):
return self.write(
json.dumps({
'status': 'fail',
'msg': '您未选择任何过滤条件，请至少输入一个'
}))
count = q.count()
# print(count)
max_page = int(math.ceil(count / int(args['size'])))
q = q.order_by(desc(order_cls.req_time)) \
.offset((page - 1) * size) \
.limit(size)
# 订单编号 手机号 产品名称 运营商 面值 采购金额 开始时间 状态时间 批次号 订单状态 备注
for order in q:
carrier = ''
carrier_name = ''
area = ''
if order.area and ':' in order.area:
carrier, area = order.area.split(':')
carrier_name = escape_carrier(carrier)
area_name = escape_area(area)
o = {
'id':
order.order_id,
'sp_id':
order.sp_order_id,
'phone':
order.mobile,
'price':
str(order.price or '-'),
'value': (order.value is not None and '%.3f' %
(order.value / 10000)) or '-',
'create':
str(order.req_time),
'update':
order.back_time and str(order.back_time),
'result':
decode_status(order),
'name':
decode_name(self.slave, order, carrier, carrier_name, area,
area_name, master_id, product_cache),
'carrier':
area_name + carrier_name,
'balance': (order.balance is not None and '%0.03f' %
(order.balance / 10000)) or '-',
}
result.append(o)
finally:
session.close()
self.write(
json.dumps({
'data': result,
'max': max_page,
'page': page,
'size': size
}))
def post(self, product):
args = self.json_args
if 'admin' not in self.current_user['roles'] or 'user_id' not in args:
args['user_id'] = self.current_user['partner_id']
if 'admin' in self.current_user['roles'] and args['user_id'] == '':
http_client = AsyncHTTPClient()
try:
url = '%s/query/mongo/%s' % (
self.application.config['blocking']['mongo'], product)
request = HTTPRequest(url=url,
method='POST',
body=json.dumps(args),
request_timeout=120)
response = yield http_client.fetch(request)
if response.code == 200:
product_cache = dict() # per-handler cache
body = response.body.decode()
r = json.loads(body)
r1 = []
for order in r.get('data'):
user_id = order.get('user_id')
if user_id not in self.application.config[
'downstream']:
continue
if 'master' in self.application.config['downstream'][
user_id]:
master_id = self.application.config['downstream'][
user_id]['master']
else:
master_id = user_id
carrier = ''
carrier_name = ''
area = ''
if order.get('area') and ':' in order.get('area'):
carrier, area = order['area'].split(':')
carrier_name = escape_carrier(carrier)
area_name = escape_area(area)
_adapter = OrderAdapter(product, order)
order['result'] = decode_status(_adapter)
order['name'] = decode_name(self.slave, _adapter,
carrier, carrier_name,
area, area_name, master_id,
product_cache)
order['carrier'] = area_name + carrier_name
if order.product == 'sinopec':
order['carrier'] = carrier_name
order['user_name'] = self.application.config[
'downstream'][user_id]['name']
r1.append(order)
r['data'] = r1
self.finish(json.dumps(r))
else:
self.send_error(500)
except Exception:
request_log.exception('QUERY CHAIN')
self.send_error(500)
finally:
http_client.close()
elif self.application.config.get(
'blocking') and self.application.config['blocking'].get('url'):
url = '%s/query/block/%s' % (
self.application.config['blocking']['url'], product)
http_client = AsyncHTTPClient()
try:
request = HTTPRequest(url=url,
method='POST',
body=json.dumps(args),
request_timeout=120)
response = yield http_client.fetch(request)
if response.code == 200:
body = response.body.decode('utf8')
self.finish(body)
else:
self.send_error(500)
except Exception:
request_log.exception('QUERY CHAIN')
self.send_error(500)
finally:
http_client.close()
else:
# fallback
o = OrderBlockingQueryHandler(self.application, self.request)
o.json_args = args
o.direct = True
o.post(product)
self._headers = o._headers
self._status_code = o._status_code
self._write_buffer = o._write_buffer
self.finish()
def post_add_or_update(self):
domain_id = self.json_args.get('domain_id')
user_id = self.json_args.get('user_id')
product_id = self.json_args.get('product_id')
value = self.json_args.get('value')
status = self.json_args.get('status')
supply = self.json_args.get('supply')
notes = self.json_args.get('notes')
session = self.session('repo')
try:
special = session.query(RepoSpecial).filter(RepoSpecial.user_id == user_id).filter(
RepoSpecial.product_id == product_id).first()
product = session.query(RepoProduct).filter(RepoProduct.domain_id == domain_id).filter(
RepoProduct.product_id == product_id).one()
is_new = False
if special:
if value:
special.value = value
special.update_value_time = dt.now()
if status:
special.status = status
special.update_status_time = dt.now()
if supply:
special.supply = supply
special.update_supply_time = dt.now()
if notes:
special.notes = notes
special.update_time = dt.now()
else:
special = RepoSpecial()
special.user_id = user_id
special.value = value
special.status = status or product.status
special.supply = supply
special.notes = notes
special.product_id = product_id
special.update_time = dt.now()
special.update_status_time = dt.now()
special.update_supply_time = dt.now()
special.update_value_time = dt.now()
is_new = True
session.add(special)
session.commit()
status, status_n = escape_status(product.status, special.status)
data = {
'id': product.product_id,
'name': product.name,
'type': product.type,
'carrier': product.carrier,
'price': product.price,
'area': product.area,
'use_area': product.use_area,
'status': status,
'p1': product.p1,
'p2': product.p2,
'p3': product.p3,
'p4': product.p4,
'p5': product.p5,
'scope': product.scope,
'legacy': product.legacy_id,
'routing': product.routing,
'type_n': PRODUCT_TYPE.get(product.type),
'carrier_n': escape.escape_carrier(str(product.carrier)),
'area_n': escape.escape_area(product.area),
'use_area_n': escape.escape_area(product.use_area),
'status_n': STATUS.get(status),
'product_value': special.value,
'user_id': special.user_id,
'user_name': special.user_id,
'product_id': product.product_id,
'value': int(special.value or product.value),
'tsp': str(special.update_time),
'tsp_status': str(special.update_status_time),
'tsp_supply': str(special.update_supply_time),
'tsp_value': str(special.update_value_time),
'notes': special.notes
}
self.finish(json.dumps({'status': 'ok', 'is_new': is_new, 'data': data}))
# yield core.sync_pricing(session, domain_id, filter_product=product_id, filter_user=user_id)
self.master.lpush('list:sync:pricing',
'{domain_id},{product_id},{user_id}'.format(
domain_id=domain_id, product_id=product_id, user_id=user_id))
except ValueError as e:
self.finish(json.dumps({'status': 'fail', 'msg': str(e)}))
finally:
session.close()
def post_list_value(self):
domain_id = self.json_args.get('domain_id')
user_id = self.json_args.get('user_id', None)
product_id = self.json_args.get('product_id', None)
#新增加的密价搜索条件 type 为系统保留字，加个前缀
product_type = self.json_args.get('type', None)
carrier = self.json_args.get('carrier', None)
price = self.json_args.get('price', None)
value = self.json_args.get('value', None)
area = self.json_args.get('area', None)
use_area = self.json_args.get('use_area', None)
name = self.json_args.get('name', None)
status = self.json_args.get('status', None)
page = int(self.json_args['page'])
size = int(self.json_args['size'])
session = self.session('repo')
user_level = {}
try:
if user_id:
# by-user
q = session.query(RepoProduct, RepoSpecial).outerjoin(
RepoSpecial, and_(
RepoSpecial.product_id == RepoProduct.product_id,
RepoSpecial.user_id == user_id
)).filter(RepoProduct.domain_id == domain_id)
else:
q = session.query(RepoProduct, RepoSpecial).filter(RepoProduct.domain_id == domain_id).filter(
RepoSpecial.product_id == RepoProduct.product_id).filter(RepoSpecial.value >= 0)
if product_type:
q = q.filter(RepoProduct.type == product_type)
if carrier:
q = q.filter(RepoProduct.carrier == carrier)
if price:
q = q.filter(RepoProduct.price == price)
if value:
q = q.filter(RepoProduct.value == value)
if area:
q = q.filter(RepoProduct.area == area)
if use_area:
q = q.filter(RepoProduct.use_area == use_area)
if name:
q = q.filter( RepoProduct.name.like('%'+name+'%') )
if status:
q = q.filter(RepoProduct.status == status)
if product_id:
q = q.filter(RepoSpecial.product_id == product_id)
count = q.count()
max_page = int(math.ceil(count / size))
product_list = []
if user_id:
q = q.order_by(RepoProduct.carrier, RepoProduct.area, RepoProduct.scope,
RepoProduct.value).offset((page - 1) * size).limit(size)
else:
q = q.order_by(RepoSpecial.user_id, RepoProduct.carrier, RepoProduct.area, RepoProduct.scope,
RepoProduct.value).offset((page - 1) * size).limit(size)
for p, s in q:
if s:
if s.user_id in user_level:
level = user_level.get(s.user_id)
else:
level = self.get_level(session, s.user_id)
user_level[s.user_id] = level
elif user_id:
if user_id in user_level:
level = user_level.get(user_id)
else:
level = self.get_level(session, user_id)
user_level[user_id] = level
product_list.append({
'id': p.product_id,
'name': p.name,
'type': p.type,
'carrier': p.carrier,
'price': p.price,
'area': p.area,
'use_area': p.use_area,
'status': p.status,
'p1': p.p1,
'p2': p.p2,
'p3': p.p3,
'p4': p.p4,
'p5': p.p5,
'scope': p.scope,
'legacy': p.legacy_id,
'routing': p.routing,
'type_n': PRODUCT_TYPE.get(p.type),
'carrier_n': escape.escape_carrier(str(p.carrier)),
'area_n': escape.escape_area(p.area),
'use_area_n': escape.escape_area(p.use_area),
'status_n': STATUS.get(p.status),
'product_value': getattr(p, level),
'user_id': s and s.user_id or user_id,
'user_name': s and s.user_id or user_id,
'product_id': p.product_id,
'value': s and s.value and int(s.value),
'tsp': s and s.update_time and str(s.update_time),
'tsp_status': s and s.update_status_time and str(s.update_status_time),
'tsp_supply': s and s.update_supply_time and str(s.update_supply_time),
'tsp_value': s and s.update_value_time and str(s.update_value_time),
'notes': s and s.notes,
})
self.finish(json.dumps({
'status': 'success',
'page': page,
'max': max_page,
'list': product_list
}))
finally:
session.close()
def post_list_product(self):
domain_id = self.json_args.get('domain_id')
user_id = self.json_args.get('user_id')
filter_id = self.json_args.get('id')
filter_price = self.json_args.get('price')
filter_name = self.json_args.get('name')
filter_type = self.json_args.get('type')
filter_carrier = self.json_args.get('carrier')
filter_area = self.json_args.get('area')
filter_status = self.json_args.get('status')
session = self.session('repo')
try:
q = session.query(RepoProduct).filter(RepoProduct.domain_id == domain_id)
if filter_id:
q = q.filter(RepoProduct.product_id.like('%'+filter_id+'%'))
if filter_price:
q = q.filter(RepoProduct.price == filter_price)
if filter_name:
q = q.filter(RepoProduct.name.like('%'+filter_name+'%'))
if filter_type:
q = q.filter(RepoProduct.type == filter_type)
if filter_carrier:
q = q.filter(RepoProduct.carrier == filter_carrier)
if filter_area:
q = q.filter(RepoProduct.area == filter_area)
if filter_status:
q = q.filter(RepoProduct.status == filter_status)
count = q.count()
page = int(self.json_args['page'])
size = int(self.json_args['size'])
max_page = int(math.ceil(count / size))
product_list = []
q = q.order_by(RepoProduct.carrier, RepoProduct.area, RepoProduct.scope, RepoProduct.value).offset(
(page - 1) * size).limit(
size)
# special status ...
# enabled_set = set()
# disabled_set = set()
enabled_set = {}
disabled_set = {}
qs = session.query(RepoSpecial).filter(RepoSpecial.user_id == user_id).filter(
RepoSpecial.status != None)
for s in qs.all():
if s.status == 'enabled':
# enabled_set.add(s.product_id)
enabled_set[s.product_id] = str(s.update_status_time)
else:
# disabled_set.add(s.product_id)
disabled_set[s.product_id] = str(s.update_status_time)
for p in q:
if p.status == 'disabled':
if p.product_id in enabled_set:
status = 'forced-enabled'
else:
status = 'n/a'
tsp = enabled_set.get(p.product_id, None)
else:
if p.product_id in disabled_set:
status = 'disabled'
else:
status = 'enabled'
tsp = disabled_set.get(p.product_id, None)
product_list.append({
'id': p.product_id,
'name': p.name,
'type': p.type,
'carrier': p.carrier,
'price': p.price,
'area': p.area,
'use_area': p.use_area,
'status': status,
'value': p.value,
'notes': p.notes,
# 'tsp': str(p.update_time),
'tsp': tsp,
'p1': p.p1,
'p2': p.p2,
'p3': p.p3,
'p4': p.p4,
'p5': p.p5,
'scope': p.scope,
'legacy': p.legacy_id,
'routing': p.routing,
'type_n': PRODUCT_TYPE.get(p.type),
'carrier_n': escape.escape_carrier(str(p.carrier)),
'area_n': escape.escape_area(p.area),
'use_area_n': escape.escape_area(p.use_area),
'status_n': STATUS.get(status),
'user_id': user_id,
})
self.finish(json.dumps({
'status': 'ok',
'page': page,
'max': max_page,
'list': product_list
}))
finally:
session.close()
def get(self, path):
if 'admin-route' not in self.current_user['roles']:
self.send_error(403)
return
http_client = AsyncHTTPClient()
if path == 'supply/list':
try:
base_url = self.application.config['connection']['repo']
url = base_url + '/api/route/supply/list?domain_id=' + self.current_user[
'domain_id']
response = yield http_client.fetch(url, method='GET')
resp = response.body.decode()
self.finish(resp)
finally:
http_client.close()
elif path == 'maintain/list':
try:
partner_id = self.current_user['partner_id']
base_url = self.application.config['downstream'][partner_id][
'shard']
url = 'http://%s/admin/config?keys=%s&with_ttl=true' % (
base_url, quote("maintain:*"))
response = yield http_client.fetch(url, method='GET')
body = response.body.decode()
if_map = self.application.config.get('interface')
downstream = self.application.config.get('downstream')
maintain_list = []
for line in sorted(body.strip().split('\n')):
request_log.debug('MAINTAIN {%s}', line)
if line != '':
key, notes, ttl = line.split(' ')
values = key.split(':')
if len(values) < 4 or len(values) > 5:
request_log.error('UNKNOWN MAINTAIN FORMAT %s',
line)
continue
ttl_name = self.get_name(ttl)
route = values[1]
route_n = if_map.get(route, route)
carrier = values[2]
carrier_n = escape_carrier(carrier)
area = values[3]
area_n = escape_area(area)
if len(values) > 4:
user_id = values[4]
user_name = downstream.get(user_id, {
'name:': '*'
}).get('name')
else:
user_id = None
user_name = '(全部)'
maintain_list.append({
'key': key,
'route': route,
'route_n': route_n,
'carrier': carrier,
'carrier_n': carrier_n,
'area': area,
'area_n': area_n,
'user_id': user_id,
'user_name': user_name,
'ttl_name': ttl_name,
'notes': unquote(notes)
})
self.finish(json.dumps(maintain_list))
finally:
http_client.close()
elif path == 'pool/list':
try:
partner_id = self.current_user['partner_id']
base_url = self.application.config['downstream'][partner_id][
'shard']
url = 'http://%s/admin/config?keys=%s' % (base_url,
quote("pool:*"))
response = yield http_client.fetch(url, method='GET')
body = response.body.decode()
r_db0 = self.application.sentinel.master_for('madeira', db=0)
keys_list = r_db0.keys("pool:*")
datapool_list = []
for line in sorted(body.strip().split('\n')):
if line != '':
madeira_key, value = line.split(' ')
for key in keys_list:
if key == madeira_key:
tmp_dict = r_db0.hgetall(key)
tmp_dict['key'] = key
datapool_list.append(tmp_dict)
tmp_dict['number'] = value
datapool_list.append(tmp_dict)
resp_data = {'status': "ok", 'data': datapool_list}
self.finish(json.dumps(resp_data))
except Exception as e:
request_log.exception('QUERY POOL FAIL')
#self.finish(json.dumps({"msg": "查询异常:" + repr(e)}))
self.send_error(500)
finally:
http_client.close()
elif path == 'pool/interface':
try:
r_db0 = self.application.sentinel.master_for('madeira', db=0)
keys_list = r_db0.keys("pool:*")
datapool_interface_list = []
for key in keys_list:
tmp_dict = r_db0.hgetall(key)
tmp_dict['key'] = key
datapool_interface_list.append(tmp_dict)
resp_data = {'status': "ok", 'data': datapool_interface_list}
self.finish(json.dumps(resp_data))
except Exception as e:
request_log.exception('QUERY POOL INTERFACE FAIL')
#self.finish(json.dumps({"msg": "查询异常:" + repr(e)}))
self.send_error(500)
else:
self.send_error(404)
def post(self):
args = self.json_args
page = args.get('page')
size = args.get('size')
max_page = 0
result = []
try:
if 'admin' not in self.current_user['roles']:
user_id = self.current_user['partner_id']
else:
user_id = args.get('user_id')
criteria = {}
if user_id:
criteria['user_id'] = user_id
if args.get('order_id'):
criteria['order_id'] = args.get('order_id')
if args.get('account'):
criteria['account'] = args.get('account')
if args.get('start') and args.get('end'):
start = datetime.strptime(args.get('start'), '%Y/%m/%d %H:%M:%S')
end = datetime.strptime(args.get('end'), '%Y/%m/%d %H:%M:%S')
criteria['create_time'] = {'$gte': start, '$lt': end}
if args.get('type'):
criteria['type'] = args.get('type')
if len(criteria) <= 1:
return self.write(json.dumps({'status': 'fail', 'msg': '您未选择任何过滤条件，请至少输入一个'}))
trans_collection = self.application.glados_client.GLaDOS.transaction
request_log.info('QUERY FINANCE %s', criteria)
count = yield trans_collection.find(criteria).count()
request_log.info('QUERY FINANCE COUNT=%d', count)
max_page = int(math.ceil(count / int(args['size'])))
cursor = trans_collection.find(criteria).sort([('_id', -1)]).skip((page - 1) * size).limit(size)
while (yield cursor.fetch_next):
trans_doc = cursor.next_object()
name = ''
if trans_doc.get('name'):
n = trans_doc.get('name').split(':')
if len(n) == 3:
c = escape_carrier(n[0])
p = escape_area(n[1])
v = n[2]
name = '%s%s%s元直充' % (p, c, v)
t = {
'id': trans_doc.get('_id'),
'user_id': trans_doc.get('user_id'),
'type': escape_finance_type(trans_doc.get('type')),
'value': '%.3f' % ((trans_doc.get('income') - trans_doc.get('outcome')) / 10000),
'balance': '%.3f' % (trans_doc.get('balance') / 10000),
'order_id': trans_doc.get('order_id'),
'account': trans_doc.get('account'),
'time': str(trans_doc.get('create_time')),
'name': trans_doc.get('name'),
'notes': trans_doc.get('notes') or ''
}
result.append(t)
except:
request_log.exception('FAIL ON QUERY2')
self.write(json.dumps({
'data': result,
'max': max_page,
'page': page,
'size': size
}))
