def mui_get_session_histories(request):
session_id = request.GET['s_id']
current_page = int(request.GET.get('cur_page', '1'))
count = int(request.GET.get('count', 10))
isManager = request.GET.get('isManager', 'false')
isSystemMenager = request.GET.get('isSystemMenager', 'false')
# user_id = request.GET['user_id']
session = Session.objects.get(id=session_id)
messages = Message.objects.filter(session=session_id).order_by('-id')
#进行分页
pageinfo, messages = paginator.paginate(messages, current_page, count)
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 Exception, e:
print e.message
response = create_response(500)
response.errMsg = u'获取公众号预览信息失败'
return response.get_jsonp_response(request)
def get_members(request):
"""
get_memers: 会员列表
"""
mpuser = get_system_user_binded_mpuser(request.user)
webapp_id = request.user_profile.webapp_id
#处理来自“数据罗盘-会员分析-关注会员链接”过来的查看关注会员的请求
#add by duhao 2015-07-13
status = request.GET.get('status' , '1')
member_tags = MemberTag.get_member_tags(webapp_id)
#调整排序，将为分组放在最前面
tags = []
for tag in member_tags:
if tag.name == '未分组':
tags = [tag] + tags
else:
tags.append(tag)
member_tags = tags
c = RequestContext(request, {
'first_nav_name': export.MEMBER_FIRST_NAV,
'second_navs': export.get_second_navs(request),
'second_nav_name': export.MEMBERS,
'should_show_authorize_cover' : get_should_show_authorize_cover(request),
'user_tags': member_tags,
'grades': MemberGrade.get_all_grades_list(webapp_id),
'counts': Member.objects.filter(webapp_id=webapp_id,is_for_test=0, status__in= [SUBSCRIBED, CANCEL_SUBSCRIBED]).count(),
'status': status
})
return render_to_response('member/editor/members.html', c)
def show_history(request):
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
raise Http404('Binded MpUser Not Found')
return_path = request.GET.get('return_path', 'message')
nav_name = request.GET.get('nav_name', weixin.WEIXIN_MESSAGE_NAV_NAME)
session_id = request.GET['session_id']
session = None
try:
session = Session.objects.get(mpuser=mpuser, id=session_id)
except:
raise Http404('Session Not Found')
#根据fake_id 得到对应用户信息weixin_user
if not session.weixin_user:
is_user_subscribed = 0
else:
is_user_subscribed = is_subscribed(session.weixin_user)
session.unread_count = 0
session.save()
c = RequestContext(
request, {
'first_nav_name': FIRSTT_NAV_NAME,
'second_navs': WEIXIN_SECOND_NAVS,
'second_nav_name': nav_name,
'session': session,
'return_path': return_path,
'is_subscribed': is_user_subscribed
})
return render_to_response('message/list_histories.html', c)
def get_should_show_authorize_cover(request): mpuser = get_system_user_binded_mpuser(request.user) if (mpuser is None) or (not mpuser.is_certified) or (not mpuser.is_service): return True else: return False
def send_custome_message(request):
content = request.POST['text']
openid_sendto = request.POST['openid']
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
response = create_response(500)
response.errMsg = u'请先进行公众号的绑定'
else:
#进行实际消息的发送
try:
if openid_sendto and get_weixinuser_sessions(
openid_sendto).count() > 0:
session = get_weixinuser_sessions(openid_sendto)[0]
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
if is_active:
_send_custom_message(mpuser, openid_sendto, content)
response = create_response(200)
else:
response = create_response(501)
response.errMsg = u'互动已经超时'
else:
response = create_response(501)
response.errMsg = u'互动已经超时'
except WeixinApiError, error:
response = create_response(500)
error_code = error.error_response.errcode
response.errMsg = weixin_error_codes.code2msg.get(
error_code, error.error_response.errmsg)
response.innerErrMsg = error.error_response.detail
except:
def reply_session(request):
session_id = request.POST['session_id']
content = request.POST['content']
receiver_username = request.POST['receiver_username']
receiver = WeixinUser.objects.get(username=receiver_username)
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
response = create_response(500)
response.errMsg = u'请先进行公众号的绑定'
#回复用户消息
return_flag = send_custome_message(content, receiver_username, mpuser)
if not return_flag:
response = create_response(500)
response.errMsg = u'发送消息失败'
else:
#存储数据库
Session.objects.filter(id=session_id).update(
latest_contact_content=content,
latest_contact_created_at=datetime.today(),
is_latest_contact_by_viper=True,
unread_count=0)
Message.objects.create(mpuser=mpuser,
session_id=session_id,
from_weixin_user_username=mpuser.username,
to_weixin_user_username=receiver_username,
content=content,
is_reply=True)
response = create_response(200)
return response.get_response()
def reset_realtime_unread_count(request):
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
return create_response(200).get_response()
else:
RealTimeInfo.objects.filter(mpuser=mpuser).update(unread_count=0)
return create_response(200).get_response()
def get_realtime_unread_count(user):
mpuser = get_system_user_binded_mpuser(user)
if mpuser is None:
return 0
else:
try:
return RealTimeInfo.objects.get(mpuser=mpuser).unread_count
except:
return 0
def create_inactive_account(request):
username = request.POST.get('name', None)
key = request.POST.get('key', None)
if username is None:
response = create_response(400)
response.errMsg = u'非法参数'
return response.get_response()
if KEY != key:
response = create_response(INVALID_KEY_ERROR_CODE)
response.errMsg = u'非法的key'
return response.get_response()
exist_users = User.objects.filter(username=username)
if exist_users.count() == 0:
response = create_response(400)
response.errMsg = u'该用户不存在'
return response.get_response()
to_operate_user = exist_users[0]
user_profile = UserProfile.objects.get(user=to_operate_user)
try:
#首先更改用户名，改为:${username}_id_deleted
#该用户名之后，原用户就无法登录
to_operate_user.username = "******".format(
to_operate_user.username, to_operate_user.id)
to_operate_user.save()
user_profile.is_mp_registered = False
user_profile.force_logout()
#进行接触绑定操作
mpuser = get_system_user_binded_mpuser(to_operate_user)
if mpuser:
mpuser.delete()
#删除所有之前的会员
Member.objects.filter(webapp_id=user_profile.webapp_id).delete()
#删除所有之前的微信用户
WeixinUser.objects.filter(webapp_id=user_profile.webapp_id).delete()
response = create_response(200)
except:
error_msg = u"置用户({}}失效操作失败, cause:\n{}".format(
username, unicode_full_stack())
watchdog_error(error_msg)
response = create_response(500)
response.innerErrMsg = error_msg
return response.get_response()
def get_unread_message_count(user):
unread_message_count = 0
mpuser = get_system_user_binded_mpuser(user)
sessions = Session.objects.select_related().filter(
mpuser=mpuser,
is_show=True).exclude(member_latest_created_at="").aggregate(
Sum("unread_count"))
if sessions["unread_count__sum"] is not None:
unread_message_count = sessions["unread_count__sum"]
return unread_message_count
def member_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
coupon_rules = get_coupon_rules(request.user)
member_qrcode_settings = MemberQrcodeSettings.objects.filter(
owner=request.user)
member_qrcode_setting = member_qrcode_settings[
0] if member_qrcode_settings.count() > 0 else None
if member_qrcode_setting:
award_contents = MemberQrcodeAwardContent.objects.filter(
member_qrcode_settings=member_qrcode_setting)
if award_contents.count() > 0:
award_content = award_contents[
0] if member_qrcode_setting.award_member_type == 1 else None
else:
award_content = None
else:
award_contents = None
award_content = None
member_grades = get_all_grades_list(request)
if member_grades and award_contents:
for member_grade in member_grades:
content = award_contents.filter(
member_level=member_grade.id)[0] if award_contents.filter(
member_level=member_grade.id).count() > 0 else None
if content:
member_grade.award_type = content.award_type
member_grade.award_content = content.award_content
c = RequestContext(
request, {
'first_nav_name': FIRST_NAV_NAME,
'second_navs': export.get_second_navs(request),
'second_nav_name': SECOND_NAV_NAME,
'member_qrcode_settings': member_qrcode_setting,
'coupon_rules': coupon_rules,
'award_content': award_content,
'member_grades': member_grades,
'should_show_authorize_cover': should_show_authorize_cover,
'is_hide_weixin_option_menu': True
})
return render_to_response(
'member_qrcode/editor/member_qrcode_settings.html', c)
def list_memers(request):
mpuser = get_system_user_binded_mpuser(request.user)
webapp_id = request.user_profile.webapp_id
c = RequestContext(request, {
'first_nav_name': FIRST_NAV_NAME,
'second_navs': export.get_second_navs(request),
'second_nav_name': WEAPP_USER_CENTER_NAV_NAME,
'should_show_authorize_cover' : get_should_show_authorize_cover(request),
'user_tags': MemberTag.get_member_tags(webapp_id),
'grades': MemberGrade.get_all_grades_list(webapp_id),
'counts': Member.objects.filter(webapp_id=webapp_id,is_for_test=0).count()
})
return render_to_response('user_center/editor/user_center.html', c)
def edit_customerized_menu(request):
mpuser = get_system_user_binded_mpuser(request.user)
if (mpuser is None) or (not mpuser.is_service and not mpuser.is_certified):
should_show_authorize_cover = True
else:
should_show_authorize_cover = False
c = RequestContext(
request, {
'first_nav_name': FIRSTT_NAV_NAME,
'second_navs': WEIXIN_SECOND_NAVS,
'second_nav_name': weixin.WEIXIN_MANAGE_MENU_NAV_NAME,
'menu_items': menu_util.get_menus_json(request.user),
'should_show_authorize_cover': should_show_authorize_cover
})
return render_to_response('editor/edit_customer_menu.html', c)
def create_mpuser_access_token(request):
from modules.member.util import create_member_group, get_all_group
appid = request.GET.get('appid', None)
secret = request.GET.get('secret', None)
if appid is None or secret is None:
response = create_response(400)
response.errMsg = u'appid或secret输入不正确'
else:
new_access_token, expires_span, error_response = get_new_access_token(
appid, secret)
if (new_access_token is None) and (error_response is None):
response = create_response(500)
response.errMsg = u'服务繁忙请稍后重试'
else:
if new_access_token is None:
response = create_response(500)
response.errMsg = error_response.get_errormsg_in_zh()
else:
#访问api成功, 需要创建本地mpser对应的授权信息
try:
mpuser = get_system_user_binded_mpuser(request.user)
access_token = _update_local_mpuser_access_token(
mpuser, appid, secret, new_access_token, expires_span)
try:
user_profile = request.user_profile
groups = get_all_group(user_profile)
create_member_group(groups, user_profile.webapp_id)
except:
notify_msg = u"更新分组失败, cause:\n{}".format(
unicode_full_stack())
watchdog_fatal(notify_msg)
response = create_response(200)
except:
notify_msg = u"获取或存储access_token失败, appid:'{}', secret:'{}', cause:\n{}".format(
appid, secret, unicode_full_stack())
watchdog_error(notify_msg)
response = create_response(500)
response.errMsg = u'服务繁忙请稍后重试'
return response.get_response()
def list_timelines(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
c = RequestContext(
request, {
'first_nav_name': FIRSTT_NAV_NAME,
'second_navs': WEIXIN_SECOND_NAVS,
'second_nav_name': weixin.WEIXIN_MESSAGE_NAV_NAME,
'should_show_authorize_cover': should_show_authorize_cover,
'IS_DEBUG': settings.DEBUG
})
account_models.reset_new_message_count(user=request.user)
return render_to_response('message/list_sessions.html', c)
def get(request):
mpuser = get_system_user_binded_mpuser(request.manager)
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
coupon_rules = get_coupon_rules(request.manager)
try:
member_qrcode_setting = MemberChannelQrcodeSettings.objects.get(
owner=request.manager)
except:
member_qrcode_setting = None
if member_qrcode_setting:
try:
award_content = MemberChannelQrcodeAwardContent.objects.get(
owner=request.manager)
except:
award_content = None
else:
award_content = None
c = RequestContext(
request, {
'first_nav_name': FIRST_NAV,
'second_navs': export.get_weixin_second_navs(request),
'second_nav_name': export.WEIXIN_ADVANCE_SECOND_NAV,
'third_nav_name':
export.ADVANCE_MANAGE_MEMBER_CHANNEL_QRCODE_NAV,
'member_qrcode_settings': member_qrcode_setting,
'coupon_rules': coupon_rules,
'award_content': award_content,
'should_show_authorize_cover': should_show_authorize_cover,
'is_hide_weixin_option_menu': True
})
return render_to_response(
'weixin/advance_manage/edit_member_channel_qrcode.html', c)
def delete_binded_mpuser(request):
user_profile = request.user_profile
response = create_response(200)
try:
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser:
mpuser.delete()
user_profile.is_mp_registered = False
user_profile.save()
#删除所有之前的会员
Member.objects.filter(webapp_id=user_profile.webapp_id).delete()
#删除所有之前的微信用户
WeixinUser.objects.filter(webapp_id=user_profile.webapp_id).delete()
except:
notify_msg = u"解除绑定操作失败, cause:\n{}".format(unicode_full_stack())
watchdog_fatal(notify_msg)
return response.get_response()
def delete_system_user(user):
if user is None:
return False
try:
from modules.member.models import Member
user_profile = UserProfile.objects.get(user_id=user.id)
mpuser = get_system_user_binded_mpuser(user)
if mpuser:
mpuser.delete()
#删除所有之前的会员
Member.objects.filter(webapp_id=user_profile.webapp_id).delete()
user_profile.delete()
User.objects.filter(id=user.id).delete()
return True
except:
watchdog_fatal(u"删除用户{}失败".format(user.id))
return False
def reply_session_write_back(request):
session_id = request.POST['session_id']
content = request.POST['content']
receiver_username = request.POST['receiver_username']
receiver = WeixinUser.objects.get(username=receiver_username)
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser is None:
response = create_response(500)
response.errMsg = u'请先进行公众号的绑定'
Session.objects.filter(id=session_id).update(
latest_contact_content=content,
latest_contact_created_at=datetime.today(),
is_latest_contact_by_viper=True,
unread_count=0)
Message.objects.create(mpuser=mpuser,
session_id=session_id,
from_weixin_user_username=mpuser.username,
to_weixin_user_username=receiver_username,
content=content,
is_reply=True)
return create_response(200).get_response()
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 list_messages(request):
page = request.GET.get('page', 1)
count = int(request.GET.get('count', 10))
mpuser = get_system_user_binded_mpuser(request.user)
isManager = request.GET.get('isManager', 'false')
isSystemMenager = request.GET.get('isSystemMenager', 'false')
if mpuser is None:
response = create_response(500)
response.errMsg = u'没有该用户的消息'
return response.get_jsonp_response(request)
sessions = Session.objects.select_related().filter(mpuser=mpuser,
is_show=True)
#分页信息
pageinfo, sessions = paginate(sessions,
page,
count,
query_string=request.META['QUERY_STRING'])
webapp_id = request.user_profile.webapp_id
if isManager == "false" and isSystemMenager == "false":
#清空未读消息数量
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_json = []
for session in sessions:
weixin_user = username2weixin_user[session.weixin_user_id]
content = session.latest_contact_content
one_session = JsonResponse()
one_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
one_session.weixin_user_icon = weixin_user.weixin_user_icon if len(
weixin_user.weixin_user_icon.strip()) > 0 else DEFAULT_ICON
messages = Message.objects.filter(
session=session.id).order_by('-created_at')
message_st_type = messages[0].message_type
if message_st_type == 'text':
if len(content) > 10:
content = content[0:10] + '...'
elif len(content.strip()) <= 0: #如果类型为text但是内容为空，则视为voice，有问题？
content = '[语音]'
elif message_st_type == 'image':
content = '[图片]'
elif message_st_type == 'voice':
content = '[语音]'
elif message_st_type == 'video':
content = '[视频]'
one_session.content = content
one_session.created_at = __format_datetime(
session.latest_contact_created_at)
one_session.unread_count = session.unread_count
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 = 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
#raise
sessions_list_json.append(one_session)
response = create_response(200)
response.data.iterms = sessions_list_json
response.data.pressed_link = 'message'
response.data.page_info = __package_pageinfo(pageinfo)
return response.get_jsonp_response(request)
def send_mui_media(request):
# 上传图片到云
uploadAction = request.POST.get('action', None)
response = create_CORS_response(200, '', '')
if uploadAction and uploadAction == 'query':
return response
filename = request.POST.get('filename')
media_type = request.POST.get('type')
receiver_username = request.POST.get('r_u')
session_id = request.POST.get('s_id')
domain = request.POST.get('domain')
user = User.objects.get(id=request.POST.get('user'))
user_profile = user.get_profile()
request.user = user
request.user_profile = user_profile
mpuser = get_system_user_binded_mpuser(request.user)
try:
if user:
try:
mpuser_access_token = get_mpuser_access_token_for(mpuser)
weixin_api = get_weixin_api(mpuser_access_token)
except:
response = create_CORS_response(500, u'微信公众号授权出错', '')
return response
else:
response = create_CORS_response(500, u'用户登陆信息出错', '')
return response
upload_value = ''
if filename and media_type:
if media_type == 'image':
# 尝试上传图片到云，成功则返回云路径，否则返回服务器存储路径
value = save_and_zip_img_file_for_muiApp(request, filename)
if not value:
response = create_CORS_response(500, u'上传云失败', '')
return response
if value.startswith('/') and value.find('http') == -1:
upload_value = os.path.join(settings.PROJECT_HOME, '../',
value[1:])
value = '%s%s' % (domain, value)
else:
upload_value = value
#上传到微信服务器
result_info = weixin_api.upload_media_image(upload_value, True)
if not result_info:
response = create_CORS_response(500, u'发送图片失败,请重试..', '')
return response
# 发送给用户
res = weixin_api.send_custom_msg(
receiver_username,
ImageCustomMessage(result_info['media_id']))
# 存储数据库
Session.objects.filter(id=session_id).update(
latest_contact_content='[图片]',
latest_contact_created_at=datetime.today(),
is_latest_contact_by_viper=True,
unread_count=0)
Message.objects.create(
mpuser=mpuser,
session_id=session_id,
from_weixin_user_username=mpuser.username,
to_weixin_user_username=receiver_username,
pic_url=value,
message_type='image',
media_id=result_info['media_id'],
content='',
is_reply=True)
response = create_CORS_response(200, '', '')
elif media_type == 'voice':
# 尝试上传语音到云，成功则返回云路径，否则返回服务器存储路径
file = request.FILES.get('upload_file', None)
if not file:
response = create_CORS_response(500, u'不存在该文件', '')
value = save_audio_file_for_mobileApp(request, file)
if not value:
response = create_CORS_response(500, u'mp3文件没有找到', '')
return response
if value.startswith('/') and value.find('http') == -1:
upload_value = os.path.join(settings.PROJECT_HOME, '../',
value[1:])
value = '%s%s' % (domain, value)
else:
upload_value = value
#上传到微信服务器
result_info = weixin_api.upload_media_voice(upload_value, True)
if not result_info:
response = create_CORS_response(500, u'发送语音失败,请重试..', '')
return response
# 发送给用户
res = weixin_api.send_custom_msg(
receiver_username,
VoiceCustomMessage(result_info['media_id']))
# 存储数据库
Session.objects.filter(id=session_id).update(
latest_contact_content='[语音]',
latest_contact_created_at=datetime.today(),
is_latest_contact_by_viper=True,
unread_count=0)
Message.objects.create(
mpuser=mpuser,
session_id=session_id,
from_weixin_user_username=mpuser.username,
to_weixin_user_username=receiver_username,
audio_url=value,
message_type='voice',
media_id=result_info['media_id'],
content='',
is_reply=True)
response = create_CORS_response(200, '', '')
except Exception:
response = create_CORS_response(500, u'发送失败', '')
return response
def mui_get_additional_histories(request):
end_id = request.GET['end_id']
session_id = request.GET['s_id']
current_page = 1
count = int(request.GET.get('count', 10))
isManager = request.GET.get('isManager', 'false')
isSystemMenager = request.GET.get('isSystemMenager', 'false')
# user_id = request.GET['user_id']
session = Session.objects.get(id=session_id)
messages = Message.objects.filter(session=session_id).order_by('-id')
#进行分页
pageinfo, messages = paginator.paginate(messages, current_page, count)
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_jsonp_response(request)
if isManager == "false" and isSystemMenager == "false":
#清空未读消息
Session.objects.filter(mpuser=mpuser,
id=session_id).update(unread_count=0)
sender_name_response = ""
messages_list_json = []
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
r_messages = []
for message in messages:
if message.id == end_id:
break
else:
r_messages.append(message)
if not r_messages:
response = create_response(500)
return response.get_jsonp_response(request)
for message in reversed(r_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.message_type = message.message_type
one_message.pic_url = message.pic_url
one_message.audio_url = message.audio_url
one_message.content = emotion.mui_change_emotion_to_img(
message.content)
one_message.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
sender_name_response = one_message.sender_name
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_json.append(one_message)
response = create_response(200)
response.data = messages_list_json
response.is_login = True
response.is_active = is_active
response.session_id = session_id
response.weixin_user_id = session.weixin_user_id
response.pressed_link = 'message'
response.send_user_name = sender_name_response if sender_name_response != "" else session.weixin_user.weixin_user_nick_name
response.page_info = __package_pageinfo(pageinfo)
response.r_messages_count = len(r_messages)
return response.get_jsonp_response(request)
def get(request):
"""
获得公众号详情
"""
user_profile = request.user_profile
# request_user = request.user
request_user = request.manager #duhao 20151020
user_profile = account_models.UserProfile.objects.get(
id=user_profile.id)
if user_profile.is_mp_registered:
try:
mpuser = weixin_models.get_system_user_binded_mpuser(
request_user)
mpuser_preview_info = weixin_models.MpuserPreviewInfo.objects.get(
mpuser=mpuser)
except:
mpuser = None
mpuser_preview_info = None
from weixin.user.util import get_component_info_from
component_info = get_component_info_from(request)
pre_auth_code = None
request_host = settings.DOMAIN
logging.info('>>>>>>>>>>>>>>>>>>>>>>>start')
logging.info(request_host)
logging.info('>>>>>>>>>>>>>>>>>>>>>>>end')
#request_host = request.META['HTTP_HOST']
if component_info:
from core.wxapi.agent_weixin_api import WeixinApi, WeixinHttpClient
weixin_http_client = WeixinHttpClient()
weixin_api = WeixinApi(component_info.component_access_token,
weixin_http_client)
result = weixin_api.api_create_preauthcode(component_info.app_id)
print result
if hasattr(result, 'pre_auth_code'):
pre_auth_code = result['pre_auth_code']
else:
result = weixin_api.api_create_preauthcode(
component_info.app_id)
if result and result.has_key('pre_auth_code'):
pre_auth_code = result['pre_auth_code']
else:
watchdog_error(result)
if weixin_models.ComponentAuthedAppid.objects.filter(
component_info=component_info,
user_id=request.manager.id).count() == 0:
weixin_models.ComponentAuthedAppid.objects.create(
component_info=component_info, user_id=request.manager.id)
auth_appid = weixin_models.ComponentAuthedAppid.objects.filter(
component_info=component_info, user_id=request.manager.id)[0]
if weixin_models.ComponentAuthedAppidInfo.objects.filter(
auth_appid=auth_appid).count() > 0:
auth_appid_info = weixin_models.ComponentAuthedAppidInfo.objects.filter(
auth_appid=auth_appid)[0]
else:
auth_appid_info = None
else:
component_info = None
auth_appid = None
auth_appid_info = None
#微众商城引流图文地址
operation_settings_objs = account_models.OperationSettings.objects.filter(
owner=request.manager)
if operation_settings_objs.count() == 0:
operation_settings = account_models.OperationSettings.objects.create(
owner=request.manager)
else:
operation_settings = operation_settings_objs[0]
if user_profile.is_mp_registered:
mpuser_access_token = weixin_models.get_mpuser_access_token_for(
mpuser)
c = RequestContext(
request, {
'first_nav_name': FIRST_NAV,
'second_navs': export.get_weixin_second_navs(request),
'second_nav_name': export.WEIXIN_MPUSER_SECOND_NAV,
'third_nav_name': export.MPUSER_BINDING_NAV,
'component_info': component_info,
'request_user': request_user,
'user_profile': user_profile,
'mpuser': mpuser,
'mpuser_access_token': mpuser_access_token,
'preview_user': mpuser_preview_info,
'default_icon': weixin_models.DEFAULT_ICON,
'is_mp_registered': user_profile.is_mp_registered,
'pre_auth_code': pre_auth_code,
'auth_appid_info': auth_appid_info,
'request_host': request_host,
'operation_settings': operation_settings
})
return render_to_response('weixin/mp_user/mp_user.html', c)
else:
c = RequestContext(
request, {
'first_nav_name': FIRST_NAV,
'pre_auth_code': pre_auth_code,
'request_user': request_user,
'user_profile': user_profile,
'default_icon': weixin_models.DEFAULT_ICON,
'component_info': component_info,
'is_mp_registered': user_profile.is_mp_registered,
'auth_appid_info': auth_appid_info,
'request_host': request_host,
'operation_settings': operation_settings
})
return render_to_response('weixin/mp_user/mp_user_index.html', c)
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(request):
"""
get_memers: 会员列表
"""
mpuser = get_system_user_binded_mpuser(request.user)
webapp_id = request.user_profile.webapp_id
#处理来自“数据罗盘-会员分析-关注会员链接”过来的查看关注会员的请求
#add by duhao 2015-07-13
status = request.GET.get('status', '1')
member_tags = MemberTag.get_member_tags(webapp_id)
#调整排序，将为分组放在最前面
tags = []
for tag in member_tags:
if tag.name == '未分组':
tags = [tag] + tags
else:
tags.append(tag)
member_tags = tags
#获取未完成的任务
woid = request.webapp_owner_id
export_jobs = ExportJob.objects.filter(woid=woid,
type=0,
is_download=0).order_by("-id")
if export_jobs:
export2data = {
"woid": int(export_jobs[0].woid), #
"status": 1 if export_jobs[0].status else 0,
"is_download": 1 if export_jobs[0].is_download else 0,
"id": int(export_jobs[0].id),
# "file_path": export_jobs[0].file_path,
}
else:
export2data = {
"woid": 0,
"status": 1,
"is_download": 1,
"id": 0,
"file_path": 0,
}
c = RequestContext(
request,
{
'first_nav_name':
export.MEMBER_FIRST_NAV,
'second_navs':
export.get_second_navs(request),
'second_nav_name':
export.MEMBERS,
#'should_show_authorize_cover' : get_should_show_authorize_cover(request),
'user_tags':
member_tags,
'grades':
MemberGrade.get_all_grades_list(webapp_id),
'counts':
Member.objects.filter(
webapp_id=webapp_id,
is_for_test=0,
status__in=[SUBSCRIBED, CANCEL_SUBSCRIBED]).count(),
'status':
status,
'export2data':
export2data,
})
return render_to_response('member/editor/members.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 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_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 start_simulator(request):
"""
启动微信模拟器
"""
if settings.MODE == 'develop' or settings.MODE == 'test':
is_in_dev_mode = True
else:
is_in_dev_mode = False
if request.user.is_authenticated():
# 如果已经登录过
mpuser = get_system_user_binded_mpuser(request.user)
if mpuser:
try:
mpuser_preview_info = MpuserPreviewInfo.objects.get(
mpuser=mpuser)
except:
mpuser_preview_info = None
else:
mpuser_preview_info = None
c = RequestContext(
request, {
'title':
mpuser_preview_info.name if
(mpuser_preview_info
and mpuser_preview_info.name) else u'信息预览',
'is_logined':
True,
'is_in_dev_mode':
is_in_dev_mode,
'mp_users':
json.dumps([]),
'menus_json':
menu_util.get_menus_json(request.user)
})
return render_to_response('simulator/simulator.html', c)
else:
user2profile = dict([(p.user_id, p)
for p in list(UserProfile.objects.all())])
id2user = dict([(u.id, u) for u in list(User.objects.all())])
id2mpuser = dict([(u.id, u) for u in WeixinMpUser.objects.all()])
mp_users = []
for mp_user in id2mpuser.values():
user_id = mp_user.owner_id
user_name = id2user[user_id].username
profile = user2profile[user_id]
mp_users.append({
'webapp_id': profile.webapp_id,
'mp_user_name': user_name
})
c = RequestContext(
request, {
'is_logined': False,
'mp_users': json.dumps(mp_users),
'is_in_dev_mode': is_in_dev_mode,
'menus_json': "[]"
})
return render_to_response('simulator/simulator.html', c)
