def check_if_number_exists(driver: WhatsAPIDriver, number: str) -> bool:
"""
Function to check if a number exists on WhatsApp
:param driver: driver object used for checking
:param number: The number to check
:return: True if the number exists, else false
"""
try:
driver.get_chat_from_phone_number(number, createIfNotFound=True)
return True
except ChatNotFoundError:
return False
def send_message(num: int, msg: str, driver: WhatsAPIDriver):
"""
Method to send a message to someone
:param num: phone number to which message is to be sent
:param msg: the message to be sent
:param driver: WhatsApidDiver object using which whatsapp web is to be operated
:return: string with name and link to chat
"""
# get chat with user
chat = driver.get_chat_from_phone_number(str(num), createIfNotFound=True)
try:
chat.send_message(msg) # send message
except (JsException, JavascriptException):
pass
import os
from webwhatsapi import WhatsAPIDriver
profiledir = os.path.join('.', 'firefox_cache')
if not os.path.exists(profiledir):
os.makedirs(profiledir)
driver = WhatsAPIDriver(profile=profiledir, headless=True)
print('login')
driver.wait_for_login()
driver.save_firefox_profile(remove_old=False)
print('start')
chat = driver.get_chat_from_phone_number('491xxxxxxxxxx')
driver.send_message_to_id(chat.id, 'This works')
profiledir = os.path.join(".", "firefox_cache")
if not os.path.exists(profiledir):
os.makedirs(profiledir)
driver = WhatsAPIDriver(profile=profiledir,
client="remote",
command_executor=os.environ["SELENIUM"])
print("Waiting for QR")
driver.wait_for_login()
print("Saving session")
driver.save_firefox_profile(remove_old=False)
print("Bot started")
logo = "./docs/logo/logomark-01.png"
chat = driver.get_chat_from_phone_number(os.environ["MY_PHONE"])
chat.send_message_with_thumb(
logo,
"https://github.com/mukulhase/WebWhatsapp-Wrapper",
"Whatsapp Wrapper!",
"(Based on web.whatsapp.com)",
"""
This package is used to provide a python interface for interacting with WhatsAPP Web to send and
receive Whatsapp messages. It is based on the official Whatsapp Web Browser
Application and uses Selenium browser automation to communicate with Whatsapp Web.
https://github.com/mukulhase/WebWhatsapp-Wrapper
""",
)
if reloaded_contacts_set is not None and len(
reloaded_contacts_set) > 0:
logging.info("The contacts will be reloaded: " +
','.join(sender_msisdn_list))
for reload_contact_row in reloaded_contacts_set:
reload_contact_row_id = reload_contact_row[0]
reload_contact_row_sender = reload_contact_row[1]
# Activating reload
with db_conn.cursor() as cur:
cur.execute(activate_reload, (reload_contact_row_id, ))
db_conn.commit()
try:
chat = driver.get_chat_from_phone_number(
reload_contact_row_sender)
# Creating directory set for photos if not exists
dirName = create_directory(reload_contact_row_sender)
# Load all earlier messages
logging.info("Loading earlier messages for: " +
reload_contact_row_sender + "...")
if chat.are_all_messages_loaded() == False:
chat.load_all_earlier_messages()
logging.info("Earlier messages loaded for: " +
reload_contact_row_sender)
else:
logging.info("All messages already loaded for: " +
reload_contact_row_sender)
assigner.assign_chat(agent_id, chat_id);
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.username_pw_set("rbpzxiof", "mY5QlIiDUZQD")
client.connect("m11.cloudmqtt.com", 18211, 60)
driver = WhatsAPIDriver(profile = "/home/user/.mozilla/firefox/mwad0hks.default")
print("Waiting for QR")
driver.wait_for_login()
print("Bot started")
chat = driver.get_chat_from_phone_number("27837548664")
print(chat.name)
print(chat.id)
#chat.load_earlier_messages()
print(assigner.get_agent_id("hello"))
print(assigner.get_agent_id(chat.id))
for message in chat.get_messages(include_notifications=True, include_me=True):
topic = "brandon/{}".format(chat.id)
print(topic)
if not isinstance(message, MediaMessage):
payload = "{}: {}".format(message.sender.get_safe_name(), message.content.encode('utf-8').strip())
client.publish(topic, payload)
from webwhatsapi import WhatsAPIDriver
driver = WhatsAPIDriver(username="******")
print('get_unread: ',
driver.get_unread(include_me=True, include_notifications=True))
print('get_contacts: ', driver.get_contacts())
# print('save_firefox_profile: ', driver.save_firefox_profile())
getChatFrom = driver.get_chat_from_phone_number(628999871008)
print('get_chat_from_phone_number: ', getChatFrom)
# print('get_all_messages_in_chat: ', driver.get_all_messages_in_chat(getChatFrom.id, include_me=True, include_notifications=True))
print(driver.get_qr())
print('get_all_chats: ', driver.get_all_chats())
print(driver.wait_for_login())
# print('get_safe_name', driver.get_safe_name())
print('get_unread: ', driver.get_unread())
# print('view_unread: ', driver.view_unread())
class Whatsapp(threading.Thread):
def __init__(self, identifier):
self.driver = WhatsAPIDriver(loadstyles=True)
self.identifier = identifier
self.messagesSent = 0
self.messageQueue = []
self.status = {}
print("Waiting for QR")
try:
self.driver.wait_for_login()
super(Whatsapp, self).__init__()
self.setDaemon(True)
except Exception as ex:
print("Error", ex)
print("New Browser Opened")
def get_chat(self, phone):
try:
chat = self.driver.get_chat_from_phone_number(phone)
except ChatNotFoundError:
url = self.driver._URL+"/send?phone="+phone
self.driver.driver.get(url)
t.sleep(5)
chat = self.driver.get_chat_from_phone_number(phone)
return chat
# Give timeout_after_sent to avoid being suspected as a spammer.
# Assign high value after multithreading is implemented.
def send_whatsapp_message(self, phone, message, chat_id=None):
try:
if chat_id is None:
chat = self.get_chat(phone)
self.driver.chat_send_message(chat.id, message)
else:
self.driver.send_message_to_id(chat_id, message)
self.messagesSent += 1
except ChatNotFoundError:
# This means the given number is invalid.
Logger.warning("Invalid phone number: " + str(phone) + " will be deleted")
c = Contact.objects.get(phone=phone)
c.delete()
raise ChatNotFoundError
except Exception as e:
# This means browser is still not available even after 5 seconds.
# But the number is not invalid.(= valid)
Logger.error(repr(e))
raise e
def send_message_and_save_log(self):
messages = Message.objects.all().filter(use=True).filter(broadcast=True)
for m in messages:
logs = Log.objects.all().filter(message_id=m.id).filter(sent=True)
contacts_already_sent = []
for l in logs:
contacts_already_sent.append(l.contact_id)
contacts_to_send = Contact.objects.all().exclude(id__in=contacts_already_sent)
if len(contacts_to_send) > 0:
# Save the log first so that the same contact cannot be used in another browsers.
for contact in contacts_to_send:
newLogs = Log.objects.filter(message_id=m.id).filter(contact_id=contact.id).get_or_create(message_id=m.id, contact_id=contact.id, sent=False, sender_id=self.identifier, broadcasted=True)
if len(newLogs) > 0:
l = newLogs[0]
try:
print("Try to send message: [phone(", contact.id, ": ", contact.phone, "), text(", m.id, ": ", m.text, ")", sep="")
# If no exception, update 'sent', 'sent_at'
self.send_whatsapp_message(contact.phone, m.text)
l.sent = True
l.sent_at = now()
l.save(update_fields=['sent', 'sent_at'])
# The reason returning here is: once the message is sent to anyone of contacts,
# then server should bring available contacts again, not iterating over the given list.
# Otherwise, there is no way to control server immediately after insert new messages, contacts to DB.
return
except Exception as e:
Logger.warning(repr(e))
# Wait when error occurred so that browser can be opened again.
t.sleep(5)
def poll_unread(self):
try:
if self.driver.is_logged_in():
# Spam only works when this server is used as a spammer.
if apps.WhatsappConfig.spammer == 'true':
try:
self.send_message_and_save_log()
except Exception as e:
Logger.error(repr(e))
# Otherwise, this server will fetch unread messages and send webhook.
else:
data = []
try:
Logger.debug("(" + self.identifier + "): get_unread()")
for messageGroup in self.driver.get_unread():
unread_messages = []
for m in messageGroup.messages:
unread_messages.append({
"content": m.content,
"timestamp": "{timestamp}".format(timestamp=m.timestamp)
})
data.append({ "chatId": messageGroup.chat.id, "unreadMessages": unread_messages })
except Exception as e:
Logger.error(repr(e))
# Doesn't have to make a request when there is no unread message.
if len(data) > 0:
payload = {'data': data}
webhook_url = apps.WhatsappConfig.api_endpoint + '/no_auth/whatsapp/webhook'
try:
print("Request:", webhook_url)
r = requests.post(webhook_url, json=payload, timeout=3)
print("Response:", r.text)
except Exception as e:
print("Tokotalk API(" + webhook_url + ") doesn't respond in 3 second", sep='')
except Exception as e:
Logger.error(repr(e))
def run(self):
while True:
try:
self.poll_unread()
except Exception as e:
Logger.debug(repr(e) + ": POLL FAILED")
# in case the interval is not set in .env
interval = 5
if apps.WhatsappConfig.message_interval is not None:
interval = int(apps.WhatsappConfig.message_interval)
t.sleep(interval)
import os
import sys
import time
from webwhatsapi import WhatsAPIDriver
driver = WhatsAPIDriver(username="******")
for x in arr:
chat = driver.get_chat_from_phone_number(x, True)
driver.send_message_to_id(chat.id, "testando velocidade do envio")
print("Waiting for QR")
wppDriver.wait_for_login()
print("Bot started")
config = {
'postgres': {
'driver': 'postgres',
'host': '35.247.235.153',
'database': 'tbc_wpp',
'user': '******',
'password': '******',
}
}
db = DatabaseManager(config)
Model.set_connection_resolver(db)
class Driver(Model):
__table__ = 'drivers'
pass
drivers = Driver.all()
print("Buscando motoristas...")
for x in drivers:
chat = wppDriver.get_chat_from_phone_number(str(x.phone), True)
wppDriver.send_message_to_id(chat.id, "testando velocidade do envio")
wppDriver.wait_for_login()
print("Bot started")
config = {
'postgres': {
'driver': 'postgres',
'host': '35.247.235.153',
'database': 'tbc_wpp',
'user': '******',
'password': '******',
}
}
db = DatabaseManager(config)
Model.set_connection_resolver(db)
class Driver(Model):
__table__ = 'drivers'
pass
drivers = Driver.all()
print("Buscando motoristas...")
for x in drivers:
chat = wppDriver.get_chat_from_phone_number(str(x.phone), True)
wppDriver.send_message_to_id(chat.id, "testando velocidade do envio")
