теперь переделай код телеграм под твой код сервера.
сервер:
const express = require('express');
const cors = require("cors");
const bodyParser = require('body-parser');
const morgan = require('morgan'); // Импортируем morgan
require('dotenv').config(); // Для загрузки переменных окружения 
const axios = require('axios');

USERNAME = process.env.COUCH_BD_USER;
PASSWORD = process.env.COUCH_BD_PASSWORD;
DB_NAME = process.env.COUCH_BD_NAME;
// Подключение к CouchDB
const COUCHDB_URL = `http://${USERNAME}:${PASSWORD}@localhost:5984/`;
console.log(COUCHDB_URL);

const app = express();
app.use(cors());
app.use(morgan('combined')); // Используем morgan для логгирования запросов
const PORT = process.env.PORT || 3000;

// Функция для получения текущей даты и времени в нужном формате
function getCurrentTimestamp() {
    const date = new Date();
    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
}

// Middleware для парсинга JSON
app.use(bodyParser.json());

app.post('/timestamp', async (req, res) => {
    const { user_id, telegram_username } = req.body;
    const currentTimestamp = getCurrentTimestamp();
    const docId = `timestamp:${currentTimestamp}`;

    const doc = {
        _id: docId,
        type: 'timestamp',
        employee: {
            [user_id]: [
                {
                    user_id,
                    date: currentTimestamp,
                    telegram_username,
                    start_time: getCurrentTime() // get current time
                }
            ]
        }
    };

    try {
        const response = await axios.post(`${COUCHDB_URL}/${DB_NAME}`, doc);
        res.status(201).json({ message: 'Document created successfully' });
    } catch (error) {
        console.error('Error creating document:', error.message);
        res.status(500).json({ message: 'Error creating document' });
    }
});

app.post('/update', async (req, res) => {
    const { user_id, type, time } = req.body;
    const currentTimestamp = getCurrentTimestamp();
    const docId = `timestamp:${currentTimestamp}`;

    try {
        const response = await axios.get(`${COUCHDB_URL}/${DB_NAME}/${docId}`);
        const doc = response.data;

        switch (type) {
            case 1: // started work
                doc.employee[user_id].start_time = time;
                break;
            case 2: // started lunch break
                doc.employee[user_id].start_lunch_time = time;
                break;
            case 3: // finished lunch break
                doc.employee[user_id].end_lunch_time = time;
                break;
            case 4: // finished work
                doc.employee[user_id].end_time = time;
                break;
            default:
                throw new Error('Invalid request type');
        }

        await axios.put(`${COUCHDB_URL}/${DB_NAME}/${docId}`, doc);
        res.status(200).json({ message: 'Document updated successfully' });
    } catch (error) {
        console.error('Error updating document:', error.message);
        res.status(500).json({ message: 'Error updating document' });
    }
});

app.post('/login', async (req, res) => {
    const { password } = req.body;
    console.log(req.body);

    try {
        // URL для получения документа
        const couchdb_url = `${COUCHDB_URL}/${DB_NAME}/_all_docs?include_docs=true`;

        // Запрос на получение всех документов
        const response = await axios.get(couchdb_url);

        // Проверка полученных данных
        const employees = response.data.rows;

        // Поиск соответствия пароля
        const employee = employees.find(row => row.doc.password === password);

        if (employee) {
            console.log(employee.doc);

            res.status(200).json(employee.doc);
        } else {
            res.status(401).json({ message: 'Неверный пароль' });
        }
    } catch (error) {
        console.error('Ошибка при получении данных из CouchDB:', error.message);
        res.status(500).json({ message: 'Ошибка сервера', error });
    }
});

const server = app.listen(PORT, () => {
    const addressInfo = server.address(); // Адрес сервера 
    console.log(`Сервер слушает на адресе ${addressInfo.address} и порту ${addressInfo.port} в режиме ${app.settings.env}`);
});

телеграм:
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
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, WORK_END, LUNCH_START, LUNCH_END, VIEW_TIMES = range(6)


async def send_event_to_server(data: dict):
    try:
        post_url = "timestamp"
        server_url = SERVER_URL + post_url
        async with aiohttp.ClientSession() as session:
            async with session.post(server_url, json=data) as resp:
                if resp.status == 200:
                    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,
                    "start_time": datetime.now(),
                    "telegram_username": telegram_username,
                    "db_username": db_username,
                }
            )

            # Подготовка данных для отправки на сервер (инициация таймера)
            event_data = {
                "user_id": text.get("_id"),
                "request_type": 0,
                "telegram_username": telegram_username,
                "db_username": db_username,
            }
            success = await send_event_to_server(event_data)
            start_message = (
                "Таймер начат и зафиксирован на сервере."
                if success
                else "Не удалось зафиксировать начало работы на сервере."
            )

            # Кнопки для регистрации времени
            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"{start_message}",
                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", "")
    db_username = context.user_data.get("db_username", "")

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

    current_time = datetime.now()
    formatted_time = current_time.strftime("%H:%M")
    formatted_date = current_time.strftime("%Y-%m-%d")

    event_data = {
        "user_id": user_id,
        "request_type": request_type,
        "telegram_username": telegram_username,
        "time": formatted_time,
        "date": formatted_date,
    }

    success = await send_event_to_server(event_data)
    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()

    success = await send_event(context, 0)  # 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)
    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)
    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)
    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()