def _fill_answer_dict(answer_dict):
import re
if answer_dict['type'] == 'news':
answer_dict['newses'] = []
#获取图文标题
newses = News.get_news_by_material_id(int(answer_dict['content']))
news_array = []
for news in newses:
news_dict = {}
news_dict['id'] = news.id
news_dict['title'] = news.title
answer_dict['newses'].append(news_dict)
else:
#把除a表情外的html字符<,>转化成html对应的编码 by Eugene
# a_pattern = re.compile(r'<a.+?href=.+?>.+?</a>')
# all_a_html = a_pattern.findall(answer_dict['content'])
# for html in all_a_html:
# answer_dict['content'] = answer_dict['content'].replace(html, "%s")
# answer_dict['content'] = answer_dict['content'].replace('<', "<")
# answer_dict['content'] = answer_dict['content'].replace('>', ">")
# answer_dict['content'] = answer_dict['content'] % tuple(all_a_html)
from message.util import translate_special_characters
answer_dict['content'] = translate_special_characters(
answer_dict['content'])
#处理表情
answer_dict['content'] = emotion.change_emotion_to_img(
answer_dict['content'])
def _build_response_without_auto_response_rule(self, user_profile, message,
is_from_simulator):
#response_rule = qa_util.find_unmatch_answer_for(user_profile.webapp_id)
#从缓存中获取数据 duhao 2015-03-09
response_rule = cache_util.find_unmatch_answer_from_cache_for(
user_profile)
if response_rule and response_rule.is_active:
#sdwex = self._get_token_for_weixin_user(user_profile, message.fromUserName, is_from_simulator)
if response_rule.material_id > 0:
response = generator.get_news_response(message.fromUserName,
message.toUserName,
response_rule.newses,
message.fromUserName)
else:
if is_from_simulator:
response = generator.get_text_response(
message.fromUserName, message.toUserName,
emotion.change_emotion_to_img(response_rule.answer),
message.fromUserName, user_profile)
else:
response = generator.get_text_response(
message.fromUserName, message.toUserName,
response_rule.answer, message.fromUserName,
user_profile)
return response_rule, response
else:
return None, None
def get(request):
"""
响应GET
"""
rebate = None
if 'id' in request.GET:
try:
rebate = app_models.Rebate.objects.get(id=request.GET['id'])
except:
c = RequestContext(request, {
'first_nav_name': FIRST_NAV,
'second_navs': mall_export.get_promotion_and_apps_second_navs(request),
'second_nav_name': mall_export.MALL_APPS_SECOND_NAV,
'third_nav_name': mall_export.MALL_APPS_REBATE_NAV,
'is_deleted_data': True,
})
return render_to_response('rebate/templates/editor/create_rebate_rule.html', c)
answer_content = {}
if rebate.reply_type == 2:
answer_content['type'] = 'news'
answer_content['newses'] = []
answer_content['content'] = rebate.reply_material_id
newses = News.get_news_by_material_id(rebate.reply_material_id)
for news in newses:
news_dict = {}
news_dict['id'] = news.id
news_dict['title'] = news.title
answer_content['newses'].append(news_dict)
else:
answer_content['type'] = 'text'
answer_content['content'] = emotion.change_emotion_to_img(rebate.reply_detail)
jsons = [{
"name": "qrcode_answer",
"content": answer_content
}]
card_stock = AppsWeizoomCard.objects(belong_to=request.GET['id'],status=0).count()
c = RequestContext(request, {
'first_nav_name': FIRST_NAV,
'second_navs': mall_export.get_promotion_and_apps_second_navs(request),
'second_nav_name': mall_export.MALL_APPS_SECOND_NAV,
'third_nav_name': mall_export.MALL_APPS_REBATE_NAV,
'rebate_rule': rebate,
'card_stock': card_stock,
'jsons': jsons
})
return render_to_response('rebate/templates/editor/create_rebate_rule.html', c)
else:
c = RequestContext(request, {
'first_nav_name': FIRST_NAV,
'second_navs': mall_export.get_promotion_and_apps_second_navs(request),
'second_nav_name': mall_export.MALL_APPS_SECOND_NAV,
'third_nav_name': mall_export.MALL_APPS_REBATE_NAV,
'rebate_rule': rebate
})
return render_to_response('rebate/templates/editor/create_rebate_rule.html', c)
def __package_rule(rule, should_change_emotion=False):
response = create_response(200)
response.data = dict()
response.data['id'] = rule.id
response.data['patterns'] = rule.patterns
if should_change_emotion:
response.data['answer'] = emotion.change_emotion_to_img(rule.answer)
else:
response.data['answer'] = rule.answer
return response.get_response()
def record_session_info(session_info, response_rule):
if session_info and response_rule:
if response_rule['is_news_type']:
content = u'[图文消息]'
else:
content = response_rule['answer'][0]['content']
latest_message = Message.objects.create(
mpuser=session_info['mpuser'],
session=session_info['session'],
from_weixin_user_username=session_info['receiver_username'],
to_weixin_user_username=session_info['sender_username'],
content=emotion.change_emotion_to_img(u'[自动回复]: %s' % content),
is_reply=True)
def update_rule(request, rule_id):
rule = None
try:
rule = Rule.objects.get(owner=request.user, id=rule_id)
except:
raise Http404('Rule Not Found')
if rule.type == NEWS_TYPE:
newses = list(News.objects.filter(material_id=rule.material_id))
newses_object = []
news_count = len(newses)
for news in newses:
one_news = {}
one_news['id'] = news.id
one_news['title'] = string_json(news.title)
one_news['display_index'] = news.display_index
one_news['type'] = 'news'
if news_count > 0:
one_news['text'] = string_json(news.text.encode("utf-8"))
one_news['date'] = news.created_at.strftime('%m月%d日').strip('0')
one_news['url'] = news.url
one_news['pic_url'] = news.pic_url
one_news['summary'] = string_json(news.summary)
if news.display_index == 1:
one_news['metadata'] = {'autoSelect':'true'};
else:
one_news['metadata'] = {};
newses_object.append(one_news)
c = RequestContext(request, {
'first_nav_name' : FIRSTT_NAV_NAME,
'second_navs' : WEIXIN_SECOND_NAVS,
'second_nav_name' : weixin.WEIXIN_QA_KEYWORD_QA_NAV_NAME,
'rule': rule,
'newses': json.dumps(newses_object)
})
return render_to_response('qa/edit_rule.html', c)
elif rule.type == TEXT_TYPE:
if rule:
rule.answer = emotion.change_emotion_to_img(rule.answer)
c = RequestContext(request, {
'first_nav_name' : FIRSTT_NAV_NAME,
'second_navs' : WEIXIN_SECOND_NAVS,
'second_nav_name' : weixin.WEIXIN_QA_KEYWORD_QA_NAV_NAME,
'rule': rule
})
return render_to_response('qa/edit_rule.html', c)
def package_rule(rule, should_change_emotion=False):
"""
封装rule为json response
"""
response = create_response(200)
response.data = dict()
response.data['id'] = rule.id
response.data['material_id'] = rule.material_id
response.data['type'] = rule.type
response.data['patterns'] = rule.patterns
if should_change_emotion:
response.data['answer'] = emotion.change_emotion_to_img(rule.answer)
else:
response.data['answer'] = rule.answer
return response.get_response()
def _build_response_to_weixin_user(self, user_profile, message,
response_rule, is_from_simulator):
from_weixin_user = self._get_from_weixin_user(message)
token = self._get_token_for_weixin_user(user_profile, from_weixin_user,
is_from_simulator)
if is_from_simulator:
response = generator.get_text_response(
from_weixin_user.username, message.toUserName,
emotion.change_emotion_to_img(response_rule.answer), token,
user_profile)
else:
response = generator.get_text_response(from_weixin_user.username,
message.toUserName,
response_rule.answer, token,
user_profile)
return response
def edit_unmatch_rule(request):
rule = None
newses_object = []
try:
rule = Rule.objects.get(owner=request.user, type=UNMATCH_TYPE)
except:
rule = None
if rule:
rule.answer = emotion.change_emotion_to_img(rule.answer)
newses = list(News.objects.filter(material_id=rule.material_id))
newses_object = __get_newses(newses)
c = RequestContext(request, {
'first_nav_name' : FIRSTT_NAV_NAME,
'second_navs' : WEIXIN_SECOND_NAVS,
'second_nav_name' : weixin.WEIXIN_QA_AUTO_QA_NAV_NAME,
'rule': rule,
'newses': json.dumps(newses_object)
})
return render_to_response('qa/edit_unmatch_rule.html', c)
def get_session_histories(request):
session_id = request.GET['session_id']
messages = Message.objects.filter(session=session_id).order_by('-id')
sender_usernames = [m.from_weixin_user_username for m in messages]
recevier_usernames = [m.to_weixin_user_username for m in messages]
weixin_user_usernames = set(sender_usernames + recevier_usernames)
weixin_users = WeixinUser.objects.filter(
username__in=weixin_user_usernames)
username2weixin_user = dict([u.username, u] for u in weixin_users)
mpuser = get_system_user_binded_mpuser(request.user)
try:
mpuser_preview_info = MpuserPreviewInfo.objects.get(mpuser=mpuser)
except:
response = create_response(500)
response.errMsg = u'获取公众号预览信息失败'
return response.get_response()
response = create_response(200)
response.data.items = []
session = Session.objects.get(id=session_id)
webapp_id = request.user_profile.webapp_id
is_active = True if datetime.now(
) < session.latest_contact_created_at + timedelta(
hours=EXPIRED_TIME) and datetime.now(
) > session.latest_contact_created_at else False
response.data.is_active = is_active
for message in messages:
sender = username2weixin_user[message.from_weixin_user_username]
one_message = JsonResponse()
one_message.id = message.id
one_message.weixin_message_id = message.weixin_message_id
one_message.is_reply = message.is_reply
one_message.content = emotion.change_emotion_to_img(message.content)
if one_message.content == None:
one_message.content = ''
one_message.weixin_created_at = __format_datetime(
message.weixin_created_at)
one_message.is_collected = CollectMessage.is_collected(message.id)
one_message.message_type = message.message_type
one_message.pic_url = message.pic_url
one_message.audio_url = message.audio_url
if message.message_type == IMAGE:
one_message.content = message.pic_url
if message.message_type == VOICE:
one_message.content = message.audio_url
if message.is_reply:
one_message.sender_icon = mpuser_preview_info.image_path #sender.weixin_user_icon
one_message.sender_name = mpuser_preview_info.name
else:
account = SocialAccount.objects.get(webapp_id=webapp_id,
openid=sender.username)
member = MemberHasSocialAccount.objects.filter(
account=account)[0].member
if member:
if member.user_icon:
one_message.sender_icon = member.user_icon if len(
member.user_icon.strip()) > 0 else DEFAULT_ICON
else:
one_message.sender_icon = DEFAULT_ICON
one_message.sender_name = member.username_for_html
one_message.member_id = member.id
if one_message.sender_icon != sender.weixin_user_icon:
sender.weixin_user_icon = member.user_icon
else:
if sender.weixin_user_icon:
one_message.sender_icon = sender.weixin_user_icon if len(
sender.weixin_user_icon.strip()) > 0 else DEFAULT_ICON
one_message.sender_name = sender.weixin_user_nick_name
response.data.items.append(one_message)
return response.get_response()
def handle(self, context, is_from_simulator=False):
message = context.message
if message.is_optimization_message:
print 'ChannelQrcodeHandler only handle is_optimization_message = true'
return None
username = message.fromUserName
user_profile = context.user_profile
member = context.member
if not hasattr(context.message, 'event'):
return None
if not hasattr(context.message,
'ticket') or context.message.ticket is None:
return None
ticket = context.message.ticket
if not hasattr(context.message, 'eventKey'
) or context.message.eventKey is None or ticket == '':
return None
if member and (hasattr(member, 'is_new') is False):
member.is_new = False
#优化处理
if hasattr(context,
'is_member_qrcode') and (context.is_member_qrcode is True):
return None
#检查是否返利活动中有这个
if rebate_models.Rebate.objects(ticket=ticket,
status=rebate_models.STATUS_RUNNING):
print 'apps.Rebate has the same ticket: %s, so let rebate handler handle it' % ticket
return None
if user_profile.user_id in [467,154] and \
check_new_channel_qrcode_ticket(ticket, user_profile):
#用户可以重复领取不同的优惠券
can_has_coupon = False
qrcode_award = MemberChannelQrcodeAwardContent.objects.get(
owner_id=user_profile.user_id)
award_type = qrcode_award.scanner_award_type
award_content = qrcode_award.scanner_award_content
if award_type == AWARD_COUPON:
if ChannelQrcodeSettings.objects.filter(
ticket=ticket,
owner_id=user_profile.user_id).count() > 0:
channel_qrcode = ChannelQrcodeSettings.objects.filter(
ticket=ticket, owner_id=user_profile.user_id)[0]
coupon_ids = ChannelQrcodeToMemberLog.objects.filter(
channel_qrcode=channel_qrcode,
member=member)[0].coupon_ids
if award_content not in coupon_ids.split(','):
can_has_coupon = True
if member.is_new or can_has_coupon:
create_new_channel_qrcode_has_memeber(user_profile,
context.member, ticket,
member.is_new)
return None
channel_qrcode = ChannelQrcodeSettings.objects.filter(
ticket=ticket, owner_id=user_profile.user_id).first()
if channel_qrcode:
if user_profile.user.username in [
'ceshi01', 'kftengyi'
] and channel_qrcode.bing_member_id > 0: #腾易微众定制需求
from modules.member.models import TengyiMember, TengyiMemberRelation
if TengyiMember.objects.filter(
member_id=channel_qrcode.bing_member_id).count() > 0:
if TengyiMemberRelation.objects.filter(
member_id=member.id).count() <= 0:
print '============================'
print 'TengyiMemberRelation recoding by channel_qrcode'
print '============================'
TengyiMemberRelation.objects.create(
member_id=member.id,
recommend_by_member_id=channel_qrcode.
bing_member_id,
)
create_channel_qrcode_has_memeber_restructure(
channel_qrcode, user_profile, context.member, ticket,
member.is_new)
msg_type, detail = get_response_msg_info_restructure(
channel_qrcode, user_profile)
if msg_type != None:
#from_weixin_user = self._get_from_weixin_user(message)
#token = self._get_token_for_weixin_user(user_profile, from_weixin_user, is_from_simulator)
if msg_type == 'text' and detail:
if is_from_simulator:
return generator.get_text_response(
username, message.toUserName,
emotion.change_emotion_to_img(detail), username,
user_profile)
else:
return generator.get_text_response(
username, message.toUserName, detail, username,
user_profile)
if msg_type == 'news' and get_material_news_info(detail):
news = get_material_news_info(detail)
return generator.get_news_response(username,
message.toUserName,
news, username)
# elif check_channel_qrcode_ticket(ticket, user_profile):
# #if member.is_new:
# create_channel_qrcode_has_memeber(user_profile, context.member, ticket, member.is_new)
# msg_type, detail = get_response_msg_info(ticket, user_profile)
# if msg_type != None:
# from_weixin_user = self._get_from_weixin_user(message)
# #token = self._get_token_for_weixin_user(user_profile, from_weixin_user, is_from_simulator)
# if msg_type == 'text' and detail:
# if is_from_simulator:
# return generator.get_text_response(username, message.toUserName, emotion.change_emotion_to_img(detail), username, user_profile)
# else:
# return generator.get_text_response(username, message.toUserName, detail, username, user_profile)
# if msg_type == 'news' and get_material_news_info(detail):
# news = get_material_news_info(detail)
# return generator.get_news_response(username, message.toUserName, news, username)
return None
def format_emotion(content): return emotion.change_emotion_to_img(content)
def get_menus_json(user):
id2menu = dict()
menu_models = list(CustomerMenuItem.objects.filter(owner=user))
#使father_id为0的menu排在最前面，menu item排在其后
menu_models.sort(lambda x, y: cmp(x.father_id, y.father_id))
rule_ids = [menu_model.rule_id for menu_model in menu_models]
id2rule = dict([(rule.id, rule)
for rule in Rule.objects.filter(id__in=rule_ids)])
for menu_model in menu_models:
if not id2rule.has_key(menu_model.rule_id):
#TODO 如果自定义菜单关联的规则被删除之后的处理？？
continue
if len(menu_model.name) == 0:
#如果菜单项的名称长度为0，删除该菜单项
try:
menu_model.delete()
except:
pass
continue
rule = id2rule[menu_model.rule_id]
if rule.is_url:
answer = {'type': 'url', 'content': rule.answer}
elif rule.is_news_type:
answer = {'type': 'news', 'content': rule.material_id}
else:
answer = {
'type': 'text',
'content': emotion.change_emotion_to_img(rule.answer)
}
if menu_model.father_id == 0:
id2menu[menu_model.id] = {
'id': menu_model.id,
'name': menu_model.name,
'index': menu_model.display_index,
'answer': answer,
'items': []
}
else:
menu_item_model = menu_model
rule = id2rule[menu_item_model.rule_id]
menu = id2menu[menu_item_model.father_id]
menu['items'].append({
'id': menu_item_model.id,
'name': menu_item_model.name,
'index': menu_item_model.display_index,
'answer': answer
})
menus = id2menu.values()
menus.sort(lambda x, y: cmp(x['index'], y['index']))
for menu in menus:
if len(menu['items']) == 0:
continue
menu['items'].sort(lambda x, y: cmp(y['index'], x['index']))
return menus
def list_messages(request):
# if type(request.user) is not types.IntType :
# return render_to_response('mobile_app/list_messages.html')
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
return render_to_response('mobile_app/list_messages.html')
sessions = Session.objects.select_related().filter(mpuser=mpuser,
is_show=True)
#清空未读消息数量
RealTimeInfo.objects.filter(mpuser=mpuser).update(unread_count=0)
weixin_user_usernames = [s.weixin_user_id for s in sessions]
weixin_users = WeixinUser.objects.filter(
username__in=weixin_user_usernames)
username2weixin_user = dict([(u.username, u) for u in weixin_users])
sessions_list = []
for session in sessions:
weixin_user = username2weixin_user[session.weixin_user_id]
content = emotion.change_emotion_to_img(session.latest_contact_content)
if len(content) > 10:
content = content[0:10]
content = content + '...'
one_session = {
'id':
session.id,
'sender_fake_id':
weixin_user.fake_id,
'sender_username':
weixin_user.username,
'sender_name':
weixin_user.nickname_for_html,
'weixin_user_icon':
weixin_user.weixin_user_icon
if len(weixin_user.weixin_user_icon.strip()) > 0 else DEFAULT_ICON,
'content':
content,
'created_at':
__format_datetime(session.latest_contact_created_at),
'unread_count':
session.unread_count,
'is_subscribed':
is_subscribed(weixin_user),
'is_active':
True if datetime.now() < session.latest_contact_created_at +
timedelta(hours=EXPIRED_TIME)
and datetime.now() > session.latest_contact_created_at else False
}
try:
member = Member.get_member_by_weixin_user_id(weixin_user.id)
if member:
one_session.member_id = member.id
one_session.member_remarks_name = member.remarks_name
if len(member.user_icon.strip()) > 0:
one_session.weixin_user_icon = member.user_icon
if member.username_for_html:
one_session.sender_name = member.username_for_html
except:
notify_message = u"设置会话信息失败, weixin_user_openid:{}, cause:\n{}".format(
session.weixin_user_id, unicode_full_stack())
watchdog_notice(notify_message)
# continue
sessions_list.append(one_session)
# response.data.page_info = __package_pageinfo(pageinfo)
c = RequestContext(request, {
'is_login': True,
'sessions': sessions_list,
'pressed_link': 'messages'
})
return render_to_response('mobile_app/list_messages.html', c)
def get_session_histories(request, session_id):
messages = Message.objects.filter(session=session_id).order_by('-id')
sender_usernames = [m.from_weixin_user_username for m in messages]
recevier_usernames = [m.to_weixin_user_username for m in messages]
weixin_user_usernames = set(sender_usernames + recevier_usernames)
weixin_users = WeixinUser.objects.filter(
username__in=weixin_user_usernames)
username2weixin_user = dict([u.username, u] for u in weixin_users)
mpuser = get_system_user_binded_mpuser(request.user)
try:
mpuser_preview_info = MpuserPreviewInfo.objects.get(mpuser=mpuser)
except:
response = create_response(500)
response.errMsg = u'获取公众号预览信息失败'
return response.get_response()
#清空未读消息
Session.objects.filter(mpuser=mpuser, id=session_id).update(unread_count=0)
messages_list = []
session = Session.objects.get(id=session_id)
is_active = True if datetime.now(
) < session.latest_contact_created_at + timedelta(
hours=EXPIRED_TIME) and datetime.now(
) > session.latest_contact_created_at else False
for message in messages:
sender = username2weixin_user[message.from_weixin_user_username]
one_message = {
'id': message.id,
'weixin_message_id': message.weixin_message_id,
'is_reply': message.is_reply,
'content': emotion.change_emotion_to_img(message.content),
'weixin_created_at': __format_datetime(message.weixin_created_at)
}
if message.is_reply:
one_message['sender_icon'] = mpuser_preview_info.image_path
one_message['sender_name'] = mpuser_preview_info.name
else:
member = Member.get_member_by_weixin_user_id(sender.id)
if member:
one_message['sender_icon'] = member.user_icon if len(
member.user_icon.strip()) > 0 else DEFAULT_ICON
one_message['sender_name'] = member.username_for_html
if one_message['sender_icon'] != sender.weixin_user_icon:
sender.weixin_user_icon = member.user_icon
else:
one_message['sender_icon'] = sender.weixin_user_icon if len(
sender.weixin_user_icon.strip()) > 0 else DEFAULT_ICON
one_message['sender_name'] = sender.weixin_user_nick_name
messages_list.append(one_message)
wei = Session.objects.get(mpuser=mpuser, id=session_id)
c = RequestContext(
request, {
'is_login': True,
'is_active': is_active,
'sessions': messages_list,
'session_id': session_id,
'weixin_user_id': wei.weixin_user_id,
'pressed_link': 'messages'
})
return render_to_response('mobile_app/list_histories.html', c)
def format_to_dict(self):
try:
self.patterns = json.loads(self.patterns)
if type(self.patterns) == int or type(
self.patterns) == long or type(self.patterns) == float:
self.patterns = str(self.patterns)
1 / 0 #防止关键词是数字时引起bug，使进入except代码块
except:
keywords = self.patterns.split('|')
keyword_array = []
for keyword in keywords:
keyword2type = {}
keyword2type['keyword'] = keyword
keyword2type['type'] = 0
keyword_array.append(keyword2type)
self.patterns = keyword_array
#处理老的图文回复
if self.is_news_type and self.answer == '':
self.answer = '[{"content":" ' + str(
self.material_id) + '","type":"news"}]'
try:
self.answer = json.loads(self.answer)
if type(self.answer) == int or type(self.answer) == long or type(
self.answer) == float or type(self.answer) == dict:
self.answer = str(self.answer)
1 / 0 #防止关键词是数字和自定义菜单字典格式内容时引起bug，使进入except代码块
except:
if self.answer != '':
answer_array = []
content2type = {}
if self.is_news_type:
content2type['content'] = self.material_id
content2type['type'] = 'news'
else:
#content2type['content'] = emotion.change_emotion_to_img(self.answer)
try:
news_answer = eval(self.answer)
content2type[
'content'] = emotion.change_emotion_to_img(
news_answer['content'])
except:
content2type[
'content'] = emotion.change_emotion_to_img(
self.answer)
content2type['type'] = 'text'
#answers_dict = json.loads(self.answer)
#content2type['content_content'] = emotion.change_emotion_to_img(answers_dict.content)
answer_array.append(content2type)
if self.type == FOLLOW_TYPE:
#关注后自动回复只有一条回复内容，不需要用数组封装
self.answer = content2type
else:
self.answer = answer_array
if self.type == FOLLOW_TYPE:
answer_dict = self.answer
_fill_answer_dict(answer_dict)
else:
for answer_dict in self.answer:
_fill_answer_dict(answer_dict)
try:
self.active_days = json.loads(self.active_days)
except:
# error_message = 'parse active_days to json error:' + self.active_days
# watchdog_error(error_message)
# print '----------------',error_message
self.active_days = ''
self.created_at = self.created_at.strftime('%Y-%m-%d %H:%M:%S')
#兼容旧的start_hour和end_hour，转换成时分格式
start_hour, end_hour = _format_hour(self.start_hour, self.end_hour)
self.start_hour = start_hour
self.end_hour = end_hour
return {
"id": self.id,
"owner_id": self.owner_id,
"type": self.type,
"rule_name": self.rule_name,
"active_type": self.active_type,
"start_hour": self.start_hour,
"end_hour": self.end_hour,
"created_at": self.created_at,
"patterns": self.patterns,
"answer": self.answer,
"material_id": self.material_id,
"is_url": self.is_url,
"active_days": self.active_days,
"is_news_type": self.is_news_type
}
def get_messages(request):
response = JsonResponse()
response.code = 200
response.data = JsonResponse()
response.data.items = []
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
return response.get_response()
#获取当前页数
cur_page = int(request.GET.get('page', '1'))
#获取每页个数
count = int(request.GET.get('count', COUNT_PER_PAGE))
is_debug = (request.GET.get('dbg', '0') == '1')
is_collected = request.GET.get('is_collected', '')
search_content = request.GET.get('search_content', '')
if is_collected:
collected_message_ids = CollectMessage.get_message_ids(request.user)
ordering = 'FIELD(`id`, %s)' % ','.join(
str(id) for id in collected_message_ids)
messages = Message.objects.filter(id__in=collected_message_ids).extra(
select={'ordering': ordering}, order_by=('ordering', ))
elif search_content:
data_before_tow_days = dateutil.get_previous_date('today', 2)
messages = Message.objects.belong_to(request.user_profile.webapp_id,
mpuser, search_content)
else:
messages = []
pageinfo, messages = paginate(messages,
cur_page,
count,
query_string=request.META['QUERY_STRING'])
webapp_id = request.user_profile.webapp_id
for message in messages:
weixin_user = message.session.weixin_user
one_session = JsonResponse()
one_session.id = message.id
one_session.session_id = message.session.id
one_session.sender_fake_id = weixin_user.fake_id
one_session.sender_username = weixin_user.username
one_session.sender_name = weixin_user.nickname_for_html
if weixin_user.weixin_user_icon:
one_session.weixin_user_icon = weixin_user.weixin_user_icon if len(
weixin_user.weixin_user_icon.strip()) > 0 else DEFAULT_ICON
else:
one_session.weixin_user_icon = DEFAULT_ICON
one_session.content = emotion.change_emotion_to_img(message.content)
one_session.is_active = True if datetime.now(
) < message.created_at + timedelta(
hours=EXPIRED_TIME) and datetime.now(
) > message.created_at else False
if is_collected:
one_session.is_active = False
try:
collect_message = CollectMessage.objects.get(
message_id=message.id)
one_session.created_at = __format_datetime(
collect_message.created_at)
except:
one_session.created_at = __format_datetime(message.created_at)
else:
one_session.created_at = __format_datetime(message.created_at)
one_session.message_id = message.id
one_session.is_collected = CollectMessage.is_collected(message.id)
one_session.message_type = message.message_type
one_session.pic_url = message.pic_url
one_session.audio_url = message.audio_url
one_session.for_collected = is_collected
one_session.hidden_a = True
if message.message_type == IMAGE:
one_session.content = message.pic_url
if message.message_type == VOICE:
one_session.content = message.audio_url
one_session.is_subscribed = is_subscribed(weixin_user)
try:
account = SocialAccount.objects.get(webapp_id=webapp_id,
openid=weixin_user.username)
member = MemberHasSocialAccount.objects.filter(
account=account)[0].member
#member = session2member[session.weixin_user_id]
if member:
one_session.member_id = member.id
one_session.member_remarks_name = member.remarks_name
if member.user_icon and len(member.user_icon.strip()) > 0:
one_session.weixin_user_icon = member.user_icon
if member.username_for_html:
one_session.sender_name = member.username_for_html
except:
notify_message = u"设置会话信息失败, weixin_user_openid:{}, cause:\n{}".format(
session.weixin_user_id, unicode_full_stack())
watchdog_notice(notify_message)
continue
response.data.items.append(one_session)
response.data.page_info = __package_pageinfo(pageinfo)
return response.get_response()
def get_sessions(request):
response = JsonResponse()
response.code = 200
response.data = JsonResponse()
response.data.items = []
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
return response.get_response()
#获取当前页数
cur_page = int(request.GET.get('page', '1'))
#获取每页个数
count = int(request.GET.get('count', COUNT_PER_PAGE))
is_debug = (request.GET.get('dbg', '0') == '1')
#收藏记录
is_collected = request.GET.get('is_collected', '0')
start_time = request.GET.get('start_time', '').strip()
end_time = request.GET.get('end_time', '').strip()
search_content = request.GET.get('search_content', '').strip()
if is_debug:
sessions = Session.objects.select_related().filter(mpuser=mpuser)
else:
sessions = Session.objects.select_related().filter(mpuser=mpuser,
is_show=True)
if start_time and end_time:
start_time = '%s 0:0:0' % start_time
end_time = '%s 23:59:59' % end_time
sessions = sessions.filter(latest_contact_created_at__gte=start_time,
latest_contact_created_at__lte=end_time)
pageinfo, sessions = paginate(sessions,
cur_page,
count,
query_string=request.META['QUERY_STRING'])
#清空未读消息数量
RealTimeInfo.objects.filter(mpuser=mpuser).update(unread_count=0)
webapp_id = request.user_profile.webapp_id
weixin_user_usernames = [s.weixin_user_id for s in sessions]
weixin_users = WeixinUser.objects.filter(
username__in=weixin_user_usernames)
username2weixin_user = dict([(u.username, u) for u in weixin_users])
# session2member = dict([(member_has_social_account.account.openid, member_has_social_account.member) for member_has_social_account \
# in MemberHasSocialAccount.objects.filter()])
for session in sessions:
weixin_user = username2weixin_user[session.weixin_user_id]
one_session = JsonResponse()
one_session.id = session.id
one_session.session_id = session.id
one_session.sender_fake_id = weixin_user.fake_id
one_session.sender_username = weixin_user.username
one_session.sender_name = weixin_user.nickname_for_html
if weixin_user.weixin_user_icon:
one_session.weixin_user_icon = weixin_user.weixin_user_icon if len(
weixin_user.weixin_user_icon.strip()) > 0 else DEFAULT_ICON
else:
one_session.weixin_user_icon = DEFAULT_ICON
one_session.content = emotion.change_emotion_to_img(
session.latest_contact_content)
one_session.created_at = __format_datetime(
session.latest_contact_created_at)
one_session.unread_count = session.unread_count
one_session.message_id = session.message_id
one_session.is_collected = CollectMessage.is_collected(
session.message_id)
one_session.for_collected = False
one_session.hidden_a = False
try:
if session.message_id != 0:
message = Message.objects.get(id=session.message_id)
one_session.message_type = message.message_type
one_session.pic_url = message.pic_url
one_session.audio_url = message.audio_url
else:
one_session.message_type = 'text'
one_session.pic_url = ''
one_session.audio_url = ''
except:
one_session.message_type = 'text'
one_session.pic_url = ''
one_session.audio_url = ''
one_session.is_subscribed = is_subscribed(weixin_user)
one_session.is_active = True if datetime.now(
) < session.latest_contact_created_at + timedelta(
hours=EXPIRED_TIME) and datetime.now(
) > session.latest_contact_created_at else False
try:
account = SocialAccount.objects.get(webapp_id=webapp_id,
openid=weixin_user.username)
member = MemberHasSocialAccount.objects.filter(
account=account)[0].member
#member = session2member[session.weixin_user_id]
if member:
one_session.member_id = member.id
one_session.member_remarks_name = member.remarks_name
if member.user_icon and len(member.user_icon.strip()) > 0:
one_session.weixin_user_icon = member.user_icon
if member.username_for_html:
one_session.sender_name = member.username_for_html
except:
notify_message = u"设置会话信息失败, weixin_user_openid:{}, webapp_id:{},cause:\n{}".format(
session.weixin_user_id, webapp_id, unicode_full_stack())
watchdog_notice(notify_message)
continue
response.data.items.append(one_session)
response.data.page_info = __package_pageinfo(pageinfo)
return response.get_response()
def handle(self, context, is_from_simulator=False):
message = context.message
if message.is_optimization_message:
print 'ChannelDistributionQrcodeHandler only handle is_optimization_message = true'
return None
username = message.fromUserName
user_profile = context.user_profile
member = context.member
if not hasattr(context.message, 'event'):
return None
if not hasattr(context.message, 'ticket') or context.message.ticket is None:
return None
ticket = context.message.ticket
if not hasattr(context.message, 'eventKey') or context.message.eventKey is None or ticket == '':
return None
if member and (hasattr(member, 'is_new') is False):
member.is_new = False
#优化处理
if hasattr(context, 'is_member_qrcode') and (context.is_member_qrcode is True):
return None
# 一 将信息添加到ChannelDistributionQrcodeHasMember中
# 二 将扫码的会员添加到新分组中
channel_distribution_qrcode_has_member = ChannelDistributionQrcodeHasMember.objects.filter(member_id=member.id)
if channel_distribution_qrcode_has_member: # 如果这个会员已经绑定到别人的二维码下:
return None
else:
qrcode = ChannelDistributionQrcodeSettings.objects.filter(ticket=ticket) # 得到ticket绑定的二维码数据
if qrcode:
ChannelDistributionQrcodeHasMember.objects.create(
channel_qrcode_id = qrcode[0].id,
member_id = member.id,
)
qrcode.update(bing_member_count = F('bing_member_count') + 1)
# 得到需要绑定的member分组
group_id = qrcode[0].group_id
# 添加到得到的分组
MemberHasTag.add_tag_member_relation(member, [group_id])
# 发放优惠券
award_prize_info = json.loads(qrcode[0].award_prize_info)
if award_prize_info['type'] == u"优惠券":
coupon_id = award_prize_info['id'] # 优惠券id
consume_coupon(qrcode[0].owner.id, coupon_id, member.id)
elif award_prize_info['type'] == u"积分":
# 发放积分
award = award_prize_info['id'] # 扫码奖励积分
increase_member_integral(member, award, u'推荐扫码奖励')
# 扫码回复
msg_type, detail = get_response_msg_info_restructure(qrcode[0], user_profile)
if msg_type != None:
# from_weixin_user = self._get_from_weixin_user(message)
# token = self._get_token_for_weixin_user(user_profile, from_weixin_user, is_from_simulator)
if msg_type == 'text' and detail:
if is_from_simulator:
return generator.get_text_response(username, message.toUserName,
emotion.change_emotion_to_img(detail), username,
user_profile)
else:
return generator.get_text_response(username, message.toUserName, detail, username,
user_profile)
if msg_type == 'news' and get_material_news_info(detail):
news = get_material_news_info(detail)
return generator.get_news_response(username, message.toUserName, news, username)
else:
return None
else:
return None
return None
