def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e)
def onEvent(self, layerEvent):
alive_thread = Thread(target=self.aliver, args=(layerEvent, ))
logging.info("WhatsApp-Plugin : EVENT " + layerEvent.getName())
if layerEvent.getName() == YowNetworkLayer.EVENT_STATE_DISCONNECTED:
logging.info("WhatsApp-Plugin : Disconnected reason: %s" %
layerEvent.getArg("reason"))
os._exit(os.EX_OK)
if layerEvent.getArg("reason") == 'Connection Closed':
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
elif layerEvent.getArg("reason") == 'Ping Timeout':
time.sleep(2)
logging.info(
"WhatsApp-Plugin : Issueing EVENT_STATE_DISCONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT))
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
elif layerEvent.getArg("reason") == 'Authentication Failure':
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
else:
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
os._exit(os.EX_OK)
elif layerEvent.getName() == YowNetworkLayer.EVENT_STATE_CONNECTED:
logging.info("WhatsApp-Plugin : Connected")
alive_thread.start()
def start(self):
"""Starts the connection with Whatsapp servers,"""
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("Starting....")
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def start(self):
self._stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self._stack.loop()
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
def onDisconnected(self):
if self.state != self.__class__.STATE_DISCONNECTED:
self.state = self.__class__.STATE_DISCONNECTED
self.connected = False
logger.debug("Disconnected")
self.emitEvent(
YowLayerEvent(self.__class__.EVENT_STATE_DISCONNECTED,
reason=self._disconnect_reason or ""))
def waitPong(self, id):
self._pingQueueLock.acquire()
self._pingQueue[id] = None
pingQueueSize = len(self._pingQueue)
self._pingQueueLock.release()
self.__logger.debug("ping queue size: %d" % pingQueueSize)
if pingQueueSize >= 2:
self.getStack().broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT, reason = "Ping Timeout"))
def sendTextMessage(self, address, message):
self.output('Trying to send Message to %s:%s' % (address, message))
self.stack.broadcastEvent(
YowLayerEvent(name=SendReciveLayer.EVENT_SEND_MESSAGE,
msg=message,
number=address))
return True
def on_connected(self, event):
self.broadcastEvent(
YowLayerEvent(
self.EVENT_AUTH,
credentials=self.getProp(self.PROP_CREDENTIALS),
passive=self.getProp(self.PROP_PASSIVE, False)
)
)
def handle_connect(self):
self.connected = True
if self.proxyHandler != None:
logger.debug("HttpProxy handle connect")
self.proxyHandler.send(self)
else:
self.emitEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECTED))
def keys_set(self):
if ModuleTools.INSTALLED_AXOLOTL():
from yowsup.layers.axolotl import YowAxolotlLayer
if self.assertConnected():
self.broadcastEvent(
YowLayerEvent(YowAxolotlLayer.EVENT_PREKEYS_SET))
else:
logger.error("Axolotl is not installed")
def sendIq(self, iq, onSuccess=None, onError=None):
self.stack.broadcastEvent(
YowLayerEvent(
YowsupAppLayer.SEND_IQ,
iq=iq,
success=onSuccess,
failure=onError,
))
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
print("Starting")
try:
self.stack.loop(timeout = 0.5, discrete = 0.5)
print("bye")
except AuthError as e:
print("Authentication Error: %s" % e.message)
def onEvent(self, layerEvent):
# In case of constant disconnects. https://github.com/tgalal/yowsup/iss
print 'event:', layerEvent.getName()
if layerEvent.getName() == YowNetworkLayer.EVENT_STATE_DISCONNECTED:
print "Disconnected- %s" % layerEvent.getArg("reason")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
print 'reconnected'
def handle_close(self, reason="Connection Closed"):
self.connected = False
logger.debug("Disconnected, reason: %s" % reason)
self.emitEvent(
YowLayerEvent(self.__class__.EVENT_STATE_DISCONNECTED,
reason=reason,
detached=True))
self.close()
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("Whatsapp IS STARTING : ReceiveStack")
self.stack.loop(timeout=1, count=100)
logging.info("Stopping ... ")
except AuthError as e:
logging.info("Authentication Error: %s" % e.message)
def login(self, username, b64password):
if self.connected:
return self.output("Already connected, disconnect first")
self.getStack().setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, (username, b64password))
connectEvent = YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)
self.broadcastEvent(connectEvent)
return True #prompt will wait until notified
def handleSuccess(self, node):
if (node.data != None):
StorageTools.writeNonce(self.credentials[0], node.data)
successEvent = YowLayerEvent(self.__class__.EVENT_AUTHED,
passive=self.getProp(
self.__class__.PROP_PASSIVE))
self.broadcastEvent(successEvent)
nodeEntity = SuccessProtocolEntity.fromProtocolTreeNode(node)
self.toUpper(nodeEntity)
def on_handshake_finished(self, e=None):
# type: (Exception) -> None
if e is not None:
self.emitEvent(YowLayerEvent(self.EVENT_HANDSHAKE_FAILED, reason=e))
data=WriteEncoder(TokenDictionary()).protocolTreeNodeToBytes(
ProtocolTreeNode("failure", {"reason": str(e)})
)
self.toUpper(data)
logger.error("An error occurred during handshake, try login again.")
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop(timeout=120)
except AuthError as e:
print("Authentication Error: %s" % e.message)
except Exception as e:
print("Another Error: %s" % str(e))
def start(self):
while True:
try:
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
self.stack.loop()
except AuthError as e:
break
except Exception as e:
print(e)
time.sleep(20)
def start(self):
print("[Whatsapp] Mac started\n")
print("[Whatsapp] Current State:", YowNetworkLayer.EVENT_STATE_CONNECT)
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop(timeout=0.5, discrete=0.5)
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
def workerwhatsapp():
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(laye).build()
stack.setCredentials(CREDENTIALS)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE,
YowsupEnv.getCurrent().getResource())
stack.loop(timeout=0.5, discrete=0.5)
def _sendAuth(self):
passive = self.getProp(self.__class__.PROP_PASSIVE, False)
nonce = StorageTools.getNonce(self.credentials[0])
if nonce == None:
self.entityToLower(
AuthProtocolEntity(self.credentials[0], passive=passive))
else:
inputKey, outputKey, authBlob = self.generateAuthBlob(nonce)
#to prevent enr whole response
self.broadcastEvent(
YowLayerEvent(YowCryptLayer.EVENT_KEYS_READY,
keys=(inputKey, None)))
self.entityToLower(
AuthProtocolEntity(self.credentials[0],
passive=passive,
nonce=authBlob))
self.broadcastEvent(
YowLayerEvent(YowCryptLayer.EVENT_KEYS_READY,
keys=(inputKey, outputKey)))
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except KeyboardInterrupt as e:
raise e
except AuthError as e:
print("Authentication Error: %s" % e.message)
def startBot(credentials):
print (credentials)
credential_Pass = YowLayerEvent('Whatsbot_Phone',phone_num=credentials[0])
stackBuilder = YowStackBuilder()
# y = YowsupConnectionManager()
# y.setAutoPong(True)
stack = stackBuilder \
.pushDefaultLayers(True) \
.push(Whatsbot) \
.build()
stack.setCredentials(credentials)
stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
stack.broadcastEvent(credential_Pass)
# stack.loop(timeout=0.5, count=2) # Let the taskloop run one time for 2 seconds. So as to Setup complete
# # Now Send Event to Scan if any Numbers in list remaining Whom to send messages
# time.sleep(0.5)
# stack.broadcastEvent(YowLayerEvent('Continue_Sending'))
stack.loop()
def start(self):
print("Yowsup Cli client\n==================\nType /help for available commands\n")
self.stack.broadcastEvent(YowLayerEvent(YowsupCliLayer.EVENT_START))
try:
self.stack.loop(timeout = 0.5, discrete = 0.5)
except AuthError as e:
print("Auth Error, reason %s" % e)
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
def SendMessage(self):
if self.Password(request.get_header('password')):
to = request.forms.get("to")
message = request.forms.get("message")
try:
self.stack.broadcastEvent(YowLayerEvent("sendMessage", to=to, msg=message))
except:
return "message Error"
return "message send"
else:
return "Unauthorized access"
def start(self):
print(
"Yowsup Cli client\n==================\nType /help for available commands\n"
)
self._stack.broadcastEvent(YowLayerEvent(YowsupCliLayer.EVENT_START))
try:
self._stack.loop()
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(
YowsupNewsbotLayer.EVENT_START))
try:
self.stack.loop(timeout=0.5, discrete=0.5)
except AuthError as e:
print("Auth Error, reason %s" % e)
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
def prepare_stack(self, credentials, messages):
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(EchoLayer).build()
stack.setProp("messages", messages)
stack.setCredentials(credentials)
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT))
return stack
