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
msg = parse_message(request.data)
replies.EmptyReply().render()
reply = handler.handle_msg(msg, AppId, Secret)
return reply.render()
else:
# encryption mode
crypto = WeChatCrypto(TOKEN, EncodingAESKey, AppId)
try:
msg = crypto.decrypt_message(request.data, msg_signature,
timestamp, nonce)
except (InvalidSignatureException, InvalidAppIdException):
abort(403)
else:
msg = parse_message(msg)
reply = handler.handle_msg(msg, AppId, Secret)
return crypto.encrypt_message(reply.render(), nonce, timestamp)
def test_parse_subscribe_scan_product_event(self):
from wechatpy.events import SubscribeScanProductEvent
xml = """<xml>
<ToUserName><![CDATA[gh_fbe8a958756e]]></ToUserName>
<FromUserName><![CDATA[otAzGjrS4AYCmeJM1GhEOcHXXTAo]]></FromUserName>
<CreateTime>1433259128</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe]]></Event>
<EventKey><![CDATA[scanbarcode|keystandard|keystr]]></EventKey>
</xml>"""
msg = parse_message(xml)
self.assertTrue(isinstance(msg, SubscribeScanProductEvent))
self.assertEqual('scanbarcode', msg.scene)
self.assertEqual('keystandard', msg.standard)
self.assertEqual('keystr', msg.key)
xml = """<xml>
<ToUserName><![CDATA[gh_fbe8a958756e]]></ToUserName>
<FromUserName><![CDATA[otAzGjrS4AYCmeJM1GhEOcHXXTAo]]></FromUserName>
<CreateTime>1433259128</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe]]></Event>
<EventKey><![CDATA[scanimage|keystandard|keystr]]></EventKey>
</xml>"""
msg = parse_message(xml)
self.assertTrue(isinstance(msg, SubscribeScanProductEvent))
self.assertEqual('scanimage', msg.scene)
self.assertEqual('keystandard', msg.standard)
self.assertEqual('keystr', msg.key)
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
msg = parse_message(request.data)
reply = msg_handler(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)
reply = msg_handler(msg)
return crypto.encrypt_message(reply.render(), nonce, timestamp)
def test_parse_subscribe_scan_product_event(self):
from wechatpy.events import SubscribeScanProductEvent
xml = """<xml>
<ToUserName><![CDATA[gh_fbe8a958756e]]></ToUserName>
<FromUserName><![CDATA[otAzGjrS4AYCmeJM1GhEOcHXXTAo]]></FromUserName>
<CreateTime>1433259128</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe]]></Event>
<EventKey><![CDATA[scanbarcode|keystandard|keystr]]></EventKey>
</xml>"""
msg = parse_message(xml)
self.assertTrue(isinstance(msg, SubscribeScanProductEvent))
self.assertEqual('scanbarcode', msg.scene)
self.assertEqual('keystandard', msg.standard)
self.assertEqual('keystr', msg.key)
xml = """<xml>
<ToUserName><![CDATA[gh_fbe8a958756e]]></ToUserName>
<FromUserName><![CDATA[otAzGjrS4AYCmeJM1GhEOcHXXTAo]]></FromUserName>
<CreateTime>1433259128</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe]]></Event>
<EventKey><![CDATA[scanimage|keystandard|keystr]]></EventKey>
</xml>"""
msg = parse_message(xml)
self.assertTrue(isinstance(msg, SubscribeScanProductEvent))
self.assertEqual('scanimage', msg.scene)
self.assertEqual('keystandard', msg.standard)
self.assertEqual('keystr', msg.key)
def message_entries():
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(Config.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
msg = parse_message(request.data)
# 事件处理
if msg.type == 'event':
# 关注事件
if msg.event == 'subscribe':
mfc = MenuFunc(msg.source)
mfc.subscribecreatemenu()
reply = create_reply(msg.event, msg)
elif msg.type == 'text':
reply = create_reply(msg.content, msg)
elif msg.type == 'image':
reply = create_reply('对不起，暂时不支持图片消息', msg)
else:
reply = create_reply(msg.type, msg)
return reply.render()
else:
# encryption mode
from wechatpy.crypto import WeChatCrypto
crypto = WeChatCrypto(Config.TOKEN, Config.AES_KEY, Config.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
msg = parse_message(request.data)
if msg.type == "text":
# reply = create_reply(msg.content, msg)
str0 = msg.content;
if str0[0] == '6':
str0 += ".XSHG"
else:
str0 += ".XSHE"
myq = query(jqdatasdk.valuation).filter(jqdatasdk.valuation.code == str0)
df = jqdatasdk.get_fundamentals(myq, '2020-9-28')
str1 = df['pe_ratio']
str2 = df['pb_ratio']
str4 = '%s ' % str1
str5 = '%s' % str2
str6 = str4 + str5
reply = create_reply(str6, 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(club_name):
logger.debug(club_name)
query = request.args
logger.debug(query)
signature = query.get("signature", "")
timestamp = query.get("timestamp", "")
nonce = query.get("nonce", "")
logger.debug(request.args)
try:
check_signature(TOKEN, signature, timestamp, nonce)
except Exception as e:
logger.debug("invalid request!")
abort(403)
if request.method == "GET":
return make_response(request.args.get("echostr", ""))
else:
logger.debug("start make response")
encrypt_type = request.args.get("encrypt_type", "raw")
xml = request.data
msg = None
if encrypt_type == "raw":
# plain mode
logger.debug("plain mode")
msg = parse_message(xml)
else:
try:
# encrypt mode
crypto = WeChatCrypto(TOKEN, AES_KEY, APP_ID)
msg = parse_message(
crypto.decrypt_message(xml, signature, timestamp, nonce))
except Exception as e:
abort(403)
reply_xml = None
if msg.type == "text":
key_words = [item.strip() for item in str(msg.content).split(" ")]
articles = app_controller.search_club_service_article(
club_name, key_words)
for article in articles:
article["image"] = "{}{}".format(get_host(), article["image"])
article["url"] = "{}{}".format(get_host(), article["url"])
reply = ArticlesReply(articles=articles, message=msg)
reply_xml = reply.render()
else:
reply = TextReply(content="Not supported!", message=msg)
reply_xml = reply.render()
logger.debug("xml:" + reply_xml)
if encrypt_type == "raw":
return reply_xml
else:
return crypto.encrypt_message(reply_xml, nonce, timestamp)
def wechat():
print(request.args)
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", "")
is_test = request.args.get("test", False)
try:
if not is_test:
check_signature(TOKEN, signature, timestamp, nonce)
pass
except InvalidSignatureException:
abort(403)
if request.method == "GET":
print("got a get request")
echo_str = request.args.get("echostr", "")
return echo_str
# POST request
if encrypt_type == "raw":
# plaintext mode
msg = parse_message(request.data)
if msg.type == "text":
# if "你是谁" in msg.content:
# reply = create_reply("我是月光如水的夏夜，融化冰雪的深情", msg)
# elif "我是鸣夏" in msg.content:
# reply = create_reply("说啥都是爱你", msg)
# else:
# relpy_text = tuning_reply(msg.content)
print(msg.content)
relpy_text = task_controller(msg.content)
reply = create_reply(relpy_text, msg)
else:
reply = create_reply(introduction, 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(introduction, 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
msg = parse_message(request.data)
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, ENCODING_AES_KEY, APPID)
try:
msg = crypto.decrypt_message(request.data, msg_signature,
timestamp, nonce)
except (InvalidSignatureException, InvalidAppIdException):
abort(403)
else:
msg = parse_message(msg)
app.logger.info(msg)
if msg.type == 'text':
result = fetchone_by_name(msg.content)
if result:
reply_msg = category.get(result, "知不道")
else:
reply_msg = "抱歉, Feed还小，不知道“{0}”是什么垃圾".format(msg.content)
reply = create_reply(reply_msg, msg)
else:
reply = create_reply('Sorry, can not handle this for now', msg)
app.logger.info("test")
return crypto.encrypt_message("".join(reply.render().split()),
nonce, timestamp)
def wechat(request):
# GET 方式用于微信公众平台绑定验证
if request.method == 'GET':
signature = request.GET.get('signature', '')
timestamp = request.GET.get('timestamp', '')
nonce = request.GET.get('nonce', '')
echo_str = request.GET.get('echostr', '')
try:
check_signature(token, signature, timestamp, nonce)
except InvalidSignatureException:
echo_str = '错误的请求'
response = HttpResponse(echo_str)
return response
elif request.method == 'POST':
msg = parse_message(request.body)
if msg.type == 'text':
answer = query(msg.content) # TODO
reply = create_reply(answer, msg)
elif msg.type == 'image':
reply = create_reply('这是条图片消息', msg)
elif msg.type == 'voice':
reply = create_reply('这是条语音消息', msg)
else:
reply = create_reply('这是条其他类型消息', msg)
response = HttpResponse(reply.render(), content_type="application/xml")
return response
def handle_msg(request):
if request.method == 'GET':
signature = request.GET.get('signature')
timestamp = request.GET.get('timestamp')
nonce = request.GET.get('nonce')
echo_str = request.GET.get('echostr')
check_signature(TOKEN, signature, timestamp, nonce)
return HttpResponse(echo_str)
elif request.method == 'POST':
body = request.body
msg = parse_message(body)
rep = TextReply()
rep.source = msg.target
rep.target = msg.source
if msg.type == 'event':
if msg.event == 'click':
print(msg.key)
if msg.key == 'sports_advice':
rep.content = recommend_plan(msg.source)
elif msg.key == 'view_info':
rep.content = get_info(msg.source)
elif msg.key == 'add_test':
rep.content = add_test(msg.source)
elif msg.key == 'show_today':
rep.content = get_datatoday(msg.source)
elif msg.event == 'subscribe':
rep.content = create_newuser(msg.source)
else:
rep.content = '!!!'
else:
rep.content = '<a href="http://learn.tsinghua.edu.cn">你好</a>'
repxml = rep.render()
return HttpResponse(repxml)
def wechat_verify():
'''
用来处理微信服务器对本后台的验证，GET方法。
:return:
'''
# POST 方式用于接受被动消息
if request.method == 'POST':
msg = parse_message(request.get_data())
# print("开发者服务收到的消息:", msg.scene_id)
# 处理方法
handleWxEvent(msg)
return 'ok'
if request.method == 'GET':
# 获取参数
rq_dict = request.args
if len(rq_dict) == 0:
return ""
tuple_args = get_all_args(rq_dict)
token = '123456'
try:
check_signature(token, tuple_args[1], tuple_args[2], tuple_args[3])
except InvalidSignatureException as e:
logger.error(e, exc_info=True)
return ''
else:
return tuple_args[0]
def text_handle(request):
msg = parse_message(request.body)
reply = TextReply(message=msg)
content = msg.content
new_uid = reply.target
if content == "来数据":
views.update_database_randomly(new_uid)
return HttpResponse(create_reply("注入了数据！", message=msg))
elif content == "xp好帅":
views.test2(new_uid)
return HttpResponse(create_reply("获得了浇水次数和施肥次数！！", message=msg))
if new_uid in sessions and sessions[new_uid] == 1:
if content == "退出":
sessions[reply.target] = 0
return HttpResponse(create_reply("生命之树期待与您再次相会", message=msg))
rebot_key = "da0d72f6aacebe4301f685e2c11f22c0"
url = "http://www.tuling123.com/openapi/api?key=%s&info=%s" % (rebot_key,urllib.parse.quote(content))
# return HttpResponse(create_reply(u"生命之树期待与您再次相会", message=msg))
response = urllib.request.urlopen(url).read() #调用urllib2向服务器发送get请求url
reply_text = json.loads(response.decode("utf-8"))['text']
reply_text.replace('图灵机器人','生命之树')
# reply_text.replace(u'图灵机器人'.encode('utf-8'),u'生命之树')
return HttpResponse(create_reply(reply_text, message=msg))
if(views.check_band_user(new_uid) == False):
views.insert_band_user(new_uid)
return HttpResponse(create_reply(u"太平洋手环保太平，欢迎您使用太平洋手环！", message=msg))
else:
return HttpResponse(create_reply(u"欢迎您重归太平洋手环！", message=msg))
def test_template_subscribe_msg_popup_event(self):
from wechatpy.events import SubscribeMsgPopupEvent
xml = """<xml>
<ToUserName><![CDATA[gh_123456789abc]]></ToUserName>
<FromUserName><![CDATA[otFpruAK8D-E6EfStSYonYSBZ8_4]]></FromUserName>
<CreateTime>1610969440</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe_msg_popup_event]]></Event>
<SubscribeMsgPopupEvent>
<List>
<TemplateId><![CDATA[VRR0UEO9VJOLs0MHlU0OilqX6MVFDwH3_3gz3Oc0NIc]]></TemplateId>
<SubscribeStatusString><![CDATA[accept]]></SubscribeStatusString>
<PopupScene>2</PopupScene>
</List>
<List>
<TemplateId><![CDATA[9nLIlbOQZC5Y89AZteFEux3WCXRRRG5Wfzkpssu4bLI]]></TemplateId>
<SubscribeStatusString><![CDATA[reject]]></SubscribeStatusString>
<PopupScene>2</PopupScene>
</List>
</SubscribeMsgPopupEvent>
</xml>"""
event = parse_message(xml)
self.assertIsInstance(event, SubscribeMsgPopupEvent)
self.assertEqual(2, len(event.subscribes))
self.assertEqual("VRR0UEO9VJOLs0MHlU0OilqX6MVFDwH3_3gz3Oc0NIc",
event.subscribes[0]["TemplateId"])
def handle_wx(request):
# GET方式用于微信公众平台绑定验证
if request.method == 'GET':
signature = request.GET.get('signature', '')
timestamp = request.GET.get('timestamp', '')
nonce = request.GET.get('nonce', '')
echostr = request.GET.get('echostr', '')
try:
check_signature(TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
echostr = 'error'
response = HttpResponse(echostr, content_type="text/plain")
return response
else:
msg = parse_message(request.body)
print(msg)
# 判断文本消息类型,文本消息处理
if msg.type == 'text':
reply = do_reply(msg)
elif msg.type == 'voice':
voice_trans()
reply = create_reply('还没识别出来,稍等...', msg)
elif msg.type == 'event':
reply = do_event(msg)
response = HttpResponse(reply.render(),
content_type='application/html')
return response
def weixin_main(request):
if request.method == "GET":
#接收微信服务器get请求发过来的参数
signature = request.GET.get('signature', None)
timestamp = request.GET.get('timestamp', None)
nonce = request.GET.get('nonce', None)
echostr = request.GET.get('echostr', None)
#服务器配置中的token
token = 'qiqi123'
#把参数放到list中排序后合成一个字符串，再用sha1加密得到新的字符串与微信发来的signature对比，如果相同就返回echostr给服务器，校验通过
hashlist = [token, timestamp, nonce]
hashlist.sort()
hashstr = ''.join([s for s in hashlist]).encode('utf-8')
hashstr = hashlib.sha1(hashstr).hexdigest()
if hashstr == signature:
return HttpResponse(echostr)
else:
return HttpResponse("error")
else:
# othercontent = autoreply(request)
# return HttpResponse(othercontent)
msg = parse_message(request.body)
if msg.type == 'text':
title, text = get_title_text()
print(text)
reply = create_reply(text, msg)
elif msg.type == 'image':
reply = create_reply('这是条图片消息', msg)
elif msg.type == 'voice':
reply = create_reply('这是条语音消息', msg)
else:
reply = create_reply('这是条其他类型消息', msg)
response = HttpResponse(reply.render(), content_type="application/xml")
return response
def decrypt_and_parse_message(cls, xml: str, msg_signature: str, timestamp: str, nonce: str):
if msg_signature:
try:
xml = cls.we_crypto.decrypt_message(msg=xml, signature=msg_signature, timestamp=timestamp, nonce=nonce)
except (InvalidAppIdException, InvalidSignatureException) as e:
raise e
return parse_message(xml)
def on_post(self, req, resp):
xml = req.stream.read()
msg = parse_message(xml)
if msg.type == 'text':
content = msg.content
if content.isdigit():
text = Connect().get_url(content)
reply = TextReply(content=text, message=msg)
elif content == '一言':
text = Connect().hitokoto()
reply = TextReply(content=text, message=msg)
elif content == 'anime':
text = Connect().bangumi()
reply = TextReply(content=text, message=msg)
elif content == '迅雷':
text = 'Android:\nhttp://suo.im/5WbiD4\niOS(用自带Safari打开):\nhttps://ithunder-ota.a.88cdn.com/download-guide/step1.html?from=gzhlm'
reply = TextReply(content=text, message=msg)
elif content == '哔咔':
text = '浏览器打开(包括iOS和Android):\nhttps://download2.picacomiccn.xyz'
reply = TextReply(content=text, message=msg)
else:
return '' # 对其他文本不作回复 https://github.com/wechatpy/wechatpy/issues/161
elif msg.type == 'event' and msg.event == 'subscribe':
help = "谢谢关注!\n\n" \
"1. 在对话框输入'哔咔', 获取哔咔下载地址\n\n" \
"2. 输入'迅雷', 获取迅雷下载地址\n\n" \
"3. 输入'一言', 可以看到一句台词\n\n" \
"4. 输入'anime', 查看今天更新的番剧\n\n" \
"5. 输入b站直播房间号, 如'1017', 可以查看当前主播是否在线"
reply = TextReply(content=help, message=msg)
else:
reply = TextReply(content="只支持文字消息", message=msg)
xml = reply.render()
resp.body = xml
resp.status = falcon.HTTP_200
def wechat(request):
if request.method == 'GET':
signature = request.GET.get('signature', '')
timestamp = request.GET.get('timestamp', '')
nonce = request.GET.get('nonce', '')
echo_str = request.GET.get('echostr', '')
try:
check_signature(WECHAT_TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
echo_str = 'error'
response = HttpResponse(echo_str, content_type="text/plain")
return response
elif request.method == 'POST':
msg = parse_message(request.body)
if msg.type == 'text':
reply = handle_message(msg)
elif msg.type == 'image':
reply = create_reply('这是条图片消息，暂时还不能处理该类型消息', msg)
elif msg.type == 'voice':
reply = create_reply('这是条语音消息，暂时还不能处理该类型消息', msg)
else:
# 关注/取消关注的时候
reply = handle_message(msg)
response = HttpResponse(reply.render(), content_type="application/xml")
return response
else:
print('不存在的方法')
def token():
if request.method == 'GET':
signature = request.args.get('signature')
timestamp = request.args.get('timestamp')
nonce = request.args.get('nonce')
echo_str = request.args.get('echostr') # echo_str是微信用来验证服务器的参数，需原样返回
print(signature, timestamp, nonce, echo_str)
try:
print('正在验证服务器签名')
# 无法验证成功？？？
# check_signature(token, signature, timestamp, nonce)
print('验证签名成功')
except InvalidSignatureException as e:
print('检查签名出错: '.format(e))
return 'Check Error'
return echo_str
# POST
print('开始处理用户消息')
msg = parse_message(request.data)
reply_text = handle_msg(msg)
reply = TextReply(message=msg)
reply.content = reply_text
return reply.render()
def on_post(self, req, resp):
xml = req.stream.read()
msg = parse_message(xml)
if msg.type != 'text' and msg.type != 'voice':
return
if msg.type == 'text':
if "收到不支持的消息类型" in msg.content:
return
received_text = msg.content
elif msg.type == 'voice':
voice = client.media.download(msg.media_id)
save_voice(voice.content, VOICE_PATH)
received_text = msg.recognition
data = {"sender": msg.source, "message": received_text}
r = requests.post(CHATBOT_URL, data=json.dumps(data))
reply = [one["text"] for one in json.loads(r.content)]
answer = "\n".join(reply)
if msg.type == 'text':
text_reply = create_reply(answer, message=msg)
elif msg.type == 'voice':
text_reply = create_reply("问：{}\n\n答：{}".format(
received_text, answer),
message=msg)
xml = text_reply.render()
resp.body = (xml)
resp.status = falcon.HTTP_200
def wechat():
xml = request.stream.read()
msg = parse_message(xml)
print(msg)
if msg.type == 'event':
if isinstance(msg, SubscribeEvent):
reply = subscribeevent_handle(msg)
else:
reply = create_reply('暂不支持其它事件', message=msg)
elif msg.type == 'text':
reply = text_handler(msg, msg.content)
elif msg.type == 'image':
reply = create_reply('图片好好哟', message=msg)
elif msg.type == 'voice':
reply = text_handler(msg, msg.recognition)
elif msg.type == 'video':
reply = create_reply('视频挺不错哟', message=msg)
# elif msg.type in ['location','link']:
# pass
else:
reply = create_reply('暂不支持处理link和location', message=msg)
# 转换成 XML
xml = reply.render()
return xml
def weixinCheck(request):
'''
所有的消息都会先进入这个函数进行处理，函数包含两个功能，
微信接入验证是GET方法，
微信正常的收发消息是用POST方法。
:param request:
:return:
'''
if request.method == 'GET':
signature = request.GET.get("signature", None)
timestamp = request.GET.get("timestamp", None)
nonce = request.GET.get("nonce", None)
echostr = request.GET.get("echostr", None)
token = WEIXIN_TOKEN
print('进来了')
try:
check_signature(token, signature, timestamp, nonce)
return HttpResponse(request.GET.get('echostr', ''),
content_type="text/plain")
except InvalidSignatureException:
# 处理异常情况或忽略
print('验证失败')
elif request.method == 'POST':
xml_message = smart_str(request.body)
msg = parse_message(xml_message)
reply = TextReply(content='你好，这是测试', message=msg)
xml_respose = reply.render()
return HttpResponse(xml_respose, content_type="application/xml")
def index(request):
if request.method == 'GET':
signature = request.GET.get('signature', '')
timestamp = request.GET.get('timestamp', '')
nonce = request.GET.get('nonce', '')
echostr = request.GET.get('echostr', '')
try:
check_signature(TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
echostr = 'error'
response = HttpResponse(echostr, content_type="text/plain")
return response
elif request.method == 'POST':
reply = None
msg = parse_message(request.body)
if msg.type == 'text':
if msg.content == '探针价格':
reply = create_reply(price_result(), msg)
else:
reply = create_reply(query_result(msg.content), msg)
elif msg.event == 'subscribe':
reply = create_reply(
'感谢关注天津市肿瘤医院病理科FISH检测公众号。点击https://jinshuju.net/f/iuoJBo登记患者信息',
msg)
response = HttpResponse(reply.render(), content_type='application/xml')
return response
else:
return HttpResponse('ERROR')
def wechatIndex():
token = current_app.config.get('WECHAT_TOKEN')
encoding_aes_key = current_app.config.get('WECHAT_AESKEY')
encrypt_mode = current_app.config.get('WECHAT_ENC_MODE')
signature = request.args.get('signature', "")
timestamp = request.args.get('timestamp', "")
nonce = request.args.get('nonce', "")
encrypt_type = request.args.get('encrypt_type', 'raw')
try:
check_signature(token, signature, timestamp, nonce)
except InvalidSignatureException:
abort(403)
if request.method == 'GET':
echo_str = request.args.get('echostr', '')
return echo_str
else:
if encrypt_type == 'raw':
# plaintext mode
msg = parse_message(request.data)
print msg.type
if msg.type == 'text':
reply = create_reply(msg.content, msg)
elif msg.type == 'event':
# evt = events.SubscribeEvent(msg)
print msg.source
reply = create_reply(msg.source, msg)
else:
reply = create_reply('Sorry, can not handle this for now', msg)
return reply.render()
def index(request):
'''
微信服务器授权
'''
if request.method == 'GET':
signature = request.GET.get('signature', '')
timestamp = request.GET.get('timestamp', '')
nonce = request.GET.get('nonce', '')
echo_str = request.GET.get('echostr', '')
try:
check_signature(settings.WECHAT_APP_TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
echo_str = 'error'
return HttpResponse(echo_str, content_type="text/plain")
else:
reply = None
msg = parse_message(request.body)
if msg.type == 'text': # 文本消息
reply = doreply_text(msg)
elif msg.type == 'event': # 事件消息
reply = doreply_event(msg)
if not reply or not isinstance(reply, BaseReply):
reply = create_reply('程序猿哥哥正在开发中', msg)
return HttpResponse(reply.render(), content_type="application/xml")
def test_pic_sysphoto_event(self):
from wechatpy.events import PicSysPhotoEvent
xml = """<xml>
<ToUserName><![CDATA[gh_e136c6e50636]]></ToUserName>
<FromUserName><![CDATA[oMgHVjngRipVsoxg6TuX3vz6glDg]]></FromUserName>
<CreateTime>1408090651</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[pic_sysphoto]]></Event>
<EventKey><![CDATA[6]]></EventKey>
<SendPicsInfo><Count>1</Count>
<PicList>
<item>
<PicMd5Sum><![CDATA[1b5f7c23b5bf75682a53e7b6d163e185]]></PicMd5Sum>
</item>
</PicList>
</SendPicsInfo>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, PicSysPhotoEvent))
self.assertEqual(1, event.count)
self.assertEqual('1b5f7c23b5bf75682a53e7b6d163e185',
event.pictures[0]['PicMd5Sum'])
def test_pic_photo_or_album_event(self):
from wechatpy.events import PicPhotoOrAlbumEvent
xml = """<xml>
<ToUserName><![CDATA[gh_e136c6e50636]]></ToUserName>
<FromUserName><![CDATA[oMgHVjngRipVsoxg6TuX3vz6glDg]]></FromUserName>
<CreateTime>1408090816</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[pic_photo_or_album]]></Event>
<EventKey><![CDATA[6]]></EventKey>
<SendPicsInfo><Count>1</Count>
<PicList>
<item>
<PicMd5Sum><![CDATA[5a75aaca956d97be686719218f275c6b]]></PicMd5Sum>
</item>
</PicList>
</SendPicsInfo>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, PicPhotoOrAlbumEvent))
self.assertEqual(1, event.count)
self.assertEqual('5a75aaca956d97be686719218f275c6b',
event.pictures[0]['PicMd5Sum'])
def test_location_select_event(self):
from wechatpy.events import LocationSelectEvent
xml = """<xml>
<ToUserName><![CDATA[gh_e136c6e50636]]></ToUserName>
<FromUserName><![CDATA[oMgHVjngRipVsoxg6TuX3vz6glDg]]></FromUserName>
<CreateTime>1408091189</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[location_select]]></Event>
<EventKey><![CDATA[6]]></EventKey>
<SendLocationInfo><Location_X><![CDATA[23]]></Location_X>
<Location_Y><![CDATA[113]]></Location_Y>
<Scale><![CDATA[15]]></Scale>
<Label><![CDATA[广州市海珠区客村艺苑路 106号]]></Label>
<Poiname><![CDATA[]]></Poiname>
</SendLocationInfo>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, LocationSelectEvent))
self.assertEqual(('23', '113'), event.location)
self.assertEqual('15', event.scale)
self.assertTrue(event.poiname is None)
self.assertEqual('广州市海珠区客村艺苑路 106号', event.label)
def reply(request):
if request.method == 'GET':
signature = request.GET.get('signature', '')
timestamp = request.GET.get('timestamp', '')
nonce = request.GET.get('nonce', '')
echo_str = request.GET.get('echostr', '')
try:
check_signature(token, signature, timestamp, nonce)
except InvalidSignatureException:
echo_str = 'error'
response = HttpResponse(echo_str, content_type="text/plain")
return response
elif request.method == 'POST':
msg = parse_message(request.body)
if msg.type == 'text':
disposeObj = dispose()
replyContent = disposeObj.run(msg.content)
reply = create_reply(replyContent, msg)
elif msg.type == 'image':
reply = create_reply('这是条图片消息', msg)
elif msg.type == 'voice':
disposeObj = dispose()
replyContent = disposeObj.run(msg.recognition)
reply = create_reply(replyContent, msg)
else:
reply = create_reply('这是条其他类型消息', msg)
response = HttpResponse(reply.render(), content_type="application/xml")
return response
else:
logger.info('--------------------------------')
def test_pic_sysphoto_event(self):
from wechatpy.events import PicSysPhotoEvent
xml = """<xml>
<ToUserName><![CDATA[gh_e136c6e50636]]></ToUserName>
<FromUserName><![CDATA[oMgHVjngRipVsoxg6TuX3vz6glDg]]></FromUserName>
<CreateTime>1408090651</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[pic_sysphoto]]></Event>
<EventKey><![CDATA[6]]></EventKey>
<SendPicsInfo><Count>1</Count>
<PicList>
<item>
<PicMd5Sum><![CDATA[1b5f7c23b5bf75682a53e7b6d163e185]]></PicMd5Sum>
</item>
</PicList>
</SendPicsInfo>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, PicSysPhotoEvent))
self.assertEqual(1, event.count)
self.assertEqual(
'1b5f7c23b5bf75682a53e7b6d163e185',
event.pictures[0]['PicMd5Sum']
)
def test_pic_photo_or_album_event(self):
from wechatpy.events import PicPhotoOrAlbumEvent
xml = """<xml>
<ToUserName><![CDATA[gh_e136c6e50636]]></ToUserName>
<FromUserName><![CDATA[oMgHVjngRipVsoxg6TuX3vz6glDg]]></FromUserName>
<CreateTime>1408090816</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[pic_photo_or_album]]></Event>
<EventKey><![CDATA[6]]></EventKey>
<SendPicsInfo><Count>1</Count>
<PicList>
<item>
<PicMd5Sum><![CDATA[5a75aaca956d97be686719218f275c6b]]></PicMd5Sum>
</item>
</PicList>
</SendPicsInfo>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, PicPhotoOrAlbumEvent))
self.assertEqual(1, event.count)
self.assertEqual(
'5a75aaca956d97be686719218f275c6b',
event.pictures[0]['PicMd5Sum']
)
def test_parse_submit_invoice_title_event(self):
""" Test parsing xml for SubmitInvoiceTitleEvent """
from wechatpy.events import SubmitInvoiceTitleEvent
xml = """<xml>
<ToUserName><![CDATA[gh_fc0a06a20993]]></ToUserName>
<FromUserName><![CDATA[oZI8Fj040-be6rlDohc6gkoPOQTQ]]></FromUserName>
<CreateTime>1475134700</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[submit_invoice_title]]></Event>
<title><![CDATA[样例公司抬头]]></title>
<tax_no><![CDATA[1486715661]]></tax_no>
<addr><![CDATA[abc]]></addr>
<phone><![CDATA[13313331333]]></phone>
<bank_type><![CDATA[bt]]></bank_type>
<bank_no><![CDATA[bn]]></bank_no>
<attach><![CDATA[at]]></attach>
<title_type><![CDATA[InvoiceUserTitleBusinessType]]></title_type>
</xml>"""
msg = parse_message(xml)
self.assertTrue(isinstance(msg, SubmitInvoiceTitleEvent))
self.assertEqual('样例公司抬头', msg.title)
self.assertEqual('1486715661', msg.tax_no)
self.assertEqual('abc', msg.addr)
self.assertEqual('13313331333', msg.phone)
self.assertEqual('bt', msg.bank_type)
self.assertEqual('bn', msg.bank_no)
self.assertEqual('at', msg.attach)
self.assertEqual('InvoiceUserTitleBusinessType', msg.title_type)
def test_location_select_event(self):
from wechatpy.events import LocationSelectEvent
xml = """<xml>
<ToUserName><![CDATA[gh_e136c6e50636]]></ToUserName>
<FromUserName><![CDATA[oMgHVjngRipVsoxg6TuX3vz6glDg]]></FromUserName>
<CreateTime>1408091189</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[location_select]]></Event>
<EventKey><![CDATA[6]]></EventKey>
<SendLocationInfo><Location_X><![CDATA[23]]></Location_X>
<Location_Y><![CDATA[113]]></Location_Y>
<Scale><![CDATA[15]]></Scale>
<Label><![CDATA[广州市海珠区客村艺苑路 106号]]></Label>
<Poiname><![CDATA[]]></Poiname>
</SendLocationInfo>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, LocationSelectEvent))
self.assertEqual(('23', '113'), event.location)
self.assertEqual('15', event.scale)
self.assertTrue(event.poiname is None)
self.assertEqual('广州市海珠区客村艺苑路 106号', event.label)
def wechat_handler():
try:
token = current_app.config['WECHAT_TOEKN']
signature = request.args.get('signature')
timestamp = request.args.get('timestamp')
nonce = request.args.get('nonce')
check_signature(token, signature, timestamp, nonce)
current_app.logger.info('wechat_handler begin')
body = request.get_data()
current_app.logger.info('wechat_handler body %s' % body)
msg = parse_message(body)
if msg.type == 'text':
return reply_msg(msg)
elif msg.type == 'event' and msg.event == 'click' and msg.key == 'V2003_SignIn':
return sign_in(msg)
elif msg.type == 'event' and msg.event in ['subscribe_scan', 'scan'] and msg.scene_id == '123':
binding(msg)
if msg.event == 'subscribe_scan':
return welcome_article(msg)
elif msg.type == 'event' and msg.event == 'unsubscribe':
unsubscribe_unbinding(msg)
elif msg.type == 'event' and msg.event == 'subscribe':
return welcome_article(msg)
reply = EmptyReply()
return reply.render()
except InvalidSignatureException:
abort(404)
except Exception as e:
current_app.logger.exception('wechat_handler %s' % e)
reply = EmptyReply()
return reply.render()
def post(self):
msg = parse_message(request.data)
# 是文本消息
if msg.type == 'text':
reply = TextReply(message=msg)
reply.content = 'text reply'
xml = reply.render()
return xml
# 事件类型消息
elif msg.type == 'event':
# 处理菜单点击事件
if msg.event == 'click':
# MenuClick是自定义类，处理菜单点击事件
click = MenuClick(msg)
return click.menu_click()
# 其他类型的事件消息不处理
else:
reply = TextReply(message=msg)
reply.content = 'event未知'
xml = reply.render()
return xml
# 其他消息
else:
reply = TextReply(message=msg)
reply.content = '未知操作'
xml = reply.render()
return xml
def wechat(request):
if request.method == 'GET':
signature = request.GET.get('signature', '')
timestamp = request.GET.get('timestamp', '')
nonce = request.GET.get('nonce', '')
echo_str = request.GET.get('echostr', '')
try:
check_signature(WECHAT_TOKEN, signature, timestamp, nonce)
except InvalidSignatureException:
echo_str = 'error'
response = HttpResponse(echo_str, content_type="text/plain")
# createMenu(client)
return response
elif request.method == 'POST':
msg = parse_message(request.body)
if msg.type == 'text':
reply = create_reply('这是条文字消息', msg)
elif msg.type == 'image':
reply = create_reply('这是条图片消息', msg)
elif msg.type == 'voice':
reply = create_reply('这是条语音消息', msg)
else:
reply = create_reply('这是条其他类型消息', msg)
response = HttpResponse(reply.render(), content_type="application/xml")
return response
else:
logger.info('--------------------------------')
def time_out_reply(event):
event = re.sub(r'\<xml\>', '<xml>\n', event)
xml = event
msg = parse_message(xml)
reply = TextReply(content='【系统已激活，请再次提问】', message=msg)
resp = apiReply(reply, txt=True, content_type="application/xml")
return resp
def wexin(request):
WEIXIN_TPKEN = 'douxinyi20130819'
if request.method == "GET":
signature = request.GET.get("signature",None)
timestamp = request.GET.get("timestamp", None)
nonce = request.GET.get("nonce", None)
echostr = request.GET.get("echostr", None)
token = WEIXIN_TPKEN
try:
check_signature(WEIXIN_TPKEN,signature,timestamp,nonce)
except InvalidSignatureException:
echostr = 'error'
return HttpResponse(echostr,content_type="text/plain")
elif request.method == "POST":
msg = parse_message(request.body)
if msg.type == 'text':
repr = create_reply('这是条文字消息', msg)
elif msg.type == 'image':
repr = create_reply('这是条图片消息', msg)
elif msg.type == 'voice':
repr = create_reply('这是条语音消息', msg)
else:
repr = create_reply('这是条其他类型消息', msg)
return HttpResponse(repr.render(),content_type='application/xml')
else:
pass
def handle(request):
if request.method == "GET":
if not tools.checkSignature(request):
return HttpResponse("invalid signature")
else:
return HttpResponse(request.GET["echostr"])
msg = parse_message(request.body)
return msg_splitter[msg.type](msg)
def _wechat_required(method, *args, **kwargs):
from wechatpy.crypto import WeChatCrypto
from wechatpy import parse_message
signature = request.args.get('signature')
timestamp = request.args.get('timestamp')
nonce = request.args.get('nonce')
if not current_app.config.get('WECHAT_TOKEN'):
return abort(500, "Token is None")
token = current_app.config['WECHAT_TOKEN']
try:
check_signature(token, signature, timestamp, nonce)
except InvalidSignatureException:
current_app.logger.warning('check signature failed.')
return abort(403)
if request.method == 'GET':
return request.args.get('echostr', '')
raw_msg = request.data
current_app.logger.debug(raw_msg)
if current_app.config.get('WECHAT_AES_KEY'):
crypto = WeChatCrypto(
current_app.config['WECHAT_TOKEN'],
current_app['WECHAT_AES_KEY'],
current_app.config['WECHAT_APPID']
)
try:
raw_msg = crypto.decrypt_message(
raw_msg,
signature,
timestamp,
nonce
)
except (InvalidAppIdException, InvalidSignatureException):
current_app.logger.warning('decode message failed.')
return abort(403)
request.wechat_msg = parse_message(raw_msg)
res = method(*args, **kwargs)
xml = ''
if isinstance(res, BaseReply):
xml = res.render()
if current_app.config.get('WECHAT_AES_KEY'):
crypto = WeChatCrypto(
current_app.config['WECHAT_TOKEN'],
current_app.config['WECHAT_AES_KEY'],
current_app.config['WECHAT_APPID']
)
xml = crypto.encrypt_message(xml, nonce, timestamp)
return xml
def index():
# print request.args
# print json.dumps(request.args)
if request.method == 'GET':
data = request.args
signature = data.get('signature')
timestamp = data.get('timestamp')
nonce = data.get('nonce')
echostr = data.get('echostr')
token = current_app.config.get('TOKEN')
try:
check_signature(token, signature, timestamp, nonce)
except InvalidSignatureException:
return 'invalid signature'
return echostr
else:
xml = request.data
print xml
msg = parse_message(xml)
if msg.type == 'text':
print msg.content
reply = TextReply(message=msg)
reply.content = u'reply 测试'
xml_reply = reply.render()
return xml_reply
elif msg.type == 'image':
reply = ImageReply(message=msg)
reply.media_id = msg.media_id
xml_reply = reply.render()
return xml_reply
elif msg.type == 'voice':
# reply = VoiceReply(message=msg)
# reply.media_id = msg.media_id
reply = TextReply(message=msg)
reply.content = msg.recognition
xml_reply = reply.render()
return xml_reply
elif msg.type == 'video':
reply = VideoReply(message=msg)
reply.media_id = msg.media_id
reply.title = u'你的video'
reply.description = u'wo 爱倪呀'
xml_reply = reply.render()
return xml_reply
pass
elif msg.type == 'location':
pass
elif msg.type == 'link':
pass
elif msg.type == 'shortvideo':
reply = VideoReply(message=msg)
reply.media_id = msg.thumb_media_id
reply.title = u'你的video'
reply.description = u'wo 爱倪呀'
xml_reply = reply.render()
return xml_reply
else:
return ''
def post(self, request):
try:
req_text = request.body.decode('utf-8')
msg = parse_message(req_text)
except Exception as e:
logger.exception('Illegal message from weixin: \n%s', req_text)
return HttpResponse('Illegal message from weixin: \n%s' % req_text)
wechat_resp = handle_message(msg)
return HttpResponse(wechat_resp, content_type='text/xml; charset=utf-8')
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
msg = parse_message(request.data)
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.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 _enterprise_wechat_required(method, *args, **kwargs):
from wechatpy.enterprise import parse_message
from wechatpy.enterprise.crypto import WeChatCrypto
from wechatpy.enterprise.exceptions import InvalidCorpIdException
signature = request.args.get('msg_signature')
timestamp = request.args.get('timestamp')
nonce = request.args.get('nonce')
if not current_app.config.get('WECHAT_TOKEN'):
return abort(500, "Token is None")
crypto = WeChatCrypto(
current_app.config['WECHAT_TOKEN'],
current_app['WECHAT_AES_KEY'],
current_app.config['WECHAT_APPID']
)
if request.method == 'GET':
echo_str = request.args.get('echostr')
try:
echo_str = crypto.check_signature(
signature,
timestamp,
nonce,
echo_str
)
except InvalidSignatureException:
abort(403)
return echo_str
try:
msg = crypto.decrypt_message(
request.data,
signature,
timestamp,
nonce,
)
except (InvalidSignatureException, InvalidCorpIdException):
return abort(403)
else:
request.wechat_msg = parse_message(msg)
res = method(*args, **kwargs)
xml = ''
if isinstance(res, BaseReply):
xml = res.render()
crypto = WeChatCrypto(
current_app.config['WECHAT_TOKEN'],
current_app.config['WECHAT_AES_KEY'],
current_app.config['WECHAT_APPID']
)
xml = crypto.encrypt_message(xml, nonce, timestamp)
return xml
def test_parse_text_message(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[fromUser]]></FromUserName>
<CreateTime>1348831860</CreateTime>
<MsgType><![CDATA[text]]></MsgType>
<Content><![CDATA[this is a test]]></Content>
<MsgId>1234567890123456</MsgId>
</xml>"""
msg = parse_message(xml)
self.assertEqual('text', msg.type)
def test_parse_video_message(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[fromUser]]></FromUserName>
<CreateTime>1357290913</CreateTime>
<MsgType><![CDATA[video]]></MsgType>
<MediaId><![CDATA[media_id]]></MediaId>
<ThumbMediaId><![CDATA[thumb_media_id]]></ThumbMediaId>
<MsgId>1234567890123456</MsgId>
</xml>"""
msg = parse_message(xml)
self.assertEqual('video', msg.type)
def test_parse_subscribe_event(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe]]></Event>
</xml>"""
msg = parse_message(xml)
self.assertEqual('event', msg.type)
self.assertEqual('subscribe', msg.event)
def test_parse_image_message(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[fromUser]]></FromUserName>
<CreateTime>1348831860</CreateTime>
<MsgType><![CDATA[image]]></MsgType>
<PicUrl><![CDATA[this is a url]]></PicUrl>
<MediaId><![CDATA[media_id]]></MediaId>
<MsgId>1234567890123456</MsgId>
</xml>"""
msg = parse_message(xml)
self.assertEqual('image', msg.type)
def test_parse_unknown_message(self):
from wechatpy.messages import UnknownMessage
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[fromUser]]></FromUserName>
<CreateTime>1348831860</CreateTime>
<MsgType><![CDATA[notsure]]></MsgType>
<MsgId>1234567890123456</MsgId>
</xml>"""
msg = parse_message(xml)
self.assertTrue(isinstance(msg, UnknownMessage))
def test_parse_link_message(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[fromUser]]></FromUserName>
<CreateTime>1351776360</CreateTime>
<MsgType><![CDATA[link]]></MsgType>
<Title><![CDATA[公众平台官网链接]]></Title>
<Description><![CDATA[公众平台官网链接]]></Description>
<Url><![CDATA[url]]></Url>
<MsgId>1234567890123456</MsgId>
</xml>"""
msg = parse_message(xml)
self.assertEqual('link', msg.type)
def handle_msg(request):
if request.method == 'GET':
signature = request.GET.get('signature')
timestamp = request.GET.get('timestamp')
nonce = request.GET.get('nonce')
echo_str = request.GET.get('echostr')
check_signature(TOKEN, signature, timestamp, nonce)
return HttpResponse(echo_str)
elif request.method == 'POST':
body = request.body
msg = parse_message(body)
rep = TextReply()
rep.source = msg.target
rep.target = msg.source
if msg.type == 'event':
if msg.event == 'click':
if msg.key == 'sports_advice':
rep.content = recommend_plan(msg.source)
elif msg.key == 'view_info':
rep.content = get_info(msg.source)
elif msg.key == 'add_bong':
rep.content = add_bong(msg.source)
elif msg.key == 'add_test':
rep.content = add_test(msg.source)
elif msg.key == 'add_test_new':
rep.content = add_test_new(msg.source)
elif msg.key == 'show_today':
rep.content = get_datatoday(msg.source)
elif msg.key == 'change_remind':
rep.content = set_remind(msg.source)
elif msg.key == 'build_match':
article_rep = ArticlesReply()
article_rep.source = msg.target
article_rep.target = msg.source
article_rep.add_article({
'title': '创建比赛',
'description': '点此链接以创建比赛',
'image': serverIP+'static/img/run02.jpg',
'url': build_match(msg.source)
})
repxml = article_rep.render()
return HttpResponse(repxml)
elif msg.event == 'subscribe':
rep.content = create_newuser(msg.source)
else:
rep.content = '!!!'
else:
rep.content = '你好'
repxml = rep.render()
return HttpResponse(repxml)
def test_verify_expired_event(self):
from wechatpy.events import VerifyExpiredEvent
xml = """
<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>1442400900</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[verify_expired]]></Event>
<ExpiredTime>1442400900</ExpiredTime>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, VerifyExpiredEvent))
self.assertTrue(isinstance(event.expired_time, datetime))
def test_naming_verify_success_event(self):
from wechatpy.events import NamingVerifySuccessEvent
xml = """
<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>1442401093</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[naming_verify_success]]></Event>
<ExpiredTime>1442401093</ExpiredTime>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, NamingVerifySuccessEvent))
self.assertTrue(isinstance(event.expired_time, datetime))
def test_annual_renew_event(self):
from wechatpy.events import AnnualRenewEvent
xml = """
<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>1442401004</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[annual_renew]]></Event>
<ExpiredTime>1442401004</ExpiredTime>
</xml>"""
event = parse_message(xml)
self.assertTrue(isinstance(event, AnnualRenewEvent))
self.assertTrue(isinstance(event.expired_time, datetime))
def check_message(self, xml, data, is_encrypt=True):
if is_encrypt:
crypto = WeChatCrypto(self.token, self.aes_key, self.app_id)
try:
decrypted_xml = crypto.decrypt_message(
xml,
data.get("msg_signature"),
data.get("timestamp"),
data.get("nonce"))
except (InvalidAppIdException, InvalidSignatureException):
return None
msg = parse_message(decrypted_xml)
else:
msg = parse_message(xml)
re_xml = self.parse_msg(msg)
if is_encrypt:
return_xml = crypto.encrypt_message(
re_xml, data.get("nonce"), data.get("timestamp"))
else:
return_xml = re_xml
return return_xml
def test_parse_subscribe_event_with_last_trade_no(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe]]></Event>
<EventKey><![CDATA[last_trade_no_4008072001201701105817415015]]></EventKey>
</xml>"""
msg = parse_message(xml)
self.assertEqual('event', msg.type)
self.assertEqual('subscribe', msg.event)
self.assertEqual('last_trade_no_4008072001201701105817415015', msg.key)
def test_parse_click_event(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[CLICK]]></Event>
<EventKey><![CDATA[EVENTKEY]]></EventKey>
</xml>"""
msg = parse_message(xml)
self.assertEqual('event', msg.type)
self.assertEqual('click', msg.event)
self.assertEqual('EVENTKEY', msg.key)
def test_parse_view_event(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[VIEW]]></Event>
<EventKey><![CDATA[www.qq.com]]></EventKey>
</xml>"""
msg = parse_message(xml)
self.assertEqual('event', msg.type)
self.assertEqual('view', msg.event)
self.assertEqual('www.qq.com', msg.url)
def test_parse_location_message(self):
xml = """<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[fromUser]]></FromUserName>
<CreateTime>1351776360</CreateTime>
<MsgType><![CDATA[location]]></MsgType>
<Location_X>23.134521</Location_X>
<Location_Y>113.358803</Location_Y>
<Scale>20</Scale>
<Label><![CDATA[位置信息]]></Label>
<MsgId>1234567890123456</MsgId>
</xml>"""
msg = parse_message(xml)
self.assertEqual('location', msg.type)
