J1147
/
CoW
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
1040 Révisions
2 Branches
4.3MB
Aborescence: c0616e7efa
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'c0616e7efa'
${ noResults }
CoW/lib/itchat/async_components/messages.py

528 lignes
22KB
Brut Annotations Historique 

  1. import os, time, re, io

  2. import json

  3. import mimetypes, hashlib

  4. import logging

  5. from collections import OrderedDict

  6. 

  7. 

  8. from .. import config, utils

  9. from ..returnvalues import ReturnValue

  10. from ..storage import templates

  11. from .contact import update_local_uin

  12. 

  13. logger = logging.getLogger('itchat')

  14. 

  15. def load_messages(core):

  16.     core.send_raw_msg = send_raw_msg

  17.     core.send_msg     = send_msg

  18.     core.upload_file  = upload_file

  19.     core.send_file    = send_file

  20.     core.send_image   = send_image

  21.     core.send_video   = send_video

  22.     core.send         = send

  23.     core.revoke       = revoke

  24. 

  25. async def get_download_fn(core, url, msgId):

  26.     async def download_fn(downloadDir=None):

  27.         params = {

  28.             'msgid': msgId,

  29.             'skey': core.loginInfo['skey'],}

  30.         headers = { 'User-Agent' : config.USER_AGENT}

  31.         r = core.s.get(url, params=params, stream=True, headers = headers)

  32.         tempStorage = io.BytesIO()

  33.         for block in r.iter_content(1024):

  34.             tempStorage.write(block)

  35.         if downloadDir is None:

  36.             return tempStorage.getvalue()

  37.         with open(downloadDir, 'wb') as f:

  38.             f.write(tempStorage.getvalue())

  39.         tempStorage.seek(0)

  40.         return ReturnValue({'BaseResponse': {

  41.             'ErrMsg': 'Successfully downloaded',

  42.             'Ret': 0, },

  43.             'PostFix': utils.get_image_postfix(tempStorage.read(20)), })

  44.     return download_fn

  45. 

  46. def produce_msg(core, msgList):

  47.     ''' for messages types

  48.      * 40 msg, 43 videochat, 50 VOIPMSG, 52 voipnotifymsg

  49.      * 53 webwxvoipnotifymsg, 9999 sysnotice

  50.     '''

  51.     rl = []

  52.     srl = [40, 43, 50, 52, 53, 9999]

  53.     for m in msgList:

  54.         # get actual opposite

  55.         if m['FromUserName'] == core.storageClass.userName:

  56.             actualOpposite = m['ToUserName']

  57.         else:

  58.             actualOpposite = m['FromUserName']

  59.         # produce basic message

  60.         if '@@' in m['FromUserName'] or '@@' in m['ToUserName']:

  61.             produce_group_chat(core, m)

  62.         else:

  63.             utils.msg_formatter(m, 'Content')

  64.         # set user of msg

  65.         if '@@' in actualOpposite:

  66.             m['User'] = core.search_chatrooms(userName=actualOpposite) or \

  67.                         templates.Chatroom({'UserName': actualOpposite})

  68.             # we don't need to update chatroom here because we have

  69.             # updated once when producing basic message

  70.         elif actualOpposite in ('filehelper', 'fmessage'):

  71.             m['User'] = templates.User({'UserName': actualOpposite})

  72.         else:

  73.             m['User'] = core.search_mps(userName=actualOpposite) or \

  74.                         core.search_friends(userName=actualOpposite) or \

  75.                         templates.User(userName=actualOpposite)

  76.             # by default we think there may be a user missing not a mp

  77.         m['User'].core = core

  78.         if m['MsgType'] == 1: # words

  79.             if m['Url']:

  80.                 regx = r'(.+?\(.+?\))'

  81.                 data = re.search(regx, m['Content'])

  82.                 data = 'Map' if data is None else data.group(1)

  83.                 msg = {

  84.                     'Type': 'Map',

  85.                     'Text': data,}

  86.             else:

  87.                 msg = {

  88.                     'Type': 'Text',

  89.                     'Text': m['Content'],}

  90.         elif m['MsgType'] == 3 or m['MsgType'] == 47: # picture

  91.             download_fn = get_download_fn(core,

  92.                 '%s/webwxgetmsgimg' % core.loginInfo['url'], m['NewMsgId'])

  93.             msg = {

  94.                 'Type'     : 'Picture',

  95.                 'FileName' : '%s.%s' % (time.strftime('%y%m%d-%H%M%S', time.localtime()),

  96.                     'png' if m['MsgType'] == 3 else 'gif'),

  97.                 'Text'     : download_fn, }

  98.         elif m['MsgType'] == 34: # voice

  99.             download_fn = get_download_fn(core,

  100.                 '%s/webwxgetvoice' % core.loginInfo['url'], m['NewMsgId'])

  101.             msg = {

  102.                 'Type': 'Recording',

  103.                 'FileName' : '%s.mp3' % time.strftime('%y%m%d-%H%M%S', time.localtime()),

  104.                 'Text': download_fn,}

  105.         elif m['MsgType'] == 37: # friends

  106.             m['User']['UserName'] = m['RecommendInfo']['UserName']

  107.             msg = {

  108.                 'Type': 'Friends',

  109.                 'Text': {

  110.                     'status'        : m['Status'],

  111.                     'userName'      : m['RecommendInfo']['UserName'],

  112.                     'verifyContent' : m['Ticket'],

  113.                     'autoUpdate'    : m['RecommendInfo'], }, }

  114.             m['User'].verifyDict = msg['Text']

  115.         elif m['MsgType'] == 42: # name card

  116.             msg = {

  117.                 'Type': 'Card',

  118.                 'Text': m['RecommendInfo'], }

  119.         elif m['MsgType'] in (43, 62): # tiny video

  120.             msgId = m['MsgId']

  121.             async def download_video(videoDir=None):

  122.                 url = '%s/webwxgetvideo' % core.loginInfo['url']

  123.                 params = {

  124.                     'msgid': msgId,

  125.                     'skey': core.loginInfo['skey'],}

  126.                 headers = {'Range': 'bytes=0-', 'User-Agent' : config.USER_AGENT}

  127.                 r = core.s.get(url, params=params, headers=headers, stream=True)

  128.                 tempStorage = io.BytesIO()

  129.                 for block in r.iter_content(1024):

  130.                     tempStorage.write(block)

  131.                 if videoDir is None:

  132.                     return tempStorage.getvalue()

  133.                 with open(videoDir, 'wb') as f:

  134.                     f.write(tempStorage.getvalue())

  135.                 return ReturnValue({'BaseResponse': {

  136.                     'ErrMsg': 'Successfully downloaded',

  137.                     'Ret': 0, }})

  138.             msg = {

  139.                 'Type': 'Video',

  140.                 'FileName' : '%s.mp4' % time.strftime('%y%m%d-%H%M%S', time.localtime()),

  141.                 'Text': download_video, }

  142.         elif m['MsgType'] == 49: # sharing

  143.             if m['AppMsgType'] == 0: # chat history

  144.                 msg = {

  145.                     'Type': 'Note',

  146.                     'Text': m['Content'], }

  147.             elif m['AppMsgType'] == 6:

  148.                 rawMsg = m

  149.                 cookiesList = {name:data for name,data in core.s.cookies.items()}

  150.                 async def download_atta(attaDir=None):

  151.                     url = core.loginInfo['fileUrl'] + '/webwxgetmedia'

  152.                     params = {

  153.                         'sender': rawMsg['FromUserName'],

  154.                         'mediaid': rawMsg['MediaId'],

  155.                         'filename': rawMsg['FileName'],

  156.                         'fromuser': core.loginInfo['wxuin'],

  157.                         'pass_ticket': 'undefined',

  158.                         'webwx_data_ticket': cookiesList['webwx_data_ticket'],}

  159.                     headers = { 'User-Agent' : config.USER_AGENT}

  160.                     r = core.s.get(url, params=params, stream=True, headers=headers)

  161.                     tempStorage = io.BytesIO()

  162.                     for block in r.iter_content(1024):

  163.                         tempStorage.write(block)

  164.                     if attaDir is None:

  165.                         return tempStorage.getvalue()

  166.                     with open(attaDir, 'wb') as f:

  167.                         f.write(tempStorage.getvalue())

  168.                     return ReturnValue({'BaseResponse': {

  169.                         'ErrMsg': 'Successfully downloaded',

  170.                         'Ret': 0, }})

  171.                 msg = {

  172.                     'Type': 'Attachment',

  173.                     'Text': download_atta, }

  174.             elif m['AppMsgType'] == 8:

  175.                 download_fn = get_download_fn(core,

  176.                     '%s/webwxgetmsgimg' % core.loginInfo['url'], m['NewMsgId'])

  177.                 msg = {

  178.                     'Type'     : 'Picture',

  179.                     'FileName' : '%s.gif' % (

  180.                         time.strftime('%y%m%d-%H%M%S', time.localtime())),

  181.                     'Text'     : download_fn, }

  182.             elif m['AppMsgType'] == 17:

  183.                 msg = {

  184.                     'Type': 'Note',

  185.                     'Text': m['FileName'], }

  186.             elif m['AppMsgType'] == 2000:

  187.                 regx = r'\[CDATA\[(.+?)\][\s\S]+?\[CDATA\[(.+?)\]'

  188.                 data = re.search(regx, m['Content'])

  189.                 if data:

  190.                     data = data.group(2).split(u'\u3002')[0]

  191.                 else:

  192.                     data = 'You may found detailed info in Content key.'

  193.                 msg = {

  194.                     'Type': 'Note',

  195.                     'Text': data, }

  196.             else:

  197.                 msg = {

  198.                     'Type': 'Sharing',

  199.                     'Text': m['FileName'], }

  200.         elif m['MsgType'] == 51: # phone init

  201.             msg = update_local_uin(core, m)

  202.         elif m['MsgType'] == 10000:

  203.             msg = {

  204.                 'Type': 'Note',

  205.                 'Text': m['Content'],}

  206.         elif m['MsgType'] == 10002:

  207.             regx = r'\[CDATA\[(.+?)\]\]'

  208.             data = re.search(regx, m['Content'])

  209.             data = 'System message' if data is None else data.group(1).replace('\\', '')

  210.             msg = {

  211.                 'Type': 'Note',

  212.                 'Text': data, }

  213.         elif m['MsgType'] in srl:

  214.             msg = {

  215.                 'Type': 'Useless',

  216.                 'Text': 'UselessMsg', }

  217.         else:

  218.             logger.debug('Useless message received: %s\n%s' % (m['MsgType'], str(m)))

  219.             msg = {

  220.                 'Type': 'Useless',

  221.                 'Text': 'UselessMsg', }

  222.         m = dict(m, **msg)

  223.         rl.append(m)

  224.     return rl

  225. 

  226. def produce_group_chat(core, msg):

  227.     r = re.match('(@[0-9a-z]*?):<br/>(.*)$', msg['Content'])

  228.     if r:

  229.         actualUserName, content = r.groups()

  230.         chatroomUserName = msg['FromUserName']

  231.     elif msg['FromUserName'] == core.storageClass.userName:

  232.         actualUserName = core.storageClass.userName

  233.         content = msg['Content']

  234.         chatroomUserName = msg['ToUserName']

  235.     else:

  236.         msg['ActualUserName'] = core.storageClass.userName

  237.         msg['ActualNickName'] = core.storageClass.nickName

  238.         msg['IsAt'] = False

  239.         utils.msg_formatter(msg, 'Content')

  240.         return

  241.     chatroom = core.storageClass.search_chatrooms(userName=chatroomUserName)

  242.     member = utils.search_dict_list((chatroom or {}).get(

  243.         'MemberList') or [], 'UserName', actualUserName)

  244.     if member is None:

  245.         chatroom = core.update_chatroom(chatroomUserName)

  246.         member = utils.search_dict_list((chatroom or {}).get(

  247.             'MemberList') or [], 'UserName', actualUserName)

  248.     if member is None:

  249.         logger.debug('chatroom member fetch failed with %s' % actualUserName)

  250.         msg['ActualNickName'] = ''

  251.         msg['IsAt'] = False

  252.     else:

  253.         msg['ActualNickName'] = member.get('DisplayName', '') or member['NickName']

  254.         atFlag = '@' + (chatroom['Self'].get('DisplayName', '') or core.storageClass.nickName)

  255.         msg['IsAt'] = (

  256.             (atFlag + (u'\u2005' if u'\u2005' in msg['Content'] else ' '))

  257.             in msg['Content'] or msg['Content'].endswith(atFlag))

  258.     msg['ActualUserName'] = actualUserName

  259.     msg['Content']        = content

  260.     utils.msg_formatter(msg, 'Content')

  261. 

  262. async def send_raw_msg(self, msgType, content, toUserName):

  263.     url = '%s/webwxsendmsg' % self.loginInfo['url']

  264.     data = {

  265.         'BaseRequest': self.loginInfo['BaseRequest'],

  266.         'Msg': {

  267.             'Type': msgType,

  268.             'Content': content,

  269.             'FromUserName': self.storageClass.userName,

  270.             'ToUserName': (toUserName if toUserName else self.storageClass.userName),

  271.             'LocalID': int(time.time() * 1e4),

  272.             'ClientMsgId': int(time.time() * 1e4),

  273.             },

  274.         'Scene': 0, }

  275.     headers = { 'ContentType': 'application/json; charset=UTF-8', 'User-Agent' : config.USER_AGENT}

  276.     r = self.s.post(url, headers=headers,

  277.         data=json.dumps(data, ensure_ascii=False).encode('utf8'))

  278.     return ReturnValue(rawResponse=r)

  279. 

  280. async def send_msg(self, msg='Test Message', toUserName=None):

  281.     logger.debug('Request to send a text message to %s: %s' % (toUserName, msg))

  282.     r = await self.send_raw_msg(1, msg, toUserName)

  283.     return r

  284. 

  285. def _prepare_file(fileDir, file_=None):

  286.     fileDict = {}

  287.     if file_:

  288.         if hasattr(file_, 'read'):

  289.             file_ = file_.read()

  290.         else:

  291.             return ReturnValue({'BaseResponse': {

  292.                 'ErrMsg': 'file_ param should be opened file',

  293.                 'Ret': -1005, }})

  294.     else:

  295.         if not utils.check_file(fileDir):

  296.             return ReturnValue({'BaseResponse': {

  297.                 'ErrMsg': 'No file found in specific dir',

  298.                 'Ret': -1002, }})

  299.         with open(fileDir, 'rb') as f:

  300.             file_ = f.read()

  301.     fileDict['fileSize'] = len(file_)

  302.     fileDict['fileMd5'] = hashlib.md5(file_).hexdigest()

  303.     fileDict['file_'] = io.BytesIO(file_)

  304.     return fileDict

  305. 

  306. def upload_file(self, fileDir, isPicture=False, isVideo=False,

  307.         toUserName='filehelper', file_=None, preparedFile=None):

  308.     logger.debug('Request to upload a %s: %s' % (

  309.         'picture' if isPicture else 'video' if isVideo else 'file', fileDir))

  310.     if not preparedFile:

  311.         preparedFile = _prepare_file(fileDir, file_)

  312.         if not preparedFile:

  313.             return preparedFile

  314.     fileSize, fileMd5, file_ = \

  315.         preparedFile['fileSize'], preparedFile['fileMd5'], preparedFile['file_']

  316.     fileSymbol = 'pic' if isPicture else 'video' if isVideo else'doc'

  317.     chunks = int((fileSize - 1) / 524288) + 1

  318.     clientMediaId = int(time.time() * 1e4)

  319.     uploadMediaRequest = json.dumps(OrderedDict([

  320.         ('UploadType', 2),

  321.         ('BaseRequest', self.loginInfo['BaseRequest']),

  322.         ('ClientMediaId', clientMediaId),

  323.         ('TotalLen', fileSize),

  324.         ('StartPos', 0),

  325.         ('DataLen', fileSize),

  326.         ('MediaType', 4),

  327.         ('FromUserName', self.storageClass.userName),

  328.         ('ToUserName', toUserName),

  329.         ('FileMd5', fileMd5)]

  330.         ), separators = (',', ':'))

  331.     r = {'BaseResponse': {'Ret': -1005, 'ErrMsg': 'Empty file detected'}}

  332.     for chunk in range(chunks):

  333.         r = upload_chunk_file(self, fileDir, fileSymbol, fileSize,

  334.             file_, chunk, chunks, uploadMediaRequest)

  335.     file_.close()

  336.     if isinstance(r, dict):

  337.         return ReturnValue(r)

  338.     return ReturnValue(rawResponse=r)

  339. 

  340. def upload_chunk_file(core, fileDir, fileSymbol, fileSize,

  341.         file_, chunk, chunks, uploadMediaRequest):

  342.     url = core.loginInfo.get('fileUrl', core.loginInfo['url']) + \

  343.         '/webwxuploadmedia?f=json'

  344.     # save it on server

  345.     cookiesList = {name:data for name,data in core.s.cookies.items()}

  346.     fileType = mimetypes.guess_type(fileDir)[0] or 'application/octet-stream'

  347.     fileName = utils.quote(os.path.basename(fileDir))

  348.     files = OrderedDict([

  349.         ('id', (None, 'WU_FILE_0')),

  350.         ('name', (None, fileName)),

  351.         ('type', (None, fileType)),

  352.         ('lastModifiedDate', (None, time.strftime('%a %b %d %Y %H:%M:%S GMT+0800 (CST)'))),

  353.         ('size', (None, str(fileSize))),

  354.         ('chunks', (None, None)),

  355.         ('chunk', (None, None)),

  356.         ('mediatype', (None, fileSymbol)),

  357.         ('uploadmediarequest', (None, uploadMediaRequest)),

  358.         ('webwx_data_ticket', (None, cookiesList['webwx_data_ticket'])),

  359.         ('pass_ticket', (None, core.loginInfo['pass_ticket'])),

  360.         ('filename' , (fileName, file_.read(524288), 'application/octet-stream'))])

  361.     if chunks == 1:

  362.         del files['chunk']; del files['chunks']

  363.     else:

  364.         files['chunk'], files['chunks'] = (None, str(chunk)), (None, str(chunks))

  365.     headers = { 'User-Agent' : config.USER_AGENT}

  366.     return core.s.post(url, files=files, headers=headers, timeout=config.TIMEOUT)

  367. 

  368. async def send_file(self, fileDir, toUserName=None, mediaId=None, file_=None):

  369.     logger.debug('Request to send a file(mediaId: %s) to %s: %s' % (

  370.         mediaId, toUserName, fileDir))

  371.     if hasattr(fileDir, 'read'):

  372.         return ReturnValue({'BaseResponse': {

  373.             'ErrMsg': 'fileDir param should not be an opened file in send_file',

  374.             'Ret': -1005, }})

  375.     if toUserName is None:

  376.         toUserName = self.storageClass.userName

  377.     preparedFile = _prepare_file(fileDir, file_)

  378.     if not preparedFile:

  379.         return preparedFile

  380.     fileSize = preparedFile['fileSize']

  381.     if mediaId is None:

  382.         r = self.upload_file(fileDir, preparedFile=preparedFile)

  383.         if r:

  384.             mediaId = r['MediaId']

  385.         else:

  386.             return r

  387.     url = '%s/webwxsendappmsg?fun=async&f=json' % self.loginInfo['url']

  388.     data = {

  389.         'BaseRequest': self.loginInfo['BaseRequest'],

  390.         'Msg': {

  391.             'Type': 6,

  392.             'Content': ("<appmsg appid='wxeb7ec651dd0aefa9' sdkver=''><title>%s</title>" % os.path.basename(fileDir) +

  393.                 "<des></des><action></action><type>6</type><content></content><url></url><lowurl></lowurl>" +

  394.                 "<appattach><totallen>%s</totallen><attachid>%s</attachid>" % (str(fileSize), mediaId) +

  395.                 "<fileext>%s</fileext></appattach><extinfo></extinfo></appmsg>" % os.path.splitext(fileDir)[1].replace('.','')),

  396.             'FromUserName': self.storageClass.userName,

  397.             'ToUserName': toUserName,

  398.             'LocalID': int(time.time() * 1e4),

  399.             'ClientMsgId': int(time.time() * 1e4), },

  400.         'Scene': 0, }

  401.     headers = {

  402.         'User-Agent': config.USER_AGENT,

  403.         'Content-Type': 'application/json;charset=UTF-8', }

  404.     r = self.s.post(url, headers=headers,

  405.         data=json.dumps(data, ensure_ascii=False).encode('utf8'))

  406.     return ReturnValue(rawResponse=r)

  407. 

  408. async def send_image(self, fileDir=None, toUserName=None, mediaId=None, file_=None):

  409.     logger.debug('Request to send a image(mediaId: %s) to %s: %s' % (

  410.         mediaId, toUserName, fileDir))

  411.     if fileDir or file_:

  412.         if hasattr(fileDir, 'read'):

  413.             file_, fileDir = fileDir, None

  414.         if fileDir is None:

  415.             fileDir = 'tmp.jpg' # specific fileDir to send gifs

  416.     else:

  417.         return ReturnValue({'BaseResponse': {

  418.             'ErrMsg': 'Either fileDir or file_ should be specific',

  419.             'Ret': -1005, }})

  420.     if toUserName is None:

  421.         toUserName = self.storageClass.userName

  422.     if mediaId is None:

  423.         r = self.upload_file(fileDir, isPicture=not fileDir[-4:] == '.gif', file_=file_)

  424.         if r:

  425.             mediaId = r['MediaId']

  426.         else:

  427.             return r

  428.     url = '%s/webwxsendmsgimg?fun=async&f=json' % self.loginInfo['url']

  429.     data = {

  430.         'BaseRequest': self.loginInfo['BaseRequest'],

  431.         'Msg': {

  432.             'Type': 3,

  433.             'MediaId': mediaId,

  434.             'FromUserName': self.storageClass.userName,

  435.             'ToUserName': toUserName,

  436.             'LocalID': int(time.time() * 1e4),

  437.             'ClientMsgId': int(time.time() * 1e4), },

  438.         'Scene': 0, }

  439.     if fileDir[-4:] == '.gif':

  440.         url = '%s/webwxsendemoticon?fun=sys' % self.loginInfo['url']

  441.         data['Msg']['Type'] = 47

  442.         data['Msg']['EmojiFlag'] = 2

  443.     headers = {

  444.         'User-Agent': config.USER_AGENT,

  445.         'Content-Type': 'application/json;charset=UTF-8', }

  446.     r = self.s.post(url, headers=headers,

  447.         data=json.dumps(data, ensure_ascii=False).encode('utf8'))

  448.     return ReturnValue(rawResponse=r)

  449. 

  450. async def send_video(self, fileDir=None, toUserName=None, mediaId=None, file_=None):

  451.     logger.debug('Request to send a video(mediaId: %s) to %s: %s' % (

  452.         mediaId, toUserName, fileDir))

  453.     if fileDir or file_:

  454.         if hasattr(fileDir, 'read'):

  455.             file_, fileDir = fileDir, None

  456.         if fileDir is None:

  457.             fileDir = 'tmp.mp4' # specific fileDir to send other formats

  458.     else:

  459.         return ReturnValue({'BaseResponse': {

  460.             'ErrMsg': 'Either fileDir or file_ should be specific',

  461.             'Ret': -1005, }})

  462.     if toUserName is None:

  463.         toUserName = self.storageClass.userName

  464.     if mediaId is None:

  465.         r = self.upload_file(fileDir, isVideo=True, file_=file_)

  466.         if r:

  467.             mediaId = r['MediaId']

  468.         else:

  469.             return r

  470.     url = '%s/webwxsendvideomsg?fun=async&f=json&pass_ticket=%s' % (

  471.         self.loginInfo['url'], self.loginInfo['pass_ticket'])

  472.     data = {

  473.         'BaseRequest': self.loginInfo['BaseRequest'],

  474.         'Msg': {

  475.             'Type'         : 43,

  476.             'MediaId'      : mediaId,

  477.             'FromUserName' : self.storageClass.userName,

  478.             'ToUserName'   : toUserName,

  479.             'LocalID'      : int(time.time() * 1e4),

  480.             'ClientMsgId'  : int(time.time() * 1e4), },

  481.         'Scene': 0, }

  482.     headers = {

  483.         'User-Agent' : config.USER_AGENT,

  484.         'Content-Type': 'application/json;charset=UTF-8', }

  485.     r = self.s.post(url, headers=headers,

  486.         data=json.dumps(data, ensure_ascii=False).encode('utf8'))

  487.     return ReturnValue(rawResponse=r)

  488. 

  489. async def send(self, msg, toUserName=None, mediaId=None):

  490.     if not msg:

  491.         r = ReturnValue({'BaseResponse': {

  492.             'ErrMsg': 'No message.',

  493.             'Ret': -1005, }})

  494.     elif msg[:5] == '@fil@':

  495.         if mediaId is None:

  496.             r = await self.send_file(msg[5:], toUserName)

  497.         else:

  498.             r = await self.send_file(msg[5:], toUserName, mediaId)

  499.     elif msg[:5] == '@img@':

  500.         if mediaId is None:

  501.             r = await self.send_image(msg[5:], toUserName)

  502.         else:

  503.             r = await self.send_image(msg[5:], toUserName, mediaId)

  504.     elif msg[:5] == '@msg@':

  505.         r = await self.send_msg(msg[5:], toUserName)

  506.     elif msg[:5] == '@vid@':

  507.         if mediaId is None:

  508.             r = await self.send_video(msg[5:], toUserName)

  509.         else:

  510.             r = await self.send_video(msg[5:], toUserName, mediaId)

  511.     else:

  512.         r = await self.send_msg(msg, toUserName)

  513.     return r

  514. 

  515. async def revoke(self, msgId, toUserName, localId=None):

  516.     url = '%s/webwxrevokemsg' % self.loginInfo['url']

  517.     data = {

  518.         'BaseRequest': self.loginInfo['BaseRequest'],

  519.         "ClientMsgId": localId or str(time.time() * 1e3),

  520.         "SvrMsgId": msgId,

  521.         "ToUserName": toUserName}

  522.     headers = {

  523.         'ContentType': 'application/json; charset=UTF-8',

  524.         'User-Agent' : config.USER_AGENT }

  525.     r = self.s.post(url, headers=headers,

  526.         data=json.dumps(data, ensure_ascii=False).encode('utf8'))

  527.     return ReturnValue(rawResponse=r)