def onMessage(self, messageProtocolEntity):
print(messageProtocolEntity.getFrom())
# send receipt otherwise we keep receiving the same message over and over
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom(),
False, messageProtocolEntity.getParticipant())
self.toLower(receipt)
# route based on message type
if messageProtocolEntity.getType() == 'text':
self.onTextMessage(messageProtocolEntity)
elif messageProtocolEntity.getType() == 'media':
self.onMediaMessage(messageProtocolEntity)
# to store in database, send grouped receipts later on when going online
store = (messageProtocolEntity.getId(),
messageProtocolEntity.getFrom(),
messageProtocolEntity.getParticipant())
time.sleep(randint(3, 5))
self.toLower(AvailablePresenceProtocolEntity())
receipt = OutgoingReceiptProtocolEntity(store[0], store[1], True,
store[2])
self.toLower(receipt)
time.sleep(randint(3, 5))
self.toLower(UnavailablePresenceProtocolEntity())
def recvCall(self, node):
entity = CallProtocolEntity.fromProtocolTreeNode(node)
if entity.getType() == "offer":
receipt = OutgoingReceiptProtocolEntity(node["id"], node["from"], callId = entity.getCallId())
self.toLower(receipt.toProtocolTreeNode())
else:
ack = OutgoingAckProtocolEntity(node["id"], "call", None, node["from"])
self.toLower(ack.toProtocolTreeNode())
self.toUpper(entity)
def recvCall(self, node):
entity = CallProtocolEntity.fromProtocolTreeNode(node)
if entity.getType() == "offer":
receipt = OutgoingReceiptProtocolEntity(node["id"],
node["from"],
callId=entity.getCallId())
self.toLower(receipt.toProtocolTreeNode())
else:
ack = OutgoingAckProtocolEntity(node["id"], "call", None,
node["from"])
self.toLower(ack.toProtocolTreeNode())
self.toUpper(entity)
def onTextMessage(self, messageProtocolEntity):
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom())
print("%s [%s]:%s" %
(messageProtocolEntity.getFrom(False),
datetime.datetime.fromtimestamp(
messageProtocolEntity.getTimestamp()).strftime(
'%d-%m-%Y %H:%M'), messageProtocolEntity.getBody()))
outgoingMessageProtocolEntity = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom())
self.toLower(receipt)
print("Sent delivered receipt Message %s" %
messageProtocolEntity.getId())
def onMessage(self, messageProtocolEntity):
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom(),
'read', messageProtocolEntity.getParticipant())
# wait for the groups to be fetched before handling any incoming messages
if not groups_ready:
logger.info("Waiting with message delivery, groups not ready")
self.offlineMsgQ.put(messageProtocolEntity)
return
if isinstance(messageProtocolEntity, MediaMessageProtocolEntity):
self.onMediaMessage(messageProtocolEntity)
return
elif isinstance(messageProtocolEntity, TextMessageProtocolEntity):
self.sendToTelegram(messageProtocolEntity,
messageProtocolEntity.getBody(),
isMedia=False)
logging.info(
"Received message from " +
messageProtocolEntity.getNotify().encode('latin-1').decode() +
": " + messageProtocolEntity.getBody())
else:
logger.error("Unknown message type %s " %
str(messageProtocolEntity))
return
# confirm message received
self.toLower(receipt)
def handleSenderKeyMessage(self, node):
encMessageProtocolEntity = EncryptedMessageProtocolEntity.fromProtocolTreeNode(
node)
enc = encMessageProtocolEntity.getEnc(EncProtocolEntity.TYPE_SKMSG)
try:
plaintext = self.manager.group_decrypt(
groupid=encMessageProtocolEntity.getFrom(True),
participantid=encMessageProtocolEntity.getParticipant(False),
data=enc.getData())
self.parseAndHandleMessageProto(encMessageProtocolEntity,
plaintext)
node = encMessageProtocolEntity.toProtocolTreeNode()
node.addChild(
(ProtoProtocolEntity(plaintext,
enc.getMediaType())).toProtocolTreeNode())
self.toUpper(node)
except exceptions.NoSessionException:
logger.warning("No session for %s, going to send a retry",
encMessageProtocolEntity.getAuthor(False))
retry = RetryOutgoingReceiptProtocolEntity.fromMessageNode(
node, self.manager.registration_id)
self.toLower(retry.toProtocolTreeNode())
except exceptions.DuplicateMessageException:
logger.warning(
"Received a message that we've previously decrypted, goint to send the delivery receipt myself"
)
self.toLower(
OutgoingReceiptProtocolEntity(
node["id"], node["from"],
participant=node["participant"]).toProtocolTreeNode())
def onMessage(self, messageProtocolEntity):
print "onMessage"
# send receipt otherwise we keep receiving the same message over and over
if True:
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom(),
'read', messageProtocolEntity.getParticipant())
jid = messageProtocolEntity.getFrom()
sender = jid.split("-")[0]
print "Message from: "
print sender
if sender not in self.session.senders and jid not in self.session.sub2gid.values(
):
if len(self.session.senders) % 5 == 0:
# Create a new group - JBG
self.session.group = "lavalab2-" + str(
int(round(time.time())))
entity = CreateGroupsIqProtocolEntity(
self.session.group,
participants=[self.aliasToJid(sender)])
self.toLower(entity)
# This will re-fetch subject to group id mappings, get new group id - JBG
self.toLower(ListGroupsIqProtocolEntity())
else:
# Invite user to group - JBG
gid = self.session.sub2gid[self.session.group]
jids = [self.aliasToJid(sender)]
entity = AddParticipantsIqProtocolEntity(
self.aliasToJid(gid), jids)
self.toLower(entity)
self.session.senders.append(sender)
self.toLower(receipt)
def onMessage(self, messageProtocolEntity):
#send receipt otherwise we keep receiving the same message over and over
if True:
receipt = OutgoingReceiptProtocolEntity(messageProtocolEntity.getId(), messageProtocolEntity.getFrom())
if messageProtocolEntity.getBody().lower() == message.lower() :
response ="1. Type 'info' to get info about temperature, moisture and weather.\n 2. Type 'water' to irrigate.\n 3. Type 'stop '
elif messageProtocolEntity.getBody().lower() == message1.lower() :
response = a
elif messageProtocolEntity.getBody().lower() == message2.lower() :
response = "enter"
elif messageProtocolEntity.getBody().lower() == message3.lower() :
response = "Enter your command stop water"
else :
response = "Enter your command"
outgoingMessageProtocolEntity = TextMessageProtocolEntity(
response,
to = messageProtocolEntity.getFrom())
self.toLower(receipt)
self.toLower(outgoingMessageProtocolEntity)
def recvMessageStanza(self, node):
protoNode = node.getChild("proto")
if protoNode:
if protoNode and protoNode["mediatype"] is None:
message = AttributesConverter.get().protobytes_to_message(
protoNode.getData())
if message.conversation:
self.toUpper(
TextMessageProtocolEntity(
message.conversation,
MessageMetaAttributes.
from_message_protocoltreenode(node)))
elif message.extended_text:
self.toUpper(
ExtendedTextMessageProtocolEntity(
message.extended_text,
MessageMetaAttributes.
from_message_protocoltreenode(node)))
elif not message.sender_key_distribution_message:
# Will send receipts for unsupported message types to prevent stream errors
logger.warning(
"Unsupported message type: %s, will send receipts to "
"prevent stream errors" % message)
self.toLower(
OutgoingReceiptProtocolEntity(
messageIds=[node["id"]],
to=node["from"],
participant=node["participant"]).
toProtocolTreeNode())
def on_message(self, msg):
print msg
# accept only media vcard
if msg.getType(
) == TextMessageProtocolEntity.MESSAGE_TYPE_MEDIA and msg.getMediaType(
) == MediaMessageProtocolEntity.MEDIA_TYPE_VCARD:
user_info = self.on_contact(msg)
# msg_reply = TextMessageProtocolEntity(
# "hang tight, setting up a transfer to " + user_info['n'],
# to=msg.getFrom())
msg_reply = TextMessageProtocolEntity(
"awesome, head over to " + PAY_URL +
", to complete the transaction for " + user_info['n'],
to=msg.getFrom())
self.toLower(msg_reply)
else:
# if it isn't a vcard return a message
msg_reply = TextMessageProtocolEntity(
"doesn't seem to be a valid message, try sending a contact ?",
to=msg.getFrom())
self.toLower(msg_reply)
# send read receipt for message
receipt = OutgoingReceiptProtocolEntity(msg.getId(), msg.getFrom(),
'read', msg.getParticipant())
self.toLower(receipt)
def handleDocumentMessage(self, originalEncNode, documentMessage):
try:
messageNode = copy.deepcopy(originalEncNode)
messageNode["type"] = "media"
mediaNode = ProtocolTreeNode(
"media", {
"type": "document",
"url": documentMessage.url,
"mimetype": documentMessage.mime_type,
"title": documentMessage.title,
"filehash": documentMessage.file_sha256,
"size": str(documentMessage.file_length),
"pages": str(documentMessage.page_count),
"mediakey": documentMessage.media_key
},
data=documentMessage.jpeg_thumbnail)
messageNode.addChild(mediaNode)
self.toUpper(messageNode)
except:
if PROP_IGNORE_UNHANDLED:
self.toLower(
OutgoingReceiptProtocolEntity(
originalEncNode["id"],
originalEncNode["from"],
participant=originalEncNode["participant"]).
toProtocolTreeNode())
logger.warning("Unhandled message, sending delivery receipt")
else:
print(m)
raise ValueError("Unhandled")
def on_message(self, message):
"""Received a message."""
# Parse information
sender = message.getFrom(full=False)
logger.debug('received message from %s' % sender)
# Send receipt
receipt = OutgoingReceiptProtocolEntity(
message.getId(),
message.getFrom(),
'read',
message.getParticipant()
)
self.toLower(receipt)
# Ignore non-text messages
if message.getType() != 'text':
logger.info('not a text message, ignoring')
return
# Do stuff
if is_blacklisted(sender):
logger.debug('phone is blacklisted: %s' % sender)
return
body = message.getBody()
# Relay to Telegram
logger.info('relaying message to Telegram')
SIGNAL_TG.send('wabot', phone=sender, message=body)
def fromProtocolTreeNode(node):
entity = OutgoingReceiptProtocolEntity.fromProtocolTreeNode(node)
entity.__class__ = RetryOutgoingReceiptProtocolEntity
retryNode = node.getChild("retry")
entity.setRetryData(ResultGetKeysIqProtocolEntity._bytesToInt(node.getChild("registration").data), retryNode["v"], retryNode["count"], retryNode["t"])
return entity
def onMediaMessage(self, messageProtocolEntity):
if messageProtocolEntity.getMediaType() == "image":
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom())
outImage = ImageDownloadableMediaMessageProtocolEntity(
messageProtocolEntity.getMimeType(),
messageProtocolEntity.fileHash,
messageProtocolEntity.url,
messageProtocolEntity.ip,
messageProtocolEntity.size,
messageProtocolEntity.fileName,
messageProtocolEntity.encoding,
messageProtocolEntity.width,
messageProtocolEntity.height,
messageProtocolEntity.getCaption(),
to=messageProtocolEntity.getFrom(),
preview=messageProtocolEntity.getPreview())
print("Echoing image %s to %s" %
(messageProtocolEntity.url,
messageProtocolEntity.getFrom(False)))
#send receipt otherwise we keep receiving the same message over and over
self.toLower(receipt)
self.toLower(outImage)
def onMediaMessage(self, mEntity):
if mEntity.getMediaType() == "image":
print("Echoing image %s to %s" %
(mEntity.url, mEntity.getFrom(False)))
elif mEntity.getMediaType() == "location":
print("Echoing location (%s, %s) to %s" %
(mEntity.getLatitude(), mEntity.getLongitude(),
mEntity.getFrom(False)))
elif mEntity.getMediaType() == "vcard":
print("Echoing vcard (%s, %s) to %s" %
(mEntity.getName(), mEntity.getCardData(),
mEntity.getFrom(False)))
id = mEntity.getId()
src = mEntity.getFrom()
tpe = mEntity.getMediaType()
url = getattr(mEntity, 'url', None)
print("<= WhatsApp: <- Media %s (%s)" % (tpe, src))
content = "Received a media of type: %s\n" % (tpe)
content += "URL: %s\n" % (url)
content += str(mEntity)
self.sendEmail(mEntity, "Media: %s" % (tpe), content)
receipt = OutgoingReceiptProtocolEntity(id, src)
self.toLower(receipt)
def onMessage(self, messageProtocolEntity):
#send receipt otherwise we keep receiving the same message over and over
if True:
print("Sending receipt")
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom(),
'read', messageProtocolEntity.getParticipant())
#outgoingMessageProtocolEntity = TextMessageProtocolEntity(
# messageProtocolEntity.getBody(),
# to = messageProtocolEntity.getFrom())
#self.toLower(receipt)
#self.toLower(outgoingMessageProtocolEntity)
t = messageProtocolEntity.getBody()
f = messageProtocolEntity.getFrom(False)
print("From: %s" % f)
if f == WA_NUMBER:
print("Message from myself!")
s = f.split('-')[0]
print("Split: %s" % s)
alias = self.jidToAlias(s)
print("Alias: %s" % alias)
if messageProtocolEntity.isGroupMessage():
print("Is group message")
g = f.split('-')[1]
g_alias = self.gidToAlias(g)
alias += '@' + g_alias
print("From: %s\nMessage: %s" % (alias, t))
sink_sms.send(IDENTIFIER, t, f)
def on_message(self, message: MessageProtocolEntity):
receipt = OutgoingReceiptProtocolEntity(
messageIds=message.getId(),
to=message.getFrom(),
read=True,
participant=message.getParticipant())
today = datetime.datetime.now().isocalendar()
target_dir = self.getProp(self.__class__.PROP_TARGET)
target_file = f'{today[0]}-{today[1]}-{today[2]}.json'
try:
nice_message = self._jsonify(message)
if nice_message:
with open(os.path.join(target_dir, target_file),
'a',
encoding='utf-8') as file:
file.write(nice_message)
file.write(os.linesep)
else:
log.info(
f'Did not write non-text message with ID {message.getId()}'
)
except Exception as e:
log.warning(f'Unable to write message: {str(e)}')
self.toLower(receipt)
def handleLocationMessage(self, originalEncNode, locationMessage):
try:
messageNode = copy.deepcopy(originalEncNode)
messageNode["type"] = "media"
mediaNode = ProtocolTreeNode("media", {
"latitude":
locationMessage.degrees_latitude,
"longitude":
locationMessage.degrees_longitude,
"name":
"%s %s" % (locationMessage.name, locationMessage.address),
"url":
locationMessage.url,
"encoding":
"raw",
"type":
"location"
},
data=locationMessage.jpeg_thumbnail)
messageNode.addChild(mediaNode)
self.toUpper(messageNode)
except:
if PROP_IGNORE_UNHANDLED:
self.toLower(
OutgoingReceiptProtocolEntity(
originalEncNode["id"],
originalEncNode["from"],
participant=originalEncNode["participant"]).
toProtocolTreeNode())
logger.warning("Unhandled message, sending delivery receipt")
else:
print(m)
raise ValueError("Unhandled")
def onMessage(self, entity):
self.toLower(
OutgoingReceiptProtocolEntity(entity.getId(), entity.getFrom(),
'read', entity.getParticipant()))
self.vkApi.messages.send(user_id=self.userId,
message='from: {getFrom}\n{getBody}'.format(
getFrom=entity.getFrom(),
getBody=entity.getBody()))
def handleEncMessage(self, node):
encMessageProtocolEntity = EncryptedMessageProtocolEntity.fromProtocolTreeNode(
node)
isGroup = node["participant"] is not None
senderJid = node["participant"] if isGroup else node["from"]
if node.getChild(
"enc")["v"] == "2" and node["from"] not in self.v2Jids:
self.v2Jids.append(node["from"])
try:
if encMessageProtocolEntity.getEnc(EncProtocolEntity.TYPE_PKMSG):
logger.debug("Handle preKey Whisper Message")
self.handlePreKeyWhisperMessage(node)
elif encMessageProtocolEntity.getEnc(EncProtocolEntity.TYPE_MSG):
logger.debug("Handle sender key message")
self.handleWhisperMessage(node)
if encMessageProtocolEntity.getEnc(EncProtocolEntity.TYPE_SKMSG):
logger.debug("Handle Sender KeyMessage")
self.handleSenderKeyMessage(node)
except (InvalidMessageException, InvalidKeyIdException) as e:
logger.warning(
"InvalidMessage or KeyId for %s, going to send a retry",
encMessageProtocolEntity.getAuthor(False))
retry = RetryOutgoingReceiptProtocolEntity.fromMessageNode(
node, self.store.getLocalRegistrationId())
self.toLower(retry.toProtocolTreeNode())
except NoSessionException as e:
logger.warning("No session for %s, getting their keys now",
encMessageProtocolEntity.getAuthor(False))
conversationIdentifier = (node["from"], node["participant"])
if conversationIdentifier not in self.pendingIncomingMessages:
self.pendingIncomingMessages[conversationIdentifier] = []
self.pendingIncomingMessages[conversationIdentifier].append(node)
successFn = lambda successJids, b: self.processPendingIncomingMessages(
*conversationIdentifier) if len(successJids) else None
self.getKeysFor([senderJid], successFn)
except DuplicateMessageException as e:
logger.warning(
"Received a message that we've previously decrypted, goint to send the delivery receipt myself"
)
self.toLower(
OutgoingReceiptProtocolEntity(
node["id"], node["from"],
participant=node["participant"]).toProtocolTreeNode())
except UntrustedIdentityException as e:
if self.getProp(PROP_IDENTITY_AUTOTRUST, False):
logger.warning("Autotrusting identity for %s", e.getName())
self.store.saveIdentity(e.getName(), e.getIdentityKey())
return self.handleEncMessage(node)
else:
logger.error("Ignoring message with untrusted identity")
except:
pass
def onMessage(self, messageProtocolEntity):
is_admin = 0
global send_next
send_next_ = send_next
admin_number = '*****@*****.**'
message = 'Whatsbot'
Demo_Message = "*WhatsBot*: \nSend Whatsapp messages by chatting with our WhatsBot."
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom(),
'read', messageProtocolEntity.getParticipant())
time.sleep(0.5)
self.toLower(receipt)
print("Message from " + messageProtocolEntity.getFrom())
if (messageProtocolEntity.getFrom() == (admin_number)):
print("IS admin number")
if send_next_ == 1:
list_cont = {'919417290392', '917508377911'}
if messageProtocolEntity.getType() == 'text':
try:
if ((messageProtocolEntity.getBody()
).index('WhatsBot --end') == 0):
send_next = 0
print("Sending Disabled")
else:
print("Sending Message")
except:
for contact_member in list_cont:
entity = OutgoingChatstateProtocolEntity(
ChatstateProtocolEntity.STATE_TYPING,
contact_member + '@s.whatsapp.net')
self.toLower(entity)
self.toLower(
messageProtocolEntity.forward(
contact_member + '@s.whatsapp.net'))
print("Sending to :", contact_member)
else:
print("Is media")
#for contact_member in list_cont:
#self.toLower(messageProtocolEntity.forward(contact_member+'@s.whatsapp.net'))
#print ("Sending to :", contact_member)
if messageProtocolEntity.getType() == 'text':
print("Is Text")
message = messageProtocolEntity.getBody()
try:
if ((messageProtocolEntity.getBody()
).index('WhatsBot --send') == 0):
send_next = 1
print("Send Next ")
except:
print("Message Passed")
else:
outgoingMessageProtocolEntity = TextMessageProtocolEntity(
Demo_Message, to=messageProtocolEntity.getFrom())
self.toLower(outgoingMessageProtocolEntity)
def processResponse(self, entity):
"""Marks the message as delivered and read."""
# mark as delivered
receipt = OutgoingReceiptProtocolEntity(entity.getId(),
entity.getFrom())
self.toLower(receipt)
# formated_response = "Hello world! This is a response message."
# mark as read
receipt = OutgoingReceiptProtocolEntity(entity.getId(),
entity.getFrom(), "read")
self.toLower(receipt)
# self.toLower(formated_response)
self.toLower(entity.ack())
self.toLower(entity.ack(True))
def retryAdd(self, node):
self.retryIncomingMessages[node["id"]] = (self.retryIncomingMessages[node["id"]] + 1) if node["id"] in self.retryIncomingMessages else 1
if self.retryIncomingMessages[node["id"]] > 5:
logger.warning("Too many retries!! Going to send the delivery receipt myself!")
self.toLower(OutgoingReceiptProtocolEntity(node["id"], node["from"], read=False, participant = node["participant"], t=node["t"]).toProtocolTreeNode())
else:
retry = RetryOutgoingReceiptProtocolEntity.fromMessageNode(node)
retry.setRegData(self.store.getLocalRegistrationId())
self.toLower(retry.toProtocolTreeNode())
def onMessage(self, messageProtocolEntity):
if messageProtocolEntity.getType() == 'text':
recv_msg.append((messageProtocolEntity.getFrom(),
messageProtocolEntity.getBody()))
#send receipt otherwise we keep receiving the same message over and over
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom())
self.toLower(receipt)
def onNotification(self, notification):
self.output(
"From :%s, Type: %s" %
(self.jidToAlias(notification.getFrom()), notification.getType()),
tag="Notification")
if self.sendReceipts:
receipt = OutgoingReceiptProtocolEntity(notification.getId(),
notification.getFrom())
self.toLower(receipt)
def onText(self, messageProtocolEntity):
if not messageProtocolEntity.isGroupMessage():
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom())
self.toLower(receipt)
#registrar mensagem recebida no BD
username = self.getStack().getProp(
YowAuthenticationProtocolLayer.PROP_CREDENTIALS)[0]
jid = messageProtocolEntity.getFrom()
cnx = mysql.connector.connect(user='******',
password='',
database='zapserver',
use_unicode=True)
cursor = cnx.cursor()
cursor.execute('SET NAMES utf8mb4')
cursor.execute("SET CHARACTER SET utf8mb4")
cursor.execute("SET character_set_connection=utf8mb4")
cursor.execute(
"insert into Queue(jidServer, jidClient, url, message, extension, imageLabel, status, dateTime) "
"values (%s,%s,%s,convert (%s using utf8mb4),'txt','',%s,%s)",
[
username,
jid.split('@')[0],
jid.split('@')[1],
messageProtocolEntity.getBody(), "R",
datetime.datetime.now()
])
cursor.execute(
"insert into Log(jidServer, jidClient, url, message, extension, status, dateTime)"
"values (%s,%s,%s,convert (%s using utf8mb4),'txt',%s,%s)", [
username,
jid.split('@')[0],
jid.split('@')[1],
messageProtocolEntity.getBody(), "R",
datetime.datetime.now()
])
cnx.commit()
cursor.close()
cnx.close()
print("Text %s received from %s" %
(messageProtocolEntity.getBody(),
messageProtocolEntity.getFrom(False)))
f = open(username + ".log", 'a')
f.write(
jid.split('@')[0] + ": " + messageProtocolEntity.getBody() +
" (" + str(datetime.datetime.now()) + ")\n")
f.close()
def respond(self, messageProtocolEntity, msg):
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom(),
'read', messageProtocolEntity.getParticipant())
outgoingMessageProtocolEntity = TextMessageProtocolEntity(
msg, to=messageProtocolEntity.getFrom())
self.toLower(receipt)
self.toLower(outgoingMessageProtocolEntity)
def onTextMessage(self, mEntity):
print("Echoing %s to %s" % (mEntity.getBody(), mEntity.getFrom(False)))
receipt = OutgoingReceiptProtocolEntity(mEntity.getId(),
mEntity.getFrom())
src = mEntity.getFrom()
print("<= WhatsApp: <- %s Message" % (src))
content = mEntity.getBody()
self.sendEmail(mEntity, content, content)
self.toLower(receipt)
def onTextMessage(self, mEntity):
receipt = OutgoingReceiptProtocolEntity(mEntity.getId(),
mEntity.getFrom())
src = mEntity.getFrom()
print("<= WhatsApp: <- %s Message" % (src))
content = mEntity.getBody()
self.sendEmail(mEntity, content, content)
if not args.dry:
self.toLower(receipt)
def onMessage(self, messageProtocolEntity):
if not messageProtocolEntity.isGroupMessage():
if messageProtocolEntity.getType() == 'text':
self.onTextMessage(messageProtocolEntity)
elif messageProtocolEntity.getType() == 'media':
self.onMediaMessage(messageProtocolEntity)
receipt = OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(), messageProtocolEntity.getFrom())
#send receipt otherwise we keep receiving the same message over and over
self.toLower(receipt)
def onMessage(self, messageProtocolEntity):
if True:
self.toLower(
OutgoingReceiptProtocolEntity(
messageProtocolEntity.getId(),
messageProtocolEntity.getFrom(), 'read',
messageProtocolEntity.getParticipant()))
self.toLower(
TextMessageProtocolEntity(c.input(
self.out(messageProtocolEntity)),
to=messageProtocolEntity.getFrom()))
def fromProtocolTreeNode(node):
entity = OutgoingReceiptProtocolEntity.fromProtocolTreeNode(node)
entity.__class__ = RetryOutgoingReceiptProtocolEntity
retryNode = node.getChild("retry")
entity.setRetryData(retryNode["t"], retryNode["v"], retryNode["count"], node.getChild("registration").data)
