Beispiel #1
0
def start(config):
    client = TelegramClient(config["session_name"], config["api_id"],
                            config["api_hash"])
    client.start()

    input_channels_entities = []
    output_channel_entity = None
    for d in client.iter_dialogs():
        if d.name in config["input_channel_names"]:
            input_channels_entities.append(
                InputChannel(d.entity.id, d.entity.access_hash))
        if d.name == config["output_channel_name"]:
            output_channel_entity = InputChannel(d.entity.id,
                                                 d.entity.access_hash)

    if output_channel_entity is None:
        logger.error(
            f"Could not find the channel \"{config['output_channel_name']}\" in the user's dialogs"
        )
        sys.exit(1)
    logging.info(
        f"Listening on {len(input_channels_entities)} channels. Forwarding messages to {config['output_channel_name']}."
    )

    @client.on(events.NewMessage(chats=input_channels_entities))
    async def handler(event):
        await client.forward_messages(output_channel_entity, event.message)
        logging.info(f"Event message: {event.message.message}.")

        with open('A:1.txt', 'w', encoding="utf-8") as filehandle:
            filehandle.write(event.message.message)
            filehandle.close()

    client.run_until_disconnected()
def start(config):
    client = TelegramClient(config["session_name"],
                            config["api_id"],
                            config["api_hash"],
                            proxy=None
                            #proxy=(socks.HTTP, '127.0.0.1', 1087)
                            )
    client.start()

    input_channels_entities = []
    output_channel_entity = None
    for d in client.iter_dialogs():
        if d.name in config["input_channel_names"]:
            input_channels_entities.append(
                InputChannel(d.entity.id, d.entity.access_hash))
        if d.name == config["output_channel_name"]:
            output_channel_entity = InputChannel(d.entity.id,
                                                 d.entity.access_hash)

    if output_channel_entity is None:
        logger.error(
            f"Could not find the channel \"{config['output_channel_name']}\" in the user's dialogs"
        )
        sys.exit(1)
    logging.info(
        f"Listening on {len(input_channels_entities)} channels. Forwarding messages to {config['output_channel_name']}."
    )

    @client.on(
        events.NewMessage(chats=input_channels_entities,
                          pattern=r'([\s\S]*)#福建([\s\S]*)'))
    async def handler(event):
        await client.forward_messages(output_channel_entity, event.message)

    client.run_until_disconnected()
Beispiel #3
0
def start(config):
    client = TelegramClient(config["session_name"], config["api_id"],
                            config["api_hash"])
    client.start()

    input_channels_entities = []
    output_channel_entities = []
    for d in client.iter_dialogs():
        if d.name in config["input_channel_names"]:
            input_channels_entities.append(
                InputChannel(d.entity.id, d.entity.access_hash))
        if d.name in config["output_channel_names"]:
            output_channel_entities.append(
                InputChannel(d.entity.id, d.entity.access_hash))

    if not output_channel_entities:
        logger.error(
            f"Could not find any output channels in the user's dialogs")
        sys.exit(1)

    if not input_channels_entities:
        logger.error(
            f"Could not find any input channels in the user's dialogs")
        sys.exit(1)

    logging.info(
        f"Listening on {len(input_channels_entities)} channels. Forwarding messages to {len(output_channel_entities)} channels."
    )

    @client.on(events.NewMessage(chats=input_channels_entities))
    async def handler(event):
        for output_channel in output_channel_entities:
            await client.forward_messages(output_channel, event.message)

    client.run_until_disconnected()
Beispiel #4
0
def start(config):
    pytesseract.pytesseract.tesseract_cmd = config['tesseract_path']
    client = TelegramClient(config["session_name"], config["api_id"],
                            config["api_hash"])
    client.start()

    input_channels_entities = []
    output_channel_entity = None
    for d in client.iter_dialogs():
        if d.name in config["input_channel_names"]:
            input_channels_entities.append(
                InputChannel(d.entity.id, d.entity.access_hash))
        if d.name == config["output_channel_name"]:
            output_channel_entity = InputChannel(d.entity.id,
                                                 d.entity.access_hash)

    if output_channel_entity is None:
        logger.error(
            f"Could not find the channel \"{config['output_channel_name']}\" in the user's dialogs"
        )
        sys.exit(1)
    logging.info(
        f"Listening on {len(input_channels_entities)} channels. Forwarding messages to {config['output_channel_name']}."
    )

    @client.on(events.NewMessage(chats=input_channels_entities))
    async def handler(event):
        message_text = None
        text_in_image = None
        if event.message.media is not None:
            if is_image(event.message.media):
                await client.download_media(event.message.media,
                                            config["temp_path"] + 'temp.jpg')
                time.sleep(2)
                # Get HOCR output
                hocr = pytesseract.image_to_pdf_or_hocr(config["temp_path"] +
                                                        'temp.jpg',
                                                        extension='hocr')
                soup = BeautifulSoup(hocr.decode('utf-8'), 'html.parser')
                elements = soup.find_all("span", class_="ocrx_word")
                text = ''
                for elm in elements:
                    text += elm.text
                text_in_image = re.findall(r'[A-Z]{3}\s*/\s*[A-Z]{3}', text)
                if len(text_in_image) > 0:
                    text_in_image = "Symbol: " + text_in_image[0].replace(
                        '/', '').replace(" ", "")
                    message_from_sender = parese_message(event.message.message)
                    if message_from_sender is not None and text_in_image is not None:
                        message_text = text_in_image + "\n" + message_from_sender
                    elif text_in_image is None:
                        message_text = message_from_sender
                    elif message_from_sender is None:
                        message_text = text_in_image
                    await client.send_message(output_channel_entity,
                                              message_text)

    client.run_until_disconnected()
Beispiel #5
0
    def invite_to_channel(self):
        """

        This definition adding contact to group,
        do not use it without def_channel() and def_usernames().
        You can invite to channel from 1 session max 15 people after that you are at risk.
        You can be banned because too many requests from 1 session.
        """
        if self.flag_channel and self.flag_user:
            for i in range(len(self.usernames)):
                try:
                    if self.usernames[i][0]:
                        sleep(31)
                        self.client(
                            InviteToChannelRequest(
                                InputChannel(self.channel.id,
                                             self.channel.access_hash),
                                [
                                    InputUser(self.usernames[i][0].id,
                                              self.usernames[i][0].access_hash)
                                ]))
                        print('Successfully added ' +
                              str(self.usernames[i][0]) + ' to ' +
                              str(self.channel))
                        print('Успешно добавлен ' + str(self.usernames[i][0]) +
                              ' в ' + str(self.channel))
                        print('------------------------')
                        sleep(5)
                except Exception as err:
                    print(err)
                    print('------------------------')
        else:
            print(
                'You don\'t define channel and users to add, please try again'
                'Вы не определили канал и/или ползователей')
Beispiel #6
0
    async def post_login(self) -> None:
        await self.init_permissions()
        info = await self.client.get_me()
        self.tgid = TelegramID(info.id)
        self.username = info.username
        self.mxid = pu.Puppet.get_mxid_from_id(self.tgid)

        chat_ids = [
            chat_id for chat_id, chat_type in self.chats.items()
            if chat_type == "chat"
        ]
        response = await self.client(GetChatsRequest(chat_ids))
        for chat in response.chats:
            if isinstance(chat,
                          ChatForbidden) or chat.left or chat.deactivated:
                self.remove_chat(TelegramID(chat.id))

        channel_ids = (InputChannel(chat_id, 0)
                       for chat_id, chat_type in self.chats.items()
                       if chat_type == "channel")
        for channel_id in channel_ids:
            try:
                await self.client(GetChannelsRequest([channel_id]))
            except (ChannelPrivateError, ChannelInvalidError):
                self.remove_chat(TelegramID(channel_id.channel_id))
Beispiel #7
0
    def get_chat_messages(self, channel_name, all=False):
        """
        Функция для получения всех сообщений из чата.
        :param channel_name: имя чата (например durov)
        :param all: количество сообщений. Если False - получает последние 5к сообщений
        :return: объекты сообщений
        """
        chat_object = self.get_chat_info(channel_name)
        input_channel = InputChannel(chat_object['chat_id'], chat_object['access_hash'])
        channel = self.client.invoke(GetFullChannelRequest(input_channel)).__dict__
        chat_peer = InputPeerChannel(channel['full_chat'].id, chat_object['access_hash'])

        all_messages = []
        offset = 0
        new_messages = self.client.invoke(GetHistoryRequest(chat_peer, 0, None, offset, LIMIT, 0, 0, )).messages

        if all:
            while len(new_messages) is not 0 and offset < MESSAGES_LIMIT:
                offset += 100

                for new_message in new_messages:
                    all_messages.append(new_message.__dict__)

                new_messages = self.client.invoke(GetHistoryRequest(chat_peer, 0, None, offset, LIMIT, 0, 0)).messages
                time.sleep(1)

        else:

            for new_message in new_messages:
                all_messages.append(new_message.__dict__)

        return all_messages
Beispiel #8
0
 async def get_call(
     self,
     chat_id: int,
 ) -> Optional[InputGroupCall]:
     chat = await self._app.get_input_entity(chat_id)
     if isinstance(chat, InputPeerChannel):
         input_call = (await self._app(
             GetFullChannelRequest(
                 InputChannel(
                     chat.channel_id,
                     chat.access_hash,
                 ), ), )).full_chat.call
     else:
         input_call = (await self._app(
             GetFullChatRequest(chat_id), )).full_chat.call
     if input_call is not None:
         try:
             call: GroupCall = (await self._app(
                 GetGroupCallRequest(
                     call=input_call,
                     limit=-1,
                 ), )).call
             if call.schedule_date is not None:
                 return None
         except Exception as e:
             print(e)
     return input_call
Beispiel #9
0
    async def post_login(self) -> None:
        await self.init_permissions()
        info = await self.client.get_me()
        self.tgid = info.id
        self.username = info.username
        self.mxid = pu.Puppet.get_mxid_from_id(self.tgid)

        chat_ids = [chat_id for chat_id, chat_type in self.chats.items() if chat_type == "chat"]
        response = await self.client(GetChatsRequest(chat_ids))
        for chat in response.chats:
            if isinstance(chat, ChatForbidden) or chat.left or chat.deactivated:
                self.remove_chat(chat.id)

        channel_ids = [InputChannel(chat_id, 0)
                       for chat_id, chat_type in self.chats.items()
                       if chat_type == "channel"]
        for channel_id in channel_ids:
            try:
                await self.client(GetChannelsRequest([channel_id]))
            except (ChannelPrivateError, ChannelInvalidError):
                self.remove_chat(channel_id.channel_id)

        if config["bridge.catch_up"]:
            try:
                await self.client.catch_up()
            except Exception:
                self.log.exception("Failed to run catch_up() for bot")
Beispiel #10
0
def get_participants_ids(channel: Channel, raw_users: bool = False) -> list:
    channel = InputChannel(channel.id, channel.access_hash)
    result = client(
        GetParticipantsRequest(channel, ChannelParticipantsSearch(''), 0,
                               10000, 5))
    if not raw_users:
        ids = [user.id for user in result.users if not user.bot]
        return ids
    else:
        return result.users
 async def run(self):
     await self.tg_client.connect()
     await self.tg_client.start()
     for ch_id in self.config["telegram"]["channels"]:
         result = await self.tg_client(ResolveUsernameRequest(ch_id))
         channel = InputChannel(result.peer.channel_id, result.chats[0].access_hash)
         await self.tg_client(JoinChannelRequest(channel))
     self.tg_client.add_event_handler(self._tg_event_handler)
     logging.info("Bot has been started")
     await self.tg_client.run_until_disconnected()
Beispiel #12
0
 def from_group_ten_first_persons(group, togroup):
     flag = True
     if group == '-':
         flag = False
         return flag
     elif togroup == '-':
         flag = False
         return flag
     users = client.get_participants(group)
     channel = client.get_entity(togroup)
     for i in range(10):
         try:
             contact = InputPhoneContact(client_id=user[i].id,
                                         phone=user[i].phone,
                                         first_name=user[i].first_name,
                                         last_name=user[i].last_name)
             result = client.invoke(ImportContactsRequest([contact]))
             client(
                 InviteToChannelRequest(
                     InputChannel(channel.id, channel.access_hash),
                     [InputUser(users[i].id, users[i].access_hash)]))
         except errors.rpcerrorlist.UserPrivacyRestrictedError as err:
             print('>>>>0. UserPrivacyRestrictedError...')
             print(err)
         except errors.rpcerrorlist.ChatAdminRequiredError as err:
             print('>>>>1. ChatAdminRequiredError...')
             print(err)
         except errors.rpcerrorlist.ChatIdInvalidError as err:
             print('>>>>2. ChatIdInvalidError...')
             print(err)
         except errors.rpcerrorlist.InputUserDeactivatedError as err:
             print('>>>>3. InputUserDeactivatedError...')
             print(err)
         except errors.rpcerrorlist.PeerIdInvalidError as err:
             print('>>>>4. PeerIdInvalidError...')
             print(err)
         except errors.rpcerrorlist.UserAlreadyParticipantError as err:
             print('>>>>5. UserAlreadyParticipantError...')
             print(err)
         except errors.rpcerrorlist.UserIdInvalidError as err:
             print('>>>>6. UserIdInvalidError...')
             print(err)
         except errors.rpcerrorlist.UserNotMutualContactError as err:
             print('>>>>>7. UserNotMutualContactError...')
             print(err)
         except errors.rpcerrorlist.UsersTooMuchError as err:
             print('>>>>>8. UsersTooMuchError...')
             print(err)
         except errors.rpcerrorlist.PeerFloodError as err:
             print(
                 '>>>>>9. PeerFloodError try again in 24 Hours...Yes, you in spam'
             )
             print(err)
     return flag
Beispiel #13
0
def get_users(group_username):
    users_list = []
    channel = client(ResolveUsernameRequest(group_username))
    offset_counter = 0
    while True:
        users = client(GetParticipantsRequest(InputChannel(channel.peer.channel_id, channel.chats[0].access_hash), limit=200, offset=offset_counter, filter=ChannelParticipantsRecent()))
        if len(users.participants) == 0: break
        offset_counter += 200
        users_list.extend(users.users)
        time.sleep(5)
    return users_list
Beispiel #14
0
    def __load_output_chats(self):
        dialogs = self.telegram.get_dialogs()

        for username in self.output_chat_usernames:
            dialog = next(
                filter(lambda e: e.entity.username == username, dialogs), None)

            if dialog:
                self.output_chats.append(
                    InputChannel(dialog.entity.id, dialog.entity.access_hash))
            else:
                raise RuntimeError(f"Output chat '{username}' was not found")
Beispiel #15
0
def start(config):
    client = TelegramClient(config["session_name"], config["api_id"],
                            config["api_hash"])
    client.start()

    input_channels_entities = []
    output_channel_entity = None
    for d in client.iter_dialogs():
        if d.id in config["input_channel_ids"]:
            input_channels_entities.append(
                InputChannel(d.entity.id, d.entity.access_hash))
        if d.id == config["output_channel_id"]:
            output_channel_entity = InputChannel(d.entity.id,
                                                 d.entity.access_hash)
        if d.id == config["test_channel_id"]:
            test_channel_entity = InputChannel(d.entity.id,
                                               d.entity.access_hash)

    if output_channel_entity is None:
        logger.error(
            f"Could not find the channel \"{config['output_channel_id']}\" in the user's dialogs"
        )
        sys.exit(1)
    logging.info(
        f"Listening on {len(input_channels_entities)} channels. Forwarding messages to {config['output_channel_name']}."
    )

    @client.on(events.NewMessage(chats=input_channels_entities))
    async def handler(event):

        chat = await event.get_chat()
        if chat.id == 1365813396:
            logging.info("Sending new message to Monitor Test")
            await client.send_message(test_channel_entity, event.message)
        else:
            logging.info("Sending new message to Monitor")
            await client.send_message(output_channel_entity, event.message)

    client.run_until_disconnected()
Beispiel #16
0
def join_to_channel(bot, list_ids=tlg_chats):
    success_rate = 0
    for id in list_ids:
        try:
            i = InputChannel(bot.get_entity(id).id, bot.get_entity(id).access_hash)
            bot.invoke(JoinChannelRequest(i))
            success_rate += 1
            print("присоединился к {}".format(id))
            time.sleep(5)
        except:
            print('не могу присоединиться к {}'.format(id))
            list_ids.remove(id)
    return success_rate/len(list_ids), list_ids
Beispiel #17
0
def get_telegram_usernames(write_results=True):
    print('Fetching telegram followers... This may take a few minutes')
    api_id = config['TELEGRAM']['ID']  # Your api_id
    api_hash = config['TELEGRAM']['HASH']  # Your api_hash
    phone_number = config['TELEGRAM']['PHONE']  # Your phone number

    client = TelegramClient(phone_number, api_id, api_hash)
    client.session.report_errors = False
    client.connect()

    # will need to enter code from message if session is not active
    if not client.is_user_authorized():
        client.send_code_request(phone_number)
        client.sign_in(phone_number, input('Enter the code: '))

    channel = client(ResolveUsernameRequest(
        config['TELEGRAM']['CHANNEL']))  # Your channel

    input_channel = InputChannel(channel.chats[0].id,
                                 channel.chats[0].access_hash)

    offset = 0
    limit = 100
    all_participants = []

    # Can pull up to 10000 participants in one shot. Will need to filter if you have more users than that.
    while True:
        participants = client(
            GetParticipantsRequest(input_channel,
                                   ChannelParticipantsSearch(''), offset,
                                   limit, 0))
        if not participants.users:
            break
        all_participants.extend(participants.users)
        offset += len(participants.users)
        print(offset)

    telegram_usernames = []
    for participant in all_participants:
        if participant.username:
            telegram_usernames.append(participant.username.lower())
    # telegram_usernames = [_user.username.lower() for _user in all_participants]
    if write_results:
        telegram_file = open('telegram_usernames.csv', 'w')
        telegram_writer = csv.writer(telegram_file, quoting=csv.QUOTE_ALL)

        for username in telegram_usernames:
            telegram_writer.writerow([username])

    return telegram_usernames
async def get_channel_entity(project_url: str) -> dict:
    cache = getEntityByURL(cache_db, project_url)
    #check if targetchannel is in db
    if cache:
        entity = InputChannel(cache['channel_id'], cache['access_hash'])
        client_alias = cache['client_alias']
        returnDict = {
            'channel_id': cache['channel_id'],
            'title': cache['title'],
            'username': cache['username']
        }
        print("using cache")
    if not cache:
        returned_entity = await telegram.client.get_entity(project_url)
        client_alias = telegram.active_client_alias
        entityDict = {
            'client_alias': client_alias,
            'type': 'channel',
            'project_url': project_url,
            'channel_id': returned_entity.id,
            'access_hash': returned_entity.access_hash,
            'username': returned_entity.username,
            'scam': returned_entity.scam,
            'megagroup': returned_entity.megagroup,
            'verified': returned_entity.verified,
            'title': returned_entity.title
        }
        returnDict = entityDict
        insertEntity(cache_db, entityDict)
        entity = InputChannel(returned_entity.id, returned_entity.access_hash)
        print("using RPC")

    return {
        'channel': entity,
        'client_alias': client_alias,
        'details': returnDict
    }
Beispiel #19
0
def getId(client, chatName, limit, debug=False):
    #Checking for not existing
    try:
        resolve = client(ResolveUsernameRequest(chatName))
    except UsernameInvalidError:
        print("Incorrect name of chat! Try again.")
        return False
    except UsernameNotOccupiedError:
        print("Incorrect name of chat! Try again.")
        return False

    #Checking for chat or no
    try:
        access_hash = resolve.chats[0].access_hash
        chat_id = resolve.chats[0].id
    except IndexError:
        print("It's not a chat!")
        return False

    input_channel = InputChannel(chat_id, access_hash)
    filter = ChannelParticipantsSearch('')
    offset = 0
    hash = 0
    allId = []

    #Checking for channel/private chat
    try:
        client(
            GetParticipantsRequest(input_channel, filter, offset, limit, hash))
    except ChatAdminRequiredError:
        print('It is channel/private chat!')
        return False

    count = 0
    while True:
        if count == limit:
            break
        part = client(
            GetParticipantsRequest(input_channel, filter, offset, limit,
                                   hash), )
        if not part.users:
            break
        allId.append(part.users[count].id)
        count += 1
        offset += 1
        print('{}/{}'.format(count, limit), end='\r')
        if debug:
            print(part.users[count].id)
    return allId
Beispiel #20
0
 async def get_call(
     self,
     chat_id: int,
 ) -> Optional[InputGroupCall]:
     chat = await self._app.get_input_entity(chat_id)
     if isinstance(chat, InputPeerChannel):
         return (await self._app(
             GetFullChannelRequest(
                 InputChannel(
                     chat.channel_id,
                     chat.access_hash,
                 ), ), )).full_chat.call
     else:
         return (await
                 self._app(GetFullChatRequest(chat_id), )).full_chat.call
def add_users_2_channel_fun(user_group_id: int, tag_id: int):
    print('start add users 2 channel.')
    try:
        global id_add_users_2_channel
        user_group = db.session.query(UserGroup).filter(
            UserGroup.group_id == user_group_id).scalar()
        if user_group is None:
            print('user group is none.')
        else:
            inputChannel = InputChannel(channel_id=user_group.group_id,
                                        access_hash=user_group.access_hash)
            user_tag_infos = db.session.query(UserTAGInfo).filter(
                UserGroup.tag_id == tag_id).all()
            if user_tag_infos is None:
                print("user tag infos is none.")
            else:
                inputUsers = []
                all_count = len(user_tag_infos)
                count = 1
                for user_tag_info in user_tag_infos:
                    inputUser = InputUser(user_id=int(user_tag_info.user_id),
                                          access_hash=int(
                                              user_tag_info.user_hash))
                    try:
                        user_1(
                            InviteToChannelRequest(inputChannel, [inputUser]))
                    except:
                        print("invite to channel error.userId=" +
                              str(user_tag_info.user_id) + ";userHash=" +
                              str(user_tag_info.user_hash))
                #     inputUsers.append(inputUser)
                #     if count % 100 == 0 or all_count == count:
                #         print('add users 2 channel.')
                #         try:
                #             client(InviteToChannelRequest(inputChannel, inputUsers))
                #         except:
                #             print("invite to channel error." + str(user_tag_info.user_id))
                #         inputUsers.clear()
                #     count += 1
                # print('all_count=' + str(all_count) + ';count=' + str(count))
        id_add_users_2_channel = False
        print('add users 2 channel finish.')
    except:
        id_add_users_2_channel = False
        print('add users 2 channel get error.')
Beispiel #22
0
def count_members(id, access_hash):
    offset = 0
    limit = 10000
    all_participants = []

    while True:
        participants = client(
            GetParticipantsRequest(InputChannel(id, access_hash),
                                   ChannelParticipantsSearch(''),
                                   offset,
                                   limit,
                                   hash=0))
        if not participants.users:
            break
        all_participants.extend(participants.users)
        offset += len(participants.users)

    return len(all_participants)
Beispiel #23
0
async def main():
    await client.connect()
    if not await client.is_user_authorized():
        client.send_code_request(phone_number)
        me = client.sign_in(phone_number, input('Enter code: '))
    channel = await client.get_entity(
        'https://t.me/qwertyuiop1234567890'
    )  #channel_ id https://t.me/bloXrouteLabsCommunity
    users_in_channel = await client.get_participants(
        'https://t.me/qwertyuiop1234567890')  #channel id or https://t.me/ncent
    print(users_in_channel)

    def is_in_group(username):
        if username in users_in_channel:
            return True
        else:
            return False

    with open('im.txt', 'r') as f:  # file with list of usernames
        for line in f:
            print(line)
            tmp = line[1:].replace('\n', '')
            print(tmp)
            try:
                user = client.get_input_entity(
                    tmp)  # (ResolveUsernameRequest(tmp))
                print(user)
            except UsernameInvalidError as err:
                print(err)
                continue
            if user:
                try:
                    sleep(301)
                    client.invoke(
                        InviteToChannelRequest(
                            InputChannel(channel.id, channel.access_hash),
                            [InputUser(user.user_id, user.access_hash)]))
                except UserNotMutualContactError as err:
                    print(err)
                except UserIdInvalidError as err:
                    print(err)
            else:
                continue
    await client.disconnect()
def get_saving_group():
    # user = client.get_entity("@Jude12")
    # print(user)
    # channel = client.get_entity("@mktesttttttttttt")
    # print(channel)
    # channel_id = channel.id
    # channel_hash = channel.access_hash
    # user_id = user.id
    # user_hash = user.access_hash
    channel_id = 1247985828
    channel_hash = -8866180916535177199
    user_id = 490342664
    user_hash = -7707849152056625292
    inputChannel = InputChannel(channel_id=channel_id,
                                access_hash=channel_hash)
    print(inputChannel)
    inputUser = InputUser(user_id=user_id, access_hash=user_hash)
    print(inputUser)
    test = user_1(InviteToChannelRequest(inputChannel, [inputUser]))
    print(test)
    return "saving group is:" + saving_group
Beispiel #25
0
def inviteToChannel(client, channel, id_list):
	#Checking for not existing 
	try:
		resolve = client(ResolveUsernameRequest(channel))
	except UsernameInvalidError:
		print("Incorrect name of channel! Try again.")
		return False
	except UsernameNotOccupiedError:
		print("Incorrect name of channel! Try again.")
		return False

	chat_id = resolve.chats[0].id
	access_hash = resolve.chats[0].access_hash

	input_channel = InputChannel(chat_id, access_hash)
	
	for id in id_list:
		input_user = InputUser(id, 0)
		InviteToChannelRequest(input_channel, input_user)

	return True
Beispiel #26
0
def dump_users(chat, client):
    counter = 0
    offset = 0
    chat_object = InputChannel(chat['chat_id'], chat['access_hash'])
    all_participants = []
    print('Process...')
    while True:
        participants = client.invoke(
            GetParticipantsRequest(chat_object, ChannelParticipantsSearch(''),
                                   offset, limit))
        if not participants.users:
            break
        all_participants.extend(
            ['{} {}'.format(x.id, x.username) for x in participants.users])
        users_count = len(participants.users)
        offset += users_count
        counter += users_count
        print('{} users collected'.format(counter))
        sleep(2)
    with open('users.txt', 'w') as file:
        file.write('\n'.join(map(str, all_participants)))
Beispiel #27
0
def add_users(client, file_name):
    dialogs, entities = client.get_dialogs(100)

    avail_channels = {}

    channel = None
    channel_id = None
    channel_access_hash = None
    for i, entity in enumerate(entities):
        if not isinstance(entity, User) and not isinstance(entity, Chat):
            avail_channels[str(i)] = [
                entity, entity.id, entity.access_hash, entity.title
            ]

    for k, v in avail_channels.items():
        print(k, v[3])

    channel_index = input(
        "Please select number of supergroup where you want to add users> ")

    #participants = client.invoke(GetParticipantsRequest(avail_channels[channel_index][0], ChannelParticipantsSearch(''), 0, 0))
    #count_of_members_before_adding = len(participants.users)

    users = None
    try:
        with open(file_name, 'r') as f:
            users = json.load(f)

    except Exception:
        print(
            'Invalid file name, make sure you have added extension or if file even exists, if not, run scrape_channel_users.py to create one!'
        )
        sys.exit()

    count = int(
        input('Do you want to add only subset of users(' + str(len(users)) +
              ')? if so, enter the number of users to be added: '))

    users_to_save_back = users[
        count:]  # only users, which didnt be used, will be saved to file again
    print(
        str(len(users_to_save_back)) + ' users to be saved back to json file!')
    users = users[:count]  # users to be added
    print(str(len(users)) + ' users to be removed from list!')
    print()

    with open(file_name, 'w') as f:
        json.dump(users_to_save_back, f, indent=4)

    input_users = []
    for item in users:
        input_users.append(InputUser(item['id'], item['access_hash']))

    user_chunks = list(chunks(input_users, 40))

    for item in user_chunks:
        try:
            client(
                InviteToChannelRequest(
                    InputChannel(avail_channels[channel_index][1],
                                 avail_channels[channel_index][2]), item))

            print('Adding chunk of ' + str(len(item)) + ' users...')
            time.sleep(2)
        except Exception as e:
            print(str(e))
            print('some error occurred, skipping to next chunk.')
            time.sleep(2)

    print('There was attempt to add ' + str(len(input_users)) +
          ' users in total.')

    #participants = client.invoke(GetParticipantsRequest(avail_channels[channel_index][0], ChannelParticipantsSearch(''), 0, 0))
    #count_of_members_after_adding = len(participants.users)

    #print('Count of members before adding: ' + str(count_of_members_before_adding))
    #print('Count of members after adding: ' + str(count_of_members_after_adding))
    print()
    #print('True number of added users: ' + str(count_of_members_after_adding - count_of_members_before_adding))
    print('added')
Beispiel #28
0
def main():
    store_local = input('Do you want to leave the local files? [N/y] ') in ['y', 'yes']

    vkaudio, user_id = auth_vk()
    with auth_tg() as client:

        VKMusicChannel = None
        last_file = None
        progress = 0

        dialogs = client.get_dialogs(limit=None)
        for chat in dialogs:
            if type(chat.entity) == Channel and chat.title == channelName:
                VKMusicChannel = chat

        if VKMusicChannel is None:
            VKMusicChannel = client(CreateChannelRequest(
                title=channelName, about='made with https://github.com/HaCk3Dq/vktotg')).chats[0]
            client(EditPhotoRequest(
                InputChannel(VKMusicChannel.id, VKMusicChannel.access_hash), InputChatUploadedPhoto(
                    client.upload_file('music.jpg'))
            ))
            client.delete_messages(client.get_entity(VKMusicChannel), 2)
        else:
            last_file = client.get_messages(VKMusicChannel, limit=None)[0].document
            if last_file:
                last_file = last_file.attributes[1].file_name

        audios = vkaudio.get(user_id)
        total = len(audios)
        if last_file:
            progress = [track['artist'] + ' - ' + track['title'] for track in audios[::-1]].index(last_file) + 1
            if progress == total:
                print(f'[Done] Found {progress}/{total} tracks')
                exit()
            else:
                print(f'\nFound {progress}/{total} tracks, continue downloading...')
        print()

        progress += 1
        for i, track in enumerate(audios[::-1]):
            if progress and i < progress - 1:
                continue
            filename = track['artist'] + ' - ' + track['title']
            escaped_filename = filename.replace("/", "_")
            file_path = folderName + str(user_id) + '/' + escaped_filename + '.mp3'

            print(f'Downloading [{i + 1}/{total}]')
            print(filename)
            try:
                save(track['url'], file_path)
            except ssl.SSLError:
                print(f'SSL ERROR: {escaped_filename}, launching again...')
                try:
                    save(track['url'], escaped_filename + '.mp3')
                except:
                    print(f'Failed to save track after 2 tries [{i + 1}/{total}]')
                    exit()

            print('\nUploading...')
            sys.stdout.flush()
            send_file(
                client, client.get_entity(VKMusicChannel),
                file_path,
                track['duration'], track['title'],
                track['artist'], filename
            )

            if not store_local:
                os.remove(file_path)
            print()
            sys.stdout.flush()
Beispiel #29
0
def start(config):
    # Get information from config file:
    session_name = config["session_name"]
    api_id = config["api_id"]
    api_hash = config["api_hash"]
    trigger_words = config["trigger_words"]
    quit_key_words = config["quit_key_words"]

    # Initialisations:
    input_channels_entities = []
    output_channel_entity = None
    connectivity = ()
    # Acquire entities:
    with TelegramClient(session_name, api_id, api_hash) as client:
        for d in client.iter_dialogs():
            if d.name in config["input_channel_names"]:
                if (config["mode"] in ['1', '2', '3']):
                    input_channels_entities.append(
                        InputChannel(d.entity.id, d.entity.access_hash))
                else:
                    input_channels_entities.append(InputPeerChat(d.entity.id))
            if d.name == config["output_channel_name"]:
                if (config["mode"] in ['1', '4']):
                    output_channel_entity = InputChannel(
                        d.entity.id, d.entity.access_hash)
                elif (config["mode"] in ['2', '5']):
                    output_channel_entity = InputPeerChat(d.entity.id)
                else:
                    output_channel_entity = InputPeerUser(
                        d.entity.id, d.entity.access_hash)

        # Do a check on entities acquired:
        if output_channel_entity is None:
            connectivity = connectivity + (0, )
            print("Requested output channel entity could not be found")
        else:
            connectivity = connectivity + (1, )
        if len(input_channels_entities) == 0:
            connectivity = connectivity + (0, )
            print("Requested input channel entity(s) cannot be found")
        else:
            connectivity = connectivity + (1, )
        if 0 in connectivity:
            print("Shutting down due to entity-check failure...")
            sys.exit(1)
        else:
            print("Entity-check successful!")
            print(
                "Listening on %d channels. Forwarding messages to %s." %
                (len(input_channels_entities), config['output_channel_name']))

        # Create events to listen to:
        # For more recipes, visit https://arabic-telethon.readthedocs.io/en/stable/

        @client.on(events.NewMessage(chats=input_channels_entities))
        async def forwarding_handler(event):
            client = event.client
            # if trigger_words in event.raw_text.lower():
            if any(word in event.raw_text.lower() for word in trigger_words):
                # await event.reply('hi!')    # extra
                await client.forward_messages(output_channel_entity,
                                              event.message)

        @client.on(
            events.NewMessage(chats=output_channel_entity, outgoing=True))
        async def control_handler(event):
            # if quit_key_words in event.raw_text.lower():
            if any(word in event.raw_text.lower() for word in quit_key_words):
                await client.disconnect()

        client.run_until_disconnected()
Beispiel #30
0
def start(source, config):
    
    # setup the Telegram client
    telegram_client = setup_telegram(config)

    #setup discord client
    discord_client = setup_discord(config)







    #setup telegram output channels
    telegram_output_channel_entities = []
    for d in telegram_client.iter_dialogs():
        if 'Channel' == type(d.entity).__name__ and d.name in config["output_channel_names"]:
            telegram_output_channel_entities.append(InputChannel(d.entity.id, d.entity.access_hash))
    if not telegram_output_channel_entities:
        logger.error(f"Could not find any Telegram output channels in the user's dialogs")
        sys.exit(1)
    logging.info(f"Forwarding messages to {len(telegram_output_channel_entities)} Telegram channels.")
    
    

    
    discord_subscribed_channels = []

    #setup guilds (servers) and channels
    @discord_client.event
    async def on_ready():
        print('We have logged in as {0.user}'.format(discord_client))
        for guild in discord_client.guilds:
            if guild.name == config["discord_input_guild_name"]:
                print("Starting Discord forwarder on server '"+guild.name+"'")
                print("Forwarding the following channels:")
                for channel in guild.channels:
                    if channel.name in config["discord_channel_names"]:
                        print(channel)
                        discord_subscribed_channels.append(channel)

    
    # Wait for messages and reply (debug) or forward to telegram
    @discord_client.event
    async def on_message(message):
        if message.author == discord_client.user:
            return
        if message.content.startswith('$hello'):
            if message.channel in discord_subscribed_channels:
                await message.channel.send('Hello!')
        else:
            if message.channel in discord_subscribed_channels:
                for output_channel in telegram_output_channel_entities:
                    if len(message.attachments) == 1:
                        for attachment in message.attachments:
                            await telegram_client.send_file(output_channel, attachment.url, caption=message.content)
                    elif len(message.attachments) > 1:
                        if message.content.length > 0:
                            await telegram_client.send_message(output_channel, message.content) 
                        for attachment in message.attachments:
                            await telegram_client.send_file(output_channel, attachment.url)
                    else:
                        await telegram_client.send_message(output_channel, message.content)

    if source == 'telegram':
        listen_telegram(telegram_client, config)
    else if source == 'discord'
        listen_discord(discord_client, config)
    else:
        raise Error('SourceArgumentMissing')