async def test_failed_update(text_update):
update = json.loads(text_update)
User.create(id=425606,
telegram_chat_id=2,
mode='one_note',
evernote_access_token='token',
current_notebook={
'guid': '000',
'name': 'test_notebook'
},
places={'000': 'note_guid'})
TelegramUpdate.create(user_id=425606,
request_type='text',
status_message_id=5,
message=update['message'])
dealer = EvernoteDealer()
mock_note_provider = AsyncMock()
note = Types.Note()
mock_note_provider.get_note = AsyncMock(return_value=note)
mock_note_provider.get_note.side_effect = Exception('test')
mock_telegram_api = AsyncMock()
dealer._telegram_api = mock_telegram_api
for k, handlers in dealer._EvernoteDealer__handlers.items():
for handler in handlers:
handler._note_provider = mock_note_provider
updates = dealer.fetch_updates()
for user_id, update_list in updates.items():
user = User.get({'id': user_id})
await dealer.process_user_updates(user, update_list)
failed_updates = FailedUpdate.find()
assert len(failed_updates) == 1
async def fix_failed_update(request):
await request.post()
update_id = request.POST.get('update_id')
if update_id:
updates = [FailedUpdate.get({'id': ObjectId(update_id)})]
elif not update_id and request.POST.get('all'):
updates = FailedUpdate.find()
else:
updates = []
for failed_update in updates:
await request.app.bot.handle_update({
'update_id': failed_update.id,
'message': failed_update.message
})
failed_update.delete()
return await list_failed_updates(request)
async def process_user_updates(self, user,
update_list: List[TelegramUpdate]):
start_ts = time.time()
self.logger.debug(
'Start update list processing (user_id = {0})'.format(user.id))
for update in update_list:
try:
for handler in self.__handlers[update.request_type]:
await handler.execute(user, update)
text = '✅ {0} saved ({1:.2} s)'.format(
update.request_type.capitalize(),
time.time() - start_ts)
asyncio.ensure_future(
self._telegram_api.editMessageText(
user.telegram_chat_id, update.status_message_id, text))
except TokenExpired:
asyncio.ensure_future(
self.edit_telegram_message(
user.telegram_chat_id, update.status_message_id,
'⛔️ Evernote access token is expired. Send /start to get new token'
))
except Exception as e:
self.logger.error(e, exc_info=1)
FailedUpdate.create(error=traceback.format_exc(),
**update.save_data())
asyncio.ensure_future(
self.edit_telegram_message(
user.telegram_chat_id, update.status_message_id,
'❌ Something went wrong. Please, try again'))
self.logger.debug('Cleaning up...')
for update in update_list:
for handler in self.__handlers[update.request_type]:
await handler.cleanup(user, update)
self.logger.debug(
'Done. (user_id = {0}). Processing takes {1} s'.format(
user.id,
time.time() - start_ts))
async def handle_request(self, user: User, request_type: str, message: Message):
chat_id = user.telegram_chat_id
handler = self.handlers[request_type]
reply = await self.async_send_message(chat_id, '🔄 Accepted')
status_message_id = reply['message_id']
try:
await handler.execute(
user,
status_message_id=status_message_id,
request_type=request_type,
message=message
)
except TelegramBotError as e:
FailedUpdate.create(
user_id=user.id,
request_type=request_type,
status_message_id=status_message_id,
message=message.raw,
error=traceback.format_exc()
)
await self.api.editMessageText(chat_id, status_message_id, e.message, e.reply_markup)
raise e
async def list_failed_updates(request):
failed_updates = [update.save_data() for update in FailedUpdate.find()]
params = {'failed_updates': failed_updates}
response = aiohttp_jinja2.render_template('failed_updates.html', request,
params)
return response
async def dashboard(request):
params = {'cnt_failed_updates': len(FailedUpdate.find())}
return aiohttp_jinja2.render_template('dashboard.html', request, params)