ikoncomponents 1.4.8 → 1.5.0

package/templates/default/utils/actions/account/index.ts

@@ -0,0 +1,33 @@
+"use server"
+import { cache } from "react";
+import { getAccountTree } from "../../api/accountService";
+import { getCookieSession, setCookieSession } from "../../session/cookieSession";
+import { AccountTreeProps } from "./type";
+
+export const getAccount = cache(async (): Promise<AccountTreeProps> => {
+    return await getAccountTree()
+});
+
+export const getActiveAccountId = async (): Promise<string> => {
+    const activeAccountId = await getCookieSession("activeAccountId")
+    return activeAccountId || "";
+};
+
+
+export const getOrSetActiveAccountId = async (): Promise<string> => {
+    let activeAccountId = await getCookieSession("activeAccountId")
+    if (!activeAccountId) {
+        try {
+            const account = await getAccount()
+            activeAccountId = account.ACCOUNT_ID
+            await setActiveAccountId(activeAccountId)
+        } catch (error) {
+            console.error(error)
+        }
+    }
+    return activeAccountId || "";
+};
+
+export const setActiveAccountId = async (accountId: string) => {
+    await setCookieSession("activeAccountId", accountId)
+};

package/templates/default/utils/actions/account/type.ts

@@ -0,0 +1,4 @@
+export interface AccountTreeProps {
+    ACCOUNT_ID: string,
+    ACCOUNT_NAME: string,
+}

package/{dist/utils/actions/auth/index.js → templates/default/utils/actions/auth/index.ts}

@@ -1,58 +1,69 @@
-"use server";
-import { redirect } from "next/navigation";
-import { logout } from "../../api/loginService";
-import { clearAllCookieSession, getCookieSession, setCookieSession } from "../../session/cookieSession";
-import { cookies } from "next/headers";
-export const setTicket = async (ticket) => {
-    await setCookieSession("ticket", ticket);
-};
-export const getTicket = async () => {
-    return await getCookieSession("ticket");
-};
-export const getProfileData = async () => {
-    const cookieStore = await cookies();
-    const cookieHeader = cookieStore.getAll()
-        .map(({ name, value }) => `${name}=${value}`)
-        .join("; "); // Convert to a valid Cookie header string
-    // Fetch API with cookies
-    const resp = await fetch(`${process.env.NEXT_BASE_PATH_URL}/api/profile`, {
-        method: "GET",
-        headers: {
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-            "Cookie": cookieHeader, // ✅ Send all cookies
-        },
-        cache: "force-cache",
-    });
-    return resp.json();
-    // let data1: GetLoggedInUserProfileReturnProps = {} as GetLoggedInUserProfileReturnProps;
-    // try {
-    //     data1 = await getLoggedInUserProfile();
-    // } catch (error) {
-    //     console.error(error)
-    // }
-    // let data2: GetLoggedInUserProfileDetailsReturnProps = {} as GetLoggedInUserProfileDetailsReturnProps;
-    // try {
-    //     data2 = await getLoggedInUserProfileDetails();
-    // } catch (error) {
-    //     console.error(error)
-    // }
-    // return { ...data1, ...data2 };
-};
-export async function signOut() {
-    try {
-        await logout();
-    }
-    catch (error) {
-        console.error(error);
-    }
-    await clearAllCookieSession();
-    redirect("/login");
-}
-export const getCurrentUserId = async () => {
-    const currentUserId = await getCookieSession("currentUserId");
-    return currentUserId || "";
-};
-export const setCurrentUserId = async (userId) => {
-    await setCookieSession("currentUserId", userId);
-};
+"use server"
+import { redirect } from "next/navigation";
+import { GetLoggedInUserProfileDetailsReturnProps, GetLoggedInUserProfileReturnProps } from "../../api/loginService/type";
+import { logout } from "../../api/loginService";
+import { clearAllCookieSession, getCookieSession, setCookieSession } from "../../session/cookieSession";
+import { cookies } from "next/headers";
+
+export const setTicket = async (ticket: string) => {
+    await setCookieSession("ticket", ticket)
+};
+export const getTicket = async (): Promise<string | undefined> => {
+    return await getCookieSession("ticket")
+};
+
+export const getProfileData = async (): Promise<GetLoggedInUserProfileReturnProps & GetLoggedInUserProfileDetailsReturnProps> => {
+
+
+    const cookieStore = await cookies();
+    const cookieHeader = cookieStore.getAll()
+        .map(({ name, value }) => `${name}=${value}`)
+        .join("; "); // Convert to a valid Cookie header string
+
+    // Fetch API with cookies
+    const resp = await fetch(`${process.env.NEXT_BASE_PATH_URL}/api/profile`, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Cookie": cookieHeader, // ✅ Send all cookies
+        },
+        cache: "force-cache",
+    });
+
+    return resp.json();
+
+    // let data1: GetLoggedInUserProfileReturnProps = {} as GetLoggedInUserProfileReturnProps;
+    // try {
+    //     data1 = await getLoggedInUserProfile();
+    // } catch (error) {
+    //     console.error(error)
+    // }
+    // let data2: GetLoggedInUserProfileDetailsReturnProps = {} as GetLoggedInUserProfileDetailsReturnProps;
+    // try {
+    //     data2 = await getLoggedInUserProfileDetails();
+    // } catch (error) {
+    //     console.error(error)
+    // }
+    // return { ...data1, ...data2 };
+
+}
+
+export async function signOut() {
+    try {
+        await logout();
+    } catch (error) {
+        console.error(error)
+    }
+    await clearAllCookieSession()
+    redirect("/login")
+}
+
+export const getCurrentUserId = async (): Promise<string> => {
+    const currentUserId = await getCookieSession("currentUserId")
+    return currentUserId || "";
+};
+
+export const setCurrentUserId = async (userId: string) => {
+    await setCookieSession("currentUserId", userId)
+};

package/templates/default/utils/actions/common/revalidate.ts

@@ -0,0 +1,18 @@
+"use server"
+
+import { revalidatePath, revalidateTag } from "next/cache";
+import { RevalidateProps } from "./type";
+
+export async function revalidateData({ paths, tags }: RevalidateProps) {
+    if (tags) {
+        for (const tag of tags) {
+           revalidateTag(tag, "default");
+        }
+    }
+
+    if (paths) {
+        for (const path of paths) {
+            revalidatePath(path)
+        }
+    }
+}

package/templates/default/utils/actions/common/type.ts

@@ -0,0 +1,4 @@
+export interface RevalidateProps {
+    paths?: string[],
+    tags?: string[]
+}

package/{dist/utils/actions/common/utils.js → templates/default/utils/actions/common/utils.ts}

@@ -1,25 +1,28 @@
-import { getTicket } from "../auth";
-export function getSrcFromBase64String(imgString, type) {
-    return imgString ? `data:${type || "image/webp"};base64,${imgString}` : "";
-}
-export async function getResourceUrl(fileInfo) {
-    const globalTicket = await getTicket();
-    return "https://ikoncloud-dev.keross.com/ikon-api/download" + "?ticket=" + globalTicket + "&resourceId=" + fileInfo.resourceId + "&resourceName=" + fileInfo.resourceName + "&resourceType=" + fileInfo.resourceType;
-}
-export async function downloadResource(fileInfo) {
-    const resourceUrl = await getResourceUrl(fileInfo);
-    window.open(encodeURI(resourceUrl));
-}
-export async function openFileInNewTab(url) {
-    const encodedLink = encodeURI(url);
-    try {
-        const response = await fetch(encodedLink);
-        const blob = await response.blob();
-        const blobUrl = URL.createObjectURL(blob);
-        window.open(blobUrl, '_blank');
-    }
-    catch (err) {
-        console.error('Failed to open file in new tab:', err);
-    }
-}
-;
+import { FileinfoProps } from "../../api/file-upload/type";
+import { getTicket } from "../auth";
+
+export function getSrcFromBase64String(imgString?: string | null, type?: string) {
+    return imgString ? `data:${type || "image/webp"};base64,${imgString}` : "";
+}
+
+export async function getResourceUrl(fileInfo: FileinfoProps): Promise<string> {
+    const globalTicket = await getTicket();
+    return "https://ikoncloud-dev.keross.com/ikon-api/download" + "?ticket=" + globalTicket + "&resourceId=" + fileInfo.resourceId + "&resourceName=" + fileInfo.resourceName + "&resourceType=" + fileInfo.resourceType
+}
+
+export async function downloadResource(fileInfo: FileinfoProps) {
+    const resourceUrl = await getResourceUrl(fileInfo)
+    window.open(encodeURI(resourceUrl))
+}
+
+export async function openFileInNewTab(url: string) {
+    const encodedLink = encodeURI(url);
+    try {
+        const response = await fetch(encodedLink);
+        const blob = await response.blob();
+        const blobUrl = URL.createObjectURL(blob);
+        window.open(blobUrl, '_blank');
+    } catch (err) {
+        console.error('Failed to open file in new tab:', err);
+    }
+};

package/templates/default/utils/actions/software/index.ts

@@ -0,0 +1,106 @@
+"use server";
+import { cache } from "react";
+import {
+  getAccessibleSoftwareForUser,
+  mapSoftwareName,
+} from "../../api/softwareService";
+import {
+  getCookieSession,
+  setCookieSession,
+} from "../../session/cookieSession";
+import { cookies } from "next/headers";
+import { SubscribeSoftwareProps } from "../../api/softwareService/type";
+
+export const getBaseSoftwareId = async (): Promise<string | undefined> => {
+  return await getCookieSession("baseSoftwareId");
+};
+
+export const getOrSetBaseSoftwareId = async (): Promise<string | undefined> => {
+  let baseSoftwareId = await getCookieSession("baseSoftwareId");
+  if (!baseSoftwareId) {
+    try {
+      baseSoftwareId = await getSoftwareIdByNameVersion("Base App", "1");
+      await setBaseSoftwareId(baseSoftwareId);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return baseSoftwareId;
+};
+
+export const setBaseSoftwareId = async (softwareId: string) => {
+  await setCookieSession("baseSoftwareId", softwareId);
+};
+
+export const getCurrentSoftwareId = async (): Promise<string> => {
+  return (await getCookieSession("currentSoftwareId")) || "";
+};
+
+export const getCurrentAppName = async (): Promise<string> => {
+  return (await getCookieSession("currentAppName")) || "";
+};
+
+export const setCurrentSoftwareId = async (softwareId: string) => {
+  await setCookieSession("currentSoftwareId", softwareId);
+};
+
+export const getSoftwareIdByNameVersion = cache(
+  async (softwareName: string, version: string): Promise<string> => {
+    return await mapSoftwareName({ softwareName, version });
+  }
+);
+
+export const setCurrentSoftwareIdByNameVersion = async (
+  softwareName: string,
+  version: string
+) => {
+  const softwareId = await getSoftwareIdByNameVersion(softwareName, version);
+  await setCurrentSoftwareId(softwareId);
+};
+
+export const getAccessibleSoftware = cache(
+  async (accountId: string, userId: string) => {
+    return await getAccessibleSoftwareForUser({ accountId, userId });
+  }
+);
+
+// export const getAllSubscribedSoftwares = cache(async (accountId: string) => {
+//     return await getAllSubscribedSoftwaresForClient({ accountId });
+// });
+
+export const getAllSubscribedSoftwares = async (
+  accountId?: string
+): Promise<SubscribeSoftwareProps[]> => {
+  try {
+    const cookieStore = await cookies();
+    const cookieHeader = cookieStore
+      .getAll()
+      .map(({ name, value }) => `${name}=${value}`)
+      .join("; "); // Convert to a valid Cookie header string
+
+    // Fetch API with cookies
+    const resp = await fetch(
+      `${process.env.NEXT_BASE_PATH_URL}/api/software/subscribe`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          Cookie: cookieHeader, // ✅ Send all cookies
+          body: JSON.stringify({
+            accountId,
+          }),
+        },
+        cache: "force-cache",
+      }
+    );
+
+    if (!resp.ok) throw new Error("Failed to fetch subscribe softwares");
+
+    return resp.json();
+  } catch (error) {
+    console.error(error);
+    return [];
+  }
+};
+

package/templates/default/utils/api/accountService/index.ts

@@ -0,0 +1,103 @@
+"use server";
+import ikonBaseApi from "../ikonBaseApi";
+import { GetAccountTreeProps } from "./type";
+
+export const getAccountTree = async (): Promise<GetAccountTreeProps> => {
+  const result = await ikonBaseApi({
+    service: "accountService",
+    operation: "getAccountTree",
+  });
+  return result.data;
+};
+
+export const checkExistingAccount = async ({
+  accountName,
+}: {
+  accountName: string;
+}): Promise<boolean> => {
+  const result = await ikonBaseApi({
+    service: "accountService",
+    operation: "checkExistingAccount",
+    arguments_: [accountName],
+  });
+  return result.data;
+};
+
+export const getFullAccountTree = async (): Promise<any> => {
+  const result = await ikonBaseApi({
+    service: "accountService",
+    operation: "getFullAccountTree",
+  });
+  return result.data;
+};
+
+export const getAllInvitedAccountsForUser = async (
+  userId: string
+): Promise<any> => {
+  const result = await ikonBaseApi({
+    service: "userInvitationService",
+    operation: "getAllInvitedAccountsForUser",
+    arguments_: [userId],
+  });
+  return result.data;
+};
+
+export const acceptAccountInvitationRequest = async ({
+  userId,
+  requestId,
+}: {
+  userId: string;
+  requestId: string;
+}): Promise<any> => {
+  const result = await ikonBaseApi({
+    service: "userInvitationService",
+    operation: "acceptAccountInvitationRequest",
+    arguments_: [userId, requestId],
+  });
+  return result.data;
+};
+
+export const rejectAccountInvitationRequest = async ({
+  userId,
+  requestId,
+}: {
+  userId: string;
+  requestId: string;
+}): Promise<any> => {
+  const result = await ikonBaseApi({
+    service: "userInvitationService",
+    operation: "rejectAccountInvitationRequest",
+    arguments_: [userId, requestId],
+  });
+  return result.data;
+};
+
+export const cancelAccountInvitationRequest = async ({
+  userId,
+  requestId,
+}: {
+  userId: string;
+  requestId: string;
+}): Promise<any> => {
+  const result = await ikonBaseApi({
+    service: "userInvitationService",
+    operation: "cancelAccountInvitationRequest",
+    arguments_: [userId, requestId],
+  });
+  return result.data;
+};
+
+export const deactivateInvitedUserFromAccount = async ({
+  userId,
+  invitationId,
+}: {
+  userId: string;
+  invitationId: string;
+}): Promise<any> => {
+  const result = await ikonBaseApi({
+    service: "userInvitationService",
+    operation: "deactivateInvitedUserFromAccount",
+    arguments_: [userId, invitationId],
+  });
+  return result.data;
+};

package/templates/default/utils/api/accountService/type.ts

@@ -0,0 +1,4 @@
+export interface GetAccountTreeProps {
+    ACCOUNT_ID: string,
+    ACCOUNT_NAME: string,
+}

package/templates/default/utils/api/file-upload/index.ts

@@ -0,0 +1,103 @@
+"use server";
+import { AxiosResponse } from "axios";
+import { axiosInstance } from "../ikonBaseApi";
+import { v4 } from "uuid";
+import { FileinfoProps } from "./type";
+import { getTicket } from "../../actions/auth";
+
+export async function singleFileUpload(
+  file: File,
+  resourceId?: string
+): Promise<FileinfoProps> {
+  const formData = new FormData();
+  formData.append("file", file);
+
+  const fileInfo = {} as FileinfoProps;
+  fileInfo["resourceId"] = resourceId || v4();
+  fileInfo["resourceName"] = file.name;
+  fileInfo["resourceSize"] = file.size;
+  fileInfo["resourceType"] = file.type;
+
+  const globalTicket = (await getTicket()) || "";
+  const queryParams = new URLSearchParams({
+    ticket: globalTicket,
+    resourceId: fileInfo["resourceId"],
+  });
+  try {
+    const result: AxiosResponse<unknown> = await axiosInstance({
+      method: "POST",
+      url: `https://ikoncloud-dev.keross.com/ikon-api/upload?${queryParams.toString()}`,
+      data: formData,
+      responseType: "json",
+      headers: { "Content-Type": "multipart/form-data" },
+    });
+    console.log("File upload result:", result);
+  } catch (error) {
+    throw error;
+  }
+
+  return fileInfo;
+}
+
+export async function multipleFileUpload(
+  files: File[],
+  resourceId?: string
+): Promise<FileinfoProps[]> {
+  const fileInfos: FileinfoProps[] = [];
+  for (const file of files) {
+    const fileInfo = await singleFileUpload(file, resourceId);
+    fileInfos.push(fileInfo);
+  }
+  return fileInfos;
+}
+
+export async function base64FileUpload(
+  base64File: string,
+  resourceName: string,
+  resourceType: string,
+  resourceId?: string
+): Promise<FileinfoProps> {
+  const base64 = base64File.split(",")[1];
+  const byteCharacters = atob(base64);
+  const byteNumbers = new Array(byteCharacters.length);
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteNumbers[i] = byteCharacters.charCodeAt(i);
+  }
+  const byteArray = new Uint8Array(byteNumbers);
+  const blob = new Blob([byteArray], { type: resourceType });
+  const file = new File([blob], resourceName, { type: resourceType });
+  return await singleFileUpload(file, resourceId);
+}
+export async function singleUAResourceUpload(
+  file: File,
+  folder: string
+): Promise<any> {
+  const formData = new FormData();
+  formData.append("file", file);
+
+  const fileInfo = {} as any;
+  fileInfo["folder"] = folder || "ikon";
+  fileInfo["resourceName"] = file.name;
+  fileInfo["resourceSize"] = file.size;
+  fileInfo["resourceType"] = file.type;
+
+  const globalTicket = (await getTicket()) || "";
+  const queryParams = new URLSearchParams({
+    ticket: globalTicket,
+    folder: fileInfo["folder"],
+  });
+  try {
+    const result: AxiosResponse<unknown> = await axiosInstance({
+      method: "POST",
+      url: `https://ikoncloud-dev.keross.com/ikon-api//uaresourceupload?${queryParams.toString()}`,
+      data: formData,
+      responseType: "json",
+      headers: { "Content-Type": "multipart/form-data" },
+    });
+    console.log("File upload result:", result);
+  } catch (error) {
+    throw error;
+  }
+
+  return fileInfo;
+}

package/templates/default/utils/api/file-upload/type.ts

@@ -0,0 +1,8 @@
+export interface FileinfoProps {
+
+  resourceId: string;
+  resourceName?: string;
+  resourceSize?: number;
+  resourceType?: string;
+}
+