def main():
""" Пример использования longpoll
https://vk.com/dev/using_longpoll
https://vk.com/dev/using_longpoll_2
"""
login, password = '******', 'mypassword'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth(token_only=True)
except vk_api.AuthError as error_msg:
print(error_msg)
return
longpoll = VkLongPoll(vk_session)
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW:
print('Новое сообщение:')
if event.from_me:
print('От меня для: ', end='')
elif event.to_me:
print('Для меня от: ', end='')
if event.from_user:
print(event.user_id)
elif event.from_chat:
print(event.user_id, 'в беседе', event.chat_id)
elif event.from_group:
print('группы', event.group_id)
print('Текст: ', event.text)
print()
elif event.type == VkEventType.USER_TYPING:
print('Печатает ', end='')
if event.from_user:
print(event.user_id)
elif event.from_group:
print('администратор группы', event.group_id)
elif event.type == VkEventType.USER_TYPING_IN_CHAT:
print('Печатает ', event.user_id, 'в беседе', event.chat_id)
elif event.type == VkEventType.USER_ONLINE:
print('Пользователь', event.user_id, 'онлайн', event.platform)
elif event.type == VkEventType.USER_OFFLINE:
print('Пользователь', event.user_id, 'оффлайн', event.offline_type)
else:
print(event.type, event.raw[1:])
def main():
if DEBUG:
print("Start work!")
session = requests.Session()
# Авторизация пользователя:
"""
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
return
"""
# Авторизация группы:
# при передаче token вызывать vk_session.auth не нужно
"""
vk_session = vk_api.VkApi(token='токен с доступом к сообщениям и фото')
"""
vk_session = vk_api.VkApi(token=vk_token)
vk = vk_session.get_api()
longpoll = VkLongPoll(vk_session)
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me and event.text:
# Отправка в Slack чат (#vk) - должен быть заранее создан у вас в Slack
slack.chat.post_message('#vk', 'Новое сообщение: id{}: "{}"'.format(event.user_id, event.text))
if DEBUG:
print('id{}: "{}"'.format(event.user_id, event.text), end=' ')
# Ответ пользователю на сообщение в ВК.
vk.messages.send(
user_id=event.user_id,
message="Мы получили ваше сообщение. В ближайшее время мы ответим вам."
)
if DEBUG:
print('ok')
def bot_processing(self):
longpoll = VkLongPoll(self.vk_session)
while True:
try:
for event in longpoll.listen():
if hasattr(event, 'type'):
if event.type == VkEventType.MESSAGE_NEW:
self.parse_message(event)
print('Новое сообщение:')
if event.from_me:
print('От меня для: ', end='')
elif event.to_me:
print('Для меня от: ', end='')
if event.from_user:
print(event.user_id)
elif event.from_chat:
print(event.user_id, 'в беседе', event.chat_id)
elif event.from_group:
print('группы', event.group_id)
print('Текст: ', event.text)
elif event.type == VkEventType.USER_TYPING:
print('Печатает ', end='')
if event.from_user:
print(event.user_id)
elif event.from_group:
print('администратор группы', event.group_id)
elif event.type == VkEventType.USER_TYPING_IN_CHAT:
print('Печатает ', event.user_id, 'в беседе', event.chat_id)
elif event.type == VkEventType.USER_ONLINE:
print('Пользователь', event.user_id, 'онлайн', event.platform)
elif event.type == VkEventType.USER_OFFLINE:
print('Пользователь', event.user_id, 'оффлайн', event.offline_type)
else:
print(event.type, event.raw[1:])
except AttributeError:
print('Voice Record\n\n\n')
import vk_api
import requests
import datetime
vk_session = vk_api.VkApi(
token=
f3caee452f620cabce7d7cd684195e431c6463557dab3b284572ac4aface7331a6d7b049fe78dba961737
)
from vk_api.longpoll import VkLongPoll, VkEventType
longpoll = VkLongPoll(vk_session)
vk = vk_api.VkApi(token=token)
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me and event.text:
#Слушаем longpoll, если пришло сообщение то:
if event.text == 'Привет' or event.text == '5c59406c': #Если написали заданную фразу
if event.from_user: #Если написали в ЛС
vk.messages.send( #Отправляем сообщение
user_id=event.user_id,
message='5c59406c')
elif event.from_chat: #Если написали в Беседе
vk.messages.send( #Отправляем собщение
chat_id=event.chat_id,
message='5c59406c')
attachments = []
from vk_api import VkUpload
upload = VkUpload(vk_session)
image_url = 'Ссылка на картинку'
image = session.get(image_url, stream=True)
photo = upload.photo_messages(photos=image.raw)[0]
attachments.append('photo{}_{}'.format(photo['owner_id'], photo['id']))
def __init__(self, token):
self.token = token
self.vk = vk_api.VkApi(token=token)
self.longpoll = VkLongPoll(self.vk)
def polling(login, token):
contact = dbase.getClientContacts(login)
vk_session = vk_api.VkApi(token=token)
longpoll = VkLongPoll(vk_session)
vk = vk_session.get_api()
buffer[login] = {}
for event in longpoll.listen():
if (dbase.timeToStop(login)):
break
if event.to_me:
username = int(event.user_id)
try:
userinfo = dbase.getUserInfo(username, login)
print('OK')
except Exception as er:
print(er)
dbase.addNewUser(username=username, login=login)
userinfo = {
'resortsFordet': '0',
'tours': '0',
'lastIndex': '0',
'cashResult': 0,
'selectTour': '0',
'userSorts': '0',
'step': 'frstwaitrespons',
'botName': login,
'username': username,
'country': '0',
'resort': '0',
'fromcity': '0',
'date': '0',
'nit': 0,
'price': 0,
'adults': 0,
'children': 0,
'fromc': '0'
}
print(str(event.text) + ' ' + str(event.user_id))
updateMes(login=username, mes=event.text)
if username in buffer[login]:
try:
if buffer[login][username]['type'] == 'resorts':
userinfo['resortsFordet'] = buffer[login][username][
'arr']
print(userinfo['resortsFordet'])
except Exception:
if 'tours' in buffer[login][username]:
userinfo['tours'] = buffer[login][username]['tours']
userinfo['lastIndex'] = buffer[login][username][
'lastIndex']
if 'cashResult' in buffer[login][username]:
userinfo['cashResult'] = int(
buffer[login][username]['cashResult'])
if 'selectTour' in buffer[login][username]:
userinfo['selectTour'] = buffer[login][username][
'selectTour']
if 'userSorts' in buffer[login][username]:
userinfo['userSorts'] = buffer[login][username][
'userSorts']
result = tourBot.agregation(userinfo, login, {
'type': 'to_me',
'text': event.text
}, contact)
print(result['userNew']['step'], ' - result step')
if result['userNew']['step'] == 'fire':
sir_tour = searchTours(vk=vk,
user=result['userNew'],
botname=login)
sir_tour.start()
elif result['userNew']['step'] == 'fire2':
sir_tour = searchTours(vk=vk,
user=result['userNew'],
botname=login,
alter=True)
sir_tour.start()
else:
if len(result['buffer']) > 0:
buffer[login][username] = result['buffer'][0]
else:
if username in buffer[login]: del buffer[login][username]
for i in result['message']['attachment']:
if i['url'] != 'none':
savePhoto(i['url'])
up = PhotoUpVk(vk=vk)[0]
print('up - ', up)
vk.messages.send(message=i['text'],
attachment='photo' +
str(up['owner_id']) + '_' +
str(up['id']),
user_id=[username],
random_id=random.randint(0, 10000000))
else:
try:
vk.messages.send(
user_id=[username],
random_id=random.randint(0, 10000000),
domain='public' + dbase.getBotname(login),
message=i['text'])
except Exception as er:
print(er)
if 'lastIndex' in result['userNew']:
try:
buffer[login][username]['lastIndex'] = result[
'userNew']['lastIndex']
buffer[login][username]['tours'] = result['userNew'][
'tours']
except Exception:
buffer[login][username] = {}
buffer[login][username]['lastIndex'] = result[
'userNew']['lastIndex']
buffer[login][username]['tours'] = result['userNew'][
'tours']
try:
vk.messages.send(user_id=[username],
random_id=random.randint(0, 10000000),
domain='public' + login,
message=str(result['message']['text']))
except Exception:
print('er was result text = "' +
result['message']['text'] + '"')
dbase.fullUserUpdate(result['userNew'], username)
if username not in buffer[login]:
buffer[login][username] = {}
if 'tours' in result['userNew']:
buffer[login][username]['tours'] = result['userNew']['tours']
if 'selectTour' in result['userNew']:
buffer[login][username]['selectTour'] = result['userNew'][
'selectTour']
if 'userSorts' in result['userNew']:
try:
buffer[login][username]['userSorts'] = result['userNew'][
'userSorts']
except Exception:
buffer[login][username] = {}
buffer[login][username]['userSorts'] = result['userNew'][
'userSorts']
dbase.updateStep(step=result['userNew']['step'],
username=username,
botname=login)
print('respons succesfull')
def vk_bot():
asd = []
info = []
info2 = []
status = []
trigger = 0
clients = ['248950122', '58917585', '32298906', '168272786']
session = requests.Session()
vkSession = vk_api.VkApi(token=token1)
vk = vkSession.get_api()
longpoll = VkLongPoll(vkSession)
lists = []
for event in longpoll.listen():
info = []
info.clear()
time.sleep(600)
status = ParserPrint()
for stat in status:
if stat not in lists:
print(stat, " NOT in list")
info.append('Printer: ' + stat.get('Printer') + '\n Status: ' +
stat.get('Status') + '\n Error: ' +
stat.get('Error') + '\n Paper: ' +
stat.get('Paper'))
trigger = 1
if lists != status:
print("!=")
print_info(info)
lists = status
else:
print("list = status")
for stat in status:
info2.append('Printer: ' + stat.get('Printer') + '\n Status: ' +
stat.get('Status') + '\n Error: ' +
stat.get('Error') + '\n Paper: ' +
str(stat.get('Paper')))
for client in clients:
for inf in info:
vk.messages.send(
user_id=client, #event.user_id,#'248950122',
random_id=get_random_id(),
message=inf)
if trigger == 1:
vk.messages.send(user_id=client,
random_id=get_random_id(),
message='**********\n**********\n')
print(client)
trigger = 0
continue
if event.type == VkEventType.MESSAGE_NEW and event.to_me and event.text:
print('id{}: "{}"'.format(event.user_id, event.text), end=" ")
#status = ParserPrint()
for inf in info2:
vk.messages.send(
user_id=event.user_id, #'248950122', #event.user_id
random_id=get_random_id(),
message=inf)
vk.messages.send(user_id=event.user_id,
random_id=get_random_id(),
message="***********\n*******\n")
print('no result')
continue
import vk_api
from vk_api.utils import get_random_id
from Student import *
from vk_api.longpoll import VkLongPoll, VkEventType
from vk_api.keyboard import VkKeyboard, VkKeyboardColor
import main
import enum
from SQLiteManager import SQLiteManager
ADMIN_ID = 556317586
token = '4094458ea0a9ff184809db5a025ed12d4d68566661f0779c0852970d9789dc680c7878ffbbc0b1ec91b55'
vk_session = vk_api.VkApi(token=token)
longpoll = VkLongPoll(vk_session, wait=0)
vk = vk_session.get_api()
users = 'resources/users.txt'
Students = []
FEATURES = [
'СЕГОДНЯ', 'ЗАВТРА', 'НЕДЕЛЯ', *DAY_NUMBER, *SHORT_DAY_NUMBER,
'СМЕНИТЬ ГРУППУ', 'КОМАНДЫ', 'ДЕНЬ НЕДЕЛИ', 'ПОДПИСКИ', 'ЕЖЕНЕДЕЛЬНО',
'ЕЖЕПАРНО', 'ЕЖЕДНЕВНО', 'СМЕНИТЬ НЕДЕЛЮ'
]
RING_SCHEDULE = ['8:55', '10:35', '12:35', '14:15', '16:15', '17:55']
sql = SQLiteManager(file='scheduleBot.db')
start = VkKeyboard(one_time=False, inline=False)
start.add_button('Сегодня', color=VkKeyboardColor.PRIMARY)
start.add_button('Завтра', color=VkKeyboardColor.PRIMARY)
start.add_line()
start.add_button('Неделя', color=VkKeyboardColor.PRIMARY)
start.add_line()
start.add_button('День недели', color=VkKeyboardColor.SECONDARY)
)
bot = Bot(
"ab4145d1b0425733b338a2082ae05c1452c98a5d38a14a1100f239b07dc2249b6278d9b1e05d2679a4222"
)
group_id = '-195266217'
coin = VKCoin(key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19',
merchantId=192557599)
pay = VKCoin(key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19',
merchantId=192557599)
coin_sema = VKCoin(key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19',
merchantId=192557599)
merchant = vkcoin.VKCoin(
user_id=192557599,
key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19')
vk = vk_session.get_api()
longpoll_type = VkLongPoll(vk_session)
conn = sqlite3.connect(r"timer.db")
c = conn.cursor()
sqlite3.connect(":memory:", check_same_thread=False)
connt = sqlite3.connect(r"all_inf.db")
t = connt.cursor()
sqlite3.connect(":memory:", check_same_thread=False)
def winner(id, summ):
t.execute("SELECT balance FROM us WHERE id=%d" % (int(id)))
bal = int(t.fetchone()[0])
t.execute("UPDATE us SET balance=%d WHERE id=%d" %
(bal + int(summ), int(id)))
connt.commit()
def message_vk(mes):
token = "20df76bd47c10e08c770927485ec32df51c7d8833a9df961151e59e910abfce2dc3a277c063f19e8f2b1a"
vk_session = vk_api.VkApi(token=token)
longpoll = VkLongPoll(vk_session)
vk = vk_session.get_api()
vk.messages.send(user_id=307049558, message=mes, random_id = 0)
if test == 0:
os._exit(1)
my_thread = MyThread()
my_thread.start()
thread_sleep = MyThread_sleep()
thread_sleep.start()
while True:
if prov == 1:
with open("main/database/database_token.json", "r", encoding="utf-8") as file:
data = json.loads(file.read())
token = data['token']
vk = vk_api.VkApi(app_id=6146827, token=token)
longpoll = VkLongPoll(vk, wait=0)
from main.additions import bomb, friends_lp, online, ping_lp, profile, info_lp, sms
from main.templates import press_f_1, press_f_2, anim_templates, conv, xz, templates_lp, gb
try:
for event in longpoll.listen():
# Если пришло новое сообщение
if event.type == VkEventType.MESSAGE_NEW:
if event.from_me:
command = event.text
delay = 0
peer_id = event.peer_id
if run == False:
print("лп не запущен")
else:
def Start(self):
self.is_running = True
self.dop_thread.start()
if self.USE_LONGPOLL:
self.longpoll = VkLongPoll(self.vk_session)
self.loop_thread.start()
class Bot:
def __init__(self):
self.__schedule = Schedule()
self.__vk = vk_api.VkApi(token=token)
self.__vk_api = self.__vk.get_api()
self.__longpoll = VkLongPoll(self.__vk)
self.__database = Database()
self.__handler = Handler(self.__database, self.__schedule)
def start(self):
print("Bot started...")
for event in self.__longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.text and event.to_me:
uid = event.user_id
text = event.text
if log:
print('New message from {}, text = {}'.format(uid, text))
# Обработка запроса
res = self.__handler.handle(uid, text)
# Сообщение
if res.is_message():
self.send_message(uid, res.get_message())
# Клавиатура
elif res.get_keyboard() is not None:
self.send_keyboard(uid, res.get_message(),
res.get_keyboard())
# Картинка с заголовком
elif res.get_image() is not None and res.get_title(
) is not None:
self.send_title_image(uid, res.get_title(),
res.get_message(), res.get_image())
# Картинка
elif res.get_image() is not None:
self.send_image(uid, res.get_message(), res.get_image())
def send_message(self, user_id, message):
self.__vk_api.messages.send(user_id=user_id,
random_id=get_random_id(),
message=message)
def send_keyboard(self, user_id, message, keyboard):
self.__vk_api.messages.send(user_id=user_id,
random_id=get_random_id(),
keyboard=keyboard.get_keyboard(),
message=message)
def send_image(self, user_id, message, image):
attachments = self.upload_image(image)
self.__vk_api.messages.send(user_id=user_id,
random_id=get_random_id(),
attachment=','.join(attachments),
message=message)
def send_title_image(self, user_id, title, message, image):
self.send_image(user_id, title, image)
self.send_message(user_id, message)
def upload_image(self, image):
server = self.__vk.method("photos.getMessagesUploadServer")
post_req = requests.post(server["upload_url"],
files={
"photo": open(image, "rb")
}).json()
save = self.__vk.method(
"photos.saveMessagesPhoto", {
"photo": post_req["photo"],
"server": post_req["server"],
"hash": post_req["hash"]
})[0]
attachments = ["photo{}_{}".format(save["owner_id"], save["id"])]
return attachments
class Main(object):
def __init__(self):
self.CONFIG = confloader.VKFOConfig()
self.vk_session = vk_api.VkApi(login=self.CONFIG.VK_LOGIN, password=self.CONFIG.VK_PASSWORD)
self.vk_session.auth(token_only=True)
self.vkapi = self.vk_session.get_api()
self.VK_USER_IDS = []
self.DOP_USER_IDS = []
self.dop_thread = threading.Thread(target=self.UpdateDopUsers)
self.loop_thread = threading.Thread(target=self._loop)
self.USE_LONGPOLL = False
self.is_running = False
if self.CONFIG.PROMETHEUS_SEND:
self.pgt_sender = pgt.PushgatewaySender(self.CONFIG.PROMETHEUS_HOST)
if self.CONFIG.HAS_UPSER_FILE:
self.DOP_USER_IDS = fs_tools.GetIdList(self.CONFIG.USERS_FILE)
signal.signal(signal.SIGINT, self._handleExit)
signal.signal(signal.SIGTERM, self._handleExit)
def Start(self):
self.is_running = True
self.dop_thread.start()
if self.USE_LONGPOLL:
self.longpoll = VkLongPoll(self.vk_session)
self.loop_thread.start()
def Stop(self):
self.is_running = False
def Wait(self):
self.dop_thread.join()
if self.USE_LONGPOLL:
self.loop_thread.join()
def _loop(self):
conn = db.CreateDB('./sql/init.sql')
for event in self.longpoll.listen():
if not self.is_running:
break
tags = { 'user': event.user_id, 'full_name': event.full_name, 'platform': event.last_seen }
if event.type == VkEventType.USER_ONLINE:
db.InsertOnline(conn, event.user_id, event.timestamp)
self.pgt_sender.AddToPool(self.pgt_sender.GetMetricsStr('friends_online_stats', tags, '1'))
elif event.type == VkEventType.USER_OFFLINE:
db.InsertOffline(conn, event.user_id, event.timestamp, event.last_seen)
self.pgt_sender.AddToPool(self.pgt_sender.GetMetricsStr('friends_online_stats', tags, '0'))
if event.user_id not in self.VK_USER_IDS:
self.VK_USER_IDS.append(event.user_id)
db.AddNewUser(conn, event.user_id, event.full_name)
def UpdateDopUsers(self):
conn = db.CreateDB('./sql/init.sql')
while self.is_running:
dop_users = self.vkapi.users.get(user_uds=self.DOP_USER_IDS, fields=['online', 'last_seen'])
if not self.USE_LONGPOLL:
friends = self.vkapi.friends.get(fields=['online', 'last_seen'])['items']
dop_users = dop_users + friends
timestamp = self.GetUnixTimestamp()
for user in dop_users:
user_id = int(user['id'])
full_name = '{} {}'.format(user['first_name'], user['last_name'])
user_online = int(user['online'])
user_last_seen = -1
if 'last_seen' in user:
user_last_seen = int(user['last_seen']['platform'])
if not user_id in self.VK_USER_IDS:
self.VK_USER_IDS.append(user_id)
if not db.IsUserExists(conn, user_id):
db.AddNewUser(conn, user_id, full_name, False)
state = db.GetLastState(conn, user_id)
if state != None:
if self.CONFIG.PROMETHEUS_SEND:
tags = { 'user': user_id, 'full_name': full_name, 'platform': user_last_seen }
self.pgt_sender.AddToPool(self.pgt_sender.GetMetricsStr('friends_online_stats', tags, str(user_online)))
if int(state) == user_online:
continue
if user_online == 0:
db.InsertOffline(conn, user_id, timestamp, user_last_seen, False)
elif user_online == 1:
db.InsertOnline(conn, user_id, timestamp, False)
conn.commit()
if self.CONFIG.PROMETHEUS_SEND:
self.pgt_sender.SendFromPool()
self._waiter()
def _waiter(self):
UPD_SECONDS = 60
i = 0
while self.is_running and i < UPD_SECONDS:
i = i + 1
time.sleep(1)
def _updateDopUsers(self):
if self.CONFIG.HAS_UPSER_FILE:
fs_tools.GetIdList(self.CONFIG.USERS_FILE)
def GetUnixTimestamp(self):
return datetime.now().timestamp()
def _handleExit(self, sig, frame):
self.is_running = False
print('Stopping')
def main():
global connection_counter
connection_counter = connection_counter + 1
print(time.strftime("%H:%M:%S"),
'* Попытка подключения №{num}'.format(num=connection_counter))
try:
longpoll = VkLongPoll(vk_session)
print(time.strftime("%H:%M:%S"), "* Успешное подключение")
print(time.strftime("%H:%M:%S"), "* Бот запущен")
print('*' * 40)
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me and event.text:
#Слушаем longpoll, если пришло сообщение то:
if event.text == 'Когда вайп?': #Если написали заданную фразу
if event.from_user: #Если написали в ЛС
vk.messages.send( #Отправляем сообщение
user_id=event.user_id,
message='Вайп каждую пятницу в 10:00 по МСК.',
keyboard=keyboard.get_keyboard(),
random_id=0)
elif event.text == 'Промо': #Если написали заданную фразу
vk.messages.send( #Отправляем сообщение
user_id=event.user_id,
message=
'Промокод для новичков "new". Так же вы можете получить вознаграждения за проведенное время на сервере , используйте команду /case в игре . Важно! Сначала авторизируйтесь в магазине https://galakrond.playrust.ru/ перед тем как забрать вознаграждение.',
keyboard=keyboard.get_keyboard(),
random_id=0)
elif event.text == 'Бан\Разбан':
vk.messages.send( #Отправляем сообщение
user_id=event.user_id,
message=
'Все зявки на разбан рассматриваются в этом топике https://vk.com/topic-185597153_40565047. Перед тем как написать заявку, рекомендуем сначала ознакомиться с правилами сервера https://vk.com/topic-185597153_40516485.',
keyboard=keyboard.get_keyboard(),
random_id=0)
elif event.text == 'Команды':
vk.messages.send( #Отправляем сообщение
user_id=event.user_id,
message=
'С доступными командами чата можно ознакомиться тут https://vk.com/@galakrondproject-komandy',
keyboard=keyboard.get_keyboard(),
random_id=0)
elif event.text == 'Хочу стать модератором':
vk.messages.send( #Отправляем сообщение
user_id=event.user_id,
message=
'https://vk.com/@galakrondproject-nabor-moderacii',
keyboard=keyboard.get_keyboard(),
random_id=0)
elif event.text == 'Пиратка?':
vk.messages.send(
message='Нет, наш сервер для владельцев лицензии.',
user_id=event.user_id,
keyboard=keyboard.get_keyboard(),
random_id=0)
elif 'начать' in (event.text).lower() \
or 'начало' in (event.text).lower() \
or 'начинаем' in (event.text).lower()\
or 'start' in (event.text).lower():
vk.messages.send( # Отправляем сообщение
user_id=event.user_id,
message='Ок, начинаем!',
keyboard=keyboard.get_keyboard(),
random_id=0)
except Exception as ex:
print(time.strftime("%H:%M:%S"), "* Подключиться не удалось")
print(time.strftime("%H:%M:%S"), "* Причина:", ex)
finally:
print(time.strftime("%H:%M:%S"), "* Ждём 5 секунд")
time.sleep(5)
def __init__(self, token):
self.vk = vk_api.VkApi(token=token)
self.long_poll = VkLongPoll(self.vk)
self.user: models.VkUser = models.VkUser.objects.none()
self.next_step_users: {str: NextStep} = {}
class VkBot(ChatBotActions):
def __init__(self, token):
self.vk = vk_api.VkApi(token=token)
self.long_poll = VkLongPoll(self.vk)
self.user: models.VkUser = models.VkUser.objects.none()
self.next_step_users: {str: NextStep} = {}
def send_message(self, user_id: int, text, keyboard: VkKeyboard = None):
"""
Отправка сообщения пользователю.
:param user_id:
:param text:
:param keyboard:
:return:
"""
values = {
'user_id': user_id,
'message': text,
'random_id': random.randint(0, 2048)
}
if keyboard:
values['keyboard'] = keyboard.get_keyboard(),
self.vk.method('messages.send', values)
def polling(self):
"""
Получение обновлений от Вк.
:return:
"""
logger.info('Вк бот запущен...')
for event in self.long_poll.listen():
self.event_handling(event)
def infinity_polling(self):
"""
Получение обновлений от Вк без остановки.
:return:
"""
while True:
try:
self.polling()
except Exception as e:
time.sleep(1)
continue
def get_user(self, event) -> models.VkUser:
"""
Получение или создание пользователя из базы данных.
:param event:
:return:
"""
user = self.vk.method("users.get", {"user_ids": event.user_id})
fullname = user[0]['first_name'] + ' ' + user[0]['last_name']
try:
user_object = models.VkUser.objects.get(chat_id=event.user_id)
except models.VkUser.DoesNotExist:
user_object = models.VkUser.objects.create(chat_id=event.user_id,
name=fullname)
self.user = user_object
return self.user
def register_next_step_by_user_id(self, user_id, callback, *args,
**kwargs):
"""
Регистрация функции, которая обработает слдующий ивент по user_id.
:param user_id:
:param callback:
:param args:
:param kwargs:
:return:
"""
next_step = NextStep(callback, *args, **kwargs)
self.next_step_users[user_id] = next_step
def register_next_step(self, event, callback, *args, **kwargs):
"""
Регистрация функции, которая обработает слдующий ивент.
:param event:
:param callback:
:param args:
:param kwargs:
:return:
"""
user_id = event.user_id
self.register_next_step_by_user_id(user_id, callback, *args, **kwargs)
def processing_next_step(self, event):
"""
Обработка запланированных ивентов.
:param event:
:return:
"""
user_id = event.user_id
if self.next_step_users.get(user_id):
next_step = self.next_step_users[user_id]
del self.next_step_users[user_id]
next_step.callback(event, *next_step.args, **next_step.kwargs)
return True
def event_handling(self, event):
"""
Обработка событий бота.
:param event:
:return:
"""
if event.to_me:
self.get_user(event)
if self.processing_next_step(event):
return
elif event.type == VkEventType.MESSAGE_NEW:
self.message_processing(event)
def write_phone_number_step(self, event):
"""
Получение номера телефона пользователя.
:param event:
:return:
"""
if event.text.lower() == 'отмена':
text = 'Тогда в другой раз😊'
self.send_message(user_id=event.user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
return
text = 'Скоро мы с вами свяжемся😉\n' \
'Спасибо!'
phone_number = event.text
if is_valid_phone_number(phone_number):
# сохраняем номер телефона
self.user.phone_number = phone_number
self.user.save()
# создаем запрос обратной связи
core.RequestManager.create_request(
phone_number=phone_number, question=self.user.last_question)
self.send_message(user_id=event.user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
else:
self.send_message(
user_id=event.user_id,
text='Вы ввели некорректный номер телефона😨\n'
'Попробуйте ещё раз😌',
)
self.register_next_step(event, self.write_phone_number_step)
def ask_question_step(self, event):
"""
Получение вопроса пользователя для обратной связи.
:param event:
:return:
"""
if event.text.lower() == 'отмена':
text = 'Тогда в другой раз😊'
self.send_message(user_id=event.user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
return
elif not event.text:
self.send_message(user_id=event.user_id,
text='Я такое не понимаю😒\n'
'Попробуйте ещё раз😌',
keyboard=keyboards.get_cancel_keyboard())
self.register_next_step(event, self.ask_question_step)
return
# сохраняем вопрос
self.user.last_question = event.text
self.user.save()
text = 'Отлично!\n' \
'А теперь введите номер телефона'
self.send_message(user_id=event.user_id,
text=text,
keyboard=keyboards.get_cancel_keyboard())
self.register_next_step(event, self.write_phone_number_step)
def search_step(self, event):
event_text = event.text.lower()
if event_text == 'отмена':
text = 'Тогда в другой раз😊'
self.send_message(user_id=event.user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
return
questions = core.QuestionsManager.search(event_text)
if not questions:
core.RequestManager.create_question(question=event_text)
text = bot.get_not_found_answer()
self.send_message(
user_id=event.user_id,
text=text,
keyboard=keyboards.get_question_not_found_keyboard())
return
else:
text = 'Результат поиска😉'
self.send_message(user_id=event.user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
for question in questions:
text = f'❓Вопрос:\n' \
f'{question.question}\n\n' \
f'❗Ответ:\n' \
f'{question.answer}'
self.send_message(user_id=event.user_id, text=text)
def message_processing(self, event):
"""
Обработка текстовых сообщений.
:param event:
:return:
"""
categories_manager = core.CategoriesManager()
user_id = event.user_id
event_text = event.text
if event_text.lower() == 'начать':
text = self.get_start_message()
self.send_message(user_id=user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
elif event_text.lower() == 'описание':
text = self.get_about_message()
self.send_message(user_id=user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
elif event_text.lower() == 'помощь':
text = self.get_help_message()
self.send_message(user_id=user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
elif event_text == 'Основное меню':
text = 'Основное меню'
self.send_message(user_id=user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
elif event.text.lower() == 'отмена':
text = 'Тогда в другой раз😊'
self.send_message(user_id=event.user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
return
elif event_text == 'Заказать звонок':
text = 'Введите интересующий Вас вопрос'
self.send_message(user_id=user_id,
text=text,
keyboard=keyboards.get_cancel_keyboard())
self.register_next_step(event, self.ask_question_step)
elif 'Частые вопросы' in event_text:
categories = categories_manager.get_categories()
text = 'Категории'
self.send_message(
user_id=user_id,
text=text,
keyboard=keyboards.get_categories_keyboard(categories))
elif 'Поиск' in event_text:
text = 'Введите ваш вопрос'
self.send_message(user_id=user_id,
text=text,
keyboard=keyboards.get_cancel_keyboard())
self.register_next_step(event, self.search_step)
else:
if '« ' in event_text:
event_text = event_text[2:]
elif '<<' in event_text:
event_text = event_text[3:]
categories = categories_manager.get_categories(
parent_category_text=event_text)
if categories:
text = 'Категории'
self.send_message(
user_id=user_id,
text=text,
keyboard=keyboards.get_categories_keyboard(categories))
return
questions_manager = core.QuestionsManager()
questions = questions_manager.get_questions(
category_text=event_text)
if questions:
for question in questions:
text = f'❓Вопрос:\n' \
f'{question.question}\n\n' \
f'❗Ответ:\n' \
f'{question.answer}'
self.send_message(user_id=user_id, text=text)
return
else:
questions = core.QuestionsManager.search(event_text)
if not questions:
core.RequestManager.create_question(question=event_text)
text = bot.get_not_found_answer()
self.send_message(
user_id=event.user_id,
text=text,
keyboard=keyboards.get_question_not_found_keyboard())
return
else:
text = 'Результат поиска😉'
self.send_message(
user_id=event.user_id,
text=text,
keyboard=keyboards.get_main_menu_keyboard())
for question in questions:
text = f'❓Вопрос:\n' \
f'{question.question}\n\n' \
f'❗Ответ:\n' \
f'{question.answer}'
self.send_message(user_id=event.user_id, text=text)
return
def __init__(self, handler: AbsRequestHandler):
self.handler = handler
self.vk = vk_api.VkApi(token=API_KEY)
self.session = requests.Session()
self.longpoll = VkLongPoll(self.vk)
self.upload = vk_api.VkUpload(self.vk)
from old_version.defs.physics import *
from old_version.defs.literature import *
from old_version.defs.geometry import *
from old_version.defs.physics_2 import *
from old_version.defs.terms import *
from old_version.defs.memorize_terms import *
from old_version.defs.self_test_div import *
from old_version.defs.self_test_1 import *
from old_version.defs.self_test_2 import *
from old_version.defs.answer_self_test_1 import *
from old_version.defs.answer_self_test_2 import *
VK_TOKEN = 'a47436d8894f49e81a488838f5ad9d9e56718655410b974ded4d48739f1ac128e19e12209fd8fd1e47b9f'
API_KEY = 'e769f0fe046f901526994f29b5bc6f8e'
WEATHER_URL = 'https://api.openweathermap.org/data/2.5/weather'
vk_session = VkApi(token=VK_TOKEN)
longpoll = VkLongPoll(vk_session)
upload = VkUpload(vk_session)
userStates = {}
course = {}
term = {}
definition = {}
for event in longpoll.listen(): #слушаем собеседника
if event.type == VkEventType.MESSAGE_NEW and event.to_me:
if not (event.user_id in userStates):
userStates[event.user_id] = ['home', 'home']
request = event.text.lower(
) #пихаем ответ в переменную и отделываемся от регистра
from vk_api import VkUpload
import vk_api
token = "YOUR_TOKEN"
def write_msg(user_id, message, random_id):
vk.messages.send(
user_id=user_id,
random_id=0,
message=message,
)
def write_k_msg(user_id, message, random_id, keyboard):
vk.messages.send(user_id=user_id,
random_id=0,
message=message,
keyboard=keyboard)
def getrealuid(user_id):
res = vk.users.get(user_ids=user_id)
real_uid = res[0]['id']
return real_uid
vk_session = vk_api.VkApi(token=token)
vk = vk_session.get_api()
longpoll = VkLongPoll(vk_session, mode=2)
class BOT():
message_dict = {
'for_start':
'Я буду отправлять тебе фото людей, которые возможно заинтересуют тебя, а ты будешь отвечать мне, нравится тебе предложеный человек, или нет.\nЕсли ты готов, напиши мне в чате "start":)\nЕсли захочешь закончить диалог, напиши мне в чате "by"',
'input_age':
'Ведите возрастной промежуток для поиска в виде "[22-33]"',
'input_token': 'Ведите ваш токен в формате "token=XXXXXX...XXX":',
'start_search': 'Отлично! Для начала поиска введите "search":',
'for_one_VKPerson':
'Если вам нравится кондидат, введите "+", иначе введите "-":',
'send_set':
'Я нашла несколько хороших вариантов для тебя:)\nВведите "go" для продолжения',
'person_missed':
'Вы не сделали выбор:( \nНаверняка это нехороший человек! Отмеу его как неинтересного',
'person_interest_not': f'Пропускаем, не для нас :(',
'person_interest': f'Отличный выбор! Добавляем в рекомендации :)',
'all_person_is_viewed':
'Вау! Ты просмотрели всех возможных кондидатов!\n Заходи ко мне позже, и я поищу для тебя еще :)',
'search_started': 'Минутку, уже ищу...'
}
def stoped_chat(self, event):
self.write_msg(event.user_id, "Пока((")
print('Бот остановлен')
self.status_bot = 'stoped'
def __init__(self, AOuthData):
self.AOuthData = AOuthData
self.vk = vk_api.VkApi(token=self.AOuthData['m_token'])
self.longpoll = VkLongPoll(self.vk)
self.status_bot = 'started'
print('Бот запущен')
BASE.metadata.create_all(engine)
def write_msg(self, user_id, message, attachment=None, ranbom=None):
if attachment == None:
self.vk.method(
'messages.send', {
'user_id': user_id,
'message': message,
'random_id': random.randint(10**7, 10**8)
})
else:
self.vk.method(
'messages.send', {
'user_id': user_id,
'message': message,
'random_id': random.randint(10**7, 10**8),
"attachment": attachment
})
def send_set(self, event_user_id, person):
attachment = []
for photo in person.list_photos:
attachment.append(f'photo{photo.id}')
self.write_msg(event_user_id, '', ','.join(attachment))
self.write_msg(
event_user_id,
f'{person.first_name} {person.last_name} \n{self.message_dict["for_one_VKPerson"]}'
)
def chat(self):
for event in self.longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW:
if event.to_me:
request = event.text.replace(' ', '').lower()
if request == "by":
# self.stoped_chat(event)
self.write_msg(event.user_id, "Пока((")
# return self.status_bot
elif request == "hi":
self.write_msg(
event.user_id,
f"{self.message_dict['for_start']}, {event.user_id}"
)
# Я буду отправлять тебе фото людей, которые возможно заинтересуют тебя, а ты будешь отвечать мне,
# нравится тебе предложеный человек, или нет. Если ты готов, напиши мне в чате "Старт"
elif request == "start":
self.write_msg(event.user_id,
self.message_dict['input_token'])
# 'input_token': 'Ведите ваш токен в формате "token=XXXXXX...XXX":'}
elif request.find('token=') != -1:
self.token = request[6:]
self.write_msg(event.user_id,
self.message_dict['input_age'])
# 'input_age': 'Ведите возрастной промежуток для поиска в виде "[22-33]:"'
elif request.find('[') != -1 and request.find(
'-') != -1 and request.find(']') != -1:
char = request.find('-')
self.age_from = int(request[1:char])
self.age_to = int(request[char + 1:len(request) - 1])
self.write_msg(event.user_id,
self.message_dict['start_search'])
# 'start_search': 'Отлично! Для начала поиска введите "search"
elif request == "search":
self.user = mVK.User(event.user_id, self.token,
self.age_from, self.age_to)
result = self.user.get_infouser()
if result.error == 1:
self.write_msg(event.user_id, result.massage)
self.stoped_chat(event)
else:
self.write_msg(event.user_id,
self.message_dict['search_started'])
# 'search_started': 'Минутку, уже ищу...'
result = add_user_in_DataBase(self.user)
VKpersons = mVK.VKperson()
result = VKpersons.get_people(
self.user, 100, self.AOuthData, self.token)
if result.error == 1:
self.write_msg(event.user_id, result.massage)
self.stoped_chat(event)
else:
self.person_list_for_chat = []
for person in self.user.VKperson_list:
if DB_search_person(
self.user.id,
person).bool_result == 0:
photos = mVK.Photo()
result = photos.get_photoslink(
person, self.token)
self.person_list_for_chat.append(
person)
for elem in self.person_list_for_chat:
elem.FOR_MY_print_elem()
if len(self.person_list_for_chat) == 0:
self.write_msg(
event.user_id, self.
message_dict['all_person_is_viewed'])
# 'all_person_is_viewed': 'Вау! Ты просмотрели всех возможных кондидатов! Заходи ко мне позже, и я поищу для тебя еще :)'
self.stoped_chat(event)
else:
self.current_person_index = -1
self.write_msg(
event.user_id,
self.message_dict['send_set'])
elif request == "go":
self.current_person_index = self.current_person_index + 1
self.send_set(
event.user_id, self.person_list_for_chat[
self.current_person_index])
elif request == "+":
if self.current_person_index == len(
self.person_list_for_chat) - 1:
self.write_msg(
event.user_id,
self.message_dict['all_person_is_viewed'])
# 'all_person_is_viewed': 'Вау! Ты просмотрели всех возможных кондидатов! Заходи ко мне позже, и я поищу для тебя еще :)'
self.stoped_chat(event)
# self.status_bot = 'stoped'
else:
self.person_list_for_chat[
self.current_person_index].interest = True
DB_add_person(
self.user.id, self.person_list_for_chat[
self.current_person_index])
self.write_msg(
event.user_id,
self.message_dict['person_interest'])
# 'person_interest': f'Отличный выбор! Добавляем в рекомендации :)'
self.current_person_index = self.current_person_index + 1
self.send_set(
event.user_id, self.person_list_for_chat[
self.current_person_index])
elif request == "-":
if self.current_person_index == len(
self.person_list_for_chat) - 1:
self.write_msg(
event.user_id,
self.message_dict['all_person_is_viewed'])
# 'all_person_is_viewed': 'Вау! Ты просмотрели всех возможных кондидатов! Заходи ко мне позже, и я поищу для тебя еще :)'
self.stoped_chat(event)
# self.status_bot = 'stoped'
else:
self.person_list_for_chat[
self.current_person_index].interest = False
DB_add_person(
self.user.id, self.person_list_for_chat[
self.current_person_index])
self.write_msg(
event.user_id,
self.message_dict['person_interest_not'])
# 'person_interest_not': f'Пропускаем, не для нас :('
self.current_person_index = self.current_person_index + 1
self.send_set(
event.user_id, self.person_list_for_chat[
self.current_person_index])
else:
self.write_msg(
event.user_id,
"Я тебя не понимаю :(\n Попробуй, пожалуйта, еще раз"
)
class Bot:
def __init__(self, i):
self.reg = VkKeyboard(one_time=True)
self.reg.add_button('Зарегистрироваться',
color=VkKeyboardColor.POSITIVE)
self.main = VkKeyboard(one_time=True)
self.main.add_button("Профиль")
self.profile = VkKeyboard(one_time=True)
self.profile.add_button("Изменить логин")
self.profile.add_button("Изменить пароль")
self.profile.add_line()
self.profile.add_button("Назад", color=VkKeyboardColor.NEGATIVE)
self.token = i["token"]
self.group_id = i["group_id"]
self.key = i["key"]
self.server = i["server"]
self.ts = i["ts"]
self.vk_session = vk_api.VkApi(token=self.token)
self.longpoll = VkLongPoll(self.vk_session)
self.vk = self.vk_session.get_api()
def start_msg(self, peer):
x = User()
if x.getProfile(peer) == None:
keyboard = self.reg.get_keyboard()
else:
keyboard = self.main.get_keyboard()
self.vk.messages.send(user_id=peer,
random_id=get_random_id(),
keyboard=keyboard,
message="Привет, я бот Daruna, чем могу помочь?")
def send_msg(self, text, peer, key):
if key == "main":
key = self.main.get_keyboard()
elif key == "profile":
key = self.profile.get_keyboard()
else:
key = None
self.vk.messages.send(user_id=peer,
random_id=get_random_id(),
message=text,
keyboard=key)
def start(self):
user = User()
for event in self.longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me:
ltext = event.text
text = event.text.lower()
author = event.user_id
if text.lower() == "начать":
self.start_msg(author)
user.createProfile(author)
continue
act = user.getProfile(author)["act"]
if text == "зарегистрироваться":
if user.inDb(author):
self.send_msg("Вы уже зарегистрированны", author,
"main")
else:
self.send_msg("Введите логин для вашего аккаунта",
author, None)
user.getProfile(author)["act"] = "registr(login)"
else:
if act == "registr(login)":
if ltext in db.data["logins"]:
self.send_msg(
"Введённый вами логин уже используется, попробуйте другой",
author, None)
elif len(ltext) < 3:
self.send_msg(
"Введённый вами логин слишком короткий(необходимо хотя бы 3 символов),\
попробуйте другой", author, None)
elif len(ltext) >= 30:
self.send_msg(
"Введённый вами логин слишком длинный(необходимо не больше 30 символов),\
попробуйте другой", author, None)
else:
user.editProfile(author, "name", ltext)
db.data["logins"].append(ltext)
self.send_msg("Введите пароль для вашего аккаунта",
author, None)
user.getProfile(
author)["act"] = "registr(password)"
elif act == "registr(password)":
test = User.cheakPassword(ltext)
if test == -1:
self.send_msg(
"Введённый вами пароль слишком маленький(минимум 7 символов), попробуйте другой",
author, None)
elif test == -2:
self.send_msg(
"Введённый вами пароль не содержит заглавные буквы, попробуйте другой",
author, None)
elif test == -3:
self.send_msg(
"Введённый вами пароль не содержит строчные буквы, попробуйте другой",
author, None)
elif test == -4:
self.send_msg(
"Введённый вами пароль не содержит цифры, попробуйте другой",
author, None)
elif test == -5:
self.send_msg(
"Введённый вами пароль содержит пробелы, попробуйте другой",
author, None)
elif test == 1:
user.editProfile(author, "password", ltext)
self.send_msg("Регистрация завершена", author,
"main")
logs.newUser(author)
user.getProfile(author)["act"] = "main"
elif act == "cheangeLogin":
if ltext == user.getProfile(author)["name"]:
self.send_msg(
"Введенный вами логин совпадает со старым, придумаете другой",
author, None)
else:
old_login = user.getProfile(author)["name"]
self.send_msg("Логин изменён", author, "profile")
db.data["logins"].remove(old_login)
user.getProfile(author)["name"] = ltext
logs.cheangeLogin(
user.getProfile(author)["id"], old_login,
ltext)
user.getProfile(author)["act"] = "profile"
elif act == "cheangePassword":
if ltext == user.getProfile(author)["password"]:
self.send_msg(
"Введенный вами пароль совпадает со старым, придумаете другой",
author, None)
else:
old_pass = user.getProfile(author)["password"]
self.send_msg("Пароль изменён", author, "profile")
user.getProfile(author)["password"] = ltext
logs.cheangeLogin(
user.getProfile(author)["id"], old_pass, ltext)
user.getProfile(author)["act"] = "profile"
elif act == "getOldPassword":
if ltext != user.getProfile(author)["password"]:
self.send_msg(
"Введенный вами пароль не совпадает с нынешним, попробуйте ещё раз",
author, None)
else:
self.send_msg("Введите новый пароль", author, None)
user.getProfile(author)["act"] = "cheangePassword"
elif text == "профиль" and act == "main":
people = user.getProfile(author)
self.send_msg(
f"Ваш аккаунт:\nid - {people['id']}\nлогин - {people['name']}\
\nроль - {people['role']}", author, "profile")
user.getProfile(author)["act"] = "profile"
elif text == "изменить логин" and act == "profile":
self.send_msg("Введите новый логин", author, None)
user.getProfile(author)["act"] = "cheangeLogin"
elif text == "изменить пароль" and act == "profile":
self.send_msg(
"Чтобы установить новый пароль введите нынешний",
author, None)
user.getProfile(author)["act"] = "getOldPassword"
elif text == "назад" and act == "profile":
self.send_msg("Чем могу помочь?", author, "main")
user.getProfile(author)["act"] = "main"
else:
break
from vk_api.longpoll import VkLongPoll, VkEventType
import handler
import argparse
import sys
# API-key
# HERE SHOULD BE YOUR TOKEN!!!
token = ""
# authorization as community
vk = vk_api.VkApi(token=token)
# working with messages
longpoll = VkLongPoll(vk)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-w", "--weather", action="store_true", help="weather display function")
args = parser.parse_args()
arg_list = []
if args.weather:
arg_list.append("weather")
handler_object = handler.Handler(arg_list)
try:
for event in longpoll.listen():
# new message income
class Server:
def __init__(self, server_name: str = "Empty"):
self.server_name = server_name
global api_token
f = open("token.txt")
api_token = f.read()
self.vk = vk_api.VkApi(token=api_token)
self.long_poll = VkLongPoll(self.vk)
self.vk_api = self.vk.get_api()
def send_img(self, send_id):
"""
Отправка сообщения через метод messages.send
:param send_id: vk id пользователя, который получит сообщение
:param message: содержимое отправляемого письма
:return: None
"""
self.vk_api.messages.send(peer_id=send_id,
attachment="photo510166866_457241739",
random_id=123456 + random.randint(1, 27))
def send_msg(self, send_id, message):
"""
Отправка сообщения через метод messages.send
:param send_id: vk id пользователя, который получит сообщение
:param message: содержимое отправляемого письма
:return: None
"""
self.vk_api.messages.send(peer_id=send_id,
message=message,
random_id=123456 + random.randint(1, 27))
def send_chmok(self, send_id, message_id):
self.send_msg(send_id, "Чмок")
message_id = int(message_id)
message_id = message_id + 1
messages = [
" 😚 ❤ ᅠ ᅠ ᅠ ᅠ ᅠ ᅠ 😊 ",
" 😎 ᅠ ❤ ᅠ ᅠ ᅠ ᅠ ᅠ 😊 ",
" 😎 ᅠ ᅠ ❤ ᅠ ᅠ ᅠ ᅠ 😊 ",
" 😎 ᅠ ᅠ ᅠ ❤ ᅠ ᅠ ᅠ 😊 ",
" 😎 ᅠ ᅠ ᅠ ᅠ ❤ ᅠ ᅠ 😊 ",
" 😎 ᅠ ᅠ ᅠ ᅠ ᅠ ❤ ᅠ 😊 ",
" 😎 ᅠ ᅠ ᅠ ᅠ ᅠ ᅠ ❤ 😊 ",
" 😎 ᅠ ᅠ ᅠ ᅠ ᅠ ᅠ ᅠ 😍 "
]
for i in range(len(messages)):
time.sleep(1 + random.uniform(0.3, 0.9))
self.vk_api.messages.edit(peer_id=send_id,
message=messages[i],
message_id=message_id)
def start(self):
for event in self.long_poll.listen():
if str(event.type.MESSAGE_NEW) == "VkEventType.MESSAGE_NEW":
try:
master_key = self.vk_api.messages.getLongPollServer()
keygen = master_key["key"]
server = master_key["server"]
ts = master_key["ts"]
response = requests.get(
"https://{}?act=a_check&key={}&ts={}&wait=25&mode=2&version=3"
.format(server, keygen, ts)).text
response = json.loads(response)
#print("res " + response["updates"][0][6]["from"])
print(self.vk_api.users.get()[0])
print(response["updates"][0][6]["from"])
print(
int(self.vk_api.users.get()[0]["id"]) == int((
response["updates"][0][6]["from"])))
if ((response["updates"][0][5]).lower()
== "чмок".lower()) and (int(
self.vk_api.users.get()[0]["id"]) == int(
(response["updates"][0][6]["from"]))):
peer_id = response["updates"][0][3]
message_id = response["updates"][0][1]
self.send_chmok(peer_id, message_id)
except:
pass
history = vk.method('messages.getHistory', {
'count': 1,
'peer_id': peer_id,
'rev': 0
})
msg_id = history['items'][0]['from_id']
msg_text = history['items'][0]['text']
user_id = vk.method('users.get', {})
user_id = user_id[0]['id']
if msg_id == user_id:
return msg_text
else:
print("Отправленно не от Вас")
def command(text):
command = text
return command
with open("main/database/database_token.json", "r", encoding="utf-8") as file:
data = json.loads(file.read())
token = data['token']
# Авторизуемся как сообщество
vk = vk_api.VkApi(app_id=6146827, token=token)
# Работа с сообщениями
longpoll = VkLongPoll(vk, wait=0)
return ans
def send(id, msg, keyboard=None):
if keyboard:
vk.messages.send(peer_id=id,
random_id=get_random_id(),
message=msg,
keyboard=keyboard.get_keyboard())
else:
vk.messages.send(peer_id=id, random_id=get_random_id(), message=msg)
token = "f70b5c9412c788c2a0af2627559f8085ae4903c83bbdbbd3991458363ce4a77269266a1df62e6ba669e56"
vk_session = vk_api.VkApi(token=token)
longpoll = VkLongPoll(vk_session, mode=10)
vk = vk_session.get_api()
keyboard_start = VkKeyboard(one_time=False)
keyboard_start.add_button(label='Hey!', color=VkKeyboardColor.DEFAULT)
keyboard_choose = VkKeyboard(one_time=False)
keyboard_choose.add_button(label='Solving discriminant equation',
color=VkKeyboardColor.POSITIVE)
keyboard_choose.add_button(label='Weather forecast',
color=VkKeyboardColor.POSITIVE)
keyboard_choose.add_line()
keyboard_choose.add_button(label='exit', color=VkKeyboardColor.NEGATIVE)
my_id = 293865317
dima_id = 291326308
file.close()
return token
main_menu_keyb = VkKeyboard()
organizations_keyb = VkKeyboard()
support_keyb = VkKeyboard()
keyboard_create(main_menu_keyb, k_main_menu)
keyboard_create(organizations_keyb, k_organizations)
keyboard_create(support_keyb, k_support)
bot = vk_api.VkApi(token=get_token("Token.txt"))
longpolling = VkLongPoll(bot)
for event in longpolling.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me:
text_message = event.text.lower()
id_random = vk_api.utils.get_random_id()
if text_message in ["start", "начать", "главное меню"]:
bot.method('messages.send', {
'user_id': event.user_id,
'message': (message_mm if text_message == "главное меню" else message_welcome),
'keyboard': main_menu_keyb.get_keyboard(),
'random_id': id_random})
class Main(object):
def __init__(self, token):
vk = vk_api.VkApi(token=token)
self.longpoll = VkLongPoll(vk)
self.vk_api = vk.get_api()
print("Server started")
def send_msg(self, userId, message):
self.vk_api.messages.send(peer_id=userId,
random_id=get_random_id(),
message=message)
def send_msg_k(self, userId, keyboard, message):
self.vk_api.messages.send(peer_id=userId,
random_id=get_random_id(),
keyboard=keyboard.get_keyboard(),
message=message)
def mailing(self, z):
date = datetime.datetime.today() + datetime.timedelta(hours=3)
weekNum = date.isocalendar()[1] % 2
dayNum = date.weekday()
print(date)
if dayNum < 6:
file = open("id.txt", "r").read().split("\n")
for id in file:
if id != "":
if z == 0:
self.send_msg(id, Rasp.day(weekNum, dayNum))
elif '--' not in Rasp.shed[weekNum, dayNum, z]:
self.send_msg(id, Rasp.shed[weekNum, dayNum, z])
def timetable(self):
# время указано в UTC
schedule.every().day.at("06:00").do(self.mailing, 0)
schedule.every().day.at("06:25").do(self.mailing, 1)
schedule.every().day.at("08:15").do(self.mailing, 2)
schedule.every().day.at("10:05").do(self.mailing, 3)
schedule.every().day.at("12:15").do(self.mailing, 4)
schedule.every().day.at("14:10").do(self.mailing, 5)
while True:
schedule.run_pending()
time.sleep(55)
def waiting_msg(self):
try:
for event in self.longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW:
if event.to_me:
self.respond(event.user_id, str(event.text.lower()))
except Exception as e:
print(e)
self.waiting_msg()
def respond(self, user_id, msg):
date = datetime.datetime.today() + datetime.timedelta(hours=3)
print(
date.strftime("%d.%m.%Y.%H:%M:%S") +
f' New message from: {user_id}\nText: {msg}')
if msg == "начать" or msg == "start" or msg == "#":
self.send_msg_k(user_id, Keyboard.start(),
"Здравствуй, " + self.getUserName(user_id))
elif msg == "info":
self.send_msg(
user_id, "autor @shaidulllin\n" +
"# Проект был создан с целью напоминаия о предстоящих парах, подпишись на рассылку, чтобы быть в курсе\n"
+
"# Так же присутствует возможность узнавать расписание вручную, нажми на расписание\n"
+ "# Есть возможность узнавать информацию о преподователях\n" +
"# Возможности бота небольшие, но вы можете это исправить")
elif msg == "расписание" or msg == "<-":
self.send_msg_k(user_id, Keyboard.today(), "Расписание на...")
elif msg == "->":
self.send_msg_k(user_id, Keyboard.weekday(), "Какой день недели?")
elif msg == "подписаться на рассылку расписания":
if not str(user_id) in open('id.txt', 'r').read():
open('id.txt', 'a').write(str(user_id) + "\n")
self.send_msg(user_id, "Ты подписался на мою рассылку")
else:
self.send_msg(user_id, "Ты уже подписан на мою рассылку!")
elif msg == "отказаться от рассылки":
if str(user_id) in open('id.txt', 'r').read():
id = open('id.txt', 'r').readlines()
f = open('id.txt', 'w')
for line in id:
if line != str(user_id) + "\n":
f.write(line)
f.close()
self.send_msg(user_id, "Я убрал тебя из рассылки")
else:
self.send_msg(
user_id,
"Чтобы отказаться от рассылки, нужно сначала на нее подписаться, дубина"
)
elif msg in Rasp.dayWeek:
self.send_msg(user_id, Rasp.weekday(msg))
elif msg in "".join(Rasp.teachers).lower().split(" "):
self.send_msg(user_id, Rasp.teacher(msg))
elif msg == "преподаватели":
self.send_msg(
user_id,
"Напиши мне его фамилию или предмет, который он ведет")
elif msg == "show":
self.send_msg(user_id, open('id.txt', 'r').read())
elif msg == '0':
self.send_msg(user_id, date)
print("-------------------")
@staticmethod
def getUserName(user_id):
request = requests.get("https://vk.com/id" + str(user_id))
bs = bs4.BeautifulSoup(request.text, "html.parser")
result = ""
for i in list(bs.findAll("title")[0]):
if i != '<':
result += i
elif i == '>':
break
return result.split()[0]
game_over_keyboard.add_button('Выйти')
game_over_keyboard.add_line()
game_over_keyboard.add_button('Продолжить(просто введи число)')
donat_keyboard = VkKeyboard(one_time=True) #<1=====
donat_keyboard.add_button('Помолиться за автора')
donat_keyboard.add_line()
donat_keyboard.add_button('Купить автору шаурму')
donat_keyboard.add_line()
donat_keyboard.add_button('Оплатить хостинг бота')
donat_keyboard.add_line()
donat_keyboard.add_button('Я передумал')
send_message(76904317, "41")
gamers = {}
# Работа с сообщениями
longpoll = VkLongPoll(vk)
# Основной цикл
for event in longpoll.listen():
# Если пришло новое сообщение
if event.type == VkEventType.MESSAGE_NEW:
# Если оно имеет метку для меня( то есть бота)
if event.to_me:
text = event.text.lower()
user_id = event.user_id
print(text)
if user_id in gamers:
try:
otvet = int(text)
except:
if text == 'выйти':
del gamers[user_id]
def __init__(self, token):
vk = vk_api.VkApi(token=token)
self.longpoll = VkLongPoll(vk)
self.vk_api = vk.get_api()
print("Server started")
import requests
import pyautogui
import time
import os
import clipboard
import vk_api
import urllib.request
vk_session = vk_api.VkApi(
token=
'8c546de0819da95731ebe881113cc7d9f20f4acc1f7ce479ac79fca3638495e8aec5000693015ddd70035'
)
from vk_api.longpoll import VkLongPoll, VkEventType
from vk_api.utils import get_random_id
longpoll = VkLongPoll(vk_session)
vk = vk_session.get_api()
def copy(text):
command = 'echo | set /p nul=' + text.strip() + '| clip'
os.system(command)
def clicker(image):
time.sleep(2)
pyautogui.moveTo(664, 923)
pyautogui.click()
time.sleep(5)
pyautogui.moveTo(353, 48)
pyautogui.click()
password=redis_password,
charset=memcached_charset,
decode_responses=True,
)
redis_client.flushdb()
vk_session = vk_api.VkApi(token=vk_api_key)
vk_api = vk_session.get_api()
keyboard = VkKeyboard(one_time=True)
keyboard.add_button('Новый вопрос', color=VkKeyboardColor.POSITIVE)
keyboard.add_button('Сдаться', color=VkKeyboardColor.NEGATIVE)
keyboard.add_line()
keyboard.add_button('Мой счет', color=VkKeyboardColor.PRIMARY)
quiz = get_quiz_questions()
long_poll = VkLongPoll(vk_session, group_id=vk_group_id)
for event in long_poll.listen():
if not (event.type == VkEventType.MESSAGE_NEW and event.to_me):
continue
if event.text == 'Новый вопрос':
quiz_line, quiz_content = random.choice(list(quiz.items()))
redis_client.rpush(event.user_id, quiz_line, quiz_content[1]['q'],
quiz_content[1]['a'])
vk_api.messages.send(
user_id=event.user_id,
message=f'{quiz_content[0]}\n{quiz_content[1]["q"]}',
random_id=random.randint(1, 1000),
keyboard=keyboard.get_keyboard())
elif event.text == 'Сдаться':
if redis_client.llen(event.user_id) > 0:
answer = redis_client.lrange(event.user_id, -1, -1)[0]
})
greetings = [
'привет', 'здравствуй', 'ку', 'хелло', 'прив', 'начать', 'меню',
'доброе утро', 'добрый день', 'добрый вечер', 'здравствуйте', 'салют',
'здорово', 'приветствую'
]
bue = ['пока', 'досвидания', 'до свидания', 'до встречи', 'всего хорошего']
os = [
'обратная связь', 'связь со специалистом', 'свяжи со сппециалистом',
'связь', 'помощь'
]
session_api = vk_session.get_api()
longpoll = VkLongPoll(
vk_session, 200112664
) #Подключение к лонгпул серверу для прослушиания входящих сообщений
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me:
if event.text.lower() in greetings:
send_message(
event.user_id,
"Доброго времени суток! Я - Бот, и пока мало чего умею, поэтому свяжитесь со специалистом!"
)
elif event.text.lower() in bue:
send_message(event.user_id, "До свидания, я буду ждать Вас здесь.")
elif event.text.lower() in os:
send_message(event.user_id, 'Специалист скоро свяжется с Вами!')
send_message(529844902, 'Клиент ждёт Вас в чате.')
send_message(223182527, 'Клиент ждёт Вас в чате.')
send_message(391899173, 'Клиент ждёт Вас в чате.')
def main():
session = requests.Session()
# Авторизация пользователя:
"""
login, password = '******', 'mypassword'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth(token_only=True)
except vk_api.AuthError as error_msg:
print(error_msg)
return
"""
# Авторизация группы (для групп рекомендуется использовать VkBotLongPoll):
# при передаче token вызывать vk_session.auth не нужно
"""
vk_session = vk_api.VkApi(token='токен с доступом к сообщениям и фото')
"""
vk = vk_session.get_api()
upload = VkUpload(vk_session) # Для загрузки изображений
longpoll = VkLongPoll(vk_session)
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me and event.text:
print('id{}: "{}"'.format(event.user_id, event.text), end=' ')
response = session.get(
'http://api.duckduckgo.com/',
params={
'q': event.text,
'format': 'json'
}
).json()
text = response.get('AbstractText')
image_url = response.get('Image')
if not text:
vk.messages.send(
user_id=event.user_id,
random_id=get_random_id(),
message='No results'
)
print('no results')
continue
attachments = []
if image_url:
image = session.get(image_url, stream=True)
photo = upload.photo_messages(photos=image.raw)[0]
attachments.append(
'photo{}_{}'.format(photo['owner_id'], photo['id'])
)
vk.messages.send(
user_id=event.user_id,
attachment=','.join(attachments),
random_id=get_random_id(),
message=text
)
print('ok')
