def __init__(self, keepAlive=False, sendReceipts=False):
self.sendReceipts = sendReceipts
self.keepAlive = keepAlive
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.cm = connectionManager
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener(
"media_uploadRequestSuccess", self.onmedia_uploadRequestSuccess)
self.signalsInterface.registerListener(
"media_uploadRequestFailed", self.onmedia_uploadRequestFailed)
self.signalsInterface.registerListener(
"media_uploadRequestDuplicate",
self.onmedia_uploadRequestDuplicate)
class LibInterfaceHandler(InterfaceHandlerBase): def __init__(self, username): self.connectionManager = YowsupConnectionManager() self.connectionManager.setAutoPong(True) self.signalInterface = self.connectionManager.getSignalsInterface() self.methodInterface = self.connectionManager.getMethodsInterface() super(LibInterfaceHandler,self).__init__(); self.initSignals() self.initMethods() def initSignals(self): self.signals = self.signalInterface.getSignals() def initMethods(self): #get methods self.methods = self.methodInterface.getMethods() def connectToSignal(self, signalName, callback): if not self.isSignal(signalName): raise InvalidSignalException() self.signalInterface.registerListener(signalName, callback) def call(self, methodName, params = ()): if not self.isMethod(methodName): raise InvalidMethodException() return self.methodInterface.call(methodName, params)
def __init__(self, target, message, waitForReceipt=False):
self.jids = []
if '-' in target:
self.jids = ["*****@*****.**" % target]
else:
self.jids = ["*****@*****.**" % t for t in target.split(',')]
self.message = message
self.waitForReceipt = waitForReceipt
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
if waitForReceipt:
self.signalsInterface.registerListener("receipt_messageSent",
self.onMessageSent)
self.gotReceipt = False
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.done = False
def __init__(self, app, keepAlive = False, sendReceipts = False):
self.sendReceipts = sendReceipts
self.app = app
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived", self.onGroupMessageReceived)
self.signalsInterface.registerListener("image_received", self.onImageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("contact_gotProfilePicture", self.onGotProfilePicture)
self.signalsInterface.registerListener("profile_setStatusSuccess", self.onSetStatusSuccess)
self.signalsInterface.registerListener("group_createSuccess", self.onGroupCreateSuccess)
self.signalsInterface.registerListener("group_createFail", self.onGroupCreateFail)
self.signalsInterface.registerListener("group_gotInfo", self.onGroupGotInfo)
self.signalsInterface.registerListener("group_addParticipantsSuccess", self.onGroupAddParticipantsSuccess)
self.cm = connectionManager
self.url = os.getenv('SERVER_URL', 'http://localhost:3000')
self.post_headers = {'Content-type': 'application/json', 'Accept': 'application/json'}
self.done = False
def __init__(self, keepAlive=False, sendReceipts=False, dryRun=False):
self.sendReceipts = sendReceipts
self.dryRun = dryRun
# Initialize
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
# Configure the listeners
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived", self.onGroupMessageReceived)
self.signalsInterface.registerListener("image_received", self.onImageReceived)
self.signalsInterface.registerListener("group_imageReceived", self.onGroupImageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
# Create a printqueue so we won't print two things at the same time
self.queue = Queue.PriorityQueue()
self.history = [] #List of timestamp, action, item
self.printer = None
self.last_sender = None
self.connected = False
def inicia_whatsapp():
#Se hacen publicas las variables de la conexion
global y
global signalsInterface
global methodsInterface
global contador
global vaciado_mensajes_offline
y = YowsupConnectionManager()
y.setAutoPong(True) #Responder a los ping que hagan
signalsInterface = y.getSignalsInterface() #Se recibiran las senales
methodsInterface = y.getMethodsInterface() #Se utilizaran los metodos
signalsInterface.registerListener("message_received", onMessageReceived)
signalsInterface.registerListener("receipt_messageSent", onMessageSent)
signalsInterface.registerListener("receipt_messageDelivered", onMessageDelivered)
signalsInterface.registerListener("auth_success", onAuthSuccess)
signalsInterface.registerListener("ping", onPing)
signalsInterface.registerListener("disconnected", onDisconnected)
methodsInterface.call("auth_login", (username, password))
methodsInterface.call("ready")
#Leer todos los mensajes offline y no analizarlos
contador = 0
vaciado_mensajes_offline = False
while (contador<10): #Contador se pondra a cero cada vez que salta la interrupcion de un mensaje
contador += 1
time.sleep(0.1)
#Cuando sale del while ha pasado 1 segundo sin recibir mensajes
vaciado_mensajes_offline = True
#Aqui ponemos nuestro numero de movil principal para que abrá una conversación como que la pi está operativa
methodsInterface.call("message_send", ("*****@*****.**", 'Reset'))
def __init__(self, phoneNumber, keepAlive = False, sendReceipts = False):
self.sendReceipts = sendReceipts
self.phoneNumber = phoneNumber
self.jid = "*****@*****.**" % phoneNumber
self.sentCache = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("presence_updated", self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.commandMappings = {"lastseen":lambda: self.methodsInterface.call("presence_request", ( self.jid,)),
"available": lambda: self.methodsInterface.call("presence_sendAvailable"),
"unavailable": lambda: self.methodsInterface.call("presence_sendUnavailable"),
"crypt": None,
"close": None
}
self.done = False
#signalsInterface.registerListener("receipt_messageDelivered", lambda jid, messageId: methodsInterface.call("delivered_ack", (jid, messageId)))
#for encrypted communication
self.decrRcvMsgKey = myRsa().create() #generate my rsa keys
self.encrSendMsgKey = None
self.encrProtocolStatus = 0 # 1: request made, 2:request arrived, 3: com. is encrypted
def __init__(self, phoneNumber, keepAlive=False, sendReceipts=False):
self.sendReceipts = sendReceipts
self.phoneNumber = phoneNumber
self.jid = "*****@*****.**" % phoneNumber
self.sentCache = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent",
self.onMessageSent)
self.signalsInterface.registerListener("presence_updated",
self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.commandMappings = {
"lastseen":
lambda: self.methodsInterface.call("presence_request",
(self.jid, )),
"available":
lambda: self.methodsInterface.call("presence_sendAvailable"),
"unavailable":
lambda: self.methodsInterface.call("presence_sendUnavailable")
}
self.done = False
def __init__(self, phoneNumber, message, waitForReceipt=False):
if '-' in phoneNumber:
self.jid = "*****@*****.**" % phoneNumber
else:
self.jid = "*****@*****.**" % phoneNumber
self.message = message
self.waitForReceipt = waitForReceipt
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
if waitForReceipt:
self.signalsInterface.registerListener("receipt_messageSent",
self.onMessageSent)
self.gotReceipt = False
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.done = False
def __init__(self, phoneNumber, keepAlive = False, sendReceipts = False):
self.sendReceipts = sendReceipts
self.phoneNumber = phoneNumber
self.jid = "*****@*****.**" % phoneNumber
self.sentCache = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("presence_updated", self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.commandMappings = {"lastseen":lambda: self.methodsInterface.call("presence_request", ( self.jid,)),
"available": lambda: self.methodsInterface.call("presence_sendAvailable"),
"unavailable": lambda: self.methodsInterface.call("presence_sendUnavailable")
}
self.done = False
def __init__(self, url, keepAlive = False, sendReceipts = False):
super(Server, self).__init__()
self.sendReceipts = sendReceipts
self.keepAlive = keepAlive
self.db = create_engine(url, echo=False, pool_size=10, pool_timeout=600,pool_recycle=300)
self.Session = sessionmaker(bind=self.db)
self.s = self.Session()
self.job = None
self.pubnub = Pubnub(os.environ['PUB_KEY'], os.environ['SUB_KEY'], None, False)
self.timeout = int(os.getenv('TIMEOUT', 3600))
connectionManager = YowsupConnectionManager(self.timeout)
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived", self.onGroupMessageReceived)
self.signalsInterface.registerListener("image_received", self.onImageReceived)
self.signalsInterface.registerListener("video_received", self.onVideoReceived)
self.signalsInterface.registerListener("audio_received", self.onAudioReceived)
self.signalsInterface.registerListener("vcard_received", self.onVCardReceived)
self.signalsInterface.registerListener("location_received", self.onLocationReceived)
self.signalsInterface.registerListener("receipt_messageSent", self.onReceiptMessageSent)
self.signalsInterface.registerListener("receipt_messageDelivered", self.onReceiptMessageDelivered)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("contact_gotProfilePicture", self.onGotProfilePicture)
self.signalsInterface.registerListener("profile_setStatusSuccess", self.onSetStatusSuccess)
self.signalsInterface.registerListener("group_createSuccess", self.onGroupCreateSuccess)
self.signalsInterface.registerListener("group_createFail", self.onGroupCreateFail)
self.signalsInterface.registerListener("group_gotInfo", self.onGroupGotInfo)
self.signalsInterface.registerListener("group_addParticipantsSuccess", self.onGroupAddParticipantsSuccess)
self.signalsInterface.registerListener("group_removeParticipantsSuccess", self.onGroupRemoveParticipantsSuccess)
self.signalsInterface.registerListener("group_imageReceived", self.onGroupImageReceived)
self.signalsInterface.registerListener("group_subjectReceived", self.onGroupSubjectReceived)
self.signalsInterface.registerListener("notification_removedFromGroup", self.onNotificationRemovedFromGroup)
self.signalsInterface.registerListener("notification_groupParticipantAdded", self.onNotificationGroupParticipantAdded)
self.signalsInterface.registerListener("group_gotParticipants", self.onGotGroupParticipants)
self.signalsInterface.registerListener("media_uploadRequestSuccess", self.onUploadRequestSuccess)
# self.signalsInterface.registerListener("media_uploadRequestFailed", self.onUploadRequestFailed)
self.signalsInterface.registerListener("media_uploadRequestDuplicate", self.onUploadRequestDuplicate)
self.signalsInterface.registerListener("presence_available", self.onPresenceAvailable)
self.signalsInterface.registerListener("presence_unavailable", self.onPresenceUnavailable)
self.cm = connectionManager
self.url = os.environ['URL']
self.post_headers = {'Content-type': 'application/json', 'Accept': 'application/json'}
self.done = False
def __init__(self):
self.sendReceipts = True
self.groupMembership = {}
self.groupParticipants = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived", self.onGroupMessageReceived)
self.signalsInterface.registerListener("group_subjectReceived", self.onGroupSubjectReceived)
self.signalsInterface.registerListener("group_gotInfo", self.onGroupGotInfo)
self.signalsInterface.registerListener("group_gotParticipants", self.onGroupGotParticipants)
self.signalsInterface.registerListener("group_imageReceived", self.onGroupImageReceived)
self.signalsInterface.registerListener("group_videoReceived", self.onGroupVideoReceived)
self.signalsInterface.registerListener("group_audioReceived", self.onGroupAudioReceived)
self.signalsInterface.registerListener("group_locationReceived", self.onGroupLocationReceived)
self.signalsInterface.registerListener("group_vcardReceived", self.onGroupVcardReceived)
self.signalsInterface.registerListener("notification_groupParticipantRemoved", self.onNotificationGroupParticipantRemoved)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.cm = connectionManager
def __init__(self, user, password, phone):
"""WhatsAppClient's constructor.
Args:
user (str): the local phone number.
password (str): the WhatsApp password of 'user'.
phone (str): the remote phone number.
"""
super().__init__()
self.user = user
try:
self.password = base64.b64decode(bytes(password.encode("utf-8")))
except base64.binascii.Error: # Lets Yowsup handle the error.
self.password = bytes(password.encode("utf-8"))
# Users are identified in WhatsApp by their phone number (plus the
# code) followed by the domain '@s.whatsapp.net'.
self.phone = phone + "@s.whatsapp.net"
self.connected = False
# Yowsup managers and signals setting up.
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("image_received", self.onImageReceived)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
def __init__(self, config, keepAlive=False, sendReceipts=False, dryRun=False):
self.sendReceipts = sendReceipts
self.dryRun = dryRun
self.config = config
# Initialize
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
# Configure the listeners
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("presence_updated", self.onPresenceUpdated)
self.signalsInterface.registerListener("presence_available", self.onPresenceAvailable)
self.signalsInterface.registerListener("presence_unavailable", self.onPresenceUnavailable)
# Create a queue so we can stash the incoming data somewhere
self.events = Queue.PriorityQueue()
# Dictionary of contacts with their names
self.names = dict(config['jids'])
self.contacts = [jid for jid, name in config['jids']]
# A count of events for each interval for each contact
self.tally = defaultdict(lambda: dict((jid, 0) for jid in self.contacts))
self.printer = None
self.connected = False
self.lastline, self.nextline = findInterval(LINE_INTERVAL)
self.nth = 0
def __init__(self, keepAlive = True, sendReceipts = True):
self.sendReceipts = sendReceipts
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("message_error", self.onError)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("receipt_messageDelivered", self.onMessageDelivered)
self.signalsInterface.registerListener("image_received", self.onImageReceived)
self.cm = connectionManager
self.message_queue = Queue()
self.image_queue = Queue()
self.reply_dic = {}
self.running = True
def __init__(self, keepAlive = False, sendReceipts = False):
self.sendReceipts = sendReceipts
self.redis=redis.Redis()
self.queue_key = 'MESSAGES_LISTS'
self.MODE_CONNECTED=1
self.MODE_DISCONNECTED=2
self.MODE_CONNECTING=3
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("receipt_messageDelivered",self.messageReceived)
#self.signalsInterface.registerListener("receipt_messageDelivered", lambda jid, messageId: methodsInterface.call("delivered_ack", (jid, messageId)))
self.cm = connectionManager
def __init__(self, keepAlive=False, sendReceipts=False):
self.sendReceipts = sendReceipts
self.redis = redis.Redis()
self.queue_key = 'MESSAGES_LISTS'
self.MODE_CONNECTED = 1
self.MODE_DISCONNECTED = 2
self.MODE_CONNECTING = 3
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("receipt_messageSent",
self.onMessageSent)
self.signalsInterface.registerListener("receipt_messageDelivered",
self.messageReceived)
#self.signalsInterface.registerListener("receipt_messageDelivered", lambda jid, messageId: methodsInterface.call("delivered_ack", (jid, messageId)))
self.cm = connectionManager
def __init__(self, phoneNumber):
self.sendReceipts = True
self.phoneNumber = phoneNumber
self.jid = "*****@*****.**" % phoneNumber
self.sentCache = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("presence_updated", self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("sync_contactsReceived", self.onSyncContacts)
self.signalsInterface.registerListener("sync_statusesReceived", self.onSyncStatuses)
self.commandMappings = {"lastseen":lambda: self.methodsInterface.call("presence_request", ( self.jid,)),
"available": lambda: self.methodsInterface.call("presence_sendAvailable"),
"unavailable": lambda: self.methodsInterface.call("presence_sendUnavailable"),
"sync": lambda number: self.methodsInterface.call("sync_sendContacts", ([number],)),
"status": lambda cjid: self.methodsInterface.call("sync_getStatuses", ([cjid],))
}
self.done = False
def __init__(self, app, keepAlive=False, sendReceipts=False):
self.sendReceipts = sendReceipts
self.app = app
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("image_received",
self.onImageReceived)
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("contact_gotProfilePicture",
self.onGotProfilePicture)
self.cm = connectionManager
self.done = False
class LibInterfaceHandler(InterfaceHandlerBase):
def __init__(self, username):
self.connectionManager = YowsupConnectionManager()
self.connectionManager.setAutoPong(True)
self.signalInterface = self.connectionManager.getSignalsInterface()
self.methodInterface = self.connectionManager.getMethodsInterface()
super(LibInterfaceHandler, self).__init__()
self.initSignals()
self.initMethods()
def initSignals(self):
self.signals = self.signalInterface.getSignals()
def initMethods(self):
#get methods
self.methods = self.methodInterface.getMethods()
def connectToSignal(self, signalName, callback):
if not self.isSignal(signalName):
raise InvalidSignalException()
self.signalInterface.registerListener(signalName, callback)
def call(self, methodName, params=()):
if not self.isMethod(methodName):
raise InvalidMethodException()
return self.methodInterface.call(methodName, params)
def __init__(self, sendReceipts = True, timeout = 5):
""" __init__"""
self.timeout = timeout
self.done = False
self.path = ""
self.gotMediaReceipt = False
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
# self.signalsInterface.registerListener("profile_setPictureSuccess", self.onSetPictureSuccess)
# self.signalsInterface.registerListener("profile_setPictureError", self.onSetPictureError)
# self.signalsInterface.registerListener("profile_setStatusSuccess", self.onSetStatusSuccess)
# self.signalsInterface.registerListener("presence_updated", self.onPresenceUpdated)
# self.signalsInterface.registerListener("presence_available", self.onPresenceAvailable)
# self.signalsInterface.registerListener("presence_unavailable", self.onPresenceUnavailable)
self.signalsInterface.registerListener("media_uploadRequestSuccess", self.onMediaUploadRequestSuccess)
self.signalsInterface.registerListener("media_uploadRequestFailed", self.onMediaUploadRequestFailure)
self.signalsInterface.registerListener("media_uploadRequestDuplicate", self.onMediaUploadRequestDuplicate)
def __init__(self, login, password):
connectionManager = YowsupConnectionManager()
self.signals = connectionManager.getSignalsInterface()
self.methods = connectionManager.getMethodsInterface()
self.signals.registerListener("auth_success", self.onAuthSuccess)
self.signals.registerListener("auth_fail", self.onAuthFailed)
self.login = login
self.password = base64.b64decode(bytes(password.encode('utf-8')))
self.done = False
def __init__(self, status):
self.status=status
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.done = False
def __init__(self, keepAlive = False, sendReceipts = True):
self.sendReceipts = sendReceipts
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived", self.onGroupMessageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("presence_updated", self.onPresence_updated)
self.signalsInterface.registerListener("presence_available", self.onPresence_available)
self.signalsInterface.registerListener("presence_unavailable", self.onPresence_unavailable)
self.signalsInterface.registerListener("contact_gotProfilePicture", self.onContact_gotProfilePicture)
self.signalsInterface.registerListener("profile_setStatusSuccess", self.onProfile_setStatusSuccess)
self.signalsInterface.registerListener("status_dirty", self.onStatus_dirty)
self.signalsInterface.registerListener("contact_gotProfilePictureId", self.onContact_gotProfilePictureId)
self.signalsInterface.registerListener("contact_gotProfilePicture", self.onContact_gotProfilePicture)
self.signalsInterface.registerListener("group_gotParticipants", self.onGroup_gotParticipants)
self.cm = connectionManager
self.db = MyZODB('Data/Data.fs')
self.dbroot = self.db.dbroot
if not self.dbroot.has_key("groups"):
self.dbroot["groups"] = PersistentMapping()
if not self.dbroot.has_key("messages"):
self.dbroot["messages"] = PersistentMapping()
if not self.dbroot.has_key("config"):
self.dbroot["config"] = PersistentMapping()
if not self.dbroot.has_key("features"):
self.dbroot["features"] = PersistentMapping()
if not self.dbroot.has_key("contacts"):
self.dbroot["contacts"] = PersistentMapping()
if not self.dbroot.has_key("chats"):
self.dbroot['chats'] = PersistentMapping()
if not self.dbroot['features'].has_key("responses"):
self.dbroot['features']['responses'] = PersistentMapping()
if not self.dbroot['features'].has_key("outbox"):
self.dbroot['features']['outbox'] = PersistentList()
self.outbox=self.dbroot['features']['outbox']
self.outboxempty=False
self.outboxprocessing=False
def __init__(self, phone_number):
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
# self.signalsInterface.registerListener("profile_setPictureSuccess", self.onSetProfilePicture)
# self.signalsInterface.registerListener("profile_setPictureError", self.onSetProfilePictureError)
self.signalsInterface.registerListener("contact_gotProfilePicture", self.onGotProfilePicture)
# self.signalsInterface.registerListener("profile_setStatusSuccess", self.onSetStatusSuccess)
self.phone_number = phone_number
self.done = False
def __init__(self, keepAlive = False, sendReceipts = False):
self.sendReceipts = sendReceipts
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.cm = connectionManager
def __init__(self, target, waitForReceipt=True):
self.jid = target
jid = self.jid
print(jid)
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("contact_gotProfilePicture", self.onProfilePicture)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
def setup():
global cm, signals_interface, methods_interface
Debugger.enabled = False
cm = YowsupConnectionManager()
cm.setAutoPong(True)
signals_interface = cm.getSignalsInterface()
methods_interface = cm.getMethodsInterface()
signals_interface.registerListener('auth_success', cb_auth_success)
signals_interface.registerListener('auth_fail', cb_auth_fail)
signals_interface.registerListener('disconnected', cb_disconnected)
def __init__(self, login, password, keepAlive=False, autoack=False):
logging.info("bot created")
self.sendReceipts = autoack
self.username = login
self.password = password
self.stayon = True
#self.setup()
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
dirs = ["downloads", "logs", "modules", "configs"]
for folder in dirs:
if not os.path.isdir(folder):
print "missing directory %s. Creating it." % folder
modules.misctools.mkdir_p(folder)
self.clientsinfofile = os.path.join('configs', 'clientsinfo')
try:
with open(self.clientsinfofile, 'r') as clientsinfofileobj:
self.clientsinfo = json.load(clientsinfofileobj)
print "loaded clients", self.clientsinfo
except IOError:
print "No client registered/talked to yet"
self.clientsinfo = {}
self.adminfile = os.path.join('configs', 'admin')
try:
with open(self.adminfile, 'r') as adminfileobj:
self.admin = json.load(adminfileobj)
print "admin is", self.admin
except IOError:
print "No admin set. please set by saving admin in configs/admin"
self.admin = "noneset"
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.signals.append("command")
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
for module in vars(modules).values():
if hasattr(module, "setup"):
module.setup(self)
def __init__(self, phoneNumber, keepAlive=False, sendReceipts=False):
self.ui = Gtk.Builder()
#self.ui.set_translation_domain(APP_NAME)
self.ui.add_from_file('Examples/window.ui')
self.ui.connect_signals(self)
self.window = self.ui.get_object('window')
self.window.connect('destroy', self.stop_loop)
self.messagesbuffer = self.ui.get_object('messagesbuffer')
self.debugbuffer = self.ui.get_object('debugbuffer')
self.messageentry = self.ui.get_object('messageentry')
self.scrolleddebugwindow = self.ui.get_object('scrolleddebugwindow')
self.autoscrollmenuitem = self.ui.get_object('autoscrollmenuitem')
self.autoscrollbutton = self.ui.get_object('autoscrollbutton')
self.chatlabel = self.ui.get_object('chatlabel')
self.chatlabel.set_text('Chat with +%s' % phoneNumber)
self.sendReceipts = sendReceipts
self.phoneNumber = phoneNumber
self.jid = "*****@*****.**" % phoneNumber
self.sentCache = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("presence_updated", self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.commandMappings = {"lastseen": lambda: self.methodsInterface.call("presence_request", (self.jid,)),
"available": lambda: self.methodsInterface.call("presence_sendAvailable"),
"unavailable": lambda: self.methodsInterface.call("presence_sendUnavailable"),
"quit": lambda: self.stop_loop()
}
self.done = False
self.run_loop = True
self.autoscroll = True
self.window.show_all()
prompt = self.getPrompt() + '\n'
self.messagesbuffer.insert_at_cursor(prompt, len(prompt))
def __init__(self,login,password,keepAlive=False,autoack=False):
logging.info("bot created")
self.sendReceipts = autoack
self.username=login
self.password=password
self.stayon=True
#self.setup()
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
dirs=["downloads","logs","modules","configs"]
for folder in dirs:
if not os.path.isdir(folder):
print "missing directory %s. Creating it." % folder
modules.misctools.mkdir_p(folder)
self.clientsinfofile=os.path.join('configs','clientsinfo')
try:
with open(self.clientsinfofile,'r') as clientsinfofileobj:
self.clientsinfo=json.load(clientsinfofileobj)
print "loaded clients",self.clientsinfo
except IOError:
print "No client registered/talked to yet"
self.clientsinfo={}
self.adminfile=os.path.join('configs','admin')
try:
with open(self.adminfile,'r') as adminfileobj:
self.admin=json.load(adminfileobj)
print "admin is",self.admin
except IOError:
print "No admin set. please set by saving admin in configs/admin"
self.admin="noneset"
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.signals.append("command")
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
for module in vars(modules).values():
if hasattr(module,"setup"):
module.setup(self)
def __init__(self, phone_number):
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
# self.signalsInterface.registerListener("profile_setPictureSuccess", self.onSetProfilePicture)
# self.signalsInterface.registerListener("profile_setPictureError", self.onSetProfilePictureError)
self.signalsInterface.registerListener("contact_gotProfilePicture",
self.onGotProfilePicture)
# self.signalsInterface.registerListener("profile_setStatusSuccess", self.onSetStatusSuccess)
self.phone_number = phone_number
self.done = False
def __init__(self, username, password, boxClient, keepAlive = False, sendReceipts = False):
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.cm = connectionManager
self.sendReceipts = sendReceipts
self.username = username
self.password = base64.b64decode(bytes(password.encode('utf-8')))
self.boxClient = boxClient
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
def startConnection(self):
trace_start("trace.html")
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("ping", self.onPing)
self.gotReceipt = 0
self.cm = connectionManager
self.fileName="defaultFileName"
def __init__(self, keepAlive = True, sendReceipts = False):
self.sendReceipts = sendReceipts
connectionManager = YowsupConnectionManager()
#connectionManager.setAutoPong(keepAlive)
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived", self.group_messageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.cm = connectionManager
def __init__(self, target, waitForReceipt=True):
self.jid = target
jid = self.jid
print(jid)
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("contact_gotProfilePicture",
self.onProfilePicture)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
def __init__(self, phoneNumber):
self.sendReceipts = True
self.phoneNumber = phoneNumber
self.jid = "*****@*****.**" % phoneNumber
self.sentCache = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent",
self.onMessageSent)
self.signalsInterface.registerListener("presence_updated",
self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("sync_contactsReceived",
self.onSyncContacts)
self.signalsInterface.registerListener("sync_statusesReceived",
self.onSyncStatuses)
self.commandMappings = {
"lastseen":
lambda: self.methodsInterface.call("presence_request",
(self.jid, )),
"available":
lambda: self.methodsInterface.call("presence_sendAvailable"),
"unavailable":
lambda: self.methodsInterface.call("presence_sendUnavailable"),
"sync":
lambda number: self.methodsInterface.call("sync_sendContacts",
([number], )),
"status":
lambda cjid: self.methodsInterface.call("sync_getStatuses",
([cjid], ))
}
self.done = False
def setup():
global cm, signals_interface, methods_interface
Debugger.enabled = False
cm = YowsupConnectionManager()
cm.setAutoPong(True)
signals_interface = cm.getSignalsInterface()
methods_interface = cm.getMethodsInterface()
signals_interface.registerListener('auth_success', cb_auth_success)
signals_interface.registerListener('auth_fail', cb_auth_fail)
signals_interface.registerListener('contact_gotProfilePicture', cb_contact_gotProfilePicture)
signals_interface.registerListener('receipt_messageSent', cb_message_sent)
signals_interface.registerListener('receipt_messageDelivered', cb_message_delivered)
def __init__(self, phoneNumber, message, waitForReceipt=False):
self.jid = "*****@*****.**" % phoneNumber
self.message = message
self.waitForReceipt = waitForReceipt
connectionManager = YowsupConnectionManager()
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
if waitForReceipt:
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.gotReceipt = False
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.done = False
def __init__(self, username, password, phoneNumber, keepAlive = False, sendReceipts = False):
self.sendReceipts = sendReceipts
self.phoneNumber = phoneNumber
self.keepAlive = keepAlive
self.jid = "*****@*****.**" % phoneNumber
self.sentCache = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(self.keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("presence_updated", self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_size_request(500, 350)
self.window.set_border_width(10)
self.window.set_title('cchat')
self.window.connect('delete_event',self.close_window)
self.vcontainer = gtk.VBox(False, 0)
self.hcontainer = gtk.HBox(False, 0)
self.chatview = gtk.ScrolledWindow()
self.chatview.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.textview = gtk.TextView()
self.textview.set_editable(False)
self.textview.set_cursor_visible(False)
self.textview.set_wrap_mode(gtk.WRAP_WORD)
self.text_buffer = self.textview.get_buffer()
self.chatview.add(self.textview)
self.chatview.show()
self.vcontainer.pack_start(self.chatview)
self.textbox = gtk.Entry()
self.send_button = gtk.Button('Send')
self.send_button.connect('clicked', self.send)
self.hcontainer.pack_start(self.textbox)
self.hcontainer.pack_end(self.send_button)
self.vcontainer.pack_end(self.hcontainer)
self.window.show_all()
def __init__(self, app, keepAlive=False, sendReceipts=False):
self.sendReceipts = sendReceipts
self.app = app
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived",
self.onGroupMessageReceived)
self.signalsInterface.registerListener("image_received",
self.onImageReceived)
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("contact_gotProfilePicture",
self.onGotProfilePicture)
self.signalsInterface.registerListener("profile_setStatusSuccess",
self.onSetStatusSuccess)
self.signalsInterface.registerListener("group_createSuccess",
self.onGroupCreateSuccess)
self.signalsInterface.registerListener("group_createFail",
self.onGroupCreateFail)
self.signalsInterface.registerListener("group_gotInfo",
self.onGroupGotInfo)
self.signalsInterface.registerListener(
"group_addParticipantsSuccess", self.onGroupAddParticipantsSuccess)
self.cm = connectionManager
self.url = os.getenv('SERVER_URL', 'http://localhost:3000')
self.post_headers = {
'Content-type': 'application/json',
'Accept': 'application/json'
}
self.done = False
def __init__(self):
self.sendReceipts = True
self.groupMembership = {}
self.groupParticipants = {}
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived",
self.onGroupMessageReceived)
self.signalsInterface.registerListener("group_subjectReceived",
self.onGroupSubjectReceived)
self.signalsInterface.registerListener("group_gotInfo",
self.onGroupGotInfo)
self.signalsInterface.registerListener("group_gotParticipants",
self.onGroupGotParticipants)
self.signalsInterface.registerListener("group_imageReceived",
self.onGroupImageReceived)
self.signalsInterface.registerListener("group_videoReceived",
self.onGroupVideoReceived)
self.signalsInterface.registerListener("group_audioReceived",
self.onGroupAudioReceived)
self.signalsInterface.registerListener("group_locationReceived",
self.onGroupLocationReceived)
self.signalsInterface.registerListener("group_vcardReceived",
self.onGroupVcardReceived)
self.signalsInterface.registerListener(
"notification_groupParticipantRemoved",
self.onNotificationGroupParticipantRemoved)
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.cm = connectionManager
def setup():
global cm, signals_interface, methods_interface
Debugger.enabled = False
cm = YowsupConnectionManager()
cm.setAutoPong(True)
signals_interface = cm.getSignalsInterface()
methods_interface = cm.getMethodsInterface()
signals_interface.registerListener('auth_success', cb_auth_success)
signals_interface.registerListener('auth_fail', cb_auth_fail)
signals_interface.registerListener('contact_gotProfilePicture',
cb_contact_gotProfilePicture)
signals_interface.registerListener('receipt_messageSent', cb_message_sent)
signals_interface.registerListener('receipt_messageDelivered',
cb_message_delivered)
def __init__(self, app, keepAlive = False, sendReceipts = False):
self.sendReceipts = sendReceipts
self.app = app
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("image_received", self.onImageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("contact_gotProfilePicture", self.onGotProfilePicture)
self.cm = connectionManager
self.done = False
def __init__(self, admin_phone, keep_alive=False, send_receipts=False):
self.send_receipts = send_receipts
self.keep_alive = keep_alive
self.admin_phone = admin_phone
self.admin_jid = JID_BASE % admin_phone
# Configure connection manager
connection_manager = YowsupConnectionManager()
connection_manager.setAutoPong(keep_alive)
self.signals = connection_manager.getSignalsInterface()
self.methods = connection_manager.getMethodsInterface()
# Configure callbacks
self.signals.registerListener("auth_success", self.on_auth_success)
self.signals.registerListener("auth_fail", self.on_auth_failed)
self.signals.registerListener("disconnected", self.on_disconnected)
self.signals.registerListener("message_received", self.on_message_received)
self.signals.registerListener("group_messageReceived", self.on_group_message_received)
self.groups = {}
self.creation_time = time.time()
self.done = False
def setup():
Debugger.enabled = True
global cm, signals_interface, methods_interface
print 'Settng up environment'
cm = YowsupConnectionManager()
cm.setAutoPong(True)
signals_interface = cm.getSignalsInterface()
methods_interface = cm.getMethodsInterface()
signals_interface.registerListener('auth_success', cb_auth_success)
signals_interface.registerListener('auth_fail', cb_auth_fail)
signals_interface.registerListener('contact_gotProfilePicture',
cb_contact_gotProfilePicture)
signals_interface.registerListener('receipt_messageSent', cb_message_sent)
signals_interface.registerListener('receipt_messageDelivered',
cb_message_delivered)
# Presence
signals_interface.registerListener('presence_updated', cb_presence_updated)
def __init__(self, admin_phone, keep_alive=False, send_receipts=False):
self.send_receipts = send_receipts
self.keep_alive = keep_alive
self.admin_phone = admin_phone
self.admin_jid = JID_BASE % admin_phone
# Configure connection manager
connection_manager = YowsupConnectionManager()
connection_manager.setAutoPong(keep_alive)
self.signals = connection_manager.getSignalsInterface()
self.methods = connection_manager.getMethodsInterface()
# Configure callbacks
self.signals.registerListener("auth_success", self.on_auth_success)
self.signals.registerListener("auth_fail", self.on_auth_failed)
self.signals.registerListener("disconnected", self.on_disconnected)
self.signals.registerListener("message_received",
self.on_message_received)
self.signals.registerListener("group_messageReceived",
self.on_group_message_received)
self.groups = {}
self.creation_time = time.time()
self.done = False
def __init__(self):
super(WazappDesktop, self).__init__()
Contacts.instance().contacts_updated_signal.connect(self.checkPresence)
self.contact_status_changed_signal.connect(Contacts.instance().contactStatusChanged)
self._hasUnreadMessage = False
self._isOnline = False
self._mainWindow = MainWindow()
self.show = self._mainWindow.show
self._mainWindow.send_message_signal.connect(self.do_send)
self._mainWindow.has_unread_message_signal.connect(self.unreadMessage)
self._systrayIcon = SystemTrayIcon()
self._systrayIcon.quit_signal.connect(self.close)
self._systrayIcon.quit_signal.connect(self._mainWindow.close)
self._systrayIcon.toggle_main_window_signal.connect(self.toggleMainWindow)
self.status_changed_signal.connect(self._systrayIcon.statusChanged)
self.show_message_signal.connect(self._mainWindow.showMessage)
self.message_status_changed_signal.connect(self._mainWindow.messageStatusChanged)
self._ownJid = Contacts.instance().phoneToConversationId(getConfig('countryCode') + getConfig('phoneNumber'))
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self._pictureDownloader = PictureDownloader(connectionManager, Contacts.instance())
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
for method, events in self.getEventBindings().iteritems():
for event in events:
self.signalsInterface.registerListener(event, method)
self.setOnline(False)
self._login()
def __init__(self, user, password, phone):
'''WhatsAppClient's constructor.
Args:
user (str): the local phone number.
password (str): the WhatsApp password of 'user'.
phone (str): the remote phone number.
'''
super().__init__()
self.user = user
try:
self.password = base64.b64decode(bytes(password.encode('utf-8')))
except base64.binascii.Error: # Lets Yowsup handle the error.
self.password = bytes(password.encode('utf-8'))
# Users are identified in WhatsApp by their phone number (plus the
# code) followed by the domain '@s.whatsapp.net'.
self.phone = phone + '@s.whatsapp.net'
self.connected = False
# Yowsup managers and signals setting up.
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(True)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener('auth_success',
self.onAuthSuccess)
self.signalsInterface.registerListener('auth_fail', self.onAuthFailed)
self.signalsInterface.registerListener('message_received',
self.onMessageReceived)
self.signalsInterface.registerListener('image_received',
self.onImageReceived)
self.signalsInterface.registerListener('disconnected',
self.onDisconnected)
##Audio receive and download
def onaudio_received(messageId, jid, url, size, receiptRequested, a):
urllib.urlretrieve(url, messageId + ".acc")
methodsInterface.call("message_ack", (jid, messageId))
#avconv -i 1402571446-347.acc -ar 16000 out.flac
#curl -X POST -H 'Content-Type:audio/x-flac; rate=16000' -T out.flac 'https://www.google.com/speech-api/v2/recognize?lang=es&maxresults=10&pfilter=0&key=AIzaSyCGRH-QgpLZyHy0SlIIJS30oolFCUXk5S0'
##Init Yowsup and Thermal Printer
t = Thermal(devid)
y = YowsupConnectionManager()
y.setAutoPong(True)
Debugger.enabled = False
methodsInterface = y.getMethodsInterface()
signalsInterface = y.getSignalsInterface()
##Regiter listeners
signalsInterface.registerListener("auth_success", onAuthSuccess)
signalsInterface.registerListener("message_received", onMessage)
signalsInterface.registerListener("disconnected", ondisconnected)
signalsInterface.registerListener("image_received", onimage_received)
signalsInterface.registerListener("audio_received", onaudio_received)
signalsInterface.registerListener("receipt_messageDelivered",
onMessageDelivered)
##Auth
methodsInterface.call("auth_login", (user, base64.b64decode(passw)))
methodsInterface.call("ready")
##Profile photo and Status
class MainBot():
def __init__(self, user, passwd):
self.con = YowsupConnectionManager()
self.con.setAutoPong(True)
self.signalsInterface = self.con.getSignalsInterface()
self.methodsInterface = self.con.getMethodsInterface()
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("receipt_messageDelivered",
self.onMessageDelivered)
self.methodsInterface.call("auth_login",
(user, base64.b64decode(passwd)))
self.running = True
def onAuthSuccess(self, args):
print("Auth True")
self.methodsInterface.call("ready")
def onAuthFailed(self, args):
print("Auth False")
self.running = False
def onDisconnected(self, args):
print("Connection Terminated")
self.running = False
def onMessageDelivered(self, jid, messageId):
print("Message Delivered")
def onMessageReceived(self, messageId, jid, messageContent, timestamp,
wantsReceipt, pushName, isBroadcast):
time.sleep(0.2)
self.methodsInterface.call("message_ack", (jid, messageId))
time.sleep(0.2)
self.react(jid, messageContent)
def react(self, jid, messageContent):
messageContent = messageContent.upper()
text = messageContent.split()
if ('HI' in text) or ('SUP' in text) or ('HELLO' in text):
self.methodsInterface.call("message_send",
(jid, "Hello Im WABot Alpha"))
elif (('LOL' in text) or ('BYE' in text)):
self.methodsInterface.call("message_send", (jid, "hmmm..."))
elif (('OK' in text) or ('THANKS' in text)):
self.methodsInterface.call("message_send",
(jid, "Your Welcome, anything else"))
elif ('HITME' in text) or (('HIT' in text) and ('ME' in text)):
self.methodsInterface.call("message_send",
(jid, self.action_send_quote()))
elif ((('CHUCK' in text) or ('NORRIS' in text))
and (('JOKE' in text) or ('JOKES' in text))):
self.methodsInterface.call("message_send",
(jid, self.action_send_norris()))
else:
self.methodsInterface.call("message_send",
(jid, self.do_a_search(text)))
def action_send_quote(self):
try:
data = urllib.urlopen(
"http://www.iheartquotes.com/api/v1/random?source=joel_on_software+paul_graham+prog_style"
).read()
e = data.split('\n')
txt = '\n'.join(e[0:len(e) - 2])
return str(self.uscape(txt))
except:
return "cannot hit you, for now"
def action_send_norris(self):
try:
data = urllib.urlopen("http://api.icndb.com/jokes/random/").read()
joke = json.loads(data)
return str(self.uscape(joke['value']['joke']).encode('utf8'))
except:
return "Norris killed the server"
def do_a_search(self, text):
try:
q = '+'.join(text)
data = urllib.urlopen(
"http://api.duckduckgo.com/?q=" + q +
"&format=json&pretty=1&no_redirect=1").read()
result = json.loads(data)
if not (result["RelatedTopics"][0]["Text"] == ""):
return str(
self.uscape("Lets Seee.... \n" +
(result["AbstractText"]).encode('utf8')))
else:
return "Hmmmmm, Nothing to say"
except:
return "Hmmmmm, Not in the mood"
def uscape(self, text):
try:
return HTMLParser.HTMLParser().unescape(text)
except:
return text
class WhatsappCmdClient:
bAuthFinished = False
bAuthSuccess = False
bSetProfileFile = False
bSetProfileSuccess = False
bSetStatus = False
bDisconnected = True
sDisconnectReason = ""
lvMessage = []
def __init__(self, phoneNumber, keepAlive=False, sendReceipts=False):
self.sendReceipts = sendReceipts
self.phoneNumber = phoneNumber
self.jid = "*****@*****.**" % phoneNumber
self.myjid = ""
self.sentCache = {}
WhatsappCmdClient.lvMessage = []
self.connectionManager = YowsupConnectionManager(False)
self.connectionManager.setAutoPong(keepAlive)
self.signalsInterface = self.connectionManager.getSignalsInterface()
self.methodsInterface = self.connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("receipt_messageSent",
self.onMessageSent)
self.signalsInterface.registerListener("presence_updated",
self.onPresenceUpdated)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("profile_setPictureSuccess",
self.onPictureSuccess)
self.signalsInterface.registerListener("profile_setPictureError",
self.onPictureError)
self.signalsInterface.registerListener("contact_gotProfilePicture",
self.onProfilePicture),
self.signalsInterface.registerListener("profile_setStatusSuccess",
self.onStatusSuccess)
#0: method, 1: parameter name in prompt, 2: position in prompt
#self.commandMappings = {"lastseen": (lambda: self.methodsInterface.call("presence_request", (self.jid,)),"",6),
#"available": (lambda: self.methodsInterface.call("presence_sendAvailable"),"",1),
#"unavailable": (lambda: self.methodsInterface.call("presence_sendUnavailable"),"",2),
#"setprofile": (lambda file: self.setProfile(file,),"filename",4),
#"setstatus": (lambda status: self.setStatus(status,),"status",5),
#"getprofile": (lambda: self.methodsInterface.call("contact_getProfilePicture", (self.jid,)),"",3),
#"exit": (self.done,"",7)
#}
#self.done = False
#self.signalsInterface.registerListener("receipt_messageDelivered", lambda jid, messageId: self.methodsInterface.call("delivered_ack", (jid, messageId)))
def login(self, username, password):
self.username = username
self.myjid = "*****@*****.**" % username
self.methodsInterface.call("auth_login", (username, password))
def onAuthSuccess(self, username):
self.methodsInterface.call("ready")
WhatsappCmdClient.bAuthFinished = True
WhatsappCmdClient.bAuthSuccess = True
WhatsappCmdClient.bDisconnected = False
def onAuthFailed(self, username, err):
WhatsappCmdClient.bAuthFinished = True
WhatsappCmdClient.bAuthSuccess = False
def setProfile(self, file):
if os.path.isfile(file):
self.methodsInterface.call("profile_setPicture", (file, ))
WhatsappCmdClient.bSetProfileFile = True
else:
WhatsappCmdClient.bSetProfileFile = False
def onPictureSuccess(self, id):
WhatsappCmdClient.bSetProfileSuccess = True
def onPictureError(self, error):
WhatsappCmdClient.bSetProfileSuccess = False
def onMessageReceived(self, messageId, jid, messageContent, timestamp,
wantsReceipt, pushName, isBroadcast):
formattedDate = datetime.datetime.fromtimestamp(timestamp).strftime(
'%Y%m%d %H:%M.%S')
WhatsappCmdClient.lvMessage.append(
(jid, formattedDate, messageContent, messageId))
if wantsReceipt and self.sendReceipts:
self.methodsInterface.call("message_ack", (jid, messageId))
def onMessageSent(self, jid, messageId):
pass
def sendMessage(self, jid, message):
msgId = self.methodsInterface.call("message_send", (jid, message))
self.sentCache[msgId] = [int(time.time()), message]
def setStatus(self, status):
self.methodsInterface.call("profile_setStatus", (status, )),
WhatsappCmdClient.bSetStatus = False
def onStatusSuccess(self, jid, messageId):
self.methodsInterface.call("message_ack", (jid, messageId))
WhatsappCmdClient.bSetStatus = True
def onDisconnected(self, reason):
WhatsappCmdClient.bDisconnected = True
WhatsappCmdClient.sDisconnectReason = reason
def onProfilePicture(self, jid, pictureid, path):
print("Got profile picture of %s: id: %s path:%s" %
(jid, pictureid, path))
def onPresenceUpdated(self, jid, lastSeen):
formattedDate = datetime.datetime.fromtimestamp(
long(time.time()) - lastSeen).strftime('%d-%m-%Y %H:%M')
self.onMessageReceived(0, jid, "LAST SEEN RESULT: %s" % formattedDate,
long(time.time()), False, None, False)
class WAInterface(threading.Thread):
def __init__(self, username, password, msg_handler, stopped_handler):
threading.Thread.__init__(self)
self.connected = False
self.must_run = True
self.msg_handler = msg_handler
self.stopped_handler = stopped_handler
self.username = username
self.password = base64.b64decode(password)
self.cm = YowsupConnectionManager()
self.cm.setAutoPong(True)
self.signalsInterface = self.cm.getSignalsInterface()
self.methodsInterface = self.cm.getMethodsInterface()
self.signalsInterface.registerListener("notification_groupPictureUpdated", self.onGroup_PictureUpdated)
self.signalsInterface.registerListener("group_gotPicture", self.onGroup_PictureGot)
self.signalsInterface.registerListener("group_imageReceived", self.onGroup_ImageReceived)
self.signalsInterface.registerListener("image_received", self.onImageReceived)
self.signalsInterface.registerListener("group_videoReceived", self.onGroup_VideoReceived)
self.signalsInterface.registerListener("videoimage_received", self.onVideoReceived)
self.signalsInterface.registerListener("message_received", self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived", self.onGroup_MessageReceived)
self.signalsInterface.registerListener("auth_success", self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.signalsInterface.registerListener("receipt_messageSent", self.onMessageSent)
self.signalsInterface.registerListener("receipt_messageDelivered", self.onMessageDelivered)
self.signalsInterface.registerListener("ping", self.onPing)
@catch_them_all
def onMessageReceived(self, messageId, jid, messageContent, timestamp, wantsReceipt, pushName, isBroadcast):
message = Message(kind="wa", nick_full=jid, chan=self.username, msg=messageContent)
message.time = Timestamp(ms_int = timestamp*1000)
self.msg_handler(message)
sendReceipts = True
if wantsReceipt and sendReceipts:
self.wait_connected()
self.methodsInterface.call("message_ack", (jid, messageId))
@catch_them_all
def onImageReceived(self, messageId, jid, preview, url, size, receiptRequested):
messageContent = unicode("[ image: %s ]"%url, "utf-8")
message = Message(kind="wa", nick_full=jid, chan=self.username, msg=messageContent)
self.msg_handler(message)
sendReceipts = True
if receiptRequested and sendReceipts:
self.wait_connected()
self.methodsInterface.call("message_ack", (jid, messageId))
@catch_them_all
def onGroup_PictureUpdated(self, jid, author, timestamp, messageId, pictureId, receiptRequested):
self.methodsInterface.call("group_getPicture", (jid,))
sendReceipts = True
if receiptRequested and sendReceipts:
self.wait_connected()
self.methodsInterface.call("message_ack", (jid, messageId))
@catch_them_all
def onGroup_PictureGot(self, jid, filePath):
#TODO: upload filePath to services like imgur (or even upload as whatsapp picture, hah!) instead of displaying local file path here:
messageContent = unicode("[ group picture: %s ]"%filePath, "utf-8")
message = Message(kind="wa", nick_full="unknown", chan=jid, msg=messageContent)
self.msg_handler(message)
@catch_them_all
def onGroup_ImageReceived(self, messageId, jid, author, preview, url, size, receiptRequested):
messageContent = unicode("[ image: %s ]"%url, "utf-8")
message = Message(kind="wa", nick_full=author, chan=jid, msg=messageContent)
self.msg_handler(message)
sendReceipts = True
if receiptRequested and sendReceipts:
self.wait_connected()
self.methodsInterface.call("message_ack", (jid, messageId))
@catch_them_all
def onVideoReceived(self, messageId, jid, preview, url, size, receiptRequested):
messageContent = unicode("[ video: %s ]"%url, "utf-8")
message = Message(kind="wa", nick_full=jid, chan=self.username, msg=messageContent)
self.msg_handler(message)
sendReceipts = True
if receiptRequested and sendReceipts:
self.wait_connected()
self.methodsInterface.call("message_ack", (jid, messageId))
@catch_them_all
def onGroup_VideoReceived(self, messageId, jid, author, preview, url, size, receiptRequested):
messageContent = unicode("[ video: %s ]"%url, "utf-8")
message = Message(kind="wa", nick_full=author, chan=jid, msg=messageContent)
self.msg_handler(message)
sendReceipts = True
if receiptRequested and sendReceipts:
self.wait_connected()
self.methodsInterface.call("message_ack", (jid, messageId))
@catch_them_all
def onGroup_MessageReceived(self, messageId, jid, author, messageContent, timestamp, wantsReceipt, pushName):
message = Message(kind="wa", nick_full=author, chan=jid, msg=messageContent)
message.time = Timestamp(ms_int = timestamp*1000)
self.msg_handler(message)
sendReceipts = True
if wantsReceipt and sendReceipts:
self.wait_connected()
self.methodsInterface.call("message_ack", (jid, messageId))
@catch_them_all
def run(self):
try:
self.must_run = True
self.methodsInterface.call("auth_login", (self.username, self.password))
self.wait_connected()
while self.must_run:
if not self.connected:
self.methodsInterface.call("auth_login", (self.username, self.password))
time.sleep(0.5)
#raw_input()
finally:
info("Main loop closing")
self.connected = False
self.stopped_handler()
self.must_run = False
def stop(self):
self.must_run = False
def send(self, target, text):
self.wait_connected()
self.methodsInterface.call("message_send", (target, text.encode("utf-8")))
info((" >>> WA %s: %s" %(target, text)).encode("utf-8"))
@catch_them_all
def onAuthSuccess(self, username):
info("Connected WA client (%s)" %username)
self.connected = True
self.methodsInterface.call("ready")
@catch_them_all
def onAuthFailed(self, username, reason):
info("Auth Failed: %s" %reason)
self.connected = False
@catch_them_all
def onDisconnected(self, reason):
info("Disconnected WA client (%s): %s" %(self.username, reason))
self.connected = False
@catch_them_all
def onMessageSent(self, jid, messageId):
info("Message successfully sent to %s" % jid)
@catch_them_all
def onMessageDelivered(self, jid, messageId):
info("Message successfully delivered to %s" %jid)
self.wait_connected()
self.methodsInterface.call("delivered_ack", (jid, messageId))
@catch_them_all
def onPing(self, pingId):
info("Pong! (%s)" %pingId)
self.wait_connected()
self.methodsInterface.call("pong", (pingId,))
def wait_connected(self):
while not self.connected:
if not self.must_run:
raise Exception("bot does not intend to connect")
time.sleep(0.1)
def __init__(self, url, keepAlive=False, sendReceipts=False):
super(Server, self).__init__()
self.sendReceipts = sendReceipts
self.keepAlive = keepAlive
self.db = create_engine(url,
echo=False,
pool_size=10,
pool_timeout=600,
pool_recycle=300)
self.Session = sessionmaker(bind=self.db)
self.s = self.Session()
self.job = None
self.pubnub = Pubnub(os.environ['PUB_KEY'], os.environ['SUB_KEY'],
None, False)
self.timeout = int(os.getenv('TIMEOUT', 3600))
connectionManager = YowsupConnectionManager(self.timeout)
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived",
self.onGroupMessageReceived)
self.signalsInterface.registerListener("image_received",
self.onImageReceived)
self.signalsInterface.registerListener("video_received",
self.onVideoReceived)
self.signalsInterface.registerListener("audio_received",
self.onAudioReceived)
self.signalsInterface.registerListener("vcard_received",
self.onVCardReceived)
self.signalsInterface.registerListener("location_received",
self.onLocationReceived)
self.signalsInterface.registerListener("receipt_messageSent",
self.onReceiptMessageSent)
self.signalsInterface.registerListener("receipt_messageDelivered",
self.onReceiptMessageDelivered)
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("contact_gotProfilePicture",
self.onGotProfilePicture)
self.signalsInterface.registerListener("profile_setStatusSuccess",
self.onSetStatusSuccess)
self.signalsInterface.registerListener("group_createSuccess",
self.onGroupCreateSuccess)
self.signalsInterface.registerListener("group_createFail",
self.onGroupCreateFail)
self.signalsInterface.registerListener("group_gotInfo",
self.onGroupGotInfo)
self.signalsInterface.registerListener(
"group_addParticipantsSuccess", self.onGroupAddParticipantsSuccess)
self.signalsInterface.registerListener(
"group_removeParticipantsSuccess",
self.onGroupRemoveParticipantsSuccess)
self.signalsInterface.registerListener("group_imageReceived",
self.onGroupImageReceived)
self.signalsInterface.registerListener("group_subjectReceived",
self.onGroupSubjectReceived)
self.signalsInterface.registerListener(
"notification_removedFromGroup",
self.onNotificationRemovedFromGroup)
self.signalsInterface.registerListener(
"notification_groupParticipantAdded",
self.onNotificationGroupParticipantAdded)
self.signalsInterface.registerListener("group_gotParticipants",
self.onGotGroupParticipants)
self.signalsInterface.registerListener("media_uploadRequestSuccess",
self.onUploadRequestSuccess)
# self.signalsInterface.registerListener("media_uploadRequestFailed", self.onUploadRequestFailed)
self.signalsInterface.registerListener("media_uploadRequestDuplicate",
self.onUploadRequestDuplicate)
self.signalsInterface.registerListener("presence_available",
self.onPresenceAvailable)
self.signalsInterface.registerListener("presence_unavailable",
self.onPresenceUnavailable)
self.cm = connectionManager
self.url = os.environ['URL']
self.post_headers = {
'Content-type': 'application/json',
'Accept': 'application/json'
}
self.done = False
if db.Mensajes.count() > 0:
date = db.Mensajes.find_one()
Number = date [ "Destino" ].encode('utf-8')
Message = date [ "Mensaje" ].encode('utf-8')
IdDate = date [ "_id" ]
db.Mensajes.remove({"_id":IdDate})
client.close()
print ("::.MessageEngine.:: 521"+str(Number)+"@s.whatsapp.net"+str(Message))
methodsInterface.call("message_send",("521"+str(Number)+"@s.whatsapp.net",str(Message)))
else:
print ("::.MessageEngine.:: No hay Mensajes en Cola")
def espera():
while True:
time.sleep(10) #espera entre cada mensaje enviado, se tomaron 10 segundos para evitar saturacion con WhatsApp
MessageSendCola()
#............................................................................
password = "" #Pswd de Yowsup.
username = '' #Numero de WhatsApp.
keepAlive = True
sendReceipts = True
password = base64.b64decode(bytes(password.encode('utf-8')))
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
signalsInterface = connectionManager.getSignalsInterface()
methodsInterface = connectionManager.getMethodsInterface()
signalsInterface.registerListener("receipt_messageSent", onMessageSent)
signalsInterface.registerListener("receipt_messageDelivered", onMessageDelivered)
signalsInterface.registerListener("auth_success", onAuthSuccess)
methodsInterface.call("auth_login", (username, password))
espera()
class Whatspy(object):
phase = None
cm = None
signals_interface = None
methods_interface = None
time_got = None
photo_got = None
# Login
def cb_auth_success(self, username):
print 'Authed %s' % username
self.methods_interface.call('ready')
self.phase = True
def cb_auth_fail(self, username, reason):
print 'Auth Fail!', username, reason
self.phase = False
def login(self):
self.methods_interface.call('auth_login', (USERNAME, PASSWORD))
# Presence
def cb_presence_updated_once(self, jid, last_seen):
self.time_got = time.ctime(time.time() - last_seen)
print 'Last seen @', self.time_got
# Contacts
def cb_contact_gotProfilePicture_once(self, jid, picture_id, image_path):
phone_number = jid.split('@')[0]
print 'Got', phone_number
new_path = image_location(phone_number)
shutil.copyfile(image_path, new_path)
self.photo_got = new_path
# Main
def setup(self):
#global cm, signals_interface, methods_interface
Debugger.enabled = False
self.cm = YowsupConnectionManager()
self.cm.setAutoPong(True)
self.signals_interface = self.cm.getSignalsInterface()
self.methods_interface = self.cm.getMethodsInterface()
self.signals_interface.registerListener('auth_success',
self.cb_auth_success)
self.signals_interface.registerListener('auth_fail', self.cb_auth_fail)
def get_photo_time(self, phone_number):
''' phone number includes the country code'''
self.setup()
self.login()
self.photo_got = None
self.time_got = None
while self.phase is None:
time.sleep(0.5)
self.signals_interface.registerListener('presence_updated',
self.cb_presence_updated_once)
jid = phone_number2jid(phone_number)
self.methods_interface.call('presence_request', (jid, ))
# only get image if doesn't already exist
if os.path.isfile(image_location(phone_number)):
self.photo_got = image_location(phone_number)
else:
self.signals_interface.registerListener(
'contact_gotProfilePicture',
self.cb_contact_gotProfilePicture_once)
self.methods_interface.call('contact_getProfilePicture', (jid, ))
timeout = 0
while not (self.photo_got
and self.time_got) and timeout < TIMEOUT_SECS:
time.sleep(0.25)
timeout += 0.25
return (self.photo_got, self.time_got)
def __init__(self, keepAlive=False, sendReceipts=True):
self.sendReceipts = sendReceipts
connectionManager = YowsupConnectionManager()
connectionManager.setAutoPong(keepAlive)
self.signalsInterface = connectionManager.getSignalsInterface()
self.methodsInterface = connectionManager.getMethodsInterface()
self.signalsInterface.registerListener("message_received",
self.onMessageReceived)
self.signalsInterface.registerListener("group_messageReceived",
self.onGroupMessageReceived)
self.signalsInterface.registerListener("auth_success",
self.onAuthSuccess)
self.signalsInterface.registerListener("auth_fail", self.onAuthFailed)
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.signalsInterface.registerListener("presence_updated",
self.onPresence_updated)
self.signalsInterface.registerListener("presence_available",
self.onPresence_available)
self.signalsInterface.registerListener("presence_unavailable",
self.onPresence_unavailable)
self.signalsInterface.registerListener(
"contact_gotProfilePicture", self.onContact_gotProfilePicture)
self.signalsInterface.registerListener("profile_setStatusSuccess",
self.onProfile_setStatusSuccess)
self.signalsInterface.registerListener("status_dirty",
self.onStatus_dirty)
self.signalsInterface.registerListener(
"contact_gotProfilePictureId", self.onContact_gotProfilePictureId)
self.signalsInterface.registerListener(
"contact_gotProfilePicture", self.onContact_gotProfilePicture)
self.signalsInterface.registerListener("group_gotParticipants",
self.onGroup_gotParticipants)
self.cm = connectionManager
self.db = MyZODB('Data/Data.fs')
self.dbroot = self.db.dbroot
if not self.dbroot.has_key("groups"):
self.dbroot["groups"] = PersistentMapping()
if not self.dbroot.has_key("messages"):
self.dbroot["messages"] = PersistentMapping()
if not self.dbroot.has_key("config"):
self.dbroot["config"] = PersistentMapping()
if not self.dbroot.has_key("features"):
self.dbroot["features"] = PersistentMapping()
if not self.dbroot.has_key("contacts"):
self.dbroot["contacts"] = PersistentMapping()
if not self.dbroot.has_key("chats"):
self.dbroot['chats'] = PersistentMapping()
if not self.dbroot['features'].has_key("responses"):
self.dbroot['features']['responses'] = PersistentMapping()
if not self.dbroot['features'].has_key("outbox"):
self.dbroot['features']['outbox'] = PersistentList()
self.outbox = self.dbroot['features']['outbox']
self.outboxempty = False
self.outboxprocessing = False
class WWMCore:
def __init__(self):
self.connectionManager = YowsupConnectionManager()
self.connectionManager.setAutoPong(Config.keepAlive)
self.signalsInterface = self.connectionManager.getSignalsInterface()
self.methodsInterface = self.connectionManager.getMethodsInterface()
self.yowsupRanOnce = 0
self.listener = None
self.sender = None
self.session = None
self.httpRequestHandler = None
self.instanceId = None
self.status = Constants.INSTANCESTATUS_INITED
self.dbi = DBI(
) #Use this for HTTP requests only. For every other case, Go ahead and create a different connection for now
self.callbackDBI = CallbackDBI(
) #Extra care for preventing interference
#self.dbiCursor = None
self.yowsupStarted = 0
#Just to keep track of the instances created
def registerInstance(self, procId):
timeNow = time.time()
procId = os.getpid()
status = Constants.INSTANCESTATUS_STARTED
authStatus = Constants.AUTHSTATUS_IDLE
self.dbiCursor.execute(
"INSERT INTO pythoninstances (phone, procId, lastUpdated,status, authStatus) VALUES(%s, %s, %s, %s)",
(self.session.phone, procId, timeNow, status, authStatus))
#self.instanceId =
def genAESKey(self, str):
#md5 hash of reverse of str
return hashlib.md5(str[::-1]).hexdigest()
def initSender(self):
if self.sender == None:
self.sender = Sender(self)
def initListener(self):
if self.listener == None:
self.listener = Listener(self)
#deprecated
def initDBI(self):
print "Call to Core.initDBI which is deprecated"
'''
try:
self.dbi = MySQLdb.connect('localhost','root','','webwhatsapp')
self.dbiCursor = self.dbi.cursor(MySQLdb.cursors.DictCursor)
except MySQLdb.Error, e:
raise WWMException("MySQL could not connect: %s" %e)
'''
def getDBICursor(self): #returns dbi and cursor
return self.dbiCursor
#This method is called from session
def initSession(self, phone, AESKey):
print "Core.initSession called"
if self.session == None or self.session.authStatus == Constants.AUTHSTATUS_IDLE: #self.yowsupStarted==0 and
self.yowsupStarted = 1
if self.session == None:
self.session = Session(self, phone, AESKey)
self.session.getAuthData()
self.signalsInterface.registerListener("disconnected",
self.onDisconnected)
self.session.login()
else:
print "\nPretty sure yowsup is already started."
def authCallback(self, isSuccess): #Called manually from Session
if isSuccess:
self.yowsupRanOnce == 1 #Very important flag
#This is done earlier in initSession with the above flag to differentiate between pre auth disco and post auth disco
#self.signalsInterface.registerListener("disconnected", self.onDisconnected)
self.status = Constants.INSTANCESTATUS_RUNNING
self.yowsupStarted = 1
else:
self.yowsupStarted = 0
def onDisconnected(self, reason):
print "Core.onDisconnected called"
if self.status == Constants.INSTANCESTATUS_WRAPPEDUP:
print "Core.onDisconnected: Disconnected and wrapping up"
return #And die
self.yowsupStarted = 0
self.session.authStatus = Constants.AUTHSTATUS_IDLE
#self.session.updateAuthStatus(Constants.AUTHSTATUS_IDLE)
if self.yowsupRanOnce == 0:
print "Could not connect. Rerun startYowsup to try again"
return
self.addNotification(self.session.phone,
"Yowsup got disconnected. Will retry")
sleepInterval = Config.conRetry_interval
print "Disconnected because %s" % (reason)
print "Retrying every %d seconds" % (sleepInterval)
retryCount = 1
retryMax = Config.conRetry_maxRetry
while self.session.authStatus != Constants.AUTHSTATUS_LOGGEDIN and retryCount <= retryMax:
time.sleep(sleepInterval)
print "Retry #%d" % (retryCount)
self.session.login()
retryCount = retryCount + 1
if self.session.authStatus == Constants.AUTHSTATUS_LOGGEDIN:
print "Re-Logged in successfully!"
else:
self.addNotification(
self.session.phone,
"Could not login. Retries failed. Killing yowsup")
print "Can't login. Killing yowsup"
self.connectionManager.disconnect("Login retries failed")
self.status = Constants.INSTANCESTATUS_IDLE #So he can try again manually if he wants
def getStatus(self):
#Create a dictionary and return it
status = {}
status["Core"] = [("yowsupStarted", self.yowsupStarted),
("instanceStatus", self.status)]
if self.session == None:
status["Session"] = [("inited", "No")]
else:
status["Session"] = [("inited", "Yes"),
("AuthStatus", self.session.authStatus)]
return status
def addNotification(self, phone, reason):
#lol
return
def wrapUp(self, reason):
#Write some code to wrap up
self.status = Constants.INSTANCESTATUS_WRAPPEDUP
with BlockingDBICursor(self.dbi) as dbiCursor:
dbiCursor.execute(
"UPDATE pythonInstances set status=%s WHERE instanceId=%s ",
(self.status, self.instanceId))
self.connectionManager.disconnect(reason)
self.yowsupStarted = 0
def addUser(self, phone, email, name, password, whatsapp_pass):
AESKey = self.genAESKey(password)
hash = hashlib.md5(password).hexdigest()
try:
dbiCursor = self.dbi.getCursor()
dbiCursor.execute(
"INSERT INTO users (phone,email,name,password,whatsapp_pass) VALUES(%s,%s,%s,%s,AES_ENCRYPT(%s,%s))",
(phone, email, name, hash, whatsapp_pass, AESKey))
self.dbi.commit()
self.dbi.done()
except MySQLdb.Error, e:
print "Exception: %s" % e
