示例#1
0
 def onMessage(self, messageProtocolEntity):
     if messageProtocolEntity.getType() == "text":
         time.sleep(0.5)
         self.toLower(messageProtocolEntity.ack())  # Set received (double v)
         time.sleep(0.5)
         self.toLower(PresenceProtocolEntity(name=name))  # Set name Presence
         time.sleep(0.5)
         self.toLower(AvailablePresenceProtocolEntity())  # Set online
         time.sleep(0.5)
         self.toLower(messageProtocolEntity.ack(True))  # Set read (double v blue)
         time.sleep(0.5)
         self.toLower(
             OutgoingChatstateProtocolEntity(
                 OutgoingChatstateProtocolEntity.STATE_TYPING, Jid.normalize(messageProtocolEntity.getFrom(False))
             )
         )  # Set is writing
         time.sleep(1)
         self.toLower(
             OutgoingChatstateProtocolEntity(
                 OutgoingChatstateProtocolEntity.STATE_PAUSED, Jid.normalize(messageProtocolEntity.getFrom(False))
             )
         )  # Set no is writing
         time.sleep(1)
         self.onTextMessage(messageProtocolEntity)  # Send the answer
         time.sleep(1)
         self.toLower(UnavailablePresenceProtocolEntity())  # Set offline
示例#2
0
 def onIq(self, entity):
     self.lock.acquire()
     for alert in self.alertQueue:
         message = alert['alert_text']
         messageEntity = TextMessageProtocolEntity(message, to = Jid.normalize(self.admin_phone))
         ack_id = messageEntity.getId()
         self.ackQueue.append(ack_id)
         self.sentQueue[ack_id] = alert;
         print(alert)
     self.lock.release()
示例#3
0
文件: layer.py 项目: mevinbabuc/aron
 def onSuccess(self, successProtocolEntity):
     # self.lock.acquire()
     for target in self.getProp(self.__class__.PROP_MESSAGES, []):
         #getProp() is trying to retreive the list of (jid, message) tuples, if none exist, use the default []
         phone, message = target
         messageEntity = TextMessageProtocolEntity(message, to = Jid.normalize(phone))
         #append the id of message to ackQueue list
         #which the id of message will be deleted when ack is received.
         # self.ackQueue.append(messageEntity.getId())
         self.toLower(messageEntity)
示例#4
0
    def handleEncNode(self, node):
        recipient_id = node["to"].split('@')[0]
        v2 = node["to"]
        if node.getChild("enc"):  # media enc is only for v2 messsages
            if '-' in recipient_id:  ## Handle Groups

                def getResultNodes(resultNode, requestEntity):
                    groupInfo = InfoGroupsResultIqProtocolEntity.fromProtocolTreeNode(
                        resultNode)
                    jids = list(groupInfo.getParticipants().keys()
                                )  #keys in py3 returns dict_keys
                    jids.remove(
                        self.getLayerInterface(
                            YowAuthenticationProtocolLayer).getUsername(True))
                    jidsNoSession = []
                    for jid in jids:
                        if not self.store.containsSession(
                                jid.split('@')[0], 1):
                            jidsNoSession.append(jid)
                    if len(jidsNoSession):
                        self.getKeysFor(
                            jidsNoSession, lambda successJids, b: self.
                            sendToGroupWithSessions(node, successJids))
                    else:
                        self.sendToGroupWithSessions(node, jids)

                groupInfoIq = InfoGroupsIqProtocolEntity(
                    Jid.normalize(node["to"]))
                self._sendIq(groupInfoIq, getResultNodes)
            else:
                messageData = self.serializeToProtobuf(node)
                if messageData:
                    if not self.store.containsSession(recipient_id, 1):

                        def on_get_keys(successJids, b):
                            print(successJids)
                            if len(successJids) == 1:
                                self.sendToContact(node)
                            else:
                                self.toLower(node)

                        self.getKeysFor([node["to"]], on_get_keys,
                                        lambda: self.toLower(node))
                    else:
                        sessionCipher = self.getSessionCipher(recipient_id)
                        messageData = messageData.SerializeToString(
                        ) + self.getPadding()
                        ciphertext = sessionCipher.encrypt(messageData)
                        mediaType = node.getChild(
                            "enc")["type"] if node.getChild("enc") else None

                        encEntity = EncryptedMessageProtocolEntity(
                            [
                                EncProtocolEntity(
                                    EncProtocolEntity.TYPE_MSG
                                    if ciphertext.__class__ == WhisperMessage
                                    else EncProtocolEntity.TYPE_PKMSG,
                                    2 if v2 else 1, ciphertext.serialize(),
                                    mediaType)
                            ],
                            "text" if not mediaType else "media",
                            _id=node["id"],
                            to=node["to"],
                            notify=node["notify"],
                            timestamp=node["timestamp"],
                            participant=node["participant"],
                            offline=node["offline"],
                            retry=node["retry"])
                        self.toLower(encEntity.toProtocolTreeNode())
                else:  # case of unserializable messages (audio, video) ?
                    self.toLower(node)
        else:
            self.toLower(node)
示例#5
0
 def alarmHandler():
     self.sendMsg("1pm Alarm!!", to=Jid.normalize('447760333610'))
     # set tomorrows alarm
     setAlarm()
示例#6
0
文件: layer.py 项目: zecjy/whats-spy
 def doSubscribe(self, numbers):
     for number in numbers:
         self.toLower(SubscribePresenceProtocolEntity(
             Jid.normalize(number)))
         time.sleep(0.1)
示例#7
0
 def media_send(self, number, path, mediaType, caption = None):
     jid = Jid.normalize(number)
     entity = RequestUploadIqProtocolEntity(mediaType, filePath=path)
     successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(jid, mediaType, path, successEntity, originalEntity, caption)
     errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(jid, path, errorEntity, originalEntity)
     self._sendIq(entity, successFn, errorFn)
示例#8
0
def start_typing(self, conversation):
    self.toLower(
        OutgoingChatstateProtocolEntity(
            OutgoingChatstateProtocolEntity.STATE_TYPING,
            Jid.normalize(conversation)))
示例#9
0
def contact_picture_from(number, success_fn=None, preview=False):
    jid = Jid.normalize(number)
    contact_picture(jid, success_fn, preview)
示例#10
0
def send_video_to(path, phone_number, caption=None):
    jid = Jid.normalize(phone_number)
    send_video(path, jid, caption)
示例#11
0
def make_message(msg, conversation):
    outgoing_message_enity = TextMessageProtocolEntity(
        msg, to=Jid.normalize(conversation))
    return outgoing_message_enity
示例#12
0
    def onMessage(self, messageProtocolEntity):
        try:
            if messageProtocolEntity.getType() == 'text':
                self.onTextMessage(messageProtocolEntity)
            elif messageProtocolEntity.getType() == 'media':
                self.onMediaMessage(messageProtocolEntity)
            
            #self.toLower(messageProtocolEntity.forward(messageProtocolEntity.getFrom()))
            self.toLower(messageProtocolEntity.ack())
            self.toLower(messageProtocolEntity.ack(True))
            
            phone = messageProtocolEntity.getFrom()
            messageBody = messageProtocolEntity.getBody()
            messageToBeSent = ""
            
            print phone
            print "**************";
            print messageProtocolEntity.getNotify()
            
            if messageProtocolEntity.getType() == 'text':
                #if isQuizActive(Jid.normalize(phone)):
                #    currentAnswer = getCurrentAnswer(Jid.normalize(phone));
                #    if currentAnswer == messageBody.lower():
                #        sender = messageProtocolEntity.getNotify();
                #        updateScore(Jid.normalize(phone), sender);
                #        messageToBeSent = getScore();
                #        messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone));
                #        self.toLower(messageEntity);
                #        updateQuestionCount(Jid.normalize(phone));
                #        if(wasLastQuestion):
                #            messageToBeSent = getFinalMessage(Jid.normalize(phone));
                #            messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone));
                #            self.toLower(messageEntity);
                #        else:
                #            messageToBeSent = getQuestion(Jid.normalize(phone));
                #            messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone));
                #            self.toLower(messageEntity);
                #
                #if 'start quiz' in messageBody.lower():
                #    if(startQuiz(Jid.normalize(phone)) == True):
                #        messageToBeSent = getIntroMessage();
                #        messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone));
                #        self.toLower(messageEntity)
                #        #wait 30 seconds
                #        messageToBeSent = getQuestion();
                #        messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone));
                #        self.toLower(messageEntity);
                #    else:
                #        messageToBeSent = "Quiz already in progress...";
                #        messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone))
                #        self.toLower(messageEntity)

                if 'happy' in messageBody.lower() or 'congrats' in messageBody.lower():
                    sendmessage = sendwish(messageBody)
                    if sendmessage == True:
                        self.toLower(messageProtocolEntity.forward(messageProtocolEntity.getFrom()))

                if 'meaning?' in messageBody.lower():
                    messageToBeSent = getmeaningfromapi(messageBody)
                    messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone))
                    self.toLower(messageEntity)

                if '#' in messageBody.lower():
                    messageToBeSent = gettweetsfromapi(messageBody)
                    messageEntity = TextMessageProtocolEntity(messageToBeSent, to = Jid.normalize(phone))
                    self.toLower(messageEntity)

                print (messageToBeSent)
        except Exception, e:
            print (e)
示例#13
0
 def aliasToJid(self, calias):
     return Jid.normalize(calias)
示例#14
0
    def aliasToJid(self, calias):
        for alias, ajid in self.jidAliases.items():
            if calias.lower() == alias.lower():
                return Jid.normalize(ajid)

        return Jid.normalize(calias)
示例#15
0
def stop_typing(self, message_entity):
    self.toLower(
        OutgoingChatstateProtocolEntity(
            OutgoingChatstateProtocolEntity.STATE_PAUSED,
            Jid.normalize(message_entity.getFrom(False))))
示例#16
0
def send_message_to(str_message, phone_number, disconnect_after=True):
    jid = Jid.normalize(phone_number)
    send_message(str_message, jid)
示例#17
0
 def onMessage(self, messageProtocolEntity):
     if messageProtocolEntity.getType() == 'text':
         time.sleep(0.5)
         self.toLower(messageProtocolEntity.ack()) #Set received (double v)
         time.sleep(0.5)
         self.toLower(PresenceProtocolEntity(name = name)) #Set name Presence
         time.sleep(0.5)
         self.toLower(AvailablePresenceProtocolEntity()) #Set online
         time.sleep(0.5)
         self.toLower(messageProtocolEntity.ack(True)) #Set read (double v blue)
         time.sleep(0.5)
         self.toLower(OutgoingChatstateProtocolEntity(OutgoingChatstateProtocolEntity.STATE_TYPING, Jid.normalize(messageProtocolEntity.getFrom(False)) )) #Set is writing
         time.sleep(1)
         self.toLower(OutgoingChatstateProtocolEntity(OutgoingChatstateProtocolEntity.STATE_PAUSED, Jid.normalize(messageProtocolEntity.getFrom(False)) )) #Set no is writing
         time.sleep(1)
         self.onTextMessage(messageProtocolEntity) #Send the answer
         time.sleep(1)
         self.toLower(UnavailablePresenceProtocolEntity()) #Set offline
示例#18
0
def send_audio_to(path, phone_number):
    jid = Jid.normalize(phone_number)
    send_audio(path, jid)
示例#19
0
def send_document_to(path, phone_number):
    jid = Jid.normalize(phone_number)
    send_document(path, jid)
示例#20
0
def contact_status_from(number, fn=None):
    jid = Jid.normalize(number)
    contact_status(jid, fn)
示例#21
0
	def onMessage(self, messageProtocolEntity):
		if messageProtocolEntity.getType() == 'text':
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			#Devine mensagem como enviada
			self.toLower(messageProtocolEntity.ack())
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			self.toLower(AvailablePresenceProtocolEntity())
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			self.toLower(PresenceProtocolEntity(name = name))
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			#Devine mensagem como visualisada
			self.toLower(messageProtocolEntity.ack(True))
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			self.toLower(OutgoingChatstateProtocolEntity(OutgoingChatstateProtocolEntity.STATE_TYPING, Jid.normalize(messageProtocolEntity.getFrom(False))))#Set esta escribiendo
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			#Envia a resposta
			self.onTextMessage(messageProtocolEntity)
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			self.toLower(OutgoingChatstateProtocolEntity(OutgoingChatstateProtocolEntity.STATE_PAUSED, Jid.normalize(messageProtocolEntity.getFrom(False))))#Set pausa
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			#Fica offline
			self.toLower(UnavailablePresenceProtocolEntity())
		elif messageProtocolEntity.getType() == 'media':
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			self.toLower(AvailablePresenceProtocolEntity())
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			self.toLower(PresenceProtocolEntity(name = name))#Set presencia
			self.onMediaMessage(messageProtocolEntity)
			self.toLower(messageProtocolEntity.ack())
			self.toLower(messageProtocolEntity.ack(True))
			time.sleep(random.randrange(Cfg.RAND_MIN,Cfg.RAND_MAX))
			self.toLower(UnavailablePresenceProtocolEntity())#Set offline
		else:
			pass
示例#22
0
def stop_typing(self, conversation):
    self.toLower(
        OutgoingChatstateProtocolEntity(
            OutgoingChatstateProtocolEntity.STATE_PAUSED,
            Jid.normalize(conversation)))
示例#23
0
 def sendMsg(self, text, to=Jid.normalize('447760333610-1485190753')):
     logging.info('Sent %s to %s', text, to)
     messageEntity = TextMessageProtocolEntity(text, to=to)
     self.toLower(messageEntity)
示例#24
0
    def aliasToJid(self, calias):
        for alias, ajid in self.jidAliases.items():
            if calias.lower() == alias.lower():
                return Jid.normalize(ajid)

        return Jid.normalize(calias)
示例#25
0
    def handleEncMessage(self, node):
        encMessageProtocolEntity = EncryptedMessageProtocolEntity(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):
                self.handlePreKeyWhisperMessage(node)
            elif encMessageProtocolEntity.getEnc(EncProtocolEntity.TYPE_MSG):
                self.handleWhisperMessage(node)
            if encMessageProtocolEntity.getEnc(EncProtocolEntity.TYPE_SKMSG):
                self.handleSenderKeyMessage(node)

        except (InvalidMessageException, InvalidKeyIdException):
            logger.warning(
                "InvalidMessage or InvalidKeyIdException for %s, would to send a retry",
                Jid.denormalize(encMessageProtocolEntity.getAuthor()))

            if node["count"] is not None:
                logger.warning("This is the second retry forget it")
                return

            from yowsup.layers.axolotl.protocolentities.iq_key_get import GetKeysIqProtocolEntity
            logger.info("Trying GetKeys for %s, getting keys now",
                        Jid.denormalize(encMessageProtocolEntity.getAuthor()))
            # entity = GetKeysIqProtocolEntity([Jid.denormalize(encMessageProtocolEntity.getAuthor())])

            retry = RetryOutgoingReceiptProtocolEntity.fromMessageNode(
                node, self.store.getLocalRegistrationId())
            self.toLower(retry.toProtocolTreeNode())

        except NoSessionException:
            logger.warning(
                "No session for %s, getting their keys now",
                Jid.denormalize(encMessageProtocolEntity.getAuthor()))

            conversationIdentifier = (node["from"], node["participant"])
            if conversationIdentifier not in self.pendingIncomingMessages:
                self.pendingIncomingMessages[conversationIdentifier] = []
            self.pendingIncomingMessages[conversationIdentifier].append(node)

            def successFn(successJids, _):
                return self.processPendingIncomingMessages(
                    *conversationIdentifier) if len(successJids) else None

            self.getKeysFor([senderJid], successFn)

        except 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())

        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")