def put(args):
order_id = args['order_id']
express_company_name = args['express_company_name']
express_number = args['express_number']
data_mns = []
data = {
'order_id': order_id,
'express_company_name': express_company_name,
'express_number': express_number
}
resp = Resource.use('zeus').put({
'resource': 'mall.delivery',
'data': data
})
errcode = SYSTEM_ERROR_CODE
# 获取app_id传送到mns进行消息处理
pay_log = PayLog.from_order_id({"order_id": order_id})
if pay_log:
app_id = pay_log.appid
else:
watchdog.info(
"order paylog is not exits, delivery mns message send failed!! order_id:{}, msg:{}"
.format(order_id, unicode_full_stack()),
log_type='OPENAPI_ORDER')
errcode = DELIVERY_ORDER_HAS_NO_PAYLOG
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
topic_name = TOPIC['order']
data_mns['order_id'] = order_id
data_mns['app_id'] = app_id or ''
data_mns['express_company_name'] = express_company_name
data_mns['express_number'] = express_number
if resp:
if resp['code'] == 200:
if resp['data']['result'] == 'SUCCESS':
errcode = SUCCESS_CODE
data = {'errcode': errcode}
msgutil.send_message(topic_name, 'delivery_item_shipped',
data_mns)
return data
else:
if resp['data']['msg'] == u'不能对当前订单发货':
errcode = DELIVERY_ORDER_HAS_MULTIPLE_CHILD_ORDERS
elif resp['data']['msg'] == u'订单状态已经改变':
errcode = DELIVERY_ORDER_STATUS_ERROR
elif resp['data']['msg'] == u'订单不存在':
errcode = DELIVERY_ORDER_NOT_EXIST
watchdog.info(
"delivery failed!! errcode:{}, order_id:{}".format(
errcode, order_id),
log_type='OPENAPI_ORDER')
if errcode == SYSTEM_ERROR_CODE:
watchdog.error("delivery failed!! errcode:{}, msg:{}".format(
errcode, unicode_full_stack()),
log_type='OPENAPI_ORDER')
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
def call_wapi(self, method, app, resource, req, resp):
watchdog_client.watchdogClient = watchdog_client.WatchdogClient(
settings.SERVICE_NAME)
response = {
"code": 200,
"errMsg": "",
"innerErrMsg": "",
}
resp.status = falcon.HTTP_200
args = {}
args.update(req.params)
args.update(req.context)
args['wapi_id'] = req.path + '_' + req.method
param_args = {}
param_args['req_params'] = req.params
try:
raw_response = wapi_resource.wapi_call(method, app, resource, args,
req)
if type(raw_response) == tuple:
response['code'] = raw_response[0]
response['data'] = raw_response[1]
if response['code'] != 200:
response['errMsg'] = response['data']
response['innerErrMsg'] = response['data']
else:
response['code'] = 200
response['data'] = raw_response
except wapi_resource.ApiNotExistError as e:
response['code'] = 404
response['errMsg'] = str(e).strip()
response['innerErrMsg'] = unicode_full_stack()
except Exception as e:
response['code'] = 531 #不要改动这个code，531是表明service内部发生异常的返回码
response['errMsg'] = str(e).strip()
response['innerErrMsg'] = unicode_full_stack()
msg = {'traceback': unicode_full_stack()}
watchdog.alert(msg, 'Error')
resp.body = json.dumps(response, default=_default)
try:
param_args['app'] = app
param_args['resource'] = resource
param_args['method'] = method
param_args.update(json.loads(resp.body))
#param_args.update(simplejson.loads(resp.body))
watchdog.info(param_args, "CALL_API")
except:
pass
def send_task(queue_name, args):
try:
result = celery.send_task(queue_name, args=[args], queue=queue_name)
except:
notify_message = u"queue_name:{}, args:{}, cause:\n{}".format(
queue_name, args, unicode_full_stack())
watchdog.error(notify_message)
def api_put(request):
post = request.POST
name = post.get('name')
db_model = None
try:
db_model = models.ProductLimitZoneTemplate.objects.create(name=name,
owner_id=request.user.id)
params = {
'name': name,
'owner_id': PRODUCT_POOL_OWNER_ID
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.product_limit_zone_template',
method='put')
if resp and resp_data:
# 创建中间关系
models.ProductLimitZoneTemplateRelation.objects.create(
template_id=db_model.id,
weapp_template_id=resp_data.get('template').get('id')
)
response = create_response(200)
else:
models.ProductLimitZoneTemplate.objects.filter(id=db_model).delete()
response = create_response(500)
except:
msg = unicode_full_stack()
watchdog.error('product_limit_zone.template_PUT{}'.format(msg))
if db_model:
models.ProductLimitZoneTemplate.objects.filter(id=db_model.id).delete()
response = create_response(500)
return response.get_response()
def api_delete(request):
post = request.POST
template_id = post.get('id')
try:
# 判断是否有正在使用的
use_products = product_models.Product.objects.filter(limit_zone=template_id)\
.exclude(limit_zone_type=product_models.NO_LIMIT)
# print '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.'
# print use_products.count()
# print '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.'
if use_products.count() > 0:
# data = {
# 'msg': '还有正在使用该模板的商品，请先处理！'
# }
response = create_response(500)
response.errMsg = '还有正在使用该模板的商品，请先处理！'
return response.get_response()
models.ProductLimitZoneTemplate.objects.filter(id=template_id).update(is_deleted=True)
# 同步到weapp
relation = models.ProductLimitZoneTemplateRelation.objects.filter(template_id=template_id).first()
if relation:
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'template_id': relation.weapp_template_id
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.product_limit_zone_template',
method='delete')
response = create_response(200)
except:
msg = unicode_full_stack()
watchdog.error('product_limit_zone.template_DELETE{}'.format(msg))
response = create_response(500)
return response.get_response()
def process_order_from_spread(args):
"""静态方法 订单完成后处理分享链接相关
@param[in] order_id 订单id
@param[in] webapp_user 当前下单用户
"""
order_id = args['order_id']
mall_order_from_shared = mall_models.MallOrderFromSharedRecord.select(
).dj_where(order_id=order_id).first()
if mall_order_from_shared:
shared_url = mall_order_from_shared.url
fmt = mall_order_from_shared.fmt
if shared_url and fmt:
try:
member_models.MemberSharedUrlInfo.update(
leadto_buy_count=member_models.MemberSharedUrlInfo.
leadto_buy_count + 1).dj_where(
shared_url=shared_url, ).execute()
mall_order_from_shared.is_updated = True
mall_order_from_shared.save()
except:
notify_message = u"process_order_from_spread cause:\n{}, fmt:{}".format(
unicode_full_stack(), fmt)
watchdog.error(notify_message)
print notify_message
def wrapper(*args, **kw):
try:
return func(*args, **kw)
except:
watchdog.alert({
'uuid': 'order_trade_error',
'traceback': unicode_full_stack()
})
def __log_exception(self, e=BaseException):
if isinstance(e, redis.exceptions.RedisError):
exception_type = 'redis_error'
else:
exception_type = 'other'
watchdog.alert(
'redis_lock_error:type:{}.\nunicode_full_stack:{}'.format(exception_type, unicode_full_stack()))
self.__redis_error = True
return True
def api_put(request):
# 新建商品分类
post = request.POST
name = post.get('catalog_name', '')
father_id = int(post.get('father_catalog', -1))
level = 1 if father_id == -1 else 2
note = post.get('note', '')
try:
product_catalog = product_catalog_models.ProductCatalog.objects.create(
name=name, level=level, father_id=father_id, note=note)
#
weapp_father_id = father_id
if father_id > 0:
relation = product_catalog_models.ProductCatalogRelation.objects.filter(
catalog_id=father_id).first()
if relation:
weapp_father_id = relation.weapp_catalog_id
params = {
'name': name,
'level': level,
'father_id': 0 if father_id == -1 else weapp_father_id
}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).put({
'resource': 'mall.classification',
'data': params
})
if resp and resp.get('code') == 200 and resp.get('data').get(
'classification'):
product_catalog_models.ProductCatalogRelation\
.objects.create(catalog_id=product_catalog.id,
weapp_catalog_id=resp.get('data').get('classification').get('id'))
response = create_response(200)
else:
product_catalog_models.ProductCatalog.objects.filter(
id=product_catalog.id).delete()
response = create_response(500)
except:
response = create_response(500)
response.errMsg = u'新建失败'
response.innerErrMsg = unicode_full_stack()
watchdog.error(unicode_full_stack())
return response.get_response()
def api_post(request):
post = request.POST
name = post.get('name')
template_id = post.get('id')
flag = post.get('flag', 'name')
try:
models.ProductLimitZoneTemplate.objects.filter(id=template_id).update(name=name)
# 同步到weapp的参数
weapp_cities = []
weapp_provinces = []
if flag != 'name':
selected_data = json.loads(post.get('selected_data', ''))
provinces = selected_data.get('provinces')
# 先删除
models.LimitTemplateHasZone.objects.filter(template_id=template_id).delete()
# 创建模板的数据
bulk_create = []
for province in provinces:
# 前段传递的数据如果是全选了省，那么cities是空的
cities = province.get('cities')
weapp_provinces.append(str(province.get('provinceId')))
if not cities:
bulk_create.append(models.LimitTemplateHasZone(template_id=template_id,
province=province.get('provinceId'),
))
else:
bulk_create += [models.LimitTemplateHasZone(template_id=template_id,
province=province.get('provinceId'),
city=city.get('cityId')) for city in cities]
weapp_cities += [str(city.get('cityId')) for city in cities]
models.LimitTemplateHasZone.objects.bulk_create(bulk_create)
# 同步更新到weapp
relation = models.ProductLimitZoneTemplateRelation.objects.filter(template_id=template_id).first()
if relation:
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'name': name,
'cities': ','.join(weapp_cities),
'template_id': relation.weapp_template_id,
'provinces': ','.join(weapp_provinces),
'flag': flag
}
sync_util.sync_zeus(params=params, resource='mall.product_limit_zone_template',
method='post')
response = create_response(200)
except:
msg = unicode_full_stack()
watchdog.error('product_limit_zone.template_POST{}'.format(msg))
response = create_response(500)
return response.get_response()
def filter_products(self, args):
raw_products = args['products']
product_name = filter_invalid_str(args['product_name'], '').strip()
products = filter(lambda x: product_name in x['name'], raw_products)
try:
self.__log_record(product_name)
except:
msg = unicode_full_stack()
watchdog.alert(msg)
return products
def get_wapi_lock(lockname, lock_timeout=1): try: conn = DEFAULT_CONN identifier = '1' lockname = 'lk:' + lockname lock_timeout = int(math.ceil(lock_timeout)) if conn.set(name=lockname, value=identifier, nx=True, ex=lock_timeout): return identifier else: return False except: watchdog.alert(unicode_full_stack()) return True
def _poll_response(self):
"""
发送快递100 订阅请求，返回成功与否信息
"""
# post中的param的json
param_json_data = {
self.express_params.COMPANY: self.express_company_name,
self.express_params.NUMBER: self.express_number,
self.express_params.TO: self.area,
self.express_params.KEY: self.express_config.app_key,
self.express_params.PARAMETERS: {
self.express_params.CALLBACK_URL: self._get_api()
}
}
# 将PARAMETERS的json转换为字符串
param_str = json.dumps(param_json_data)
json_data = {
self.express_params.SCHEMA: self.express_config.schema,
self.express_params.PARAM: param_str
}
# print param_str
verified_result = ''
try:
param_data = urllib.urlencode(json_data)
# print '-------------------------------------------'
# print param_data
# if settings.IS_UNDER_BDD:
# from test.bdd_util import WeappClient
# bdd_client = WeappClient()
# response = bdd_client.post('/tools/api/express/test_kuaidi_poll/?code=1', param_json_data)
# verified_result = response.content
# else:
request = urllib2.Request(self.express_config.get_api_url(),
param_data)
response = urllib2.urlopen(request)
verified_result = response.read()
watchdog.info(
u"发送快递100 订阅请求 url: {},/n param_data: {}, /n response: {}".
format(self.express_config.get_api_url(), param_str,
verified_result.decode('utf-8')))
except:
watchdog.error(u'发送快递100 订阅请求 失败，url:{},data:{},原因:{}'.format(
self.express_config.get_api_url(), param_str,
unicode_full_stack()))
return verified_result
def get_express_poll(self):
# 如果是空不处理
if self.express_company_name is '' or self.express_number is '':
watchdog.error(
u'快递订阅异常,订单号:{}, 原因:{}'.format(self.delivery_item.bid,
unicode_full_stack()),
self.express_config.watchdog_type)
return False
# 是否已经订阅过该订单，并且成功
status = self._is_poll_by_order()
if status:
return True
# 保存快递信息
self.express = self._save_poll_order_id()
# 发送订阅请求
data = self._send_poll_requset()
result = True if data.get(
'result') == "true" or data.get('result') is True else False
if result:
# 修改快递信息状态
self.express.status = data.get('returnCode')
self.express.send_count = self.express.send_count + 1
self.express.abort_receive_message = ""
self.express.save()
return True
else:
if data and data.get('returnCode'):
self.express.status = data.get('returnCode')
self.express.save()
watchdog.error(
u'快递订阅异常,订单号:{}, 原因:{}'.format(self.delivery_item.bid,
unicode_full_stack()),
self.express_config.watchdog_type)
return False
def get(args):
order_id = args['order_id']
woid = args['woid']
access_token = args['apiserver_access_token']
timestamp = str(long(time.time() * 1000))
data = {
'timestamp':timestamp, 'woid': woid, 'order_id':order_id,u'access_token':access_token
}
resp = Resource.use('apiserver').get({
'resource': 'mall.express_details',
'data': data
})
errcode = SUCCESS_CODE
if resp:
code = resp["code"]
if code == 200:
order_detail = {}
data = resp["data"]
for express_detail in data['express_details']:
for i in ['express_id', 'ftime', 'status', 'id', 'created_at']:
del express_detail[i]
return {'express':data}
if code == 500:
# msg = '获取物流信息请求参数错误或缺少参数'
errcode = GET_EXPRESS_DETAILS_PARAMETER_ERROR
watchdog.error("get express detail failed!! errcode:{}, msg:{}".format(errcode,unicode_full_stack()),log_type='OPENAPI_ORDER')
return {'errcode':errcode, 'errmsg':code2msg[errcode]}
else:
errcode = SYSTEM_ERROR_CODE
watchdog.error("get express detail failed!! errcode:{}, msg:{}".format(errcode,unicode_full_stack()),log_type='OPENAPI_ORDER')
return {'errcode':errcode, 'errmsg':code2msg[errcode]}
def _parse_result(self, result):
data = dict()
if result is None or len(result) == 0:
return data
try:
data = json.loads(result)
watchdog.info(u'从快递100获取订单信息，data{}'.format(result),
self.express_config.watchdog_type)
except:
notify_message = u'解析快递100获取订单信息失败，url:{}, data:{}, 原因:{}'.format(
result, data, unicode_full_stack())
watchdog.error(notify_message, self.express_config.watchdog_type)
return data
def api_post(request):
# 编辑商品分类
post = request.POST
catalog_id = post.get('catalog_id', '')
name = post.get('catalog_name', '')
note = post.get('note', '')
try:
product_catalog_models.ProductCatalog.objects.filter(
id=catalog_id).update(name=name, note=note)
relation = product_catalog_models.ProductCatalogRelation.objects.filter(
catalog_id=catalog_id)
if relation:
relation = relation.first()
weapp_catalog_id = relation.weapp_catalog_id
params = {'id': weapp_catalog_id, 'name': name}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).post({
'resource':
'mall.classification',
'data':
params
})
if resp and resp.get('code') == 200:
response = create_response(200)
else:
response = create_response(500)
response.errMsg = u'编辑失败'
else:
response = create_response(200)
return response.get_response()
except:
response = create_response(500)
response.errMsg = u'编辑失败'
response.innerErrMsg = unicode_full_stack()
watchdog.error(unicode_full_stack())
return response.get_response()
def _parse_result(self, result):
data = dict()
try:
data = json.loads(result)
# status = int(data['status'])
# if status >= 0 and status < 3:
# data['message'] = self.express_config.STATUSES[status]
# else:
# data['message'] = self.express_config.STATUSES[3]
watchdog_info(u'从快递100获取订单信息，data{}'.format(result), 'EXPRESS')
except:
notify_message = u'解析快递100获取订单信息失败，url:{},原因:{}'.format(
result, unicode_full_stack())
watchdog_error(notify_message)
return data
def save_express_details(self, data):
# 删除之前的
callback_id = int(data.get(
'CallBack', -1)) #CallBack作为ExpressHasOrderPushStatus的id
express_code = int(data.get('LogisticCode', -1)) #快递号
if not callback_id:
watchdog_error(
u'保存快递鸟的推送数据失败,没有返回订阅id,callback_id:{}'.format(callback_id),
self.express_config.watchdog_type)
return False
self.express = express_models.ExpressHasOrderPushStatus.get(
callback_id)
if self.order_id > 0:
ExpressDetail.objects.filter(order_id=self.order_id).delete()
else:
ExpressDetail.objects.filter(express_id=self.express.id).delete()
try:
express_details = data.get('Traces', {})
display_index = 1
express_id = self.express.id if self.express else -1 #订单的推送状态的id
for detail in express_details:
express_detail = ExpressDetail.objects.create(
order_id=self.order_id,
express_id=express_id,
context=detail['AcceptStation'],
time=detail['AcceptTime'],
ftime=detail['AcceptTime'],
#status = detail.get('status',''), #快递鸟没有该数据
display_index=display_index)
display_index = display_index + 1
watchdog_info(
u'保存快递鸟的推送数据成功，express_id:{}, json:{}'.format(
express_id, data), self.express_config.watchdog_type)
self.express.receive_count = self.express.receive_count + 1
self.express.save()
return True
except:
watchdog_error(
u'保存快递鸟的推送数据失败，express_id:{}, json:{}, 原因:{}'.format(
express_id, data, unicode_full_stack()),
self.express_config.watchdog_type)
return False
def _verify_response(self):
"""用登陆返回的code，获取信息,发送请求"""
verity_url = self.EXPRESS_ORDER_QUERY_URL_TMPL.format(
self.express_config.app_key, self.express_company,
self.express_number, self.order_by)
verified_result = ''
try:
verify_response = urllib2.urlopen(verity_url)
verified_result = verify_response.read().strip()
watchdog_info(u'从快递100获取订单信息，url:{}'.format(verity_url), 'EXPRESS')
except:
notify_message = u'从快递100获取订单信息失败，url:{},原因:{}'.format(
verity_url, unicode_full_stack())
watchdog_error(notify_message)
return verified_result
def increase_member_integral(args):
#TODO-bert 调整统一参数
member_id = args['member_id']
event_type = args['event_type']
integral_increase_count = args.get('integral_increase_count', 0)
follower_member = args.get('follower_member', None)
reason = args.get('reason', '')
manager = args.get('manager', '')
webapp_user_id = args.get('webapp_user_id', None)
corp = args['corp']
integral_increase_count = int(integral_increase_count)
if integral_increase_count == 0:
return None
member = corp.member_repository.get_member_by_id(member_id)
current_integral = member.integral + integral_increase_count
try:
#TODO-bert 并发下是否会出现积分日志无法对应上
member_models.Member.update(
integral=member_models.Member.integral +
integral_increase_count).dj_where(id=member.id).execute()
integral_log = member_models.MemberIntegralLog.create(
member=member.id,
follower_member_token=follower_member.token
if follower_member else '',
integral_count=integral_increase_count,
event_type=event_type,
webapp_user_id=webapp_user_id,
reason=reason,
current_integral=current_integral,
manager=manager)
# todo 看起来有个清理缓存的样子。。。。
if member:
member.cleanup_cache()
return True, integral_log.id
except:
notify_message = u"update_member_integral member_id:{}, cause:\n{}".format(
member.id, unicode_full_stack())
watchdog.error(notify_message)
return False, None
def post(args):
woid = args['woid']
order_id = args['order_id']
access_token = args['apiserver_access_token']
timestamp = str(long(time.time() * 1000))
data = {
'order_id': order_id,
'timestamp': timestamp,
'woid': woid,
u'access_token': access_token,
'action': 'cancel'
}
resp = Resource.use('apiserver').put({
'resource': 'mall.refund',
'data': data
})
status = 0
code = 0
errcode = SUCCESS_CODE
if resp:
code = resp["code"]
if code == 200:
return {'errcode': errcode}
if code == 500:
msg = resp['data']['msg']
errcode = SUB_ORDER_STATUS_ERROR
if msg == u'有子订单的状态不是待发货,不能取消订单':
errcode = CANCEL_ORDER_ERROR
watchdog.info(
"cancel order failed!! errcode:{}, msg:{}".format(
errcode, msg),
log_type='OPENAPI_ORDER')
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
else:
errcode = SYSTEM_ERROR_CODE
watchdog.error("cancel order failed!! errcode:{}, msg:{}".format(
errcode, unicode_full_stack()),
log_type='OPENAPI_ORDER')
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
def getMessge(self, level, message, log_type, log_id):
self.index += 1
if log_type:
self.log_type = log_type
self.log_id = log_id
try:
err_msg = ''
json.dumps(message)
except:
message = str(message)
err_msg = unicode_full_stack()
# message = {
# "msg": self.msg,
# "service_name": self.service_name,
# "type": self.type,
# "uuid": self.id,
# "index": self.index,
# "xmessage": message, # 兼容elk，字段名不能为message
# "json_error": err_msg
# }
message = {
"msg": self.msg,
"service_name": self.service_name,
"type": self.log_type,
"uuid": self.log_id,
"index": self.index,
"xmessage": message, # 兼容elk，字段名不能为message
"json_error": err_msg,
"level": level,
"datetime": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'version': self.version
}
# log = json.dumps(message) + ":::" + pson.dumps(message)
# log = json.dumps({
# 'json_log': message,
# # 'pson_log': pson.dumps(message, stringify=False)
# 'pson_log': pson.dumps(message)
# })
log = pson.dumps(message)
return log
def _poll_response(self):
"""
发送快递100 订阅请求，返回成功与否信息
"""
# post中的param的json
param_json_data = {
'Code':
self.express_company_name_kdniao,
'Item': [
{
'No': str(self.express_number),
'Bk': str(self.express.id)
},
]
}
DataSign = self._encrypt(str(param_json_data))
params = {
"RequestData": param_json_data,
"EBusinessID": self.Business_id,
"RequestType": "1005",
"DataSign": DataSign,
"DataType": "2"
}
#将数据处理为RequestData=xxx&DataType=xxx这种格式的
param_str = urllib.urlencode(params)
verified_result = ''
try:
verified_result = post(KdniaoExpressConfig.req_url, param_str)
watchdog.info(
u"发送快递鸟 订阅请求 url: {},/n param_data: {}, /n response: {}".
format(KdniaoExpressConfig.req_url, param_str,
verified_result.decode('utf-8')),
self.express_config.watchdog_type)
except:
watchdog.error(
u'发送快递鸟 订阅请求 失败，url:{},data:{},原因:{}'.format(
KdniaoExpressConfig.req_url, param_str,
unicode_full_stack()), self.express_config.watchdog_type)
return verified_result
def update_order_status(self, data, orders):
status = data.get("State")
#status 1：已取件2：在途中 3：签收
for order in orders:
try:
if int(
status
) == self.express_config.STATE_SIGNED and order.status == 4:
mall_api.update_order_status(user=None,
action=u'finish-系统',
order=order)
except:
watchdog_error(
u'修改订单状态失败，该订单已签收，order_id:{}, 原因:{}'.format(
order.id, unicode_full_stack()),
self.express_config.watchdog_type)
return True
def process_request(self, req, resp):
if req.path == "/notifications":
if not mns_util.mns_authenticate(req):
self.raise_response({"errmsg": "Access Forbidden!"},
falcon.HTTP_403)
msg = mns_util.NotifyMessage()
msg_type = "XML"
body = req.stream.read()
# print ">>>>>>>>>>", body
if not mns_util.validate_body(body, msg, msg_type):
self.raise_response({"errmsg": "Invalid Notify Message"},
falcon.HTTP_400)
msg = msg.to_dict()
logging.info(
"Receive Message Succeed! MessageBody:%s MessageID:%s" %
(msg['message'], msg['message_id']))
message = base64.decodestring(msg['message'])
data = json.loads(message)
function_name = data['name']
func = handler_register.find_message_handler(function_name)
status = falcon.HTTP_500
if func:
try:
response = func(data['data'], msg)
logging.info("service response: {}".format(response))
status = falcon.HTTP_200
except:
logging.info(u"Service Exception: {}".format(
unicode_full_stack()))
else:
logging.info(
u"Error: no such service found : {}".format(function_name))
# query_string = urllib.urlencode({'message': recv_msg['message']})
# raise redirects.HTTPTemporaryRedirect("/notifications/HTTPEndpoint?{}".format(query_string))
# resp = Resource.use('notifications', 'localhost:4180').post({'resource': 'HTTPEndpoint', 'data': {'message': recv_msg['message']} })
self.raise_response({}, status)
def update_order_status(self, json, orders):
status = json.get(self.express_params.LAST_RESULT,
{}).get(self.express_params.STATE)
# 状态为 3已签收，并且order的状态为 已发货
# 将状态改为 已完成
for order in orders:
try:
if int(
status
) == self.express_config.STATE_SIGNED and order.status == 4:
mall_api.update_order_status(user=None,
action=u'finish-系统',
order=order)
# order.status = 5
# order.save()
except:
watchdog_error(
u'修改订单状态失败，该订单已签收，order_id:{}, 原因:{}'.format(
order.id, unicode_full_stack()),
self.express_config.watchdog_type)
return True
def getMessge(self, message, user_id, type=None):
self.index += 1
if type:
self.type = type
try:
err_msg = ''
json.dumps(message)
except:
message = str(message)
err_msg = unicode_full_stack()
message = {
"msg": self.msg,
"service_name": self.service_name,
"type": self.type,
"uuid": self.id,
"index": self.index,
"message": message,
"user_id": user_id,
"json_error": err_msg
}
return json.dumps(message)
def upload_qrcode_url_to_upyun(http_image_url, file_name):
if settings.MODE == 'develop':
return '/static%s' % upyun_path
up = upyun.UpYun(BUCKETNAME,
USERNAME,
PASSWORD,
timeout=300,
endpoint=upyun.ED_AUTO)
#headers = {"x-gmkerl-rotate": "180"}
try:
res = urllib2.urlopen(http_image_url).read()
result = up.put('/qrcode/%s' % file_name, res)
if result:
return qr_image_path % (BUCKETNAME, file_name)
else:
return http_image_url
except:
notify_message = u"upload_qrcode_url_to_upyun error {}".format(
unicode_full_stack())
watchdog.error(notify_message)
return http_image_url
return None
def save_express_details(self, json):
# 删除之前的
if self.order_id > 0:
ExpressDetail.objects.filter(order_id=self.order_id).delete()
else:
ExpressDetail.objects.filter(express_id=self.express.id).delete()
try:
express_details = json.get(self.express_params.LAST_RESULT,
{}).get('data', {})
display_index = 1
express_id = self.express.id if self.express else -1
for detail in express_details:
ExpressDetail.objects.create(order_id=self.order_id,
express_id=express_id,
context=detail['context'],
time=detail['time'],
ftime=detail['ftime'],
status=detail.get('status', ''),
display_index=display_index)
display_index = display_index + 1
watchdog_info(
u'保存快递100的 推送数据成功，url:{}, json:{}'.format(
self.callback_post_request.get_full_path(), json),
self.express_config.watchdog_type)
self.express.receive_count = self.express.receive_count + 1
self.express.save()
return True
except:
watchdog_error(
u'保存快递100的 推送数据失败，url:{}, json:{}, 原因:{}'.format(
self.callback_post_request.get_full_path(), json,
unicode_full_stack()), self.express_config.watchdog_type)
return False
