def connect_user(creds): # try connecting with session_id, otherwise authenticate try: session = StringSession(creds['session_id']) client = TelegramClient(session, creds['api_id'], creds['api_hash']) client.start() if client.is_connected(): logger.info('Client is connected using session.') return (client, False) else: logger.error('Client failed to connect using existing session') raise Exception('Error occured - client is not connected') except KeyError: logger.info('Session is not found. Trying to authenticate user.') start_params = (creds['phone'], ) if creds.get('phone') else tuple() client = TelegramClient(StringSession(), creds['api_id'], creds['api_hash']) client.start(*start_params) if client.is_connected(): logger.info('Client is authenticated and connected.') return (client, True) else: logger.error('Client failed to connect using authentication') raise Exception('Error occured - client is not connected')
class ProcessUpload(Thread): def __init__(self, name, client, q_request=None): Thread.__init__(self) self.name = name self.client = TelegramClient(client._session_name, client.api_id, client.api_hash, update_workers=None, spawn_read_thread=False) self.q_request = q_request self.result = None def run(self): # print('Thread %s started' % self.name) time.sleep(random.randrange(20, 200, 10) * 0.001) if not self.client.is_connected(): self.client.connect() while True: request = self.q_request.get() if request is None: break self.result = None # time.sleep(random.randrange(20, 100, 1) * 0.001) self.result = self.client.invoke(request) if self.result is False: break self.q_request.task_done() self.client.disconnect() # print('Thread {0} stopped result {1}'.format(self.name, self.result)) return
async def get_sign_in_results(api_id, api_hash, code, phone_number, password, session_name, loop=None): """Tries to sign-in in Telegram with given parameters. Notes: Automatically creates .session file for further sign-ins. Args: api_id (str/int): Telegram API id. api_hash (str): Telegram API hash. code (str/int): A confirmation code. phone_number (str): A phone number connected to such id/hash pair. password (str): 2FA password (if needed). session_name (str): A name of the current session. loop (asyncio.windows_events._WindowsSelectorEventLoop, optional): An event loop. Returns: A string describing the results of sign-in. """ try: client = TelegramClient(session_name, api_id, api_hash, loop=loop) await client.connect() except (ApiIdInvalidError, ValueError): log_line("Unsuccessful sign-in! Wrong API.") return "wrong api" except OSError: log_line("No Internet connection.") return "no internet" try: if not await client.is_user_authorized(): await client.send_code_request(phone_number) try: await client.sign_in(phone_number, code) except SessionPasswordNeededError: await client.sign_in(phone_number, password=password) if not await client.is_user_authorized(): raise PhoneCodeInvalidError(request=None) except ApiIdInvalidError: log_line("Unsuccessful sign-in! Wrong API.") return "wrong api" except PhoneCodeInvalidError: log_line("Unsuccessful sign-in! Need code.") return "need code" except PasswordHashInvalidError: log_line("Unsuccessful sign-in! Need password.") return "need password" except (PhoneNumberInvalidError, TypeError): log_line("Unsuccessful sign-in! Need phone.") return "need phone" except FloodWaitError as err: log_line(f'Unsuccessful sign-in! {err.message}') return f'need wait for {err.seconds}' finally: if client.is_connected(): await client.disconnect() log_line("Successful sign-in.") return "success"
async def auth_phone(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) phone = request.json['phone'] #telegram auth try: client = TelegramClient( f'{telegram_sessions_path}/phone_{phone}.session', os.environ.get('TELEGRAM_API_ID'), os.environ.get('TELEGRAM_API_HASH'), loop=loop) if client.is_connected() is False: await client.connect() if await client.is_user_authorized() is False: code = await client.send_code_request(phone, force_sms=True) await client.disconnect() return jsonify( status=True, phone_code_hash=code.phone_code_hash, message= f'Berhasil mengirimkan kode OTP verifikasi ke nomor {phone}') else: user = await client.get_me() await client.disconnect() return jsonify(status=True, user={ 'id': user.id, 'username': user.username, 'first_name': user.first_name, 'last_name': user.last_name, 'phone': user.phone, 'access_hash': user.access_hash }, message='Berhasil mendapatkan data user Telegram') except (PhoneNumberInvalidError, FloodWaitError) as ex: await client.disconnect() if isinstance(ex, PhoneNumberInvalidError): return jsonify(status=False, message=f'Format nomor HP tidak valid'), 500 elif isinstance(ex, FloodWaitError): return jsonify( status=False, message= f'Kode verifikasi OTP menunggu {ex.seconds} detik untuk pengiriman selanjutnya' ), 500 else: return jsonify(status=False, message=str(ex)), 500
class TelegramDriver: def __init__(self, config, bot_dialog_config): self.config = config self.bot_dialog_config = bot_dialog_config self.client = None self.logger = logging.getLogger() self.updater_telegram_channel = Updater( self.config["crypto-bot"]["token"]) def log_started(self): self.send_to_channel(self.config["crypto-bot"]["channel_id"], self.bot_dialog_config["Start"]) self.send_to_channel(self.config["crypto-bot"]["channel_id"], self.bot_dialog_config["Ready"]) def first_connection(self): self.client.send_code_request( self.config["telegram-api"]["phone_number"]) myself = self.client.sign_in( self.config["telegram-api"]["phone_number"], input('Enter code: ')) self.logger.info(myself.stringify()) def connect(self): self.client = TelegramClient("User", self.config["telegram-api"]["api_id"], self.config["telegram-api"]["api_hash"], update_workers=1, spawn_read_thread=False) self.client.connect() if self.client.is_connected(): if not self.client.is_user_authorized(): self.first_connection() self.logger.info("Client connected to Telegram.") else: self.logger.error("Client not connected") def send_to_channel(self, channel_id, msg): self.updater_telegram_channel.bot.send_message(chat_id=channel_id, text=msg) def add_handler_update(self, callback): self.client.add_update_handler(callback) def call_idle(self): self.client.idle() self.send_to_channel(self.config["crypto-bot"]["channel_id"], self.bot_dialog_config["Stop"]) def disconnect(self): self.client.disconnect()
async def update_user_photo(photo): client = TelegramClient( 'upd phototemp', TELEGRAM_API_ID, TELEGRAM_API_HASH, ) if not client.is_connected(): await client.start(PHONE) await client(DeletePhotosRequest(await client.get_profile_photos('me'))) await client(UploadProfilePhotoRequest(await client.upload_file(photo))) await client.disconnect() print('finish')
async def logout(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) if 'user_id' not in request.json or ObjectId.is_valid( request.json['user_id']) is False: return jsonify(status=False, message='Object Id tidak valid'), 500 user_id = request.json['user_id'] phone = request.json['phone'] chat_emotion = mongo.db.telegram_chat_emotions.find_one({ 'user_id': ObjectId(user_id), 'phone': phone }) if chat_emotion is None: return jsonify(status=False, is_authorized=False, message='Belum melakukan login ke dalam Telegram'), 401 try: client = TelegramClient( f'{telegram_sessions_path}/phone_{chat_emotion["phone"]}.session', os.environ.get('TELEGRAM_API_ID'), os.environ.get('TELEGRAM_API_HASH'), loop=loop) if client.is_connected() is False: await client.connect() if await client.is_user_authorized() is True: await client.log_out() await client.disconnect() return jsonify(status=True, message='Berhasil melakukan logout dari Telegram') return jsonify( status=True, message='Pengguna belum melakukan login ke dalam Telegram') except Exception as ex: return jsonify(status=False, message=str(ex)), 500
async def update_channel_photo(photo, channel_link): client = TelegramClient( 'upd phototemp', TELEGRAM_API_ID, TELEGRAM_API_HASH, ) if not client.is_connected(): await client.start(PHONE) dialogs = await client.get_dialogs() channel_entity = await client.get_entity(channel_link) upload_file_result = await client.upload_file(file=photo) try: result = await client( EditPhotoRequest(channel=channel_entity, photo=upload_file_result)) except BaseException as e: print(e) await client.disconnect() print('finish')
async def two_step_verification(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) user_id = request.json['user_id'] phone = request.json['phone'] #phone_code_hash= request.json['phone_code_hash'] password = request.json['password'] is_chat_emotions_exist = mongo.db.telegram_chat_emotions.find_one({ 'user_id': ObjectId(user_id), 'phone': phone }) try: client = TelegramClient( f'{telegram_sessions_path}/phone_{phone}.session', os.environ.get('TELEGRAM_API_ID'), os.environ.get('TELEGRAM_API_HASH'), loop=loop) if client.is_connected() is False: await client.connect() if await client.is_user_authorized() is False: await client.sign_in(phone, password=password) await client.disconnect() #mongo check phone exist if is_chat_emotions_exist is None: result = mongo.db.telegram_chat_emotions.insert_one({ 'user_id': ObjectId(user_id), 'phone': phone, 'emotions': None }) if result.inserted_id is None: return jsonify( status=False, message= f'Terjadi kesalahan pada server, gagal login menggunakan Telegram dengan nomor {phone}' ), 500 return jsonify( status=True, verify_success=True, message= f'Berhasil melakukan login ke dalam Telegram dengan nomor {phone}' ) else: await client.disconnect() return jsonify(status=False, verify_success=False, message=f'Nomor {phone} sudah terverifikasi') except: await client.disconnect() return jsonify(status=False, message='Password anda tidak valid'), 500
class Telegram: def __init__(self, connect_on_start=True): try: # Load config file filepath = os.path.realpath( os.path.join(os.getcwd(), os.path.dirname(__file__))) configFile = filepath + "/telegram_config.json" #Parse details from config file with open(configFile) as f: self.config = json.load(f) self.username = self.config["USERNAME"] self.app_id = int(self.config["APP_API_ID"]) self.api_hash = self.config["APP_API_HASH"] self.phone = self.config["PHONE"] except: print( "You must provide a telegram_config.json file with proper credentials." ) # Create the client self.client = TelegramClient(self.username, self.app_id, self.api_hash) if connect_on_start: self.connect() async def connect(self): self.client.start() print("Client Created") # Ensure you're authorized if not await self.client.is_user_authorized(): self.client.send_code_request(self.phone) try: self.client.sign_in(self.phone, input('Enter the code: ')) except SessionPasswordNeededError: self.client.sign_in(password=input('Password: '******'with' destroys the client after the code block with self.client: #I don't know async lol, this just runs once self.client.loop.run_until_complete(self.connect()) #This contains a loop to poll for messages self.client.loop.run_until_complete( self.scrape_channel(telegram_url)) async def scrape_channel(self, telegram_url): self.channel = await self.client.get_entity(telegram_url) offset_id = 0 limit = 100 all_messages = [] total_messages = 0 total_count_limit = 1000 while True: print("Current Offset ID is:", offset_id, "; Total Messages:", total_messages) history = await self.client( GetHistoryRequest(peer=self.channel, offset_id=offset_id, offset_date=None, add_offset=0, limit=limit, max_id=0, min_id=0, hash=0)) if not history.messages: break messages = history.messages for message in messages: all_messages.append(message.to_dict()) offset_id = messages[len(messages) - 1].id total_messages = len(all_messages) if total_count_limit != 0 and total_messages >= total_count_limit: break with open('channel_messages.json', 'w') as outfile: json.dump(all_messages, outfile, indent=4, sort_keys=True, default=str)
async def get_chat_emotions(user_id, phone): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) if ObjectId.is_valid(user_id) is False: return jsonify(message='Object Id tidak valid'), 500 chat_emotions = mongo.db.telegram_chat_emotions.find_one({ 'user_id': ObjectId(user_id), 'phone': phone }) if chat_emotions is None: return jsonify(status=False, is_authorized=False, message='Belum melakukan login ke dalam Telegram') try: client = TelegramClient( f'{telegram_sessions_path}/phone_{chat_emotions["phone"]}.session', os.environ.get('TELEGRAM_API_ID'), os.environ.get('TELEGRAM_API_HASH'), loop=loop) if client.is_connected() is False: await client.connect() if await client.is_user_authorized() is False: return jsonify(status=False, is_authorized=False, message='Belum melakukan login ke dalam Telegram') else: entities = await client.get_dialogs() messages = [] for entity in entities: sender = await client.get_entity(entity) if (isinstance(sender, User) and sender.bot is False and sender.first_name != 'Telegram'): message_container = client.iter_messages(entity) async for message_object in message_container: if (message_object.out is True and message_object.message is not None and message_object.message != ''): chat_with = await client.get_entity( message_object.peer_id) messages.append({ 'chat_with': { 'user_id': chat_with.id, 'first_name': chat_with.first_name, 'phone': '+' + str(chat_with.phone) }, 'data': { 'message_id': message_object.id, 'text': message_object.message, 'timestamps': message_object.date, 'is_out_message': message_object.out }, 'emotions': {} }) await client.disconnect() translator = Translator() for message in messages: translated = translator.translate(message['data']['text'], src='id') emotions = te.get_emotion(translated.text) message['emotions'] = { 'angry': emotions['Angry'], 'fear': emotions['Fear'], 'happy': emotions['Happy'], 'sad': emotions['Sad'], 'surprise': emotions['Surprise'], } emotions_total = { 'angry': 0, 'fear': 0, 'happy': 0, 'sad': 0, 'surprise': 0 } for message in messages: for key in message['emotions']: if message['emotions'][key] > 0: emotions_total[key] += 1 # if chat_emotions['emotions'] != emotions_total: # result= mongo.db.telegram_chat_emotions.find_one_and_update( # { 'user_id': ObjectId(user_id) }, # { '$set': { 'emotions': dict(emotions_total) } } # ) # if result is None: # return jsonify(status= False, message= 'Terjadi kesalahan pada server, gagal menyimpan data emosi teks pengguna'), 500 return jsonify( status=True, chat_emotions={ 'emotions_total': emotions_total, 'messages': messages }, message='Berhasil mendapatkan riwayat pesan telegram') except (FloodWaitError, Exception) as ex: await client.disconnect() if isinstance(ex, FloodWaitError): return jsonify( status=False, message= f'Kode verifikasi OTP menunggu {ex.seconds} detik untuk pengiriman selanjutnya' ), 500 else: return jsonify(status=False, message=str(ex)), 500
def post(self): phone = parse_phone(self.request.data.get('phone')) if phone == self.user['phone_number']: user = self.get() if user.get('authorized', True): return user code = self.request.data.get('code') password = self.request.data.get('password') phone_code_hash = None if not phone: raise HTTP_400('Invalid `phone` value') msg = None is_authorized = False try: client = TelegramClient( os.path.join(config.get('paths', 'sessions'), parse_phone(phone)), config.get('telegram', 'api_id'), config.get('telegram', 'api_hash')) if not client.is_connected(): client.connect() # check if already authorized if client.is_user_authorized(): self._set_authorized(phone) is_authorized = True raise AuthorizedSuccessfully() # 2nd step if code: t = db.get_interim_state(phone) if not t: raise HTTP_400('Invalid `phone` value') phone_code_hash = t['phone_code_hash'] resp = client.sign_in(phone, code, password=password, phone_code_hash=phone_code_hash) # 2nd/3rd step success if code and client.is_user_authorized(): self._set_authorized(phone) is_authorized = True raise AuthorizedSuccessfully() # 1st step if not resp.phone_registered: db.del_interim_state(phone) raise HTTP_400('Phone number is not registered') db.set_interim_state(phone, { 'provider': 'Telegram', 'phone_code_hash': resp.phone_code_hash }) return {'authorized': False, 'code': True} except AuthorizedSuccessfully: pass except SessionPasswordNeededError: return {'authorized': False, '2fa': True} except (PhoneNumberBannedError, PhoneNumberInvalidError, PhoneCodeExpiredError, PhoneCodeInvalidError, PhoneCodeEmptyError, PhonePasswordProtectedError) as e: db.del_interim_state(phone) client.log_out() raise HTTP_400(str(e)) except (FloodWaitError, FloodError, PhonePasswordFloodError) as e: db.del_interim_state(phone) raise HTTP_400(str(e)) except HTTPError: # passthru raise except Exception as e: self.logger.error('Telegram communication error %s', e) msg = str(e) raise finally: client.disconnect() if is_authorized: return self.get() raise HTTP_500('Internal error', msg)
def messages_task(limit, user_id, group_id, message_id, numbers_list=None, use_system_numbers=False): user = User.objects.get(pk=user_id) group = TelegramGroup.objects.get(pk=group_id) message = Message.objects.get(pk=message_id) if use_system_numbers: price = settings.PRICE_USING_SYSTEM_NUMBERS active_accounts = TelegramAccount.objects.filter(system=True, confirmed=True, active=True, is_used_now=False) else: price = settings.PRICE_USING_OWN_NUMBERS # active_accounts = TelegramAccount.objects.filter(id__in=numbers_list, # user=user, # system=False, # confirmed=True, # active=True, # is_used_now=False) active_accounts = TelegramAccount.objects.filter(user=user, system=False, confirmed=True, active=True, is_used_now=False) if not active_accounts: return {'success': False, 'error': _('No active accounts left.')} messaged = 0 try: for account in active_accounts: # mark being used now, so account won't be used in other tasks account.set_is_used(True) proxy_settings = ( socks.HTTP, settings.PROXY_HOST, settings.PROXY_PORT, True, settings.PROXY_USERNAME + '-session-{}'.format(random.randint(9999, 9999999)), settings.PROXY_PASSWORD) client = TelegramClient(StringSession(account.session), account.api_id, account.api_hash, proxy=proxy_settings) # connect to Telegram try: client.connect() except Exception as e: logger.exception(e) account.set_is_used(False) continue # find not messaged contacts or with errors message_events = MessageEvent.objects.filter( Q(success=True) | Q(error__isnull=False), user=user, telegram_group=group, message=message) processed_contacts = [i.contact for i in message_events] contacts = [ c for c in TelegramContact.objects.filter( user=user, group=group).order_by('priority') if c not in processed_contacts ] # send messages to contacts for contact in contacts: if messaged >= limit: client.disconnect() account.set_is_used(False) return {'success': True, 'error': None} if user.balance <= 0: client.disconnect() account.set_is_used(False) return { 'success': False, 'error': _('Not enough funds. Please, ' 'refill your balance.') } try: if message.file: client.send_message(contact.username, message.text, file=message.file.path, link_preview=message.link_preview, parse_mode='html') else: client.send_message(contact.username, message.text, link_preview=message.link_preview, parse_mode='html') messaged += 1 user.update_balance(-price) MessageEvent.objects.create(user=user, telegram_group=group, telegram_account=account, contact=contact, success=True, message=message, price=price) # errors with account except (PeerFloodError, AuthKeyUnregisteredError, UserDeactivatedError, ChatWriteForbiddenError, UserBannedInChannelError, ChannelsTooMuchError) as e: client.disconnect() account.set_is_used(False) account.deactivate(e.__class__.__name__) break except Exception as e: MessageEvent.objects.create(user=user, telegram_group=group, contact=contact, telegram_account=account, message=message, error=e.__class__.__name__) account.update_last_used() account.set_is_used(False) if client.is_connected(): client.disconnect() return {'success': True, 'error': None} except Exception as e: logger.exception(e) return {'success': True, 'error': _('Error sending message.')}
def invites_task(limit, user_id, source_group_id, target_group_id, numbers_list=None, use_system_numbers=False): user = User.objects.get(pk=user_id) source_group = TelegramGroup.objects.get(pk=source_group_id) target_group = TelegramGroup.objects.get(pk=target_group_id) if use_system_numbers: price = settings.PRICE_USING_SYSTEM_NUMBERS active_accounts = TelegramAccount.objects.filter(system=True, confirmed=True, active=True, is_used_now=False) else: price = settings.PRICE_USING_OWN_NUMBERS # active_accounts = TelegramAccount.objects.filter(id__in=numbers_list, # user=user, # system=False, # confirmed=True, # active=True, # is_used_now=False) active_accounts = TelegramAccount.objects.filter(user=user, system=False, confirmed=True, active=True, is_used_now=False) if not active_accounts: return {'success': False, 'error': _('No active accounts left.')} invited = 0 try: for account in active_accounts: # mark being used now, so account won't be used in other tasks account.set_is_used(True) proxy_settings = ( socks.HTTP, settings.PROXY_HOST, settings.PROXY_PORT, True, settings.PROXY_USERNAME + '-session-{}'.format(random.randint(9999, 9999999)), settings.PROXY_PASSWORD) client = TelegramClient(StringSession(account.session), account.api_id, account.api_hash, proxy=proxy_settings) # connect to Telegram try: client.connect() except Exception as e: logger.exception(e) account.set_is_used(False) continue # get target group entity try: target_group_entity = client.get_input_entity( target_group.username if target_group. username else target_group.join_link) except Exception as e: logger.exception(e) client.disconnect() account.set_is_used(False) return {'success': False, 'error': _('Target Group invalid.')} # join channel joined = join_group(client, account, target_group_entity) if not joined: account.set_is_used(False) client.disconnect() continue elif isinstance(joined, dict): # means there was an error client.disconnect() return joined # find not invited contacts or with errors invites = InviteEvent.objects.filter(Q(success=True) | Q(error__isnull=False), user=user, source_group=source_group, target_group=target_group) processed_contacts = [i.contact for i in invites] contacts = [ c for c in TelegramContact.objects.filter( user=user, group=source_group).order_by('priority') if c not in processed_contacts ] # invite contacts for contact in contacts: if invited >= limit: account.set_is_used(False) client.disconnect() return {'success': True, 'error': None} if user.balance <= 0: account.set_is_used(False) client.disconnect() return { 'success': False, 'error': _('Not enough funds. Please, ' 'refill your balance.') } try: client( InviteToChannelRequest(target_group_entity, [contact.username])) invited += 1 user.update_balance(-price) InviteEvent.objects.create(user=user, source_group=source_group, target_group=target_group, telegram_account=account, contact=contact, success=True, price=price) # errors with account except (PeerFloodError, AuthKeyUnregisteredError, UserDeactivatedError, ChatWriteForbiddenError, UserBannedInChannelError, ChannelsTooMuchError) as e: logger.exception(e) account.deactivate(e.__class__.__name__) account.set_is_used(False) client.disconnect() break # critical errors, when we need to stop inviting except ChannelPrivateError as e: InviteEvent.objects.create(user=user, source_group=source_group, target_group=target_group, telegram_account=account, error=e.__class__.__name__) account.update_last_used() account.set_is_used(False) client.disconnect() return { 'success': False, 'error': _('Cannot invite to Channel, ' 'since it is private.') } except ChatIdInvalidError as e: InviteEvent.objects.create(user=user, source_group=source_group, target_group=target_group, telegram_account=account, error=e.__class__.__name__) account.update_last_used() account.set_is_used(False) client.disconnect() return { 'success': False, 'error': _('Cannot invite to Channel, ' 'since it is private.') } except ChatAdminRequiredError as e: InviteEvent.objects.create(user=user, source_group=source_group, target_group=target_group, telegram_account=account, error=e.__class__.__name__) account.update_last_used() account.set_is_used(False) client.disconnect() return { 'success': False, 'error': _('Cannot invite to Channel, ' 'since it admin rights are required.') } except InputUserDeactivatedError as e: InviteEvent.objects.create(user=user, source_group=source_group, target_group=target_group, telegram_account=account, contact=contact, error=e.__class__.__name__) account.update_last_used() except UsersTooMuchError as e: InviteEvent.objects.create(user=user, source_group=source_group, target_group=target_group, telegram_account=account, error=e.__class__.__name__) account.update_last_used() client.disconnect() return { 'success': False, 'error': _('Cannot invite to Channel, ' 'since it has already reached the ' 'maximum number of users.') } # other errors except Exception as e: InviteEvent.objects.create(user=user, source_group=source_group, target_group=target_group, telegram_account=account, contact=contact, error=e.__class__.__name__) account.update_last_used() account.set_is_used(False) if client.is_connected(): client.disconnect() return {'success': True, 'error': None} except Exception as e: logger.exception(e) return {'success': True, 'error': None}
def register_accounts(limit): registered_count = 0 fails_count = 0 while registered_count < limit: summary = get_summary() if summary is None or summary['balance'] < 0.12: fails_count += 1 continue number = get_mobile_number() if number is None: fails_count += 1 continue proxy = session.query(Proxy).first() client = TelegramClient(os.path.join(config.TELETHON_SESSIONS_DIR, '+' + str(number)), config.TELEGRAM_API_ID, config.TELEGRAM_API_HASH, proxy=(socks.HTTP, proxy.ip, proxy.port, True, proxy.username, proxy.password)) try: client.connect() client.send_code_request('+' + str(number), force_sms=True) send_code_time = datetime.datetime.now() sms = None while (datetime.datetime.now() - send_code_time).total_seconds() < 65: sms = get_sms(number) if sms: break else: time.sleep(10) if sms is None: fails_count += 1 blacklist_mobile_number(number) client.disconnect() continue try: name = get_random_first_last_names() myself = None try: myself = client.sign_up(sms, first_name=name['first'], last_name=name['last']) except PhoneNumberOccupiedError: config.logger.error( 'PhoneNumberOccupiedError, trying to login instead.') try: myself = client.sign_in('+' + str(number), sms) except Exception as e: config.logger.exception(e) fails_count += 1 if myself: registered_count += 1 client.send_message( 'llelloboss', 'Hello! This account ({}) is' ' active.'.format('+' + str(number))) account = TelegramAccount(phone_number='+' + str(number)) session.add(account) session.commit() client.disconnect() except Exception as e: config.logger.exception(e) fails_count += 1 client.disconnect() continue except Exception as e: config.logger.exception(e) if client.is_connected(): client.disconnect() fails_count += 1 for adm in config.ADMIN_IDS: bot.send_message( adm, f'Registration finished.\n' f'Registered: {registered_count}\n' f'Failed: {fails_count}')
def invite_contact(task_id): task = session.query(Task).filter(Task.id == task_id).first() accounts = session.query(TelegramAccount).filter( TelegramAccount.active == True, TelegramAccount.task == task).order_by( TelegramAccount.last_used).all() if not accounts: session.delete(task) session.commit() for adm in config.ADMIN_IDS: bot.send_message(adm, f'<code>Inviting to {task.target_group} ' f'from {task.source_group}</code> stopped.\n' f'No active accounts left.', parse_mode=ParseMode.HTML) return account = random.choice(accounts) contacts = session.query(Contact).filter( Contact.source_group == task.source_group).order_by( desc(Contact.priority)).all() invite_errors = session.query(InviteError).filter( InviteError.task == task).all() contacts_with_errors_ids = [i.contact_id for i in invite_errors] invited_contacts_ids = [c.id for c in task.invited_contacts] contacts = [ c for c in contacts if c.id not in invited_contacts_ids and c.id not in contacts_with_errors_ids ] proxy = session.query(Proxy).first() client = TelegramClient(os.path.join(config.TELETHON_SESSIONS_DIR, account.phone_number), config.TELEGRAM_API_ID, config.TELEGRAM_API_HASH, proxy=(socks.HTTP, proxy.ip, proxy.port, True, proxy.username, proxy.password)) try: client.connect() target_participants = client.get_participants(task.target_group, aggressive=True) target_participants_ids = [i.id for i in target_participants] if int(contacts[0].tg_id) not in target_participants_ids: target = int(task.target_group) if task.target_group.startswith('-') \ else task.target_group.lower() if int(client.get_me().id) not in target_participants_ids: client(JoinChannelRequest(target)) client(InviteToChannelRequest(target, [contacts[0].username])) task.invited_contacts.append(contacts[0]) account.last_used = datetime.datetime.now() session.commit() else: error = InviteError(task=task, contact=contacts[0]) session.add(error) account.last_used = datetime.datetime.now() session.commit() except PeerFloodError as e: config.logger.exception(e) account.active = False account.task = None account.error_time = datetime.datetime.now() session.commit() except UserKickedError as e: config.logger.exception(e) account.active = False account.task = None account.error_time = datetime.datetime.now() session.commit() except (AuthKeyUnregisteredError, UserDeactivatedError) as e: config.logger.exception(e) session.delete(account) session.commit() path = os.path.join(config.TELETHON_SESSIONS_DIR, '{}.session'.format(account.phone_number)) if os.path.exists(path): os.remove(path) for adm in config.ADMIN_IDS: bot.send_message( adm, f'Account {account.phone_number} had {e.__class__.__name__} ' f'and was removed.') except (UserNotMutualContactError, UserPrivacyRestrictedError) as e: config.logger.exception(e) error = InviteError(task=task, contact=contacts[0]) session.add(error) session.commit() except Exception as e: config.logger.exception(e) if client.is_connected(): client.disconnect()
async def auth_code(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) if 'user_id' not in request.json or ObjectId.is_valid( request.json['user_id']) is False: return jsonify(message='Object Id tidak valid'), 500 user_id = request.json['user_id'] phone = request.json['phone'] phone_code_hash = request.json['phone_code_hash'] otp_code = request.json['otp_code'] is_chat_emotions_exist = mongo.db.telegram_chat_emotions.find_one({ 'user_id': ObjectId(user_id), 'phone': phone }) try: client = TelegramClient( f'{telegram_sessions_path}/phone_{phone}.session', os.environ.get('TELEGRAM_API_ID'), os.environ.get('TELEGRAM_API_HASH'), loop=loop) if client.is_connected() is False: await client.connect() if await client.is_user_authorized() is False: await client.sign_in(phone, otp_code, phone_code_hash=phone_code_hash) await client.disconnect() #mongo check phone exist if is_chat_emotions_exist is None: result = mongo.db.telegram_chat_emotions.insert_one({ 'user_id': ObjectId(user_id), 'phone': phone, 'emotions': None }) if result.inserted_id is None: return jsonify( status=False, message= f'Terjadi kesalahan pada server, gagal login menggunakan Telegram dengan nomor {phone}' ), 500 return jsonify( status=True, verify_success=True, message= f'Berhasil melakukan login ke dalam Telegram dengan nomor {phone}' ) else: await client.disconnect() return jsonify(status=False, verify_success=False, message=f'Nomor {phone} sudah terverifikasi') except (SessionPasswordNeededError, PhoneCodeExpiredError, PhoneCodeInvalidError) as ex: await client.disconnect() if isinstance(ex, SessionPasswordNeededError): return jsonify( status=False, is_two_step_verification=True, message= 'Two-step verification akun milik anda dalam keadaan aktif, harap lakukan login disini' ) elif isinstance(ex, PhoneCodeExpiredError): return jsonify( status=False, message='Kode verifikasi OTP sudah tidak berlaku'), 500 elif isinstance(ex, PhoneCodeInvalidError): return jsonify(status=False, message='Kode verifikasi OTP tidak valid'), 500 else: return jsonify(status=False, message=str(ex)), 500