def create_question(request):
response = create_response(200)
start_patterns = request.POST.get('start_patterns', '').strip()
end_patterns = request.POST.get('end_patterns', '').strip()
finished_message = request.POST.get('finished_message', '')
problems = request.POST.get('problems')
prizes = request.POST.get('prizes')
question = QuestionInfo.objects.create(owner=request.user,
start_patterns=start_patterns,
end_patterns=end_patterns,
finished_message=finished_message)
json_problems = decode_json_str(problems)
json_prizes = decode_json_str(prizes)
display_index = 0
for problem in json_problems:
display_index = display_index + 1
Problem.objects.create(question_answer=question,
title=problem['title'],
right_answer=problem['right_answer'],
right_feedback=problem['right_feedback'],
error_feedback=problem['error_feedback'],
display_index=display_index)
for prize in json_prizes:
Prize.objects.create(question_answer=question,
right_count_min=prize['right_count_min'],
right_count_max=prize['right_count_max'],
content=prize['content'],
count=prize['count'])
return response.get_response()
def api_post(request):
"""
更新自定义菜单项状态
"""
owner = request.manager
status = int(request.POST['status'])
#开启自定义菜单
if status == STATUS_OPEN:
#调用微信api
menu_json_obj = menu_util.get_menus_json_for_weixin(
request.manager)
post = {'menu_json': json.dumps(menu_json_obj, ensure_ascii=False)}
fake_request = menu_util.get_fake_request(request.manager, post)
response = menu_tool.update_customerized_menu(fake_request)
#禁用自定义菜单
if status == STATUS_STOP:
response = menu_tool.delete_customerized_menu(request)
# response = create_response(200).get_response()
result = decode_json_str(response.content)
try:
if int(result['code']) == 200:
try:
menu_status = CustomerMenuStatus.objects.get(owner=owner)
except:
menu_status = CustomerMenuStatus()
menu_status.owner = owner
menu_status.status = status
menu_status.save()
except:
pass
return response
def send_custom_msg(self, sendto_openid, custom_msg):
post_param_json_str = None
try:
post_param_json_str = build_custom_message_json_str(
sendto_openid, custom_msg)
except:
self._raise_system_error(u'创建要发送的客服消息')
if post_param_json_str is None:
self._raise_system_error(u'要发送的客服消息为None')
post_param_json = decode_json_str(post_param_json_str)
request_url = self._complete_weixin_api_get_request_url(
'cgi-bin/message/custom/send', {})
try:
api_response = self.weixin_http_client.post(
request_url, post_param_json)
except:
self._raise_system_error(
u"发送客服消息:\n{}".format(post_param_json_str))
if self._is_error_response(api_response):
self._raise_request_error(
api_response, u"发送客服消息:\n{}".format(post_param_json_str))
return api_response
def create_qrcode_ticket(self,
scene_id,
ticket_type=QrcodeTicket.TEMPORARY,
is_retry=False):
post_param_json_str = '{"expire_seconds": %d, "action_name": "%s", "action_info": {"scene": {"scene_id": %d}}}' % (
QrcodeTicket.MAX_EXPIRE_SECONDS, ticket_type, scene_id)
post_param_json = decode_json_str(post_param_json_str)
request_url = self._complete_weixin_api_get_request_url(
'cgi-bin/qrcode/create', {})
try:
api_response = self.weixin_http_client.post(
request_url, post_param_json)
except:
self._raise_system_error(u'创建带参数的二维码')
if self._is_error_response(api_response):
if self._is_error_dueto_access_token(api_response):
if is_retry:
self._raise_request_error(api_response, u'创建带参数的二维码')
else:
#如果由于access_token的问题，那么先更新access_token后重试
if (update_access_token(self.mpuser_access_token)):
return create_qrcode_ticket(scene_id, ticket_type,
True)
else:
self._raise_request_error(api_response, u'创建带参数的二维码')
else:
self._raise_request_error(api_response, u'创建带参数的二维码')
return QrcodeTicket(api_response)
def _parse_response(self, response_text):
response_text = response_text.strip()
if response_text.startswith(u'{') and response_text.endswith(u'}'):
try:
return decode_json_str(response_text)
except:
return response_text
else:
return response_text
def _assert_integral_equal_with_increase_by_award(self, response, member,
expected_increase_count):
latest_member = self._reload_member(self.test_member)
expected_new_integral = self.test_member.integral + expected_increase_count
self.assertEqual(expected_new_integral, latest_member.integral)
response_json = decode_json_str(response.content)
self.assertEqual(expected_increase_count,
response_json['data']['integral_increase_count'])
def update_vote(request):
try:
vote_options_json_str = request.POST["vote_options"]
vote_options = decode_json_str(vote_options_json_str)
is_non_member = int(request.POST.get("is_non_member", 0))
vote_id = int(request.POST['id'])
Vote.objects.filter(id=vote_id, owner=request.user).update(
name=request.POST["name"].strip(),
detail=request.POST["detail"].strip(),
award_prize_info=request.POST['prize_info'].strip(),
is_non_member=is_non_member)
#更新所有投票选项：
#1. 获取之前库中存在的所有投票选项id集合update_vote_options_ids
#2. 更新update_vote_options_ids对应的所有投票选项信息
#3. 删除库中除update_vote_options_ids之外的所有选项
#4. 创建本次提交的新增的投票选项
#
#在操作过程中如果发生异常中断，之前已经进行的操作
#不会进行恢复
update_vote_options_ids = []
new_added_vote_options = []
for vote_option in vote_options:
vote_option_id = int(vote_option['id'])
if vote_option_id == -1: #新创建的
new_added_vote_options.append(vote_option)
else: #更新之前的选项
update_vote_options_ids.append(vote_option_id)
if len(vote_option.get('pic_url', '')) > 0:
VoteOption.objects.filter(id=vote_option_id).update(
name=vote_option['name'].strip(),
pic_url=vote_option['pic_url'],
)
else:
VoteOption.objects.filter(id=vote_option_id).update(
name=vote_option['name'].strip(), )
VoteOption.objects.filter(vote_id=vote_id).exclude(
id__in=update_vote_options_ids).delete()
for new_vote_option in new_added_vote_options:
vote_option = VoteOption.objects.create(
vote_id=vote_id,
name=new_vote_option['name'].strip(),
pic_url=new_vote_option.get('pic_url', ''),
)
response = create_response(200)
except:
response = create_response(500)
response.innerErrMsg = unicode_full_stack()
return response.get_response()
def testMenuDeleteWithError(self):
menu_view.weixin_menu_request.set_to_failed(True)
request = self.factory.post('/tools/api/customerized_menu/delete')
request.user = self.test_user
response = delete_customerized_menu(request)
#验证api返回response的code为500
response_json = decode_json_str(response.content)
self.assertEqual(500, response_json['code'])
def __get_current_temp(city_code):
data_str, error_info = __get_http_response_data(
"www.weather.com.cn", "/data/sk/%s.html" % city_code)
temp = ''
if data_str:
info_json = decode_json_str(data_str)
# 当前温度
temp = info_json['weatherinfo']['temp']
else:
# print u'获取当前天气温度,天气的api不可用！'
watchdog_fatal(u'获取当前天气温度,发送请求失败！%s' % error_info, WATCHDOG_TYPE)
return temp
def post(self, url, post_param, is_for):
if is_for == 'form':
# 在 urllib2 上注册 http 流处理句柄
register_openers()
# 开始对文件 "DSC0001.jpg" 的 multiart/form-data 编码
# "xx" 是参数的名字，一般通过 HTML 中的 <input> 标签的 name 参数设置
# headers 包含必须的 Content-Type 和 Content-Length
# datagen 是一个生成器对象，返回编码过后的参数
#{"media": open("d://1.jpg", "rb")}
datagen, headers = multipart_encode(post_param)
# 创建请求对象
request = urllib2.Request(url, datagen, headers)
# 实际执行请求并取得返回
weixin_response = urllib2.urlopen(request)#.read()
elif is_for == 'xml':
cookies = urllib2.HTTPCookieProcessor()
opener = urllib2.build_opener(cookies)
request = urllib2.Request(
url = url,
headers = {'Content-Type' : 'text/xml'},
data = post_param.encode('utf8'))
weixin_response = opener.open(request)
else:
req = urllib2.Request(url)
opener = urllib2.build_opener()
post_param_json = decode_json_str(post_param)
weixin_response = opener.open(req, json.dumps(post_param_json, ensure_ascii=False).encode('utf-8'))
try:
if is_for == 'xml':
response_data = weixin_response.read()
tree = ElementTree.fromstring(response_data)
data = {}
#深度搜索、树的先序遍历
for node in tree.iter():
#深度搜索、树的先序遍历该结点下的子树
for n in node.iter():
if n.tag == 'xml':
continue
data[n.tag]=n.text
break
return self._parse_response(json.dumps(data))
else:
return self._parse_response(weixin_response.read().decode('utf-8'))
finally:
if weixin_response:
try:
weixin_response.close()
except:
pass
def __get_weather_info(city_code, weather_id=0):
data_str, error_info = __get_http_response_data(
"m.weather.com.cn", "/data/%s.html" % city_code)
weather_info = []
weather = None
if data_str:
info_json = decode_json_str(data_str)
weather_json = info_json['weatherinfo']
# 计算周几
weeks = [u'一', u'二', u'三', u'四', u'五', u'六', u'日']
week_index = __get_week_index(weeks, weather_json['week'])
# 获取今天日期
today_date = datetime.now()
total_days, low_date, cur_date, high_date = dateutil.get_date_range(
dateutil.get_today(), '6', 6)
date_list = dateutil.get_date_range_list(datetime.date(today_date),
high_date)
for i in range(1, 7):
data = dict()
data['date'] = date_list[i - 1].strftime("%Y年%m月%d日")
data['weather'] = weather_json['weather%d' % i]
data['temp'] = weather_json['temp%d' % i]
data['week'] = u'周%s' % weeks[week_index]
# 给week赋值下标
week_index = week_index + 1 if week_index + 1 < len(weeks) else 0
weather_info.append(data)
# 判断是否已经添加过数据，如果添加过就修改
if weather_id:
weather = Weather.objects.get(id=weather_id)
weather.info = json.dumps(weather_info)
weather.update_time = today_date
weather.save()
else:
weather = Weather.objects.create(info=json.dumps(weather_info),
city_code=city_code)
else:
if weather_id:
weather = Weather.objects.get(id=weather_id)
weather_info = json.loads(weather.info)
# print u'更新数据,天气的api不可用！'
watchdog_fatal(u'更新数据,天气的api不可用！%s' % error_info, WATCHDOG_TYPE)
else:
# print u'首次获取数据,天气的api不可用！'
watchdog_fatal(u'首次获取数据,天气的api不可用！%s' % error_info, WATCHDOG_TYPE)
return weather_info, weather
def testMenuDeleteWithoudError(self):
request = self.factory.post('/tools/api/customerized_menu/delete')
request.user = self.test_user
response = delete_customerized_menu(request)
#验证向微信平台请求的请求信息正确
self.assertEqual(
"{}/delete?access_token={}".format(
menu_settings.WEIXIN_MP_CUSTOMERIZED_MENU_REQUEST_URL_PREFIX,
self.fake_access_token),
menu_view.weixin_menu_request.request_url)
#验证api返回response的code为200
response_json = decode_json_str(response.content)
self.assertEqual(200, response_json['code'])
def show_vote_statistics(request, vote_id):
vote = Vote.objects.get(id=vote_id, owner=request.user)
vote_options = VoteOption.objects.filter(vote=vote).order_by('-vote_count')
prize_info = decode_json_str(vote.award_prize_info)
if prize_info['name'] == '_score-prize_':
vote.cur_prize = '[%s]%d' % (prize_info['type'], prize_info['id'])
elif prize_info['name'] == 'non-prize':
vote.cur_prize = prize_info['type']
else:
vote.cur_prize = '[%s]%s' % (prize_info['type'], prize_info['name'])
c = RequestContext(request, {
'first_nav_name': MARKET_TOOLS_NAV,
'second_navs': export.get_second_navs(request),
'second_nav_name': SECOND_NAV_NAME,
'vote': vote,
'vote_options': vote_options
})
return render_to_response('vote/editor/vote_statistics.html', c)
def create_vote(request):
created_vote = None
try:
vote_options_json_str = request.POST["vote_options"]
vote_options = decode_json_str(vote_options_json_str)
is_non_member = int(request.POST.get("is_non_member", 0))
created_vote = Vote.objects.create(
owner=request.user,
name=request.POST["name"].strip(),
detail=request.POST["detail"].strip(),
award_prize_info=request.POST['prize_info'].strip(),
is_non_member=is_non_member,
show_style=int(request.POST.get('show_style', '1')),
)
for vote_option in vote_options:
vote_option = VoteOption.objects.create(
vote_id=created_vote.id,
name=vote_option['name'].strip(),
pic_url=vote_option.get('pic_url', ''),
)
response = create_response(200)
response.data.vote_id = created_vote.id
except:
alert_msg = u"创建投票信息失败, cause:\n {}".format(unicode_full_stack())
watchdog_error(alert_msg, user_id=request.user.id)
#创建投票选项失败，需要把创建成功的投票选项和投票全部删除
if created_vote is not None:
try:
created_vote.delete()
except:
alert_msg = u"删除投票信息失败, cause:\n {}".format(
unicode_full_stack())
watchdog_warning(alert_msg, user_id=request.user.id)
response = create_response(500)
response.innerErrMsg = unicode_full_stack()
return response.get_response()
def testMenuCreateWithError(self):
menu_view.weixin_menu_request.set_to_failed(True)
request = self.factory.post('/tools/api/customerized_menu/create',
{"menu_json": self.fake_menu_json_str})
request.user = self.test_user
response = update_customerized_menu(request)
#验证向微信平台请求的请求信息正确，由于更新操作会先进行删除操作，因此
#最后一次请求是针对删除操作的
self.assertEqual(
"{}/delete?access_token={}".format(
menu_settings.WEIXIN_MP_CUSTOMERIZED_MENU_REQUEST_URL_PREFIX,
self.fake_access_token),
menu_view.weixin_menu_request.request_url)
#验证api返回response的code为500
response_json = decode_json_str(response.content)
self.assertEqual(500, response_json['code'])
def testMenuUpdateWithoudError(self):
request = self.factory.post('/tools/api/customerized_menu/update',
{"menu_json": self.fake_menu_json_str})
request.user = self.test_user
response = update_customerized_menu(request)
#验证向微信平台请求的请求信息正确, 由于更新操作会先删除然后重新创建，因此
#最后一次请求是针对创建操作的
self.assertEqual(
"{}/create?access_token={}".format(
menu_settings.WEIXIN_MP_CUSTOMERIZED_MENU_REQUEST_URL_PREFIX,
self.fake_access_token),
menu_view.weixin_menu_request.request_url)
self.assertEqual(self.fake_menu_json_str,
menu_view.weixin_menu_request.menu_json)
#验证api返回response的code为200
response_json = decode_json_str(response.content)
self.assertEqual(200, response_json['code'])
def _is_wexin_request_successful(response_content):
response_json = decode_json_str(response_content)
return response_json['errcode'] == 0
def _call_api(*agrs):
# 获得该api的请求方式： get or post
try:
request_method = api_instance_class.request_method()
except:
raise ValueError(u'request method illegality')
request_url, api_desc = api_instance_class.get_get_request_url_and_api_info(weixin_api.mpuser_access_token, agrs)
api_response = None
try:
# get
if request_method == api_settings.API_GET:
api_response = weixin_api.weixin_http_client.get(request_url)
# post
if request_method == api_settings.API_POST:
post_param_json_str = api_instance_class.parese_post_param_json_str(agrs)
if hasattr(api_instance_class, 'is_for_form') and api_instance_class.is_for_form:
is_for_form = True
else:
try:
post_param_json_str = decode_json_str(post_param_json_str)
except:
pass
is_for_form = False
api_response = weixin_api.weixin_http_client.post(request_url, post_param_json_str, is_for_form)
except:
weixin_api._raise_system_error(api_desc, weixin_api.mpuser_access_token.mpuser.owner_id)
result = api_response
print 'api call result>>>>>>>>>>>>>>>>>:',result
"""
TODO:
记录微信api调用记录
"""
# try:
# #watchdog.info('call weixin api: {} , result:{}'.format(api_instance_class.__class__.__name__, result))
# from weixin.message.message_handler.tasks import record_call_weixin_api
# if hasattr(result, 'errcode'):
# success = False
# #watchdog.error('call weixin api: {} , result:{}'.format(api_instance_class.__class__.__name__, result))
# else:
# success = True
# record_call_weixin_api.delay(api_instance_class.__class__.__name__, success)
# except:
# pass
if hasattr(result, 'errcode'):
try:
result_code = int(result['errcode'])
except:
result_code = result['errcode']
if result_code == errorcodes.API_NOT_AUTHORIZED_CODE:
mpuser_access_token = weixin_api.mpuser_access_token
#mpuser_access_token.is_active = False
mpuser_access_token.is_certified = False
mpuser_access_token.save()
# try:
# if result_code == errorcodes.INVALID_ACCESS_TOKEN_CODE or result_code == errorcodes.ILLEGAL_ACCESS_TOKEN_CODE or result_code == errorcodes.ACCESS_TOKEN_EXPIRED_CODE:
# update_access_token(weixin_api.mpuser_access_token)
# except:
# notify_message = u"weixin_api update_access_token error {}".format(unicode_full_stack())
# watchdog.error(notify_message)
if weixin_api._is_error_response(api_response):
# if weixin_api._is_error_dueto_access_token(api_response):
# if api_instance_class.is_retry(agrs):
# weixin_api._raise_request_error(api_response, api_desc, weixin_api.mpuser_access_token.mpuser.owner_id)
# else:
# #如果由于access_token的问题，那么先更新access_token后重试
# if (update_access_token(weixin_api.mpuser_access_token)):
# return _call_api(*agrs)
# else:
# weixin_api._raise_request_error(api_response, api_desc, weixin_api.mpuser_access_token.mpuser.owner_id)
# else:
weixin_api._raise_request_error(api_response, api_desc, weixin_api.mpuser_access_token.mpuser.owner_id)
return api_instance_class.parse_response(api_response)
def __parse_response(self, response_text): response_text = response_text.strip() return decode_json_str(response_text)
def get_test_game(request):
webapp_user = request.webapp_user
member = request.member
game_id = request.GET['game_id']
request.should_hide_footer = True
is_participated = False #是否已经参加
#重新玩一次
is_again = int(request.GET.get('is_again', 0))
try:
game = TestGame.objects.get(id=game_id)
except:
c = RequestContext(request, {'is_deleted_data': True})
return render_to_response('test_game/webapp/game.html', c)
hide_non_member_cover = False
if game.is_non_member:
hide_non_member_cover = True
#判断是否参与过
records = TestGameRecord.objects.filter(
webapp_user_id=webapp_user.id,
test_game=game_id).order_by('-created_at')
if records:
record = records[0]
is_participated = True
#参与后直接返回结果页面
if is_participated and (not is_again):
score = record.score
prize_info = decode_json_str(game.award_prize_info)
if prize_info['name'] == '_score-prize_':
cur_prize = '[%s]%d' % (prize_info['type'], prize_info['id'])
elif prize_info['name'] == 'non-prize':
# cur_prize = prize_info['type']
cur_prize = None
else:
cur_prize = '[%s]%s' % (prize_info['type'], prize_info['name'])
results = TestGameResult.objects.filter(test_game=game_id)
cur_result_id = 0
min_difference = None
for result in results:
start, end = result.section.split('-')
start_difference = abs(int(start) - score)
end_difference = abs(int(end) - score)
if min_difference == None:
min_difference = start_difference
cur_result_id = result.id
if start_difference < min_difference:
min_difference = start_difference
cur_result_id = result.id
if end_difference < min_difference:
min_difference = end_difference
cur_result_id = result.id
other_results = []
for result in results:
if result.id == cur_result_id:
cur_result = result
else:
other_results.append(result)
is_show_prize = True
if len(records) > 1:
is_show_prize = False
c = RequestContext(
request, {
'page_title': game.name,
'game': game,
'record': record,
'cur_result': cur_result,
'other_results': other_results,
'hide_non_member_cover': hide_non_member_cover,
'member': member,
'cur_prize': cur_prize,
'is_show_prize': is_show_prize
})
return render_to_response('test_game/webapp/result.html', c)
questions = TestGameQuestion.objects.filter(test_game=game_id)
for q in questions:
q.answers = []
id2question = dict([(q.id, q) for q in questions])
question_ids = [q.id for q in questions]
answers = TestGameQuestionAnswer.objects.filter(
test_game_question__in=question_ids)
for answer in answers:
question = id2question[answer.test_game_question_id]
question.answers.append(answer)
c = RequestContext(
request, {
'page_title': game.name,
'game': game,
'questions': questions,
'hide_non_member_cover': hide_non_member_cover,
'member': member
})
return render_to_response('test_game/webapp/game.html', c)
def get_channel_qrcode_settings(request):
"""
获取渠道扫码配置列表
"""
#处理搜索
query = request.GET.get('query', '').strip()
if query:
settings = ChannelQrcodeSettings.objects.filter(owner=request.user,
name__contains=query)
else:
settings = ChannelQrcodeSettings.objects.filter(owner=request.user)
setting_ids = [s.id for s in settings]
relations = ChannelQrcodeHasMember.objects.filter(
channel_qrcode_id__in=setting_ids)
setting_id2count = {}
member_id2setting_id = {}
member_ids = []
for r in relations:
member_ids.append(r.member_id)
member_id2setting_id[r.member_id] = r.channel_qrcode_id
if r.channel_qrcode_id in setting_id2count:
setting_id2count[r.channel_qrcode_id] += 1
else:
setting_id2count[r.channel_qrcode_id] = 1
webapp_users = member_model.WebAppUser.objects.filter(
member_id__in=member_ids)
webapp_user_id2member_id = dict([(u.id, u.member_id)
for u in webapp_users])
webapp_user_ids = set(webapp_user_id2member_id.keys())
orders = mall_model.Order.by_webapp_user_id(webapp_user_ids).filter(
status=mall_model.ORDER_STATUS_SUCCESSED)
member_id2total_final_price = {}
for order in orders:
member_id = webapp_user_id2member_id[order.webapp_user_id]
if member_id in member_id2total_final_price:
member_id2total_final_price[member_id] += order.final_price
else:
member_id2total_final_price[member_id] = order.final_price
setting_id2total_final_price = {}
for member_id in member_id2total_final_price.keys():
final_price = member_id2total_final_price[member_id]
setting_id = member_id2setting_id[member_id]
if setting_id in setting_id2total_final_price:
setting_id2total_final_price[setting_id] += final_price
else:
setting_id2total_final_price[setting_id] = final_price
response = create_response(200)
response.data.items = []
items = []
mp_user = get_binding_weixin_mpuser(request.user)
mpuser_access_token = get_mpuser_accesstoken(mp_user)
for setting in settings:
cur_setting = JsonResponse()
prize_info = decode_json_str(setting.award_prize_info)
if prize_info['name'] == '_score-prize_':
setting.cur_prize = '[%s]%d' % (prize_info['type'],
prize_info['id'])
elif prize_info['name'] == 'non-prize':
setting.cur_prize = prize_info['type']
else:
setting.cur_prize = '[%s]%s' % (prize_info['type'],
prize_info['name'])
if setting.id in setting_id2count:
setting.count = setting_id2count[setting.id]
else:
setting.count = 0
if setting.id in setting_id2total_final_price:
setting.total_final_price = setting_id2total_final_price[
setting.id]
else:
setting.total_final_price = 0
#如果没有ticket信息则获取ticket信息
if not setting.ticket:
try:
if mp_user.is_certified and mp_user.is_service and mpuser_access_token.is_active:
weixin_api = get_weixin_api(mpuser_access_token)
qrcode_ticket = weixin_api.create_qrcode_ticket(
int(setting.id), QrcodeTicket.PERMANENT)
try:
ticket = qrcode_ticket.ticket
except:
ticket = ''
setting.ticket = ticket
setting.save()
except:
pass
cur_setting.id = setting.id
cur_setting.name = setting.name
cur_setting.count = setting.count
cur_setting.total_final_price = round(setting.total_final_price, 2)
cur_setting.cur_prize = setting.cur_prize
cur_setting.ticket = setting.ticket
cur_setting.remark = setting.remark
items.append(cur_setting)
#进行分页
response.data.sortAttr = request.GET.get('sort_attr', 'count')
if '-' in response.data.sortAttr:
sorter = response.data.sortAttr[1:]
is_reverse = True
else:
sorter = response.data.sortAttr
is_reverse = False
items = sorted(items, reverse=is_reverse, key=lambda b: getattr(b, sorter))
count_per_page = int(request.GET.get('count_per_page', 15))
cur_page = int(request.GET.get('page', '1'))
pageinfo, items = paginator.paginate(
items,
cur_page,
count_per_page,
query_string=request.META['QUERY_STRING'])
#
response.data.items = items
response.data.pageinfo = paginator.to_dict(pageinfo)
return response.get_response()
def list_channel_qrcode_settings(request):
mpuser = get_system_user_binded_mpuser(request.user)
if (mpuser is None) or (not mpuser.is_certified) or (not mpuser.is_service):
should_show_authorize_cover = True
else:
should_show_authorize_cover = False
settings = ChannelQrcodeSettings.objects.filter(owner=request.user)
setting_ids = [s.id for s in settings]
relations = ChannelQrcodeHasMember.objects.filter(channel_qrcode_id__in=setting_ids)
setting_id2count = {}
member_id2setting_id = {}
member_ids = []
for r in relations:
member_ids.append(r.member_id)
member_id2setting_id[r.member_id] = r.channel_qrcode_id
if r.channel_qrcode_id in setting_id2count:
setting_id2count[r.channel_qrcode_id] += 1
else:
setting_id2count[r.channel_qrcode_id] = 1
webapp_users = member_model.WebAppUser.objects.filter(member_id__in=member_ids)
webapp_user_id2member_id = dict([(u.id, u.member_id) for u in webapp_users])
webapp_user_ids = set(webapp_user_id2member_id.keys())
orders = mall_model.Order.by_webapp_user_id(webapp_user_ids).filter(status=mall_model.ORDER_STATUS_SUCCESSED)
member_id2total_final_price = {}
for order in orders:
member_id = webapp_user_id2member_id[order.webapp_user_id]
if member_id in member_id2total_final_price:
member_id2total_final_price[member_id] += order.final_price
else:
member_id2total_final_price[member_id] = order.final_price
setting_id2total_final_price = {}
for member_id in member_id2total_final_price.keys():
final_price = member_id2total_final_price[member_id]
setting_id = member_id2setting_id[member_id]
if setting_id in setting_id2total_final_price:
setting_id2total_final_price[setting_id] += final_price
else:
setting_id2total_final_price[setting_id] = final_price
mp_user = get_binding_weixin_mpuser(request.user)
mpuser_access_token = get_mpuser_accesstoken(mp_user)
for setting in settings:
prize_info = decode_json_str(setting.award_prize_info)
if prize_info['name'] == '_score-prize_':
setting.cur_prize = '[%s]%d' % (prize_info['type'], prize_info['id'])
elif prize_info['name'] == 'non-prize':
setting.cur_prize = prize_info['type']
else:
setting.cur_prize = '[%s]%s' % (prize_info['type'], prize_info['name'])
if setting.id in setting_id2count:
setting.count = setting_id2count[setting.id]
else:
setting.count = 0
if setting.id in setting_id2total_final_price:
setting.total_final_price = setting_id2total_final_price[setting.id]
else:
setting.total_final_price = 0
#如果没有ticket信息则获取ticket信息
if not setting.ticket:
try:
if mp_user.is_certified and mp_user.is_service and mpuser_access_token.is_active:
weixin_api = get_weixin_api(mpuser_access_token)
qrcode_ticket = weixin_api.create_qrcode_ticket(int(setting.id), QrcodeTicket.PERMANENT)
try:
ticket = qrcode_ticket.ticket
except:
ticket = ''
setting.ticket = ticket
setting.save()
except:
pass
c = RequestContext(request, {
'first_nav_name': MARKET_TOOLS_NAV,
'second_navs': export.get_second_navs(request),
'second_nav_name': SECOND_NAV_NAME,
'settings': settings,
'should_show_authorize_cover': should_show_authorize_cover,
'is_hide_weixin_option_menu': True
})
return render_to_response('channel_qrcode/editor/channel_qrcode_settings.html', c)
def _call_api(*agrs):
# 获得该api的请求方式： get or post
try:
request_method = api_instance_class.request_method()
except:
raise ValueError(u'request method illegality')
request_url, api_desc = api_instance_class.get_get_request_url_and_api_info(weixin_api.component_token, agrs)
api_response = None
try:
# get
if request_method == api_settings.API_GET:
api_response = weixin_api.weixin_http_client.get(request_url)
# post
if request_method == api_settings.API_POST:
post_param_json_str = api_instance_class.parese_post_param_json_str(agrs)
if hasattr(api_instance_class, 'is_for_form') and api_instance_class.is_for_form:
is_for_form = True
else:
try:
post_param_json_str = decode_json_str(post_param_json_str)
except:
pass
is_for_form = False
api_response = weixin_api.weixin_http_client.post(request_url, post_param_json_str, is_for_form)
except:
weixin_api._raise_system_error(api_desc, weixin_api.component_token)
result = api_response
if hasattr(result, 'errcode'):
try:
result_code = int(result['errcode'])
except:
result_code = result['errcode']
# if result_code == errorcodes.API_NOT_AUTHORIZED_CODE:
# mpuser_access_token = weixin_api.mpuser_access_token
# #mpuser_access_token.is_active = False
# mpuser_access_token.is_certified = False
# mpuser_access_token.save()
# try:
# if result_code == errorcodes.INVALID_ACCESS_TOKEN_CODE or result_code == errorcodes.ILLEGAL_ACCESS_TOKEN_CODE or result_code == errorcodes.ACCESS_TOKEN_EXPIRED_CODE:
# update_access_token(weixin_api.mpuser_access_token)
# except:
# notify_message = u"weixin_api update_access_token error {}".format(unicode_full_stack())
# watchdog_error(notify_message)
# if weixin_api._is_error_response(api_response):
# if weixin_api._is_error_dueto_access_token(api_response):
# if api_instance_class.is_retry(agrs):
# weixin_api._raise_request_error(api_response, api_desc, -1)
# else:
# #如果由于access_token的问题，那么先更新access_token后重试
# if (update_access_token(weixin_api.mpuser_access_token)):
# return _call_api(agrs)
# else:
# weixin_api._raise_request_error(api_response, api_desc, weixin_api.mpuser_access_token.mpuser.owner.id)
# else:
# weixin_api._raise_request_error(api_response, api_desc, weixin_api.mpuser_access_token.mpuser.owner.id)
return api_instance_class.parse_response(api_response)
def get_json(self, response):
#去掉头部信息，截取返回的json字符串
data_str = str(response).split('\n\n')[1].strip()
#解析json字符串，返回json对象
return decode_json_str(data_str)
