def run(self):
        """ Dumps all desired chat messages into a file """
        # Resolve chat name into id
        peer = self(ResolveUsernameRequest(self.settings.chat_name))

        if peer.chats is None or not peer.chats:
            raise ValueError('Error: failed to resolve chat name into chat_id')

        chat = peer.chats[0]

        sprint('Chat name @{} resolved into channel id={}'.format(
            self.settings.chat_name, chat.id))

        # Dump history to file
        count = self.dump_messages_in_file(chat)

        if self.settings.is_clean:
            try:
                # TODO self.log_out()
                sprint('Session data cleared.')
            # pylint: disable=broad-except
            except Exception:
                sprint('Error: failed to log-out.')

        sprint(
            '{} messages were successfully written in resulting file. Done!'.
            format(count))
示例#2
0
    def run(self):
        # Resolve chat name into id
        peer = self(ResolveUsernameRequest(self.settings.chat_name))

        if (peer.chats is None or len(peer.chats)
                == 0) and (peer.users is None or len(peer.users) == 0):
            raise ValueError(
                'Error: failed to resolve chat name into chat_id or user')

        if len(peer.chats) == 0:
            chat = peer.users[0]
        else:
            chat = peer.chats[0]

        sprint('Chat name @{} resolved into id={}'.format(
            self.settings.chat_name, chat.id))

        # Dump history to file
        count = self.dump_messages_in_file(chat)

        if self.settings.is_clean:
            # noinspection PyBroadException
            try:
                self.log_out()
                sprint('Session data cleared.')
            except:
                sprint('Error: failed to log-out.')

        sprint(
            '{} messages were successfully written in resulting file. Done!'.
            format(count))
示例#3
0
def checkCurChat(chatname, client):
    print("\n")

    try:
        int_chat = int(chatname)
    except:
        int_chat = 0

    if int_chat != 0:
        input_channel =  client(GetFullChannelRequest(int_chat))
        channel_id = input_channel.full_chat.id
        channel = int_chat
        print("<<<Fast checking: " + input_channel.chats[0].title + " (" + str(int_chat) + ">>>")
    else:
        response = client.invoke(ResolveUsernameRequest(chatname))
        channel_id = response.peer.channel_id
        channel = chatname
        print("<<<Fast checking: " + response.chats[0].title + " (" + response.chats[0].username + ") >>>")

    for msg in client.get_messages(channel_id, limit=1):
        if (msg != '') and not (msg is None):
            if not hasattr(msg, 'text'):
                msg.text = None
            if msg.text is None and hasattr(msg, 'entities'):
                msg.text = markdown.unparse(msg.message, msg.entities or [])
            if msg.text is None and msg.message:
                msg.text = msg.message
            textCheck(msg.text, False, 1, client)

    return channel
示例#4
0
    def isUserJoined(self, userID, channelName):
        try:
            LIMIT = 200
            channel = self.client(ResolveUsernameRequest(channelName)).chats[0]

            offset = 0
            output = []
            while True:
                participants = self.client(
                    GetParticipantsRequest(channel,
                                           ChannelParticipantsSearch(''),
                                           offset,
                                           LIMIT,
                                           hash=0))
                if not participants.users:
                    break

                offset += len(participants.users)

                for user in participants.users:
                    if userID == user.id:
                        return True
            return False
        except Exception as e:
            return 0
def add(bot, update, args):
    chat_id = update.message.chat_id
    bot.sendChatAction(chat_id, "TYPING")
    if args[0] not in channel_list:
        channel_list.append(args[0])
        try:
            response_add = client.invoke(ResolveUsernameRequest(args[0]))
            messages_add = client.get_messages(response_add.peer, limit=3000)
            for message in messages_add:
                this_url = 't.me/' + args[0] + '/' + str(message.id)
                try:
                    splitted = re.split(r"[\W']+", str(message.message))
                    for word in splitted:
                        if word.lower() in dictionary:
                            dictionary[word.lower()].append(this_url)
                        else:
                            dictionary[word.lower()] = this_url.split()
                except AttributeError:
                    pass
        except:
            bot.sendMessage(chat_id, 'آدرس کانال وارد شده اشتباه می باشد.لطفا نام کانال را بدون @ وارد کنید.')
        else:
            bot.sendMessage(chat_id, 'کانال درخواستی شما به ربات اضافه گردید.')
    else:
        bot.sendMessage(chat_id, 'کانال مورد نظر در مخازن ربات موجود می باشد.')
示例#6
0
文件: views.py 项目: Pauldic/newbot
def t_member_leech(request, username=None):
    if username:
        t_client = TinClient.getConnection(type=TinClient.TELEGRAM)
        result = t_client(ResolveUsernameRequest(
            username[1:].strip())) if username.startswith("@") else t_client(
                ResolveUsernameRequest(username.strip()))

        if len(result.users) > 0:
            user = result.users[0]

            return JsonResponse({
                'msg': 'success',
                'tuser': {
                    "first_name": user.first_name,
                    "id": user.id,
                    "username": user.username,
                    "last_name": user.last_name
                }
            })
        else:
            return JsonResponse({'msg': 'Invalid Username'}, safe=False)
    elif request.method == "POST":
        member = Member.objects.filter(member_id=request.POST['member_id'],
                                       type=Member.TELEGRAM).first()
        log.warning(member)
        if member is None:
            member = Member.objects.update_or_create(
                member_id=request.POST['member_id'],
                first_name=request.POST['first_name'],
                last_name=request.POST['last_name'],
                username=request.POST['username'],
                type=Member.TELEGRAM,
                is_blacklisted=False)

        try:
            Leech.objects.create(member=member,
                                 group=Group(id=request.POST['group_id']))
            Defaulter.objects.filter(
                member=member,
                group=Group(id=request.POST['group_id'])).delete()
        except IntegrityError as err:
            return JsonResponse({'msg': 'Something went wrong'}, safe=False)

        return JsonResponse({
            'msg': 'success',
        })
    return JsonResponse({'msg': 'Invalid Username'}, safe=False)
示例#7
0
def removeUser(client, username, channel_id=DEFAULT_CHANNEL):
    try:
        msg = removeUser_by_user(client, user=client(ResolveUsernameRequest(username)).users[0], channel_id=channel_id)
    except Exception as err:
        msg = "Attempt to kicked user @{}  from channel ({}) failed. Confirm the username is valid".format(username, channel_id)
        log.error(msg)
        log.error(err)
    return msg
示例#8
0
def addUser(client, username, channel_id=DEFAULT_CHANNEL):
    try:
        user = client(ResolveUsernameRequest(username))
        return add_user_by_id(client, user_id=user.users[0].id, channel_id=channel_id)
    except Exception as err:
        msg = "Add User @{} attempt to channel ({}) failed. Confirm the username is valid".format(username, channel_id)
        log.error(msg)
        log.error(err)
        return msg
示例#9
0
 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()
示例#10
0
 async def get_group_from_link(self, link):
     link_id = link.split("/")[-1]
     chat_grp = None
     if "joinchat" in link:
         chat_grp = await self.client(CheckChatInviteRequest(hash=link_id))
     else:
         chat_grp = await self.client(
             ResolveUsernameRequest(username=link_id))
         chat_grp = chat_grp.chats[0]
     return chat_grp
示例#11
0
def get_tg():
    client = TelegramClient('fetcher-session', config.api_id, config.api_hash)
    client.connect()

    if not client.is_user_authorized():
        client.sign_in(phone=config.phone)
        client.sign_in(code=int(input('Enter code: ')))

    channel = client(ResolveUsernameRequest(config.channel)).chats[0]

    return client, channel
示例#12
0
def get_chat_info(username, client):
    try:
        chat = client(ResolveUsernameRequest(username))
    except UsernameNotOccupiedError:
        print('Chat/channel not found!')
        sys.exit()
    result = {
        'chat_id': chat.peer.channel_id,
        'access_hash': chat.chats[0].access_hash
    }
    return result
示例#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
示例#14
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
示例#15
0
def checkCurchan(channel, client, signals_limit):
    chantitle = channel.title
    if not chantitle:
        chantitle = channel.name
    if not chantitle:
        chantitle = str(channel.id)

    global log
    if log:
        log.write("\n\n")
        log.write("------------------------------\n")
        log.write("BEGIN CHECKING CHANNEL: "+channel.title+" - " + channel.name +" - " + str(channel.id) + "\n")
        log.write("------------------------------\n")
        log.write("\n\n")

    channame = channel.name

    if not channame and channel.id != 0:
        int_chan = int(channel.id)
    else:
        int_chan = 0

    if int_chan != 0:
        try:
            input_channel =  client(GetFullChannelRequest(int_chan))
            channel_id = input_channel.full_chat.id
        except Exception as e:
            print(str(e))
            return None
    else:
        try:
            response = client.invoke(ResolveUsernameRequest(channame))
            channel_id = response.peer.channel_id
        except Exception as e:
            print(str(e))
            return None

    if signals_limit > 0:
        for msg in client.get_messages(channel_id, limit=signals_limit):
            if (msg != '') and not (msg is None):
                if not hasattr(msg, 'text'):
                    msg.text = None
                if msg.text is None and hasattr(msg, 'entities'):
                    msg.text = markdown.unparse(msg.message, msg.entities or [])
                if msg.text is None and msg.message:
                    msg.text = msg.message
                separateCheck(msg.text, chantitle, channel.rating, dateFix(msg.date), client)

    return client.get_input_entity(channel_id)
示例#16
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
示例#17
0
 def get_chat_info(self, username):
     """
     Функция для получения информации о чате
     :param username: имя пользователя
     :return: словарь c chat_id и access_hash
     """
     try:
         chat = self.client(ResolveUsernameRequest(username))
     except UsernameNotOccupiedError:
         print('Chat/channel not found!')
         sys.exit()
     result = {
         'chat_id': chat.peer.channel_id,
         'access_hash': chat.chats[0].access_hash
     }
     return result
示例#18
0
async def async_get_channel_msgs(channel_name,
                                 limit=3,
                                 offset_id=0,
                                 offset_date=None,
                                 max_id=0,
                                 min_id=0):
    channel = redis_utils.get_channel(channel_name)
    if not channel:
        channel = await client(ResolveUsernameRequest(channel_name))
        redis_utils.save_channel(channel_name, channel)
    result = await client(
        messages.GetHistoryRequest(peer=channel,
                                   limit=limit,
                                   offset_id=offset_id,
                                   offset_date=offset_date,
                                   add_offset=0,
                                   max_id=max_id,
                                   min_id=min_id,
                                   hash=0))
    return result
示例#19
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
示例#20
0
# Bot settings
token = "<botapi_token>"
bot_id = token.split(":")[0] 
chat_username = "******"
sorry_message = "Hello, {}! You were excluded from the conversation due to {} daytime inactivity. If you still want to be in the group, come back: @{}. You can here apply for disabling auto-kick you."
admin_id = <admin_id>
time_by = 1 # days
bot = telebot.TeleBot(token)

while not client.is_user_authorized():
    client.send_code_request(telethon_account)
    bot.send_message(admin_id, "Read-only filtering bot waiting authorization. Enter confirmation code in bot console.") # TODO: Make less security by entering code in bot
    client.sign_in(telethon_account, input("CODE: "))

# Chat id
chat_id = client(ResolveUsernameRequest(chat_username)).peer.channel_id

if not os.path.isfile("messages.db"):
    conn = sqlite3.connect('messages.db', check_same_thread=False, timeout=2)
    cursor = conn.cursor()
    cursor.execute('CREATE TABLE messages (id INTEGER PRIMARY KEY, last_date DATETIME, ignore BOOL)')
    conn.commit()
    print("[i] Create database.")
else:
    conn = sqlite3.connect('messages.db', check_same_thread=False, timeout=2)
    cursor = conn.cursor()

def bot_chat_id(chat_id):
    return int("-100" + str(chat_id))

def check_chat(message):
from telethon import TelegramClient
from telethon.tl.functions.contacts import ResolveUsernameRequest

#this fields should be provided from my.telgram.com
api_id =
api_hash =

client = TelegramClient('session_name', api_id, api_hash)
client.start()
print('started')
# print(client.get_me().stringify())

dictionary = {}
channel_list = ['ebookonline', 'YarAmoozan', 'eng_books', 'bestsellers_book', 'dl_ketab', 'ketabkhanichanel']
for channel_name in channel_list:
    response = client.invoke(ResolveUsernameRequest(channel_name))
    messages = client.get_messages(response.peer, limit=3000)
    # print(messages[0].stringify())

    for message in messages:
        this_url = 't.me/' + channel_name + '/' + str(message.id)
        try:
            splitted = re.split(r"[\W']+", str(message.message))
            for word in splitted:
                if word.lower() in dictionary:
                    dictionary[word.lower()].append(this_url)
                else:
                    dictionary[word.lower()] = this_url.split()
        except AttributeError:
            pass
示例#22
0
from telethon.tl.types import ChannelAdminLogEventsFilter
from telethon.tl.types import InputUserSelf
from telethon.tl.types import InputUser
api_id = 1135557
api_hash = 'b00c96e8406d2d404d353394cd90f05a'
phone = '+918299446752'

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

if not client.is_user_authorized():
    client.send_code_request(phone_number)
    client.sign_in(phone_number, input('Enter the code: '))

channel = client(ResolveUsernameRequest('MY_CHANNEL'))  # Your channel username

user = client(
    ResolveUsernameRequest('Username'))  # Your channel admin username
admins = [
    InputUserSelf(),
    InputUser(user.users[0].id, user.users[0].access_hash)
]  # admins
admins = []  # No need admins for join and leave and invite filters

filter = None  # All events
filter = ChannelAdminLogEventsFilter(True, False, False, False, True, True,
                                     True, True, True, True, True, True, True,
                                     True)
cont = 0
list = [0, 100, 200, 300]
示例#23
0
def get_channel_users(channel_name):
    result = []
    offset = 0
    limit = 100

    channel = client(ResolveUsernameRequest(channel_name))

    while True:
        participants = client(
            GetParticipantsRequest(channel,
                                   ChannelParticipantsSearch(''),
                                   offset,
                                   limit,
                                   hash=0))
        if not participants.users:
            break

        for _user in participants.users:
            if type(_user.status) is UserStatusOffline:
                result.append({
                    'id': _user.id,
                    'bot': _user.bot,
                    'status': _user.status.was_online.isoformat()
                })
            elif type(_user.status) is UserStatusLastWeek:
                result.append({
                    'id': _user.id,
                    'bot': _user.bot,
                    'status': 'week'
                })
            elif type(_user.status) is UserStatusLastMonth:
                result.append({
                    'id': _user.id,
                    'bot': _user.bot,
                    'status': 'month'
                })
            elif type(_user.status) is UserStatusOffline:
                result.append({
                    'id': _user.id,
                    'bot': _user.bot,
                    'status': 'offline'
                })
            elif type(_user.status) is UserStatusOnline:
                result.append({
                    'id': _user.id,
                    'bot': _user.bot,
                    'status': 'online'
                })
            elif type(_user.status) is UserStatusRecently:
                result.append({
                    'id': _user.id,
                    'bot': _user.bot,
                    'status': 'recently'
                })
            else:
                result.append({
                    'id': _user.id,
                    'bot': _user.bot,
                    'status': 'empty'
                })

        offset += len(participants.users)

    return result
示例#24
0
    def handle(self, *args, **options):
        print("Started:", datetime.now())

        telegram_api = TelegramApi()
        sys_sender_client = telegram_api.get_sys_sender_client()

        for user in User.objects.all():
            print("user:"******"collection:", collection)

                try:
                    sources = collection.source_set.all()

                    sleep(1)
                    destination_chan = telegram_api.get_dest_channel(
                        user_client, sys_sender_client,
                        collection.destination_data['id'], sources)
                except:
                    continue

                for source in sources:
                    try:
                        try:
                            src = Source.objects.get(
                                id=source.id,
                                last_fm_time__gt=datetime.now().timestamp() -
                                30,
                                are_collecting=True)
                            if src.are_collecting:
                                continue
                            else:
                                source.are_collecting = True
                                source.save()
                        except:
                            source.are_collecting = True
                            source.save()

                        print("source:", source)

                        try:
                            channel = telegram_api.get_channel(
                                sys_sender_client, source.source_data['id'])

                        except ValueError:
                            sys_sender_client(
                                ResolveUsernameRequest(
                                    source.source_data['username']))
                            channel = telegram_api.get_channel(
                                sys_sender_client, source.source_data['id'])

                        sleep(1)
                        try:
                            total, messages, senders = user_client.get_message_history(
                                channel, limit=20)

                        except ChannelInvalidError:
                            try:
                                print("ChannelInvalidError:",
                                      source.source_data['username'])
                                user_client(
                                    ResolveUsernameRequest(
                                        source.source_data['username']))
                                total, messages, senders = user_client.get_message_history(
                                    channel, limit=20)

                            except:
                                source.are_collecting = False
                                source.save()
                                continue

                        messages = messages[::
                                            -1]  # reversing list to be asc (because telegram desc mid)

                        for msg in messages:
                            if type(msg) is Message:
                                if msg.date.timestamp(
                                ) > source.last_fm_time.timestamp():
                                    print("msg:", msg.id)

                                    sys_sender_client(
                                        ForwardMessagesRequest(
                                            from_peer=channel,
                                            id=[msg.id],
                                            to_peer=destination_chan,
                                            silent=True))

                                    source.last_fm_time = msg.date
                                    source.last_fm_id = msg.id
                                    source.save()

                        source.are_collecting = False
                        source.save()
                    except:
                        source.are_collecting = False
                        source.save()
        self.stdout.write("End of work!")
示例#25
0
 def resolve_username(self, username):
     result = self.invoke(ResolveUsernameRequest(username))
     if result:
         return result
     else:
         return "Cannot resolve given username. Ensure provided username is valid."
示例#26
0
def join_channel(channel_name):
    channel = client(ResolveUsernameRequest(channel_name))
    client(JoinChannelRequest(channel))

    return 0
示例#27
0
  async def EVENTER(event):
   event.original_update=event.original_update
   if type(event.original_update)is not UpdateShortMessage:
    if hasattr(event.original_update.message,'reply_markup')and type(event.original_update.message.reply_markup)is ReplyInlineMarkup:
     RQForm=MUFilter(event.original_update.message.reply_markup)
     if RQForm is not None:
      if MUFilterT(event.original_update.message.reply_markup) is None:
       if RFORMER2(RQForm).find('/vc/')>0:
        await event.message.click(2)
       else:
        print (num+"..rewarding\r")
        #ScreenMessage(Fore.GREEN+'      Requesting reward')
        UravxBuCwNMpYWTzKhcy=20
        CompteurSUC=0
        while True:
         (RQCode,RQText)=RFORMER(RQForm)
         MFINDER=BeautifulSoup(RQText,'html.parser')
         cc=MFINDER.find('div',{'class':'g-recaptcha'})
         tt=MFINDER.find('div',{'id':'headbar'})
         if RQCode==302:
          print(num+"..ok\r")
          #sys.stdout.write(Fore.MAGENTA+'[%s] STATUS: %s (%d)\r'%(datetime.datetime.now().strftime("%H:%M:%S"),'FALSE' if cc is not None else 'TRUE',CompteurSUC))
          break
         elif RQCode==200 and cc is None and tt is not None:
          TTCode=tt.get('data-code')
          TTime=tt.get('data-timer')
          TToken=tt.get('data-token')
          await event.message.click(2)
         #requests.post('http://bch.dogeclick.com/reward',data={'code':TTCode,'token':TToken},headers=BROWSER,allow_redirects=False)
          break
         elif RQCode==200 and cc is not None:
          await event.message.click(2)
          time.sleep(10)
          print(num+"..ok\r")
          #sys.stdout.write(Fore.MAGENTA+'[%s] STATUS: %s (%d)\r'%(datetime.datetime.now().strftime("%H:%M:%S"),'FALSE' if cc is not None else 'TRUE',CompteurSUC))
         CompteurSUC+=1
         time.sleep(3)
      elif MUFilterT(event.original_update.message.reply_markup) is True:
       print(num)
       if RFORMER2(RQForm).find('/jc/') >0:
        await event.message.click(3)
       else:
        username = RFORMER2(RQForm).replace('https://telegram.me/', '')
        try:
         papa = await event.client(ResolveUsernameRequest(username))
        except FloodWaitError as e :
         await PROFILER.send_message('BitcoinClick_bot','/visit')
         return
         time.sleep(3)
         #VWate(e.seconds,num)
        except UsernameNotOccupiedError:
         await event.message.click(3)
        except UsernameInvalidError:
         await event.message.click(3)
        #papa = await event.client(ResolveUsernameRequest(username))
        #ScreenMessage(Fore.BLUE+username)
        #sys.stdout.write(Fore.GREEN+'[%s]: %s (%s)\r'%(datetime.datetime.now().strftime("%H:%M:%S"),'Wait joining Channel', username))

        try:
         await event.client(JoinChannelRequest(InputPeerChannel(papa.chats[0].id, papa.chats[0].access_hash)))
        except FloodWaitError as e:
         await PROFILER.send_message('BitcoinClick_bot','/visit')
         #VWate(e.seconds,num)
         #await event.client(JoinChannelRequest(InputPeerChannel(papa.chats[0].id, papa.chats[0].access_hash)))
        except ChannelsTooMuchError as c:
         await main()
         try:
          await event.client(JoinChannelRequest(InputPeerChannel(papa.chats[0].id, papa.chats[0].access_hash)))
         except ChannelsTooMuchError:
          await PROFILER.send_message('BitcoinClick_bot','/visit')
        except ChannelPrivateError:
         await event.message.click(1)
        await event.message.click(1)
        time.sleep(2)
      elif MUFilterT(event.original_update.message.reply_markup) is False:
       try:
        print(num+"..ok\r")
        #print(RFORMER2(RQForm))
        await boter(RFORMER2(RQForm))
       except UsernameNotOccupiedError:
        await event.message.click(2)
       except ChatWriteForbiddenError:
        await event.message.click(2)
       except StartParamInvalidError:
        await event.message.click(2)
       except ValueError:
        await event.message.click(2)  
       time.sleep(2)
示例#28
0
        async def EVENTER(event):
            event.original_update = event.original_update
            if type(event.original_update) is not UpdateShortMessage:
                if (hasattr(event.original_update.message, 'reply_markup')
                        and type(event.original_update.message.reply_markup) is
                        ReplyInlineMarkup):
                    RQForm = MUFilter(
                        event.original_update.message.reply_markup)
                    if RQForm is not None:
                        if (MUFilterT(
                                event.original_update.message.reply_markup) is
                                None):
                            ScreenMessage(Fore.GREEN +
                                          '      Requesting reward')
                            UravxBuCwNMpYWTzKhcy = 20
                            CompteurSUC = 0
                            while True:
                                (RQCode, RQText) = RFORMER(RQForm)
                                MFINDER = BeautifulSoup(RQText, 'html.parser')
                                cc = MFINDER.find('div',
                                                  {'class': 'g-recaptcha'})
                                tt = MFINDER.find('div', {'id': 'headbar'})
                                if RQCode == 302:
                                    sys.stdout.write(
                                        Fore.MAGENTA +
                                        '[%s] STATUS: %s (%d)\r' % (
                                            datetime.datetime.now().strftime(
                                                "%H:%M:%S"),
                                            'FALSE'
                                            if cc is not None else 'TRUE',
                                            CompteurSUC,
                                        ))
                                    break
                                elif RQCode == 200 and cc is None and tt is not None:
                                    TTCode = tt.get('data-code')
                                    TTime = tt.get('data-timer')
                                    TToken = tt.get('data-token')
                                    await event.message.click(2)
                                    break
                                elif RQCode == 200 and cc is not None:
                                    await event.message.click(2)
                                    time.sleep(10)
                                    sys.stdout.write(
                                        Fore.MAGENTA +
                                        '[%s] STATUS: %s (%d)\r' % (
                                            datetime.datetime.now().strftime(
                                                "%H:%M:%S"),
                                            'FALSE'
                                            if cc is not None else 'TRUE',
                                            CompteurSUC,
                                        ))
                                CompteurSUC += 1
                                time.sleep(3)
                        elif (MUFilterT(
                                event.original_update.message.reply_markup) is
                              True):
                            username = RQForm.replace('https://t.me/', '')
                            papa = await event.client(
                                ResolveUsernameRequest(username))
                            ScreenMessage(Fore.BLUE + username)
                            sys.stdout.write(Fore.GREEN + '[%s]: %s (%s)\r' % (
                                datetime.datetime.now().strftime("%H:%M:%S"),
                                'Wait joining Channel',
                                username,
                            ))

                            try:
                                await event.client(
                                    JoinChannelRequest(
                                        InputPeerChannel(
                                            papa.chats[0].id,
                                            papa.chats[0].access_hash)))
                            except FloodWaitError as e:
                                VWate(e.seconds)
                                await event.client(
                                    JoinChannelRequest(
                                        InputPeerChannel(
                                            papa.chats[0].id,
                                            papa.chats[0].access_hash)))
                            except ChannelsTooMuchError as c:
                                await main()
                                await event.client(
                                    JoinChannelRequest(
                                        InputPeerChannel(
                                            papa.chats[0].id,
                                            papa.chats[0].access_hash)))
                            except ChannelPrivateError:
                                await event.message.click(1)
                            await event.message.click(1)
                            time.sleep(2)
                        elif (MUFilterT(
                                event.original_update.message.reply_markup) is
                              False):
                            try:
                                await boter()
                            except UsernameNotOccupiedError:
                                await event.message.click(2)
                            except ChatWriteForbiddenError:
                                await event.message.click(2)
                            except StartParamInvalidError:
                                await event.message.click(2)
                            except ValueError:
                                await event.message.click(2)
                            time.sleep(2)
    def _get_channel(self):
        """ Returns telethon.tl.types.Channel object resolved from chat_name
            at Telegram server
        """
        name = self.settings.chat_name

        # For private channels try to resolve channel peer object from its invitation link
        # Note: it will only work if the login user has already joined the private channel.
        # Otherwise, get_entity will throw ValueError
        if name.startswith(JOIN_CHAT_PREFIX_URL):
            self.logger.debug('Trying to resolve as invite url.')
            try:
                peer = self.get_entity(name)
                if peer:
                    sprint('Invitation link "{}" resolved into channel id={}'.
                           format(name, peer.id))
                    return peer
            except ValueError as ex:
                self.logger.debug(
                    'Failed to resolve "%s" as an invitation link. %s',
                    self.settings.chat_name,
                    ex,
                    exc_info=self.logger.level > logging.INFO)

        if name.startswith('@'):
            name = name[1:]
            self.logger.debug('Trying ResolveUsernameRequest().')
            try:
                peer = self(ResolveUsernameRequest(name))
                if peer.chats is not None and peer.chats:
                    sprint('Chat name "{}" resolved into channel id={}'.format(
                        name, peer.chats[0].id))
                    return peer.chats[0]
                if peer.users is not None and peer.users:
                    sprint('User name "{}" resolved into channel id={}'.format(
                        name, peer.users[0].id))
                    return peer.users[0]
            except (UsernameNotOccupiedError, UsernameInvalidError) as ex:
                self.logger.debug('Failed to resolve "%s" as @-chat-name. %s',
                                  self.settings.chat_name,
                                  ex,
                                  exc_info=self.logger.level > logging.INFO)

        # Search in dialogs first, this way we will find private groups and
        # channels.
        self.logger.debug('Fetch logged in user`s dialogs')
        dialogs_count = self.get_dialogs(0).total
        self.logger.info('%s user`s dialogs found', dialogs_count)
        dialogs = self.get_dialogs(limit=None)
        self.logger.debug('%s dialogs fetched.', len(dialogs))
        for dialog in dialogs:
            if dialog.name == name:
                sprint('Dialog title "{}" resolved into channel id={}'.format(
                    name, dialog.entity.id))
                return dialog.entity
            if hasattr(dialog.entity,
                       'username') and dialog.entity.username == name:
                sprint(
                    'Dialog username "{}" resolved into channel id={}'.format(
                        name, dialog.entity.id))
                return dialog.entity
            if name.startswith('@') and dialog.entity.username == name[1:]:
                sprint(
                    'Dialog username "{}" resolved into channel id={}'.format(
                        name, dialog.entity.id))
                return dialog.entity
        self.logger.debug('Specified chat name was not found among dialogs.')

        raise ValueError(
            'Failed to resolve dialogue/chat name "{}".'.format(name))
示例#30
0
sys.exit(1)

print(total)
print(len(messages))
print(len(senders))

for i, m in enumerate(messages):
    print(m.stringify())
    print(senders[i].stringify())
    print(m.id)
    break

# sys.exit(1)
from telethon.tl.functions.contacts import ResolveUsernameRequest

result = client(ResolveUsernameRequest('mp3downloads1'))
print(result.stringify())
found_chats = result.chats
found_users = result.users

#print(found_chats)
#print(found_users)

# from telethon.tl.functions.messages import GetDialogsRequest
# from telethon.tl.types import InputPeerEmpty
# from time import sleep

# dialogs = []
# users = []
# chats = []