ikoncomponents 1.5.8 → 1.5.9

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

@@ -1,356 +0,0 @@
-import ikonBaseApi from "../ikonBaseApi";
-import {
-  CreateSoftwareProps,
-  EditSoftwareProps,
-  getAccessibleSoftwareForUserProps,
-  getAllSubscribedSoftwaresForClientProps,
-  getAvailableSoftwaresForAccountProps,
-  getMySoftwaresProps,
-  getMySoftwaresV2Props,
-  mapSoftwareNameProps,
-} from "./type";
-
-export const mapSoftwareName = async ({
-  softwareName,
-  version,
-}: mapSoftwareNameProps): Promise<string> => {
-  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,
-}: CreateSoftwareProps): Promise<string> => {
-  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,
-}: EditSoftwareProps): Promise<string> => {
-  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,
-}: getAccessibleSoftwareForUserProps) => {
-  const result = await ikonBaseApi({
-    service: "softwareService",
-    operation: "getAccessibleSoftwareForUser",
-    arguments_: [userId, accountId],
-  });
-  return result.data;
-};
-
-export const getAllSubscribedSoftwaresForClient = async (
-  { accountId }: getAllSubscribedSoftwaresForClientProps,
-  isServerApi?: boolean
-) => {
-  const result = await ikonBaseApi({
-    service: "softwareSubscriptionService",
-    operation: "getAllSubscribedSoftwaresForClient",
-    arguments_: [accountId],
-    isServerApi: isServerApi,
-  });
-  return result.data;
-};
-
-export const inviteAccountForSoftware = async ({
-  accountId,
-  softwareId,
-  expirationTime,
-}: {
-  accountId: string;
-  softwareId: string;
-  expirationTime?: number | string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "inviteAccountForSoftware",
-    arguments_: [accountId, softwareId, expirationTime],
-  });
-  return result.data;
-};
-
-export const getAllSentSoftwareInviteRequests = async ({
-  accountId,
-}: {
-  accountId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "getAllSentSoftwareInviteRequests",
-    arguments_: [accountId],
-  });
-  return result.data;
-};
-
-export const getAllReceivedSoftwareInviteRequests = async ({
-  accountId,
-}: {
-  accountId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "getAllReceivedSoftwareInviteRequests",
-    arguments_: [accountId],
-  });
-  return result.data;
-};
-
-export const getAllSoftwareInvitesV2 = async ({
-  accountId,
-}: {
-  accountId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "getAllSoftwareInvitesV2",
-    arguments_: [accountId],
-  });
-  return result.data;
-};
-
-export const acceptInvitationRequestForSoftware = async ({
-  requestId,
-  shareKey,
-}: {
-  requestId: string;
-  shareKey: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "acceptInvitationRequestForSoftware",
-    arguments_: [requestId, shareKey],
-  });
-  return result.data;
-};
-
-export const cancelInvitationRequestForSoftware = async ({
-  requestId,
-}: {
-  requestId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "cancelInvitationRequestForSoftware",
-    arguments_: [requestId],
-  });
-  return result.data;
-};
-
-export const rejectInvitationRequestForSoftware = async ({
-  requestId,
-}: {
-  requestId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "rejectInvitationRequestForSoftware",
-    arguments_: [requestId],
-  });
-  return result.data;
-};
-
-export const activateSoftwareInviteForAccount = async ({
-  invitationId,
-}: {
-  invitationId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "activateSoftwareInviteForAccount",
-    arguments_: [invitationId],
-  });
-  return result.data;
-};
-
-export const deactivateSoftwareInviteForAccount = async ({
-  invitationId,
-}: {
-  invitationId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "accountInvitationService",
-    operation: "deactivateSoftwareInviteForAccount",
-    arguments_: [invitationId],
-  });
-  return result.data;
-};
-
-export const getAllPendingInvitationRequestsForUser = async ({
-  userId,
-}: {
-  userId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "userInvitationService",
-    operation: "getAllPendingInvitationRequestsForUser",
-    arguments_: [userId],
-  });
-  return result.data;
-};
-
-export const getAllInvitationRequestsSentByAccount = async ({
-  accountId,
-}: {
-  accountId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "userInvitationService",
-    operation: "getAllInvitationRequestsSentByAccount",
-    arguments_: [accountId],
-  });
-  return result.data;
-};
-
-export const inviteUserToMyAccount = async ({
-  accountId,
-  userLogin,
-}: {
-  accountId: string;
-  userLogin: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "userInvitationService",
-    operation: "inviteUserToMyAccount",
-    arguments_: [accountId, userLogin],
-  });
-  return result.data;
-};
-
-export const getMySoftwares = async ({ accountId }: getMySoftwaresProps) => {
-  const result = await ikonBaseApi({
-    service: "softwareService",
-    operation: "getMySoftwares",
-    arguments_: [accountId],
-  });
-  return result.data;
-};
-
-export const getMySoftwaresV2 = async ({
-  accountId,
-  onlyActive = false,
-}: getMySoftwaresV2Props) => {
-  const result = await ikonBaseApi({
-    service: "softwareService",
-    operation: "getMySoftwaresV2",
-    arguments_: [accountId, onlyActive],
-  });
-  return result.data;
-};
-
-export const getAvailableSoftwaresForAccount = async ({
-  accountId,
-}: getAvailableSoftwaresForAccountProps) => {
-  const result = await ikonBaseApi({
-    service: "softwareService",
-    operation: "getAvailableSoftwaresForAccount",
-    arguments_: [accountId],
-  });
-  return result.data;
-};
-
-export const getSoftwareById = async ({
-  softwareId,
-}: {
-  softwareId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "softwareService",
-    operation: "getSoftwareById",
-    arguments_: [softwareId],
-  });
-  return result.data;
-};
-
-export const activateSoftware = async ({
-  softwareId,
-}: {
-  softwareId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "softwareService",
-    operation: "activateSoftware",
-    arguments_: [softwareId],
-  });
-  return result.data;
-};
-
-export const deactivateSoftware = async ({
-  softwareId,
-}: {
-  softwareId: string;
-}) => {
-  const result = await ikonBaseApi({
-    service: "softwareService",
-    operation: "deactivateSoftware",
-    arguments_: [softwareId],
-  });
-  return result.data;
-};
-
-export const requestForFinalSubscription = async ({
-  accountId,
-  userId,
-  softwareId,
-  suggestedDate = null,
-}: {
-  accountId: string;
-  userId: string;
-  softwareId: string;
-  suggestedDate?: string | null;
-}) => {
-  const result = await ikonBaseApi({
-    service: "requestService",
-    operation: "requestForFinalSubscription",
-    arguments_: [accountId, userId, softwareId, suggestedDate],
-  });
-  return result.data;
-};

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

@@ -1,62 +0,0 @@
-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"; // assuming only these two possible values
-  ACTIVE: boolean;
-  PURCHASE_DATE: string; // ISO date string
-  EXPIRES_ON: string | null; // ISO date string or null
-}

package/templates/default/utils/cn.ts

@@ -1,6 +0,0 @@
-import { type ClassValue, clsx } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-    return twMerge(clsx(inputs))
-}

package/templates/default/utils/session/cookieSession.ts

@@ -1,49 +0,0 @@
-"use server";
-import { cookies } from "next/headers";
-
-const cookiePrefix = "ikoncloud_next_";
-
-export interface CookieSessionOptionsProps {
-  maxAge?: number;
-  expires?: Date;
-}
-
-export async function setCookieSession(
-  sessionName: string,
-  data: string,
-  options?: CookieSessionOptionsProps
-) {
-  const cookieStore = await cookies();
-
-  cookieStore.set(cookiePrefix + sessionName, data, {
-    httpOnly: true,
-    sameSite: "lax",
-    secure: process.env.NODE_ENV === "production",
-    path: "/",
-    domain: process.env.NEXT_PUBLIC_COOKIE_DOMAIN,
-    expires: options?.expires,
-    maxAge: options?.maxAge,
-  });
-}
-
-export async function getCookieSession(
-  sessionName: string
-): Promise<string | undefined> {
-  const cookieStore = await cookies();
-  const cookie = cookieStore.get(cookiePrefix + sessionName)?.value;
-  return cookie;
-}
-
-export async function clearCookieSession(sessionName: string) {
-  const cookieStore = await cookies();
-  cookieStore.delete(cookiePrefix + sessionName);
-}
-
-export async function clearAllCookieSession() {
-  const cookieStore = await cookies();
-  cookieStore.getAll().forEach((cookie) => {
-    if (cookie.name.startsWith(cookiePrefix)) {
-      cookieStore.delete(cookie.name);
-    }
-  });
-}

package/templates/default/utils/theme-provider/index.tsx

@@ -1,11 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { ThemeProvider as NextThemesProvider } from "next-themes"
-
-export function ThemeProvider({
-    children,
-    ...props
-}: React.ComponentProps<typeof NextThemesProvider>) {
-    return <NextThemesProvider {...props}>{children}</NextThemesProvider>
-}

package/templates/default/utils/token-management/index.ts

@@ -1,115 +0,0 @@
-"use server";
-import { redirect } from "next/navigation";
-import {
-  clearAllCookieSession,
-  getCookieSession,
-  setCookieSession,
-} from "../session/cookieSession";
-import { TokenResponse } from "./types";
-import { jwtDecode } from "jwt-decode";
-
-interface AccessTokenOptionsProps {
-  isNotLogOutWhenExpire?: boolean;
-  platformUrl?: string;
-  isSetToken?: boolean;
-}
-
-// Prevent multiple refresh calls at once
-let refreshPromise: Promise<string | null> | null = null;
-
-export async function getValidAccessToken(
-  baseUrl: string,
-  options?: AccessTokenOptionsProps
-): Promise<string | null> {
-  const accessToken = await getCookieSession("accessToken");
-
-  console.log("Access Token....:");
-  const refreshToken = await getCookieSession("refreshToken");
-
-  console.log("Refresh Token...");
-
-  console.log(
-    "Before Return Access Token:..............................................."
-  );
-  if (accessToken) return accessToken;
-
-  console.log(
-    "After Return Access Token:..............................................."
-  );
-
-  if (refreshToken) {
-    console.log("Refreshing access token using refresh token...", refreshToken);
-    if (!refreshPromise) {
-      refreshPromise = refreshAccessToken(refreshToken, baseUrl, options?.isSetToken);
-      refreshPromise.finally(() => (refreshPromise = null));
-    }
-    return await refreshPromise;
-  }
-
-  if (!options?.isNotLogOutWhenExpire && options?.platformUrl) {
-    await logOut(options?.platformUrl);
-  }
-
-  return null;
-}
-
-export async function refreshAccessToken(
-  refreshToken: string,
-  baseUrl: string,
-  isSetToken?: boolean
-): Promise<string | null> {
-  try {
-    console.log("Refreshing access token...");
-
-    const response = await fetch(
-      `${baseUrl}/platform/auth/refresh-token`,
-      {
-        method: "POST",
-        credentials: "include",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ refreshToken }),
-      }
-    );
-
-    console.log("Refresh Token API Response:", response.status);
-
-    if (!response.ok) return null;
-
-    const {
-      accessToken,
-      refreshToken: newRefreshToken,
-      expiresIn,
-      refreshExpiresIn,
-    }: TokenResponse = await response.json();
-
-    //  Always set new access token
-    await setCookieSession("accessToken", accessToken, {
-      maxAge: expiresIn,
-    });
-
-    //  IMPORTANT: Save the rotated refresh token
-    if (newRefreshToken) {
-      await setCookieSession("refreshToken", newRefreshToken, {
-        maxAge: refreshExpiresIn,
-      });
-      console.log("Refresh token rotated & updated.");
-    }
-
-    console.log(" Access token refreshed successfully.");
-    return accessToken;
-  } catch (error) {
-    console.error("Failed to refresh access token:", error);
-    return null;
-  }
-}
-
-export async function decodeAccessToken(baseUrl: string,) {
-  const accessToken = await getValidAccessToken(baseUrl);
-  return accessToken ? jwtDecode(accessToken) : null;
-}
-
-export async function logOut(platformUrl: string,) {
-  await clearAllCookieSession();
-  console.log("Logging out...");
-  redirect(`${platformUrl}/login.html`)
-}

package/templates/default/utils/token-management/types.ts

@@ -1,6 +0,0 @@
-export interface TokenResponse {
-  accessToken: string;
-  refreshToken: string; // Usually, refresh endpoints return a new refresh token too
-  expiresIn: number; // Access token expiry in seconds
-  refreshExpiresIn: number; // Refresh token expiry in seconds
-}