def set(self, token, encoding_aes_key):
self.crypto = WeChatCrypto(token, encoding_aes_key,
self.component_appid)
from django.http import HttpResponse
from django.shortcuts import redirect, render
from django.views.decorators.csrf import csrf_exempt
from wechatpy import parse_message, create_reply, WeChatClient
from wechatpy.crypto import WeChatCrypto
from wechatpy.exceptions import InvalidSignatureException, InvalidAppIdException
from wechatpy.utils import check_signature
from .config import WechatConfig
from .models import Person, Snippet
from .utils import MsgType
CONFIG = WechatConfig.config()
if CONFIG['env'] != 'local':
print("Environment: Running on server")
crypto = WeChatCrypto(CONFIG['token'], CONFIG['encodingAESKey'],
CONFIG['appid'])
# I think this is the way to create menu
client = WeChatClient(CONFIG['appid'], CONFIG['appsecret'])
def view(request):
# View current week's snippet
current_year = datetime.datetime.now().year
current_week_no = datetime.datetime.now().isocalendar()[1]
return view_by_week(request, current_year, current_week_no)
def view_by_week(request, year, week_no):
year = int(year)
week_no = int(week_no)
snippet_list = Snippet.objects.filter(date__year=year,
register_tortoise(
app,
db_url=config['MP_SETTINGS']['DB'],
# create table
generate_schemas=True,
add_exception_handlers=True,
modules={'models': [
'models',
]},
)
# initial crypto for mp message
crypto = WeChatCrypto(
token=config['MP_SETTINGS']['TOKEN'],
encoding_aes_key=config['MP_SETTINGS']['AESKEY'],
app_id=config['MP_SETTINGS']['APPID'],
)
Reply = namedtuple('Reply', ['question', 'answer'])
def get_user_info(openid: str):
url = API_URL + '/api/mp-unionid/'
res = requests.post(url, {
'openid': openid,
})
print(f'[获取推荐人信息] : {res.json()}')
return res
# plaintext mode
msg = parse_message(data)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
else:
reply = create_reply(
_('Welcome to follow our WeChat Official Accounts'), msg)
return fire_raw_content(reply.render(), 200, 'text/xml')
else:
# encryption mode
from wechatpy.crypto import WeChatCrypto
AES_KEY = frappe.get_value('Wechat App', app, 'aes_key')
APP_ID = frappe.get_value('Wechat App', app, 'app_id')
crypto = WeChatCrypto(TOKEN, AES_KEY, APP_ID)
try:
msg = crypto.decrypt_message(data, msg_signature, timestamp, nonce)
except (InvalidSignatureException, InvalidAppIdException), e:
return fire_raw_content(e, 403)
else:
msg = parse_message(msg)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
else:
reply = create_reply(
_('Welcome to follow our WeChat Official Accounts'), msg)
#frappe.enqueue('wechat.api.create_wechat_menu', app_name=app)
return fire_raw_content(
crypto.encrypt_message(reply.render(), nonce, timestamp), 200,
'text/xml')
def wechat(app=None, signature=None, timestamp=None, nonce=None, encrypt_type='raw', msg_signature=None, echostr=None):
"""
微信回调接口
:param app:
:param signature:
:param timestamp:
:param nonce:
:param encrypt_type:
:param msg_signature:
:param echostr:
:return:
"""
app = app or 'test'
TOKEN = frappe.get_value('Wechat App', app, 'token')
try:
check_signature(TOKEN, signature, timestamp, nonce)
except InvalidSignatureException as ex:
return fire_raw_content(ex, 403)
if frappe.request.method == "GET":
#frappe.enqueue('wechat.api.create_wechat_menu', app_name=app)
return fire_raw_content(echostr)
#data = frappe.request.get_data()
data = frappe.form_dict.data.decode('utf-8')
frappe.logger(__name__).info(_("Received WeChat message {0}").format(data))
# POST request
if encrypt_type == 'raw':
# plaintext mode
msg = parse_message(data)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
else:
reply = create_reply(_('Welcome to follow our WeChat Official Accounts'), msg)
return fire_raw_content(reply.render(), 200, 'text/xml')
else:
# encryption mode
from wechatpy.crypto import WeChatCrypto
AES_KEY = frappe.get_value('Wechat App', app, 'aes_key')
APP_ID = frappe.get_value('Wechat App', app, 'app_id')
crypto = WeChatCrypto(TOKEN, AES_KEY, APP_ID)
try:
msg = crypto.decrypt_message(
data,
msg_signature,
timestamp,
nonce
)
except (InvalidSignatureException, InvalidAppIdException) as ex:
return fire_raw_content(ex, 403)
else:
msg = parse_message(msg)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
else:
reply = create_reply(_('Welcome to follow our WeChat Official Accounts'), msg)
#frappe.enqueue('wechat.api.create_wechat_menu', app_name=app)
return fire_raw_content(crypto.encrypt_message(reply.render(), nonce, timestamp), 200, 'text/xml')
def Webpage(self):
self.TOKEN = self.oTOLL.get('wx_token','')
self.AES_KEY = self.oTOLL.get('wx_aeskey', '')
self.APPID = self.oTOLL.get('wx_appid', '')
signature = self.objHandle.args.get('signature', '')
timestamp = self.objHandle.args.get('timestamp', '')
nonce = self.objHandle.args.get('nonce', '')
encrypt_type = self.objHandle.args.get('encrypt_type', 'raw')
msg_signature = self.objHandle.args.get('msg_signature', '')
open_id = self.objHandle.args.get('openid', '')
try:
check_signature(self.TOKEN, signature, timestamp, nonce)
except Exception as e:
self.wx_log('验证失败:%s'%open_id, '%s' % e)
if encrypt_type == 'raw':
msg = parse_message(self.objHandle.data)
reply=create_reply('该公众号服务器故障，请休息一会再试', msg)
return reply.render()
return ''
if self.objHandle.method == 'GET':
echo_str = self.objHandle.args.get('echostr', '')
return echo_str
#self.wx_log('恭恭敬敬恭恭敬敬', 'aaaaaaaaaaaaaaaa')
# POST request
if encrypt_type == 'raw':
# plaintext mode
msg = parse_message(self.objHandle.data)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
elif msg.type == 'event':
if msg.event =='scan' or msg.event=='subscribe_scan':
if msg.scene_id == 'login_code' or msg.scene_id == 'register_code':
MSG = self.wx_code_msg(open_id)
reply = create_reply(MSG, msg)
else:
reply = create_reply('未知事件', msg)
else:
reply = create_reply('login_code666666', msg)
else:
reply = create_reply('Sorry, can not handle this for now', msg)
return reply.render()
else:
# encryption mode
from wechatpy.crypto import WeChatCrypto
crypto = WeChatCrypto(self.TOKEN, self.AES_KEY, self.APPID)
try:
msg = crypto.decrypt_message(
self.objHandle.data,
msg_signature,
timestamp,
nonce
)
except Exception as e:
self.wx_log('消息解密失败:%s' % open_id, '%s' % e)
else:
msg = parse_message(msg)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
elif msg.type == 'event':
if msg.event == 'scan' or msg.event == 'subscribe_scan':
if msg.scene_id == 'login_code' or msg.scene_id == 'register_code':
MSG = self.wx_code_msg(open_id)
reply = create_reply(MSG, msg)
else:
reply = create_reply('未知事件', msg)
else:
reply = create_reply('login_code666666', msg)
else:
reply = create_reply('Sorry, can not handle this for now11111111', msg)
return crypto.encrypt_message(reply.render(), nonce, timestamp)
def wechat():
signature = request.args.get("signature", "")
timestamp = request.args.get("timestamp", "")
nonce = request.args.get("nonce", "")
encrypt_type = request.args.get("encrypt_type", "raw")
msg_signature = request.args.get("msg_signature", "")
try:
check_signature(TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
abort(403)
if request.method == "GET":
echo_str = request.args.get("echostr", "")
return echo_str
# POST request
if encrypt_type == "raw":
# plaintext mode
date = (datetime.datetime.now() +
datetime.timedelta(days=-1)).strftime("%Y-%m-%d")
msg = parse_message(request.data)
# if msg.type == "text":
# reply = create_reply(msg.content, msg)
code = msg.content
if code[0] == '6':
code += ".XSHG"
strPePercent = JqDataSDKOperate.get_stock_pe_and_pb(
code, date, 2500)
strReply = code + "; " + strPePercent
reply = create_reply(strReply, msg)
return reply.render()
elif code[0] == '0' or code[0] == '3':
code += ".XSHE"
strPePercent = JqDataSDKOperate.get_stock_pe_and_pb(
code, date, 2500)
strReply = code + "; " + strPePercent
reply = create_reply(strReply, msg)
return reply.render()
# elif code == '行业':
elif code == '行业':
reply = ImageReply(message=msg)
reply.media_id = get_media_id(client, msg)
return reply.render()
# else:
# reply = create_reply("Sorry, can not handle this for now", msg)
# return reply.render()
else:
# encryption mode
from wechatpy.crypto import WeChatCrypto
crypto = WeChatCrypto(TOKEN, AES_KEY, APPID)
try:
msg = crypto.decrypt_message(request.data, msg_signature,
timestamp, nonce)
except (InvalidSignatureException, InvalidAppIdException):
abort(403)
else:
msg = parse_message(msg)
if msg.type == "text":
reply = create_reply(msg.content, msg)
else:
reply = create_reply("Sorry, can not handle this for now", msg)
return crypto.encrypt_message(reply.render(), nonce, timestamp)
def wechat():
signature = request.args.get('signature', '')
timestamp = request.args.get('timestamp', '')
nonce = request.args.get('nonce', '')
encrypt_type = request.args.get('encrypt_type', 'raw')
msg_signature = request.args.get('msg_signature', '')
try:
check_signature(TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
abort(403)
if request.method == 'GET':
echo_str = request.args.get('echostr', '')
return echo_str
# POST request
if encrypt_type == 'raw':
# plaintext mode
print("msg content "+request.data)
msg = parse_message(request.data)
if msg.type == 'text':
print('msg_content:', msg.content )
datacontent=json.loads(json.dumps(datajson))
fixup(datacontent,'data',msg.content.decode('unicode_escape'))
r=requests.post(url,json.dumps(datacontent))
print('push to iot device'+r.text)
if "errmsg" in r.text:
if json.loads(r.text)['errmsg']=='access_token expired' or 'access_token' in json.loads(r.text)['errmsg']:
fetch_app_access_token('wxc7ffbe44cacb90d0','a636227739200a71b1ec76be9e5bec81')
r=requests.post(url,json.dumps(datacontent))
print('again push to iot device'+r.text+'url:'+url)
reply = create_reply(msg.content, msg)
elif msg.type=='voice':
print('voice message '+str(msg.media_id)+ 'voice message '+str(msg.format)+'voice recognition '+str(msg.recognition))
data='{\"msg_type\":voice,\"media_id+\":'+msg.media_id+',\"format\":'+msg.format+'}'
datacontent=json.loads(json.dumps(datajson))
fixup(datacontent,'data',data)
r=requests.post(url,json.dumps(datacontent))
print('voice to iot device'+r.text)
if "errmsg" in r.text:
if json.loads(r.text)['errmsg']=='access_token expired':
fetch_app_access_token('wxc7ffbe44cacb90d0','a636227739200a71b1ec76be9e5bec81')
r=requests.post(url,json.dumps(datacontent))
print('again push to iot device'+r.text+'url:'+url)
reply=create_reply('voice message',msg)
else:
reply = create_reply('Sorry, can not handle this for now', msg)
return reply.render()
else:
# encryption mode
from wechatpy.crypto import WeChatCrypto
crypto = WeChatCrypto(TOKEN, AES_KEY, APPID)
try:
msg = crypto.decrypt_message(
request.data,
msg_signature,
timestamp,
nonce
)
except (InvalidSignatureException, InvalidAppIdException):
abort(403)
else:
msg = parse_message(msg)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
else:
reply = create_reply('Sorry, can not handle this for now', msg)
return crypto.encrypt_message(reply.render(), nonce, timestamp)
def wechat():
try:
signature = request.args.get('signature', '')
timestamp = request.args.get('timestamp', '')
nonce = request.args.get('nonce', '')
encrypt_type = request.args.get('encrypt_type', 'raw')
msg_signature = request.args.get('msg_signature', '')
try:
check_signature(WECHAT_TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
abort(403)
if request.method == 'GET':
echo_str = request.args.get('echostr', '')
return echo_str
# POST
if encrypt_type != 'raw':
crypto = WeChatCrypto(WECHAT_TOKEN, WECHAT_AES_KEY, WECHAT_APPID)
try:
msg = crypto.decrypt_message(request.data, msg_signature,
timestamp, nonce)
except (InvalidSignatureException, InvalidAppIdException):
abort(403)
else:
msg = request.data
# BIZ
msg = parse_message(msg)
if msg.type == 'image':
problem = process_image(msg.image)
logging.info(problem['question'])
result_arthur, reverse = RANKER.do_rank_answers(problem)
message = ' | '.join(
['%d-%s' % (r['count'], r['ans']) for r in result_arthur])
logging.info(message)
reply = create_reply(message, msg)
elif msg.type == 'voice':
logging.info(msg)
media_id = msg.media_id
client = WeChatClient(WECHAT_APPID, WECHAT_SECRET_KEY)
wechat_media = WeChatMedia(client)
url = wechat_media.get_url(media_id)
# Call baidu's asr
baidu_message = process_voice(url)
# Call xf's asr
xunfei_message = process_voice_xf(url)
message = '\n'.join([baidu_message, xunfei_message])
reply = create_reply(message, msg)
# # Call tencent's aai
# aai.call(url)
elif msg.type == 'text' and msg.content == 'qq':
global AAI_CACHE
reply = create_reply('\n'.join(AAI_CACHE), msg)
AAI_CACHE = []
else:
reply = create_reply('Sorry, can not handle this for now', msg)
# Render
if encrypt_type != 'raw':
return crypto.encrypt_message(reply.render(), nonce, timestamp)
else:
return reply.render()
except Exception as e:
import traceback
traceback.print_exc()
from wechatpy.crypto import WeChatCrypto
from wechatpy.crypto.cryptography import WeChatCipher
from wechatpy.crypto.pkcs7 import PKCS7Encoder
from wechatpy.utils import to_text
from wechatpy.replies import EmptyReply
from django.views.decorators.csrf import csrf_exempt
from wechat.models import WechatUser, Message, TextMessage
from twitter_image.models import ImageData
import logging
import base64
from django.core.cache import cache
from django.shortcuts import render, reverse
from wechat import actions
logger = logging.getLogger('wechat')
crypto = WeChatCrypto(settings.WECHAT_TOKEN, settings.WECHAT_AES_KEY,
settings.WECHAT_APPID)
imgs_cipher = WeChatCipher(crypto.key)
def serve_imgs(request, imgs):
if request.method == 'GET':
try:
plain_imgs = imgs_cipher.decrypt(base64.b64decode(imgs))
content = to_text(PKCS7Encoder.decode(plain_imgs))
token = content[:len(settings.WECHAT_TOKEN)]
if token != settings.WECHAT_TOKEN:
raise Exception('Invalid token.')
img_ids = list(
map(int, content[len(settings.WECHAT_TOKEN):].split(',')))
except:
return HttpResponseBadRequest()
def post(self, request, *args, **kwargs):
signature = request.GET.get("signature")
timestamp = request.GET.get("timestamp")
nonce = request.GET.get("nonce")
encrypt_type = request.GET.get("encrypt_type", "raw")
msg_signature = request.GET.get("msg_signature")
try:
check_signature(TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
pass
if encrypt_type == 'raw':
# plaintext mode
msg = parse_message(request.body)
if msg.type == 'text':
reply = create_reply(msg.content, msg)
else:
reply = create_reply('Sorry, can not handle this for now', msg)
return reply.render()
else:
# encryption mode
from wechatpy.crypto import WeChatCrypto
crypto = WeChatCrypto(TOKEN, AES_KEY, APPID)
try:
msg = crypto.decrypt_message(request.body, msg_signature,
timestamp, nonce)
except (InvalidSignatureException, InvalidAppIdException):
return HttpResponseBadRequest("Failed")
else:
msg = parse_message(msg)
response = "小助手无法识别输入的内容。\n" + CURRENT_MENU_TIP
if msg.type == "event":
if msg.event == SubscribeEvent.event:
response = SUBSCRIBE_TEXT + OPERATION_TIPS_TEXT
elif msg.type == 'text':
options = {
"help":
OPERATION_TIPS_TEXT,
"0":
self.get_tip_text,
"q":
self._clear_status,
"l":
"还没想好",
"m":
self.comment,
"w":
"在微信里点开：\nhttp://bythesea.cn\n\n用外部浏览器访问：\nhttps://jza.one"
}
self.msg = msg
_r = options.get(msg.content, "")
if _r:
if callable(_r):
response = _r()
elif isinstance(_r, str):
response = _r
else:
_s = rds.hget(redis_key(msg.source), "status")
logger.info(_s)
if _s is None:
if msg.content in ("1", ):
response = self.login_mode(init=True)
elif msg.content in ("2", ):
response = self.fast_mode(init=True)
elif _s in ("logged", "year", "semester"):
response = self.login_mode(init=False)
elif _s == "fast":
response = self.fast_mode(init=False)
elif _s.endswith("comment"):
response = self.comment(init=False)
elif _s in ("xh", "pw"):
response = self.login_mode()
reply = create_reply(response, msg)
encrypted_response = crypto.encrypt_message(
reply.render(), nonce, timestamp)
return HttpResponse(encrypted_response,
content_type="application/xml")
def messages_events_oper(request, oper_type, appid):
response = Response.ResponseObj()
# 消息与事件接收
if oper_type == 'callback':
timestamp = request.GET.get('timestamp')
nonce = request.GET.get('nonce')
msg_signature = request.GET.get('msg_signature')
postdata = request.body.decode(encoding='UTF-8')
# xml_tree = ET.fromstring(postdata)
# encrypt = xml_tree.find("Encrypt").text
print('==--------121111111111postdata-> ', postdata)
crypto = WeChatCrypto(encoding_token, encodingAESKey, encoding_appid)
decrypted_xml = crypto.decrypt_message(
postdata,
msg_signature,
timestamp,
nonce
)
DOMTree = xmldom.parseString(decrypted_xml)
collection = DOMTree.documentElement
MsgType = collection.getElementsByTagName("MsgType")[0].childNodes[0].data
print('Event------------Event-------> ', MsgType)
Event = collection.getElementsByTagName("Event")[0].childNodes[0].data
print('Event-1-> ', DOMTree)
print('Event-->2 ', collection)
print('Event--3> ', Event)
if MsgType == 'event': # api消息
ToUserName = collection.getElementsByTagName("ToUserName")[0].childNodes[0].data
FromUserName = collection.getElementsByTagName("FromUserName")[0].childNodes[0].data
CreateTime = collection.getElementsByTagName("CreateTime")[0].childNodes[0].data
# FailTime = collection.getElementsByTagName("FailTime")[0].childNodes[0].data
# ScreenShot = collection.getElementsByTagName("ScreenShot")[0].childNodes[0].data
if Event == 'weapp_audit_success': # 小程序审核通通过知
# 更新审核状态
applet_code_version_obj = models.AppletCodeVersion.objects.filter(applet__appid=ToUserName).order_by('-create_datetime')[0]
applet_code_version_obj.status = 0
applet_code_version_obj.save()
client_applet_objs = models.ClientApplet.objects.filter(appid=ToUserName)
user_id = client_applet_objs[0].user_id
nick_name = client_applet_objs[0].nick_name
msg = "微信小程序: %s 发布代码审核通过" % nick_name
message_inform.save_msg_inform(user_id, msg, is_send_admin=True)
# 审核通过之后,发布代码
tripartite_platform_objs = tripartite_platform() # 实例化三方平台
credential_expired_data = CredentialExpired(appid, 2) # 判断调用凭证是否过期 (操作 GZH/XCX 前调用该函数)
authorizer_access_token = credential_expired_data.get('authorizer_access_token')
tripartite_platform_objs.publish_approved_applets(authorizer_access_token)
msg = "微信小程序: %s 发布代码由系统发布上线成功" % nick_name
message_inform.save_msg_inform(user_id, msg, is_send_admin=True, only_send_admin=True) # 只发送给管理员
template_obj = client_applet_objs[0].template.objects.all()[0]
template_obj.tab_bar_data = template_obj.tab_bar_data_dev
template_obj.save()
page_objs = models.Page.objects.filter(page_group__template=template_obj)
for page_obj in page_objs:
page_obj.data = page_obj.data_dev
page_obj.save()
elif Event == 'weapp_audit_fail': # 小程序审核不通过
Reason = collection.getElementsByTagName("Reason")[0].childNodes[0].data
applet_code_version_obj = models.AppletCodeVersion.objects.filter(applet__appid=ToUserName).order_by('-create_datetime')[0]
applet_code_version_obj.status = 1
applet_code_version_obj.status = Reason
applet_code_version_obj.save()
client_applet_objs = models.ClientApplet.objects.filter(appid=ToUserName)
user_id = client_applet_objs[0].user_id
nick_name = client_applet_objs[0].nick_name
msg = "微信小程序: %s 发布代码审核不通过\n不通过原因: %s " % (nick_name, Reason)
message_inform.save_msg_inform(user_id, msg, is_send_admin=True)
elif Event == "SCAN":
pass
else:
content = collection.getElementsByTagName("Content")[0].childNodes[0].data
print('content--------> ', content)
else: # 文本消息
pass
return JsonResponse(response.__dict__)
def wechatHome(request):
# get signature, timestamp and nonce
signature = request.GET.get('signature')
timestamp = request.GET.get('timestamp')
nonce = request.GET.get('nonce')
encrypt_type = request.GET.get('encrypt_type')
msg_signature = request.GET.get('msg_signature')
try:
check_signature(TOKEN, signature, timestamp, nonce)
if request.method == 'GET':
response = request.GET.get('echostr')
return HttpResponse(response, content_type="application/json")
# POST request
if encrypt_type != None:
# encryption mode
print("request is encrypt")
from wechatpy.crypto import WeChatCrypto
crypto = WeChatCrypto(TOKEN, AES_KEY, APPID)
try:
# now msg is xml
msg = crypto.decrypt_message(request.body, msg_signature,
timestamp, nonce)
except (InvalidSignatureException, InvalidAppIdException):
HttpResponseBadRequest("decrypt message error")
else:
msg = request.body
# plaintext mode
print("before parse_message")
pprint.pprint(msg)
msg = wechatpy.parse_message(msg)
print("after parse_message")
pprint.pprint(msg)
if msg.type == 'text': # text message
reply = TextReply(message=msg)
reply.content = 'text reply'
elif msg.type == 'image':
reply = ImageReply(message=msg)
reply.media_id = msg.media_id
elif msg.type == 'voice':
reply = VoiceReply(message=msg)
reply.media_id = 'voice media id'
elif msg.type == 'video':
reply = VideoReply(message=msg)
reply.media_id = 'video media id'
reply.title = 'video title'
reply.description = 'video description'
elif msg.type == 'music':
reply = MusicReply(message=msg)
reply.thumb_media_id = 'thumb media id'
reply.title = 'music title'
reply.description = 'music description'
reply.music_url = 'music url'
reply.hq_music_url = 'hq music url'
elif msg.type == 'news':
reply = ArticlesReply(message=msg,
articles=[
{
'title': u'标题1',
'description': u'描述1',
'url': u'http://www.qq.com',
},
])
else:
reply = create_reply('Sorry, can not handle this for now', msg)
return HttpResponse(reply.render(), content_type="application/json")
except InvalidSignatureException as e:
print("check_signature failed")
HttpResponseBadRequest(e)
