pythonbot/dan63047VKbot.py

826 lines
38 KiB
Python
Raw Normal View History

2020-08-27 09:43:09 +00:00
"""Here you can found Bot class and Database worker class"""
2020-04-04 16:07:39 +00:00
import vk_api
import datetime
2020-04-11 14:40:25 +00:00
import time
2020-04-04 16:07:39 +00:00
import requests
2020-04-04 21:18:12 +00:00
import logging
2020-04-05 14:41:33 +00:00
import pyowm
2020-04-05 22:46:06 +00:00
import random
2020-04-07 16:00:49 +00:00
import json
2020-05-08 19:30:43 +00:00
import threading
import pymysql
2020-04-06 10:26:50 +00:00
import wikipediaapi as wiki
2020-07-01 15:09:54 +00:00
import config
2020-07-02 09:17:36 +00:00
from pymysql.cursors import DictCursor
from pyowm.utils.config import get_default_config
from collections import deque
2020-04-11 21:50:14 +00:00
from vk_api.bot_longpoll import VkBotLongPoll, VkBotEventType
2020-04-13 18:25:48 +00:00
root_logger = logging.getLogger()
2020-04-11 21:50:14 +00:00
root_logger.setLevel(logging.INFO)
try:
2020-06-08 18:52:51 +00:00
log_path = f'logs/bot_log{str(datetime.datetime.now())}.log'
handler = logging.FileHandler(log_path, 'w', 'utf-8')
except:
2020-06-08 18:52:51 +00:00
log_path = 'bot.log'
handler = logging.FileHandler(log_path, 'w', 'utf-8')
2020-06-10 17:42:30 +00:00
handler.setFormatter(logging.Formatter('%(message)s'))
2020-04-11 21:50:14 +00:00
root_logger.addHandler(handler)
debug_array = {'vk_warnings': 0, 'db_warnings': 0, 'bot_warnings': 0,
'logger_warnings': 0, 'start_time': 0, 'messages_get': 0, 'messages_answered': 0}
2020-04-27 11:48:20 +00:00
def log(warning, text):
if warning:
2020-06-10 17:42:30 +00:00
msg = "[" + str(datetime.datetime.now()) + "] [WARNING] " + text
logging.warning(msg)
print(msg)
2020-05-04 20:26:22 +00:00
debug_array['logger_warnings'] += 1
2020-04-27 11:48:20 +00:00
else:
2020-06-10 17:42:30 +00:00
msg = "[" + str(datetime.datetime.now()) + "] " + text
logging.info(msg)
print(msg)
2020-04-27 11:48:20 +00:00
2020-08-27 09:43:09 +00:00
bot = {}
errors_array = {"access": "Отказано в доступе",
"miss_argument": "Отсуствует аргумент", "command_off": "Команда отключена"}
2020-07-02 09:17:36 +00:00
try:
vk = vk_api.VkApi(token=config.vk_group_token)
longpoll = VkBotLongPoll(vk, config.group_id)
except Exception as e:
log(True, "Can't connect to longpull: "+str(e))
exit(log(False, "[SHUTDOWN]"))
try:
if(config.vk_service_token != None and config.album_for_command):
random_image_command = True
vk_mda = vk_api.VkApi(token=config.vk_service_token)
vk_mda.method('photos.get', {'owner_id': "-"+str(config.group_id),
'album_id': config.album_for_command, 'count': 1000})
2020-07-02 09:17:36 +00:00
if(config.album_for_command == None):
log(False, "Album id for !image is not setted, command will be turned off")
if(config.vk_service_token == None):
random_image_command = False
log(False, "Service token is 'None', !image command will be turned off")
except vk_api.ApiError:
random_image_command = False
log(True, "Invalid service token, !image command will be turned off")
except AttributeError:
random_image_command = False
log(True, "Service token or album id not found, !image command will be turned off")
try:
if(config.openweathermap_api_key != None):
owm_dict = get_default_config()
owm_dict['language'] = 'ru'
owm = pyowm.OWM(config.openweathermap_api_key, owm_dict)
mgr = owm.weather_manager()
mgr.weather_at_place("Минск")
weather_command = True
else:
log(False, "OpenWeatherMap API key is 'None', !weather command will be turned off")
weather_command = False
except AttributeError:
weather_command = False
log(True, "OpenWeatherMap API key not found, !image command will be turned off")
except Exception:
weather_command = False
log(True, "Invalid OpenWeatherMap API key, !weather command will be turned off")
2020-07-01 15:09:54 +00:00
class Database_worker():
def __init__(self):
2020-07-01 15:09:54 +00:00
if(config.use_database):
log(False, "Trying to connect to database")
try:
self._CON = pymysql.connect(
host=config.mysql_host,
user=config.mysql_user,
password=config.mysql_pass,
db=config.mysql_db,
2020-07-01 15:09:54 +00:00
charset='utf8mb4',
cursorclass=DictCursor
)
cur = self._CON.cursor()
except Exception as e:
debug_array['db_warnings'] += 1
log(True, f"Unable to connect to database: {str(e)}")
try:
cur.execute("SELECT * FROM bot_users")
except:
cur.execute("CREATE TABLE bot_users ( id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, chat_id INT UNSIGNED, awaiting VARCHAR(128), access TINYINT, midnight BOOL, new_post BOOL, admin_mode BOOL, game_wins INT UNSIGNED, game_defeats INT UNSIGNED, game_draws INT UNSIGNED)")
cur.close()
log(False, f"Database connection established")
2020-07-01 15:09:54 +00:00
else:
log(False, "Bot will use JSON file as database")
try:
with open("data.json", "r") as data:
self._DATA_DIST = json.load(data)
data.close()
except Exception:
log(True, "data.json is not exist, it will be created soon")
self._DATA_DIST = {"users": {}}
def set_new_user(self, peer_id, midnight=False, awaiting=None, access=1, new_post=False, admin_mode=False, game_wins=0, game_defeats=0, game_draws=0):
2020-07-01 15:09:54 +00:00
if(config.use_database):
try:
cur = self._CON.cursor()
cur.execute("INSERT INTO bot_users (chat_id, awaiting, access, midnight, new_post, admin_mode, game_wins, game_defeats, game_draws) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)",
(peer_id, awaiting, access, midnight, new_post, admin_mode, game_wins, game_defeats, game_draws))
2020-07-01 15:09:54 +00:00
self._CON.commit()
cur.close()
except Exception as e:
debug_array['db_warnings'] += 1
log(True, f"Unable to add new user in database: {str(e)}")
else:
self._DATA_DIST['users'][peer_id] = {"awaiting": awaiting, "access": access, "midnight": midnight, "new_post": new_post,
"admin_mode": admin_mode, "game_wins": game_wins, "game_defeats": game_defeats, "game_draws": game_draws}
2020-07-01 15:09:54 +00:00
open("data.json", "w").write(json.dumps(self._DATA_DIST))
def get_all_users(self):
2020-07-01 15:09:54 +00:00
if(config.use_database):
try:
cur = self._CON.cursor()
cur.execute("SELECT * FROM bot_users")
result = cur.fetchall()
cur.close()
return result
except Exception as e:
debug_array['db_warnings'] += 1
log(True, f"Unable to load user from database: {str(e)}")
else:
return self._DATA_DIST['users']
def get_from_users(self, from_id):
2020-07-01 15:09:54 +00:00
if(config.use_database):
try:
cur = self._CON.cursor()
cur.execute(
"SELECT * FROM bot_users WHERE chat_id = %s", (from_id))
2020-07-01 15:09:54 +00:00
result = cur.fetchall()
cur.close()
return result
except Exception as e:
debug_array['db_warnings'] += 1
log(True, f"Unable to load user from database: {str(e)}")
else:
return self._DATA_DIST['users'][str(from_id)]
2020-06-09 10:19:10 +00:00
def get_game_stat(self):
2020-07-01 15:09:54 +00:00
if(config.use_database):
try:
cur = self._CON.cursor()
cur.execute(
"SELECT chat_id, game_wins, game_draws, game_defeats FROM bot_users WHERE game_wins > 0 OR game_draws > 0 OR game_defeats > 0")
2020-07-01 15:09:54 +00:00
result = cur.fetchall()
cur.close()
return result
except Exception as e:
debug_array['db_warnings'] += 1
log(True, f"Unable to load stats from database: {str(e)}")
else:
return self._DATA_DIST['users']
# Info: dist cannot return only the necessary keys
def update_user(self, chat_id, thing, new_value):
2020-07-01 15:09:54 +00:00
if(config.use_database):
try:
cur = self._CON.cursor()
cur.execute(
f"UPDATE bot_users SET {thing} = %s WHERE bot_users.chat_id = %s;", (new_value, chat_id))
2020-07-01 15:09:54 +00:00
self._CON.commit()
cur.close()
except Exception as e:
debug_array['db_warnings'] += 1
log(True,
f"Unable to update info about user in database: {str(e)}")
2020-07-01 15:09:54 +00:00
else:
self._DATA_DIST['users'][str(chat_id)][thing] = new_value
open("data.json", "w").write(json.dumps(self._DATA_DIST))
def delete_user(self, chat_id):
2020-07-01 15:09:54 +00:00
if(config.use_database):
try:
cur = self._CON.cursor()
cur.execute(
"DELETE FROM bot_users, game_defeats WHERE chat_id = %s", (chat_id))
2020-07-01 15:09:54 +00:00
self._CON.commit()
cur.close()
return True
except Exception as e:
debug_array['db_warnings'] += 1
log(True, f"Unable to delete user from database: {str(e)}")
return False
else:
self._DATA_DIST['users'].pop(str(chat_id))
open("data.json", "w").write(json.dumps(self._DATA_DIST))
2020-07-01 15:09:54 +00:00
db = Database_worker()
def load_users():
try:
log(False, "Reading database")
get_info = db.get_all_users()
2020-07-01 15:09:54 +00:00
if(config.use_database):
for i in get_info:
bot[int(i['chat_id'])] = VkBot(int(i['chat_id']), bool(i['midnight']), i['awaiting'], int(
i['access']), bool(i['new_post']), bool(i['admin_mode']))
2020-07-01 15:09:54 +00:00
else:
for i in get_info:
bot[int(i)] = VkBot(int(i), bool(get_info[i]['midnight']), get_info[i]['awaiting'], int(
get_info[i]['access']), bool(get_info[i]['new_post']), bool(get_info[i]['admin_mode']))
except Exception as lol:
2020-06-09 10:19:10 +00:00
debug_array['bot_warnings'] += 1
log(True, f"Problem with creating objects: {str(lol)}")
2020-04-27 11:48:20 +00:00
2020-04-13 18:25:48 +00:00
def toFixed(numObj, digits=0):
return f"{numObj:.{digits}f}"
2020-04-11 21:50:14 +00:00
class MyVkLongPoll(VkBotLongPoll):
def listen(self):
while True:
2020-04-13 18:25:48 +00:00
try:
2020-04-11 21:50:14 +00:00
for event in self.check():
yield event
except Exception as e:
2020-05-24 11:57:02 +00:00
err = "A problem with VK LongPull: " + str(e)
2020-04-27 11:48:20 +00:00
log(True, err)
2020-05-04 20:26:22 +00:00
debug_array['vk_warnings'] += 1
2020-04-11 21:50:14 +00:00
time.sleep(15)
continue
2020-04-04 16:07:39 +00:00
def create_new_bot_object(chat_id):
bot[chat_id] = VkBot(chat_id)
db.set_new_user(chat_id)
2020-04-13 18:25:48 +00:00
2020-04-13 18:25:48 +00:00
def get_weather(place):
try:
2020-07-02 09:17:36 +00:00
weather_request = mgr.weather_at_place(place)
2020-07-01 15:09:54 +00:00
except Exception as i:
2020-05-24 11:57:02 +00:00
err = "A problem with OpenWeather API: " + str(i)
2020-04-27 11:48:20 +00:00
log(True, err)
2020-04-13 18:25:48 +00:00
return "Такого города нет, либо данных о погоде нет"
2020-07-01 15:09:54 +00:00
weather_status = weather_request.weather.detailed_status
weather_temp = weather_request.weather.temperature('celsius')
weather_humidity = weather_request.weather.humidity
weather_wing = weather_request.weather.wind()
return f"Погода в городе {place}<br> {str(round(weather_temp['temp']))}°C, {weather_status}<br>Влажность: {weather_humidity}%<br>Ветер: {weather_wing['speed']} м/с"
2020-04-13 18:25:48 +00:00
2020-04-03 21:18:34 +00:00
class VkBot:
2020-08-27 09:43:09 +00:00
"""Bot object, which can answer to user commands\n\n
Keyword arguments:\n
peer_id -- id of conversation with user for answering. Int\n
midnight -- flag of midnight function, which send every midnigtht a message. Defalt: False. Bool\n
awaiting -- strind, what show, which function awaiting input. Defalt: None. Str\n
access -- flag, what set access level to bot functions. Defalt: True. Bool\n
new_post -- flag of notificaton function about new post on group. Defalt: False. Bool\n
admin_mode -- flag of moderating function, which moderate conversation. Defalt: False. Bool
"""
def __init__(self, peer_id, midnight=False, awaiting=None, access=True, new_post=False, admin_mode=False):
"""Initialise the bot object\n\n
Keyword arguments:\n
peer_id -- id of conversation with user for answering. Int\n
midnight -- flag of midnight function, which send every midnigtht a message. Defalt: False. Bool\n
awaiting -- strind, what show, which function awaiting input. Defalt: None. Str\n
access -- flag, what set access level to bot functions. Defalt: True. Bool\n
new_post -- flag of notificaton function about new post on group. Defalt: False. Bool\n
admin_mode -- flag of moderating function, which moderate conversation. Defalt: False. Bool
"""
2020-05-24 11:57:02 +00:00
log(False, f"[BOT_{peer_id}] Created new bot-object")
2020-04-05 16:24:24 +00:00
self._CHAT_ID = peer_id
2020-05-21 19:52:49 +00:00
self._AWAITING_INPUT_MODE = awaiting
2020-08-27 09:43:09 +00:00
self._ACCESS_TO_ALL = access
2020-05-21 19:52:49 +00:00
self._SET_UP_REMINDER = {"task": None, "time": None}
2020-05-23 07:48:05 +00:00
self._MIDNIGHT_EVENT = midnight
self._NEW_POST = new_post
2020-05-31 12:25:53 +00:00
self._ADMIN_MODE = admin_mode
2020-04-03 19:56:57 +00:00
2020-07-01 15:09:54 +00:00
if int(self._CHAT_ID) == int(config.owner_id):
2020-05-04 20:26:22 +00:00
self._OWNER = True
else:
self._OWNER = False
2020-04-13 18:25:48 +00:00
self._COMMANDS = ["!image", "!my_id", "!h", "!user_id", "!group_id", "!help", "!weather", "!wiki", "!byn",
2020-05-31 12:25:53 +00:00
"!echo", "!game", "!debug", "!midnight", "!access", "!turnoff", "!reminder", "!subscribe", "!random", "!admin_mode"]
2020-05-16 19:09:52 +00:00
def __str__(self):
2020-08-27 09:43:09 +00:00
return f"[BOT_{str(self._CHAT_ID)}] a: {str(self._ACCESS_TO_ALL)}, mn: {str(self._MIDNIGHT_EVENT)}, await: {str(self._AWAITING_INPUT_MODE)}, sub: {str(self._NEW_POST)}, adm: {str(self._ADMIN_MODE)}"
2020-05-16 19:09:52 +00:00
def __del__(self):
2020-05-24 11:57:02 +00:00
log(False, f"[BOT_{str(self._CHAT_ID)}] Bot-object has been deleted")
2020-04-04 16:07:39 +00:00
2020-05-23 07:48:05 +00:00
def event(self, event, something=None):
2020-05-08 19:30:43 +00:00
if event == "midnight" and self._MIDNIGHT_EVENT:
current_time = datetime.datetime.fromtimestamp(time.time() + 10800)
2020-05-09 21:46:09 +00:00
midnight_text = ["Миднайт!", "Полночь!", "Midnight!",
"миднигхт", "Середина ночи", "Смена даты!", "00:00"]
2020-07-02 09:17:36 +00:00
if(random_image_command):
self.send(
f"{random.choice(midnight_text)}<br>Наступило {current_time.strftime('%d.%m.%Y')}<br>Картинка дня:", self.random_image())
2020-07-02 09:17:36 +00:00
else:
self.send(
f"{random.choice(midnight_text)}<br>Наступило {current_time.strftime('%d.%m.%Y')}")
2020-05-24 11:57:02 +00:00
log(False, f"[BOT_{self._CHAT_ID}] Notified about midnight")
2020-05-23 07:48:05 +00:00
elif event == "post" and self._NEW_POST:
post = f"wall{str(something['from_id'])}_{str(something['id'])}"
self.send(f"Вышел новый пост", post)
2020-05-24 11:57:02 +00:00
log(False, f"[BOT_{self._CHAT_ID}] Notified about new post")
2020-05-08 19:30:43 +00:00
2020-05-31 12:25:53 +00:00
def get_message(self, event):
message = event.message.text
user_id = event.message.from_id
if self._ADMIN_MODE:
2020-05-31 12:45:50 +00:00
if message.find("@all") != -1 or message.find("@online") != -1 or message.find("@here") != -1 or message.find("@everyone") != -1 or message.find("@здесь") != -1 or message.find("@все") != -1:
2020-06-09 19:50:37 +00:00
self.send(f"[@id{user_id}|Дебил]")
2020-05-31 12:25:53 +00:00
try:
2020-07-01 15:09:54 +00:00
if int(user_id) != int(config.owner_id):
vk.method("messages.removeChatUser", {"chat_id": int(
self._CHAT_ID)-2000000000, "member_id": user_id})
log(False,
f"[BOT_{self._CHAT_ID}] user id{user_id} has been kicked")
2020-05-31 12:25:53 +00:00
else:
log(False, f"[BOT_{self._CHAT_ID}] can't kick owner")
except Exception as e:
log(True,
f"[BOT_{self._CHAT_ID}] can't kick user id{user_id} - {str(e)}")
2020-07-01 15:09:54 +00:00
with open('bad_words.txt', 'r', encoding="utf-8", newline='') as filter:
2020-06-09 20:49:28 +00:00
flag = False
2020-07-01 15:09:54 +00:00
forcheck = message.lower()
2020-06-09 19:50:37 +00:00
for word in filter:
if flag:
2020-07-01 15:09:54 +00:00
if random.randint(0, 5) == 1:
2020-06-09 19:50:37 +00:00
self.send("За м*т извенись")
break
2020-07-01 15:09:54 +00:00
else:
if forcheck.find(word[:-1]) != -1:
flag = True
if event.message.action:
action = event.message.action
if action['type'] == 'chat_invite_user' or action['type'] == 'chat_invite_user_by_link':
user_info = vk.method('users.get', {'user_ids': action["member_id"], 'fields': 'verified,last_seen,sex'})
self.send(f'Добро пожаловать в беседу, {user_info[0]["first_name"]} {user_info[0]["last_name"]}')
elif action['type'] == 'chat_kick_user':
user_info = vk.method('users.get', {'user_ids': action["member_id"], 'fields': 'verified,last_seen,sex'})
self.send(f'{user_info[0]["first_name"]} {user_info[0]["last_name"]} покинул беседу')
2020-05-21 19:52:49 +00:00
if self._AWAITING_INPUT_MODE:
2020-05-20 16:36:28 +00:00
if message == "Назад":
2020-05-21 19:52:49 +00:00
self.change_await()
self.send("Отменено")
2020-05-20 16:36:28 +00:00
else:
2020-07-01 15:09:54 +00:00
if self._AWAITING_INPUT_MODE == "echo":
2020-05-21 19:52:49 +00:00
if message == "!echo off":
self.send("Эхо режим выключен")
self.change_await()
2020-05-24 11:57:02 +00:00
log(False, f"[BOT_{self._CHAT_ID}] Out from echo mode")
2020-05-21 19:52:49 +00:00
else:
self.send(message)
log(False,
f"[BOT_{self._CHAT_ID}] Answer in echo mode")
2020-04-12 09:47:30 +00:00
else:
2020-07-01 15:09:54 +00:00
if message.lower() == "бот дай денег":
self.send("Иди нахуй")
2020-05-08 19:30:43 +00:00
respond = {'attachment': None, 'text': None}
message = message.split(' ', 1)
if message[0] == self._COMMANDS[0]:
2020-07-02 09:17:36 +00:00
if(random_image_command):
2020-07-01 15:09:54 +00:00
respond['attachment'] = self.random_image()
else:
respond['text'] = errors_array["command_off"]
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[1]:
2020-05-21 19:52:49 +00:00
respond['text'] = "Ваш ид: " + str(user_id)
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[2] or message[0] == self._COMMANDS[5]:
2020-05-25 20:03:42 +00:00
with open('help.txt', 'r') as h:
help = h.read()
respond['text'] = help
h.close()
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[3]:
try:
respond['text'] = self.get_info_user(message[1])
except IndexError:
2020-05-16 19:09:52 +00:00
respond['text'] = errors_array["miss_argument"]
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[4]:
try:
respond['text'] = self.get_info_group(message[1])
except IndexError:
2020-05-16 19:09:52 +00:00
respond['text'] = errors_array["miss_argument"]
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[6]:
2020-07-02 09:17:36 +00:00
if(weather_command):
2020-07-01 15:09:54 +00:00
try:
respond['text'] = get_weather(message[1])
except IndexError:
respond['text'] = errors_array["miss_argument"]
else:
respond['text'] = errors_array["command_off"]
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[7]:
try:
respond['text'] = self.wiki_article(message[1])
except IndexError:
2020-05-16 19:09:52 +00:00
respond['text'] = errors_array["miss_argument"]
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[8]:
respond['text'] = self.exchange_rates()
elif message[0] == self._COMMANDS[9]:
2020-05-21 19:52:49 +00:00
respond['text'] = "Теперь бот работает в режиме эхо. Чтобы это выключить, введить \"!echo off\""
self.change_await("echo")
2020-05-24 11:57:02 +00:00
log(False, f"[BOT_{self._CHAT_ID}] Enter in echo mode")
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[10]:
try:
message[1] = message[1].lower()
respond['text'] = self.game(message[1], user_id)
2020-05-08 19:30:43 +00:00
except IndexError:
2020-05-16 19:09:52 +00:00
respond['text'] = errors_array["miss_argument"]
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[11]:
2020-08-27 09:43:09 +00:00
if self._ACCESS_TO_ALL or int(user_id) == int(config.owner_id):
2020-05-11 18:24:34 +00:00
try:
respond['text'] = self.debug(message[1])
except IndexError:
respond['text'] = self.debug()
else:
2020-05-16 19:09:52 +00:00
respond["text"] = errors_array["access"]
2020-05-08 19:30:43 +00:00
elif message[0] == self._COMMANDS[12]:
2020-08-27 09:43:09 +00:00
if self._ACCESS_TO_ALL or int(user_id) == int(config.owner_id):
2020-05-11 18:24:34 +00:00
if self._MIDNIGHT_EVENT:
2020-08-27 09:43:09 +00:00
self.change_flag('midnight', False)
2020-05-11 18:24:34 +00:00
self.send("Уведомление о миднайте выключено")
log(False,
f"[BOT_{self._CHAT_ID}] Unsubscribed from event \"Midnight\"")
2020-05-11 18:24:34 +00:00
else:
2020-08-27 09:43:09 +00:00
self.change_flag('midnight', True)
2020-05-11 18:24:34 +00:00
self.send("Бот будет уведомлять вас о каждом миднайте")
log(False,
f"[BOT_{self._CHAT_ID}] Subscribed on event \"Midnight\"")
2020-05-11 18:24:34 +00:00
else:
2020-05-16 19:09:52 +00:00
respond['text'] = errors_array["access"]
2020-05-11 18:24:34 +00:00
elif message[0] == self._COMMANDS[13]:
2020-07-01 15:09:54 +00:00
if int(user_id) == int(config.owner_id):
2020-05-11 18:24:34 +00:00
try:
if message[1] == "owner":
respond['text'] = "Теперь некоторыми командами может пользоваться только владелец бота"
2020-08-27 09:43:09 +00:00
self.change_flag('admin_mode', False)
2020-05-11 18:24:34 +00:00
elif message[1] == "all":
respond['text'] = "Теперь все могут пользоваться всеми командами"
2020-08-27 09:43:09 +00:00
self.change_flag('admin_mode', True)
2020-05-11 18:24:34 +00:00
else:
respond['text'] = "Некорректный аргумент"
except IndexError:
2020-05-16 19:09:52 +00:00
respond['text'] = errors_array["miss_argument"]
log(False,
2020-08-27 09:43:09 +00:00
f"[BOT_{self._CHAT_ID}] Access level changed on {self._ACCESS_TO_ALL}")
2020-05-08 19:30:43 +00:00
else:
2020-05-16 19:09:52 +00:00
respond['text'] = errors_array["access"]
elif message[0] == self._COMMANDS[14]:
2020-07-01 15:09:54 +00:00
if self._OWNER or int(user_id) == int(config.owner_id):
2020-05-16 19:09:52 +00:00
self.send("Бот выключается")
2020-05-24 11:57:02 +00:00
exit(log(False, "[SHUTDOWN]"))
2020-05-16 19:09:52 +00:00
elif message[0] == self._COMMANDS[15]:
2020-07-01 15:09:54 +00:00
respond['text'] = "Функция удалена за ненадобнастью"
2020-05-23 07:48:05 +00:00
elif message[0] == self._COMMANDS[16]:
2020-08-27 09:43:09 +00:00
if self._ACCESS_TO_ALL or int(user_id) == int(config.owner_id):
2020-05-23 07:48:05 +00:00
if self._NEW_POST:
2020-08-27 09:43:09 +00:00
self.change_flag('new_post', False)
2020-05-23 07:48:05 +00:00
self.send("Уведомление о новом посте выключено")
log(False,
f"[BOT_{self._CHAT_ID}] Unsubscribed from new posts")
2020-05-23 07:48:05 +00:00
else:
2020-08-27 09:43:09 +00:00
self.change_flag('new_post', True)
self.send(
"Бот будет уведомлять вас о каждом новом посте")
log(False,
f"[BOT_{self._CHAT_ID}] Subscribed on new posts")
2020-05-23 07:48:05 +00:00
else:
respond['text'] = errors_array["access"]
elif message[0] == self._COMMANDS[17]:
try:
message[1] = message[1].split(' ', 1)
try:
respond['text'] = self.random_number(
int(message[1][0]), int(message[1][1]))
except:
respond['text'] = self.random_number(
0, int(message[1][0]))
except:
respond['text'] = self.random_number(0, 10)
2020-05-31 12:25:53 +00:00
elif message[0] == self._COMMANDS[18]:
if int(self._CHAT_ID) <= 2000000000:
respond['text'] = "Данный чат не является беседой"
2020-07-01 15:09:54 +00:00
elif int(user_id) != int(config.owner_id):
2020-05-31 12:25:53 +00:00
respond['text'] = errors_array["access"]
else:
try:
vk.method("messages.getConversationMembers", {
"peer_id": int(self._CHAT_ID), "group_id": config.group_id})
2020-05-31 12:25:53 +00:00
if self._ADMIN_MODE:
respond["text"] = "Режим модерирования выключен"
2020-08-27 09:43:09 +00:00
self.change_flag('admin_mode', False)
log(False,
f"[BOT_{self._CHAT_ID}] Admin mode: {self._ADMIN_MODE}")
2020-05-31 12:25:53 +00:00
else:
respond["text"] = "Режим модерирования включён"
2020-08-27 09:43:09 +00:00
self.change_flag('admin_mode', True)
log(False,
f"[BOT_{self._CHAT_ID}] Admin mode: {self._ADMIN_MODE}")
2020-05-31 12:25:53 +00:00
except Exception:
respond["text"] = "У меня нет прав администратора"
2020-05-08 19:30:43 +00:00
if respond['text'] or respond['attachment']:
self.send(respond['text'], respond['attachment'])
def debug(self, arg=None):
if arg == "log":
if self._OWNER:
2020-06-08 18:52:51 +00:00
with open(log_path, 'r') as f:
2020-05-08 19:30:43 +00:00
log = list(deque(f, 10))
text_log = "<br>Последние 10 строк из лога:<br>"
for i in range(len(log)):
text_log += log[i]
f.close()
return text_log
else:
2020-05-16 19:09:52 +00:00
return errors_array["access"]
elif arg == "bots":
if self._OWNER:
answer = "Обьекты бота:"
for i in bot:
answer += "<br>"+str(bot[i])
return answer
else:
return errors_array["access"]
2020-06-09 10:19:10 +00:00
elif arg == "game":
stats = db.get_game_stat()
if len(stats) > 0:
answer = "Статистика игроков в !game"
for i in stats:
try:
winrate = (i['game_wins']/(i['game_wins'] +
i['game_defeats']+i['game_draws'])) * 100
2020-06-09 10:19:10 +00:00
except ZeroDivisionError:
winrate = 0
2020-06-09 10:30:51 +00:00
answer += f"<br> @id{i['chat_id']} - Сыграл раз: {i['game_wins']+i['game_defeats']+i['game_draws']}, Победы/Ничьи/Поражения: {i['game_wins']}/{i['game_draws']}/{i['game_defeats']}, {toFixed(winrate, 2)}% побед"
2020-06-09 10:19:10 +00:00
else:
answer = "Никто не пользуется !game"
return answer
2020-05-08 19:30:43 +00:00
else:
up_time = time.time() - debug_array['start_time']
time_d = int(up_time) / (3600 * 24)
time_h = int(up_time) / 3600 - int(time_d) * 24
time_min = int(up_time) / 60 - int(time_h) * \
60 - int(time_d) * 24 * 60
time_sec = int(up_time) - int(time_min) * 60 - \
int(time_h) * 3600 - int(time_d) * 24 * 60 * 60
str_up_time = '%01d:%02d:%02d:%02d' % (
time_d, time_h, time_min, time_sec)
datetime_time = datetime.datetime.fromtimestamp(
debug_array['start_time'])
2020-05-08 19:30:43 +00:00
answer = "UPTIME: " + str_up_time + "<br>Прослушано сообщений: " + str(
2020-06-09 10:30:51 +00:00
debug_array['messages_get']) + "<br>Отправлено сообщений: " + str(
2020-06-09 10:19:10 +00:00
debug_array['messages_answered']) + "<br>Ошибок в работе: " + str(
debug_array['logger_warnings']) + ", из них:<br> •Беды с ВК: " + str(
debug_array['vk_warnings']) + "<br> •Беды с БД: " + str(
debug_array['db_warnings']) + "<br> •Беды с ботом: " + str(
debug_array['bot_warnings']) + "<br>Обьектов бота: " + str(
len(bot)) + "<br>Запуск бота по часам сервера: " + datetime_time.strftime('%d.%m.%Y %H:%M:%S UTC')
2020-05-08 19:30:43 +00:00
return answer
2020-05-04 20:26:22 +00:00
def game(self, thing, user_id):
data = db.get_from_users(user_id)
2020-07-01 15:09:54 +00:00
if (config.use_database):
if len(data) == 0:
create_new_bot_object(user_id)
data = db.get_from_users(user_id)
d = data[0]
else:
d = data
2020-04-13 18:25:48 +00:00
if thing == "статистика":
try:
winrate = (d['game_wins']/(d['game_wins'] +
d['game_defeats']+d['game_draws'])) * 100
except ZeroDivisionError:
winrate = 0
return f"Камень, ножницы, бумага<br>Сыграно игр: {d['game_wins']+d['game_defeats']+d['game_draws']}<br>Из них:<br>•Побед: {d['game_wins']}<br>•Поражений: {d['game_defeats']}<br>•Ничей: {d['game_draws']}<br>Процент побед: {toFixed(winrate, 2)}%"
2020-04-13 18:25:48 +00:00
elif thing == "камень" or thing == "ножницы" or thing == "бумага":
things = ["камень", "ножницы", "бумага"]
bot_thing = random.choice(things)
if thing == "камень" and bot_thing == "ножницы":
result = 2
elif thing == "ножницы" and bot_thing == "бумага":
result = 2
elif thing == "бумага" and bot_thing == "камень":
result = 2
elif thing == "ножницы" and bot_thing == "камень":
result = 1
elif thing == "бумага" and bot_thing == "ножницы":
result = 1
elif thing == "камень" and bot_thing == "бумага":
result = 2
elif thing == "камень" and bot_thing == "камень":
result = 0
elif thing == "ножницы" and bot_thing == "ножницы":
result = 0
elif thing == "бумага" and bot_thing == "бумага":
result = 0
if result == 2:
response = f"Камень, ножницы, бумага<br>{thing} vs. {bot_thing}<br>Вы выиграли!"
db.update_user(user_id, "game_wins", d['game_wins']+1)
2020-04-13 18:25:48 +00:00
elif result == 1:
response = f"Камень, ножницы, бумага<br>{thing} vs. {bot_thing}<br>Вы проиграли!"
db.update_user(user_id, "game_defeats", d['game_defeats']+1)
2020-04-13 18:25:48 +00:00
elif result == 0:
response = f"Камень, ножницы, бумага<br>{thing} vs. {bot_thing}<br>Ничья!"
db.update_user(user_id, "game_draws", d['game_draws']+1)
2020-04-13 18:25:48 +00:00
return response
2020-04-13 18:25:48 +00:00
else:
return "Неверный аргумент<br>Использование команды:<br>!game *камень/ножницы/бумага/статистика*"
2020-04-05 14:41:33 +00:00
2020-04-04 16:07:39 +00:00
def get_info_user(self, id):
try:
user_info = vk.method(
'users.get', {'user_ids': id, 'fields': 'verified,last_seen,sex'})
2020-04-04 16:07:39 +00:00
except vk_api.exceptions.ApiError as lol:
2020-05-24 11:57:02 +00:00
err = "Method users.get: " + str(lol)
2020-04-27 11:48:20 +00:00
log(True, err)
2020-04-13 18:25:48 +00:00
return "Пользователь не найден<br>" + str(lol)
2020-04-15 10:45:05 +00:00
if "deactivated" in user_info[0]:
if user_info[0]['deactivated'] == 'banned':
return user_info[0]['first_name'] + " " + user_info[0]['last_name'] + " забанен"
elif user_info[0]['deactivated'] == 'deleted':
return "Профиль был удалён"
2020-04-15 10:36:12 +00:00
2020-04-04 16:07:39 +00:00
if user_info[0]['is_closed']:
is_closed = "Да"
else:
is_closed = "Нет"
if user_info[0]['sex'] == 1:
sex = "Женский"
elif user_info[0]['sex'] == 2:
sex = "Мужской"
else:
sex = "Неизвестно"
if user_info[0]['last_seen']['platform'] == 1:
platform = "m.vk.com"
elif user_info[0]['last_seen']['platform'] == 2:
platform = "iPhone"
elif user_info[0]['last_seen']['platform'] == 3:
platform = "iPad"
elif user_info[0]['last_seen']['platform'] == 4:
platform = "Android"
elif user_info[0]['last_seen']['platform'] == 5:
platform = "Windows Phone"
elif user_info[0]['last_seen']['platform'] == 6:
platform = "Windows 10"
elif user_info[0]['last_seen']['platform'] == 7:
platform = "vk.com"
else:
platform = "тип платформы неизвестен"
time = datetime.datetime.fromtimestamp(
user_info[0]['last_seen']['time'])
2020-04-04 16:07:39 +00:00
2020-04-27 11:48:20 +00:00
answer = user_info[0]['first_name'] + " " + user_info[0]['last_name'] + "<br>Его ид: " + \
str(user_info[0]['id']) + "<br>Профиль закрыт: " + is_closed + "<br>Пол: " + sex \
+ "<br>Последний онлайн: " + \
time.strftime('%d.%m.%Y в %H:%M:%S') + " (" + platform + ")"
2020-04-04 16:07:39 +00:00
return answer
def get_info_group(self, id):
try:
group_info = vk.method(
'groups.getById', {'group_id': id, 'fields': 'description,members_count'})
2020-04-04 16:07:39 +00:00
except vk_api.exceptions.ApiError as lol:
2020-05-24 11:57:02 +00:00
err = "Method groups.getById: " + str(lol)
2020-04-27 11:48:20 +00:00
log(True, err)
2020-04-13 18:25:48 +00:00
return "Группа не найдена<br>" + str(lol)
2020-04-04 16:07:39 +00:00
if group_info[0]['description'] == "":
description = "Отсутствует"
else:
description = group_info[0]['description']
2020-04-13 18:25:48 +00:00
answer = group_info[0]['name'] + "<br>Описание: " + description + "<br>Ид группы: " + str(
group_info[0]['id']) + "<br>Подписчиков: " + str(group_info[0]['members_count'])
2020-04-04 16:07:39 +00:00
return answer
2020-04-03 19:56:57 +00:00
2020-04-05 22:46:06 +00:00
def random_image(self):
2020-07-01 15:09:54 +00:00
group = "-" + str(config.group_id)
2020-07-02 09:17:36 +00:00
random_images_query = vk_mda.method('photos.get',
2020-07-01 15:09:54 +00:00
{'owner_id': group, 'album_id': config.album_for_command, 'count': 1000})
info = "Method photos.get: " + \
str(random_images_query['count']) + " photos received"
2020-04-27 11:48:20 +00:00
log(False, info)
2020-04-06 10:26:50 +00:00
random_number = random.randrange(random_images_query['count'])
2020-04-13 18:25:48 +00:00
return "photo" + str(random_images_query['items'][random_number]['owner_id']) + "_" + str(
random_images_query['items'][random_number]['id'])
2020-04-05 22:46:06 +00:00
2020-04-06 10:26:50 +00:00
def wiki_article(self, search):
w = wiki.Wikipedia('ru')
page = w.page(search)
if page.exists():
2020-04-13 18:25:48 +00:00
answer = page.title + "<br>" + page.summary
2020-04-06 10:26:50 +00:00
else:
answer = "Такой статьи не существует"
return answer
2020-05-08 19:30:43 +00:00
def exchange_rates(self):
2020-04-10 16:06:15 +00:00
try:
2020-04-13 18:25:48 +00:00
rates_USD = json.loads(
requests.get("https://www.nbrb.by/api/exrates/rates/145?periodicity=0", timeout=10).text)
rates_EUR = json.loads(
requests.get("https://www.nbrb.by/api/exrates/rates/292?periodicity=0", timeout=10).text)
rates_RUB = json.loads(
requests.get("https://www.nbrb.by/api/exrates/rates/298?periodicity=0", timeout=10).text)
return "Текущий курс валют по данным НБ РБ:<br>" + rates_USD['Cur_Name'] + ": " + str(
rates_USD['Cur_Scale']) + " " + rates_USD['Cur_Abbreviation'] + " = " + str(
rates_USD['Cur_OfficialRate']) + " BYN<br>" + rates_EUR['Cur_Name'] + ": " + str(
rates_EUR['Cur_Scale']) + " " + rates_EUR['Cur_Abbreviation'] + " = " + str(
rates_EUR['Cur_OfficialRate']) + " BYN<br>" + "Российский рубль" + ": " + str(
rates_RUB['Cur_Scale']) + " " + rates_RUB['Cur_Abbreviation'] + " = " + str(
rates_RUB['Cur_OfficialRate']) + " BYN"
2020-04-10 16:06:15 +00:00
except Exception as mda:
2020-05-24 11:57:02 +00:00
err = "НБ РБ API: " + str(mda)
2020-04-27 11:48:20 +00:00
log(True, err)
2020-04-13 18:25:48 +00:00
return "Невозможно получить данные из НБ РБ: " + str(mda)
2020-04-10 16:06:15 +00:00
def random_number(self, lower, higher):
r = random.randint(lower, higher)
return f"Рандомное число от {lower} до {higher}:<br>{r}"
2020-05-21 19:52:49 +00:00
def change_await(self, awaiting=None):
2020-08-27 09:43:09 +00:00
"""Change the awaiting input state
Keyword arguments:
awaiting -- name of function, what awaiting input from user. Defalt: None. String
"""
2020-05-21 19:52:49 +00:00
self._AWAITING_INPUT_MODE = awaiting
db.update_user(self._CHAT_ID, "awaiting", self._AWAITING_INPUT_MODE)
2020-08-27 09:43:09 +00:00
def change_flag(self, flag, value):
"""Change 'flag' to 'value'
Keyword arguments:
flag -- name of flag. Can be 'access', 'new_post', 'midnight', 'admin_mode'. String
value -- set the flag state. Bool
"""
if flag == 'access':
self._ACCESS_TO_ALL = value
db.update_user(self._CHAT_ID, "access", self._ACCESS_TO_ALL)
elif flag == 'new_post':
self._NEW_POST = value
db.update_user(self._CHAT_ID, "new_post", self._NEW_POST)
elif flag == 'midnight':
self._MIDNIGHT_EVENT = value
db.update_user(self._CHAT_ID, "midnight", self._MIDNIGHT_EVENT)
elif flag == 'admin_mode':
self._ADMIN_MODE = value
db.update_user(self._CHAT_ID, "admin_mode", self._ADMIN_MODE)
2020-05-23 07:48:05 +00:00
2020-05-08 19:30:43 +00:00
def send(self, message=None, attachment=None):
2020-08-27 09:43:09 +00:00
"""Send to user something.
Keyword arguments:
message -- text of message. string
attachment -- name of attachment. string
"""
2020-05-24 11:57:02 +00:00
try:
random_id = random.randint(-9223372036854775808,
9223372036854775807)
2020-07-02 09:17:36 +00:00
message = vk.method('messages.send',
2020-05-24 11:57:02 +00:00
{'peer_id': self._CHAT_ID, 'message': message, 'random_id': random_id,
'attachment': attachment})
log(False,
f'[BOT_{self._CHAT_ID}] id: {message}, random_id: {random_id}')
2020-05-24 11:57:02 +00:00
debug_array['messages_answered'] += 1
except Exception as e:
log(True, f'Failed to send message: {str(e)}')