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