Ejemplo n.º 1
0
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:])
Ejemplo n.º 2
0
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')
Ejemplo n.º 3
0
 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')
Ejemplo n.º 4
0
Archivo: index.py Proyecto: dopak/test1
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']))
Ejemplo n.º 5
0
 def __init__(self, token):
     self.token = token
     self.vk = vk_api.VkApi(token=token)
     self.longpoll = VkLongPoll(self.vk)
Ejemplo n.º 6
0
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')
Ejemplo n.º 7
0
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
Ejemplo n.º 8
0
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)
Ejemplo n.º 9
0
)
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()
Ejemplo n.º 10
0
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)
Ejemplo n.º 11
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()
Ejemplo n.º 13
0
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')
Ejemplo n.º 15
0
    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)
Ejemplo n.º 16
0
 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} = {}
Ejemplo n.º 17
0
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
Ejemplo n.º 18
0
 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)
Ejemplo n.º 19
0
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(
        )  #пихаем ответ в переменную и отделываемся от регистра
Ejemplo n.º 20
0
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)
Ejemplo n.º 21
0
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 Попробуй, пожалуйта, еще раз"
                        )
Ejemplo n.º 22
0
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
Ejemplo n.º 23
0
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
Ejemplo n.º 24
0
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 = [
            " &#128538; &#10084; &#4448; &#4448; &#4448; &#4448; &#4448; &#4448; &#128522; ",
            " &#128526; &#4448; &#10084; &#4448; &#4448; &#4448; &#4448; &#4448; &#128522; ",
            " &#128526; &#4448; &#4448; &#10084; &#4448; &#4448; &#4448; &#4448; &#128522; ",
            " &#128526; &#4448; &#4448; &#4448; &#10084; &#4448; &#4448; &#4448; &#128522; ",
            " &#128526; &#4448; &#4448; &#4448; &#4448; &#10084; &#4448; &#4448; &#128522; ",
            " &#128526; &#4448; &#4448; &#4448; &#4448; &#4448; &#10084; &#4448; &#128522; ",
            " &#128526; &#4448; &#4448; &#4448; &#4448; &#4448; &#4448;  &#10084; &#128522; ",
            " &#128526; &#4448; &#4448; &#4448; &#4448; &#4448; &#4448; &#4448; &#128525; "
        ]

        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
Ejemplo n.º 25
0
    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)
Ejemplo n.º 26
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
Ejemplo n.º 27
0
    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})
Ejemplo n.º 28
0
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 == "&lt;-":
            self.send_msg_k(user_id, Keyboard.today(), "Расписание на...")

        elif msg == "-&gt;":
            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]
Ejemplo n.º 29
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]
Ejemplo n.º 30
0
 def __init__(self, token):
     vk = vk_api.VkApi(token=token)
     self.longpoll = VkLongPoll(vk)
     self.vk_api = vk.get_api()
     print("Server started")
Ejemplo n.º 31
0
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()
Ejemplo n.º 32
0
        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]
Ejemplo n.º 33
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, 'Клиент ждёт Вас в чате.')
Ejemplo n.º 34
0
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')