ikoncomponents 1.2.0 → 1.2.2

package/dist/utils/api/ikonBaseApi.js

@@ -0,0 +1,104 @@
+"use server";
+import axios from 'axios';
+import { redirect } from 'next/navigation';
+import { getActiveAccountId } from '../actions/account';
+import { getBaseSoftwareId, getCurrentSoftwareId } from '../actions/software';
+import { getTicket } from '../actions/auth';
+// Create an Axios instance
+export const axiosInstance = axios.create({
+    baseURL: "https://ikoncloud-dev.keross.com/ikon-api"
+});
+async function ikonBaseApi({ service, operation, arguments_, accountId, softwareId, isTicketRequried = true, isServerApi = false }) {
+    var _a;
+    //console.log("ikonBaseApi called with params: ", { service, operation, arguments_, accountId, softwareId, isTicketRequried });
+    const queryParams = new URLSearchParams({
+        inZip: String(false),
+        outZip: String(true),
+        inFormat: "freejson",
+        outFormat: "freejson",
+        service: service,
+        operation: operation,
+    });
+    if (isTicketRequried) {
+        const globalTicket = await getTicket();
+        if (globalTicket) {
+            queryParams.append('ticket', globalTicket);
+            if (accountId) {
+                queryParams.append('activeAccountId', accountId);
+            }
+            else {
+                const activeAccountId = await getActiveAccountId();
+                if (activeAccountId) {
+                    queryParams.append('activeAccountId', activeAccountId);
+                }
+            }
+            if (softwareId) {
+                queryParams.append('softwareId', softwareId);
+            }
+            else {
+                const currentSoftwareId = await getCurrentSoftwareId();
+                if (currentSoftwareId) {
+                    queryParams.append('softwareId', currentSoftwareId);
+                }
+                else {
+                    const baseSoftwareId = await getBaseSoftwareId();
+                    if (baseSoftwareId) {
+                        queryParams.append('softwareId', baseSoftwareId);
+                    }
+                }
+            }
+        }
+    }
+    const contentType = 'application/x-www-form-urlencoded; charset=UTF-8;';
+    const requestData = JSON.stringify(arguments_);
+    try {
+        const result = await axiosInstance({
+            method: 'POST',
+            url: `https://ikoncloud-dev.keross.com/ikon-api?${queryParams.toString()}`,
+            headers: { 'Content-Type': contentType },
+            data: { arguments: requestData },
+            responseType: 'json'
+        });
+        return { data: result.data, status: result.status };
+    }
+    catch (axiosError) {
+        const error = axiosError;
+        const { status, response } = error;
+        console.error(status);
+        // console.error(axiosError)
+        // if (status === 401) {
+        //     redirect("/login")
+        // }
+        // throw Error(error.message)
+        const ikonErrorCode = (_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a["ikon-error-code"];
+        console.error(ikonErrorCode);
+        if (ikonErrorCode == "AUTHENTICATIONEXCEPTION") {
+            const message = "You are re-directed to Login Page. Possible reasons are:\n\t1) Your session has been idle for more than allowed timeout value.\n\t2) This is an unauthenticated access.";
+            if (isServerApi) {
+                throw new Error("AUTHENTICATIONEXCEPTION");
+            }
+            else {
+                redirect("/login");
+            }
+        }
+        else {
+            if (ikonErrorCode == "TASKNOTEXISTSEXCEPTION") {
+                console.error(error.message, "Task does not exist!");
+            }
+            if (ikonErrorCode == "AUTHORIZATIONEXCEPTION") {
+                console.error(error.message, "Authorization Error!");
+            }
+            if (ikonErrorCode == "INTERNALIKONEXCEPTION") {
+                console.error("Internal IKON Error - " + error.message, "IKON Error!");
+            }
+            if (ikonErrorCode == "DATAEXCEPTION") {
+                console.error(response, error.message);
+            }
+            if (ikonErrorCode == "UNCAUGHTEXCEPTION") {
+                console.error("Internal IKON Error - " + error.message, "IKON Error!");
+            }
+            throw new Error(error.message);
+        }
+    }
+}
+export default ikonBaseApi;

package/dist/utils/api/loginService/index.d.ts

@@ -0,0 +1,12 @@
+import { ForgotPasswordProps, GetLoggedInUserProfileDetailsReturnProps, GetLoggedInUserProfileReturnProps, LoginProps, UpdateUserProfileProps, ValidateOTPProps } from "./type";
+export declare const login: ({ userName, password }: LoginProps) => Promise<any>;
+export declare const resetPassword: ({ userName }: ForgotPasswordProps) => Promise<any>;
+export declare const generateOTP: ({ temporaryTicket, otpMedium, }: {
+    temporaryTicket: string;
+    otpMedium?: string;
+}) => Promise<any>;
+export declare const validateOTP: ({ temporaryTicket, otp, }: ValidateOTPProps) => Promise<any>;
+export declare const logout: () => Promise<any>;
+export declare const getLoggedInUserProfile: (isServerApi?: boolean) => Promise<GetLoggedInUserProfileReturnProps>;
+export declare const getLoggedInUserProfileDetails: (isServerApi?: boolean) => Promise<GetLoggedInUserProfileDetailsReturnProps>;
+export declare const updateUserProfile: ({ userName, userPassword, userPhone, userEmail, userThumbnail, }: UpdateUserProfileProps) => Promise<any>;

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

@@ -0,0 +1,72 @@
+"use server";
+import sha512 from "crypto-js/sha512";
+import ikonBaseApi from "../../api/ikonBaseApi";
+import { revalidateTag } from "next/cache";
+export const login = async ({ userName, password }) => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "login",
+        arguments_: [userName, sha512(password).toString()],
+        isTicketRequried: false,
+    });
+    return result.data;
+};
+export const resetPassword = async ({ userName }) => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "resetPassword",
+        arguments_: [userName],
+        isTicketRequried: false,
+    });
+    return result.data;
+};
+export const generateOTP = async ({ temporaryTicket, otpMedium = "EMAIL", }) => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "generateOTP",
+        arguments_: [temporaryTicket, otpMedium],
+        isTicketRequried: false,
+    });
+    return result.data;
+};
+export const validateOTP = async ({ temporaryTicket, otp, }) => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "validateOTP",
+        arguments_: [temporaryTicket, otp],
+        isTicketRequried: false,
+    });
+    return result.data;
+};
+export const logout = async () => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "logout",
+    });
+    return result.data;
+};
+export const getLoggedInUserProfile = async (isServerApi) => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "getLoggedInUserProfile",
+        isServerApi,
+    });
+    return result.data;
+};
+export const getLoggedInUserProfileDetails = async (isServerApi) => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "getLoggedInUserProfileDetails",
+        isServerApi,
+    });
+    return result.data;
+};
+export const updateUserProfile = async ({ userName, userPassword, userPhone, userEmail, userThumbnail, }) => {
+    const result = await ikonBaseApi({
+        service: "loginService",
+        operation: "updateUserProfile",
+        arguments_: [userName, userPassword, userPhone, userEmail, userThumbnail],
+    });
+    revalidateTag("profile");
+    return result.data;
+};

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

@@ -0,0 +1,31 @@
+export interface LoginProps {
+    userName: string;
+    password: string;
+}
+export interface ForgotPasswordProps {
+    userName: string;
+}
+export interface ValidateOTPProps {
+    temporaryTicket: string;
+    otp: string;
+}
+export interface GetLoggedInUserProfileReturnProps {
+    USER_NAME: string;
+    USER_LOGIN: string;
+    USER_ID: string;
+    CNT: number;
+    USER_THUMBNAIL?: string | null;
+}
+export interface GetLoggedInUserProfileDetailsReturnProps {
+    USER_NAME: string;
+    USER_EMAIL: string;
+    USER_PHONE: string;
+    USER_THUMBNAIL?: string | null;
+}
+export interface UpdateUserProfileProps {
+    userName: string;
+    userPassword: string;
+    userPhone: string;
+    userEmail: string;
+    userThumbnail?: string | null;
+}

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

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

package/dist/utils/api/softwareService/index.d.ts

@@ -0,0 +1,64 @@
+import { CreateSoftwareProps, EditSoftwareProps, getAccessibleSoftwareForUserProps, getAllSubscribedSoftwaresForClientProps, getAvailableSoftwaresForAccountProps, getMySoftwaresProps, getMySoftwaresV2Props, mapSoftwareNameProps } from "./type";
+export declare const mapSoftwareName: ({ softwareName, version, }: mapSoftwareNameProps) => Promise<string>;
+export declare const createSoftware: ({ softwareName, softwareDescription, softwareVersion, softwareOwnerAccount, softwareDeveloperAccount, softwareManagerAccount, softwareAccessibility, softwareStatus, }: CreateSoftwareProps) => Promise<string>;
+export declare const editSoftware: ({ softwareId, softwareName, softwareDescription, softwareVersion, softwareDeveloperAccount, softwareManagerAccount, softwareAccessibility, softwareStatus, }: EditSoftwareProps) => Promise<string>;
+export declare const getAccessibleSoftwareForUser: ({ accountId, userId, }: getAccessibleSoftwareForUserProps) => Promise<any>;
+export declare const getAllSubscribedSoftwaresForClient: ({ accountId }: getAllSubscribedSoftwaresForClientProps, isServerApi?: boolean) => Promise<any>;
+export declare const inviteAccountForSoftware: ({ accountId, softwareId, expirationTime, }: {
+    accountId: string;
+    softwareId: string;
+    expirationTime?: number | string;
+}) => Promise<any>;
+export declare const getAllSentSoftwareInviteRequests: ({ accountId, }: {
+    accountId: string;
+}) => Promise<any>;
+export declare const getAllReceivedSoftwareInviteRequests: ({ accountId, }: {
+    accountId: string;
+}) => Promise<any>;
+export declare const getAllSoftwareInvitesV2: ({ accountId, }: {
+    accountId: string;
+}) => Promise<any>;
+export declare const acceptInvitationRequestForSoftware: ({ requestId, shareKey, }: {
+    requestId: string;
+    shareKey: string;
+}) => Promise<any>;
+export declare const cancelInvitationRequestForSoftware: ({ requestId, }: {
+    requestId: string;
+}) => Promise<any>;
+export declare const rejectInvitationRequestForSoftware: ({ requestId, }: {
+    requestId: string;
+}) => Promise<any>;
+export declare const activateSoftwareInviteForAccount: ({ invitationId, }: {
+    invitationId: string;
+}) => Promise<any>;
+export declare const deactivateSoftwareInviteForAccount: ({ invitationId, }: {
+    invitationId: string;
+}) => Promise<any>;
+export declare const getAllPendingInvitationRequestsForUser: ({ userId, }: {
+    userId: string;
+}) => Promise<any>;
+export declare const getAllInvitationRequestsSentByAccount: ({ accountId, }: {
+    accountId: string;
+}) => Promise<any>;
+export declare const inviteUserToMyAccount: ({ accountId, userLogin, }: {
+    accountId: string;
+    userLogin: string;
+}) => Promise<any>;
+export declare const getMySoftwares: ({ accountId }: getMySoftwaresProps) => Promise<any>;
+export declare const getMySoftwaresV2: ({ accountId, onlyActive, }: getMySoftwaresV2Props) => Promise<any>;
+export declare const getAvailableSoftwaresForAccount: ({ accountId, }: getAvailableSoftwaresForAccountProps) => Promise<any>;
+export declare const getSoftwareById: ({ softwareId, }: {
+    softwareId: string;
+}) => Promise<any>;
+export declare const activateSoftware: ({ softwareId, }: {
+    softwareId: string;
+}) => Promise<any>;
+export declare const deactivateSoftware: ({ softwareId, }: {
+    softwareId: string;
+}) => Promise<any>;
+export declare const requestForFinalSubscription: ({ accountId, userId, softwareId, suggestedDate, }: {
+    accountId: string;
+    userId: string;
+    softwareId: string;
+    suggestedDate?: string | null;
+}) => Promise<any>;

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

@@ -0,0 +1,212 @@
+import ikonBaseApi from "../ikonBaseApi";
+export const mapSoftwareName = async ({ softwareName, version, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "mapSoftwareName",
+        arguments_: [softwareName, version],
+    });
+    return result.data;
+};
+export const createSoftware = async ({ softwareName, softwareDescription, softwareVersion, softwareOwnerAccount, softwareDeveloperAccount, softwareManagerAccount, softwareAccessibility, softwareStatus, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "createSoftware",
+        arguments_: [
+            softwareName,
+            softwareDescription,
+            softwareVersion,
+            softwareOwnerAccount,
+            softwareDeveloperAccount,
+            softwareManagerAccount,
+            softwareAccessibility,
+            softwareStatus,
+        ],
+    });
+    return result.data;
+};
+export const editSoftware = async ({ softwareId, softwareName, softwareDescription, softwareVersion, softwareDeveloperAccount, softwareManagerAccount, softwareAccessibility, softwareStatus, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "editSoftware",
+        arguments_: [
+            softwareId,
+            softwareName,
+            softwareDescription,
+            softwareVersion,
+            softwareDeveloperAccount,
+            softwareManagerAccount,
+            softwareAccessibility,
+            softwareStatus,
+        ],
+    });
+    return result.data;
+};
+export const getAccessibleSoftwareForUser = async ({ accountId, userId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getAccessibleSoftwareForUser",
+        arguments_: [userId, accountId],
+    });
+    return result.data;
+};
+export const getAllSubscribedSoftwaresForClient = async ({ accountId }, isServerApi) => {
+    const result = await ikonBaseApi({
+        service: "softwareSubscriptionService",
+        operation: "getAllSubscribedSoftwaresForClient",
+        arguments_: [accountId],
+        isServerApi: isServerApi,
+    });
+    return result.data;
+};
+export const inviteAccountForSoftware = async ({ accountId, softwareId, expirationTime, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "inviteAccountForSoftware",
+        arguments_: [accountId, softwareId, expirationTime],
+    });
+    return result.data;
+};
+export const getAllSentSoftwareInviteRequests = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "getAllSentSoftwareInviteRequests",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getAllReceivedSoftwareInviteRequests = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "getAllReceivedSoftwareInviteRequests",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getAllSoftwareInvitesV2 = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "getAllSoftwareInvitesV2",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const acceptInvitationRequestForSoftware = async ({ requestId, shareKey, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "acceptInvitationRequestForSoftware",
+        arguments_: [requestId, shareKey],
+    });
+    return result.data;
+};
+export const cancelInvitationRequestForSoftware = async ({ requestId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "cancelInvitationRequestForSoftware",
+        arguments_: [requestId],
+    });
+    return result.data;
+};
+export const rejectInvitationRequestForSoftware = async ({ requestId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "rejectInvitationRequestForSoftware",
+        arguments_: [requestId],
+    });
+    return result.data;
+};
+export const activateSoftwareInviteForAccount = async ({ invitationId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "activateSoftwareInviteForAccount",
+        arguments_: [invitationId],
+    });
+    return result.data;
+};
+export const deactivateSoftwareInviteForAccount = async ({ invitationId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "deactivateSoftwareInviteForAccount",
+        arguments_: [invitationId],
+    });
+    return result.data;
+};
+export const getAllPendingInvitationRequestsForUser = async ({ userId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "getAllPendingInvitationRequestsForUser",
+        arguments_: [userId],
+    });
+    return result.data;
+};
+export const getAllInvitationRequestsSentByAccount = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "getAllInvitationRequestsSentByAccount",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const inviteUserToMyAccount = async ({ accountId, userLogin, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "inviteUserToMyAccount",
+        arguments_: [accountId, userLogin],
+    });
+    return result.data;
+};
+export const getMySoftwares = async ({ accountId }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getMySoftwares",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getMySoftwaresV2 = async ({ accountId, onlyActive = false, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getMySoftwaresV2",
+        arguments_: [accountId, onlyActive],
+    });
+    return result.data;
+};
+export const getAvailableSoftwaresForAccount = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getAvailableSoftwaresForAccount",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getSoftwareById = async ({ softwareId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getSoftwareById",
+        arguments_: [softwareId],
+    });
+    return result.data;
+};
+export const activateSoftware = async ({ softwareId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "activateSoftware",
+        arguments_: [softwareId],
+    });
+    return result.data;
+};
+export const deactivateSoftware = async ({ softwareId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "deactivateSoftware",
+        arguments_: [softwareId],
+    });
+    return result.data;
+};
+export const requestForFinalSubscription = async ({ accountId, userId, softwareId, suggestedDate = null, }) => {
+    const result = await ikonBaseApi({
+        service: "requestService",
+        operation: "requestForFinalSubscription",
+        arguments_: [accountId, userId, softwareId, suggestedDate],
+    });
+    return result.data;
+};

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

@@ -0,0 +1,54 @@
+export interface mapSoftwareNameProps {
+    softwareName: string;
+    version: string;
+}
+export interface CreateSoftwareProps {
+    softwareName: string;
+    softwareDescription: string;
+    softwareVersion: number;
+    softwareOwnerAccount: string;
+    softwareDeveloperAccount: string;
+    softwareManagerAccount: string | null;
+    softwareAccessibility: string;
+    softwareStatus: string;
+}
+export interface EditSoftwareProps {
+    softwareId: string;
+    softwareName: string;
+    softwareDescription: string;
+    softwareVersion: number;
+    softwareDeveloperAccount: string;
+    softwareManagerAccount: string | null;
+    softwareAccessibility: string;
+    softwareStatus: string;
+}
+export interface getAllSubscribedSoftwaresForClientProps {
+    accountId?: string;
+}
+export interface getAccessibleSoftwareForUserProps {
+    accountId?: string;
+    userId: string;
+}
+export interface getMySoftwaresProps {
+    accountId?: string;
+}
+export interface getMySoftwaresV2Props {
+    accountId?: string;
+    onlyActive?: boolean;
+}
+export interface getAvailableSoftwaresForAccountProps {
+    accountId?: string;
+}
+export interface SubscribeSoftwareProps {
+    ACCOUNT_ID: string;
+    SOFTWARE_ID: string;
+    SOFTWARE_NAME: string;
+    SOFTWARE_VERSION: number;
+    SOFTWARE_DESCRIPTION: string;
+    SOFTWARE_OWNER_ID: string;
+    SOFTWARE_OWNER_NAME: string;
+    SOFTWARE_ACCESSIBILITY: "PUBLIC" | "PRIVATE";
+    ACTIVE: boolean;
+    PURCHASE_DATE: string;
+    EXPIRES_ON: string | null;
+}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ikoncomponents",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "css": "dist/styles.css",
@@ -46,17 +46,19 @@
     "cmdk": "^1.1.1",
     "countries-list": "^3.1.1",
     "country-flag-icons": "^1.5.21",
+    "crypto-js": "^4.2.0",
     "date-fns": "^4.1.0",
     "echarts": "^6.0.0",
     "eslint": "^9",
     "framer-motion": "^12.23.22",
     "input-otp": "^1.4.2",
-    "lucide-react": "^0.545.0",
+    "lucide-react": "^0.552.0",
     "motion": "^12.23.22",
     "next": "16.0.0",
     "next-themes": "^0.4.6",
     "react": "^18.2.0",
     "react-big-calendar": "^1.19.4",
+    "react-cropper": "^2.3.3",
     "react-day-picker": "^9.9.0",
     "react-dom": "^18.2.0",
     "react-hook-form": "^7.64.0",
@@ -64,11 +66,13 @@
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.3.1",
     "tailwindcss-animate": "^1.0.7",
+    "uuid": "^13.0.0",
     "vaul": "^1.1.2",
     "zxcvbn": "^4.4.2"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
+    "@types/crypto-js": "^4.2.2",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-big-calendar": "^1.16.3",