MED-129 + MED-103: add shopping cart functionality for TTO services

2025-09-24 18:49:10 +03:00
parent b4cdc08532 6c6e7a6847
commit 5dc625c903
73 changed files with 11169 additions and 3079 deletions
--- a/app/admin/_components/admin-menu-navigation.tsx
+++ b/app/admin/_components/admin-menu-navigation.tsx
@@ -1,12 +1,11 @@
+import { SIDEBAR_WIDTH_PROPERTY } from '@/packages/ui/src/shadcn/constants';
+
 import { AppLogo } from '@kit/shared/components/app-logo';
 import { ProfileAccountDropdownContainer } from '@kit/shared/components/personal-account-dropdown-container';
-import { SIDEBAR_WIDTH_PROPERTY } from '@/packages/ui/src/shadcn/constants';

 import type { UserWorkspace } from '../../home/(user)/_lib/server/load-user-workspace';

-export function AdminMenuNavigation(props: {
-  workspace: UserWorkspace;
-}) {
+export function AdminMenuNavigation(props: { workspace: UserWorkspace }) {
  const { accounts } = props.workspace;

  return (
@@ -17,9 +16,7 @@ export function AdminMenuNavigation(props: {

      <div className="flex items-center justify-end gap-3">
        <div>
-          <ProfileAccountDropdownContainer
-            accounts={accounts}
-          />
+          <ProfileAccountDropdownContainer accounts={accounts} />
        </div>
      </div>
    </div>
--- a/app/admin/accounts/[id]/page.tsx
+++ b/app/admin/accounts/[id]/page.tsx
@@ -3,8 +3,8 @@ import { cache } from 'react';
 import { AdminAccountPage } from '@kit/admin/components/admin-account-page';
 import { AdminGuard } from '@kit/admin/components/admin-guard';

-import { getAccount } from '~/lib/services/account.service';
 import { withI18n } from '~/lib/i18n/with-i18n';
+import { getAccount } from '~/lib/services/account.service';

 interface Params {
  params: Promise<{
--- a/app/admin/accounts/page.tsx
+++ b/app/admin/accounts/page.tsx
@@ -8,6 +8,7 @@ import { getSupabaseServerClient } from '@kit/supabase/server-client';
 import { AppBreadcrumbs } from '@kit/ui/app-breadcrumbs';
 import { Button } from '@kit/ui/button';
 import { PageBody, PageHeader } from '@kit/ui/page';
+
 import { withI18n } from '~/lib/i18n/with-i18n';

 interface SearchParams {
--- a/app/admin/layout.tsx
+++ b/app/admin/layout.tsx
@@ -5,8 +5,8 @@ import { cookies } from 'next/headers';
 import { Page, PageMobileNavigation, PageNavigation } from '@kit/ui/page';
 import { SidebarProvider } from '@kit/ui/shadcn-sidebar';

-import { AdminSidebar } from '~/admin/_components/admin-sidebar';
 import { AdminMenuNavigation } from '~/admin/_components/admin-menu-navigation';
+import { AdminSidebar } from '~/admin/_components/admin-sidebar';
 import { AdminMobileNavigation } from '~/admin/_components/mobile-navigation';

 import { loadUserWorkspace } from '../home/(user)/_lib/server/load-user-workspace';
--- a/app/admin/page.tsx
+++ b/app/admin/page.tsx
@@ -1,6 +1,7 @@
 import { AdminDashboard } from '@kit/admin/components/admin-dashboard';
 import { AdminGuard } from '@kit/admin/components/admin-guard';
 import { PageBody, PageHeader } from '@kit/ui/page';
+
 import { withI18n } from '~/lib/i18n/with-i18n';

 function AdminPage() {
--- a/app/api/job/handler/sync-connected-online.ts
+++ b/app/api/job/handler/sync-connected-online.ts
@@ -2,7 +2,40 @@ import axios from 'axios';

 import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';

-import type { ISearchLoadResponse } from '~/lib/types/connected-online';
+import { logSyncResult } from '~/lib/services/audit.service';
+import { SyncStatus } from '~/lib/types/audit';
+import type {
+  ISearchLoadResponse,
+  P_JobTitleTranslation,
+} from '~/lib/types/connected-online';
+
+function createTranslationMap(translations: P_JobTitleTranslation[]) {
+  const result: Map<
+    number,
+    Map<number, { textEN: string; textRU: string; textET: string }>
+  > = new Map();
+
+  for (const translation of translations) {
+    const { ClinicID, TextET, TextEN, TextRU, SyncID } = translation;
+
+    if (!result.has(ClinicID)) {
+      result.set(ClinicID, new Map());
+    }
+
+    result.get(ClinicID)!.set(SyncID, {
+      textET: TextET,
+      textEN: TextEN,
+      textRU: TextRU,
+    });
+  }
+
+  return result;
+}
+
+function getSpokenLanguages(spokenLanguages?: string) {
+  if (!spokenLanguages || !spokenLanguages.length) return [];
+  return spokenLanguages.split(',');
+}

 export default async function syncConnectedOnline() {
  const isProd = process.env.NODE_ENV === 'production';
@@ -16,14 +49,19 @@ export default async function syncConnectedOnline() {
  const supabase = getSupabaseServerAdminClient();

  try {
-    const response = await axios.post<{ d: string }>(`${baseUrl}/Search_Load`, {
-      headers: {
-        'Content-Type': 'application/json; charset=utf-8',
+    const searchLoadResponse = await axios.post<{ d: string }>(
+      `${baseUrl}/Search_Load`,
+      {
+        headers: {
+          'Content-Type': 'application/json; charset=utf-8',
+        },
+        param: "{'Value':'|et|-1'}", // get all available services in Estonian
      },
-      param: "{'Value':'|et|-1'}", // get all available services in Estonian
-    });
+    );

-    const responseData: ISearchLoadResponse = JSON.parse(response.data.d);
+    const responseData: ISearchLoadResponse = JSON.parse(
+      searchLoadResponse.data.d,
+    );

    if (responseData?.ErrorCode !== 0) {
      throw new Error('Failed to get Connected Online data');
@@ -43,16 +81,35 @@ export default async function syncConnectedOnline() {

    let clinics;
    let services;
+    let serviceProviders;
+    let jobTitleTranslations;
    // Filter out "Dentas Demo OÜ" in prod or only sync "Dentas Demo OÜ" in any other environment
+    const isDemoClinic = (clinicId: number) => clinicId === 2;
    if (isProd) {
-      clinics = responseData.Data.T_Lic.filter((clinic) => clinic.ID !== 2);
+      clinics = responseData.Data.T_Lic.filter(({ ID }) => !isDemoClinic(ID));
      services = responseData.Data.T_Service.filter(
-        (service) => service.ClinicID !== 2,
+        ({ ClinicID }) => !isDemoClinic(ClinicID),
+      );
+      serviceProviders = responseData.Data.T_Doctor.filter(
+        ({ ClinicID }) => !isDemoClinic(ClinicID),
+      );
+      jobTitleTranslations = createTranslationMap(
+        responseData.Data.P_JobTitleTranslations.filter(
+          ({ ClinicID }) => !isDemoClinic(ClinicID),
+        ),
      );
    } else {
-      clinics = responseData.Data.T_Lic.filter((clinic) => clinic.ID === 2);
-      services = responseData.Data.T_Service.filter(
-        (service) => service.ClinicID === 2,
+      clinics = responseData.Data.T_Lic.filter(({ ID }) => isDemoClinic(ID));
+      services = responseData.Data.T_Service.filter(({ ClinicID }) =>
+        isDemoClinic(ClinicID),
+      );
+      serviceProviders = responseData.Data.T_Doctor.filter(({ ClinicID }) =>
+        isDemoClinic(ClinicID),
+      );
+      jobTitleTranslations = createTranslationMap(
+        responseData.Data.P_JobTitleTranslations.filter(({ ClinicID }) =>
+          isDemoClinic(ClinicID),
+        ),
      );
    }

@@ -64,6 +121,8 @@ export default async function syncConnectedOnline() {
        name: clinic.Name,
        personal_code_required: !!clinic.PersonalCodeRequired,
        phone_number: clinic.Phone || null,
+        key: clinic.Key,
+        address: clinic.Address,
      };
    });

@@ -71,7 +130,7 @@ export default async function syncConnectedOnline() {
      return {
        id: service.ID,
        clinic_id: service.ClinicID,
-        sync_id: service.SyncID,
+        sync_id: Number(service.SyncID),
        name: service.Name,
        description: service.Description || null,
        price: service.Price,
@@ -87,45 +146,133 @@ export default async function syncConnectedOnline() {
      };
    });

+    const mappedServiceProviders = serviceProviders.map((serviceProvider) => {
+      const jobTitleTranslation = serviceProvider.JobTitleID
+        ? jobTitleTranslations
+            .get(serviceProvider.ClinicID)
+            ?.get(serviceProvider.JobTitleID)
+        : null;
+      return {
+        id: serviceProvider.ID,
+        prefix: serviceProvider.Prefix,
+        name: serviceProvider.Name,
+        spoken_languages: getSpokenLanguages(serviceProvider.SpokenLanguages),
+        job_title_et: jobTitleTranslation?.textET,
+        job_title_en: jobTitleTranslation?.textEN,
+        job_title_ru: jobTitleTranslation?.textRU,
+        job_title_id: serviceProvider.JobTitleID,
+        is_deleted: !!serviceProvider.Deleted,
+        clinic_id: serviceProvider.ClinicID,
+      };
+    });
+
    const { error: providersError } = await supabase
      .schema('medreport')
      .from('connected_online_providers')
      .upsert(mappedClinics);

+    if (providersError) {
+      return logSyncResult({
+        operation: 'CONNECTED_ONLINE_SYNC',
+        comment:
+          'Error saving connected online providers: ' +
+          JSON.stringify(providersError),
+        status: SyncStatus.Fail,
+        changed_by_role: 'service_role',
+      });
+    }
+
    const { error: servicesError } = await supabase
      .schema('medreport')
      .from('connected_online_services')
-      .upsert(mappedServices, { onConflict: 'id', ignoreDuplicates: false });
+      .upsert(mappedServices, {
+        onConflict: 'id',
+        ignoreDuplicates: false,
+      });

-    if (providersError || servicesError) {
-      return supabase
-        .schema('audit')
-        .from('sync_entries')
-        .insert({
-          operation: 'CONNECTED_ONLINE_SYNC',
-          comment: providersError
-            ? 'Error saving providers: ' + JSON.stringify(providersError)
-            : 'Error saving services: ' + JSON.stringify(servicesError),
-          status: 'FAIL',
-          changed_by_role: 'service_role',
-        });
+    if (servicesError) {
+      return logSyncResult({
+        operation: 'CONNECTED_ONLINE_SYNC',
+        comment:
+          'Error saving connected online services: ' +
+          JSON.stringify(servicesError),
+        status: SyncStatus.Fail,
+        changed_by_role: 'service_role',
+      });
    }

-    await supabase.schema('audit').from('sync_entries').insert({
+    const { error: serviceProvidersError } = await supabase
+      .schema('medreport')
+      .from('connected_online_service_providers')
+      .upsert(mappedServiceProviders, {
+        onConflict: 'id',
+        ignoreDuplicates: false,
+      });
+
+    if (serviceProvidersError) {
+      return logSyncResult({
+        operation: 'CONNECTED_ONLINE_SYNC',
+        comment:
+          'Error saving service providers: ' +
+          JSON.stringify(serviceProvidersError),
+        status: SyncStatus.Fail,
+        changed_by_role: 'service_role',
+      });
+    }
+
+    for (const mappedClinic of mappedClinics) {
+      const defaultLoadResponse = await axios.post<{ d: string }>(
+        `${baseUrl}/Default_Load`,
+        {
+          headers: {
+            'Content-Type': 'application/json; charset=utf-8',
+          },
+          param: `{'Value':'${mappedClinic.key}|et'}`,
+        },
+      );
+
+      const defaultLoadResponseData = JSON.parse(defaultLoadResponse.data.d);
+
+      if (defaultLoadResponseData?.ErrorCode !== 0) {
+        throw new Error('Failed to get Connected Online location data');
+      }
+
+      const clinicLocations: {
+        SyncID: number;
+        Address: string;
+        Name: string;
+      }[] = defaultLoadResponseData.Data.T_SelectableLocation;
+
+      if (clinicLocations?.length) {
+        const mappedLocations = clinicLocations.map(
+          ({ SyncID, Address, Name }) => ({
+            address: Address,
+            clinic_id: mappedClinic.id,
+            sync_id: SyncID,
+            name: Name,
+          }),
+        );
+
+        await supabase
+          .schema('medreport')
+          .from('connected_online_locations')
+          .insert(mappedLocations)
+          .throwOnError();
+      }
+    }
+
+    await logSyncResult({
      operation: 'CONNECTED_ONLINE_SYNC',
-      status: 'SUCCESS',
+      status: SyncStatus.Success,
      changed_by_role: 'service_role',
    });
  } catch (e) {
-    await supabase
-      .schema('audit')
-      .from('sync_entries')
-      .insert({
-        operation: 'CONNECTED_ONLINE_SYNC',
-        status: 'FAIL',
-        comment: JSON.stringify(e),
-        changed_by_role: 'service_role',
-      });
+    await logSyncResult({
+      operation: 'CONNECTED_ONLINE_SYNC',
+      status: SyncStatus.Fail,
+      comment: JSON.stringify(e),
+      changed_by_role: 'service_role',
+    });
    throw new Error(
      `Failed to sync Connected Online data, error: ${JSON.stringify(e)}`,
    );
--- a/app/home/(user)/(dashboard)/booking/[handle]/page.tsx
+++ b/app/home/(user)/(dashboard)/booking/[handle]/page.tsx
@@ -1,12 +1,20 @@
+import { redirect } from 'next/navigation';
+
 import { HomeLayoutPageHeader } from '@/app/home/(user)/_components/home-page-header';
 import { loadCategory } from '@/app/home/(user)/_lib/server/load-category';

+import { pathsConfig } from '@kit/shared/config';
 import { AppBreadcrumbs } from '@kit/ui/makerkit/app-breadcrumbs';
-import { PageBody } from '@kit/ui/page';
 import { Trans } from '@kit/ui/trans';

+import BookingContainer from '~/home/(user)/_components/booking/booking-container';
+import { loadCurrentUserAccount } from '~/home/(user)/_lib/server/load-user-account';
 import { createI18nServerInstance } from '~/lib/i18n/i18n.server';
 import { withI18n } from '~/lib/i18n/with-i18n';
+import {
+  PageViewAction,
+  createPageViewLog,
+} from '~/lib/services/audit/pageView.service';

 export const generateMetadata = async () => {
  const i18n = await createI18nServerInstance();
@@ -17,9 +25,30 @@ export const generateMetadata = async () => {
  };
 };

-async function BookingHandlePage({ params }: { params: { handle: string } }) {
-  const handle = await params.handle;
+async function BookingHandlePage({
+  params,
+}: {
+  params: Promise<{ handle: string }>;
+}) {
+  const { handle } = await params;
  const { category } = await loadCategory({ handle });
+  const { account } = await loadCurrentUserAccount();
+
+  if (!category) {
+    return <div>Category not found</div>;
+  }
+
+  if (!account) {
+    return redirect(pathsConfig.auth.signIn);
+  }
+
+  await createPageViewLog({
+    accountId: account.id,
+    action: PageViewAction.VIEW_TTO_SERVICE_BOOKING,
+    extraData: {
+      handle,
+    },
+  });

  return (
    <>
@@ -30,10 +59,10 @@ async function BookingHandlePage({ params }: { params: { handle: string } }) {
      />
      <HomeLayoutPageHeader
        title={<Trans i18nKey={'booking:title'} />}
-        description={<Trans i18nKey={'booking:description'} />}
+        description=""
      />

-      <PageBody></PageBody>
+      <BookingContainer category={category} />
    </>
  );
 }
--- a/app/home/(user)/(dashboard)/cart/montonio-callback/actions.ts
+++ b/app/home/(user)/(dashboard)/cart/montonio-callback/actions.ts
@@ -8,17 +8,20 @@ import type { StoreOrder } from '@medusajs/types';
 import jwt from 'jsonwebtoken';
 import { z } from 'zod';

-import type { AccountWithParams } from '@kit/accounts/types/accounts';
+import { AccountWithParams } from '@kit/accounts/types/accounts';
 import { createNotificationsApi } from '@kit/notifications/api';
 import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';

 import { createI18nServerInstance } from '~/lib/i18n/i18n.server';
+import { bookAppointment } from '~/lib/services/connected-online.service';
 import { sendOrderToMedipost } from '~/lib/services/medipost/medipostPrivateMessage.service';
 import { getOrderedAnalysisIds } from '~/lib/services/medusaOrder.service';
 import {
  createAnalysisOrder,
  getAnalysisOrder,
 } from '~/lib/services/order.service';
+import { getOrderedTtoServices } from '~/lib/services/reservation.service';
+import { FailureReason } from '~/lib/types/connected-online';

 const ANALYSIS_PACKAGES_TYPE_HANDLE = 'analysis-packages';
 const ANALYSIS_TYPE_HANDLE = 'synlab-analysis';
@@ -91,6 +94,10 @@ const sendEmail = async ({
      account_id: account.id,
      body: html,
    });
+    await createNotificationsApi(client).createNotification({
+      account_id: account.id,
+      body: html,
+    });
  } catch (error) {
    throw new Error(`Failed to send email, message=${error}`);
  }
@@ -183,10 +190,7 @@ async function sendAnalysisPackageOrderEmail({
    });
    console.info(`Successfully sent analysis package order email to ${email}`);
  } catch (error) {
-    console.error(
-      `Failed to send analysis package order email to ${email}`,
-      error,
-    );
+    console.error('Failed to send email', error);
  }
 }

@@ -207,6 +211,8 @@ export async function processMontonioCallback(orderToken: string) {
      medusaOrder,
    });

+    const orderContainsSynlabItems = !!orderedAnalysisElements?.length;
+
    try {
      const existingAnalysisOrder = await getAnalysisOrder({
        medusaOrderId: medusaOrder.id,
@@ -219,15 +225,38 @@ export async function processMontonioCallback(orderToken: string) {
      // ignored
    }

-    const orderId = await createAnalysisOrder({
-      medusaOrder,
-      orderedAnalysisElements,
-    });
+    let orderId;
+    if (orderContainsSynlabItems) {
+      orderId = await createAnalysisOrder({
+        medusaOrder,
+        orderedAnalysisElements,
+      });
+    }
+
    const orderResult = await getOrderResultParameters(medusaOrder);

    const { medusaOrderId, email, analysisPackageOrder, analysisItemsOrder } =
      orderResult;

+    const orderedTtoServices = await getOrderedTtoServices({ medusaOrder });
+    let bookServiceResults: {
+      success: boolean;
+      reason?: FailureReason;
+      serviceId?: number;
+    }[] = [];
+    if (orderedTtoServices?.length) {
+      const bookingPromises = orderedTtoServices.map((service) =>
+        bookAppointment(
+          service.service_id,
+          service.clinic_id,
+          service.service_user_id,
+          service.sync_user_id,
+          service.start_time,
+        ),
+      );
+      bookServiceResults = await Promise.all(bookingPromises);
+    }
+
    if (email) {
      if (analysisPackageOrder) {
        await sendAnalysisPackageOrderEmail({
@@ -251,10 +280,21 @@ export async function processMontonioCallback(orderToken: string) {
      console.error('Missing email to send order result email', orderResult);
    }

-    if (env().isEnabledDispatchOnMontonioCallback) {
+    if (env().isEnabledDispatchOnMontonioCallback && orderContainsSynlabItems) {
      await sendOrderToMedipost({ medusaOrderId, orderedAnalysisElements });
    }

+    if (bookServiceResults.some(({ success }) => success === false)) {
+      const failedServiceBookings = bookServiceResults.filter(
+        ({ success }) => success === false,
+      );
+      return {
+        success: false,
+        failedServiceBookings,
+        orderId,
+      };
+    }
+
    return { success: true, orderId };
  } catch (error) {
    console.error('Failed to place order', error);
--- a/app/home/(user)/(dashboard)/cart/montonio-callback/client-component.tsx
+++ b/app/home/(user)/(dashboard)/cart/montonio-callback/client-component.tsx
@@ -34,8 +34,15 @@ export default function MontonioCallbackClient({
      setHasProcessed(true);

      try {
-        const { orderId } = await processMontonioCallback(orderToken);
-        router.push(`/home/order/${orderId}/confirmed`);
+        const result = await processMontonioCallback(orderToken);
+        if (result.success) {
+          return router.push(`/home/order/${result.orderId}/confirmed`);
+        }
+        if (result.failedServiceBookings?.length) {
+          router.push(
+            `/home/cart/montonio-callback/error?reasonFailed=${result.failedServiceBookings.map(({ reason }) => reason).join(',')}`,
+          );
+        }
      } catch (error) {
        console.error('Failed to place order', error);
        router.push('/home/cart/montonio-callback/error');
--- a/app/home/(user)/(dashboard)/cart/montonio-callback/error/page.tsx
+++ b/app/home/(user)/(dashboard)/cart/montonio-callback/error/page.tsx
@@ -1,8 +1,11 @@
+import { use } from 'react';
+
 import Link from 'next/link';

 import { createI18nServerInstance } from '@/lib/i18n/i18n.server';
 import { PageBody, PageHeader } from '@/packages/ui/src/makerkit/page';

+import { toArray } from '@kit/shared/utils';
 import { Button } from '@kit/ui/button';
 import { Alert, AlertDescription } from '@kit/ui/shadcn/alert';
 import { AlertTitle } from '@kit/ui/shadcn/alert';
@@ -16,7 +19,15 @@ export async function generateMetadata() {
  };
 }

-export default async function MontonioCheckoutCallbackErrorPage() {
+export default async function MontonioCheckoutCallbackErrorPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ reasonFailed: string }>;
+}) {
+  const params = await searchParams;
+
+  const failedBookingData: string[] = toArray(params.reasonFailed?.split(','));
+
  return (
    <div className={'flex h-full flex-1 flex-col'}>
      <PageHeader title={<Trans i18nKey="cart:montonioCallback.title" />} />
@@ -28,9 +39,15 @@ export default async function MontonioCheckoutCallbackErrorPage() {
            </AlertTitle>

            <AlertDescription>
-              <p>
+              {failedBookingData.length ? (
+                failedBookingData.map((failureReason, index) => (
+                  <p key={index}>
+                    <Trans i18nKey={`checkout.error.${failureReason}`} />
+                  </p>
+                ))
+              ) : (
                <Trans i18nKey={'checkout.error.description'} />
-              </p>
+              )}
            </AlertDescription>
          </Alert>

--- a/app/home/(user)/(dashboard)/cart/page.tsx
+++ b/app/home/(user)/(dashboard)/cart/page.tsx
@@ -8,9 +8,12 @@ import { listProductTypes } from '@lib/data/products';
 import { Trans } from '@kit/ui/trans';

 import { withI18n } from '~/lib/i18n/with-i18n';
+import { getCartReservations } from '~/lib/services/reservation.service';
+import { findProductTypeIdByHandle } from '~/lib/utils';

 import Cart from '../../_components/cart';
 import CartTimer from '../../_components/cart/cart-timer';
+import { EnrichedCartItem } from '../../_components/cart/types';

 export async function generateMetadata() {
  const { t } = await createI18nServerInstance();
@@ -27,29 +30,33 @@ async function CartPage() {
  });

  const { productTypes } = await listProductTypes();
-  const analysisPackagesType = productTypes.find(
-    ({ metadata }) => metadata?.handle === 'analysis-packages',
+
+  const synlabAnalysisTypeId = findProductTypeIdByHandle(
+    productTypes,
+    'synlab-analysis',
  );
-  const synlabAnalysisType = productTypes.find(
-    ({ metadata }) => metadata?.handle === 'synlab-analysis',
+  const analysisPackagesTypeId = findProductTypeIdByHandle(
+    productTypes,
+    'analysis-packages',
  );
+
  const synlabAnalyses =
-    analysisPackagesType && synlabAnalysisType && cart?.items
+    analysisPackagesTypeId && synlabAnalysisTypeId && cart?.items
      ? cart.items.filter((item) => {
          const productTypeId = item.product?.type_id;
          if (!productTypeId) {
            return false;
          }
-          return [analysisPackagesType.id, synlabAnalysisType.id].includes(
+          return [analysisPackagesTypeId, synlabAnalysisTypeId].includes(
            productTypeId,
          );
        })
      : [];
-  const ttoServiceItems =
-    cart?.items?.filter(
-      (item) => !synlabAnalyses.some((analysis) => analysis.id === item.id),
-    ) ?? [];

+  let ttoServiceItems: EnrichedCartItem[] = [];
+  if (cart?.items?.length) {
+    ttoServiceItems = await getCartReservations(cart);
+  }
  const otherItemsSorted = ttoServiceItems.sort((a, b) =>
    (a.updated_at ?? '') > (b.updated_at ?? '') ? -1 : 1,
  );
--- a/app/home/(user)/(dashboard)/order/page.tsx
+++ b/app/home/(user)/(dashboard)/order/page.tsx
@@ -11,7 +11,8 @@ import { PageBody } from '@kit/ui/makerkit/page';
 import { Trans } from '@kit/ui/trans';

 import { withI18n } from '~/lib/i18n/with-i18n';
-import { getAnalysisOrders } from '~/lib/services/order.service';
+import { getAnalysisOrders, getTtoOrders } from '~/lib/services/order.service';
+import { findProductTypeIdByHandle } from '~/lib/utils';
 import { listOrders } from '~/medusa/lib/data/orders';

 import { HomeLayoutPageHeader } from '../../_components/home-page-header';
@@ -28,15 +29,21 @@ export async function generateMetadata() {
 async function OrdersPage() {
  const medusaOrders = await listOrders();
  const analysisOrders = await getAnalysisOrders();
+  const ttoOrders = await getTtoOrders();
  const { productTypes } = await listProductTypes();

-  if (!medusaOrders || !productTypes) {
+  if (!medusaOrders || !productTypes || !ttoOrders) {
    redirect(pathsConfig.auth.signIn);
  }

-  const analysisPackagesType = productTypes.find(
-    ({ metadata }) => metadata?.handle === 'analysis-packages',
-  )!;
+  const analysisPackagesTypeId = findProductTypeIdByHandle(
+    productTypes,
+    'analysis-package',
+  );
+  const ttoServiceTypeId = findProductTypeIdByHandle(
+    productTypes,
+    'tto-service',
+  );

  return (
    <>
@@ -45,9 +52,9 @@ async function OrdersPage() {
        description={<Trans i18nKey={'orders:description'} />}
      />
      <PageBody>
-        {analysisOrders.map((analysisOrder) => {
-          const medusaOrder = medusaOrders.find(
-            ({ id }) => id === analysisOrder.medusa_order_id,
+        {medusaOrders.map((medusaOrder) => {
+          const analysisOrder = analysisOrders.find(
+            ({ medusa_order_id }) => medusa_order_id === medusaOrder.id,
          );
          if (!medusaOrder) {
            return null;
@@ -55,18 +62,27 @@ async function OrdersPage() {

          const medusaOrderItems = medusaOrder.items || [];
          const medusaOrderItemsAnalysisPackages = medusaOrderItems.filter(
-            (item) => item.product_type_id === analysisPackagesType?.id,
+            (item) => item.product_type_id === analysisPackagesTypeId,
+          );
+          const medusaOrderItemsTtoServices = medusaOrderItems.filter(
+            (item) => item.product_type_id === ttoServiceTypeId,
          );
          const medusaOrderItemsOther = medusaOrderItems.filter(
-            (item) => item.product_type_id !== analysisPackagesType?.id,
+            (item) =>
+              !item.product_type_id ||
+              ![analysisPackagesTypeId, ttoServiceTypeId].includes(
+                item.product_type_id,
+              ),
          );

          return (
-            <React.Fragment key={analysisOrder.id}>
+            <React.Fragment key={medusaOrder.id}>
              <Divider className="my-6" />
              <OrderBlock
+                medusaOrderId={medusaOrder.id}
                analysisOrder={analysisOrder}
                itemsAnalysisPackage={medusaOrderItemsAnalysisPackages}
+                itemsTtoService={medusaOrderItemsTtoServices}
                itemsOther={medusaOrderItemsOther}
              />
            </React.Fragment>
--- a/app/home/(user)/_components/booking/booking-calendar.tsx
+++ b/app/home/(user)/_components/booking/booking-calendar.tsx
@@ -0,0 +1,40 @@
+'use client';
+
+import { isBefore, isSameDay } from 'date-fns';
+import { uniq } from 'lodash';
+
+import { Calendar } from '@kit/ui/shadcn/calendar';
+import { Card } from '@kit/ui/shadcn/card';
+import { cn } from '@kit/ui/utils';
+
+import { useBooking } from './booking.provider';
+
+export default function BookingCalendar() {
+  const { selectedDate, setSelectedDate, isLoadingTimeSlots, timeSlots } =
+    useBooking();
+  const availableDates = uniq(timeSlots?.map((timeSlot) => timeSlot.StartTime));
+
+  return (
+    <Card className="mb-4">
+      <Calendar
+        mode="single"
+        selected={selectedDate}
+        onSelect={setSelectedDate}
+        disabled={(date) => {
+          const today = new Date();
+          today.setHours(0, 0, 0, 0);
+          return (
+            isBefore(date, today) ||
+            !availableDates.some((dateWithBooking) =>
+              isSameDay(date, dateWithBooking),
+            )
+          );
+        }}
+        className={cn('rounded-md border', {
+          'pointer-events-none rounded-md border opacity-50':
+            isLoadingTimeSlots,
+        })}
+      />
+    </Card>
+  );
+}
--- a/app/home/(user)/_components/booking/booking-container.tsx
+++ b/app/home/(user)/_components/booking/booking-container.tsx
@@ -0,0 +1,49 @@
+'use client';
+
+import { StoreProduct } from '@medusajs/types';
+
+import { Trans } from '@kit/ui/trans';
+
+import { EnrichedCartItem } from '../cart/types';
+import BookingCalendar from './booking-calendar';
+import { BookingProvider } from './booking.provider';
+import LocationSelector from './location-selector';
+import ServiceSelector from './service-selector';
+import TimeSlots from './time-slots';
+
+const BookingContainer = ({
+  category,
+  cartItem,
+  onComplete,
+}: {
+  category: { products: StoreProduct[]; countryCode: string };
+  cartItem?: EnrichedCartItem;
+  onComplete?: () => void;
+}) => {
+  const products = cartItem?.product ? [cartItem.product] : category.products;
+
+  if (!cartItem || !products?.length) {
+    <p>
+      <Trans i18nKey="booking:noProducts" />
+    </p>;
+  }
+
+  return (
+    <BookingProvider category={{ products }} service={cartItem?.product}>
+      <div className="xs:flex-row flex max-h-full flex-col gap-6">
+        <div className="flex flex-col">
+          <ServiceSelector products={products} />
+          <BookingCalendar />
+          <LocationSelector />
+        </div>
+        <TimeSlots
+          countryCode={category.countryCode}
+          cartItem={cartItem}
+          onComplete={onComplete}
+        />
+      </div>
+    </BookingProvider>
+  );
+};
+
+export default BookingContainer;
--- a/app/home/(user)/_components/booking/booking.context.ts
+++ b/app/home/(user)/_components/booking/booking.context.ts
@@ -0,0 +1,77 @@
+import { createContext } from 'react';
+
+import { StoreProduct } from '@medusajs/types';
+import { noop } from 'lodash';
+
+import { Tables } from '@kit/supabase/database';
+
+export type Location = Tables<
+  { schema: 'medreport' },
+  'connected_online_locations'
+>;
+
+export type TimeSlotResponse = {
+  timeSlots: TimeSlot[];
+  locations: Location[];
+};
+
+export type TimeSlot = {
+  ClinicID: number;
+  LocationID: number;
+  UserID: number;
+  SyncUserID: number;
+  ServiceID: number;
+  HKServiceID: number;
+  StartTime: Date;
+  EndTime: Date;
+  PayorCode: string;
+  serviceProvider?: ServiceProvider;
+  syncedService?: SyncedService;
+} & { location?: Location };
+
+export type ServiceProvider = {
+  name: string;
+  id: number;
+  jobTitleEn: string | null;
+  jobTitleEt: string | null;
+  jobTitleRu: string | null;
+  clinicId: number;
+};
+
+export type SyncedService = Tables<
+  { schema: 'medreport' },
+  'connected_online_services'
+> & {
+  providerClinic: ProviderClinic;
+};
+
+export type ProviderClinic = Tables<
+  { schema: 'medreport' },
+  'connected_online_providers'
+> & { locations: Location[] };
+
+const BookingContext = createContext<{
+  timeSlots: TimeSlot[] | null;
+  selectedService: StoreProduct | null;
+  locations: Location[] | null;
+  selectedLocationId: number | null;
+  selectedDate?: Date;
+  isLoadingTimeSlots?: boolean;
+  setSelectedService: (selectedService: StoreProduct | null) => void;
+  setSelectedLocationId: (selectedLocationId: number | null) => void;
+  updateTimeSlots: (serviceIds: number[]) => Promise<void>;
+  setSelectedDate: (selectedDate?: Date) => void;
+}>({
+  timeSlots: null,
+  selectedService: null,
+  locations: null,
+  selectedLocationId: null,
+  selectedDate: new Date(),
+  isLoadingTimeSlots: false,
+  setSelectedService: (_) => _,
+  setSelectedLocationId: (_) => _,
+  updateTimeSlots: async (_) => noop(),
+  setSelectedDate: (_) => _,
+});
+
+export { BookingContext };
--- a/app/home/(user)/_components/booking/booking.provider.tsx
+++ b/app/home/(user)/_components/booking/booking.provider.tsx
@@ -0,0 +1,80 @@
+import React, { useContext, useEffect, useState } from 'react';
+
+import { StoreProduct } from '@medusajs/types';
+
+import { getAvailableTimeSlotsForDisplay } from '~/lib/services/connected-online.service';
+
+import { BookingContext, Location, TimeSlot } from './booking.context';
+
+export function useBooking() {
+  const context = useContext(BookingContext);
+
+  if (!context) {
+    throw new Error('useBooking must be used within a BookingProvider.');
+  }
+
+  return context;
+}
+
+export const BookingProvider: React.FC<{
+  children: React.ReactElement;
+  category: { products: StoreProduct[] };
+  service?: StoreProduct;
+}> = ({ children, category, service }) => {
+  const [selectedService, setSelectedService] = useState<StoreProduct | null>(
+    (service ?? category?.products?.[0]) || null,
+  );
+  const [selectedLocationId, setSelectedLocationId] = useState<number | null>(
+    null,
+  );
+  const [selectedDate, setSelectedDate] = useState<Date>();
+  const [timeSlots, setTimeSlots] = useState<TimeSlot[] | null>(null);
+  const [locations, setLocations] = useState<Location[] | null>(null);
+  const [isLoadingTimeSlots, setIsLoadingTimeSlots] = useState(false);
+
+  useEffect(() => {
+    const metadataServiceIds = selectedService?.metadata?.serviceIds as string;
+    if (metadataServiceIds) {
+      const json = JSON.parse(metadataServiceIds);
+      if (Array.isArray(json)) {
+        updateTimeSlots(json);
+      }
+    }
+  }, [selectedService, selectedLocationId]);
+
+  const updateTimeSlots = async (serviceIds: number[]) => {
+    setIsLoadingTimeSlots(true);
+    try {
+      console.log('serviceIds', serviceIds, selectedLocationId);
+      const response = await getAvailableTimeSlotsForDisplay(
+        serviceIds,
+        selectedLocationId,
+      );
+      setTimeSlots(response.timeSlots);
+      setLocations(response.locations);
+    } catch (error) {
+      setTimeSlots(null);
+    } finally {
+      setIsLoadingTimeSlots(false);
+    }
+  };
+
+  return (
+    <BookingContext.Provider
+      value={{
+        timeSlots,
+        locations,
+        selectedService,
+        selectedLocationId,
+        setSelectedLocationId,
+        selectedDate,
+        isLoadingTimeSlots,
+        setSelectedService,
+        updateTimeSlots,
+        setSelectedDate,
+      }}
+    >
+      {children}
+    </BookingContext.Provider>
+  );
+};
--- a/app/home/(user)/_components/booking/location-selector.tsx
+++ b/app/home/(user)/_components/booking/location-selector.tsx
@@ -0,0 +1,55 @@
+import { Label } from '@medusajs/ui';
+import { useTranslation } from 'react-i18next';
+
+import { RadioGroup, RadioGroupItem } from '@kit/ui/radio-group';
+import { Card } from '@kit/ui/shadcn/card';
+import { Trans } from '@kit/ui/trans';
+
+import { useBooking } from './booking.provider';
+
+const LocationSelector = () => {
+  const { t } = useTranslation();
+  const { selectedLocationId, setSelectedLocationId, locations } = useBooking();
+
+  const onLocationSelect = (locationId: number | string | null) => {
+    if (locationId === 'all') return setSelectedLocationId(null);
+    setSelectedLocationId(Number(locationId));
+  };
+
+  return (
+    <Card className="mb-4 p-4">
+      <h5 className="text-semibold mb-2">
+        <Trans i18nKey="booking:locations" />
+      </h5>
+      <div className="flex flex-col">
+        <RadioGroup
+          className="mb-2 flex flex-col"
+          onValueChange={(val) => onLocationSelect(val)}
+        >
+          <div className="flex items-center gap-2">
+            <RadioGroupItem
+              value={'all'}
+              id={'all'}
+              checked={selectedLocationId === null}
+            />
+            <Label htmlFor={'all'}>{t('booking:showAllLocations')}</Label>
+          </div>
+          {locations?.map((location) => (
+            <div key={location.sync_id} className="flex items-center gap-2">
+              <RadioGroupItem
+                value={location.sync_id.toString()}
+                id={location.sync_id.toString()}
+                checked={selectedLocationId === location.sync_id}
+              />
+              <Label htmlFor={location.sync_id.toString()}>
+                {location.name}
+              </Label>
+            </div>
+          ))}
+        </RadioGroup>
+      </div>
+    </Card>
+  );
+};
+
+export default LocationSelector;
--- a/app/home/(user)/_components/booking/service-selector.tsx
+++ b/app/home/(user)/_components/booking/service-selector.tsx
@@ -0,0 +1,85 @@
+import { useState } from 'react';
+
+import { StoreProduct } from '@medusajs/types';
+import { ChevronDown } from 'lucide-react';
+
+import { Card } from '@kit/ui/shadcn/card';
+import { Label } from '@kit/ui/shadcn/label';
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from '@kit/ui/shadcn/popover';
+import { RadioGroup, RadioGroupItem } from '@kit/ui/shadcn/radio-group';
+import { Trans } from '@kit/ui/trans';
+
+import { useBooking } from './booking.provider';
+
+const ServiceSelector = ({ products }: { products: StoreProduct[] }) => {
+  const { selectedService, setSelectedService } = useBooking();
+  const [collapsed, setCollapsed] = useState(false);
+  const [firstFourProducts] = useState<StoreProduct[]>(products?.slice(0, 4));
+
+  const onServiceSelect = async (productId: StoreProduct['id']) => {
+    const product = products.find((p) => p.id === productId);
+    setSelectedService(product ?? null);
+    setCollapsed(false);
+  };
+
+  return (
+    <Card className="mb-4 p-4">
+      <h5 className="text-semibold mb-2">
+        <Trans i18nKey="booking:services" />
+      </h5>
+      <Popover open={collapsed} onOpenChange={setCollapsed}>
+        <div className="flex flex-col">
+          <RadioGroup
+            defaultValue={selectedService?.id || ''}
+            className="mb-2 flex flex-col"
+            onValueChange={onServiceSelect}
+          >
+            {firstFourProducts?.map((product) => (
+              <div key={product.id} className="flex items-center gap-2">
+                <RadioGroupItem
+                  value={product.id}
+                  id={product.id}
+                  checked={selectedService?.id === product.id}
+                />
+                <Label htmlFor={product.id}>{product.title}</Label>
+              </div>
+            ))}
+          </RadioGroup>
+          {products.length > 4 && (
+            <PopoverTrigger asChild>
+              <div
+                onClick={() => setCollapsed((_) => !_)}
+                className="flex cursor-pointer items-center justify-between border-t py-1"
+              >
+                <span>
+                  <Trans i18nKey="booking:showAll" />
+                </span>
+                <ChevronDown />
+              </div>
+            </PopoverTrigger>
+          )}
+        </div>
+        <PopoverContent sideOffset={10}>
+          <RadioGroup onValueChange={onServiceSelect}>
+            {products?.map((product) => (
+              <div key={product.id + '-2'} className="flex items-center gap-2">
+                <RadioGroupItem
+                  value={product.id}
+                  id={product.id + '-2'}
+                  checked={selectedService?.id === product.id}
+                />
+                <Label htmlFor={product.id + '-2'}>{product.title}</Label>
+              </div>
+            ))}
+          </RadioGroup>
+        </PopoverContent>
+      </Popover>
+    </Card>
+  );
+};
+
+export default ServiceSelector;
--- a/app/home/(user)/_components/booking/time-slots.tsx
+++ b/app/home/(user)/_components/booking/time-slots.tsx
@@ -0,0 +1,317 @@
+import { useMemo, useState } from 'react';
+
+import { useRouter } from 'next/navigation';
+
+import { formatCurrency } from '@/packages/shared/src/utils';
+import { addHours, isAfter, isSameDay } from 'date-fns';
+import { orderBy } from 'lodash';
+import { useTranslation } from 'react-i18next';
+
+import { pathsConfig } from '@kit/shared/config';
+import { formatDateAndTime } from '@kit/shared/utils';
+import { Button } from '@kit/ui/shadcn/button';
+import { Card } from '@kit/ui/shadcn/card';
+import { toast } from '@kit/ui/sonner';
+import { Trans } from '@kit/ui/trans';
+import { cn } from '@kit/ui/utils';
+
+import { updateReservationTime } from '~/lib/services/reservation.service';
+
+import { createInitialReservationAction } from '../../_lib/server/actions';
+import { EnrichedCartItem } from '../cart/types';
+import { ServiceProvider, TimeSlot } from './booking.context';
+import { useBooking } from './booking.provider';
+
+const getServiceProviderTitle = (
+  currentLocale: string,
+  serviceProvider?: ServiceProvider,
+) => {
+  if (!serviceProvider) return null;
+  if (currentLocale === 'en') return serviceProvider.jobTitleEn;
+  if (currentLocale === 'ru') return serviceProvider.jobTitleRu;
+
+  return serviceProvider.jobTitleEt;
+};
+
+const PAGE_SIZE = 7;
+
+const TimeSlots = ({
+  countryCode,
+  cartItem,
+  onComplete,
+}: {
+  countryCode: string;
+  cartItem?: EnrichedCartItem;
+  onComplete?: () => void;
+}) => {
+  const [currentPage, setCurrentPage] = useState(1);
+
+  const {
+    t,
+    i18n: { language: currentLocale },
+  } = useTranslation();
+
+  const booking = useBooking();
+
+  const router = useRouter();
+
+  const selectedDate = booking.selectedDate ?? new Date();
+
+  const filteredBookings = useMemo(
+    () =>
+      orderBy(
+        booking?.timeSlots?.filter(({ StartTime }) => {
+          const firstAvailableTimeToSelect = isSameDay(selectedDate, new Date())
+            ? addHours(new Date(), 0.5)
+            : selectedDate;
+          return isAfter(StartTime, firstAvailableTimeToSelect);
+        }) ?? [],
+        'StartTime',
+        'asc',
+      ),
+    [booking.timeSlots, selectedDate],
+  );
+
+  const totalPages = Math.ceil(filteredBookings.length / PAGE_SIZE);
+
+  const paginatedBookings = useMemo(() => {
+    const startIndex = (currentPage - 1) * PAGE_SIZE;
+    const endIndex = startIndex + PAGE_SIZE;
+    return filteredBookings.slice(startIndex, endIndex);
+  }, [filteredBookings, currentPage, PAGE_SIZE]);
+
+  const handlePageChange = (page: number) => {
+    setCurrentPage(page);
+  };
+
+  const generatePageNumbers = () => {
+    const pages = [];
+    const maxVisiblePages = 5;
+
+    if (totalPages <= maxVisiblePages) {
+      for (let i = 1; i <= totalPages; i++) {
+        pages.push(i);
+      }
+    } else {
+      if (currentPage <= 3) {
+        for (let i = 1; i <= 4; i++) {
+          pages.push(i);
+        }
+        pages.push('...');
+        pages.push(totalPages);
+      } else if (currentPage >= totalPages - 2) {
+        pages.push(1);
+        pages.push('...');
+        for (let i = totalPages - 3; i <= totalPages; i++) {
+          pages.push(i);
+        }
+      } else {
+        pages.push(1);
+        pages.push('...');
+        for (let i = currentPage - 1; i <= currentPage + 1; i++) {
+          pages.push(i);
+        }
+        pages.push('...');
+        pages.push(totalPages);
+      }
+    }
+
+    return pages;
+  };
+
+  if (!booking?.timeSlots?.length) {
+    return null;
+  }
+
+  const handleBookTime = async (timeSlot: TimeSlot, comments?: string) => {
+    const selectedService = booking.selectedService;
+
+    const selectedVariant = selectedService?.variants?.[0];
+
+    const syncedService = timeSlot.syncedService;
+    if (!syncedService || !selectedVariant) {
+      return toast.error(t('booking:serviceNotFound'));
+    }
+
+    const bookTimePromise = createInitialReservationAction(
+      selectedVariant,
+      countryCode,
+      Number(syncedService.id),
+      syncedService?.clinic_id,
+      timeSlot.UserID,
+      timeSlot.SyncUserID,
+      timeSlot.StartTime,
+      booking.selectedLocationId ? booking.selectedLocationId : null,
+      comments,
+    ).then(() => {
+      if (onComplete) {
+        onComplete();
+      }
+      router.push(pathsConfig.app.cart);
+    });
+
+    toast.promise(() => bookTimePromise, {
+      success: <Trans i18nKey={'booking:bookTimeSuccess'} />,
+      error: <Trans i18nKey={'booking:bookTimeError'} />,
+      loading: <Trans i18nKey={'booking:bookTimeLoading'} />,
+    });
+  };
+
+  const handleChangeTime = async (
+    timeSlot: TimeSlot,
+    reservationId: number,
+    cartId: string,
+  ) => {
+    const syncedService = timeSlot.syncedService;
+    if (!syncedService) {
+      return toast.error(t('booking:serviceNotFound'));
+    }
+
+    const bookTimePromise = updateReservationTime(
+      reservationId,
+      timeSlot.StartTime,
+      Number(syncedService.id),
+      timeSlot.UserID,
+      timeSlot.SyncUserID,
+      booking.selectedLocationId ? booking.selectedLocationId : null,
+      cartId,
+    );
+
+    toast.promise(() => bookTimePromise, {
+      success: <Trans i18nKey={'booking:bookTimeSuccess'} />,
+      error: <Trans i18nKey={'booking:bookTimeError'} />,
+      loading: <Trans i18nKey={'booking:bookTimeLoading'} />,
+    });
+
+    if (onComplete) {
+      onComplete();
+    }
+  };
+
+  const handleTimeSelect = async (timeSlot: TimeSlot) => {
+    if (cartItem?.reservation.id) {
+      return handleChangeTime(
+        timeSlot,
+        cartItem.reservation.id,
+        cartItem.cart_id,
+      );
+    }
+
+    return handleBookTime(timeSlot);
+  };
+
+  return (
+    <div className="flex w-full flex-col gap-4">
+      <div className="flex h-full w-full flex-col gap-2 overflow-auto">
+        {paginatedBookings.map((timeSlot, index) => {
+          const isEHIF = timeSlot.HKServiceID > 0;
+          const serviceProviderTitle = getServiceProviderTitle(
+            currentLocale,
+            timeSlot.serviceProvider,
+          );
+          const price =
+            booking.selectedService?.variants?.[0]?.calculated_price
+              ?.calculated_amount ?? cartItem?.unit_price;
+          return (
+            <Card
+              className="xs:flex xs:justify-between grid w-full justify-center-safe gap-3 p-4"
+              key={index}
+            >
+              <div>
+                <span>{formatDateAndTime(timeSlot.StartTime.toString())}</span>
+                <div className="flex">
+                  <h5
+                    className={cn(
+                      (serviceProviderTitle || isEHIF) &&
+                        "after:mx-2 after:content-['·']",
+                    )}
+                  >
+                    {timeSlot.serviceProvider?.name}
+                  </h5>
+                  {serviceProviderTitle && (
+                    <span
+                      className={cn(isEHIF && "after:mx-2 after:content-['·']")}
+                    >
+                      {serviceProviderTitle}
+                    </span>
+                  )}
+                  {isEHIF && <span>{t('booking:ehifBooking')}</span>}
+                </div>
+                <div className="flex text-xs">{timeSlot.location?.address}</div>
+              </div>
+              <div className="flex-end not-last:xs:justify-center flex items-center justify-between gap-2">
+                <span className="text-sm font-semibold">
+                  {formatCurrency({
+                    currencyCode: 'EUR',
+                    locale: 'et-EE',
+                    value: price ?? '',
+                  })}
+                </span>
+                <Button onClick={() => handleTimeSelect(timeSlot)} size="sm">
+                  <Trans i18nKey="common:book" />
+                </Button>
+              </div>
+            </Card>
+          );
+        })}
+
+        {!paginatedBookings.length && (
+          <div className="wrap text-muted-foreground flex size-full content-center-safe justify-center-safe">
+            <p>{t('booking:noResults')}</p>
+          </div>
+        )}
+      </div>
+
+      {totalPages > 1 && (
+        <div className="flex items-center justify-between">
+          <div className="text-muted-foreground text-sm">
+            {t('common:pageOfPages', {
+              page: currentPage,
+              total: totalPages,
+            })}
+          </div>
+
+          <div className="flex items-center gap-1">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => handlePageChange(currentPage - 1)}
+              disabled={currentPage === 1}
+            >
+              <Trans i18nKey="common:previous" defaultValue="Previous" />
+            </Button>
+
+            {generatePageNumbers().map((page, index) => (
+              <Button
+                key={index}
+                variant={page === currentPage ? 'default' : 'outline'}
+                size="sm"
+                onClick={() =>
+                  typeof page === 'number' && handlePageChange(page)
+                }
+                disabled={page === '...'}
+                className={cn(
+                  'min-w-[2rem]',
+                  page === '...' && 'cursor-default hover:bg-transparent',
+                )}
+              >
+                {page}
+              </Button>
+            ))}
+
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => handlePageChange(currentPage + 1)}
+              disabled={currentPage === totalPages}
+            >
+              <Trans i18nKey="common:next" defaultValue="Next" />
+            </Button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default TimeSlots;
--- a/app/home/(user)/_components/cart/cart-service-item.tsx
+++ b/app/home/(user)/_components/cart/cart-service-item.tsx
@@ -0,0 +1,146 @@
+'use client';
+
+import { useState } from 'react';
+
+import { formatCurrency, formatDateAndTime } from '@/packages/shared/src/utils';
+import { useTranslation } from 'react-i18next';
+
+import { Button } from '@kit/ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from '@kit/ui/dialog';
+import { TableCell, TableRow } from '@kit/ui/table';
+import { Trans } from '@kit/ui/trans';
+
+import BookingContainer from '../booking/booking-container';
+import CartItemDelete from './cart-item-delete';
+import { EnrichedCartItem } from './types';
+
+const EditCartServiceItemModal = ({
+  item,
+  onComplete,
+}: {
+  item: EnrichedCartItem | null;
+  onComplete: () => void;
+}) => {
+  if (!item) return null;
+
+  return (
+    <Dialog defaultOpen>
+      <DialogContent className="xs:max-w-[90vw] flex max-h-screen max-w-full flex-col items-center gap-4 space-y-4 overflow-y-scroll">
+        <DialogHeader className="items-center text-center">
+          <DialogTitle>
+            <Trans i18nKey="cart:editServiceItem.title" />
+          </DialogTitle>
+          <DialogDescription>
+            <Trans i18nKey="cart:editServiceItem.description" />
+          </DialogDescription>
+        </DialogHeader>
+        <div>
+          {item.product && item.reservation.countryCode ? (
+            <BookingContainer
+              category={{
+                products: [item.product],
+                countryCode: item.reservation.countryCode,
+              }}
+              cartItem={item}
+              onComplete={onComplete}
+            />
+          ) : (
+            <p>
+              <Trans i18nKey="booking:noProducts" />
+            </p>
+          )}
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+};
+
+export default function CartServiceItem({
+  item,
+  currencyCode,
+  isUnavailable,
+}: {
+  item: EnrichedCartItem;
+  currencyCode: string;
+  isUnavailable?: boolean;
+}) {
+  const [editingItem, setEditingItem] = useState<EnrichedCartItem | null>(null);
+  const {
+    i18n: { language },
+  } = useTranslation();
+
+  return (
+    <>
+      <TableRow className="w-full" data-testid="product-row">
+        <TableCell className="w-[100%] px-4 text-left sm:px-6">
+          <p
+            className="txt-medium-plus text-ui-fg-base"
+            data-testid="product-title"
+          >
+            {item.product_title}
+          </p>
+        </TableCell>
+
+        <TableCell className="px-4 sm:px-6">
+          {formatDateAndTime(item.reservation.startTime.toString())}
+        </TableCell>
+
+        <TableCell className="px-4 sm:px-6">
+          {item.reservation.location?.address ?? '-'}
+        </TableCell>
+
+        <TableCell className="px-4 sm:px-6">{item.quantity}</TableCell>
+
+        <TableCell className="min-w-[80px] px-4 sm:px-6">
+          {formatCurrency({
+            value: item.unit_price,
+            currencyCode,
+            locale: language,
+          })}
+        </TableCell>
+
+        <TableCell className="min-w-[80px] px-4 text-right sm:px-6">
+          {formatCurrency({
+            value: item.total,
+            currencyCode,
+            locale: language,
+          })}
+        </TableCell>
+
+        <TableCell className="px-4 text-right sm:px-6">
+          <span className="flex justify-end gap-x-1">
+            <Button size="sm" onClick={() => setEditingItem(item)}>
+              <Trans i18nKey="common:change" />
+            </Button>
+          </span>
+        </TableCell>
+
+        <TableCell className="px-4 text-right sm:px-6">
+          <span className="flex w-[60px] justify-end gap-x-1">
+            <CartItemDelete id={item.id} />
+          </span>
+        </TableCell>
+      </TableRow>
+      {isUnavailable && (
+        <TableRow>
+          <TableCell
+            colSpan={8}
+            className="text-destructive px-4 text-left sm:px-6"
+          >
+            <Trans i18nKey="booking:timeSlotUnavailable" />
+          </TableCell>
+        </TableRow>
+      )}
+      <EditCartServiceItemModal
+        item={editingItem}
+        onComplete={() => setEditingItem(null)}
+      />
+    </>
+  );
+}
--- a/app/home/(user)/_components/cart/cart-service-items.tsx
+++ b/app/home/(user)/_components/cart/cart-service-items.tsx
@@ -0,0 +1,72 @@
+import { StoreCart } from '@medusajs/types';
+
+import {
+  Table,
+  TableBody,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@kit/ui/table';
+import { Trans } from '@kit/ui/trans';
+
+import CartServiceItem from './cart-service-item';
+import { EnrichedCartItem } from './types';
+
+export default function CartServiceItems({
+  cart,
+  items,
+  productColumnLabelKey,
+  unavailableLineItemIds,
+}: {
+  cart: StoreCart;
+  items: EnrichedCartItem[];
+  productColumnLabelKey: string;
+  unavailableLineItemIds?: string[];
+}) {
+  if (!items || items.length === 0) {
+    return null;
+  }
+
+  return (
+    <Table className="border-separate rounded-lg border">
+      <TableHeader className="text-ui-fg-subtle txt-medium-plus">
+        <TableRow>
+          <TableHead className="px-4 sm:px-6">
+            <Trans i18nKey={productColumnLabelKey} />
+          </TableHead>
+          <TableHead className="px-4 sm:px-6">
+            <Trans i18nKey="cart:table.time" />
+          </TableHead>
+          <TableHead className="px-4 sm:px-6">
+            <Trans i18nKey="cart:table.location" />
+          </TableHead>
+          <TableHead className="px-4 sm:px-6">
+            <Trans i18nKey="cart:table.quantity" />
+          </TableHead>
+          <TableHead className="min-w-[100px] px-4 sm:px-6">
+            <Trans i18nKey="cart:table.price" />
+          </TableHead>
+          <TableHead className="min-w-[100px] px-4 text-right sm:px-6">
+            <Trans i18nKey="cart:table.total" />
+          </TableHead>
+          <TableHead className="px-4 sm:px-6"></TableHead>
+          <TableHead className="px-4 sm:px-6"></TableHead>
+        </TableRow>
+      </TableHeader>
+      <TableBody>
+        {items
+          .sort((a, b) =>
+            (a.created_at ?? '') > (b.created_at ?? '') ? -1 : 1,
+          )
+          .map((item) => (
+            <CartServiceItem
+              key={item.id}
+              item={item}
+              currencyCode={cart.currency_code}
+              isUnavailable={unavailableLineItemIds?.includes(item.id)}
+            />
+          ))}
+      </TableBody>
+    </Table>
+  );
+}
--- a/app/home/(user)/_components/cart/index.tsx
+++ b/app/home/(user)/_components/cart/index.tsx
@@ -15,7 +15,9 @@ import { Trans } from '@kit/ui/trans';

 import AnalysisLocation from './analysis-location';
 import CartItems from './cart-items';
+import CartServiceItems from './cart-service-items';
 import DiscountCode from './discount-code';
+import { EnrichedCartItem } from './types';

 const IS_DISCOUNT_SHOWN = true as boolean;

@@ -26,13 +28,15 @@ export default function Cart({
 }: {
  cart: StoreCart | null;
  synlabAnalyses: StoreCartLineItem[];
-  ttoServiceItems: StoreCartLineItem[];
+  ttoServiceItems: EnrichedCartItem[];
 }) {
  const {
    i18n: { language },
  } = useTranslation();

  const [isInitiatingSession, setIsInitiatingSession] = useState(false);
+  const [unavailableLineItemIds, setUnavailableLineItemIds] =
+    useState<string[]>();

  const items = cart?.items ?? [];

@@ -64,8 +68,16 @@ export default function Cart({
    if (response.payment_collection) {
      const { payment_sessions } = response.payment_collection;
      const paymentSessionId = payment_sessions![0]!.id;
-      const url = await handleNavigateToPayment({ language, paymentSessionId });
-      window.location.href = url;
+      const result = await handleNavigateToPayment({
+        language,
+        paymentSessionId,
+      });
+      if (result.url) {
+        window.location.href = result.url;
+      }
+      if (result.unavailableLineItemIds) {
+        setUnavailableLineItemIds(result.unavailableLineItemIds);
+      }
    } else {
      setIsInitiatingSession(false);
    }
@@ -82,10 +94,11 @@ export default function Cart({
          items={synlabAnalyses}
          productColumnLabelKey="cart:items.synlabAnalyses.productColumnLabel"
        />
-        <CartItems
+        <CartServiceItems
          cart={cart}
          items={ttoServiceItems}
          productColumnLabelKey="cart:items.ttoServices.productColumnLabel"
+          unavailableLineItemIds={unavailableLineItemIds}
        />
      </div>
      {hasCartItems && (
@@ -167,6 +180,10 @@ export default function Cart({
                cart={{ ...cart }}
                synlabAnalyses={synlabAnalyses}
              />
+              <AnalysisLocation
+                cart={{ ...cart }}
+                synlabAnalyses={synlabAnalyses}
+              />
            </CardContent>
          </Card>
        )}
--- a/app/home/(user)/_components/cart/types.ts
+++ b/app/home/(user)/_components/cart/types.ts
@@ -1,3 +1,6 @@
+import { StoreCartLineItem } from "@medusajs/types";
+import { Reservation } from "~/lib/types/reservation";
+
 export interface MontonioOrderToken {
  uuid: string;
  accessKey: string;
@@ -10,6 +13,12 @@ export interface MontonioOrderToken {
    | 'PENDING'
    | 'EXPIRED'
    | 'REFUNDED';
+    | 'PAID'
+    | 'FAILED'
+    | 'CANCELLED'
+    | 'PENDING'
+    | 'EXPIRED'
+    | 'REFUNDED';
  paymentMethod: string;
  grandTotal: number;
  currency: string;
@@ -20,3 +29,10 @@ export interface MontonioOrderToken {
  iat: number;
  exp: number;
 }
+
+export enum CartItemType {
+  analysisOrders = 'analysisOrders',
+  ttoServices = 'ttoServices',
+}
+
+export type EnrichedCartItem = StoreCartLineItem & { reservation: Reservation };
--- a/app/home/(user)/_components/order-analyses-cards.tsx
+++ b/app/home/(user)/_components/order-analyses-cards.tsx
@@ -103,7 +103,6 @@ export default function OrderAnalysesCards({
                  {title}
                  {description && (
                    <>
-                      {'  '}
                      <InfoTooltip
                        content={
                          <div className="flex flex-col gap-2">
--- a/app/home/(user)/_components/orders/order-block.tsx
+++ b/app/home/(user)/_components/orders/order-block.tsx
@@ -12,40 +12,54 @@ import OrderItemsTable from './order-items-table';
 export default function OrderBlock({
  analysisOrder,
  itemsAnalysisPackage,
+  itemsTtoService,
  itemsOther,
+  medusaOrderId,
 }: {
-  analysisOrder: AnalysisOrder;
+  analysisOrder?: AnalysisOrder;
  itemsAnalysisPackage: StoreOrderLineItem[];
+  itemsTtoService: StoreOrderLineItem[];
  itemsOther: StoreOrderLineItem[];
+  medusaOrderId: string;
 }) {
  return (
    <div className="flex flex-col gap-4">
      <h4>
        <Trans
          i18nKey="analysis-results:orderTitle"
-          values={{ orderNumber: analysisOrder.medusa_order_id }}
+          values={{ orderNumber: medusaOrderId }}
        />
-        {` (${analysisOrder.id})`}
      </h4>
-      <div className="flex gap-2">
-        <h5>
-          <Trans i18nKey={`orders:status.${analysisOrder.status}`} />
-        </h5>
-        <Link
-          href={`/home/order/${analysisOrder.id}`}
-          className="text-small-regular flex items-center justify-between"
-        >
-          <button className="text-ui-fg-subtle hover:text-ui-fg-base flex cursor-pointer gap-x-1">
-            <Eye />
-          </button>
-        </Link>
-      </div>
+      {analysisOrder && (
+        <div className="flex gap-2">
+          <h5>
+            <Trans i18nKey={`orders:status.${analysisOrder.status}`} />
+          </h5>
+          <Link
+            href={`/home/order/${analysisOrder.id}`}
+            className="text-small-regular flex items-center justify-between"
+          >
+            <button className="text-ui-fg-subtle hover:text-ui-fg-base flex cursor-pointer gap-x-1">
+              <Eye />
+            </button>
+          </Link>
+        </div>
+      )}
      <div className="flex flex-col gap-4">
-        <OrderItemsTable
-          items={itemsAnalysisPackage}
-          title="orders:table.analysisPackage"
-          analysisOrder={analysisOrder}
-        />
+        {analysisOrder && (
+          <OrderItemsTable
+            items={itemsAnalysisPackage}
+            title="orders:table.analysisPackage"
+            analysisOrder={analysisOrder}
+          />
+        )}
+        {itemsTtoService && (
+          <OrderItemsTable
+            items={itemsTtoService}
+            title="orders:table.ttoService"
+            type="ttoService"
+          />
+        )}
        <OrderItemsTable
          items={itemsOther}
          title="orders:table.otherOrders"
--- a/app/home/(user)/_components/orders/order-items-table.tsx
+++ b/app/home/(user)/_components/orders/order-items-table.tsx
@@ -4,7 +4,6 @@ import { useRouter } from 'next/navigation';

 import { StoreOrderLineItem } from '@medusajs/types';
 import { formatDate } from 'date-fns';
-import { Eye } from 'lucide-react';

 import { pathsConfig } from '@kit/shared/config';
 import { Button } from '@kit/ui/button';
@@ -22,14 +21,18 @@ import type { AnalysisOrder } from '~/lib/types/analysis-order';

 import { logAnalysisResultsNavigateAction } from './actions';

+export type OrderItemType = 'analysisOrder' | 'ttoService';
+
 export default function OrderItemsTable({
  items,
  title,
  analysisOrder,
+  type = 'analysisOrder',
 }: {
  items: StoreOrderLineItem[];
  title: string;
-  analysisOrder: AnalysisOrder;
+  analysisOrder?: AnalysisOrder;
+  type?: OrderItemType;
 }) {
  const router = useRouter();

@@ -37,9 +40,13 @@ export default function OrderItemsTable({
    return null;
  }

+  const isAnalysisOrder = type === 'analysisOrder';
+
  const openAnalysisResults = async () => {
-    await logAnalysisResultsNavigateAction(analysisOrder.medusa_order_id);
-    router.push(`${pathsConfig.app.analysisResults}/${analysisOrder.id}`);
+    if (analysisOrder) {
+      await logAnalysisResultsNavigateAction(analysisOrder.medusa_order_id);
+      router.push(`${pathsConfig.app.analysisResults}/${analysisOrder.id}`);
+    }
  };

  return (
@@ -55,7 +62,7 @@ export default function OrderItemsTable({
          <TableHead className="px-6">
            <Trans i18nKey="orders:table.status" />
          </TableHead>
-          <TableHead className="px-6"></TableHead>
+          {isAnalysisOrder && <TableHead className="px-6"></TableHead>}
        </TableRow>
      </TableHeader>
      <TableBody>
@@ -76,14 +83,18 @@ export default function OrderItemsTable({
              </TableCell>

              <TableCell className="min-w-[180px] px-6">
-                <Trans i18nKey={`orders:status.${analysisOrder.status}`} />
+                <Trans
+                  i18nKey={`orders:status.${type}.${analysisOrder?.status ?? 'CONFIRMED'}`}
+                />
              </TableCell>

-              <TableCell className="px-6 text-right">
-                <Button size="sm" onClick={openAnalysisResults}>
-                  <Trans i18nKey="analysis-results:view" />
-                </Button>
-              </TableCell>
+              {isAnalysisOrder && (
+                <TableCell className="px-6 text-right">
+                  <Button size="sm" onClick={openAnalysisResults}>
+                    <Trans i18nKey="analysis-results:view" />
+                  </Button>
+                </TableCell>
+              )}
            </TableRow>
          ))}
      </TableBody>
--- a/app/home/(user)/_components/service-categories.tsx
+++ b/app/home/(user)/_components/service-categories.tsx
@@ -4,17 +4,20 @@ import React from 'react';

 import { redirect } from 'next/navigation';

-import { createPath, pathsConfig } from '@/packages/shared/src/config';
+import { pathsConfig } from '@/packages/shared/src/config';
+import { StoreProduct } from '@medusajs/types';
 import { ComponentInstanceIcon } from '@radix-ui/react-icons';

 import { cn } from '@kit/ui/shadcn';
-import { Card, CardDescription, CardTitle } from '@kit/ui/shadcn/card';
+import { Card, CardDescription } from '@kit/ui/shadcn/card';

 export interface ServiceCategory {
  name: string;
  handle: string;
  color: string;
  description: string;
+  products: StoreProduct[];
+  countryCode: string;
 }

 const ServiceCategories = ({
--- a/app/home/(user)/_lib/server/actions.ts
+++ b/app/home/(user)/_lib/server/actions.ts
@@ -0,0 +1,43 @@
+'use server';
+
+import { updateLineItem } from '@lib/data/cart';
+import { StoreProductVariant } from '@medusajs/types';
+
+import { handleAddToCart } from '~/lib/services/medusaCart.service';
+import { createInitialReservation } from '~/lib/services/reservation.service';
+
+export async function createInitialReservationAction(
+  selectedVariant: Pick<StoreProductVariant, 'id'>,
+  countryCode: string,
+  serviceId: number,
+  clinicId: number,
+  appointmentUserId: number,
+  syncUserId: number,
+  startTime: Date,
+  locationId: number | null,
+  comments?: string,
+) {
+  const { addedItem } = await handleAddToCart({
+    selectedVariant,
+    countryCode,
+  });
+
+  if (addedItem) {
+    const reservation = await createInitialReservation(
+      serviceId,
+      clinicId,
+      appointmentUserId,
+      syncUserId,
+      startTime,
+      addedItem.id,
+      locationId,
+      comments,
+    );
+
+    await updateLineItem({
+      lineId: addedItem.id,
+      quantity: addedItem.quantity,
+      metadata: { connectedOnlineReservationId: reservation.id },
+    });
+  }
+}
--- a/app/home/(user)/_lib/server/load-analyses.ts
+++ b/app/home/(user)/_lib/server/load-analyses.ts
@@ -45,10 +45,6 @@ async function analysesLoader() {
      })
    : null;

-  const serviceCategories = productCategories.filter(
-    ({ parent_category }) => parent_category?.handle === 'tto-categories',
-  );
-
  return {
    analyses:
      categoryProducts?.response.products
--- a/app/home/(user)/_lib/server/load-category.ts
+++ b/app/home/(user)/_lib/server/load-category.ts
@@ -1,20 +1,30 @@
 import { cache } from 'react';

-import { getProductCategories } from '@lib/data';
+import { getProductCategories, listProducts } from '@lib/data';

-import { ServiceCategory } from '../../_components/service-categories';
-
-async function categoryLoader({
-  handle,
-}: {
-  handle: string;
-}): Promise<{ category: ServiceCategory | null }> {
-  const response = await getProductCategories({
-    handle,
-    fields: '*products, is_active, metadata',
-  });
+import { loadCountryCodes } from './load-analyses';

+async function categoryLoader({ handle }: { handle: string }) {
+  const [response, countryCodes] = await Promise.all([
+    getProductCategories({
+      handle,
+      limit: 1,
+    }),
+    loadCountryCodes(),
+  ]);
  const category = response.product_categories[0];
+  const countryCode = countryCodes[0]!;
+
+  if (!response.product_categories?.[0]?.id) {
+    return { category: null };
+  }
+
+  const {
+    response: { products: categoryProducts },
+  } = await listProducts({
+    countryCode,
+    queryParams: { limit: 100, category_id: response.product_categories[0].id },
+  });

  return {
    category: {
@@ -25,6 +35,8 @@ async function categoryLoader({
      description: category?.description || '',
      handle: category?.handle || '',
      name: category?.name || '',
+      countryCode,
+      products: categoryProducts,
    },
  };
 }
--- a/app/home/(user)/_lib/server/load-tto-services.ts
+++ b/app/home/(user)/_lib/server/load-tto-services.ts
@@ -10,38 +10,36 @@ async function ttoServicesLoader() {
  });

  const heroCategories = response.product_categories?.filter(
-    ({ parent_category, is_active, metadata }) =>
-      parent_category?.handle === 'tto-categories' &&
-      is_active &&
-      metadata?.isHero,
+    ({ parent_category, metadata }) =>
+      parent_category?.handle === 'tto-categories' && metadata?.isHero,
  );

  const ttoCategories = response.product_categories?.filter(
-    ({ parent_category, is_active, metadata }) =>
-      parent_category?.handle === 'tto-categories' &&
-      is_active &&
-      !metadata?.isHero,
+    ({ parent_category, metadata }) =>
+      parent_category?.handle === 'tto-categories' && !metadata?.isHero,
  );

  return {
    heroCategories:
-      heroCategories.map<ServiceCategory>(
-        ({ name, handle, metadata, description }) => ({
+      heroCategories.map<Omit<ServiceCategory, 'countryCode'>>(
+        ({ name, handle, metadata, description, products }) => ({
          name,
          handle,
          color:
            typeof metadata?.color === 'string' ? metadata.color : 'primary',
          description,
+          products: products ?? [],
        }),
      ) ?? [],
    ttoCategories:
-      ttoCategories.map<ServiceCategory>(
-        ({ name, handle, metadata, description }) => ({
+      ttoCategories.map<Omit<ServiceCategory, 'countryCode'>>(
+        ({ name, handle, metadata, description, products }) => ({
          name,
          handle,
          color:
            typeof metadata?.color === 'string' ? metadata.color : 'primary',
          description,
+          products: products ?? [],
        }),
      ) ?? [],
  };
--- a/app/home/[account]/_components/team-account-layout-sidebar.tsx
+++ b/app/home/[account]/_components/team-account-layout-sidebar.tsx
@@ -52,7 +52,6 @@ function SidebarContainer(props: {
      <SidebarContent>
        <SidebarNavigation config={config} />
      </SidebarContent>
-
    </Sidebar>
  );
 }
--- a/app/home/[account]/billing/_components/health-benefit-fields.tsx
+++ b/app/home/[account]/billing/_components/health-benefit-fields.tsx
@@ -30,7 +30,9 @@ const HealthBenefitFields = () => {
              <Select {...field} onValueChange={field.onChange}>
                <SelectTrigger>
                  <SelectValue
-                    placeholder={<Trans i18nKey="common:formField:occurrence" />}
+                    placeholder={
+                      <Trans i18nKey="common:formField:occurrence" />
+                    }
                  />
                </SelectTrigger>

--- a/app/home/[account]/members/page.tsx
+++ b/app/home/[account]/members/page.tsx
@@ -55,7 +55,9 @@ async function TeamAccountMembersPage({ params }: TeamAccountMembersPageProps) {
    <>
      <TeamAccountLayoutPageHeader
        title={<Trans i18nKey={'common:routes.members'} />}
-        description={<AppBreadcrumbs values={{ [account.slug]: account.name }}/>}
+        description={
+          <AppBreadcrumbs values={{ [account.slug]: account.name }} />
+        }
      />

      <PageBody>
--- a/app/home/[account]/settings/page.tsx
+++ b/app/home/[account]/settings/page.tsx
@@ -48,7 +48,9 @@ async function TeamAccountSettingsPage(props: TeamAccountSettingsPageProps) {
    <>
      <TeamAccountLayoutPageHeader
        title={<Trans i18nKey={'teams:settings.pageTitle'} />}
-        description={<AppBreadcrumbs values={{ [account.slug]: account.name }} />}
+        description={
+          <AppBreadcrumbs values={{ [account.slug]: account.name }} />
+        }
      />

      <PageBody>
--- a/lib/services/audit.service.ts
+++ b/lib/services/audit.service.ts
@@ -1,14 +1,13 @@
 'use server';

-import { RequestStatus } from '@/lib/types/audit';
+import { RequestStatus, SyncStatus } from '@/lib/types/audit';
 import { ConnectedOnlineMethodName } from '@/lib/types/connected-online';
 import { ExternalApi } from '@/lib/types/external';
 import { MedipostAction } from '@/lib/types/medipost';
 import { getSupabaseServerAdminClient } from '@/packages/supabase/src/clients/server-admin-client';
-import { getSupabaseServerClient } from '@/packages/supabase/src/clients/server-client';

 export default async function logRequestResult(
-  /* personalCode: string, */ requestApi: keyof typeof ExternalApi,
+  requestApi: keyof typeof ExternalApi,
  requestApiMethod: `${ConnectedOnlineMethodName}` | `${MedipostAction}`,
  status: RequestStatus,
  comment?: string,
@@ -16,11 +15,10 @@ export default async function logRequestResult(
  serviceId?: number,
  serviceProviderId?: number,
 ) {
-  const { error } = await getSupabaseServerClient()
+  const { error } = await getSupabaseServerAdminClient()
    .schema('audit')
    .from('request_entries')
    .insert({
-      /* personal_code: personalCode, */
      request_api: requestApi,
      request_api_method: requestApiMethod,
      requested_start_date: startTime,
@@ -69,3 +67,29 @@ export async function getMedipostDispatchTries(medusaOrderId: string) {

  return data;
 }
+
+export async function logSyncResult({
+  operation,
+  comment,
+  status,
+  changed_by_role,
+}: {
+  operation: string;
+  comment?: string;
+  status: SyncStatus;
+  changed_by_role: string;
+}) {
+  const { error } = await getSupabaseServerAdminClient()
+    .schema('audit')
+    .from('sync_entries')
+    .insert({
+      operation,
+      comment,
+      status,
+      changed_by_role,
+    });
+
+  if (error) {
+    throw new Error('Failed to insert log entry, error: ' + error.message);
+  }
+}
--- a/lib/services/audit/cartEntries.ts
+++ b/lib/services/audit/cartEntries.ts
@@ -0,0 +1,40 @@
+import { getSupabaseServerClient } from '@kit/supabase/server-client';
+
+export const createCartEntriesLog = async ({
+  operation,
+  accountId,
+  cartId,
+  variantId,
+  comment,
+}: {
+  operation: string;
+  accountId: string;
+  cartId: string;
+  variantId?: string;
+  comment?: string;
+}) => {
+  try {
+    const supabase = getSupabaseServerClient();
+
+    const {
+      data: { user },
+      error: userError,
+    } = await supabase.auth.getUser();
+
+    if (userError || !user) {
+      console.error('No authenticated user found; skipping audit insert');
+      return;
+    }
+
+    return supabase.schema('audit').from('cart_entries').insert({
+      operation,
+      account_id: accountId,
+      cart_id: cartId,
+      changed_by: user.id,
+      variant_id: variantId,
+      comment,
+    });
+  } catch (error) {
+    console.error('Failed to insert doctor page view log', error);
+  }
+};
--- a/lib/services/audit/pageView.service.ts
+++ b/lib/services/audit/pageView.service.ts
@@ -6,6 +6,7 @@ export enum PageViewAction {
  REGISTRATION_SUCCESS = 'REGISTRATION_SUCCESS',
  VIEW_ORDER_ANALYSIS = 'VIEW_ORDER_ANALYSIS',
  VIEW_TEAM_ACCOUNT_DASHBOARD = 'VIEW_TEAM_ACCOUNT_DASHBOARD',
+  VIEW_TTO_SERVICE_BOOKING = 'VIEW_TTO_SERVICE_BOOKING',
 }

 export const createPageViewLog = async ({
@@ -37,6 +38,7 @@ export const createPageViewLog = async ({
        account_id: accountId,
        action,
        changed_by: user.id,
+        extra_data: extraData,
      })
      .throwOnError();
  } catch (error) {
--- a/lib/services/connected-online.service.ts
+++ b/lib/services/connected-online.service.ts
@@ -7,19 +7,30 @@ import {
  BookTimeResponse,
  ConfirmedLoadResponse,
  ConnectedOnlineMethodName,
+  FailureReason,
 } from '@/lib/types/connected-online';
 import { ExternalApi } from '@/lib/types/external';
 import { Tables } from '@/packages/supabase/src/database.types';
-import { createClient } from '@/utils/supabase/server';
 import axios from 'axios';
+import { uniq, uniqBy } from 'lodash';
+
+import { renderBookTimeFailedEmail } from '@kit/email-templates';
+import { getLogger } from '@kit/shared/logger';
+import { getSupabaseServerClient } from '@kit/supabase/server-client';
+
+import { TimeSlotResponse } from '~/home/(user)/_components/booking/booking.context';
+
+import { sendEmailFromTemplate } from './mailer.service';

 export async function getAvailableAppointmentsForService(
  serviceId: number,
+  key: string,
+  locationId: number | null,
  startTime?: Date,
+  maxDays?: number,
 ) {
  try {
-    const showTimesFrom = startTime ? { StartTime: startTime } : {};
-
+    const start = startTime ? { StartTime: startTime } : {};
    const response = await axios.post(
      `${process.env.CONNECTED_ONLINE_URL!}/${ConnectedOnlineMethodName.GetAvailabilities}`,
      {
@@ -28,9 +39,11 @@ export async function getAvailableAppointmentsForService(
        },
        param: JSON.stringify({
          ServiceID: serviceId,
-          Key: '7T624nlu',
+          Key: key,
          Lang: 'et',
-          ...showTimesFrom,
+          MaxDays: maxDays ?? 120,
+          LocationId: locationId ?? -1,
+          ...start,
        }),
      },
    );
@@ -80,157 +93,210 @@ export async function getAvailableAppointmentsForService(
 }

 export async function bookAppointment(
-  serviceSyncId: number,
+  serviceId: number,
  clinicId: number,
  appointmentUserId: number,
  syncUserID: number,
  startTime: string,
-  locationId = 0,
  comments = '',
-  isEarlierTimeRequested = false,
-  earlierTimeRequestComment = '',
 ) {
-  const supabase = await createClient();
+  const logger = await getLogger();
+  const supabase = getSupabaseServerClient();

+  let reason = FailureReason.BOOKING_FAILED;
  try {
    const {
      data: { user },
    } = await supabase.auth.getUser();

+    logger.info(
+      `Booking time slot ${JSON.stringify({ serviceId, clinicId, startTime, userId: user?.id })}`,
+    );
+
    if (!user?.id) {
      throw new Error('User not authenticated');
    }

+    const formattedStartTime = startTime.replace('T', ' ');
+
    const [
      { data: dbClinic, error: clinicError },
      { data: dbService, error: serviceError },
+      { data: account, error: accountError },
+      { data: dbReservation, error: dbReservationError },
    ] = await Promise.all([
      supabase
        .schema('medreport')
        .from('connected_online_providers')
        .select('*')
        .eq('id', clinicId)
-        .limit(1),
+        .single(),
      supabase
        .schema('medreport')
        .from('connected_online_services')
        .select('*')
-        .eq('sync_id', serviceSyncId)
+        .eq('id', serviceId)
        .eq('clinic_id', clinicId)
-        .limit(1),
+        .single(),
+      supabase
+        .schema('medreport')
+        .from('accounts')
+        .select('name, last_name, personal_code, phone, email')
+        .eq('is_personal_account', true)
+        .eq('primary_owner_user_id', user.id)
+        .single(),
+      supabase
+        .schema('medreport')
+        .from('connected_online_reservation')
+        .select('id')
+        .eq('clinic_id', clinicId)
+        .eq('service_id', serviceId)
+        .eq('start_time', formattedStartTime)
+        .eq('user_id', user.id)
+        .eq('status', 'PENDING')
+        .single(),
    ]);

-    if (!dbClinic?.length || !dbService?.length) {
-      return logRequestResult(
-        ExternalApi.ConnectedOnline,
-        ConnectedOnlineMethodName.BookTime,
-        RequestStatus.Fail,
-        dbClinic?.length
-          ? `Could not find clinic with id ${clinicId}, error: ${JSON.stringify(clinicError)}`
-          : `Could not find service with sync id ${serviceSyncId} and clinic id ${clinicId}, error: ${JSON.stringify(serviceError)}`,
-        startTime,
-        serviceSyncId,
-        clinicId,
-      );
+    if (!dbClinic || !dbService) {
+      const errorMessage = dbClinic
+        ? `Could not find clinic with id ${clinicId}, error: ${JSON.stringify(clinicError)}`
+        : `Could not find service with sync id ${serviceId} and clinic id ${clinicId}, error: ${JSON.stringify(serviceError)}`;
+      logger.error(errorMessage);
+
+      throw new Error(errorMessage);
+    }
+
+    if (clinicError || serviceError || accountError) {
+      const stringifiedErrors = JSON.stringify({
+        clinicError,
+        serviceError,
+        accountError,
+      });
+      const errorMessage = `Failed to book time, error: ${stringifiedErrors}`;
+      logger.error(errorMessage);
+
+      throw new Error(errorMessage);
+    }
+
+    if (!dbReservation) {
+      const errorMessage = `No reservation found in db with data ${JSON.stringify({ clinicId, serviceId, startTime, userId: user.id })}, got error ${JSON.stringify(dbReservationError)}`;
+      logger.error(errorMessage);
+
+      throw new Error(errorMessage);
    }

    const clinic: Tables<
      { schema: 'medreport' },
      'connected_online_providers'
-    > = dbClinic![0];
+    > = dbClinic;
    const service: Tables<
      { schema: 'medreport' },
      'connected_online_services'
-    > = dbService![0];
+    > = dbService;

-    // TODO the dummy data needs to be replaced with real values once they're present on the user/account
-    const response = await axios.post(
+    const connectedOnlineBookingResponse = await axios.post(
      `${process.env.CONNECTED_ONLINE_URL!}/${ConnectedOnlineMethodName.BookTime}`,
      {
        headers: {
          'Content-Type': 'application/json; charset=utf-8',
        },
        param: JSON.stringify({
-          EarlierTime: isEarlierTimeRequested, // once we have the e-shop functionality we can let the user select if she would like to be offered earlier time slots if they become available
-          EarlierTimeComment: earlierTimeRequestComment,
          ClinicID: clinic.id,
-          ServiceID: service.id,
-          ClinicServiceID: service.sync_id,
+          ServiceID: service.sync_id,
+          ClinicServiceID: service.id,
          UserID: appointmentUserId,
          SyncUserID: syncUserID,
          StartTime: startTime,
-          FirstName: 'Test',
-          LastName: 'User',
-          PersonalCode: '4',
-          Email: user.email,
-          Phone: 'phone',
+          FirstName: account.name,
+          LastName: account.last_name,
+          PersonalCode: account.personal_code,
+          Email: account.email ?? user.email,
+          Phone: account.phone,
          Comments: comments,
-          Location: locationId,
-          FreeCode: '',
          AddToBasket: false,
-          Key: '7T624nlu',
-          Lang: 'et', // update when integrated into app, if needed
+          Key: dbClinic.key,
+          Lang: 'et',
        }),
      },
    );

-    const responseData: BookTimeResponse = JSON.parse(response.data.d);
+    const connectedOnlineBookingResponseData: BookTimeResponse = JSON.parse(
+      connectedOnlineBookingResponse.data.d,
+    );

-    if (responseData?.ErrorCode !== 0 || !responseData.Value) {
-      return logRequestResult(
-        ExternalApi.ConnectedOnline,
-        ConnectedOnlineMethodName.BookTime,
-        RequestStatus.Fail,
-        JSON.stringify(responseData),
-        startTime,
-        service.id,
-        clinicId,
+    const errorCode = connectedOnlineBookingResponseData?.ErrorCode;
+    if (errorCode !== 0 || !connectedOnlineBookingResponseData.Value) {
+      const errorMessage = `Received invalid result from external api, error: ${JSON.stringify(connectedOnlineBookingResponseData)}`;
+      logger.error(errorMessage);
+      if (process.env.SUPPORT_EMAIL) {
+        await sendEmailFromTemplate(
+          renderBookTimeFailedEmail,
+          { reservationId: dbReservation.id, error: errorMessage },
+          process.env.SUPPORT_EMAIL,
+        );
+      }
+      await supabase
+        .schema('medreport')
+        .from('connected_online_reservation')
+        .update({
+          status: 'REJECTED',
+        })
+        .eq('id', dbReservation.id)
+        .throwOnError();
+
+      if (errorCode === 1) {
+        reason = FailureReason.TIME_SLOT_UNAVAILABLE;
+      }
+
+      throw new Error(errorMessage);
+    }
+
+    const responseParts = connectedOnlineBookingResponseData.Value.split(',');
+
+    const { data: updatedReservation, error } = await supabase
+      .schema('medreport')
+      .from('connected_online_reservation')
+      .update({
+        booking_code: responseParts[1],
+        requires_payment: !!responseParts[0],
+        status: 'CONFIRMED',
+      })
+      .eq('id', dbReservation.id)
+      .select('id')
+      .single();
+
+    if (error) {
+      throw new Error(
+        JSON.stringify({ connectedOnlineBookingResponseData, error }),
      );
    }

-    const responseParts = responseData.Value.split(',');
-
-    const { error } = await supabase
-      .schema('medreport')
-      .from('connected_online_reservation')
-      .insert({
-        booking_code: responseParts[1],
-        clinic_id: clinic.id,
-        comments,
-        lang: 'et', // change later, if needed
-        service_id: service.id,
-        service_user_id: appointmentUserId,
-        start_time: startTime,
-        sync_user_id: syncUserID,
-        requires_payment: !!responseParts[0],
-        user_id: user.id,
-      });
+    logger.info(
+      'Booked time, updated reservation with id ' + updatedReservation?.id,
+    );

    await logRequestResult(
      ExternalApi.ConnectedOnline,
      ConnectedOnlineMethodName.BookTime,
      RequestStatus.Success,
-      JSON.stringify(responseData),
-      startTime,
+      JSON.stringify(connectedOnlineBookingResponseData),
+      startTime.toString(),
      service.id,
      clinicId,
    );
-
-    if (error) {
-      throw new Error(error.message);
-    }
-
-    return responseData.Value;
+    return { success: true };
  } catch (error) {
-    return logRequestResult(
+    logger.error(`Failed to book time, error: ${JSON.stringify(error)}`);
+    await logRequestResult(
      ExternalApi.ConnectedOnline,
      ConnectedOnlineMethodName.BookTime,
      RequestStatus.Fail,
      JSON.stringify(error),
-      startTime,
-      serviceSyncId,
+      startTime.toString(),
+      serviceId,
      clinicId,
    );
+    return { success: false, reason };
  }
 }

@@ -270,8 +336,83 @@ export async function getConfirmedService(reservationCode: string) {
      ExternalApi.ConnectedOnline,
      ConnectedOnlineMethodName.ConfirmedLoad,
      RequestStatus.Fail,
-      JSON.stringify(error),
+      error?.toString(),
    );
    return null;
  }
 }
+
+export async function getAvailableTimeSlotsForDisplay(
+  serviceIds: number[],
+  locationId: number | null,
+  date?: Date,
+): Promise<TimeSlotResponse> {
+  const supabase = getSupabaseServerClient();
+
+  const { data: syncedServices } = await supabase
+    .schema('medreport')
+    .from('connected_online_services')
+    .select(
+      '*, providerClinic:clinic_id(*,locations:connected_online_locations(*))',
+    )
+    .in('id', serviceIds)
+    .throwOnError();
+
+  const timeSlotPromises = [];
+  for (const syncedService of syncedServices) {
+    const timeSlotsPromise = getAvailableAppointmentsForService(
+      syncedService.id,
+      syncedService.providerClinic.key,
+      locationId,
+      date,
+    );
+    timeSlotPromises.push(timeSlotsPromise);
+  }
+
+  const timeSlots = await Promise.all(timeSlotPromises);
+
+  const mappedTimeSlots = [];
+  for (const timeSlotGroup of timeSlots) {
+    const { data: serviceProviders } = await supabase
+      .schema('medreport')
+      .from('connected_online_service_providers')
+      .select(
+        'name, id, jobTitleEn: job_title_en, jobTitleEt: job_title_et, jobTitleRu: job_title_ru, clinicId: clinic_id',
+      )
+      .in(
+        'clinic_id',
+        uniq(timeSlotGroup?.T_Booking.map(({ ClinicID }) => ClinicID)),
+      )
+      .throwOnError();
+
+    const timeSlots =
+      timeSlotGroup?.T_Booking?.map((item) => {
+        return {
+          ...item,
+          serviceProvider: serviceProviders.find(
+            ({ id }) => id === item.UserID,
+          ),
+          syncedService: syncedServices.find(
+            (syncedService) => syncedService.sync_id === item.ServiceID,
+          ),
+          location: syncedServices
+            .find(
+              ({ providerClinic }) =>
+                providerClinic.id === Number(item.ClinicID),
+            )
+            ?.providerClinic?.locations?.find(
+              (location) => location.sync_id === item.LocationID,
+            ),
+        };
+      }) ?? [];
+    mappedTimeSlots.push(...timeSlots);
+  }
+
+  return {
+    timeSlots: mappedTimeSlots,
+    locations: uniqBy(
+      syncedServices.flatMap(({ providerClinic }) => providerClinic.locations),
+      'id',
+    ),
+  };
+}
--- a/lib/services/medusaCart.service.ts
+++ b/lib/services/medusaCart.service.ts
@@ -5,9 +5,16 @@ import { MontonioOrderHandlerService } from '@/packages/billing/montonio/src';
 import { addToCart, deleteLineItem, retrieveCart } from '@lib/data/cart';
 import { getCartId } from '@lib/data/cookies';
 import { StoreCartLineItem, StoreProductVariant } from '@medusajs/types';
+import { isSameMinute } from 'date-fns';
 import { z } from 'zod';

-import { getSupabaseServerClient } from '@kit/supabase/server-client';
+import {
+  cancelReservation,
+  getOrderedTtoServices,
+} from '~/lib/services/reservation.service';
+
+import { createCartEntriesLog } from './audit/cartEntries';
+import { getAvailableAppointmentsForService } from './connected-online.service';

 const env = () =>
  z
@@ -24,8 +31,8 @@ const env = () =>
        .min(1),
    })
    .parse({
-      medusaBackendPublicUrl: process.env.MEDUSA_BACKEND_PUBLIC_URL!,
-      siteUrl: process.env.NEXT_PUBLIC_SITE_URL!,
+      medusaBackendPublicUrl: 'http://webhook.site:3000',
+      siteUrl: 'http://webhook.site:3000',
    });

 export async function handleAddToCart({
@@ -35,53 +42,44 @@ export async function handleAddToCart({
  selectedVariant: Pick<StoreProductVariant, 'id'>;
  countryCode: string;
 }) {
-  const supabase = getSupabaseServerClient();
-  const { account, user } = await loadCurrentUserAccount();
+  const { account } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }

  const quantity = 1;
-  const cart = await addToCart({
+  const { newCart, addedItem } = await addToCart({
    variantId: selectedVariant.id,
    quantity,
    countryCode,
  });

-  const { error } = await supabase.schema('audit').from('cart_entries').insert({
-    variant_id: selectedVariant.id,
+  await createCartEntriesLog({
+    variantId: selectedVariant.id,
    operation: 'ADD_TO_CART',
-    account_id: account.id,
-    cart_id: cart.id,
-    changed_by: user.id,
+    accountId: account.id,
+    cartId: newCart.id,
  });
-  if (error) {
-    throw new Error('Error logging cart entry: ' + error.message);
-  }

-  return cart;
+  return { cart: newCart, addedItem };
 }

 export async function handleDeleteCartItem({ lineId }: { lineId: string }) {
  await deleteLineItem(lineId);
+  await cancelReservation(lineId);

-  const supabase = getSupabaseServerClient();
  const cartId = await getCartId();
-  const { account, user } = await loadCurrentUserAccount();
+  const { account } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }

-  const { error } = await supabase.schema('audit').from('cart_entries').insert({
-    variant_id: lineId,
+  await createCartEntriesLog({
+    variantId: lineId,
    operation: 'REMOVE_FROM_CART',
-    account_id: account.id,
-    cart_id: cartId!,
-    changed_by: user.id,
+    accountId: account.id,
+    cartId: cartId!,
  });
-  if (error) {
-    throw new Error('Error logging cart entry: ' + error.message);
-  }
 }

 export async function handleNavigateToPayment({
@@ -91,8 +89,7 @@ export async function handleNavigateToPayment({
  language: string;
  paymentSessionId: string;
 }) {
-  const supabase = getSupabaseServerClient();
-  const { account, user } = await loadCurrentUserAccount();
+  const { account } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }
@@ -101,6 +98,33 @@ export async function handleNavigateToPayment({
  if (!cart) {
    throw new Error('No cart found');
  }
+  const orderedTtoServices = await getOrderedTtoServices({ cart });
+
+  if (orderedTtoServices?.length) {
+    const unavailableLineItemIds: string[] = [];
+    for (const ttoService of orderedTtoServices) {
+      const availabilities = await getAvailableAppointmentsForService(
+        ttoService.service_id,
+        ttoService.provider.key,
+        ttoService.location_sync_id,
+        new Date(ttoService.start_time),
+        1,
+      );
+      const isAvailable = availabilities?.T_Booking?.length
+        ? availabilities.T_Booking.find((timeSlot) =>
+            isSameMinute(ttoService.start_time, timeSlot.StartTime),
+          )
+        : false;
+
+      if (!isAvailable) {
+        unavailableLineItemIds.push(ttoService.medusa_cart_line_item_id!);
+      }
+    }
+
+    if (unavailableLineItemIds.length) {
+      return { unavailableLineItemIds };
+    }
+  }

  const paymentLink =
    await new MontonioOrderHandlerService().getMontonioPaymentLink({
@@ -113,17 +137,13 @@ export async function handleNavigateToPayment({
      merchantReference: `${account.id}:${paymentSessionId}:${cart.id}`,
    });

-  const { error } = await supabase.schema('audit').from('cart_entries').insert({
+  await createCartEntriesLog({
    operation: 'NAVIGATE_TO_PAYMENT',
-    account_id: account.id,
-    cart_id: cart.id,
-    changed_by: user.id,
+    accountId: account.id,
+    cartId: cart.id,
  });
-  if (error) {
-    throw new Error('Error logging cart entry: ' + error.message);
-  }

-  return paymentLink;
+  return { url: paymentLink };
 }

 export async function handleLineItemTimeout({
@@ -131,21 +151,16 @@ export async function handleLineItemTimeout({
 }: {
  lineItem: StoreCartLineItem;
 }) {
-  const supabase = getSupabaseServerClient();
-  const { account, user } = await loadCurrentUserAccount();
+  const { account } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }

  await deleteLineItem(lineItem.id);

-  const { error } = await supabase.schema('audit').from('cart_entries').insert({
+  await createCartEntriesLog({
    operation: 'LINE_ITEM_TIMEOUT',
-    account_id: account.id,
-    cart_id: lineItem.cart_id,
-    changed_by: user.id,
+    accountId: account.id,
+    cartId: lineItem.cart_id,
  });
-  if (error) {
-    throw new Error('Error logging cart entry: ' + error.message);
-  }
 }
--- a/lib/services/order.service.ts
+++ b/lib/services/order.service.ts
@@ -171,3 +171,42 @@ export async function getAnalysisOrdersAdmin({
    .throwOnError();
  return orders.data;
 }
+
+export async function getTtoOrders({
+  orderStatus,
+  lineItemIds,
+}: {
+  orderStatus?: Tables<
+    { schema: 'medreport' },
+    'connected_online_reservation'
+  >['status'];
+  lineItemIds?: string[];
+} = {}) {
+  const client = getSupabaseServerClient();
+
+  const {
+    data: { user },
+  } = await client.auth.getUser();
+  if (!user) {
+    throw new Error('Unauthorized');
+  }
+
+  const query = client
+    .schema('medreport')
+    .from('connected_online_reservation')
+    .select('*')
+    .eq('user_id', user.id);
+
+  if (orderStatus) {
+    query.eq('status', orderStatus);
+  }
+
+  if (lineItemIds?.length) {
+    query.in('medusa_cart_line_item_id', lineItemIds);
+  }
+
+  const orders = await query
+    .order('created_at', { ascending: false })
+    .throwOnError();
+  return orders.data;
+}
--- a/lib/services/reservation.service.ts
+++ b/lib/services/reservation.service.ts
@@ -0,0 +1,326 @@
+'use server';
+
+import { revalidatePath } from 'next/cache';
+
+import { listRegions } from '@lib/data/regions';
+import { StoreCart, StoreOrder } from '@medusajs/types';
+
+import { getLogger } from '@kit/shared/logger';
+import { Tables } from '@kit/supabase/database';
+import { getSupabaseServerClient } from '@kit/supabase/server-client';
+
+import { EnrichedCartItem } from '../../app/home/(user)/_components/cart/types';
+import { loadCurrentUserAccount } from '../../app/home/(user)/_lib/server/load-user-account';
+import { createCartEntriesLog } from './audit/cartEntries';
+import { handleDeleteCartItem } from './medusaCart.service';
+
+type Locations = Tables<{ schema: 'medreport' }, 'connected_online_locations'>;
+type Services = Tables<{ schema: 'medreport' }, 'connected_online_services'>;
+type ServiceProviders = Tables<
+  { schema: 'medreport' },
+  'connected_online_service_providers'
+>;
+
+export async function getCartReservations(
+  medusaCart: StoreCart,
+): Promise<EnrichedCartItem[]> {
+  const supabase = getSupabaseServerClient();
+
+  const cartLineItemIds = medusaCart.items?.map(({ id }) => id);
+
+  if (!cartLineItemIds?.length) {
+    return [];
+  }
+
+  const { data: reservations } = await supabase
+    .schema('medreport')
+    .from('connected_online_reservation')
+    .select(
+      'id, startTime:start_time, service:service_id, location:location_sync_id, serviceProvider:service_user_id, medusaCartLineItemId:medusa_cart_line_item_id',
+    )
+    .in('medusa_cart_line_item_id', cartLineItemIds)
+    .throwOnError();
+
+  const locationSyncIds: number[] =
+    reservations
+      ?.filter((reservation) => !!reservation.location)
+      .map((reservation) => reservation.location!) ?? [];
+  const serviceIds =
+    reservations?.map((reservation) => reservation.service) ?? [];
+  const serviceProviderIds =
+    reservations.map((reservation) => reservation.serviceProvider) ?? [];
+
+  let locations:
+    | {
+        syncId: Locations['sync_id'];
+        name: Locations['name'];
+        address: Locations['address'];
+      }[]
+    | null = null;
+  if (locationSyncIds.length) {
+    ({ data: locations } = await supabase
+      .schema('medreport')
+      .from('connected_online_locations')
+      .select('syncId:sync_id, name, address')
+      .in('sync_id', locationSyncIds)
+      .throwOnError());
+  }
+
+  let services:
+    | {
+        id: Services['id'];
+        name: Services['name'];
+      }[]
+    | null = null;
+  if (serviceIds.length) {
+    ({ data: services } = await supabase
+      .schema('medreport')
+      .from('connected_online_services')
+      .select('name, id')
+      .in('id', serviceIds)
+      .throwOnError());
+  }
+
+  let serviceProviders:
+    | {
+        id: ServiceProviders['id'];
+        name: ServiceProviders['name'];
+        jobTitleEt: ServiceProviders['job_title_et'];
+        jobTitleEn: ServiceProviders['job_title_en'];
+        jobTitleRu: ServiceProviders['job_title_ru'];
+        spokenLanguages: ServiceProviders['spoken_languages'];
+      }[]
+    | null = null;
+  if (serviceProviderIds.length) {
+    ({ data: serviceProviders } = await supabase
+      .schema('medreport')
+      .from('connected_online_service_providers')
+      .select(
+        'id, name, jobTitleEt:job_title_et, jobTitleEn:job_title_en, jobTitleRu:job_title_ru, spokenLanguages:spoken_languages',
+      )
+      .in('id', serviceProviderIds)
+      .throwOnError());
+  }
+
+  const results = [];
+  for (const reservation of reservations) {
+    if (reservation.medusaCartLineItemId === null) {
+      continue;
+    }
+
+    const cartLineItem = medusaCart.items?.find(
+      (item) => item.id === reservation.medusaCartLineItemId,
+    );
+
+    if (!cartLineItem) {
+      continue;
+    }
+
+    const location = locations?.find(
+      (location) => location.syncId === reservation.location,
+    );
+    const service = services?.find(
+      (service) => service.id === reservation.service,
+    );
+    const serviceProvider = serviceProviders?.find(
+      (serviceProvider) => serviceProvider.id === reservation.serviceProvider,
+    );
+
+    const countryCodes = await listRegions().then((regions) =>
+      regions?.map((r) => r.countries?.map((c) => c.iso_2)).flat(),
+    );
+
+    const enrichedReservation = {
+      ...reservation,
+      location,
+      service,
+      serviceProvider,
+    };
+
+    results.push({
+      ...cartLineItem,
+      reservation: {
+        ...enrichedReservation,
+        medusaCartLineItemId: reservation.medusaCartLineItemId!,
+        countryCode: countryCodes[0],
+      },
+    });
+  }
+
+  return results;
+}
+
+export async function createInitialReservation(
+  serviceId: number,
+  clinicId: number,
+  appointmentUserId: number,
+  syncUserID: number,
+  startTime: Date,
+  medusaLineItemId: string,
+  locationId?: number | null,
+  comments = '',
+) {
+  const logger = await getLogger();
+  const supabase = getSupabaseServerClient();
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  const userId = user?.id;
+
+  if (!userId) {
+    throw new Error('User not authenticated');
+  }
+
+  logger.info(
+    'Creating reservation' +
+      JSON.stringify({ serviceId, clinicId, startTime, userId }),
+  );
+
+  try {
+    const { data: createdReservation } = await supabase
+      .schema('medreport')
+      .from('connected_online_reservation')
+      .insert({
+        clinic_id: clinicId,
+        comments,
+        lang: 'et',
+        service_id: serviceId,
+        service_user_id: appointmentUserId,
+        start_time: startTime.toString(),
+        sync_user_id: syncUserID,
+        user_id: userId,
+        status: 'PENDING',
+        medusa_cart_line_item_id: medusaLineItemId,
+        location_sync_id: locationId,
+      })
+      .select('id')
+      .single()
+      .throwOnError();
+
+    logger.info(
+      `Created reservation ${JSON.stringify({ createdReservation, userId })}`,
+    );
+
+    return createdReservation;
+  } catch (e) {
+    logger.error(
+      `Failed to create initial reservation ${JSON.stringify({ serviceId, clinicId, startTime })} ${e}`,
+    );
+    await handleDeleteCartItem({ lineId: medusaLineItemId });
+    throw e;
+  }
+}
+
+export async function cancelReservation(medusaLineItemId: string) {
+  const supabase = getSupabaseServerClient();
+
+  return supabase
+    .schema('medreport')
+    .from('connected_online_reservation')
+    .update({
+      status: 'CANCELLED',
+    })
+    .eq('medusa_cart_line_item_id', medusaLineItemId)
+    .throwOnError();
+}
+
+export async function getOrderedTtoServices({
+  cart,
+  medusaOrder,
+}: {
+  cart?: StoreCart;
+  medusaOrder?: StoreOrder;
+}) {
+  const supabase = getSupabaseServerClient();
+
+  if (!medusaOrder && !cart) {
+    throw new Error('No cart or medusa order provided');
+  }
+
+  const ttoReservationIds: number[] =
+    (medusaOrder?.items ?? cart?.items)
+      ?.filter(({ metadata }) => !!metadata?.connectedOnlineReservationId)
+      .map(({ metadata }) => Number(metadata!.connectedOnlineReservationId)) ??
+    [];
+
+  const { data: orderedTtoServices } = await supabase
+    .schema('medreport')
+    .from('connected_online_reservation')
+    .select('*, provider:connected_online_providers(key)')
+    .in('id', ttoReservationIds)
+    .throwOnError();
+
+  return orderedTtoServices;
+}
+
+export async function updateReservationTime(
+  reservationId: number,
+  newStartTime: Date,
+  newServiceId: number,
+  newAppointmentUserId: number,
+  newSyncUserId: number,
+  newLocationId: number | null, // TODO stop allowing null when Connected starts returning the correct ids instead of -1
+  cartId: string,
+) {
+  const logger = await getLogger();
+  const supabase = getSupabaseServerClient();
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  const userId = user?.id;
+  const { account } = await loadCurrentUserAccount();
+
+  if (!userId || !account) {
+    throw new Error('User not authenticated');
+  }
+
+  const reservationData = JSON.stringify({
+    reservationId,
+    newStartTime,
+    newServiceId,
+    newAppointmentUserId,
+    newSyncUserId,
+    newLocationId,
+    userId,
+    cartId,
+  });
+
+  logger.info('Updating reservation' + reservationData);
+  try {
+    await supabase
+      .schema('medreport')
+      .from('connected_online_reservation')
+      .update({
+        service_id: newServiceId,
+        service_user_id: newAppointmentUserId,
+        sync_user_id: newSyncUserId,
+        start_time: newStartTime.toString(),
+        location_sync_id: newLocationId,
+      })
+      .eq('id', reservationId)
+      .eq('user_id', user.id)
+      .throwOnError();
+
+    logger.info(`Successfully updated reservation ${reservationData}`);
+    await createCartEntriesLog({
+      operation: 'CHANGE_RESERVATION',
+      accountId: account.id,
+      cartId: cartId,
+      comment: `${reservationData}`,
+    });
+    revalidatePath('/home/cart', 'layout');
+  } catch (e) {
+    logger.error(`Failed to update reservation ${reservationData}`);
+    await createCartEntriesLog({
+      operation: 'CHANGE_RESERVATION',
+      accountId: account.id,
+      cartId: cartId,
+      comment: `${e}`,
+    });
+    throw e;
+  }
+}
--- a/lib/types/connected-online.ts
+++ b/lib/types/connected-online.ts
@@ -10,13 +10,15 @@ export type BookTimeResponse = z.infer<typeof BookTimeResponseSchema>;

 export enum ConnectedOnlineMethodName {
  SearchLoad = 'Search_Load',
+  DefaultLoad = 'Default_Load',
+  ConfirmedCancel = 'Confirmed_Cancel',
  GetAvailabilities = 'GetAvailabilities',
  BookTime = 'BookTime',
  ConfirmedLoad = 'Confirmed_Load',
 }

 export const AvailableAppointmentTBookingSchema = z.object({
-  ClinicID: z.string(),
+  ClinicID: z.number(),
  LocationID: z.number(),
  UserID: z.number(),
  SyncUserID: z.number(),
@@ -225,6 +227,18 @@ export const ConfirmedLoadResponseSchema = z.object({
 });
 export type ConfirmedLoadResponse = z.infer<typeof ConfirmedLoadResponseSchema>;

+export type P_JobTitleTranslation = {
+  ID: number;
+  SyncID: number;
+  TextEN: string;
+  TextET: string;
+  TextFI: string;
+  TextRU: string;
+  TextLT: string;
+  ClinicID: number;
+  Deleted: number;
+};
+
 export interface ISearchLoadResponse {
  Value: string;
  Data: {
@@ -232,9 +246,11 @@ export interface ISearchLoadResponse {
      ID: number;
      Name: string;
      OnlineCanSelectWorker: boolean;
+      Address: string;
      Email: string | null;
      PersonalCodeRequired: boolean;
      Phone: string | null;
+      Key: string;
    }[];
    T_Service: {
      ID: number;
@@ -253,7 +269,14 @@ export interface ISearchLoadResponse {
      RequiresPayment: boolean;
      SyncID: string;
    }[];
+    T_Doctor: TDoctor[];
+    P_JobTitleTranslations: P_JobTitleTranslation[];
  };
  ErrorCode: number;
  ErrorMessage: string;
 }
+
+export enum FailureReason {
+  BOOKING_FAILED = 'BOOKING_FAILED',
+  TIME_SLOT_UNAVAILABLE = 'TIME_SLOT_UNAVAILABLE',
+}
--- a/lib/types/reservation.ts
+++ b/lib/types/reservation.ts
@@ -0,0 +1,35 @@
+import z from 'zod';
+
+export const LocationSchema = z.object({
+  syncId: z.number(),
+  name: z.string(),
+  address: z.string().nullable(),
+});
+export type Location = z.infer<typeof LocationSchema>;
+
+export const ServiceSchema = z.object({
+  name: z.string(),
+  id: z.number(),
+});
+export type Service = z.infer<typeof ServiceSchema>;
+
+export const ServiceProviderSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  jobTitleEt: z.string().nullable(),
+  jobTitleEn: z.string().nullable(),
+  jobTitleRu: z.string().nullable(),
+  spokenLanguages: z.array(z.string()).nullable(),
+});
+export type ServiceProvider = z.infer<typeof ServiceProviderSchema>;
+
+export const ReservationSchema = z.object({
+  startTime: z.string(),
+  service: ServiceSchema.optional(),
+  location: LocationSchema.optional(),
+  serviceProvider: ServiceProviderSchema.optional(),
+  medusaCartLineItemId: z.string(),
+  id: z.number(),
+  countryCode: z.string().optional(),
+});
+export type Reservation = z.infer<typeof ReservationSchema>;
--- a/lib/utils.ts
+++ b/lib/utils.ts
@@ -143,3 +143,10 @@ export default class PersonalCode {
    };
  }
 }
+
+export const findProductTypeIdByHandle = (
+  productTypes: { metadata?: Record<string, unknown> | null; id: string }[],
+  handle: string,
+) => {
+  return productTypes.find(({ metadata }) => metadata?.handle === handle)?.id;
+};
--- a/packages/email-templates/src/emails/book-time-failed.email.tsx
+++ b/packages/email-templates/src/emails/book-time-failed.email.tsx
@@ -0,0 +1,61 @@
+import {
+  Body,
+  Head,
+  Html,
+  Preview,
+  Tailwind,
+  Text,
+  render,
+} from '@react-email/components';
+
+import { BodyStyle } from '../components/body-style';
+import { EmailContent } from '../components/content';
+import { EmailHeader } from '../components/header';
+import { EmailHeading } from '../components/heading';
+import { EmailWrapper } from '../components/wrapper';
+
+export async function renderBookTimeFailedEmail({
+  reservationId,
+  error,
+}: {
+  reservationId: number;
+  error: string;
+}) {
+  const subject = 'Aja broneerimine ei õnnestunud';
+
+  const html = await render(
+    <Html>
+      <Head>
+        <BodyStyle />
+      </Head>
+
+      <Preview>{subject}</Preview>
+
+      <Tailwind>
+        <Body>
+          <EmailWrapper>
+            <EmailContent>
+              <EmailHeader>
+                <EmailHeading>{subject}</EmailHeading>
+              </EmailHeader>
+              <Text className="text-[16px] leading-[24px] text-[#242424]">
+                Tere
+              </Text>
+
+              <Text>
+                Broneeringu {reservationId} Connected Online'i saatmine ei
+                õnnestunud, kliendile tuleb teha tagasimakse.
+              </Text>
+              <Text>Saadud error: {error}</Text>
+            </EmailContent>
+          </EmailWrapper>
+        </Body>
+      </Tailwind>
+    </Html>,
+  );
+
+  return {
+    html,
+    subject,
+  };
+}
--- a/packages/email-templates/src/index.ts
+++ b/packages/email-templates/src/index.ts
@@ -10,3 +10,4 @@ export * from './emails/all-results-received.email';
 export * from './emails/order-processing.email';
 export * from './emails/patient-first-results-received.email';
 export * from './emails/patient-full-results-received.email';
+export * from './emails/book-time-failed.email';
--- a/packages/features/admin/src/components/admin-members-table.tsx
+++ b/packages/features/admin/src/components/admin-members-table.tsx
@@ -4,10 +4,10 @@ import Link from 'next/link';

 import { ColumnDef } from '@tanstack/react-table';

+import { formatDateAndTime } from '@kit/shared/utils';
 import { Database } from '@kit/supabase/database';
 import { DataTable } from '@kit/ui/enhanced-data-table';
 import { ProfileAvatar } from '@kit/ui/profile-avatar';
-import { formatDateAndTime } from '@kit/shared/utils';

 type Memberships =
  Database['medreport']['Functions']['get_account_members']['Returns'][number];
--- a/packages/features/medusa-storefront/src/lib/data/cart.ts
+++ b/packages/features/medusa-storefront/src/lib/data/cart.ts
@@ -168,7 +168,12 @@ export async function addToCart({
    })
    .catch(medusaError);

-  return cart;
+  const newCart = await getOrSetCart(countryCode);
+  const addedItem = newCart.items?.filter(
+    (item) => !cart.items?.some((oldCartItem) => oldCartItem.id === item.id),
+  )?.[0];
+
+  return { newCart, addedItem };
 }

 export async function updateLineItem({
--- a/packages/features/medusa-storefront/src/lib/data/categories.ts
+++ b/packages/features/medusa-storefront/src/lib/data/categories.ts
@@ -21,7 +21,6 @@ export const listCategories = async (query?: Record<string, any>) => {
          ...query,
        },
        next,
-        cache: 'force-cache',
      },
    )
    .then(({ product_categories }) => product_categories);
@@ -57,7 +56,6 @@ export const getProductCategories = async ({
        limit,
      },
      next,
-      //cache: "force-cache",
    },
  );
 };
--- a/packages/features/medusa-storefront/src/lib/data/regions.ts
+++ b/packages/features/medusa-storefront/src/lib/data/regions.ts
@@ -15,7 +15,7 @@ export const listRegions = async () => {
    .fetch<{ regions: HttpTypes.StoreRegion[] }>(`/store/regions`, {
      method: 'GET',
      next,
-      cache: 'force-cache',
+      // cache: 'force-cache',
    })
    .then(({ regions }) => regions)
    .catch(medusaError);
--- a/packages/shared/src/config/index.ts
+++ b/packages/shared/src/config/index.ts
@@ -1,7 +1,7 @@
+import { adminNavigationConfig } from './admin-navigation.config';
 import appConfig from './app.config';
 import authConfig from './auth.config';
 import billingConfig from './billing.config';
-import { adminNavigationConfig } from './admin-navigation.config';
 import {
  DynamicAuthConfig,
  getCachedAuthConfig,
--- a/packages/supabase/src/database.types.ts
+++ b/packages/supabase/src/database.types.ts
@@ -224,7 +224,6 @@ export type Database = {
          comment: string | null
          created_at: string
          id: number
-          personal_code: number | null
          request_api: string
          request_api_method: string
          requested_end_date: string | null
@@ -232,12 +231,12 @@ export type Database = {
          service_id: number | null
          service_provider_id: number | null
          status: Database["audit"]["Enums"]["request_status"]
+          user_id: string | null
        }
        Insert: {
          comment?: string | null
          created_at?: string
          id?: number
-          personal_code?: number | null
          request_api: string
          request_api_method: string
          requested_end_date?: string | null
@@ -245,12 +244,12 @@ export type Database = {
          service_id?: number | null
          service_provider_id?: number | null
          status: Database["audit"]["Enums"]["request_status"]
+          user_id?: string | null
        }
        Update: {
          comment?: string | null
          created_at?: string
          id?: number
-          personal_code?: number | null
          request_api?: string
          request_api_method?: string
          requested_end_date?: string | null
@@ -258,6 +257,7 @@ export type Database = {
          service_id?: number | null
          service_provider_id?: number | null
          status?: Database["audit"]["Enums"]["request_status"]
+          user_id?: string | null
        }
        Relationships: []
      }
@@ -337,6 +337,91 @@ export type Database = {
  }
  medreport: {
    Tables: {
+      account_balance_entries: {
+        Row: {
+          account_id: string
+          amount: number
+          created_at: string
+          created_by: string | null
+          description: string | null
+          entry_type: string
+          expires_at: string | null
+          id: string
+          is_active: boolean
+          reference_id: string | null
+          source_company_id: string | null
+        }
+        Insert: {
+          account_id: string
+          amount: number
+          created_at?: string
+          created_by?: string | null
+          description?: string | null
+          entry_type: string
+          expires_at?: string | null
+          id?: string
+          is_active?: boolean
+          reference_id?: string | null
+          source_company_id?: string | null
+        }
+        Update: {
+          account_id?: string
+          amount?: number
+          created_at?: string
+          created_by?: string | null
+          description?: string | null
+          entry_type?: string
+          expires_at?: string | null
+          id?: string
+          is_active?: boolean
+          reference_id?: string | null
+          source_company_id?: string | null
+        }
+        Relationships: [
+          {
+            foreignKeyName: "account_balance_entries_account_id_fkey"
+            columns: ["account_id"]
+            isOneToOne: false
+            referencedRelation: "accounts"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "account_balance_entries_account_id_fkey"
+            columns: ["account_id"]
+            isOneToOne: false
+            referencedRelation: "user_account_workspace"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "account_balance_entries_account_id_fkey"
+            columns: ["account_id"]
+            isOneToOne: false
+            referencedRelation: "user_accounts"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "account_balance_entries_source_company_id_fkey"
+            columns: ["source_company_id"]
+            isOneToOne: false
+            referencedRelation: "accounts"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "account_balance_entries_source_company_id_fkey"
+            columns: ["source_company_id"]
+            isOneToOne: false
+            referencedRelation: "user_account_workspace"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "account_balance_entries_source_company_id_fkey"
+            columns: ["source_company_id"]
+            isOneToOne: false
+            referencedRelation: "user_accounts"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
      account_params: {
        Row: {
          account_id: string
@@ -841,6 +926,64 @@ export type Database = {
          },
        ]
      }
+      benefit_distribution_schedule: {
+        Row: {
+          benefit_amount: number
+          benefit_occurrence: string
+          company_id: string
+          created_at: string
+          id: string
+          is_active: boolean
+          last_distributed_at: string | null
+          next_distribution_at: string
+          updated_at: string
+        }
+        Insert: {
+          benefit_amount: number
+          benefit_occurrence: string
+          company_id: string
+          created_at?: string
+          id?: string
+          is_active?: boolean
+          last_distributed_at?: string | null
+          next_distribution_at: string
+          updated_at?: string
+        }
+        Update: {
+          benefit_amount?: number
+          benefit_occurrence?: string
+          company_id?: string
+          created_at?: string
+          id?: string
+          is_active?: boolean
+          last_distributed_at?: string | null
+          next_distribution_at?: string
+          updated_at?: string
+        }
+        Relationships: [
+          {
+            foreignKeyName: "benefit_distribution_schedule_company_id_fkey"
+            columns: ["company_id"]
+            isOneToOne: false
+            referencedRelation: "accounts"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "benefit_distribution_schedule_company_id_fkey"
+            columns: ["company_id"]
+            isOneToOne: false
+            referencedRelation: "user_account_workspace"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "benefit_distribution_schedule_company_id_fkey"
+            columns: ["company_id"]
+            isOneToOne: false
+            referencedRelation: "user_accounts"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
      billing_customers: {
        Row: {
          account_id: string
@@ -1057,32 +1200,76 @@ export type Database = {
        }
        Relationships: []
      }
+      connected_online_locations: {
+        Row: {
+          address: string | null
+          clinic_id: number
+          created_at: string
+          id: number
+          name: string
+          sync_id: number
+          updated_at: string | null
+        }
+        Insert: {
+          address?: string | null
+          clinic_id: number
+          created_at?: string
+          id?: number
+          name: string
+          sync_id: number
+          updated_at?: string | null
+        }
+        Update: {
+          address?: string | null
+          clinic_id?: number
+          created_at?: string
+          id?: number
+          name?: string
+          sync_id?: number
+          updated_at?: string | null
+        }
+        Relationships: [
+          {
+            foreignKeyName: "connected_online_locations_clinic_id_fkey"
+            columns: ["clinic_id"]
+            isOneToOne: false
+            referencedRelation: "connected_online_providers"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
      connected_online_providers: {
        Row: {
+          address: string
          can_select_worker: boolean
          created_at: string
          email: string | null
          id: number
+          key: string
          name: string
          personal_code_required: boolean
          phone_number: string | null
          updated_at: string | null
        }
        Insert: {
+          address?: string
          can_select_worker: boolean
          created_at?: string
          email?: string | null
          id: number
+          key: string
          name: string
          personal_code_required: boolean
          phone_number?: string | null
          updated_at?: string | null
        }
        Update: {
+          address?: string
          can_select_worker?: boolean
          created_at?: string
          email?: string | null
          id?: number
+          key?: string
          name?: string
          personal_code_required?: boolean
          phone_number?: string | null
@@ -1092,54 +1279,131 @@ export type Database = {
      }
      connected_online_reservation: {
        Row: {
-          booking_code: string
+          booking_code: string | null
          clinic_id: number
          comments: string | null
          created_at: string
          discount_code: string | null
          id: number
          lang: string
-          requires_payment: boolean
+          location_sync_id: number | null
+          medusa_cart_line_item_id: string | null
+          requires_payment: boolean | null
          service_id: number
-          service_user_id: number | null
+          service_user_id: number
          start_time: string
+          status: Database["medreport"]["Enums"]["connected_online_order_status"]
          sync_user_id: number
          updated_at: string | null
          user_id: string
        }
        Insert: {
-          booking_code: string
+          booking_code?: string | null
          clinic_id: number
          comments?: string | null
          created_at?: string
          discount_code?: string | null
          id?: number
          lang: string
-          requires_payment: boolean
+          location_sync_id?: number | null
+          medusa_cart_line_item_id?: string | null
+          requires_payment?: boolean | null
          service_id: number
-          service_user_id?: number | null
+          service_user_id: number
          start_time: string
+          status: Database["medreport"]["Enums"]["connected_online_order_status"]
          sync_user_id: number
          updated_at?: string | null
          user_id: string
        }
        Update: {
-          booking_code?: string
+          booking_code?: string | null
          clinic_id?: number
          comments?: string | null
          created_at?: string
          discount_code?: string | null
          id?: number
          lang?: string
-          requires_payment?: boolean
+          location_sync_id?: number | null
+          medusa_cart_line_item_id?: string | null
+          requires_payment?: boolean | null
          service_id?: number
-          service_user_id?: number | null
+          service_user_id?: number
          start_time?: string
+          status?: Database["medreport"]["Enums"]["connected_online_order_status"]
          sync_user_id?: number
          updated_at?: string | null
          user_id?: string
        }
-        Relationships: []
+        Relationships: [
+          {
+            foreignKeyName: "fk_reservation_clinic"
+            columns: ["clinic_id"]
+            isOneToOne: false
+            referencedRelation: "connected_online_providers"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "fk_reservation_service"
+            columns: ["service_id"]
+            isOneToOne: false
+            referencedRelation: "connected_online_services"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
+      connected_online_service_providers: {
+        Row: {
+          clinic_id: number
+          created_at: string
+          id: number
+          is_deleted: boolean | null
+          job_title_en: string | null
+          job_title_et: string | null
+          job_title_id: number | null
+          job_title_ru: string | null
+          name: string
+          prefix: string | null
+          spoken_languages: string[] | null
+          updated_at: string | null
+        }
+        Insert: {
+          clinic_id: number
+          created_at?: string
+          id: number
+          is_deleted?: boolean | null
+          job_title_en?: string | null
+          job_title_et?: string | null
+          job_title_id?: number | null
+          job_title_ru?: string | null
+          name: string
+          prefix?: string | null
+          spoken_languages?: string[] | null
+          updated_at?: string | null
+        }
+        Update: {
+          clinic_id?: number
+          created_at?: string
+          id?: number
+          is_deleted?: boolean | null
+          job_title_en?: string | null
+          job_title_et?: string | null
+          job_title_id?: number | null
+          job_title_ru?: string | null
+          name?: string
+          prefix?: string | null
+          spoken_languages?: string[] | null
+          updated_at?: string | null
+        }
+        Relationships: [
+          {
+            foreignKeyName: "connected_online_service_providers_clinic_id_fkey"
+            columns: ["clinic_id"]
+            isOneToOne: false
+            referencedRelation: "connected_online_providers"
+            referencedColumns: ["id"]
+          },
+        ]
      }
      connected_online_services: {
        Row: {
@@ -1158,7 +1422,7 @@ export type Database = {
          price: number
          price_periods: string | null
          requires_payment: boolean
-          sync_id: string
+          sync_id: number
          updated_at: string | null
        }
        Insert: {
@@ -1177,7 +1441,7 @@ export type Database = {
          price: number
          price_periods?: string | null
          requires_payment: boolean
-          sync_id: string
+          sync_id: number
          updated_at?: string | null
        }
        Update: {
@@ -1196,7 +1460,7 @@ export type Database = {
          price?: number
          price_periods?: string | null
          requires_payment?: boolean
-          sync_id?: string
+          sync_id?: number
          updated_at?: string | null
        }
        Relationships: [
@@ -1931,10 +2195,23 @@ export type Database = {
        }
        Returns: Database["medreport"]["Tables"]["invitations"]["Row"][]
      }
+      calculate_next_distribution_date: {
+        Args: { p_current_date?: string; p_occurrence: string }
+        Returns: string
+      }
      can_action_account_member: {
        Args: { target_team_account_id: string; target_user_id: string }
        Returns: boolean
      }
+      consume_account_balance: {
+        Args: {
+          p_account_id: string
+          p_amount: number
+          p_description: string
+          p_reference_id?: string
+        }
+        Returns: boolean
+      }
      create_invitation: {
        Args: { account_id: string; email: string; role: string }
        Returns: {
@@ -1988,6 +2265,18 @@ export type Database = {
          updated_by: string | null
        }
      }
+      distribute_health_benefits: {
+        Args: {
+          p_benefit_amount: number
+          p_benefit_occurrence?: string
+          p_company_id: string
+        }
+        Returns: undefined
+      }
+      get_account_balance: {
+        Args: { p_account_id: string }
+        Returns: number
+      }
      get_account_invitations: {
        Args: { account_slug: string }
        Returns: {
@@ -2148,6 +2437,10 @@ export type Database = {
        Args: { medusa_order_id: string }
        Returns: boolean
      }
+      process_periodic_benefit_distributions: {
+        Args: Record<PropertyKey, never>
+        Returns: undefined
+      }
      revoke_nonce: {
        Args: { p_id: string; p_reason?: string }
        Returns: boolean
@@ -2172,6 +2465,10 @@ export type Database = {
        Args: { new_owner_id: string; target_account_id: string }
        Returns: undefined
      }
+      trigger_benefit_distribution: {
+        Args: { p_company_id: string }
+        Returns: undefined
+      }
      update_account: {
        Args:
          | {
@@ -2211,6 +2508,14 @@ export type Database = {
          user_id: string
        }
      }
+      upsert_benefit_distribution_schedule: {
+        Args: {
+          p_benefit_amount: number
+          p_benefit_occurrence: string
+          p_company_id: string
+        }
+        Returns: undefined
+      }
      upsert_order: {
        Args: {
          billing_provider: Database["medreport"]["Enums"]["billing_provider"]
@@ -2300,6 +2605,11 @@ export type Database = {
        | "invites.manage"
      application_role: "user" | "doctor" | "super_admin"
      billing_provider: "stripe" | "lemon-squeezy" | "paddle" | "montonio"
+      connected_online_order_status:
+        | "PENDING"
+        | "CONFIRMED"
+        | "REJECTED"
+        | "CANCELLED"
      locale: "en" | "et" | "ru"
      notification_channel: "in_app" | "email"
      notification_type: "info" | "warning" | "error"
@@ -8217,6 +8527,12 @@ export const Constants = {
      ],
      application_role: ["user", "doctor", "super_admin"],
      billing_provider: ["stripe", "lemon-squeezy", "paddle", "montonio"],
+      connected_online_order_status: [
+        "PENDING",
+        "CONFIRMED",
+        "REJECTED",
+        "CANCELLED",
+      ],
      locale: ["en", "et", "ru"],
      notification_channel: ["in_app", "email"],
      notification_type: ["info", "warning", "error"],
--- a/packages/ui/src/shadcn/calendar.tsx
+++ b/packages/ui/src/shadcn/calendar.tsx
@@ -34,11 +34,11 @@ function Calendar({
        nav_button_previous: 'absolute left-1',
        nav_button_next: 'absolute right-1',
        table: 'w-full border-collapse space-y-1',
-        head_row: 'flex',
+        head_row: 'flex justify-evenly',
        head_cell:
          'text-muted-foreground rounded-md w-9 font-normal text-[0.8rem]',
-        row: 'flex w-full mt-2',
-        cell: 'text-center text-sm p-0 relative [&:has([aria-selected])]:bg-accent first:[&:has([aria-selected])]:rounded-l-md last:[&:has([aria-selected])]:rounded-r-md focus-within:relative focus-within:z-20',
+        row: 'flex w-full mt-2 justify-evenly',
+        cell: 'text-center text-sm p-0 relative [&:has([aria-selected])]:bg-accent first:[&:has([aria-selected])]:rounded-l-md last:[&:has([aria-selected])]:rounded-md focus-within:relative focus-within:z-20',
        day: cn(
          buttonVariants({ variant: 'ghost' }),
          'h-9 w-9 p-0 font-normal aria-selected:opacity-100',
--- a/packages/ui/src/shadcn/card.tsx
+++ b/packages/ui/src/shadcn/card.tsx
@@ -41,11 +41,9 @@ const CardHeader: React.FC<React.HTMLAttributes<HTMLDivElement>> = ({
 );
 CardHeader.displayName = 'CardHeader';

-const CardTitle: React.FC<React.HTMLAttributes<HTMLHeadingElement> & { size?: 'h3' | 'h4' | 'h5' }> = ({
-  className,
-  size = 'h3',
-  ...props
-}) => {
+const CardTitle: React.FC<
+  React.HTMLAttributes<HTMLHeadingElement> & { size?: 'h3' | 'h4' | 'h5' }
+> = ({ className, size = 'h3', ...props }) => {
  const Component = size;
  return (
    <Component
--- a/packages/ui/src/shadcn/radio-group.tsx
+++ b/packages/ui/src/shadcn/radio-group.tsx
@@ -25,12 +25,12 @@ const RadioGroupItem: React.FC<
  return (
    <RadioGroupPrimitive.Item
      className={cn(
-        'border-primary text-primary focus-visible:ring-ring aspect-square h-4 w-4 rounded-full border shadow-xs focus:outline-hidden focus-visible:ring-1 disabled:cursor-not-allowed disabled:opacity-50',
+        'border-primary focus-visible:ring-ring aspect-square h-4 w-4 rounded-full border text-white shadow-xs focus:outline-hidden focus-visible:ring-1 disabled:cursor-not-allowed disabled:opacity-50',
        className,
      )}
      {...props}
    >
-      <RadioGroupPrimitive.Indicator className="flex items-center justify-center">
+      <RadioGroupPrimitive.Indicator className="bg-primary flex items-center justify-center rounded-full">
        <CheckIcon className="fill-primary h-3.5 w-3.5" />
      </RadioGroupPrimitive.Indicator>
    </RadioGroupPrimitive.Item>
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/public/locales/en/booking.json
+++ b/public/locales/en/booking.json
@@ -4,5 +4,17 @@
  "analysisPackages": {
    "title": "Analysis packages",
    "description": "Get to know the personal analysis packages and order"
-  }
+  },
+  "noCategories": "Service list not found, please try again later",
+  "noResults": "No available times on the selected dates",
+  "services": "Services",
+  "locations": "Locations",
+  "showAll": "Show all",
+  "showAllLocations": "Show all locations",
+  "bookTimeSuccess": "Time selected",
+  "bookTimeError": "Failed to select time",
+  "bookTimeLoading": "Selecting time...",
+  "serviceNotFound": "Service not found",
+  "noProducts": "No products found",
+  "timeSlotUnavailable": "Service availability has changed, please select a new time"
 }
--- a/public/locales/en/cart.json
+++ b/public/locales/en/cart.json
@@ -7,14 +7,18 @@
    "item": "Item",
    "quantity": "Quantity",
    "price": "Price",
-    "total": "Total"
+    "total": "Total",
+    "time": "Time",
+    "location": "Location"
  },
  "checkout": {
    "goToCheckout": "Go to checkout",
    "goToDashboard": "Continue",
    "error": {
      "title": "Something went wrong",
-      "description": "Please try again later."
+      "description": "Please try again later.",
+      "BOOKING_FAILED": "Service error, please try again later.",
+      "TIME_SLOT_UNAVAILABLE": "The selected time is not available."
    },
    "timeLeft": "Time left  {{timeLeft}}",
    "timeoutTitle": "Reservation expired",
@@ -82,5 +86,9 @@
    "title": "Location for analysis",
    "description": "If you are unable to go to the lab to collect the sample, you can go to any other suitable collection point.",
    "locationSelect": "Select location"
+  },
+  "editServiceItem": {
+    "title": "Edit booking",
+    "description": "Edit booking details"
  }
 }
--- a/public/locales/en/common.json
+++ b/public/locales/en/common.json
@@ -148,5 +148,7 @@
  "language": "Language",
  "yes": "Yes",
  "no": "No",
-  "preferNotToAnswer": "Prefer not to answer"
+  "preferNotToAnswer": "Prefer not to answer",
+  "book": "Book",
+  "change": "Change"
 }
--- a/public/locales/en/orders.json
+++ b/public/locales/en/orders.json
@@ -9,12 +9,27 @@
    "status": "Status"
  },
  "status": {
-    "QUEUED": "Waiting to send to lab",
-    "PROCESSING": "Waiting for results",
-    "PARTIAL_ANALYSIS_RESPONSE": "Partial analysis response",
-    "FULL_ANALYSIS_RESPONSE": "All analysis responses received, waiting for doctor response",
-    "COMPLETED": "Completed",
+    "QUEUED": "Queued",
+    "PROCESSING": "Processing",
+    "PARTIAL_ANALYSIS_RESPONSE": "Partial results",
+    "FULL_ANALYSIS_RESPONSE": "All results received",
+    "COMPLETED": "Confirmed",
    "REJECTED": "Rejected",
-    "CANCELLED": "Cancelled"
+    "CANCELLED": "Cancelled",
+    "analysisOrder": {
+      "QUEUED": "Queued",
+      "PROCESSING": "Sent to Synlab",
+      "PARTIAL_ANALYSIS_RESPONSE": "Partial results",
+      "FULL_ANALYSIS_RESPONSE": "All results received, awaiting doctor's summary",
+      "COMPLETED": "Confirmed",
+      "REJECTED": "Rejected",
+      "CANCELLED": "Cancelled"
+    },
+    "ttoService": {
+      "PENDING": "Started",
+      "CONFIRMED": "Confirmed",
+      "REJECTED": "Rejected",
+      "CANCELLED": "Cancelled"
+    }
  }
 }
--- a/public/locales/et/booking.json
+++ b/public/locales/et/booking.json
@@ -5,5 +5,16 @@
    "title": "Analüüside paketid",
    "description": "Tutvu personaalsete analüüsi pakettidega ja telli"
  },
-  "noCategories": "Teenuste loetelu ei leitud, proovi hiljem uuesti"
+  "noCategories": "Teenuste loetelu ei leitud, proovi hiljem uuesti",
+  "noResults": "Valitud kuupäevadel ei ole vabu aegu",
+  "services": "Teenused",
+  "locations": "Asutused",
+  "showAll": "Kuva kõik",
+  "showAllLocations": "Näita kõiki asutusi",
+  "bookTimeSuccess": "Aeg valitud",
+  "bookTimeError": "Aega ei õnnestunud valida",
+  "bookTimeLoading": "Aega valitakse...",
+  "serviceNotFound": "Teenust ei leitud",
+  "noProducts": "Tooteid ei leitud",
+  "timeSlotUnavailable": "Teenuse saadavus muutus, palun vali uus aeg"
 }
--- a/public/locales/et/cart.json
+++ b/public/locales/et/cart.json
@@ -7,14 +7,18 @@
    "item": "Toode",
    "quantity": "Kogus",
    "price": "Hind",
-    "total": "Summa"
+    "total": "Summa",
+    "time": "Aeg",
+    "location": "Asukoht"
  },
  "checkout": {
    "goToCheckout": "Vormista ost",
    "goToDashboard": "Jätkan",
    "error": {
      "title": "Midagi läks valesti",
-      "description": "Palun proovi hiljem uuesti."
+      "description": "Palun proovi hiljem uuesti.",
+      "BOOKING_FAILED": "Teenuse tõrge, proovi hiljem uuesti.",
+      "TIME_SLOT_UNAVAILABLE": "Valitud aeg ei ole saadaval."
    },
    "timeLeft": "Aega jäänud  {{timeLeft}}",
    "timeoutTitle": "Broneering aegus",
@@ -82,5 +86,9 @@
    "title": "Asukoht analüüside andmiseks",
    "description": "Kui Teil ei ole võimalik valitud asukohta minna analüüse andma, siis võite minna Teile sobivasse verevõtupunkti.",
    "locationSelect": "Vali asukoht"
+  },
+  "editServiceItem": {
+    "title": "Muuda broneeringut",
+    "description": "Muuda broneeringu andmeid"
  }
 }
--- a/public/locales/et/common.json
+++ b/public/locales/et/common.json
@@ -148,5 +148,7 @@
  "language": "Keel",
  "yes": "Jah",
  "no": "Ei",
-  "preferNotToAnswer": "Eelistan mitte vastata"
+  "preferNotToAnswer": "Eelistan mitte vastata",
+  "book": "Broneeri",
+  "change": "Muuda"
 }
--- a/public/locales/et/orders.json
+++ b/public/locales/et/orders.json
@@ -4,17 +4,33 @@
  "noOrders": "Tellimusi ei leitud",
  "table": {
    "analysisPackage": "Analüüsi pakett",
+    "ttoService": "Broneering",
    "otherOrders": "Tellimus",
    "createdAt": "Tellitud",
    "status": "Olek"
  },
  "status": {
    "QUEUED": "Esitatud",
-    "PROCESSING": "Synlabile edastatud",
+    "PROCESSING": "Edastatud",
    "PARTIAL_ANALYSIS_RESPONSE": "Osalised tulemused",
-    "FULL_ANALYSIS_RESPONSE": "Kõik tulemused käes, ootab arsti kokkuvõtet",
+    "FULL_ANALYSIS_RESPONSE": "Kõik tulemused käes",
    "COMPLETED": "Kinnitatud",
    "REJECTED": "Tagastatud",
-    "CANCELLED": "Tühistatud"
+    "CANCELLED": "Tühistatud",
+    "analysisOrder": {
+      "QUEUED": "Esitatud",
+      "PROCESSING": "Synlabile edastatud",
+      "PARTIAL_ANALYSIS_RESPONSE": "Osalised tulemused",
+      "FULL_ANALYSIS_RESPONSE": "Kõik tulemused käes, ootab arsti kokkuvõtet",
+      "COMPLETED": "Kinnitatud",
+      "REJECTED": "Tagastatud",
+      "CANCELLED": "Tühistatud"
+    },
+    "ttoService": {
+      "PENDING": "Alustatud",
+      "CONFIRMED": "Kinnitatud",
+      "REJECTED": "Tagasi lükatud",
+      "CANCELLED": "Tühistatud"
+    }
  }
 }
--- a/public/locales/ru/booking.json
+++ b/public/locales/ru/booking.json
@@ -5,5 +5,16 @@
    "title": "Пакеты анализов",
    "description": "Ознакомьтесь с персональными пакетами анализов и закажите"
  },
-  "noCategories": "Список услуг не найден, попробуйте позже"
+  "noCategories": "Список услуг не найден, попробуйте позже",
+  "noResults": "На выбранные даты нет свободного времени",
+  "services": "Услуги",
+  "locations": "Учреждения",
+  "showAll": "Показать все",
+  "showAllLocations": "Показать все учреждения",
+  "bookTimeSuccess": "Время выбрано",
+  "bookTimeError": "Не удалось выбрать время",
+  "bookTimeLoading": "Выбор времени...",
+  "serviceNotFound": "Услуга не найдена",
+  "noProducts": "Товары не найдены",
+  "timeSlotUnavailable": "Доступность услуги изменилась, пожалуйста, выберите другое время"
 }
--- a/public/locales/ru/cart.json
+++ b/public/locales/ru/cart.json
@@ -7,14 +7,18 @@
    "item": "Товар",
    "quantity": "Количество",
    "price": "Цена",
-    "total": "Сумма"
+    "total": "Сумма",
+    "time": "Время",
+    "location": "Местоположение"
  },
  "checkout": {
    "goToCheckout": "Оформить заказ",
    "goToDashboard": "Продолжить",
    "error": {
      "title": "Что-то пошло не так",
-      "description": "Пожалуйста, попробуйте позже."
+      "description": "Пожалуйста, попробуйте позже.",
+      "BOOKING_FAILED": "Ошибка сервиса, попробуйте позже.",
+      "TIME_SLOT_UNAVAILABLE": "Выбранное время недоступно."
    },
    "timeLeft": "Осталось времени {{timeLeft}}",
    "timeoutTitle": "Бронирование истекло",
@@ -82,5 +86,9 @@
    "title": "Местоположение для сдачи анализов",
    "description": "Если у вас нет возможности прийти в выбранное место для сдачи анализов, вы можете посетить любой удобный для вас пункт забора крови.",
    "locationSelect": "Выберите местоположение"
+  },
+  "editServiceItem": {
+    "title": "Изменить бронирование",
+    "description": "Изменить данные бронирования"
  }
 }
--- a/public/locales/ru/orders.json
+++ b/public/locales/ru/orders.json
@@ -10,11 +10,26 @@
  },
  "status": {
    "QUEUED": "Отправлено",
-    "PROCESSING": "Передано в Synlab",
+    "PROCESSING": "В обработке",
    "PARTIAL_ANALYSIS_RESPONSE": "Частичные результаты",
-    "FULL_ANALYSIS_RESPONSE": "Все результаты получены, ожидается заключение врача",
+    "FULL_ANALYSIS_RESPONSE": "Все результаты получены",
    "COMPLETED": "Подтверждено",
-    "REJECTED": "Возвращено",
-    "CANCELLED": "Отменено"
+    "REJECTED": "Отклонено",
+    "CANCELLED": "Отменено",
+    "analysisOrder": {
+      "QUEUED": "Отправлено",
+      "PROCESSING": "Отправлено в Synlab",
+      "PARTIAL_ANALYSIS_RESPONSE": "Частичные результаты",
+      "FULL_ANALYSIS_RESPONSE": "Все результаты получены, ожидается заключение врача",
+      "COMPLETED": "Подтверждено",
+      "REJECTED": "Отклонено",
+      "CANCELLED": "Отменено"
+    },
+    "ttoService": {
+      "PENDING": "Начато",
+      "CONFIRMED": "Подтверждено",
+      "REJECTED": "Отклонено",
+      "CANCELLED": "Отменено"
+    }
  }
 }
--- a/supabase/migrations/20250908092531_add_clinic_key.sql
+++ b/supabase/migrations/20250908092531_add_clinic_key.sql
@@ -0,0 +1,11 @@
+ALTER TABLE medreport.connected_online_providers ADD COLUMN key text not null DEFAULT ''; -- avoid conflict with already existing data, will be filled on next sync
+ALTER TABLE medreport.connected_online_providers
+ALTER key DROP DEFAULT;
+
+ALTER TABLE medreport.connected_online_providers ADD COLUMN address text not null DEFAULT '';
+ALTER TABLE medreport.connected_online_providers
+ALTER key DROP DEFAULT;
+
+ALTER TABLE medreport.connected_online_services 
+ALTER COLUMN sync_id TYPE bigint 
+USING sync_id::bigint;
--- a/supabase/migrations/20250908125839_add_connected_online_service_provider_table.sql
+++ b/supabase/migrations/20250908125839_add_connected_online_service_provider_table.sql
@@ -0,0 +1,60 @@
+create table "medreport"."connected_online_service_providers" (
+    "id" bigint not null primary key,
+    "name" text not null,
+    "spoken_languages" text[],
+    "prefix" text,
+    "job_title_et" text,
+    "job_title_en" text,
+    "job_title_ru" text,
+    "clinic_id" bigint not null REFERENCES medreport.connected_online_providers(id),
+    "job_title_id" bigint,
+    "is_deleted" boolean,
+    "created_at" timestamp with time zone not null default now(),
+    "updated_at" timestamp without time zone default now()
+);
+
+ALTER TABLE audit.request_entries
+DROP COLUMN personal_code;
+
+ALTER TABLE audit.request_entries ADD COLUMN user_id uuid default auth.uid();
+
+create policy "insert_own"
+on "audit"."request_entries"
+as permissive
+for insert
+to authenticated
+with check ((( SELECT auth.uid() AS uid) = user_id));
+
+alter table "medreport"."connected_online_service_providers" enable row level security;
+
+create policy "service_role_all"
+on "medreport"."connected_online_service_providers"
+as permissive
+for all
+to service_role
+using (true);
+
+
+grant delete on table "medreport"."connected_online_service_providers" to "service_role";
+
+grant insert on table "medreport"."connected_online_service_providers" to "service_role";
+
+grant references on table "medreport"."connected_online_service_providers" to "service_role";
+
+grant select on table "medreport"."connected_online_service_providers" to "service_role";
+
+grant trigger on table "medreport"."connected_online_service_providers" to "service_role";
+
+grant truncate on table "medreport"."connected_online_service_providers" to "service_role";
+
+grant update on table "medreport"."connected_online_service_providers" to "service_role";
+
+grant select on table "medreport"."connected_online_service_providers" to "authenticated";
+
+
+create policy "authenticated_select"
+on "medreport"."connected_online_service_providers"
+as permissive
+for select
+to authenticated
+using (true);
--- a/supabase/migrations/20250915091038_add_order_fields_to_connected_online_reservation.sql
+++ b/supabase/migrations/20250915091038_add_order_fields_to_connected_online_reservation.sql
@@ -0,0 +1,14 @@
+ALTER TABLE medreport.connected_online_reservation
+ADD COLUMN medusa_cart_line_item_id TEXT references public.cart_line_item(id);
+
+ALTER TABLE medreport.connected_online_reservation
+ADD COLUMN location_sync_id bigint;
+
+create type medreport.connected_online_order_status as enum ('PENDING', 'CONFIRMED', 'REJECTED', 'CANCELLED');
+
+ALTER TABLE medreport.connected_online_reservation
+ADD COLUMN status medreport.connected_online_order_status not null;
+
+ALTER TABLE medreport.connected_online_reservation ALTER COLUMN booking_code DROP NOT NULL;
+ALTER TABLE medreport.connected_online_reservation ALTER COLUMN requires_payment DROP NOT NULL;
+ALTER TABLE medreport.connected_online_reservation ALTER COLUMN service_user_id SET NOT NULL;
--- a/supabase/migrations/20250915101146_add_connected_online_locations_table.sql
+++ b/supabase/migrations/20250915101146_add_connected_online_locations_table.sql
@@ -0,0 +1,43 @@
+create table "medreport"."connected_online_locations" (
+    "id" bigint generated by default as identity not null,
+    "sync_id" bigint not null,
+    "name" text not null,
+    "address" text,
+    "clinic_id" bigint not null REFERENCES medreport.connected_online_providers(id),
+    "created_at" timestamp with time zone not null default now(),
+    "updated_at" timestamp without time zone default now()
+);
+
+alter table "medreport"."connected_online_locations" enable row level security;
+
+create policy "service_role_all"
+on "medreport"."connected_online_locations"
+as permissive
+for all
+to service_role
+using (true);
+
+
+grant delete on table "medreport"."connected_online_locations" to "service_role";
+
+grant insert on table "medreport"."connected_online_locations" to "service_role";
+
+grant references on table "medreport"."connected_online_locations" to "service_role";
+
+grant select on table "medreport"."connected_online_locations" to "service_role";
+
+grant trigger on table "medreport"."connected_online_locations" to "service_role";
+
+grant truncate on table "medreport"."connected_online_locations" to "service_role";
+
+grant update on table "medreport"."connected_online_locations" to "service_role";
+
+grant select on table "medreport"."connected_online_locations" to "authenticated";
+
+
+create policy "authenticated_select"
+on "medreport"."connected_online_locations"
+as permissive
+for select
+to authenticated
+using (true);
--- a/supabase/migrations/20250919121028_add_references_to_reservations.sql
+++ b/supabase/migrations/20250919121028_add_references_to_reservations.sql
@@ -0,0 +1,12 @@
+ALTER TABLE medreport.connected_online_reservation 
+ADD CONSTRAINT fk_reservation_clinic 
+FOREIGN KEY (clinic_id) 
+REFERENCES medreport.connected_online_providers(id);
+
+ALTER TABLE medreport.connected_online_services 
+ADD CONSTRAINT constraint_name UNIQUE (sync_id);
+
+ALTER TABLE medreport.connected_online_reservation 
+ADD CONSTRAINT fk_reservation_service
+FOREIGN KEY (service_id) 
+REFERENCES medreport.connected_online_services(id);