сделай админ панель компонентом, который будет вызываться, если при /login пришел id: employee:admin, в админ панели должны быть:
 админ панель(просмотр за сегодня кто работает, кто должен работать, отправка гугл таблицы .xls файлом чиста ради прекола)
придумай макет и логику первым делом, потом ссумируй всё и сделай отдельным промтом:
ТЗ:
описание, макет, логика
код куда надо закинуть
import os
import logging
import aiohttp
from datetime import datetime
from dotenv import load_dotenv
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    ConversationHandler,
    CallbackQueryHandler,
    MessageHandler,
    filters,
    ContextTypes,
)

# Загрузка переменных окружения
dotenv_path = os.path.join(os.path.dirname(os.getcwd()), ".env")
if os.path.exists(dotenv_path):
    load_dotenv(dotenv_path)

TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
if not TOKEN:
    raise ValueError("TELEGRAM_BOT_TOKEN не установлен в переменных окружения.")

PORT = 4025  # Порт вашего сервера Node.js
URL = os.getenv("ADDR") or "localhost"
SERVER_URL = f"http://{URL}:{PORT}/"

# Включение логирования
logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
)
logger = logging.getLogger(__name__)  # Исправлено имя логгера

# Состояния для ConversationHandler
AUTH_PASSWORD, WORK_START = range(2)


async def send_event_to_server(data: dict, endpoint: str):
    try:
        server_url = SERVER_URL + endpoint
        async with aiohttp.ClientSession() as session:
            async with session.post(server_url, json=data) as resp:
                if resp.status == 200 or resp.status == 201:
                    response = await resp.json()
                    logger.info(f"Сервер ответил успешно: {response}")
                    return True
                else:
                    error_text = await resp.text()
                    logger.error(f"Ошибка сервера: {resp.status} - {error_text}")
                    return False
    except Exception as e:
        logger.error(f"Ошибка при отправке запроса на сервер: {e}")
        return False


async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    await update.message.reply_text(
        "Добро пожаловать! Для начала авторизуйтесь. Введите ваш пароль:"
    )
    return AUTH_PASSWORD


async def authorize(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    password = update.message.text
    user_id = update.effective_user.id
    telegram_username = update.effective_user.username or ""
    logger.info(f"Получен пароль от пользователя {user_id}")

    try:
        server_url = SERVER_URL + "login"
        async with aiohttp.ClientSession() as session:
            async with session.post(server_url, json={"password": password}) as resp:
                status = resp.status
                text = await resp.json()

        if status == 200:
            logger.info(f"Успех для пользователя {user_id}: {text}")
            working_hours = text.get("working_hours", {})
            db_username = text.get("username_from_db", "")
            context.user_data.update(
                {
                    "user_id": text.get("_id"),
                    "working_hours": working_hours,
                    "telegram_username": telegram_username,
                    "db_username": db_username,
                }
            )
            # Кнопки для регистрации времени
            keyboard = [
                [
                    InlineKeyboardButton(
                        "Я пришел на работу", callback_data="work_start"
                    ),
                    InlineKeyboardButton("Я ушел с работы", callback_data="work_end"),
                ],
                [
                    InlineKeyboardButton("Начало обеда", callback_data="lunch_start"),
                    InlineKeyboardButton("Конец обеда", callback_data="lunch_end"),
                ],
                [InlineKeyboardButton("Посмотреть время", callback_data="view_times")],
            ]
            reply_markup = InlineKeyboardMarkup(keyboard)
            await update.message.reply_text(
                f"Здравствуйте! Ваши данные:\n\n"
                f"ID: {text.get('_id')}\n"
                f"Объект: {text.get('object')}\n"
                f"Команда: {text.get('team')}\n"
                f"Супервизор: {text.get('supervisor')}\n"
                f"Часы работы:\n"
                f"  Начало: {working_hours.get('monday', {}).get('start')}\n"
                f"  Конец: {working_hours.get('monday', {}).get('end')}\n"
                f"  Обед: {working_hours.get('monday', {}).get('lunch', {}).get('start')} - {working_hours.get('monday', {}).get('lunch', {}).get('end')}\n\n"
                f"Пожалуйста, зарегистрируйте ваше прибытие на работу.",
                reply_markup=reply_markup,
            )
            return WORK_START
        else:
            logger.warning(f"Неудача для пользователя {user_id}: {status} - {text}")
            await update.message.reply_text(
                "Неверный пароль. Пожалуйста, попробуйте еще раз."
            )
            return AUTH_PASSWORD
    except Exception as e:
        logger.error(f"Ошибка при обработке запроса для пользователя {user_id}: {e}")
        await update.message.reply_text("Произошла ошибка. Попробуйте позже.")
        return ConversationHandler.END


async def send_event(context: ContextTypes.DEFAULT_TYPE, request_type: int) -> bool:
    user_id = context.user_data.get("user_id")
    telegram_username = context.user_data.get("telegram_username", "")

    if not user_id:
        logger.error("user_id отсутствует в user_data.")
        return False

    current_time = datetime.now()
    formatted_time = current_time.strftime("%H:%M")

    if request_type == 0:
        # Начало дня, создание документа
        event_data = {
            "user_id": user_id,
            "telegram_username": telegram_username,
        }
        endpoint = "timestamp"
    else:
        event_data = {
            "user_id": user_id,
            "type": request_type,
            "time": formatted_time,
        }
        endpoint = "update"

    success = await send_event_to_server(event_data, endpoint)
    return success


async def register_work_start(
    update: Update, context: ContextTypes.DEFAULT_TYPE
) -> int:
    user_id = context.user_data.get("user_id")
    start_time = datetime.now()
    context.user_data["work_start_time"] = start_time
    logger.info(
        f"Пользователь {user_id} пришел на работу в {start_time.strftime('%H:%M')}"
    )
    await update.callback_query.answer()

    # Отправка данных на сервер через '/timestamp'
    success = await send_event(context, 0)  # request_type 0 для начала дня
    response_text = (
        "Вы зарегистрировали прибытие на работу."
        if success
        else "Не удалось зафиксировать начало работы на сервере."
    )

    keyboard = [
        [
            InlineKeyboardButton("Посмотреть время", callback_data="view_times"),
            InlineKeyboardButton("Я ушел с работы", callback_data="work_end"),
        ],
        [
            InlineKeyboardButton("Начало обеда", callback_data="lunch_start"),
            InlineKeyboardButton("Конец обеда", callback_data="lunch_end"),
        ],
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.callback_query.edit_message_text(
        f"{response_text}\n",
        reply_markup=reply_markup,
    )
    return WORK_START


async def register_work_end(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    user_id = context.user_data.get("user_id")
    end_time = datetime.now()
    context.user_data["work_end_time"] = end_time
    logger.info(f"Пользователь {user_id} ушел с работы в {end_time.strftime('%H:%M')}")
    await update.callback_query.answer()

    success = await send_event(context, 4)  # Тип 4 для окончания работы
    response_text = (
        f"Вы зарегистрировали выход с работы в {end_time.strftime('%H:%M')}."
        if success
        else "Не удалось зарегистрировать выход с работы на сервере."
    )

    keyboard = [
        [
            InlineKeyboardButton("Посмотреть время", callback_data="view_times"),
            InlineKeyboardButton("Я пришел на работу", callback_data="work_start"),
        ],
        [
            InlineKeyboardButton("Начало обеда", callback_data="lunch_start"),
            InlineKeyboardButton("Конец обеда", callback_data="lunch_end"),
        ],
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.callback_query.edit_message_text(
        f"{response_text}\n",
        reply_markup=reply_markup,
    )
    return WORK_START


async def register_lunch_start(
    update: Update, context: ContextTypes.DEFAULT_TYPE
) -> int:
    user_id = context.user_data.get("user_id")
    lunch_start = datetime.now()
    context.user_data["lunch_start_time"] = lunch_start
    logger.info(f"Пользователь {user_id} начал обед в {lunch_start.strftime('%H:%M')}")
    await update.callback_query.answer()

    success = await send_event(context, 2)  # Тип 2 для начала обеда
    response_text = (
        f"Вы начали обед в {lunch_start.strftime('%H:%M')}."
        if success
        else "Не удалось зарегистрировать начало обеда на сервере."
    )

    keyboard = [
        [
            InlineKeyboardButton("Посмотреть время", callback_data="view_times"),
            InlineKeyboardButton("Конец обеда", callback_data="lunch_end"),
        ],
        [
            InlineKeyboardButton("Я пришел на работу", callback_data="work_start"),
            InlineKeyboardButton("Я ушел с работы", callback_data="work_end"),
        ],
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.callback_query.edit_message_text(
        f"{response_text}\n",
        reply_markup=reply_markup,
    )
    return WORK_START


async def register_lunch_end(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    user_id = context.user_data.get("user_id")
    lunch_end = datetime.now()
    context.user_data["lunch_end_time"] = lunch_end
    logger.info(f"Пользователь {user_id} закончил обед в {lunch_end.strftime('%H:%M')}")
    await update.callback_query.answer()

    success = await send_event(context, 3)  # Тип 3 для окончания обеда
    response_text = (
        f"Вы закончили обед в {lunch_end.strftime('%H:%M')}."
        if success
        else "Не удалось зарегистрировать окончание обеда на сервере."
    )

    keyboard = [
        [
            InlineKeyboardButton("Посмотреть время", callback_data="view_times"),
            InlineKeyboardButton("Я пришел на работу", callback_data="work_start"),
        ],
        [InlineKeyboardButton("Я ушел с работы", callback_data="work_end")],
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.callback_query.edit_message_text(
        f"{response_text}\n",
        reply_markup=reply_markup,
    )
    return WORK_START


async def view_times(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    user_id = context.user_data.get("user_id")
    work_start_time = context.user_data.get("work_start_time", "Не зарегистрировано")
    work_end_time = context.user_data.get("work_end_time", "Не зарегистрировано")
    lunch_start_time = context.user_data.get("lunch_start_time", "Не зарегистрировано")
    lunch_end_time = context.user_data.get("lunch_end_time", "Не зарегистрировано")

    await update.callback_query.answer()
    await update.callback_query.edit_message_text(
        f"Ваши зарегистрированные времена:\n"
        f"Вход на работу: {work_start_time.strftime('%H:%M') if isinstance(work_start_time, datetime) else work_start_time}\n"
        f"Выход с работы: {work_end_time.strftime('%H:%M') if isinstance(work_end_time, datetime) else work_end_time}\n"
        f"Начало обеда: {lunch_start_time.strftime('%H:%M') if isinstance(lunch_start_time, datetime) else lunch_start_time}\n"
        f"Конец обеда: {lunch_end_time.strftime('%H:%M') if isinstance(lunch_end_time, datetime) else lunch_end_time}\n"
    )
    return WORK_START


async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    await update.message.reply_text("Операция отменена.")
    return ConversationHandler.END


def main():
    application = ApplicationBuilder().token(TOKEN).build()
    conv_handler = ConversationHandler(
        entry_points=[CommandHandler("start", start)],
        states={
            AUTH_PASSWORD: [MessageHandler(filters.TEXT & ~filters.COMMAND, authorize)],
            WORK_START: [
                CallbackQueryHandler(register_work_start, pattern="^work_start$"),
                CallbackQueryHandler(register_work_end, pattern="^work_end$"),
                CallbackQueryHandler(register_lunch_start, pattern="^lunch_start$"),
                CallbackQueryHandler(register_lunch_end, pattern="^lunch_end$"),
                CallbackQueryHandler(view_times, pattern="^view_times$"),
            ],
        },
        fallbacks=[CommandHandler("cancel", cancel)],
    )
    application.add_handler(conv_handler)
    application.run_polling()


if __name__ == "__main__":  # Исправлено условие
    main()