ikoncomponents 1.5.8 → 1.5.10

package/dist/utils/actions/account/index.d.ts

@@ -0,0 +1,5 @@
+import { AccountTreeProps } from "./type";
+export declare const getAccount: () => Promise<AccountTreeProps>;
+export declare const getActiveAccountId: () => Promise<string>;
+export declare const getOrSetActiveAccountId: () => Promise<string>;
+export declare const setActiveAccountId: (accountId: string) => Promise<void>;

package/dist/utils/actions/account/index.js

@@ -0,0 +1,28 @@
+"use server";
+import { cache } from "react";
+import { getAccountTree } from "../../api/accountService";
+import { getCookieSession, setCookieSession } from "../../session/cookieSession";
+export const getAccount = cache(async () => {
+    return await getAccountTree();
+});
+export const getActiveAccountId = async () => {
+    const activeAccountId = await getCookieSession("activeAccountId");
+    return activeAccountId || "";
+};
+export const getOrSetActiveAccountId = async () => {
+    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) => {
+    await setCookieSession("activeAccountId", accountId);
+};

package/dist/utils/actions/account/type.d.ts

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

package/dist/utils/actions/account/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/actions/auth/index.d.ts

@@ -0,0 +1,7 @@
+import { GetLoggedInUserProfileDetailsReturnProps, GetLoggedInUserProfileReturnProps } from "../../api/loginService/type";
+export declare const setTicket: (ticket: string) => Promise<void>;
+export declare const getTicket: () => Promise<string | undefined>;
+export declare const getProfileData: () => Promise<GetLoggedInUserProfileReturnProps & GetLoggedInUserProfileDetailsReturnProps>;
+export declare function signOut(): Promise<void>;
+export declare const getCurrentUserId: () => Promise<string>;
+export declare const setCurrentUserId: (userId: string) => Promise<void>;

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

@@ -1,69 +1,58 @@
-"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)
-};
+"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);
+};

package/dist/utils/actions/common/utils.d.ts

@@ -0,0 +1,5 @@
+import { FileinfoProps } from "../../api/file-upload/type";
+export declare function getSrcFromBase64String(imgString?: string | null, type?: string): string;
+export declare function getResourceUrl(fileInfo: FileinfoProps): Promise<string>;
+export declare function downloadResource(fileInfo: FileinfoProps): Promise<void>;
+export declare function openFileInNewTab(url: string): Promise<void>;

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

@@ -1,28 +1,25 @@
-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);
-    }
-};
+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);
+    }
+}
+;

package/dist/utils/actions/software/index.d.ts

@@ -0,0 +1,11 @@
+import { SubscribeSoftwareProps } from "../../api/softwareService/type";
+export declare const getBaseSoftwareId: () => Promise<string | undefined>;
+export declare const getOrSetBaseSoftwareId: () => Promise<string | undefined>;
+export declare const setBaseSoftwareId: (softwareId: string) => Promise<void>;
+export declare const getCurrentSoftwareId: () => Promise<string>;
+export declare const getCurrentAppName: () => Promise<string>;
+export declare const setCurrentSoftwareId: (softwareId: string) => Promise<void>;
+export declare const getSoftwareIdByNameVersion: (softwareName: string, version: string) => Promise<string>;
+export declare const setCurrentSoftwareIdByNameVersion: (softwareName: string, version: string) => Promise<void>;
+export declare const getAccessibleSoftware: (accountId: string, userId: string) => Promise<any>;
+export declare const getAllSubscribedSoftwares: (accountId?: string) => Promise<SubscribeSoftwareProps[]>;

package/dist/utils/actions/software/index.js

@@ -0,0 +1,75 @@
+"use server";
+import { cache } from "react";
+import { getAccessibleSoftwareForUser, mapSoftwareName, } from "../../api/softwareService";
+import { getCookieSession, setCookieSession, } from "../../session/cookieSession";
+import { cookies } from "next/headers";
+export const getBaseSoftwareId = async () => {
+    return await getCookieSession("baseSoftwareId");
+};
+export const getOrSetBaseSoftwareId = async () => {
+    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) => {
+    await setCookieSession("baseSoftwareId", softwareId);
+};
+export const getCurrentSoftwareId = async () => {
+    return (await getCookieSession("currentSoftwareId")) || "";
+};
+export const getCurrentAppName = async () => {
+    return (await getCookieSession("currentAppName")) || "";
+};
+export const setCurrentSoftwareId = async (softwareId) => {
+    await setCookieSession("currentSoftwareId", softwareId);
+};
+export const getSoftwareIdByNameVersion = cache(async (softwareName, version) => {
+    return await mapSoftwareName({ softwareName, version });
+});
+export const setCurrentSoftwareIdByNameVersion = async (softwareName, version) => {
+    const softwareId = await getSoftwareIdByNameVersion(softwareName, version);
+    await setCurrentSoftwareId(softwareId);
+};
+export const getAccessibleSoftware = cache(async (accountId, userId) => {
+    return await getAccessibleSoftwareForUser({ accountId, userId });
+});
+// export const getAllSubscribedSoftwares = cache(async (accountId: string) => {
+//     return await getAllSubscribedSoftwaresForClient({ accountId });
+// });
+export const getAllSubscribedSoftwares = async (accountId) => {
+    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/dist/utils/api/accountService/index.d.ts

@@ -0,0 +1,23 @@
+import { GetAccountTreeProps } from "./type";
+export declare const getAccountTree: () => Promise<GetAccountTreeProps>;
+export declare const checkExistingAccount: ({ accountName, }: {
+    accountName: string;
+}) => Promise<boolean>;
+export declare const getFullAccountTree: () => Promise<any>;
+export declare const getAllInvitedAccountsForUser: (userId: string) => Promise<any>;
+export declare const acceptAccountInvitationRequest: ({ userId, requestId, }: {
+    userId: string;
+    requestId: string;
+}) => Promise<any>;
+export declare const rejectAccountInvitationRequest: ({ userId, requestId, }: {
+    userId: string;
+    requestId: string;
+}) => Promise<any>;
+export declare const cancelAccountInvitationRequest: ({ userId, requestId, }: {
+    userId: string;
+    requestId: string;
+}) => Promise<any>;
+export declare const deactivateInvitedUserFromAccount: ({ userId, invitationId, }: {
+    userId: string;
+    invitationId: string;
+}) => Promise<any>;

package/dist/utils/api/accountService/index.js

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

package/dist/utils/api/accountService/type.d.ts

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

package/dist/utils/api/accountService/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/api/file-upload/index.d.ts

@@ -0,0 +1,5 @@
+import { FileinfoProps } from "./type";
+export declare function singleFileUpload(file: File, resourceId?: string): Promise<FileinfoProps>;
+export declare function multipleFileUpload(files: File[], resourceId?: string): Promise<FileinfoProps[]>;
+export declare function base64FileUpload(base64File: string, resourceName: string, resourceType: string, resourceId?: string): Promise<FileinfoProps>;
+export declare function singleUAResourceUpload(file: File, folder: string): Promise<any>;

package/dist/utils/api/file-upload/index.js

@@ -0,0 +1,80 @@
+"use server";
+import { axiosInstance } from "../ikonBaseApi";
+import { v4 } from "uuid";
+import { getTicket } from "../../actions/auth";
+export async function singleFileUpload(file, resourceId) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const fileInfo = {};
+    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 = 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, resourceId) {
+    const fileInfos = [];
+    for (const file of files) {
+        const fileInfo = await singleFileUpload(file, resourceId);
+        fileInfos.push(fileInfo);
+    }
+    return fileInfos;
+}
+export async function base64FileUpload(base64File, resourceName, resourceType, resourceId) {
+    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, folder) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const fileInfo = {};
+    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 = 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/dist/utils/api/file-upload/type.d.ts

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

package/dist/utils/api/file-upload/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/api/ikonBaseApi.d.ts

@@ -0,0 +1,12 @@
+interface IkonBaseApiProps {
+    service: string;
+    operation: string;
+    arguments_?: any | null;
+    accountId?: string | null;
+    softwareId?: string | null;
+    isTicketRequried?: boolean;
+    isServerApi?: boolean;
+}
+export declare const axiosInstance: import("axios").AxiosInstance;
+declare function ikonBaseApi({ service, operation, arguments_, accountId, softwareId, isTicketRequried, isServerApi }: IkonBaseApiProps): Promise<any>;
+export default ikonBaseApi;