示例#1
0
async def add_permit_data(message: Message, state: FSMContext):
    data_state = await state.get_data()

    await bot.delete_message(chat_id=message.chat.id,
                             message_id=data_state['message_to_delete'])
    await bot.delete_message(chat_id=message.chat.id,
                             message_id=message.message_id)

    request = data_state['chosen_request']
    permit_id = request[1]
    request_numb = request[2]
    permit_date = request[0]
    old_permit_text = permit.get_old_permit_text_or_empty(permit_id)

    if old_permit_text == 'данных нет...':
        new_permit_text = message.text

    else:
        new_permit_text = old_permit_text + ', ' + message.text

    username = message.chat.username

    user = message.chat.username
    request[9] = updating_log('PERMIT',
                              user,
                              request,
                              update_data='Добавлен пропуск')

    try:
        result = await message.answer_sticker(sticker['go_to_table'])
        permit.clear_table()
        permit.write_new_permit(permit_id,
                                request_numb,
                                permit_date,
                                permit_text=new_permit_text)
        sheet.replace_row(request)

    except Exception:
        await bot.delete_message(chat_id=message.chat.id,
                                 message_id=result.message_id)
        await message.answer_sticker(sticker['not_connection'])
        await message.answer(text='Не удалось соединиться с гугл таблицей',
                             reply_markup=create_kb_coustom_main_menu(
                                 message.chat.id))

        return

    await bot.delete_message(chat_id=message.chat.id,
                             message_id=result.message_id)

    await notify_about_permit_to_order(request_numb, username)

    await message.answer(text='Новый пропуск добавлен, секретарь оповещен!',
                         reply_markup=create_kb_coustom_main_menu(
                             message.from_user.id))
    await state.finish()
示例#2
0
async def set_other_message(message: Message, state: FSMContext):
    data_state = await state.get_data()
    chosen_request = data_state['chosen_request']

    await bot.delete_message(chat_id=message.chat.id,
                             message_id=data_state['message_to_delete'])

    await bot.delete_message(chat_id=message.chat.id,
                             message_id=message.message_id)

    persone = all_emoji['персона']
    user = '******' + message.chat.username
    text = data_state['other_message'] + message.text + '\n'
    log_text = data_state['log_text'] + message.text

    chosen_request[9] = updating_log('MESSAGE',
                                     message.chat.username,
                                     chosen_request,
                                     update_data=log_text)

    try:
        result = await message.answer_sticker(sticker['go_to_table'])
        sheet.replace_row(chosen_request)

    except Exception as e:
        print(e)
        await bot.delete_message(chat_id=message.chat.id,
                                 message_id=result.message_id)
        await message.answer_sticker(sticker['not_connection'])
        await message.answer(text='Не удалось соединиться с гугл таблицей',
                             reply_markup=create_kb_coustom_main_menu(
                                 message.chat.id))

        return

    await bot.delete_message(chat_id=message.chat.id,
                             message_id=result.message_id)

    await message.answer(text='Cообщение отправлено!',
                         reply_markup=create_kb_coustom_main_menu(
                             message.chat.id))

    text = text + persone + user

    await notify_someone(text, 'admin', 'changer', 'executor')
    await notify_in_group_chat(text)

    await state.finish()

    return
async def cancel_request(call: CallbackQuery, state: FSMContext):
    await call.answer()
    await call.message.delete()

    if call.data == 'cancel':
        username = call.message.chat.username
        data_state = await state.get_data()

        request = data_state['chosen_request']
        request[5] = '0'
        request[6] = '0'
        request[7] = '0'
        request[11] = 'Отменена'
        request[12] = '0'
        request[13] = '0'
        request[14] = '0'
        request_id = request[1]
        request[9] = updating_log('CANCEL', username, request)

        result = await call.message.answer_sticker(
            'CAACAgIAAxkBAAL9pmBTBOfTdmX0Vi66ktpCQjUQEbHZAAIGAAPANk8Tx8qi9LJucHYeBA'
        )

        try:
            sheet.replace_row(request)
            permit.delete_permit(request_id)

        except Exception as e:
            print(e)
            await call.message.answer_sticker(
                'CAACAgIAAxkBAAL9rGBTCImgCvHJBZ-doEYr2jkvs6UEAAIaAAPANk8TgtuwtTwGQVceBA'
            )
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей...',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
            await state.finish()

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        request[10] = username
        request_type_emoji = all_emoji[request[3]]
        request_id = request[2]
        persone = all_emoji['персона']

        text = f'{request_type_emoji} #N{request_id}\nОТМЕНЕНА\n{persone} @{username}'

        await call.message.answer(f'Заявка отменена',
                                  reply_markup=create_kb_coustom_main_menu(
                                      call.message.chat.id))

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)

        await state.finish()

        return

    elif call.data == 'back_to_request':
        data_state = await state.get_data()
        current_requests = data_state['current_requests']
        chosen_request = data_state['chosen_request']
        request_id = chosen_request[1]

        for request in current_requests:

            if request_id == request[1]:
                await state.update_data(chosen_request=request)

                break

        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        text = get_data_chosen_request(chosen_request)

        await call.message.answer(
            text=text,
            reply_markup=create_kb_chosen_request(request)
            # > принято частично (для приема кэша, снятия с карт, обмена)
            # > отложить на выдачу (для доставки, кэшина, обмена)
            # > закрыть заявку
            # > сообщение
            # > изменить заявку
            # > отменить заявку
            # > назад главное меню
        )
        await Processing.enter_chosen_request_menu.set()

        return

    else:
        await call.message.answer(
            text='Выход из меню "В РАБОТЕ". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
        await state.finish()

        return
async def chosen_request_menu(call: CallbackQuery, state: FSMContext):
    '''
    > отложить на выдачу (для доставки, кэшина, обмена)
    > принято частично (для приема кэша, снятия с карт, обмена)
    > закрыть заявку
    > сообщение
    > изменить заявку
    > добавить пропуск
    > добавить комментарий
    > распаковать
    > отменить заявку
    > назад
    > главное меню
    '''
    await call.answer()
    await call.message.delete()

    data_btn = cb_chosen_requests.parse(call.data)

    if data_btn['type_btn'] == 'to_ready_for_give':
        # сбрасываем имя пользователя в текущей заявке
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        chosen_request[10] = '0'
        await state.update_data(chosen_request=chosen_request)
        # сбрасываем имя пользователя чтобы не отображалось
        ###################################################

        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']

        rub, usd, eur = get_minus_FGH(chosen_request)

        if not rub == '': rub = rub + '\n'
        if not usd == '': usd = usd + '\n'

        await call.message.answer(
            text=
            f'Откладываем на выдачу полные суммы по заявке:\n{rub}{usd}{eur}\nили корректировать суммы?',
            reply_markup=create_kb_what_sum()
            # > скорректировать
            # > подтвердить
            # > вернуться к заявке
            # > назад - главное меню
        )

        await Processing.enter_reserve_to_ready_menu.set()

        return

    elif data_btn['type_btn'] == 'recived_chunck':
        # сбрасываем имя пользователя в текущей заявке
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        chosen_request[10] = '0'
        await state.update_data(chosen_request=chosen_request)
        # сбрасываем имя пользователя чтобы не отображалось
        ###################################################

        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']

        await call.message.answer(
            text='Какая из исходных сумм по заявке принята частично?',
            reply_markup=create_kb_sum_correct_chunk(chosen_request)
            # > rub
            # > usd
            # > eur
            # > назад - главное меню
        )
        await Processing.enter_correct_sum_chunk_menu.set()

        return

    elif data_btn['type_btn'] == 'close_request':
        # L(11) - "Исполнено"
        # P(15) - Дата и время исполнения
        # K(10) - Исполнитель - имя исполнителя из телеги
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']

        text = get_text_before_close_request(chosen_request)
        # text = get_values_MNO_or_FGH_ifMNO_is_empty(chosen_request)

        await call.message.answer(
            text=text,
            reply_markup=create_kb_confirm_close_request(chosen_request)
            # > подтверждаю!
            # > закрыть с другой суммой
            # > скорректировать синие
            # > вернуться к заявке
            # > назад - главное меню
        )
        await Processing.close_request_menu.set()

        return

    elif data_btn['type_btn'] == 'message_to':
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']

        text = get_text_message_to(chosen_request)

        await call.message.answer(text=text,
                                  reply_markup=create_kb_message_keyboard())
        await Processing.message_processing.set()

        return

    elif data_btn['type_btn'] == 'change_request':
        data_state = await state.get_data()

        chosen_request = data_state['chosen_request']
        is_changed = False

        await state.update_data(changed_request=chosen_request)
        await state.update_data(is_changed=is_changed)
        await state.update_data(all_changes_data=[])

        text = get_data_chosen_request(chosen_request) + \
        '\n\n Выберите изменение:'

        await call.message.answer(text,
                                  reply_markup=create_kb_change_request(
                                      chosen_request, is_changed))

        await Processing.change_request_menu.set()

        return

    elif data_btn['type_btn'] == 'add_permit':
        result = await call.message.answer(
            'Введите Ф.И.О. которые будут добавленны')
        await state.update_data(message_to_delete=result.message_id)
        await Processing.add_permit.set()
        # ---> add_permit_message_handler <---

    elif data_btn['type_btn'] == 'add_comment':
        result = await call.message.answer(
            text='Напишите коментарий:', reply_markup=create_kb_back_button())
        await state.update_data(message_to_delete=result.message_id)

        await Processing.add_another_comment.set()
        # ---> ./change_request/change_request_menu

        return

    elif data_btn['type_btn'] == 'unpack':
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        username = call.message.chat.username
        chosen_request[10] = username
        chosen_request[11] = 'В обработке'
        chosen_request[12] = '0'
        chosen_request[13] = '0'
        chosen_request[14] = '0'
        chosen_request[16] = '0'
        req_id = chosen_request[1]
        chosen_request[9] = updating_log('UNPACK', username, chosen_request)

        result = await call.message.answer_sticker(
            'CAACAgIAAxkBAAL9pmBTBOfTdmX0Vi66ktpCQjUQEbHZAAIGAAPANk8Tx8qi9LJucHYeBA'
        )

        try:
            sheet.replace_row(chosen_request)
            current_requests,\
            in_processing_requests,\
            ready_to_give_requests =\
            sheet.get_numbs_processing_and_ready_requests()

        except Exception as e:
            print(e)
            await call.message.answer_sticker(
                'CAACAgIAAxkBAAL9rGBTCImgCvHJBZ-doEYr2jkvs6UEAAIaAAPANk8TgtuwtTwGQVceBA'
            )
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей...',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
            await state.finish()

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)
        await state.update_data(current_requests=current_requests)

        persone = all_emoji['персона']
        text_notify_unpack = get_data_request_unpack(chosen_request)
        text_notify_unpack = text_notify_unpack + f'⚙️ Распаковано в обработку\n{persone}@{username}'

        await notify_someone(text_notify_unpack, 'admin', 'changer',
                             'executor')
        await notify_in_group_chat(text_notify_unpack)

        for request in current_requests:

            if req_id == request[1]:
                await state.update_data(chosen_request=request)

                break

        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        text = get_data_chosen_request(chosen_request)

        await call.message.answer(
            text=text,
            reply_markup=create_kb_chosen_request(request)
            # > принято частично (для приема кэша, снятия с карт, обмена)
            # > отложить на выдачу (для доставки, кэшина, обмена)
            # > закрыть заявку
            # > сообщение
            # > изменить заявку
            # > отменить заявку
            # > назад главное меню
        )
        await Processing.enter_chosen_request_menu.set()

        return

    elif data_btn['type_btn'] == 'cancel_request':
        await call.message.answer(
            text='Отменить заявку?',
            reply_markup=create_kb_confirm_cancel_request())
        await Processing.confirm_cancel_request.set()
        # to confirm_cancel_requeest.py

        return

    elif data_btn['type_btn'] == 'show_log':
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']

        data_log = chosen_request[9]

        if data_log == 0 or data_log == '0':
            beauty_text_log = 'лог для этой заявки отсутствует'
        else:
            beauty_text_log = beauty_text_log_builder(data_log)

        await call.message.answer(text=beauty_text_log,
                                  reply_markup=create_kb_under_log())

        await Processing.request_log.set()

        return

    elif data_btn['type_btn'] == 'back':
        data_state = await state.get_data()

        in_processing_requests = data_state['in_processing_requests']
        ready_to_give_requests = data_state['ready_to_give_requests']

        await call.message.answer('Текущие заявки:',
                                  reply_markup=create_kb_current_requests(
                                      in_processing_requests,
                                      ready_to_give_requests))

        await Processing.chosen_request.set()

        return

    elif data_btn['type_btn'] == 'main_menu':
        await call.message.answer(
            text='Выход из меню "В РАБОТЕ". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

        await state.finish()

        return
示例#5
0
async def set_status_permit(call: CallbackQuery, state: FSMContext):
    '''
    Обрабатывает нажатие на один из пропусков, выведенных списком
    '''
    await call.answer()
    await call.message.delete()

    data_btn = cb_set_status_prmt.parse(call.data)

    if data_btn['type_btn'] == 'back__main_menu':
        await call.message.answer(
            f'Выход из меню "ПРОПУСКА". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
        await state.finish()

        return

    data_state = await state.get_data()
    chosen_permit = data_state['chosen_permit']
    permit_id = chosen_permit[0]
    request_numb = chosen_permit[1]

    current_requests = data_state['all_requests']
    chosen_request = ''

    for request in current_requests:

        if permit_id == request[1]:
            chosen_request = request

            break

    if data_btn['type_btn'] == 'permit_ordered':
        user = call.message.chat.username
        chosen_request[9] = updating_log('PERMIT',
                                         user,
                                         chosen_request,
                                         update_data='Пропуск заказан')

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            permit.update_permit_data(permit_id, 'заказан')
            sheet.replace_row(chosen_request)

        except Exception:
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        permit_warning = 'пропуск заказан'
        permit_ready = all_emoji['заказан']
        permit_notify = f'{permit_ready} #N{request_numb} пропуск заказан {permit_ready}'
        ready_or_office = 'ready'

        if chosen_request != '':
            permit_notify = permit_notify_data(chosen_request, ready_or_office)

        await notify_someone(permit_notify, 'admin', 'changer', 'executor')
        await notify_in_group_chat(permit_notify)

    if data_btn['type_btn'] == 'in_office':
        user = call.message.chat.username
        chosen_request[9] = updating_log('PERMIT',
                                         user,
                                         chosen_request,
                                         update_data='Клиент в офисе')

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            permit.update_permit_data(permit_id, 'отработан')
            sheet.replace_row(chosen_request)

        except Exception:
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        permit_warning = 'гость прибыл в офис'
        permit_notify = f'⚠️ #N{request_numb} В ОФИСЕ ⚠️'
        ready_or_office = 'office'

        if chosen_request != '':
            permit_notify = permit_notify_data(chosen_request, ready_or_office)

        await notify_someone(permit_notify, 'admin', 'changer', 'executor')
        await notify_in_group_chat(permit_notify)

    if data_btn['type_btn'] == 'delete_permit':
        await call.message.answer(
            f'Удаляем пропуск №{request_numb}?',
            reply_markup=create_kb_confirm_single_permit())
        await state.update_data(status_permit=permit_id)
        await state.update_data(permit_numb=request_numb)
        await Permitstate.confirm_delete_permit.set()

        return

    text = f'Все оповещены о том, что по заявке #N{request_numb} {permit_warning}'

    await call.message.answer(text=text,
                              reply_markup=create_kb_coustom_main_menu(
                                  call.message.chat.id))

    await state.finish()

    return
示例#6
0
async def blue_amount_menu(call: CallbackQuery, state: FSMContext):
    '''
    > подтверждаю!             confirm_close
    > закрыть с другой суммой  another_sum_close
    > скорректировать синие    correct_blue
    > вернуться к заявке       back_to_request
    > назад - главное меню     back__main_menu
    '''
    await call.answer()
    await call.message.delete()
    await state.update_data(close_request_menu='+')

    data_btn = cb_confirm_close_request.parse(call.data)

    if data_btn['type_btn'] == 'confirm_close':
        data_state = await state.get_data()
        current_requests = data_state['current_requests']
        chosen_request = data_state['chosen_request']
        request_id = chosen_request[1]
        initial_com = chosen_request[8]

        for request in current_requests:

            if request_id == request[1]:
                initial_rub = request[5]
                initial_usd = request[6]
                initial_eur = request[7]

                break

        if chosen_request[5] != initial_rub:
            initial_com = initial_com + ' || ' + 'изначальная сумма RUB:' + initial_rub

        if chosen_request[6] != initial_usd:
            initial_com = initial_com + ' || ' + 'изначальная сумма USD:' + initial_usd

        if chosen_request[7] != initial_eur:
            initial_com = initial_com + ' || ' + 'изначальная сумма EUR:' + initial_eur

        chosen_request[8] = initial_com
        user = call.message.chat.username
        chosen_request[10] = user
        chosen_request[11] = 'Исполнено'

        if chosen_request[12] != '0': chosen_request[5] = chosen_request[12]
        else: chosen_request[12] = chosen_request[5]

        if chosen_request[13] != '0': chosen_request[6] = chosen_request[13]
        else: chosen_request[13] = chosen_request[6]

        if chosen_request[14] != '0': chosen_request[7] = chosen_request[14]
        else: chosen_request[14] = chosen_request[7]

        # chosen_request[12] = chosen_request[5]
        # chosen_request[13] = chosen_request[6]
        # chosen_request[14] = chosen_request[7]

        time_close = datetime.today().strftime('%H:%M (%d.%m)')
        chosen_request[15] = time_close

        chosen_request[9] = updating_log('CLOSE', user, chosen_request)

        text = get_text_after_close_request(chosen_request, initial_rub,
                                            initial_usd, initial_eur)

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        await call.message.answer(text='Заявка закрыта!',
                                  reply_markup=create_kb_coustom_main_menu(
                                      call.message.chat.id))

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)

        await state.finish()

        return

    elif data_btn['type_btn'] == 'another_sum_close':
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']

        await call.message.answer(
            text='Выберите сумму для корректировки',
            reply_markup=create_kb_which_sum_close(chosen_request)
            # > rub
            # > usd
            # > eur
            # > назад главное меню
        )
        await Processing.which_sum_correct_menu.set()

        return

    elif data_btn['type_btn'] == 'correct_blue':
        result = await call.message.answer('Введите колличество синих')
        await state.update_data(message_to_delete=result.message_id)
        await Processing.blue_amount_close.set()

        return

    elif data_btn['type_btn'] == 'back_to_request':
        data_state = await state.get_data()
        current_requests = data_state['current_requests']
        chosen_request = data_state['chosen_request']
        request_id = chosen_request[2]

        for request in current_requests:

            if request_id == request[1]:
                await state.update_data(chosen_request=request)

                break

        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        text = get_data_chosen_request(chosen_request)

        await call.message.answer(
            text=text,
            reply_markup=create_kb_chosen_request(request)
            # > принято частично (для приема кэша, снятия с карт, обмена)
            # > отложить на выдачу (для доставки, кэшина, обмена)
            # > закрыть заявку
            # > сообщение
            # > изменить заявку
            # > отменить заявку
            # > назад главное меню
        )
        await Processing.enter_chosen_request_menu.set()

        return

    elif data_btn['type_btn'] == 'back__main_menu':
        await call.message.answer(
            text='Выход из меню "В РАБОТЕ". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
        await state.finish()

        return
示例#7
0
async def message_processing(call: CallbackQuery, state: FSMContext):
    '''
    keyboards.inline.in_processing.message_keyboards.create_kb_message_keyboard
    > принял без перерасчета   recived_without
    > до сих пор не было       nobody
    > вышел из офиса           go_out_office
    > в доставке               in_delivery
    > ожидаю подтверждения     wait_confirm
    > связался                 contacted
    > свой текст сообщения     other_text
    > назад главное меню       back__main_menu
    '''
    await call.answer()
    await call.message.delete()

    data_btn = cb_message_keyboard.parse(call.data)

    data_state = await state.get_data()
    chosen_request = data_state['chosen_request']
    text = get_data_request_short(chosen_request)
    user = '******' + call.message.chat.username
    persone = all_emoji['персона']
    envelop = all_emoji['конверт']

    text = text + envelop

    if data_btn['type_btn'] == 'recived_without':
        text = text + 'Принята без пересчета' + '\n'
        text = text + persone + user

        chosen_request[9] = updating_log('MESSAGE',
                                         call.message.chat.username,
                                         chosen_request,
                                         update_data='Принята без пересчета')

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        await call.message.answer(text='сообщение отправлено!',
                                  reply_markup=create_kb_coustom_main_menu(
                                      call.message.chat.id))

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)

        await state.finish()

        return

    if data_btn['type_btn'] == 'nobody':
        text = text + 'До сих пор не было' + '\n'
        text = text + persone + user

        chosen_request[9] = updating_log('MESSAGE',
                                         call.message.chat.username,
                                         chosen_request,
                                         update_data='До сих пор не было')

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        await call.message.answer(text='сообщение отправлено!',
                                  reply_markup=create_kb_coustom_main_menu(
                                      call.message.chat.id))

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)
        await state.finish()

        return

    if data_btn['type_btn'] == 'go_out_office':
        text = text + 'Вышел из офиса' + '\n'
        text = text + persone + user

        chosen_request[9] = updating_log('MESSAGE',
                                         call.message.chat.username,
                                         chosen_request,
                                         update_data='Вышел из офиса')

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        await call.message.answer(text='сообщение отправлено!',
                                  reply_markup=create_kb_coustom_main_menu(
                                      call.message.chat.id))

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)
        await state.finish()

        return

    if data_btn['type_btn'] == 'in_delivery':
        text = text + 'В доставке' + '\n'
        text = text + persone + user

        chosen_request[9] = updating_log('MESSAGE',
                                         call.message.chat.username,
                                         chosen_request,
                                         update_data='В доставке')

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        await call.message.answer(text='сообщение отправлено!',
                                  reply_markup=create_kb_coustom_main_menu(
                                      call.message.chat.id))

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)
        await state.finish()

        return

    if data_btn['type_btn'] == 'wait_confirm':
        text = text + 'Ожидаю подтверждения' + '\n'
        text = text + persone + user

        chosen_request[9] = updating_log('MESSAGE',
                                         call.message.chat.username,
                                         chosen_request,
                                         update_data='Ожидаю подтверждения')

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        await call.message.answer(text='сообщение отправлено!',
                                  reply_markup=create_kb_coustom_main_menu(
                                      call.message.chat.id))

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)
        await state.finish()

        return

    if data_btn['type_btn'] == 'contacted':
        text = text + 'Cвязался с клиентом, '

        await state.update_data(other_message=text)
        await state.update_data(log_text='Cвязался с клиентом, ')

        result = await call.message.answer(text='Введите ваше сообщение')
        await state.update_data(message_to_delete=result.message_id)
        await Processing.other_message.set()

        return

    if data_btn['type_btn'] == 'other_text':
        await state.update_data(other_message=text)
        await state.update_data(log_text='')

        result = await call.message.answer(text='Введите ваше сообщение')
        await state.update_data(message_to_delete=result.message_id)
        await Processing.other_message.set()

        return

    if data_btn['type_btn'] == 'back__main_menu':

        await call.message.answer(
            text='Выход из меню "В РАБОТЕ". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

        await state.finish()

        return
async def set_change_sum_return(message: Message, state: FSMContext):
    data_state = await state.get_data()
    await bot.delete_message(chat_id=message.chat.id,
                             message_id=data_state['message_to_delete'])
    await bot.delete_message(chat_id=message.chat.id,
                             message_id=message.message_id)

    try:
        sum_amount = int(message.text)

        if sum_amount <= 0:
            raise ValueError('f**k off')
        sum_amount = str(sum_amount)

    except Exception as e:
        print(e)
        # traceback.print_exception()

        await message.answer(
            text='Изменение заявки отменено. Формат суммы не правильный.',
            reply_markup=create_kb_coustom_main_menu(message.chat.id))

        await state.finish()

        return

    set_change_curr = data_state['set_change_curr']
    chosen_request = data_state['chosen_request']

    if set_change_curr == 'rub':
        if chosen_request[5][0] == '-':
            chosen_request[5] = str(0 - int(sum_amount))
        else:
            chosen_request[5] = sum_amount

    if set_change_curr == 'usd':
        if chosen_request[6][0] == '-':
            chosen_request[6] = str(0 - int(sum_amount))
        else:
            chosen_request[6] = sum_amount

    if set_change_curr == 'eur':
        if chosen_request[7][0] == '-':
            chosen_request[7] = str(0 - int(sum_amount))
        else:
            chosen_request[7] = sum_amount

    chosen_request[11] = 'В обработке'
    chosen_request[12] = '0'
    chosen_request[13] = '0'
    chosen_request[14] = '0'
    chosen_request[15] = '0'
    chosen_request[16] = '0'
    username = message.chat.username
    chosen_request[10] = username
    chosen_request[9] = updating_log('RETURN', username, chosen_request)

    try:
        result = await message.answer_sticker(sticker['go_to_table'])
        sheet.replace_row(chosen_request)

    except Exception as e:
        print(e)
        await bot.delete_message(chat_id=message.chat.id,
                                 message_id=result.message_id)
        await message.answer_sticker(sticker['not_connection'])
        await message.answer(text='Не удалось соединиться с гугл таблицей',
                             reply_markup=create_kb_coustom_main_menu(
                                 message.chat.id))

        await state.finish()

        return

    await bot.delete_message(chat_id=message.chat.id,
                             message_id=result.message_id)

    request_type_emoji = all_emoji[chosen_request[3]]
    request_numb = chosen_request[2]
    persone = all_emoji['персона']
    request_date = chosen_request[0]
    text = f'{request_type_emoji} #N{request_numb} от {request_date}\nвозвращена в обработку измененной суммой\n{persone} @{username}'

    await message.answer(text='Сумма изменена, заявка возвращена в обработку!',
                         reply_markup=create_kb_coustom_main_menu(
                             message.chat.id))

    await notify_someone(text, 'admin', 'changer', 'executor')
    await notify_in_group_chat(text)

    await state.finish()

    return
示例#9
0
async def confirm_blue_amount(call: CallbackQuery, state: FSMContext):
    '''
    Обрабатывает кнопки из keyboards/blue_keyboard.py
    > подтвердить  confirm
    > вернуться к заявке  back_to_request
    > назад - главное меню  back_main_menu
    '''
    await call.answer()
    await call.message.delete()
    await state.update_data(enter_to_confirm_blue_menu='+')

    data_btn = cb_confirm_blue.parse(call.data)

    if data_btn['type_btn'] == 'confirm':
        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        user = call.message.chat.username
        chosen_request[10] = user
        chosen_request[11] = 'Готово к выдаче'
        chosen_request[9] = updating_log('RESERVE', user, chosen_request)

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        text = get_data_chosen_request(chosen_request)

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)

        request_id = chosen_request[2]
        await call.message.answer(
            text=f'Заявка #N{request_id} отложена на выдачу',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
        await state.finish()

        return

    elif data_btn['type_btn'] == 'back_to_request':
        data_state = await state.get_data()
        current_requests = data_state['current_requests']
        chosen_request = data_state['chosen_request']
        request_id = chosen_request[2]

        for request in current_requests:

            if request_id == request[2]:
                await state.update_data(chosen_request=request)

                break

        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        text = get_data_chosen_request(chosen_request)

        await call.message.answer(
            text=text,
            reply_markup=create_kb_chosen_request(request)
            # > принято частично (для приема кэша, снятия с карт, обмена)
            # > отложить на выдачу (для доставки, кэшина, обмена)
            # > закрыть заявку
            # > сообщение
            # > изменить заявку
            # > отменить заявку
            # > назад главное меню
        )
        await Processing.enter_chosen_request_menu.set()

        return

    elif data_btn['type_btn'] == 'back_main_menu':
        await call.message.answer(
            text='Выход из меню "В РАБОТЕ". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
        await state.finish()

        return
示例#10
0
async def change_request_menu_handler(call:CallbackQuery, state:FSMContext):
    '''
    keyboards/inline/in_processin/change_request_keyboards.create_kb_change_request
    > новая дата            new_date
    > новый номер           new_id
    > переопределить тип    change_type
    > изменить сумму        update_sum
    > другая валюта         more_currency
    > СОХРАНИТЬ ИЗМЕНЕНИЯ   save_changes
    > назад                 back
    > главное меню          main_menu
    '''
    await call.answer()
    await call.message.delete()

    data_state = await state.get_data()
    data_btn = cb_change_request.parse(call.data)

    if data_btn['type_btn'] == 'new_date':
        await call.message.answer (
            text='Выберите дату:',
            reply_markup=create_kb_change_date()
        )
        
        await Processing.select_date.set()

        return

    elif data_btn['type_btn'] == 'new_id':
        result = await call.message.answer (
            text='Введите новый номер заявки'
        )
        
        await state.update_data(message_to_delete=result.message_id)
        await Processing.new_request_id.set()

        return

    elif data_btn['type_btn'] == 'change_type':
        data_state = await state.get_data()
        changed_request = data_state['chosen_request']

        await call.message.answer (
            text='Выберите новый тип заявки',
            reply_markup=create_kb_new_request_type()
        )
        await Processing.new_request_type.set()

        return

    elif data_btn['type_btn'] == 'update_sum':
        await call.message.answer (
            text='Выберите валюту',
            reply_markup=create_kb_choose_currency()
        )
        await Processing.which_sum_change__currency.set()

        return

    elif data_btn['type_btn'] == 'save_changes':
        username = call.message.chat.username
        data_state = await state.get_data()

        changed_request = data_state['changed_request']
        changed_request[10] = username
        
        changed_request_id = changed_request[1]
        changed_request_date = changed_request[0]
        changed_request_numb = changed_request[2]

        changed_request[9] = updating_log('CHANGE', username, changed_request)
        
        try:
            result = await call.message.answer_sticker (
                sticker['go_to_table']
            )
            sheet.replace_row(changed_request)

            if 'date' in data_state['all_changes_data']:
                permit.change_permit_date(changed_request_id, changed_request_date)

            if 'numb' in data_state['all_changes_data']:
                permit.change_permit_numb(changed_request_id, changed_request_numb)


            current_requests,\
            in_processing_requests,\
            ready_to_give_requests =\
            sheet.get_numbs_processing_and_ready_requests()

        except Exception as e:
            print(e)
            await bot.delete_message (
                chat_id=call.message.chat.id,
                message_id=result.message_id
            )

            await call.message.answer_sticker (
                sticker['not_connection']
            )

            await call.message.answer (
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id)
            )

            return

        await bot.delete_message (
            chat_id=call.message.chat.id,
            message_id=result.message_id
        )

        await state.update_data(current_requests=current_requests)
        await state.update_data(in_processing_requests=in_processing_requests)
        await state.update_data(ready_to_give_requests=ready_to_give_requests)

        for request in current_requests:

            if changed_request_id == request[1]:
                await state.update_data(chosen_request=request)

                break

        text = get_data_chosen_request(changed_request)
        
        await call.message.answer (
            text=text,
            reply_markup=create_kb_chosen_request(changed_request)
            # > принято частично (для приема кэша, снятия с карт, обмена)
            # > отложить на выдачу (для доставки, кэшина, обмена)
            # > закрыть заявку
            # > сообщение
            # > изменить заявку
            # > добавить коментарий
            # > отменить заявку
            # > назад главное меню
        )

        await Processing.enter_chosen_request_menu.set()

        user_id = call.message.chat.id

        change_info_text = get_text_after_change_request (
            data_state['chosen_request'],
            changed_request
        )

        await notify_someone_except_user (
            change_info_text, 
            user_id,
            'admin',
            'changer',
            'executor'
        )
        await notify_in_group_chat(change_info_text)

        return

    elif data_btn['type_btn'] == 'back':
        data_state = await state.get_data()

        chosen_request = data_state['chosen_request']

        text = get_data_chosen_request(chosen_request)
        
        await call.message.answer (
            text=text,
            reply_markup=create_kb_chosen_request(chosen_request)
            # > принято частично (для приема кэша, снятия с карт, обмена)
            # > отложить на выдачу (для доставки, кэшина, обмена)
            # > закрыть заявку
            # > сообщение
            # > изменить заявку
            # > отменить заявку
            # > назад главное меню
        )
        await Processing.enter_chosen_request_menu.set()

        return

    elif data_btn['type_btn'] == 'main_menu':
        await call.message.answer (
            text='Выход из меню "В РАБОТЕ". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id)
        )

        await state.finish()
        
        return
示例#11
0
async def add_another_comment(message:Message, state:FSMContext):
    data_state = await state.get_data()
    chosen_request = data_state['chosen_request']

    await bot.delete_message (
        chat_id=message.chat.id,
        message_id=data_state['message_to_delete']
    )
    await bot.delete_message (
        chat_id=message.chat.id,
        message_id=message.message_id
    )
    
    if chosen_request[8] != '0':
        comment = chosen_request[8] + ' * '

    else:
        comment = ''

    comment = comment + message.text
    chosen_request[8] = comment
    user = message.chat.username

    chosen_request[9] = updating_log (
        'COMMENT',
        user,
        chosen_request,
        update_data=message.text
    )

    try:
        result = await message.answer_sticker (
            sticker['go_to_table']
        )
        sheet.replace_row(chosen_request)

    except Exception as e:
        print(e)
        await bot.delete_message(chat_id=message.chat.id, message_id=result.message_id)
        await message.answer_sticker (
            sticker['not_connection']
        )
        await message.answer (
            text='Не удалось соединиться с гугл таблицей',
            reply_markup=create_kb_coustom_main_menu(message.chat.id)
        )
        await state.finish()
        return

    await bot.delete_message(chat_id=message.chat.id, message_id=result.message_id)

    request_type_emoji = all_emoji[chosen_request[3]]
    request_id = chosen_request[2]
    persone = all_emoji['персона']
    username = message.chat.username

    text = f'{request_type_emoji} #N{request_id}\nдобавлен коментарий\n-----\n{message.text}\n{persone} @{username}'

    await message.answer (
        text='Коментарий добавлен',
        reply_markup=create_kb_coustom_main_menu(message.chat.id)
    )

    await notify_someone(text, 'admin', 'changer', 'executor')
    await notify_in_group_chat(text)

    await state.finish()

    return
示例#12
0
async def choose_currency(call: CallbackQuery, state: FSMContext):
    '''
    > скорректировать
    > подтвердить
    > вернуться к заявке
    > назад - главное меню
    '''
    await call.answer()
    await call.message.delete()
    await state.update_data(enter_reserve_to_ready_menu='+')

    data_btn = cb_what_sum.parse(call.data)

    if data_btn['type_btn'] == 'correct_sum':
        data_state = await state.get_data()
        request = data_state['chosen_request']

        await call.message.answer(
            text='Выберите одну из исходных сумм по заявке',
            reply_markup=create_kb_what_sum_correct(request))
        await Processing.enter_correct_sum_to_ready_menu.set()

        return

    elif data_btn['type_btn'] == 'confirm_sum':
        data_state = await state.get_data()

        chosen_request = data_state['chosen_request']

        # if request with RUB than the first char will be '-'
        if chosen_request[5][0] == '-':
            chosen_request[12] = chosen_request[5]

            if chosen_request[6][0] == '-':
                chosen_request[13] = chosen_request[6]

            if chosen_request[7][0] == '-':
                chosen_request[14] = chosen_request[7]

            await state.update_data(chosen_request=chosen_request)
            await call.message.answer(
                text='Сколько синих?',
                reply_markup=create_kb_what_blue()
                # > без синих
                # > ввести колличество синих
                # > вернуться к заявке
                # > назад - главное меню
            )

            await Processing.enter_to_blue_amount_menu.set()
            # to blue_amount_handlers.py
            return
        # Проверка для синих купюр если рублевая заявка
        ###############################################

        chosen_request[11] = 'Готово к выдаче'
        user = call.message.chat.username
        chosen_request[10] = user

        if chosen_request[6][0] == '-':
            chosen_request[13] = chosen_request[6]

        if chosen_request[7][0] == '-':
            chosen_request[14] = chosen_request[7]

        chosen_request[16] = '0'  # тут синих быть не должно

        text = get_data_chosen_request(chosen_request)

        await call.message.answer(text=text)

        chosen_request[9] = updating_log('RESERVE', user, chosen_request)

        try:
            result = await call.message.answer_sticker(sticker['go_to_table'])
            sheet.replace_row(chosen_request)

        except Exception as e:
            print(e)
            await bot.delete_message(chat_id=call.message.chat.id,
                                     message_id=result.message_id)
            await call.message.answer_sticker(sticker['not_connection'])
            await call.message.answer(
                text='Не удалось соединиться с гугл таблицей',
                reply_markup=create_kb_coustom_main_menu(call.message.chat.id))
            await state.finish()

            return

        await bot.delete_message(chat_id=call.message.chat.id,
                                 message_id=result.message_id)

        text = get_data_chosen_request(chosen_request)

        await notify_someone(text, 'admin', 'changer', 'executor')
        await notify_in_group_chat(text)

        request_id = chosen_request[2]

        await call.message.answer(
            text=f'Заявка #N{request_id} отложена на выдачу',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

        await state.finish()

        return

    elif data_btn['type_btn'] == 'back_to_chosen_request':
        data_state = await state.get_data()
        current_requests = data_state['current_requests']
        chosen_request = data_state['chosen_request']
        request_id = chosen_request[2]

        for request in current_requests:

            if request_id == request[2]:
                await state.update_data(chosen_request=request)

                break

        data_state = await state.get_data()
        chosen_request = data_state['chosen_request']
        text = get_data_chosen_request(chosen_request)

        await call.message.answer(
            text=text,
            reply_markup=create_kb_chosen_request(request)
            # > принято частично (для приема кэша, снятия с карт, обмена)
            # > отложить на выдачу (для доставки, кэшина, обмена)
            # > закрыть заявку
            # > сообщение
            # > изменить заявку
            # > отменить заявку
            # > назад главное меню
        )
        await Processing.enter_chosen_request_menu.set()

        return

    elif data_btn['type_btn'] == 'back_main_menu':

        await call.message.answer(
            text='Выход из меню "В РАБОТЕ". Используйте главное меню.',
            reply_markup=create_kb_coustom_main_menu(call.message.chat.id))

        await state.finish()

        return