def launchurl(self):
global session, service, oneurl
with open("config.ini", "r+") as f:
f.seek(0)
d = f.readlines()
#print(d)
for i in d:
if "url=" + oneurl + '\n' not in i:
f.write(i)
f.write("url=" + self.textEntryVar.get() + "\n")
f.truncate()
try:
url = str(self.textEntryVar.get())
ip = IPv4Address(url) # let's create an IP address object
# now create a session
session = AirmoreSession(ip)
# if your port is not 2333
# session = AirmoreSession(ip, 2334) # assuming it is 2334
was_accepted = session.request_authorization()
if was_accepted == True:
self.nstatus['text'] = "Connected to Phone!"
self.nstatus['fg'] = "blue"
service = MessagingService(session)
except Exception as e:
self.nstatus['text'] = "IP Address Error!"
self.nstatus['fg'] = "red"
def __init__(self):
self.loc = (FILENAME)
self.ip = IPv4Address(IP_ADDRESS)
self.session = AirmoreSession(self.ip)
self.was_accepted = self.session.request_authorization()
if (self.was_accepted):
print("Connection Established")
else:
print("Connection Error! please verify ip address")
exit()
self.service = MessagingService(self.session)
#Open Excel
self.rb = xlrd.open_workbook(self.loc)
self.sheet = self.rb.sheet_by_index(0)
self.wb = copy(self.rb)
self.w_sheet = self.wb.get_sheet(0)
self.createGuestListDict()
self.sendInvitationList()
self.checkRecieve()
self.createArrivedGuestsDict()
self.sendThankYou()
def send_sms_message(self, number, message):
# now create a session
logging.info("Trying connecting AirMore on Android Device (" +
self.get_srv_info() + ")")
session = AirmoreSession(self.amipaddr, self.amport)
if not session.is_server_running:
logging.error("AirMore is not Running on Android Device (" +
self.get_srv_info() + ")")
sys.exit(1)
logging.info("AirMore is Running on Android Device (" +
self.get_srv_info() + ")")
was_accepted = session.request_authorization()
if not was_accepted:
logging.error("AirMore is rejecting session on Android Device (" +
self.get_srv_info() + ")")
sys.exit(2)
logging.error("AirMore is accpeting this session on Android Device (" +
self.get_srv_info() + ")")
service = MessagingService(session)
logging.info("Sending to " + number + " message: " + message)
service.send_message(number, message)
logging.info("Message sent to " + number)
def connecting(self):
try:
ip = str(self.ip_input.text())
port = int(self.port_input.text())
ip4 = IPv4Address(ip)
session = AirmoreSession(ip4, port)
if session.is_server_running:
self.status_connection.append("server is up")
if session.request_authorization():
self.status_connection.append("you are connect to phone")
except:
self.status_connection.append("check the connection")
def __init__(self, ip, port):
try:
self.__session = AirmoreSession(IPv4Address(ip), port)
self.__service = MessagingService(self.__session)
accepted = self.__session.request_authorization()
if not accepted:
raise Exception(f'Autorizzazione non accettata')
except Exception as e:
print(f'Error: {e}')
def __init__(self, phone_IP, send_number):
self.__send_number = format_phone_number(send_number)
self.__session = AirmoreSession(IPv4Address(phone_IP))
self.__correct_direction = lambda x: x.type == MessageType.RECEIVED
assert self.__session.is_server_running
assert self.__session.request_authorization()
self.__service = MessagingService(self.__session)
self.__initialization_time = datetime.datetime.now()
self.__chat_id = None
self.__chat_id = self.__get_chat_id()
self.__buffer = b''
self.__already_read = set()
# Add new messages to already read...
self.get_new_messages()
def send_insurance(self, ip_addr, cellPhone, name, message):
ipAddress = ip_addr
ip = IPv4Address(ipAddress)
session = AirmoreSession(ip, 2333)
service = MessagingService(session)
sendMessage = "{}님 안녕하세요. {}".format(name, message)
service.send_message(cellPhone, sendMessage)
def cellphone(verbose: bool = False):
ip = userinput("Airmore cellphone ip",
validator="ip",
always_use_default=True,
maximum_attempts=1)
if ip is None:
ip = userinput("Airmore cellphone ip", validator="ip")
device_ip = IPv4Address(ip)
session = AirmoreSession(device_ip)
if verbose:
print("I'm going to connect with your cellphone!")
print("Open up Airmore!")
if (session.request_authorization()):
return session
raise ValueError(
"Unable to connect to device, you might need to restart AirMore!")
class SmsSender:
def __init__(self, ip, port):
try:
self.__session = AirmoreSession(IPv4Address(ip), port)
self.__service = MessagingService(self.__session)
accepted = self.__session.request_authorization()
if not accepted:
raise Exception(f'Autorizzazione non accettata')
except Exception as e:
print(f'Error: {e}')
def send(self, receiver, content):
try:
self.__service.send_message(receiver, content)
except Exception as e:
print(f'Error: {e}')
def send_all(self, rows):
counter = 1
sleep_each = 10
sleep_second = 5
for row in rows:
if counter % sleep_each == 0:
print("sleep")
sleep(sleep_second)
data = dict(row)
# self.send(data['Cellulare'], f"Sono disponibili {data['Pronti']} libri su {data['Totale']}")
self.send(
'3356760194',
f"Sono disponibili {data['Pronti']} libri su {data['Totale']}")
counter += 1
print("FINITO")
def close(self):
self.__session.close()
def waitForPasscodeLabel(self, method):
global PIN_CODE
session = AirmoreSession(IPv4Address(str(config.core['airmore_server']))) # also you can put your port as int, airmore's port default is 2333
session.is_server_running # True
session.request_authorization() # True if accepted, False if denied
service = MessagingService(session)
messages = service.fetch_message_history()
pattern = "For your online transaction, please use this MasterCard SecureCode One-Time Password: (\w{4})-(\d{6})"
for msg in messages:
group = re.findall(pattern, msg.content)
if len(group) > 0 and len(group[0]) > 0:
if group[0][0] == str(self.driver.find_element(By.CSS_SELECTOR , "#pwdpage > table:nth-child(2) > tbody:nth-child(1) > tr:nth-child(3) > td:nth-child(1) > table:nth-child(3) > tbody:nth-child(1) > tr:nth-child(9) > td:nth-child(2) > span:nth-child(2)").text):
PIN_CODE = str(group[0][1])
return True
return False
def waitForPasscodeLabel(self, method):
global PIN_CODE
session = AirmoreSession(IPv4Address(str(config.core['airmore_server']))) # also you can put your port as int, airmore's port default is 2333
session.is_server_running # True
session.request_authorization() # True if accepted, False if denied
service = MessagingService(session)
messages = service.fetch_message_history()
pattern = "HSBC: Verification code is (\D{4}-)(\d{6})"
for msg in messages:
group = re.findall(pattern, msg.content)
if len(group) > 0 and len(group[0]) > 0:
if group[0][0] == str(self.driver.find_element(By.ID, "passcodelabel").text):
PIN_CODE = str(group[0][1])
return True
return False
class Airmore_SMS_handler(object):
def __init__(self, phone_IP, send_number):
self.__send_number = format_phone_number(send_number)
self.__session = AirmoreSession(IPv4Address(phone_IP))
self.__correct_direction = lambda x: x.type == MessageType.RECEIVED
assert self.__session.is_server_running
assert self.__session.request_authorization()
self.__service = MessagingService(self.__session)
self.__initialization_time = datetime.datetime.now()
self.__chat_id = None
self.__chat_id = self.__get_chat_id()
self.__buffer = b''
self.__already_read = set()
# Add new messages to already read...
self.get_new_messages()
def send(self, message):
assert isinstance(message, str)
self.__service.send_message(self.__send_number, message)
def get_new_messages(self):
chat_id = self.__get_chat_id()
new_messages = []
if chat_id != None:
messages = self.__service.fetch_chat_history(message_or_id=chat_id, limit=50)
for message in messages:
if self.__correct_direction(message) and not (message.id, message.content) in self.__already_read:
new_messages.append(message.content)
self.__already_read = set((message.id, message.content) for message in messages)
return new_messages
def __get_chat_id(self):
if self.__chat_id != None:
return self.__chat_id
for message in self.__service.fetch_message_history():
if format_phone_number(message.phone) == self.__send_number:
self.__chat_id = message.id
return self.__chat_id
@staticmethod
def create_test_connection():
handler1 = Airmore_SMS_handler('192.168.1.22', '8016605023')
handler2 = Airmore_SMS_handler('192.168.1.23', '8016436371')
return handler1, handler2
def employee_send(self, ip_addr, port, cellPhone, name, info):
# Airmore 활성화
ipAddress = ip_addr
ip = IPv4Address(ipAddress)
session = AirmoreSession(ip, int(port))
service = MessagingService(session)
now_date = datetime.date.today()
#보낼 문자내용
if info == '직원등록':
message = '{}일자로 {}님의 직원등록이 완료되었습니다.'.format(now_date, name)
elif info == '직원수정':
message = '{}님의 정보가 변경 완료되었습니다.'.format(name)
elif info == '보험사서류발송':
message = '처리 서류를 메일로 발송하였습니다. 확인 부탁드립니다.'.format(name)
elif info == '관리자등록':
message = '{}일자로 {}님의 관리자등록이 완료되었습니다.'.format(now_date, name)
service.send_message(cellPhone, message)
def sending(self):
try:
ip = str(self.ip_input.text())
port = int(self.port_input.text())
ip4 = IPv4Address(ip)
phone_number = str(self.number_input.text())
count_massage = int(self.count_input.text())
message = str(self.content_input.toPlainText())
session = AirmoreSession(ip4, port)
service = MessagingService(session)
try:
for c in range(1, count_massage + 1):
service.send_message(phone_number, message)
percent = (c / count_massage) * 100
self.progressBar.setProperty("value", percent)
self.message_send_status.append("message %i sended" % c)
self.sended_lcd.display(c)
sleep(1)
except:
self.message_send_status.append(
"the message not send. check the information.")
except:
self.message_send_status.append("check the connection")
class Wedding():
def __init__(self):
self.loc = (FILENAME)
self.ip = IPv4Address(IP_ADDRESS)
self.session = AirmoreSession(self.ip)
self.was_accepted = self.session.request_authorization()
if (self.was_accepted):
print("Connection Established")
else:
print("Connection Error! please verify ip address")
exit()
self.service = MessagingService(self.session)
#Open Excel
self.rb = xlrd.open_workbook(self.loc)
self.sheet = self.rb.sheet_by_index(0)
self.wb = copy(self.rb)
self.w_sheet = self.wb.get_sheet(0)
self.createGuestListDict()
self.sendInvitationList()
self.checkRecieve()
self.createArrivedGuestsDict()
self.sendThankYou()
def getConfirmedGuests(self):
column_sum = 0
for row in range(self.sheet.nrows):
try:
column_sum += self.sheet.cell_value(row, 4)
except:
pass
return int(column_sum)
def createArrivedGuestsDict(self):
arrived_guests = 0
self.guest_dict = {}
for i in range(1, self.sheet.nrows):
try:
if ((self.sheet.cell_value(i, 12)>0) and (len(self.sheet.cell_value(i, 2))==10)): #Person did not response and phone number is defined in list
phone_number = self.sheet.cell_value(i, 2)
phone_number = COUNTRY_AREA_CODE + phone_number[1:len(phone_number)]
self.guest_dict[phone_number] = i
arrived_guests += self.sheet.cell_value(i, 10)
except:
pass
print("Total Arrived Guests - ", arrived_guests)
def createGuestListDict(self):
not_resp = 0
self.guest_dict = {}
for i in range(0, self.sheet.nrows):
if ((self.sheet.cell_value(i, 9)=="לא הגיב") and (len(self.sheet.cell_value(i, 2))==10)): #Person did not response and phone number is defined in list
phone_number = self.sheet.cell_value(i, 2)
phone_number = COUNTRY_AREA_CODE + phone_number[1:len(phone_number)]
self.guest_dict[phone_number] = i
not_resp += 1
print("Total Rows - ", self.sheet.nrows, "Did not responed - ", not_resp, " confirmed guests - ", self.getConfirmedGuests())
def checkRecieve(self):
while True:
messages = self.service.fetch_message_history()
for i in range(0,20): #Check only last 20 messages
#Update person with the retuned number of SMS
try:
print(messages[i].phone)
print("Recieved Message from - ", messages[i].phone, " number of confirmed guests - ", int(messages[i].content))
if ((messages[i].phone in self.guest_dict) and (self.sheet.cell_value(self.guest_dict[messages[i].phone], 9)=="לא הגיב")):
print("Guest Confirmed!! Recieved Message from - ", messages[i].phone, " number of confirmed guests - ", int(messages[i].content))
self.w_sheet.write(self.guest_dict[messages[i].phone], 10, messages[i].content)
self.w_sheet.write(self.guest_dict[messages[i].phone], 9, "מגיע")
if (int(messages[i].content)>0):
print("Send Transportation")
print(messages[i].phone, TRANSPORTATION) if DEBUG else self.service.send_message(messages[i].phone, TRANSPORTATION)
self.wb.save('Wedding.xlsx')
except:
pass
time.sleep(0.2)
def sendThankYou(self):
print("Do you want to send THANK YOU SMS? \n")
choice = input().lower()
if (choice=="yes"):
print ("Sending SMS")
#Send SMS
for i in self.guest_dict:
print("Send SMS to - ", i)
name = self.sheet.cell_value(self.guest_dict[i], 0)
msg_to_send = name + ",\n" + THANK_YOU
print(msg_to_send) if DEBUG else self.service.send_message(i, msg_to_send)
time.sleep(2)
def sendInvitationList(self):
print("Do you want to send INVITATION SMS? \n")
choice = input().lower()
if (choice=="yes"):
print ("Sending SMS")
for i in self.guest_dict:
print("Send SMS to - ", i)
print(INVITE_REMINDER) if DEBUG else self.service.send_message(i, INVITE)
time.sleep(1)
def sendInvitationReminderAllList(self):
print("Do you want to send INVITATION REMINDER SMS? \n")
choice = input().lower()
if (choice=="yes"):
print ("Sending SMS")
for i in self.guest_dict:
print("Send SMS to - ", i)
print(INVITE_REMINDER) if DEBUG else self.service.send_message(i, INVITE_REMINDER)
time.sleep(1)
def __init__(self, ip):
self.ip = IPv4Address(ip)
self.session = AirmoreSession(self.ip)
self.messageService = MessagingService(self.session)
self.otpStart = 'Your OTP to register/access CoWIN is'
'''
import pyairmore
from openpyxl import load_workbook
from ipaddress import IPv4Address # for your IP address
from pyairmore.request import AirmoreSession # to create an AirmoreSession
from pyairmore.services.messaging import MessagingService # to send messages
# Airmore 활성화
ipAddress = input("핸드폰과 연결할 내부아이피를 입력하세요. ")
if not ipAddress:
ip = IPv4Address("192.168.100.210")
else:
ip = IPv4Address(ipAddress)
session = AirmoreSession(ip, 2333)
service = MessagingService(session)
# 보낼 문자내용
filepathMessage = open("./message.txt", 'rt', encoding='UTF8')
message = filepathMessage.read()
filepathMessage.close()
# 주소록 파일
filepathContact = "./contact.xlsx"
# 연락처 컬럼
columnName = "A"
columnPhone = "B"
workbook = load_workbook(filename=filepathContact, read_only=True)
from ipaddress import IPv4Address # for your IP address
from pyairmore.request import AirmoreSession # to create an AirmoreSession
from pyairmore.services.messaging import MessagingService # to send messages
print("Setup your Airmore ap with the code")
ipadd1 = str(input("Enter ip address mentioned on the Airomre app: "))
ip = IPv4Address(
ipadd1) # let's create an IP address object# now create a session
port1 = int(input("Enter the port-number mentioned on the Airomre app: "))
#session = AirmoreSession(ip)# if your port is not 2333
session = AirmoreSession(ip, port1) # assuming it is 2333
session.is_server_running # True if Airmore is running
was_accepted = session.request_authorization()
print(was_accepted) # True if accepted
#inputs to send sms
mobile_number = str(input("Enter the mobile number to send message: "))
message_content = str(input("Enter the content to send: "))
#starting sms
service = MessagingService(session)
config = {
'apiKey': "",
'authDomain': "",
'databaseURL': "",
'projectId': "",
'storageBucket': "",
'messagingSenderId': "",
'appId': "",
'measurementId': ""
}
co = 1
ip = IPv4Address("192.168.43.1")
session = AirmoreSession(ip)
session = AirmoreSession(ip, 2333) # assuming it is 2334
service = MessagingService(session)
was_accepted = session.request_authorization()
# # print(was_accepted)
# message = None
# message = service.fetch_message_history()[0]
firebase = pyrebase.initialize_app(config)
authe = firebase.auth()
database = firebase.database()
cred = credentials.Certificate("/home/prathamesh/Downloads/loginregister-5c8a7-firebase-adminsdk-w7e9m-2335f41a50.json")
driver.find_element_by_xpath(nextBtn_xpath).click()
sleep(15)
#page2 phone verification functionality
driver.find_element_by_xpath(inputPhoneNo_xpath).send_keys(phoneNumber)
driver.find_element_by_xpath(phoneNext_xpath).click()
sleep(25)
print("here")
#getting text from phone using pyairmore
ip = IPv4Address(
"192.168.0.27"
) # whatever server's address is(press the three dots at top right corner of airmore apk to get this)
session = AirmoreSession(ip) # port is default to 2333
txt_service = MessagingService(session)
messages = txt_service.fetch_message_history()
OTP_message = messages[0].content # "latest Message"
OTP_code = findnum(r'\d+', OTP_message)
driver.find_element_by_xpath(otpInput_xpath).send_keys(OTP_code)
driver.find_element_by_xpath(OTPverify_xpath).click()
sleep(15)
#page3 Bio info functionality
driver.find_element_by_xpath(birthDate_xpath).send_keys(1)
dropMonth = Select(driver.find_element_by_xpath(birthMonthDrop_xpath))
dropMonth.select_by_value('2')
driver.find_element_by_xpath(birthYear_xpath).send_keys(i.dob)
from ipaddress import IPv4Address
from pyairmore.request import AirmoreSession
from pyairmore.services.messaging import MessagingService
import sys
ip = IPv4Address(f'{sys.argv[1]}')
session = AirmoreSession(ip, 2333)
print(session.is_server_running)
req_authorization = session.request_authorization()
service = MessagingService(session)
service.send_message(f'+91{sys.argv[2]}', f'{sys.argv[3]}')
def set_airmore_session(self):
ip = IPv4Address(self.config['AIRMORE_IP_ADDRESS'])
self.session = AirmoreSession(ip)
from ipaddress import IPv4Address # for your IP address
from pyairmore.request import AirmoreSession # to create an AirmoreSession
from pyairmore.services.messaging import MessagingService # to send messages
from flask import Flask, render_template,abort,request
from pymongo import MongoClient
import requests
import json
from datetime import datetime
import os
app = Flask(__name__)
ip = IPv4Address("192.168.0.144") # let's create an IP address object
# now create a session
session = AirmoreSession(ip)
#authorization
was_accepted = session.request_authorization()
#sendign messages
service = MessagingService(session)
@app.route("/",methods=["GET"])
def main():
return render_template("broadcast.html")
@app.route("/send_weather",methods=["POST"])
def weather_update():
#send
village_id = request.get_json()["village_id"] #getting the data from the broadcast website
filee_read = open("village_database/{}.txt".format(village_id),"r")
numbers = filee_read.read().split(",")
message = "WEATHER UPDATE BROADCAST MESSAGE: MAX TEMP:32C, MIN TEMP:28C,LOW CHANCES OF RAIN."
return ip4, port
def connection():
global session
if session.is_server_running:
print("server is up")
if session.request_authorization():
print("yah, you`r connect")
else:
connection()
def sending():
global session
rucontinue = "y"
while rucontinue == "y":
phone_number = input("insert your taget phone number:")
count_massage = int(input("how many times?"))
massage = input("your massage:")
service = MessagingService(session)
for i in range(0, count_massage):
print("massage %s is seding" % str(i + 1))
service.send_message(phone_number, massage)
rucontinue = input("are you want to continue?(y for continue)")
ip4, port = get_data_connection()
session = AirmoreSession(ip4, port)
connection()
sending()
