updated and tested dashboard page

ServicesWeb/customer/src/fetchers/base.ts

@@ -1,11 +1,12 @@
-import { ApiResponse, CookieObject } from "./types";
+import { ResponseCookie } from "next/dist/compiled/@edge-runtime/cookies";
+import { ApiResponse } from "./types";
 import NextCrypto from "next-crypto";
 
 const tokenSecretEnv = process.env.TOKENSECRET_90;
 const tokenSecret = tokenSecretEnv || "e781d1b0-9418-40b3-9940-385abf81a0b7";
 const REDIS_TIMEOUT = 5000; // Redis operation timeout (5 seconds)
 const nextCrypto = new NextCrypto(tokenSecret);
-const cookieObject: CookieObject = {
+const cookieObject: Partial<ResponseCookie> = {
   httpOnly: true,
   path: "/",
   sameSite: "none",

ServicesWeb/customer/src/fetchers/custom/login/login.tsx

@@ -0,0 +1,200 @@
+"use server";
+import NextCrypto from "next-crypto";
+import { fetchData, fetchDataWithToken } from "@/fetchers/fecther";
+import { cookieObject, tokenSecret } from "@/fetchers/base";
+import { urlLoginEndpoint, urlLoginSelectEndpoint, urlLogoutEndpoint } from "@/fetchers/index";
+
+import { cookies } from "next/headers";
+import { setNewCompleteToRedis, getCompleteFromRedis } from "@/fetchers/custom/context/complete/fetch";
+import {
+  defaultValuesHeader,
+  defaultValuesMenu,
+  defaultValuesOnline,
+  defaultValuesPageConfig,
+} from "@/fetchers/types/context";
+import { retrievePageList } from "@/fetchers/mutual/cookies/token";
+import { deleteAllCookies } from "@/fetchers/mutual/cookies/cookie-actions";
+import { setMenuToRedis } from "@/fetchers/custom/context/page/menu/fetch";
+import { LoginViaAccessKeys, LoginSelect, LoginSelectOccupant } from "@/fetchers/types/login/validations";
+
+async function logoutActiveSession() {
+  const response = await fetchDataWithToken(urlLogoutEndpoint, {}, "GET", false);
+  await deleteAllCookies();
+  return response;
+}
+
+async function initRedis(loginRespone: any, firstSelection: any, accessToken: string, redisKey: string) {
+  let alreadyAtRedis = null
+  try {
+    const redisData = await getCompleteFromRedis();
+    alreadyAtRedis = redisData;
+  } catch (error) { }
+  if (!alreadyAtRedis) {
+    const loginObjectToRedis = {
+      online: {
+        ...defaultValuesOnline,
+        lastLogin: new Date(),
+        userType: `${loginRespone.user_type}`.toUpperCase(),
+        lang: loginRespone.user.person.country_code.toLowerCase(),
+      },
+      pageConfig: defaultValuesPageConfig,
+      menu: defaultValuesMenu,
+      header: defaultValuesHeader,
+      selection: { selectionList: loginRespone.selection_list, activeSelection: firstSelection },
+      user: loginRespone.user,
+      settings: { lastOnline: new Date(), token: accessToken },
+      chatRoom: [],
+      notifications: [],
+      messages: [],
+    }
+    await setNewCompleteToRedis(loginObjectToRedis, redisKey);
+  }
+}
+
+async function loginViaAccessKeys(payload: LoginViaAccessKeys) {
+  const cookieStore = await cookies();
+  try {
+    const response = await fetchData(
+      urlLoginEndpoint,
+      {
+        access_key: payload.accessKey,
+        password: payload.password,
+        remember_me: payload.rememberMe,
+      },
+      "POST",
+      false
+    );
+    await deleteAllCookies()
+    if (response.status === 200 || response.status === 202) {
+
+      const loginRespone: any = response?.data;
+      const firstSelection = loginRespone.selection_list.find((item: any) => item.uu_id === loginRespone.selection_list[0].uu_id);
+
+      const nextCrypto = new NextCrypto(tokenSecret);
+      const accessToken = await nextCrypto.encrypt(loginRespone.access_token);
+
+      const redisKey = `CLIENT:${loginRespone.user_type.toUpperCase()}:${firstSelection.uu_id}`;
+      const redisKeyAccess = await nextCrypto.encrypt(redisKey);
+      const usersSelection = await nextCrypto.encrypt(
+        JSON.stringify({
+          selected: firstSelection.uu_id,
+          userType: loginRespone.user_type.toUpperCase(),
+          redisKey,
+        })
+      );
+
+      await initRedis(loginRespone, firstSelection, accessToken, redisKey);
+      cookieStore.set({
+        name: "eys-zzz",
+        value: accessToken,
+        ...cookieObject,
+      });
+      cookieStore.set({
+        name: "eys-yyy",
+        value: redisKeyAccess,
+        ...cookieObject,
+      });
+      cookieStore.set({
+        name: "eys-sel",
+        value: usersSelection,
+        ...cookieObject,
+      });
+      try {
+        return {
+          completed: true,
+          message: "Login successful",
+          status: 200,
+          data: loginRespone,
+        };
+      } catch (error) {
+        console.error("JSON parse error:", error);
+        return {
+          completed: false,
+          message: "Login NOT successful",
+          status: 401,
+          data: "{}",
+        };
+      }
+    }
+
+    return {
+      completed: false,
+      // error: response.error || "Login failed",
+      // message: response.message || "Authentication failed",
+      status: response.status || 500,
+    };
+  } catch (error) {
+    console.error("Login error:", error);
+    return {
+      completed: false,
+      // error: error instanceof Error ? error.message : "Login error",
+      // message: "An error occurred during login",
+      status: 500,
+    };
+  }
+}
+
+async function loginSelectEmployee(payload: LoginSelect) {
+  const cookieStore = await cookies();
+  const nextCrypto = new NextCrypto(tokenSecret);
+  const employeeUUID = payload.uuid;
+  const redisKey = `CLIENT:EMPLOYEE:${employeeUUID}`;
+  const selectResponse: any = await fetchDataWithToken(urlLoginSelectEndpoint, { uuid: employeeUUID }, "POST", false);
+  cookieStore.delete({ name: "eys-sel", ...cookieObject });
+
+  if (selectResponse.status === 200 || selectResponse.status === 202) {
+    const usersSelection = await nextCrypto.encrypt(
+      JSON.stringify({
+        selected: employeeUUID,
+        userType: "employee",
+        redisKey,
+      })
+    );
+    cookieStore.set({
+      name: "eys-sel",
+      value: usersSelection,
+      ...cookieObject,
+    });
+    try {
+      const pageList = await retrievePageList()
+      await setMenuToRedis({
+        selectionList: pageList,
+        activeSelection: "/dashboard"
+      })
+    } catch (error) { }
+  }
+  return selectResponse;
+}
+
+async function loginSelectOccupant(payload: LoginSelectOccupant) {
+  const livingSpaceUUID = payload.uuid;
+  const cookieStore = await cookies();
+  const nextCrypto = new NextCrypto(tokenSecret);
+
+  const selectResponse: any = await fetchDataWithToken(urlLoginSelectEndpoint, { uuid: livingSpaceUUID }, "POST", false);
+  const redisKey = `CLIENT:OCCUPANT:${livingSpaceUUID}`;
+  cookieStore.delete("eys-sel");
+
+  if (selectResponse.status === 200 || selectResponse.status === 202) {
+    const usersSelection = await nextCrypto.encrypt(
+      JSON.stringify({
+        selected: livingSpaceUUID,
+        userType: "OCCUPANT",
+        redisKey,
+      })
+    );
+    cookieStore.set({
+      name: "eys-sel",
+      value: usersSelection,
+      ...cookieObject,
+    });
+  }
+  return selectResponse;
+}
+
+export {
+  loginViaAccessKeys,
+  loginSelectEmployee,
+  loginSelectOccupant,
+  logoutActiveSession,
+};

ServicesWeb/customer/src/fetchers/index.ts

@@ -25,12 +25,19 @@ const urlCheckToken = `${baseUrlAuth}/authentication/token/check`;
 const urlPageValid = `${baseUrlRestriction}/restrictions/page/valid`;
 const urlSiteUrls = `${baseUrlRestriction}/restrictions/sites/list`;
 
+const urlLoginEndpoint = `${baseUrlAuth}/authentication/login`;
+const urlLoginSelectEndpoint = `${baseUrlAuth}/authentication/select`;
+const urlLogoutEndpoint = `${baseUrlAuth}/authentication/logout`;
+
 const urlTesterList = `${baseUrlTester}/tester/list`;
 
 export {
   urlCheckToken,
   urlPageValid,
   urlSiteUrls,
+  urlLoginEndpoint,
+  urlLoginSelectEndpoint,
+  urlLogoutEndpoint,
   // For test use only
   urlTesterList,
 };

ServicesWeb/customer/src/fetchers/types/login/validations.ts

@@ -0,0 +1,15 @@
+interface LoginViaAccessKeys {
+  accessKey: string;
+  password: string;
+  rememberMe: boolean;
+}
+
+interface LoginSelect {
+  uuid: string;
+}
+
+interface LoginSelectOccupant {
+  uuid: any;
+}
+
+export type { LoginViaAccessKeys, LoginSelect, LoginSelectOccupant };