def set_restaurant_activity():
"""
参加餐厅活动
"""
args_spec = {
'restaurant_id': Arg(),
'activity_id': Arg(),
'activity_type': Arg()
}
args = args_parser.parse(args_spec)
restaurant_id = args['restaurant_id']
activity_id = args['activity_id']
activity_type = args['activity_type']
if activity_type is not None and activity_id is None:
TRestaurantActivity = thirdparty_svc.ers.TRestaurantActivity
with thrift_client('ers') as ers:
zeus_result = ers.javis_query_restaurant_activity_by_restaurant(
restaurant_id)
restaurant_activity_map = {}
for activity in zeus_result:
activity_type_value = activity.type
if activity_type_value in RestaurantActivityConstType._v2n.keys():
restaurant_activity_map[activity_type_value] = activity
for activity_type_value in RestaurantActivityConstType._v2n.keys():
restaurant_activity_map.setdefault(activity_type_value,
TRestaurantActivity())
restaurant_activity = restaurant_activity_map[activity_type]
activity_id = restaurant_activity.id
else:
# 取消掉activity_type,这样就是参加活动.下面的代码依赖这个来决定调用哪个接口-.-
activity_type = None
if activity_id is None:
raise Exception('activity id is None or quit an unexist activity')
with thrift_client('ers') as ers:
if activity_type:
result = ers.quit_restaurant_activity(restaurant_id, activity_id)
else:
result = ers.participate_restaurant_activity(
restaurant_id, activity_id)
return ''
def query():
args_spec = {'admin_id': Arg(int, allow_missing=True)}
args = args_parser.parse(args_spec)
page_no, page_size = get_paging_params()
offset = (page_no - 1) * page_size
limit = page_size
return coupon_batch_base.query(admin_id=args.get('admin_id',
current_user.get_id()),
offset=offset,
limit=limit)
def update(pk):
args_spec = {
'city_id': Arg(int),
'type_code': Arg(int),
'area': Arg(dict),
'name': Arg(unicode),
}
args = args_parser.parse(args_spec)
pk = int(pk)
if not region_permission(pk):
raise_auth_exc(AUTH_FAILED_ERROR)
_check_region_type(args.get('type_code'))
_check_region_json(args.get('area'))
if args.get('area', None) is not None:
args.update(area=json.dumps(args['area']))
result = region_brand.update(pk, **args)
return result
def bankcard_reject(rst_id, bankcard_id):
arg_spec = {"comment": Arg()}
args = args_parser.parse(arg_spec)
args.update({"status": RstBankCard.STATUS_INVALID})
bankcard_base.update_bankcard(bankcard_id, **args)
bankcard_base.add_bankcard_processing_record(
rst_id=rst_id,
bankcard_id=bankcard_id,
process_user_id=current_user.id,
messages=u'退回该银行卡信息',
status_to=RstBankCard.STATUS_INVALID,
)
def save():
args_spec = {
'batch_type':
Arg(int,
required=True,
validate=lambda t: t in BATCH_TYPE_LIST,
error='Invalid batch type'),
'rst_ids':
Arg(str, allow_missing=True)
}
args = args_parser.parse(args_spec)
# check restaurant ids when the batch bound with restaurant
if args['batch_type'] in BATCH_TYPE_RST:
if args.get('rst_ids') is None:
raise_user_exc(RST_IDS_REQUIRED)
args['rst_ids'] = [int(rst_id) for rst_id in args['rst_ids'].split()]
batch_sn = coupon_batch_base.save(args['batch_type'], current_user.id,
current_user.name,
args.get('rst_ids', None))
return {'batch_sn': batch_sn}
def get_building_list_by_area():
arg_spec = {'_area': Arg(list)}
args = args_parser.parse(arg_spec)
points = args['_area']
buildings = white_collar_base.query_building_by_points(points)
building_list = []
total_population = 0
for building in buildings:
building_list.append(building_to_dict(building))
total_population += int(
building.population) if building.population is not None else 0
return {
'total_population': total_population,
'building_list': building_list
}
def get_regions_by_city_id():
args_spec = {
'city_id': Arg(int),
}
if not check_get_regions_by_city_id():
raise_auth_exc(AUTH_FAILED_ERROR)
args = args_parser.parse(args_spec)
city_id = args['city_id']
result = region_base.get_regions_by_city_id(city_id)
for region in result:
region['_area'] = back_area_to_front_area(region['area'])
if region['type_code'] == WHITE_COLLAR_TYPE_CODE:
region['buildings'] = _get_building_by_region_id(region['id'])
dic_fields_process(region, excludes=['has_geohash', 'color'])
return result
def query():
args_spec = {
'city_id': Arg(int),
}
args = args_parser.parse(args_spec)
result = []
rbs = region_brand.query(**args)
for rb in rbs:
result.append({
'id': rb.id,
'name': rb.name,
'type_code': rb.type_code,
'city_id': rb.city_id,
'area': rb.area,
'created_at': rb.created_at
})
return result
def save():
args_spec = {
'coupon_type':
Arg(int,
required=True,
validate=lambda t: t in COUPON_TYPE,
error='Invalid coupon type'),
'batch_sn':
Arg(str, required=True),
'deadline':
Arg(str, required=True),
'sn':
Arg(str),
'remain':
Arg(int),
'count':
Arg(int),
}
args = args_parser.parse(args_spec)
if args['coupon_type'] == GENERIC_COUPON:
if args.get('sn') is None:
raise_user_exc(COUPON_SN_REQUIRED)
if not _check_sn_length(args['sn']):
raise_user_exc(COUPON_SN_INVALID)
remain = args.get('remain') or GENERAL_COUPON_DEFAULT_REMAIN
result = coupon_base.save_generic_coupon(batch_sn=args['batch_sn'],
deadline=args['deadline'],
sn=args['sn'],
remain=remain)
result = [
result.get('sn'),
]
else:
if args.get('count') is None:
raise_user_exc(COUPON_COUNT_REQUIRED)
if int(args.get('count')) > 500:
raise_user_exc(COUPON_COUNT_INVALID)
result = coupon_base.save_onetime_coupon(batch_sn=args['batch_sn'],
remain=1,
deadline=args['deadline'],
remarks=u"后台生成",
count=args['count'])
return result
def get_processing_record(rst_id, bankcard_id):
arg_spec = {
"limit": Arg(int, allow_missing=True),
}
args = args_parser.parse(arg_spec)
limit = args.get("limit", DEFAULT_RECORD_LIMIT)
processing_record_list = bankcard_base \
.query_processing_record(rst_id, bankcard_id, limit)
if not processing_record_list:
return []
process_user_ids = []
for m in processing_record_list:
process_user_ids.append(m.process_user_id)
process_user_list = user_base.mget_users(process_user_ids)
process_user_dict = {user.id: user.username for user in process_user_list}
processing_record_list_new = []
for processing_record in processing_record_list:
pr_dict = model2dict(processing_record)
pr_dict['process_user_username'] = \
process_user_dict.get(pr_dict['process_user_id'])
processing_record_list_new.append(pr_dict)
return processing_record_list_new
def parse_args1():
args_spec = {
'restaurant_ids':Arg(default=[]),
'restaurant_id':Arg(int,default=None),
'category_ids':Arg(default=[]),
'category_id':Arg(int,default=None),
'food_ids':Arg(default=[]),
'food_id':Arg(int,default=None),
}
args = args_parser.parse(args_spec)
restaurant_ids = args.get('restaurant_ids', [])
category_ids = args.get('category_ids', [])
food_ids = args.get('food_ids', [])
restaurant_id = args.get('restaurant_id', None)
category_id = args.get('category_id', None)
food_id = args.get('food_id', None)
if restaurant_id:
restaurant_ids.append(restaurant_id)
if category_id:
category_ids.append(category_id)
if food_id:
food_ids.append(food_id)
return restaurant_ids, category_ids, food_ids, restaurant_id, category_id, food_id
def done(pk):
user_args = {
'image_hash': Arg(str, required=True)
}
args = args_parser.parse(user_args)
return refund_service.save_payment_proof(pk=pk, **args)
def query_suspicous():
args_spec = {
'start_datetime':
Arg(unicode, default=arrow.now().replace(days=-1).__str__()),
'end_datetime':
Arg(unicode, default=arrow.now().__str__()),
'restaurant_id':
Arg(int),
'offset':
Arg(int, default=0),
'limit':
Arg(int, default=100),
}
args = args_parser.parse(args_spec)
if not args['restaurant_id']:
return {
'total': 0,
'objects': [],
}
client = pymongo.MongoClient(config.EYES_MONGO)
collection = client.evileye.suspicious_order
# db.tickets.find({"date":{$lt:ISODate("2013-01-17T01:16:33.303Z")}}).limit (5);
start_datetime = args['start_datetime'].split('+')[0]
end_datetime = args['end_datetime'].split('+')[0]
start_datetime = arrow.get(start_datetime).to('local').datetime
end_datetime = arrow.get(end_datetime).to('local').datetime
restaurant_id = args['restaurant_id']
offset = args['offset']
limit = args['limit']
query = {
'created_at': {
'$lte': end_datetime,
'$gte': start_datetime
},
}
if restaurant_id:
query.update({'restaurant_id': restaurant_id})
docs = collection.find(query)
total = docs.count()
result_docs = list(docs.limit(limit).skip(offset))
time_fields = ['deliver_time', 'settled_at']
with thrift_client('eos') as eos:
for doc in result_docs:
order_id = doc['_id']
order = eos.get(int(order_id))
order = getresult_to_raw(order)
for k, v in order.items():
doc.setdefault(k, v)
doc['detail_json'] = json.loads(doc['detail_json'])
doc['_order_id'] = doc['_id']
for field in time_fields:
new_value = arrow.get(doc[field]).__str__()
doc[field] = new_value
doc['phone'] = [doc['phone']]
with thrift_client('eus') as eus_client:
chaos = eus_client.get_order_payment_constitution_map(
[int(order_id)])
payment_constituion = chaos.get(order['id'], [])
doc['payment_constituion'] = order_query_helper.whatzfvcksay(
payment_constituion, doc['total'])
doc['order_id'] = unicode(doc['_id'])
order_ids = [doc['id'] for doc in result_docs]
with thrift_client('eyes') as eyes_client:
suspicious_orders = eyes_client.walle_get_suspicious_order_detail(
order_ids)
suspicious_orders = getresult_to_raw(suspicious_orders)
suspicious_orders_map = {
order.id: order
for order in suspicious_orders
}
for _object in result_docs:
suspicious = suspicious_orders_map.get(_object['id'], {})
_object['_order_suspicious_reason'] = suspicious.get('reasons', [])
restaurant_ids = list(set([o['restaurant_id'] for o in result_docs]))
restaurants = rst_base.get(restaurant_ids)
for r in restaurants:
r['_image_url'] = image_hash_to_url(r['image_hash'])
restaurant_map = {r.id: r for r in restaurants}
for order in result_docs:
order['_restaurant'] = restaurant_map[order['restaurant_id']]
result = {
'total': total,
'objects': result_docs,
}
return result
def _get_bankcard_args():
arg_spec = {
'type_code': Arg(int),
'status': Arg(int, allow_missing=True),
'username': Arg(),
'mobile': Arg(str),
'card_id': Arg(str),
'bank_id': Arg(int),
'cardholder_name': Arg(),
'bankcard_image_front': Arg(allow_missing=True),
'identity_card_image_front': Arg(allow_missing=True),
'identity_card_image_back': Arg(allow_missing=True),
'ol_pay_contract_image': Arg(allow_missing=True),
'misc_image': Arg(allow_missing=True),
'comment': Arg(allow_missing=True),
}
return args_parser.parse(arg_spec)
