Deploying an ECS for Handling Text Messages from an Official WeChat Account

Overview

The best practices for Huawei Cloud ECS guide you through the deployment of an ECS as an official WeChat account server so that the ECS receives text messages from the WeChat server and sends processing results to end users. On this ECS, Python is used to compile the logic code for processing WeChat messages. Figure 1 shows the service flow.

Preparations

• Apply for an official WeChat account.

  URL: https://mp.weixin.qq.com/

  This section uses the Service Infographics WeChat account as an example.

Installing Basic Software

This section uses Python and Web.py to develop the official WeChat account. You are required to install or upgrade Python, pip, Web.py framework, and WinSCP software.

Uploading Code

1. Create the main.py file and copy the following data:

   # -*- coding: utf-8 -*-
   # filename: main.py
   import web
   from handle import Handle
   
   urls = (
       '/wx', 'Handle',
   )
   
   if __name__ == '__main__':
       app = web.application(urls, globals())
       app.run()

2. Create the handle.py file and copy the following data:

   # -*- coding: utf-8 -*-
   # filename: handle.py
   
   import hashlib
   import web
   import receive
   import time
   import os
   
   class Handle(object):
   
       def __init__(self):
           self.app_root = os.path.dirname(__file__)
           self.templates_root = os.path.join(self.app_root, 'templates')
           self.render = web.template.render(self.templates_root)
   
       def GET(self):
           try:
               data = web.input()
               if len(data) == 0:
                   return "hello, this is handle view"
               signature = data.signature
               timestamp = data.timestamp
               nonce = data.nonce
               echostr = data.echostr
               token = "Use the taken value obtained in the basic configuration of the official WeChat account."
   
               list = [token, timestamp, nonce]
               list.sort()
               s = list[0] + list[1] + list[2]
               hashcode = hashlib.sha1(s.encode('utf-8')).hexdigest()
               print( "handle/GET func: hashcode, signature: ", hashcode, signature)
               if hashcode == signature:
                   return echostr
               else:
                   return echostr
           except (Exception) as Argument:
               return Argument
   
       def POST(self):
           try:
               webData = web.data()
               print("Handle Post webdata is:\n", webData)
               #Print message body logs.
               recMsg = receive.parse_xml(webData)
   
               if isinstance(recMsg, receive.Msg) and recMsg.MsgType == 'text':
                   toUser = recMsg.FromUserName
                   fromUser = recMsg.ToUserName
                   content = "Welcome to Service Infographics." + str(recMsg.Content)
                   print('Reply message info:\n')
                   print('toUser =', toUser)
                   print('fromUser = ', fromUser)
                   print('content = ', content)
                   return self.render.reply_text(toUser, fromUser, int(time.time()), content)
               else:
                   print("Message types not supported:",recMsg.MsgType)
                   return "success"
           except (Exception) as Argment:
               return Argment

3. Create the receive.py file and copy the following data:

   # -*- coding: utf-8 -*-
   # filename: receive.py
   import xml.etree.ElementTree as ET
   
   def parse_xml(web_data):
       if len(web_data) == 0:
           return None
       xmlData = ET.fromstring(web_data)
       msg_type = xmlData.find('MsgType').text
       if msg_type == 'text':
           return TextMsg(xmlData)
       elif msg_type == 'image':
           return ImageMsg(xmlData)
       elif msg_type == 'location':
           return LocationMsg(xmlData)
       elif msg_type == 'event':
           return EventMsg(xmlData)
   
   class Event(object):
       def __init__(self, xmlData):
           self.ToUserName = xmlData.find('ToUserName').text
           self.FromUserName = xmlData.find('FromUserName').text
           self.CreateTime = xmlData.find('CreateTime').text
           self.MsgType = xmlData.find('MsgType').text
           self.Eventkey = xmlData.find('EventKey').text
   
   class Msg(object):
       def __init__(self, xmlData):
           self.ToUserName = xmlData.find('ToUserName').text
           self.FromUserName = xmlData.find('FromUserName').text
           self.CreateTime = xmlData.find('CreateTime').text
           self.MsgType = xmlData.find('MsgType').text
           self.MsgId = xmlData.find('MsgId').text
   
   class TextMsg(Msg):
       def __init__(self, xmlData):
           Msg.__init__(self, xmlData)
           self.Content = xmlData.find('Content').text
   
   class ImageMsg(Msg):
       def __init__(self, xmlData):
           Msg.__init__(self, xmlData)
           self.PicUrl = xmlData.find('PicUrl').text
           self.MediaId = xmlData.find('MediaId').text
   
   class LocationMsg(Msg):
       def __init__(self, xmlData):
           Msg.__init__(self, xmlData)
           self.Location_X = xmlData.find('Location_X').text
           self.Location_Y = xmlData.find('Location_Y').text
   
   class EventMsg(Msg):
       def __init__(self, xmlData):
           Event.__init__(self, xmlData)
           self.Event = xmlData.find('Event').text

4. Create the templates folder and the reply_text.xml file in the folder. Then, copy the following data:

   $def with (toUser,fromUser,createTime,content)
   <xml>
   <ToUserName><![CDATA[$toUser]]></ToUserName>
   <FromUserName><![CDATA[$fromUser]]></FromUserName>
   <CreateTime>$createTime</CreateTime>
   <MsgType><![CDATA[text]]></MsgType>
   <Content><![CDATA[$content]]></Content>
   </xml>

5. Obtain the local file.
   Figure 15 Local file
   
6. Use WinSCP to upload the preceding files and folder to the specified directory on the ECS.
   Figure 16 Uploading files
   

Starting the Service

Run the following command to start the service:

Enabling the Developer Mode

1. Log in to official WeChat platform, choose Develop > Basic Configuration, and click Modify Configuration.
2. Specify the following basic configurations and click Submit.
   • URL: https://EIP bound to the ECS/wx. Port 80 is not required.
   • Token: the same as the token value in the handle.py file.
   • EncodingAESKey: generated randomly.
   • Message encryption and decryption: plaintext in this example.
3. Authenticate the token and click Enable.
   

   If authenticating the token failed, check whether the token configuration is the same as that in the code for processing GET messages in the handle.py file.

Verifying Service Deployment

Send a text message to the official WeChat account. If the response is properly received, the service has been successfully deployed.