import threading
from random import choice
from os import listdir
from time import sleep
import time
import re
from itertools import islice
from datetime import datetime
from SQL import Account
from SQL import DateTime
from SQL import Username
from SQL import AdminsBot
from SQL import Groups
from SQL import SettingAddmember
from SQL import AddStatistics
from pyrogram import Client
from pyrogram import filters
from pyrogram import idle
from pyrogram import errors
from pyrogram.types import InlineKeyboardButton as button
from pyrogram.types import InlineKeyboardMarkup as markup
from pyrogram.types import ForceReply as reply
api_id, api_hash = 2624818, "9d6e5f2365a2a9867d219e869f3e3656" #api_id,"api_hash"
token="1690295388:AAHC0gcrIlDGnjIW7cWYpoDL_-TO8auo_Hs" #Token bot API
app = Client("bot",api_id,api_hash,bot_token=token)
numbers = list()
for fil in listdir('sessions'):
numbers.append(fil.split("phone")[-1].split(".")[0])
global step
global phone_code_hashs
global sessions
global y
step= 'None'
phone_code_hashs= dict()
sessions= dict()
y= 0
Message = None
@app.on_message(filters.command(['start']))
def start (client,message):
chat_id = message.chat.id
print("Start id ->",chat_id)
message_id = message.message_id
Menu(chat_id,message_id)
@app.on_callback_query()
def querys(_, query):
chat_id = query.message.chat.id
message_id = query.message.message_id
data = query.data
db = AdminsBot("Model.db")
db.create_table()
listadmins = db.get_list_admins()
DeleteAdmin = [Id[1] for Id in listadmins]
db.close()
db = Groups("Model.db")
db.create_table()
List_groups = db.get_list_groups()
DeleteGroup = [Id[1] for Id in List_groups]
AddToGroup = [Id[1]for Id in List_groups]
db.close()
if data == "StartLogin" : StartLogin(chat_id,message_id,query)
if data == "ComebackToMenu" : Menu2(chat_id,message_id)
if data == "StartUAR" : StartUAR(chat_id,message_id)
if data == "StarCollect" : StarCollect(chat_id,message_id,query)
if data == "StartSet" : StartSet(chat_id,message_id)
if data == "SetAdd" : SetAdd(chat_id,message_id,query)
if data == "EditAccount" : EditAccount(chat_id,message_id)
if data == "RemoveAccount" : RemoveAccount(chat_id,message_id,query)
if data == "EditAdmins" : EditAdmins(chat_id,message_id)
if data == "ComebackSettings": StartSet(chat_id,message_id)
if data == "AddAdmin" : AddAdmin(chat_id,message_id,query)
if data == "RemoveAdmin" : RemoveAdmin(chat_id,message_id,query)
if data == "ShowAdmins" : ShowAdmins(chat_id,message_id,query)
if data == "StartStat" : Statistics(chat_id,message_id)
if data == "Accounts" : Accounts(chat_id,message_id,query)
if data == "Activity" : Activityy(chat_id,message_id,query)
if data == "EditGroups" : EditGroups(chat_id,message_id)
if data == "AddGroup" : AddGroup(chat_id,message_id)
if data == "SettingAdd" : SettingAdd(chat_id,message_id)
if data == "RemoveGroup" : RemoveGroup(chat_id,message_id,query)
if data == "ShowGroup" : ShowGroup(chat_id,message_id,query)
if data == "ShowSettings" : ShowSettings(chat_id,message_id,query)
if data == "StartAdd" : StartAdd(chat_id,message_id,query)
if data == "EditSettings" : EditSettings(chat_id,message_id)
if data == "IDeas" : IDeas(chat_id,message_id)
if data == "None" : MessageNone(chat_id,message_id,query)
if data[:2] == "re" and data[2:] in DeleteAdmin : DeleteAdmins(chat_id,message_id,query,data)
if data[:2] == "re" and data[2:] in DeleteGroup : DeleteGroups(chat_id,message_id,query,data)
if data[:2] == "ad" and data[2:] in AddToGroup : AddToGroups(chat_id,message_id,query,data)
@app.on_message()
def Updates(app,message):
global step
chat_id = message.chat.id
message_id = message.message_id
text = message.text
if step == "GetPhone":
GetPhone(chat_id,message_id,text)
elif step.split(" ")[0] == "LoginCode":
LoginCode(chat_id,message_id,text)
elif step == "GetUsername":
GetUsername(chat_id,message_id,text)
elif step == "SaveAdmin":
SaveAdmin(chat_id,message_id,text,message)
elif step == "SaveGroup":
SaveGroup(chat_id,message_id,text,message)
elif step == "GetActivityRange":
GetActivityRange(chat_id,message_id,text,message)
elif step == "DeleteAccount":
DeleteAccount(chat_id,message_id,text,message)
elif step[:11] == "GetAddRange" and step[11:].isdigit():
GetAddRange(chat_id,message_id,text,message)
elif step[:18] == "GettActivityNumber":
GettActivityNumber(chat_id,message_id,text,message)
#Menu------------------------------------------------------------------------------------------------------------
def Menu(chat_id,message_id):
modir = 1569699710 #add chat_id modir
db = AdminsBot("Model.db")
db.create_table()
list_admin = db.get_list_admins()
db.close()
list_a = [i[1] for i in list_admin]
if chat_id == modir or str(chat_id) in list_a:
app.send_message(chat_id,
" ??? Hi Admin. \nSelect Your Fav",
reply_to_message_id = message_id,
reply_markup = markup([[button("Login New Account ?",callback_data="StartLogin")],
[button("Collect Usernames ?",callback_data="StarCollect"),button("Add ? to Group ?",callback_data="StartAdd")],
[button("Statistics ?",callback_data="StartStat"),button("? Bot Settings ⚙️",callback_data="StartSet")],
[button("Update Account Reports",callback_data="StartUAR")]
]))
else:
app.send_message(chat_id,f"⭕️ You are not allowed to use this robot",parse_mode='html')
def Menu2(chat_id,message_id):
app.edit_message_text(chat_id,message_id,
" ??? Hi Admin. \nSelect Your Fav",
reply_markup = markup([[button("Login New Account ?",callback_data="StartLogin")],
[button("Collect Usernames ?",callback_data="StarCollect"),button("Add ? to Group ?",callback_data="StartAdd")],
[button("Statistics ?",callback_data="StartStat"),button("? Bot Settings ⚙️",callback_data="StartSet")],
[button("Update Account Reports",callback_data="StartUAR")]
]))
#/----------------------------------------------------------------------------------------------------------------
#MessageNone------------------------------------------------------------------------------------------------------
def MessageNone(chat_id,message_id,query):
query.answer(f"??? ??? ?????")
#/----------------------------------------------------------------------------------------------------------------
#MessageTwo-------------------------------------------------------------------------------------------------------
def MessageTwo(chat_id,message_id):
app.send_message(chat_id,"The ID list is empty")
#/----------------------------------------------------------------------------------------------------------------
#MessageTree-------------------------------------------------------------------------------------------------------
def MessageThree(chat_id,message_id):
app.send_message(chat_id,"The number of accounts you request is more than the existing accounts")
#/----------------------------------------------------------------------------------------------------------------
#log in-----------------------------------------------------------------------------------------------------------
def StartLogin(chat_id,message_id,query):
global step
app.edit_message_text(chat_id,message_id,"Send Your Number\nFor example: +989381754806",parse_mode="html")
step = "GetPhone"
def GetPhone(chat_id,message_id,text):
global step
if not text[1:].isdigit() or text[0] != "+":
app.send_message(chat_id, f"Your Number Is Wrong❌",parse_mode="html",reply_to_message_id = message_id)
step = "GetPhone"
return
Send_Code_Request(chat_id, message_id, text.replace(" ", ""))
def Send_Code_Request(chat_id,message_id,number):
global step
global phone_code_hashs
global sessions
session = f'sessions/phone{number}'
api_id, api_hash = 2624818, "9d6e5f2365a2a9867d219e869f3e3656" #api_id,"api_hash"
client = Client(session,api_id,api_hash)
client.connect()
try:
phone_code_hash = client.send_code(number).phone_code_hash
app.send_message(chat_id, f"Code Sended To {number} \nPlease Enter 5 digit Login Code!",parse_mode="html",reply_to_message_id=message_id)
sessions[number] = client
phone_code_hashs[number] = phone_code_hash
step = f"LoginCode {number}"
except errors.PhoneNumberInvalid as error:
print(error)
app.send_message(chat_id,"The phone number is invalid!\nPlease correct the number or send another number",parse_mode="html", reply_to_message_id = message_id)
step = 'GetPhone'
def LoginCode(chat_id,message_id,code):
global step
global phone_code_hashs
global sessions
if not code.isdigit() or len(code) != 5:
app.send_message(chat_id,"Your Login Code Is Wrong",parse_mode='html',reply_to_message_id = message_id)
return
number = step.split(" ")[1]
client = sessions[number]
#Register and Login
try:
client.sign_in(phone_number= number,phone_code_hash =phone_code_hashs[number], phone_code=code)
except errors.PhoneNumberUnoccupied as error:
client.sign_up(phone_number= number,phone_code_hash= phone_code_hash, first_name= "aryn" , last_name= "kaviani")
app.send_message(chat_id,"Register and Login Successfull!",parse_mode="html", reply_to_message_id= message_id)
step = 'None'
return
except errors.SessionPasswordNeeded as error:
print(error)
app.send_message(chat_id,"Two-step verification password required!\nPlease disable the two steps and then send the number here",parse_mode="html", reply_to_message_id = message_id)
step = 'GetPhone'
return
except errors.PhoneCodeExpired as error:
print(error)
app.send_message(chat_id,"The confirmation code has expired!",parse_mode="html", reply_to_message_id= message_id)
step = 'None'
return
except errors.PhoneCodeInvalid as error:
print(error)
app.send_message(chat_id,"The confirmation code is invalid!",parse_mode="html", reply_to_message_id= message_id)
step = 'None'
except Exception as error:
print(error)
else:
app.send_message(chat_id, "Login Successfull.",parse_mode="html", reply_to_message_id=message_id)
SpamBot(chat_id,message_id,number)
def SpamBot(chat_id,message_id,number,c=None):
api_id, api_hash = 2624818, "9d6e5f2365a2a9867d219e869f3e3656" #api_id,"api_hash"
try:
with Client(f'sessions/phone{number}',api_id,api_hash)as app:
app.send_message("@SpamBot","/start")
count = 1
for message in app.iter_history("SpamBot"):
if count == 1:
text = message.text
count += 1
if re.search(r"^Good news",text) or re.search(r"^مژده",text):
report = False
elif re.search(r"Unfortunately",text):
report = "Permanent"
elif re.search(r"limited until(.*)\.",text):
reep = re.findall(r"limited until(.*)\.",text)
report =reep[0]
else:pass
#DataBaste
db = Account("Model.db")
db.create_table()#Create Table
all_phone_number = db.get_list_phone()
if str(number) not in all_phone_number:
SaveAccountNew(chat_id,number,api_id,api_hash,report)
elif str(number) in all_phone_number:
UpdatesReportAccount(report,number,c,chat_id,message_id)
db.close()
except Exception as error:
print(f"Error 1{error}")
def SaveAccountNew(chat_id,number,api_id,api_hash,report):
date = DateTime().d
time = DateTime().t
SuccessfulAdds,UnSuccessfulAdds,Adds = 0,0,0
AllData = (f"{number}",f"{api_id}",f"{api_hash}",f"{report}",f"False",f"{date}",f"01-01-2020",f"{time}",f"{0}",f"{0}",f"{0}")
db = Account("Model.db")
db.insert_data(AllData)
print(f"insert data phone number {number} to database")
app.send_message(chat_id,f"✅ Insert Data Phone Number {number} To Database")
db.close()
def UpdatesReportAccount(report,number,c,chat_id,message_id):
global y,Message
db = Account("Model.db")
reports = (f"{report}",f"{number}")
db.update_report(reports)
list_account = db.get_list_phone()
db.close()
l = len(list_account)
print(f"({number}) -> report:{report}")
if y <= 0:
Message= app.send_message(chat_id,f"({number}) -> report:{report}",parse_mode='html')
y += 1
else:
app.edit_message_text(chat_id,Message.message_id,f"({number})\nreport:{report}",parse_mode='html')
if c == l:
sleep(1)
app.send_message(chat_id,f"✅ The report status of your accounts has been updated",parse_mode='html',reply_to_message_id=message_id)
else:pass
#/-----------------------------------------------------------------------------------------------------------------
#get username------------------------------------------------------------------------------------------------------
def StarCollect(chat_id,message_id,query):
global step
app.edit_message_text(chat_id,message_id,"Send The Group Link Or Username\nFor example: @username",parse_mode="html",
reply_markup=markup([[button("Comeback To Menu ? ",callback_data="ComebackToMenu")]]))
step = "GetUsername"
def GetUsername(chat_id,message_id,text):
api_id, api_hash = 2624818, "9d6e5f2365a2a9867d219e869f3e3656" #api_id,"api_hash"
try:
with Client('session_me',api_id,api_hash) as app:
count = 0
try:
app.join_chat(text)
except Exception as error:print(error)
try:
for member in app.iter_chat_members(f"{text[1:]}"):
if member.user.username != None and member.user.is_self != True and member.user.is_bot != True:
user_username = member.user.username
user_id = member.user.id
db = Username("Model.db")
db.create_table()
all_username_database = db.get_list_username
if user_username not in all_username_database():
AllData = (f"{user_username}",f"{member.user.id}")
db.insert_data(AllData)
count += 1
db.close()
print(f"save username {member.user.username}")
else:pass
else:pass
except Exception as error:print(error)
MessageSaveUsername(chat_id,text,count)
except Exception as error:print (error)
def MessageSaveUsername(chat_id,text,count):
if count > 0:
print("end Save username")
app.send_message(chat_id,f"{count} usernames from group {text} were added to the database",parse_mode="html")
step ="None"
else:
app.send_message(chat_id,f"No usernames were added to the database",parse_mode="html")
step="None"
#/-----------------------------------------------------------------------------------------------------------------
#settings-----------------------------------------------------------------------------------------------------------
def StartSet(chat_id,message_id):#setting -> Edit Admins - Edit Groups - Setting Addmember
global step
app.edit_message_text(chat_id,message_id,"Click the desired button to set and edit",
reply_markup=markup([[button("Admins ?",callback_data="EditAdmins"),button("Groups ?",callback_data="EditGroups")],
[button("Settings Addmember ?",callback_data="SettingAdd"),button("Account ?",callback_data="EditAccount")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu")]]))
step = 'None'
def EditAdmins(chat_id,message_id):#edit admins -> AddAdmin - RemoveAdmin - ShowAdmins
global step
modir = 1569699710 #add chat_id modir
if chat_id == modir:
app.edit_message_text(chat_id,message_id,"Edit Admins",
reply_markup=markup([[button("Remove Admin ➖",callback_data="RemoveAdmin"),button("Add Admin ➕",callback_data="AddAdmin")],
[button("Show Admins",callback_data="ShowAdmins")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="ComebackSettings")]]))
step = 'None'
def AddAdmin(chat_id,message_id,query):
global step
app.edit_message_text(chat_id,message_id,"Send us the New Admin Username\nFor example: @username",parse_mode="html")
step = "SaveAdmin"
def SaveAdmin(chat_id,message_id,text,message):
global step
api_id, api_hash = 2624818, "9d6e5f2365a2a9867d219e869f3e3656" #api_id,"api_hash"
try:
with Client('session_me',api_id,api_hash) as app:
try:
chat = app.get_chat(f"{text[1:]}")
Id = chat.id
name = chat.first_name
username = chat.username
except Exception as error:print(error)
AllData = (f"{name}",f"{Id}",f"{username}")
db = AdminsBot("Model.db")
db.create_table()
db.insert_data(AllData)
print("save admin in admins")
MessageSaveAdmin(chat_id,message_id,text)
db.close()
except Exception as error:print(error)
def MessageSaveAdmin(chat_id,message_id,text):
app.send_message(chat_id,f"Save {text} in Admins",reply_to_message_id=message_id)
def RemoveAdmin(chat_id,message_id,query):
try:
db = AdminsBot("Model.db")
db.create_table()
listadmins = db.get_list_admins()
db.close()
if len(listadmins) > 0:
keyboard = [button(f"{admin[0]}",callback_data= f"re{admin[1]}") for admin in listadmins]
key = iter(keyboard)
Output = [list(islice(key,elem))for elem in[2 for n in range(len(keyboard))]]
app.edit_message_text(chat_id,message_id,"Remove\nClick on admin name to remove",
reply_markup=markup(Output))
else:
query.answer(f"not admin")
StartSet(chat_id,message_id)
except Exception as error:print(error)
def DeleteAdmins(chat_id,message_id,query,data):
try:
ID = (f"{data[2:]}",)
db = AdminsBot("Model.db")
db.create_table()
db.delete_admin(ID)
db.close()
query.answer(f"delete admin")
RemoveAdmin(chat_id,message_id,query)
except Exception as error:print(error)
def ShowAdmins(chat_id,message_id,query):
try:
db = AdminsBot("Model.db")
db.create_table()
listadmins = db.get_list_admins()
if len(listadmins) > 0:
keyboard = [button(f"{admin[0]}",url=f"https://t.me/{admin[2]}")for admin in listadmins]
key = iter(keyboard)
Output = [list(islice(key,elem))for elem in[2 for n in range(len(keyboard))]]
app.edit_message_text(chat_id,message_id,"Admins AddMemberBot",reply_markup=markup(Output))
else:
query.answer(f"not admin")
StartSet(chat_id,message_id)
except Exception as error:print(error)
def EditGroups(chat_id,message_id):#edit groups -> AddGroup - RemoveGroup - ShowGroups
app.edit_message_text(chat_id,message_id,"Edit Groups",
reply_markup=markup([[button("Remove Group ➖",callback_data="RemoveGroup"),button("Add Group ➕",callback_data="AddGroup")],
[button("Show Group",callback_data="ShowGroup")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="ComebackSettings")]]))
step = 'None'
def AddGroup(chat_id,message_id):
global step
app.edit_message_text(chat_id,message_id,"Send us the new Group Username\nFor example: @username",parse_mode="html")
step = "SaveGroup"
def SaveGroup(chat_id,message_id,text,message):
api_id, api_hash = 2624818, "9d6e5f2365a2a9867d219e869f3e3656" #api_id,"api_hash"
with Client('session_me',api_id,api_hash) as app:
try:
chat = app.get_chat(f"{text[1:]}")
Id = chat.id
name = chat.title
username = chat.username
except Exception as error:print(error)
AllData = (f"{name}",f"{Id}",f"{username}")
db = Groups("Model.db")
db.create_table()
db.insert_data(AllData)
db.close()
print("save group in groups")
MessageSaveGroup(chat_id,message_id,text)
def MessageSaveGroup(chat_id,message_id,text):
app.send_message(chat_id,f"save {text} in Groups",reply_to_message_id=message_id)
def RemoveGroup(chat_id,message_id,query):
try:
db = Groups("Model.db")
db.create_table()
listgroups = db.get_list_groups()
if len(listgroups) > 0:
keyboard = [button(f"{group[0]}",callback_data= f"re{group[1]}") for group in listgroups]
key = iter(keyboard)
Output = [list(islice(key,elem))for elem in[2 for n in range(len(keyboard))]]
app.edit_message_text(chat_id,message_id,"Remove\nClick on group name to remove",
reply_markup=markup(Output))
else:
query.answer(f"not group")
StartSet(chat_id,message_id)
except Exception as error:print(error)
def DeleteGroups(chat_id,message_id,query,data):
try:
ID = (f"{data[2:]}",)
db = Groups("Model.db")
db.create_table()
db.delete_group(ID)
db.close()
query.answer(f"delete Group")
RemoveGroup(chat_id,message_id,query)
except Exception as error:print(error)
def ShowGroup(chat_id,message_id,query):
db = Groups("Model.db")
db.create_table()
listgroups = db.get_list_groups()
print(len(listgroups))
if len(listgroups) > 0:
keyboard = [button(f"{group[0]}",url=f"https://t.me/{group[2]}")for group in listgroups]
key = iter(keyboard)
Output = [list(islice(key,elem))for elem in[2 for n in range(len(keyboard))]]
app.edit_message_text(chat_id,message_id,"Groups AddMemberBot",reply_markup=markup(Output))
else:
query.answer(f"Not Group! ❌")
StartSet(chat_id,message_id)
def EditAccount(chat_id,message_id):
global step
app.edit_message_text(chat_id,message_id,"Edit Account",
reply_markup=markup([[button("Remove Account ❌",callback_data="RemoveAccount")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="ComebackSettings")]]))
step = 'None'
def RemoveAccount(chat_id,message_id,query):
global step
app.edit_message_text(chat_id,message_id,"Send Number")
step = "DeleteAccount"
def DeleteAccount(chat_id,message_id,text,message):
global step
try:
phone = (f"{text}",)
db = Account("Model.db")
db.create_table()
db.delete_account(phone)
db.close()
app.send_message(chat_id,f"The account with the number {text} was removed from the list of database accounts",parse_mode='html',
reply_to_message_id=message_id)
print(f"delete account {text}")
step = 'None'
except Exception as error:print(error)
def SettingAdd(chat_id,message_id):#SettingAdd
app.edit_message_text(chat_id,message_id,"SettingAdd",
reply_markup=markup([[button("Set Settings ?",callback_data="EditSettings"),button("Show Setting",callback_data="ShowSettings")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="ComebackSettings")]]))
def ShowSettings(chat_id,message_id,query):
db = SettingAddmember("Model.db")
db.create_table()
list_Settingss = db.get_list_Setting()
print(list_Settingss)
if len(list_Settingss) >= 1:
keyboard = [
[button("تعداد دعوت",callback_data="None"),button("استراحت اکانت ها ",callback_data="None")],
[button(f"{list_Settingss[0][2]} ممبر",callback_data="None"),button(f"روز {list_Settingss[0][1]}",callback_data="None")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="StartSet")]
]
app.edit_message_text(chat_id,message_id,"Settings\nSettings Add Member",reply_markup=markup(keyboard))
else:
query.answer(f"Not Settings")
StartSet(chat_id,message_id)
def EditSettings(chat_id,message_id):
global step
app.send_message(chat_id,"Send ActivityRange\nFor example: 1 or 2 or 3 or..",parse_mode='html',reply_markup=reply(selective=True))
step = "GetActivityRange"
def GetActivityRange(chat_id,message_id,text,message):
try:
if len(text) == 5 and text[2] == ':':
global step
app.send_message(chat_id,"Send AddRange\nFor example: 10 or 20 or 30 or..",parse_mode='html',reply_markup=reply(selective=True))
step = f"GetAddRange{text}"
elif text.isdigit():
step = f"GetAddRange{text}"
app.send_message(chat_id,"Send AddRange\nFor example: 10 or 20 or 30 or..",reply_markup=reply(selective=True))
else:
app.send_message(chat_id,"Please send correctly",parse_mode='html',reply_to_message_id=message_id)
except Exception as error:print(error)
def GetAddRange(chat_id,message_id,text,message):
global step
db = SettingAddmember("Model.db")
db.create_table()
list_setting = db.get_list_Setting()
if len(list_setting) < 1:
InsertData = (1,f"{step[11:]}",f"{text}")
db.insert_data(InsertData)
step = 'None'
app.send_message(chat_id,f"✅ Your settings have been applied",parse_mode='html',reply_to_message_id=message_id)
print(f"Add settings recorded")
elif len(list_setting) >=1:
UpdateData = (f"{step[11:]}",f"{text}")
db.update_data(UpdateData)
step = 'None'
app.send_message(chat_id,f"✅ Your settings have been applied",reply_to_message_id=message_id)
print(f"Add settings updated")
#/-----------------------------------------------------------------------------------------------------------
#Statistics--------------------------------------------------------------------------------------------------
def Statistics(chat_id,message_id):
global step
if step == "reStatistics":
app.delete_messages(chat_id,message_id)
app.send_message(chat_id,"Activity statistics and accounts",
reply_markup=markup([[button("Activity",callback_data="Activity"),button("Accounts",callback_data="Accounts")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu")]]))
else:
app.edit_message_text(chat_id,message_id,"Activity statistics and accounts",
reply_markup=markup([[button("Activity",callback_data="Activity"),button("Accounts",callback_data="Accounts"),button("IDeas",callback_data="IDeas")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu")]]))
def Accounts(chat_id,message_id,query):
global step
db = Account("Model.db")
db.create_table()
list_phone = db.get_list_phone()
len_phone = len(list_phone)
list_healthy_account = db.get_list_healthy_account()
len_healthy = len(list_healthy_account)
list_Temporary_report = db.get_list_Temporary_report()
len_Temporary = len(list_Temporary_report)
list_Permanent_report = db.get_list_Permanent_report()
len_Permanent = len(list_Permanent_report)
list_Deleted = db.get_list_deleted_account()
len_delete = len(list_Deleted)
list_phone_Activity = db.get_list_phone_Activity()
db.close()
list_accounts_add = list()
stdelta = None
setting = None
db = SettingAddmember("Model.db")
db.create_table()
get_list_Setting = db.get_list_Setting()
#check len settings addmember
if len(get_list_Setting) < 1:
print(f"no set setting {len(get_list_Setting)} ")
query.answer(f"❌ Not Set Settings")
else:
print(f"len setting {len(get_list_Setting)}")
setting = get_list_Setting[0][1]
#accounts Activity
ac = 0
for Activity in list_phone_Activity:
lastActivity = str(Activity[1]) + ' ' + str(Activity[2])
date = DateTime().d
time = DateTime().t
TimeNow = str(date) + ' ' + str(time)
FMT = '%d-%m-%Y %H:%M:%S'
tdeltaa = datetime.strptime(TimeNow, FMT) - datetime.strptime(lastActivity, FMT)
stdelta= str(tdeltaa)
print(stdelta)
if re.search(r'(\d.*).day',stdelta):
bet = re.findall(r'(\d.*).day',stdelta)
print(f"bet: {bet}\n setting:{setting}")
if bet[0] >= setting:
ac += 1
list_accounts_add.append(Activity[0])
else:
print('not account')
else:
list_accounts_add.append(Activity[0])
len_list_accounts_add = len(list_accounts_add)
if len_phone > 0:
keyboard = [
[button("اکانت های سالم",callback_data="None"),button("اکانت ها",callback_data="None")],
[button(f"{len_healthy}",callback_data="None"),button(f"{len_phone}",callback_data="None")],
[button("ریپورت های دائمی",callback_data="None"),button("ریپورت موقت",callback_data="None")],
[button(f"{len_Permanent}",callback_data="None"),button(f"{len_Temporary}",callback_data="None")],
[button("حذف شده",callback_data="None"),button('اکانت های قابل استفاده',callback_data="None")],
[button(f"{len_delete}",callback_data="None"),button(f"{ac}",callback_data="None")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="StartStat")]
]
app.edit_message_text(chat_id,message_id,"Statistics\nStatistics Accounts",reply_markup=markup(keyboard))
else:
step ="reStatistics"
query.answer(f"❌ Not Account")
Statistics(chat_id,message_id)
def Activityy(chat_id,message_id,query):
global step
db = AddStatistics("Model.db")
db.create_table()
list_activity = db.get_list_Statistics()
db.close()
if len(list_activity) > 0:
keyboard = [
[button("درصد دعوت های موفق",callback_data="None"),button("دعوت ها",callback_data="None")],
[button(f"0",callback_data="None"),button(f"{list_activity[0][5]}",callback_data="None")],
[button("درخواست ها",callback_data="None"),button("دعوت های امروز",callback_data="None")],
[button(f"{list_activity[0][4]}",callback_data="None"),button(f"{list_activity[0][3]}",callback_data="None")],
[button("اخرین فعالیت",callback_data="None"),button("اخرین دعوت",callback_data="None")],
[button(f"{list_activity[0][2]}",callback_data="None"),button(f"{list_activity[0][1]}",callback_data="None")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="StartStat")]
]
app.edit_message_text(chat_id,message_id,"Statistics\nStatistics Activity",reply_markup=markup(keyboard))
else:
step ="reStatistics"
query.answer(f"Not Activity")
Statistics(chat_id,message_id)
def IDeas(chat_id,message_id):
global step
db = Username("Model.db")
db.create_table()
list_username = db.get_list_username()
db.close()
if len(list_username) > 0:
keyboard = [
[button("آیدی ها",callback_data="None")],
[button(f"{len(list_username)}",callback_data="None")],
[button("Comeback To Menu ? ",callback_data="ComebackToMenu"),button("Comeback ?",callback_data="StartStat")]
]
app.edit_message_text(chat_id,message_id,"Statistics\nStatistics Activity",reply_markup=markup(keyboard))
else:
step ="reStatistics"
query.answer(f"Not id")
Statistics(chat_id,message_id)
#/------------------------------------------------------------------------------------------------------------
#Update Account Reports---------------------------------------------------------------------------------------
def StartUAR(chat_id,message_id):
db = Account("Model.db")
db.create_table()
list_Account = db.get_list_phone()
Message=app.send_message(chat_id,"Start Updating Account Reports")
l = len(list_Account)
c = 0
if len(list_Account) > 0:
for account in list_Account:
c+=1
sleep(3)
threading.Thread(target=SpamBot, args = [chat_id,message_id,account,c]).start()
else:
app.send_message(chat_id,"To update the report status of accounts ... I do not see any accounts",parse_mode='html',reply_to_message_id=message_id)
db.close()
#/------------------------------------------------------------------------------------------------------------
#Add Member---------------------------------------------------------------------------------------------------
def StartAdd(chat_id,message_id,query):
global step
db = Groups("Model.db")
db.create_table()
listgroups = db.get_list_groups()
db.close()
db = SettingAddmember("Model.db")
db.create_table()
listsettings = db.get_list_Setting()
db.close()
lenG = len(listgroups)
lenS = len(listsettings)
text1 = f"\
Add Member\n\n\
In which group do you want to join?\n\n\
Click on the Group name \n\
If the group name is not in the list, Add the group name to your groups"
text2 = f"The list of groups is empty and no settings have been set\n\
? Register your group\n\
? Save the relevant invitation settings"
text3 = f"Settings not set\n\
? Save the relevant invitation settings"
text4 = f"The list of groups is empty\n\
? Register your group"
if lenG > 0 and lenS > 0:
other = [[button("other groups",callback_data="OtherGroups")]]
keyboard = [button(f"{group[0]}",callback_data= f"ad{group[1]}") for group in listgroups]
key = iter(keyboard)
Output = [list(islice(key,elem))for elem in[2 for n in range(len(keyboard))]]
app.edit_message_text(chat_id,message_id,text1,
parse_mode="html",reply_markup=markup(Output))
elif lenG < 1 and lenS < 1:
app.edit_message_text(chat_id,message_id,text2,parse_mode='html')
elif lenG > 0 and lenS < 1:
app.edit_message_text(chat_id,message_id,text3,parse_mode='html')
elif lenG < 1 and lenS > 0:
app.edit_message_text(chat_id,message_id,text4,parse_mode='html')
step = 'None'
def AddToGroups(chat_id,message_id,query,data):
global step
app.edit_message_text(chat_id,message_id,f" How Many Accounts Do You want to work with? \nFor example: 6 ",parse_mode="html")
step = f"GettActivityNumber{data}"
def GettActivityNumber(chat_id,message_id,text,message):
global step
UG = step[20:] #username Group
update = (f"{str(UG)}",)
db = Groups("Model.db")
db.create_table()
usergroup = db.get_list_username_groups(update)
AN = text
step ='None'
GeActivityAccounts(chat_id,message_id,usergroup,AN)
def GeActivityAccounts(chat_id,message_id,usergroup,AN):
db = Account("Model.db")
db.create_table()
list_phone_Activity = db.get_list_phone_Activity()
list_accounts_add = list()
for Activity in list_phone_Activity:
db = SettingAddmember("Model.db")
db.create_table()
get_list_Setting = db.get_list_Setting()
try:
setting = get_list_Setting[0][1]
except:pass
lastActivity = str(Activity[1]) + ' ' + str(Activity[2])
date = DateTime().d
time = DateTime().t
TimeNow = str(date) + ' ' + str(time)
FMT = '%d-%m-%Y %H:%M:%S'
tdeltaa = datetime.strptime(TimeNow, FMT) - datetime.strptime(lastActivity, FMT)
if re.search(r'(\d.*).day',str(tdeltaa)):
bet = re.findall(r'(\d.*).day',str(tdeltaa))
if bet[0] >= setting:
list_accounts_add.append(Activity[0])
else:
print('not account')
else:
pass
if len(list_accounts_add) >= int(AN):
list_Account = list_accounts_add[:int(AN)]
print(len(list_Account))
ForAddChatMember(chat_id,message_id,list_Account,usergroup)
else:
MessageThree(chat_id,message_id)
def ForAddChatMember(chat_id,message_id,list_Account,usergroup):
for account in list_Account:
print(f"Start Add -> [{account}]")
sleep(30)
threading.Thread(target=AddMemberToGroup, args = [account,usergroup,chat_id,message_id]).start()
def AddMemberToGroup(account,usergroup,chat_id,message_id):
db = SettingAddmember("Model.db")
db.create_table()
list_setting = db.get_list_Setting()
db.close()
db = Username("Model.db")
db.create_table()
list_username = db.get_list_username()
list_user = [x for x in list_username]
activity = int(list_setting[0][2])
today_send_success = 0
today_send_unsuccess = 0
F = 0
list_group_username = list()
try:
api_id, api_hash = 2624818, "9d6e5f2365a2a9867d219e869f3e3656" #api_id,"api_hash"
app = Client(f'sessions/phone{account}',api_id,api_hash)
app.start()
if len(list_user) <= 1:
MessageTwo(chat_id,message_id)
else:
try:
app.join_chat(usergroup[0])
except Exception as error:
print(f"[{account}]\tWhen Join Chat: {error}")
try:
for member in app.iter_chat_members(usergroup[0]):
if member.user.username != None and member.user.is_self != True and member.user.is_bot != True:
list_group_username.append(member.user.username)
else:pass
except Exception as error:print(error)
while today_send_success != activity:
user_id = choice(db.get_list_username())
time.sleep(5)
try:
if user_id not in list_group_username:
app.add_chat_members(usergroup[0],user_id )
else:pass
except errors.Forbidden as error:
deleteusername = (f"{user_id}",)
db.delete_username(deleteusername)
print(f"Error [{account}] {error}")
today_send_unsuccess += 1
continue
except errors.PeerFlood as error:
today_send_unsuccess += 1
F += 1
print(f"Error ({F}) [{account}] {error}")
if F == 3:
print(f"Add [{account}] Completed.Due to Limitation")
break
else:pass
except errors.FloodWait as error:
print(f"Error [{account}] {error}")
today_send_unsuccess += 1
FW +=1
if FW == 3:
break
else:pass
except errors.BadRequest as error:
print(f"Error [{account}] {error}")
except Exception as error:
print(f"Error Exception [{account}] {error}")
today_send_unsuccess += 1
else:
deleteusername = (f"{user_id}",)
db.delete_username(deleteusername)
today_send_success += 1
print(f"[{account}]\tsucessfull: {today_send_success}")
MessageAddMember(chat_id,message_id,today_send_success,today_send_unsuccess,account)
except errors.SessionRevoked as error:
print(f"Error 1 {error} Phone: {account}")
DeleteSessionRevoked(chat_id,message_id,account)
except errors.UserDeactivated as error:
print(f"Error 2 {error} Phone: {account}")
UpdateDeleteAccount(chat_id,message_id,account)
except errors.AuthKeyUnregistered as error:
print(f"Error 3 {error} Phone: {account}")
DeleteSessionRevoked(chat_id,message_id,account)
except Exception as error:
print(f"Error 4 {error} Phone: {account}")
def DeleteSessionRevoked(chat_id,message_id,account):
db = Account("Model.db")
db.create_table()
db.delete_account((account,))
db.close()
app.send_message(chat_id,f"This account[{account}] can not be activated due to logout.\n\
Deleted from the database. Please re-enter this number in the bot"
,parse_mode="html")
def UpdateDeleteAccount(chat_id,message_id,account):
db = Account("Model.db")
db.create_table()
db.update_delete(("True",account))
db.close()
app.send_message(chat_id,f"This account[{account}] was deleted by Telegram",parse_mode="html")
def MessageAddMember(chat_id,message_id,today_send_success,today_send_unsuccess,account):
app.send_message(chat_id,f"Account{account} did {today_send_success} successful and {today_send_unsuccess} unsuccessful",parse_mode="html")
SaveAddsAccount(chat_id,message_id,today_send_success,today_send_unsuccess,account)
def SaveAddsAccount (chat_id,message_id,today_send_success,today_send_unsuccess,account):
db = Account("Model.db")
db.create_table()
aaccount = (f"{account}",)
list_Addaccount = db.get_SuccessfulAdds_UnSuccessfulAdds_Adds(aaccount)
date = DateTime().d
time = DateTime().t
LastAdd,LastActivity = date,time
SuccessfulAdds = int(list_Addaccount[0][0])+today_send_success
UnSuccessfulAdds = int(list_Addaccount[0][1])+today_send_unsuccess
Adds = int(list_Addaccount[0][2])+today_send_success
db.close()
try:
db = Account("Model.db")
AllData = (f"{LastAdd}",f"{LastActivity}",f"{SuccessfulAdds}",f"{UnSuccessfulAdds}",f"{Adds}",account)
db.update_account(AllData)
db.close()
print(f"SaveAddsAccount -> ({account})")
SaveAddStatistics(chat_id,message_id,today_send_success,today_send_unsuccess,account,date,time)
except Exception as error:
print(f"Error:{error}")
def SaveAddStatistics(chat_id,message_id,today_send_success,today_send_unsuccess,account,date,time):
db = AddStatistics("Model.db")
db.create_table()
list_AddStatistics = db.get_list_Statistics()
if len(list_AddStatistics) < 1:
LastAdd, LastActivity = date,time
RequestedAdditions = 1
Adds = today_send_success
AddToday = today_send_success
PercentAddsSuccessful = (today_send_success * 100 ) / 10
try:
AllData = (f"{PercentAddsSuccessful}", f"{LastAdd}", f"{LastActivity}", f"{AddToday}", f"{RequestedAdditions}", f"{Adds}")
db.insert_data(AllData)
db.close()
print("insert SaveAddStatistics")
except Exception as error:
print(f"Error:{error}")
elif len(list_AddStatistics) >= 1:
LastAdd, LastActivity = date,time
Last_timeAdd_dateAdd = db.get_list_Statistics()
lastActivity = str(Last_timeAdd_dateAdd[0][1]) + ' ' + str(Last_timeAdd_dateAdd[0][2])
TimeNow = str(date) + ' ' + str(time)
FMT = '%d-%m-%Y %H:%M:%S'
tdeltaa = datetime.strptime(TimeNow, FMT) - datetime.strptime(lastActivity, FMT)
if re.search(r'(\d).day',str(tdeltaa)):
bet = re.findall(r'(\d).day',str(tdeltaa))
if int(bet[0]) >= 1:
AddToday = today_send_success
else:
print(f"else:{bet[0]}")
else:
AddToday = int(list_AddStatistics[0][3])+ today_send_success
RequestedAdditions = int(list_AddStatistics[0][4]) + 1
Adds = int(list_AddStatistics[0][5])+ today_send_success
PercentAddsSuccessful = (today_send_success * 100 ) / 10
try:
AllData = (f"{PercentAddsSuccessful}", f"{LastAdd}", f"{LastActivity}", f"{AddToday}", f"{RequestedAdditions}", f"{Adds}",account)
db.update_data(AllData)
print(f"Update SaveAddStatistics -> ({account})")
db.close()
except Exception as error:
print(f"Error:{error}")
#/-------------------------------------------------------------------------------------------------------------
app.start()
print("runing..")
idle()
app.stop()