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')), type=self.express_config.watchdog_type)
except:
watchdog_error(u'发送快递鸟 订阅请求 失败，url:{},data:{},原因:{}'.format(KdniaoExpressConfig.req_url,
param_str,
unicode_full_stack()), type=self.express_config.watchdog_type)
return verified_result
def _verify_response(self):
"""用登陆返回的code，获取access_token,发送请求"""
param_data = {'client_id': self.weibo_config.app_id,
'client_secret': self.weibo_config.app_secret,
'grant_type': 'authorization_code',
'redirect_uri': self.redirect_uri,
'code': self.code}
verified_result = ''
try:
data = urllib.urlencode(param_data)
request = urllib2.Request(self.WEIBO_AUTHORIZE_URL_TMPL,data)
response = urllib2.urlopen(request)
file = response.read()
verified_result = file
watchdog_info(u"get_access_token_data url: %s ,"
u"param_data: %s" % (self.WEIBO_AUTHORIZE_URL_TMPL, data))
except:
watchdog_error(u'从Weibo获取access token失败，url:{},data:{},原因:{}'.format(self.WEIBO_AUTHORIZE_URL_TMPL,
param_data,
unicode_full_stack()))
notify_message = u'从Weibo获取access token失败，url:{},data:{},原因:{}'.format(self.WEIBO_AUTHORIZE_URL_TMPL,
param_data,
unicode_full_stack())
watchdog_fatal(notify_message)
return verified_result
def set_submit_booking(self):
data = self._submit_booking()
watchdog_info(u"set_submit_booking data:\n{}".format(data), self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
if data.get('Header').get('Code') != 0:
watchdog_fatal(u'从Shengjing获取submit booking返回code不为0，url:{}, data:{}'.format(self.api_url, self.param_str),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
return data
def start_promotion(request0, args):
"""
将promotion的状态改为"进行中"的服务
@param request 无用，为了兼容
@param args dict类型
"""
# 构造request对象
print '\n\n'
print '-*-' * 30
print 'start service @%s', datetime.now().strftime('%Y-%m-%d %H:%M:%S')
promotion_id = str(args['id']).strip()
if not promotion_id:
print 'No promotion_id. Return directly'
return
if int(promotion_id) == 0:
#处理全部促销
now = datetime.today()
promotion_ids = [promotion.id for promotion in promotion_models.Promotion.objects.filter(status=promotion_models.PROMOTION_STATUS_NOT_START, start_date__lte=now)]
promotion_models.Promotion.objects.filter(id__in=promotion_ids).update(status=promotion_models.PROMOTION_STATUS_STARTED)
watchdog_info('将promotion(%s)状态改为PROMOTION_STATUS_STARTED' % promotion_ids)
else:
promotion_models.Promotion.objects.filter(id=promotion_id).update(status=promotion_models.PROMOTION_STATUS_STARTED)
promotion_ids = [promotion_id]
watchdog_info('将promotion(%s)状态改为PROMOTION_STATUS_STARTED' % promotion_id)
product_ids = [r.product_id for r in promotion_models.ProductHasPromotion.objects.filter(promotion_id__in=promotion_ids)]
products = list(mall_models.Product.objects.filter(id__in=product_ids))
from cache.webapp_cache import update_product_cache
for product in products:
update_product_cache(product.owner_id, product.id)
return "OK"
def get_invitation_list(self):
data = self._invitation_list()
watchdog_info(
u"shengjing 访问二维码列表 get_invitation_list data:\n{}".format(data),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
data = self._resolve_invitation_list_json(data)
return data
def login_callback_handler(request):
code = request.GET.get('code', None)
state = request.GET.get('state', None)
new_url = '/'
response = HttpResponseRedirect(new_url)
watchdog_info(u'从QQ登陆回调函数，code={}，state={}'.format(code, state))
if code:
try:
# 获取webapp_id 和 登陆后跳转地址
webapp_id, new_url = get_shop_name_and_last_url(state)
request = set_user_profile(request, webapp_id)
# 获取 access_token
qq_get_token = QQAccessToken(request, code)
data = qq_get_token.get_access_token_data()
token = data.get('access_token')
# 获取 openId
qq_get_open_id = QQOpenID(request, token)
data = qq_get_open_id.get_open_id_data()
openid = data.get('openid')
# 创建 social_account
social_account = save_social_account(openid, token,
SOCIAL_PLATFORM_QQ, webapp_id)
response = HttpResponseRedirect(new_url)
save_session(response, social_account)
except:
watchdog_error(u'从QQ登陆回调函数错误，error={}'.format(
unicode_full_stack()))
else:
response = HttpResponseRedirect(new_url)
notify_message = u'从QQ登陆回调函数错误，没有code{}'.format(request)
watchdog_fatal(notify_message)
return response
def get_session_id_data(self):
data = self._session_id()
watchdog_info(u"get_session_id_data data:\n{}".format(data),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
session_id = self._resolve_session_id_json(data)
# print '>>>>>>>>>>>>>>>>>>>>>>>'
# print session_id
return session_id
def handle(self, **options):
"""
取消“团购”超时的未付款订单的
"""
try:
webapp_ids = []
relations = mall_models.OrderHasGroup.objects.filter(
group_status=mall_models.GROUP_STATUS_ON)
for relation in relations:
if relation.webapp_id not in webapp_ids:
webapp_ids.append(relation.webapp_id)
webapp_id2user = dict([
(user_profile.webapp_id, user_profile.user)
for user_profile in UserProfile.objects.filter(
webapp_id__in=webapp_ids)
])
order_ids = []
orders = mall_models.Order.objects.filter(
order_id__in=[r.order_id for r in relations],
status=mall_models.ORDER_STATUS_NOT,
created_at__lte=datetime.now() - timedelta(minutes=15))
for order in orders:
try:
update_order_status(webapp_id2user[order.webapp_id],
'cancel', order)
relations.filter(order_id=order.order_id).update(
group_status=mall_models.GROUP_STATUS_failure)
logging.info(u"团购15分钟未支付订单order_id:%s取消成功" %
order.order_id)
order_ids.append(order.order_id)
except:
notify_msg = u"团购未支付订单{}，取消失败, cause:\n{}".format(
order.order_id, unicode_full_stack())
watchdog_error(notify_msg)
continue
watchdog_info({
'hint': 'cancel_group_order_and_notify_pay',
'order_ids': 'order_ids',
'uuid': 'cancel_group_order_and_notify_pay'
})
if not settings.IS_UNDER_BDD and order_ids:
# BDD时不发消息
topic_name = "order-close"
data = {
"name": "cancel_group_order_and_notify_pay",
"data": {
"order_ids": order_ids
}
}
msg_name = "cancel_order"
msgutil.send_message(topic_name, msg_name, data)
except:
notify_msg = u"团购未支付订单取消失败, cause:\n{}".format(
unicode_full_stack())
watchdog_error(notify_msg)
print "success"
def get_captcha_verify_data(self):
captcha_json = self._captcha_verify()
watchdog_info(
u"盛景验证手机号 captcha_verify \n url:\n{}?{}\n data:\n{}".format(
self.api_url, self.param_data, captcha_json),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
print '>>>>>>>>>>>>>>>>>>>>>>>'
print captcha_json
return captcha_json
def update_product_list_cache_task(self,webapp_owner_id):
product_models = __get_product_models_for_list(webapp_owner_id)
categories = ProductCategory.objects.filter(owner_id=webapp_owner_id)
product_ids = [product_model.id for product_model in product_models]
category_has_products = CategoryHasProduct.objects.filter(product__in=product_ids)
product2categories = dict()
for relation in category_has_products:
product2categories.setdefault(relation.product_id, set()).add(relation.category_id)
categories = [{"id": category.id, "name": category.name} for category in categories]
from django.contrib.auth.models import User
webapp_owner = User.objects.get(id=webapp_owner_id)
mall_models.Product.fill_details(webapp_owner=webapp_owner, products=product_models, options={
"with_price": True,
"flash_sale": True,
"with_selected_category": True
})
product_datas = []
for product in product_models:
if 'http:' in product.thumbnails_url:
thumbnails_url = product.thumbnails_url
else:
thumbnails_url = '%s%s' % (settings.IMAGE_HOST, product.thumbnails_url)
product_datas.append({
"id": product.id,
"name": product.name,
"is_member_product": product.is_member_product,
"display_price": product.display_price,
"promotion_js": json.dumps(product.promotion),
"thumbnails_url": thumbnails_url,
"categories": list(product2categories.get(product.id, [])),
"supplier": product.supplier
})
# for product_data in product_datas:
# product_data['categories'] = list(product2categories.get(product_data['id'], []))
data = {
"products": product_datas,
"categories": categories
}
watchdog_info({
'msg_id': 'set_product_list_cache',
'woid': webapp_owner_id,
'data': data
})
key = 'webapp_products_categories_{wo:%s}' % webapp_owner_id
api_key = 'api' + key
cache_util.set_cache(api_key, data)
def get_captcha_data(self):
captcha_json = self._captcha()
watchdog_info(
u"盛景获取验证码 get_captcha_data \n url:\n{}?{}\n data:\n{}".format(
self.api_url, self.param_data, captcha_json),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
# print '>>>>>>>>>>>>>>>>>>>>>>>'
# print captcha_json
return captcha_json
def post_processing(self,
context,
handler,
response_content,
is_from_simulator=False):
#来自模拟器的消息不进行记录
if not is_from_simulator:
watchdog_info(u"{} response:\n {}".format(
handler.__class__.__name__, response_content),
user_id=context.user_profile.user_id)
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')),
type=self.express_config.watchdog_type)
except:
watchdog_error(u'发送快递100 订阅请求 失败，url:{},data:{},原因:{}'.format(
self.express_config.get_api_url(), param_str,
unicode_full_stack()),
type=self.express_config.watchdog_type)
return verified_result
def send_message_to_activemq(destination,
message_str,
retry_times=default_retry_times):
"""
send the message to specific destination
\param destination
the destination of the message send to.
ex. '/queue/jms.com.wintim.service' or '/topic/jms.com.wintim.service'
\param message_str
the message send to the destination, it will
be wrapped as textMessage, it must be in json type
\param retry_times
when send message failed, try 'retry_times' times again
\param activeMQ_host
this host of the activeMQ server's transportConnector, default is 'mq.wintim.com'
\param activeMQ_port
this port of the activeMQ server's transportConnector
"""
host = settings.MOM_HOST
port = settings.MOM_PORT
conn = stomp.Connection([(host, port)])
conn.start()
conn.connect(wait=True)
print 'send message [%s] to destination %s at %s:%s' % (
message_str, destination, host, port)
watchdog_info('send message [%s] to destination %s at %s:%s' %
(message_str, destination, host, port))
try:
conn.send(message_str, destination=destination, \
headers={'type':'textMessage','MessageNumber':random.randint(0,65535), 'persistent':'true'}, ack='auto')
except Exception, e:
print 'failed to send message, caused by ', (str)(e)
print 'retry send message [%s] to destination %s' % (message_str,
destination)
i = 1
while i < retry_times:
if conn.is_connected() == False:
conn.connect(wait=True)
try:
time.sleep(1)
conn.send(message_str, destination=destination, \
headers={'type':'textMessage','MessageNumber':random.randint(0,65535), 'persistent':'true'}, ack='auto')
except:
pass
i += 1
if i >= retry_times:
raise Exception, '[has retry %d times]' % retry_times
def cancel_order(request, args):
"""
取消订单的service
@param request 无用，为了兼容
@param args dict类型，内含order_id, reason
"""
# 构造request对象
promotion_id = args['id']
promotion_models.Promotion.objects.filter(id=promotion_id).update(
status=promotion_models.PROMOTION_STATUS_FINISHED)
watchdog_info('将promotion(%s)状态改为PROMOTION_STATUS_FINISHED' % promotion_id)
return "OK"
def get_state(self, request):
webapp_id = '3181'
try:
last_page = request.META['HTTP_REFERER']
webapp_id = request.user_profile.webapp_id
notify_message = u'微博登陆获取webapp_id在weibo_config.py，webapp_id:{}'.format(
webapp_id)
watchdog_info(notify_message)
except:
notify_message = u'微博登陆获取webapp_id错误在weibo_config.py，原因:{}'.format(
unicode_full_stack())
watchdog_fatal(notify_message)
last_page = '/'
return '%s~%s' % (webapp_id, last_page)
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 _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 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 serve(request, args):
#mall_models.MallCounter.increase_unread_order(request.webapp_owner_id, 1) #增加未读订单计数
mall_models.increase_unread_order(request.webapp_owner_id, 1) #增加未读订单计数
watchdog_info("increased unread order by 1 in MallCounter, oid: {}".format(
request.webapp_owner_id))
event_specific_data = args['event_specific_data']
order_order_id = event_specific_data['order_order_id']
mall_api.record_operation_log(order_order_id, u'客户', u'下单')
order = mall_models.Order.objects.get(order_id=order_order_id)
from webapp.handlers import event_handler_util
from utils import json_util
event_data = {
'order': json.dumps(order.to_dict(), cls=json_util.DateEncoder)
}
event_handler_util.handle(event_data, 'send_order_email')
def _learn_plan_list_response(self):
"""使用sessionID和phone获取学习计划列表"""
param_json_data = {
self.shengjing_params.METHOD:
self.shengjing_config.method_get_learn_plan_list,
self.shengjing_params.VERSION: self.shengjing_config.version,
self.shengjing_params.APPID: self.shengjing_config.app_id,
self.shengjing_params.APPKEY: self.shengjing_config.get_app_key(),
self.shengjing_params.PARAMS: {
self.shengjing_params.PHONE_NUMBER: self.phone,
self.shengjing_params.COMPANY_NAME: self.company_name,
self.shengjing_params.STATUS: self.status
}
}
# 将params的json转换为字符串
param_str = json.dumps(param_json_data)
# print param_str
param_data = {self.shengjing_params.PARAM: param_str}
verified_result = ''
try:
param_data = urllib.urlencode(param_data)
# print '-------------------------------------------'
# print param_data
request = urllib2.Request(self.api_url, param_data)
response = urllib2.urlopen(request)
file = response.read()
verified_result = file
watchdog_info(
u"盛景learn_plan url: %s ,"
u"param_data: %s" % (self.api_url, param_data),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
except:
watchdog_error(
u'从Shengjing获取learn_plan list失败，url:{},data:{},原因:{}'.format(
self.api_url, param_data, unicode_full_stack()),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
# notify_message = u'从Shengjing获取learn_plan list失败，url:{},data:{},原因:{}'.format(self.api_url,
# param_data,
# unicode_full_stack())
# watchdog_fatal(notify_message, self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
return verified_result
def _captcha_verify_response(self):
"""使用MPhone获取captcha"""
param_json_data = {
self.shengjing_params.METHOD:
self.shengjing_config.method_captcha_verify,
self.shengjing_params.VERSION: self.shengjing_config.version,
self.shengjing_params.APPID: self.shengjing_config.app_id,
self.shengjing_params.APPKEY: self.shengjing_config.get_app_key(),
self.shengjing_params.PARAMS: {
self.shengjing_params.PARAM_MPHONE: self.phone,
self.shengjing_params.Captcha: self.captcha
}
}
# 将params的json转换为字符串
param_str = json.dumps(param_json_data)
param_data = {self.shengjing_params.PARAM: param_str}
verified_result = ''
try:
param_data = urllib.urlencode(param_data)
self.param_data = param_data
print '------------------ShengjingCaptchaVerify-------------------------'
print self.api_url
print param_data
request = urllib2.Request(self.api_url, param_data)
response = urllib2.urlopen(request)
file = response.read()
verified_result = file
watchdog_info(
u"captcha_verify url: %s ,"
u"param_data: %s" % (self.api_url, param_data),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
except:
watchdog_error(
u'从Shengjing获取captcha_verify失败，url:{},data:{},原因:{}'.format(
self.api_url, param_data, unicode_full_stack()))
notify_message = u'从Shengjing获取captcha_verify失败，url:{},data:{},原因:{}'.format(
self.api_url, param_data, unicode_full_stack())
watchdog_fatal(notify_message,
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
return verified_result
def get_promotion_and_apps_second_navs(request):
if request.user.username == 'manager':
second_navs = []
else:
try:
api_resp = Resource.use('marketapp_apiserver').get({
'resource': 'apps.get_apps_third_menu',
'data': {
'manager_username': request.manager.username
}
})
watchdog_info(
'call marketapp_apiserver: apps.get_apps_third_menu, resp==> \n{}'
.format(api_resp))
if api_resp and api_resp['code'] == 200:
resp_data = api_resp['data']
for app in resp_data:
app['url'] = 'http://{}{}'.format(MARKETAPP_DOMAIN,
app['url'])
app['users'] = []
app['need_token'] = True
app['need_blank'] = True
MALL_PROMOTION_AND_APPS_SECOND_NAV['navs'][1][
'third_navs'] = resp_data + DEFAULT_APPS_THIRD_NAVS
else:
MALL_PROMOTION_AND_APPS_SECOND_NAV['navs'][1][
'third_navs'] = DEFAULT_APPS_THIRD_NAVS
except:
notify_message = u"从marketapp获取活动列表失败，cause: \n{}".format(
unicode_full_stack())
watchdog_error(notify_message)
MALL_PROMOTION_AND_APPS_SECOND_NAV['navs'][1][
'third_navs'] = DEFAULT_APPS_THIRD_NAVS
navs = copy.deepcopy(MALL_PROMOTION_AND_APPS_SECOND_NAV)
if request.user_profile.webapp_type == 1 and VAR_PREMIUM_SALE in navs[
'navs'][0]['third_navs']:
# 社群商城关闭买赠功能
navs['navs'][0]['third_navs'].remove(VAR_PREMIUM_SALE)
second_navs = [navs]
return second_navs
def _submit_booking_response(self):
"""提交在线预约信息接口"""
param_json_data = {
self.shengjing_params.METHOD: self.shengjing_config.method_submit_booking,
self.shengjing_params.VERSION: self.shengjing_config.version,
self.shengjing_params.APPID: self.shengjing_config.app_id,
self.shengjing_params.APPKEY: self.shengjing_config.get_app_key(),
self.shengjing_params.PARAMS: {
self.shengjing_params.COURSE: self.course.name,
self.shengjing_params.STUDENT: self.course.member_name,
self.shengjing_params.PARAM_MPHONE: self.course.member_phone,
self.shengjing_params.CUSTOMER: self.course.member_company,
self.shengjing_params.NUMBER: self.course.number,
self.shengjing_params.BOOKED_TIME: self.course.date_time
}
}
# 将params的json转换为字符串
param_str = json.dumps(param_json_data)
self.param_str = param_str
param_data = {
self.shengjing_params.PARAM: param_str
}
verified_result = ''
try:
param_data = urllib.urlencode(param_data)
print '-------------------------------------------'
print param_data
request = urllib2.Request(self.api_url, param_data)
response = urllib2.urlopen(request)
file = response.read()
verified_result = file
watchdog_info(u"_submit_booking_response url: %s ,"
u"param_data: %s" % (self.api_url, param_data), self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
except:
watchdog_error(u'从Shengjing获取submit booking失败，url:{},data:{},原因:{}'.format(self.api_url,
param_data,
unicode_full_stack()),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
return verified_result
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 _invitation_list_response(self):
"""使用sessionID和phone获取二维码签到列表"""
param_json_data = {
self.shengjing_params.METHOD:
self.shengjing_config.method_get_invitation_list,
self.shengjing_params.VERSION: self.shengjing_config.version,
self.shengjing_params.APPID: self.shengjing_config.app_id,
self.shengjing_params.APPKEY: self.shengjing_config.get_app_key(),
self.shengjing_params.PARAMS: {
self.shengjing_params.PARAM_MPHONE: self.phone
}
}
# 将params的json转换为字符串
param_str = json.dumps(param_json_data)
# print param_str
param_data = {self.shengjing_params.PARAM: param_str}
verified_result = ''
try:
param_data = urllib.urlencode(param_data)
# print '-------------------------------------------'
# print param_data
request = urllib2.Request(self.api_url, param_data)
response = urllib2.urlopen(request)
file = response.read()
verified_result = file
watchdog_info(
u"get_session_id_data url: %s ,"
u"param_data: %s" % (self.api_url, param_data),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
except:
watchdog_error(
u'从Shengjing获取invitation list失败，url:{},data:{},原因:{}'.format(
self.api_url, param_data, unicode_full_stack()),
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
notify_message = u'从Shengjing获取invitation list失败，url:{},data:{},原因:{}'.format(
self.api_url, param_data, unicode_full_stack())
watchdog_fatal(notify_message,
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
return verified_result
def query_order(request):
app_id = request.GET.get('app_id', '').strip()
app_key = request.GET.get('app_key', '').strip()
partner_id = request.GET.get('partner_id', '')
partner_key = request.GET.get('partner_key', '')
out_trade_no = request.GET.get('out_trade_no', '')
pay_version = request.GET.get('pay_version', PAY_V2)
data = {}
try:
# 查询订单获取开始时间
query_order_start_time = int(time.time() * 1000)
weixin_http_client = WeixinHttpClient()
if int(pay_version) == PAY_V2:
message = QueryOrderV2Message(app_id, app_key, partner_id,
partner_key, out_trade_no)
api = WeixinPayApi(weixin_http_client, is_for=IS_FOR_JSON)
else:
message = QueryOrderV3Message(app_id, partner_id, partner_key,
out_trade_no)
api = WeixinPayApi(weixin_http_client, is_for=IS_FOR_XML)
data = api.query_order(message)
# 查询订单获取结束时间
query_order_end_time = int(time.time() * 1000)
msg = u'weixin pay, stage:[query order], order_id:{}, consumed:{}ms, result:\n{}'.format(
out_trade_no, (query_order_end_time - query_order_start_time),
data)
watchdog_info(msg)
response = create_response(200)
response.data = data
return response.get_response()
except:
notify_message = u"weixin pay, stage:[query order], result:\n{}, exception:\n{}".format(
data, unicode_full_stack())
watchdog_error(notify_message)
response = create_response(201)
response.innerErrMsg = unicode_full_stack()
return response.get_response()
def _handle_post(request):
if request.method == "POST":
watchdog_info(u'绑定盛景信息，保存手动输入公司名称，request：{}'.format(request.__dict__),
'SHENGJING')
binding_member_id = request.POST.get('binding_member_id', -1)
name = request.POST.get('name', None)
position = request.POST.get('position', '')
company = request.POST.get('company', '')
#判断是否绑定过
if name and binding_member_id != -1: #and ShengjingBindingMemberInfo.objects.filter(binding_id=binding_member_id, name=name).count == 0:
if ShengjingBindingMemberInfo.objects.filter(
binding_id=binding_member_id).count() == 0:
ShengjingBindingMemberInfo.objects.create(
name=name, position=position, binding_id=binding_member_id)
#绑定成功 给父节点增加积分
ShengjingIntegralStrategySttings.increase_integral_for_father_by_binding_id(
binding_member_id, request.user_profile.webapp_id)
ShengjingBindingMemberHasCompanys.objects.get_or_create(
name=company, binding_id=binding_member_id)
def _verify_response(self):
"""用登陆返回的code，获取access_token,发送请求"""
verity_url = self.QQ_AUTHORIZE_URL_TMPL.format(
self.qq_config.app_id,
self.qq_config.app_key,
self.code,
urllib.quote(self.redirect_uri, ''),
)
verified_result = ''
verify_response = None
try:
verify_response = urllib2.urlopen(verity_url)
verified_result = verify_response.read().strip()
watchdog_info(u'从QQ获取access token，url:{}'.format(verity_url))
except:
notify_message = u'从QQ获取access token失败，url:{},原因:{}'.format(verity_url, unicode_full_stack())
watchdog_error(notify_message)
return verified_result
def _verify_response(self):
"""获取get_token_info,发送请求"""
param_data = {'access_token': self.access_token}
verified_result = ''
try:
data = urllib.urlencode(param_data)
request = urllib2.Request(self.WEIBO_GET_TOKEN_INFO_TMPL, data)
response = urllib2.urlopen(request)
file = response.read()
verified_result = file
watchdog_info(u"get_open_id_data verified_result: %s" %
verified_result)
except:
notify_message = u'从weibo获取token_info失败，url:{},原因:{}'.format(
self.WEIBO_GET_TOKEN_INFO_TMPL, unicode_full_stack())
watchdog_fatal(notify_message)
return verified_result
