ikoncomponents 1.4.7 → 1.4.9

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

@@ -0,0 +1,356 @@
+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

@@ -0,0 +1,62 @@
+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/{dist/utils/border-radius-provider.js → templates/default/utils/border-radius-provider.tsx}

@@ -1,35 +1,59 @@
-'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState, useEffect, useMemo } from 'react';
-const RadiusContext = createContext(undefined);
-export function RadiusProvider({ children }) {
-    const [radius, setRadius] = useState(0.5);
-    const [mounted, setMounted] = useState(false);
-    useEffect(() => {
-        setMounted(true);
-        const storedRadius = localStorage.getItem('app-radius');
-        if (storedRadius) {
-            const parsed = parseFloat(storedRadius);
-            if ([0, 0.25, 0.5, 0.75, 1].includes(parsed)) {
-                setRadius(parsed);
-            }
-        }
-    }, []);
-    useEffect(() => {
-        if (!mounted)
-            return;
-        const radiusInRem = radius === 0 ? '0rem' : `${radius}rem`;
-        document.documentElement.style.setProperty('--radius', radiusInRem);
-        localStorage.setItem('app-radius', radius.toString());
-        console.log('Radius changed to:', radius, radiusInRem);
-    }, [radius, mounted]);
-    const value = useMemo(() => ({ radius, setRadius }), [radius]);
-    return (_jsx(RadiusContext.Provider, { value: value, children: children }));
-}
-export const useRadius = () => {
-    const context = useContext(RadiusContext);
-    if (context === undefined) {
-        throw new Error('useRadius must be used within a RadiusProvider');
-    }
-    return context;
-};
+'use client';
+
+import React, {
+    createContext,
+    useContext,
+    useState,
+    useEffect,
+    useMemo
+} from 'react';
+
+type RadiusValue = 0 | 0.25 | 0.5 | 0.75 | 1;
+
+interface RadiusContextType {
+    radius: RadiusValue;
+    setRadius: (radius: RadiusValue) => void;
+}
+
+const RadiusContext = createContext<RadiusContextType | undefined>(undefined);
+
+export function RadiusProvider({ children }: { children: React.ReactNode }) {
+    const [radius, setRadius] = useState<RadiusValue>(0.5);
+    const [mounted, setMounted] = useState(false);
+
+    useEffect(() => {
+        setMounted(true);
+        const storedRadius = localStorage.getItem('app-radius');
+        if (storedRadius) {
+            const parsed = parseFloat(storedRadius) as RadiusValue;
+            if ([0, 0.25, 0.5, 0.75, 1].includes(parsed)) {
+                setRadius(parsed);
+            }
+        }
+    }, []);
+
+    useEffect(() => {
+        if (!mounted) return;
+
+        const radiusInRem = radius === 0 ? '0rem' : `${radius}rem`;
+        document.documentElement.style.setProperty('--radius', radiusInRem);
+        localStorage.setItem('app-radius', radius.toString());
+        console.log('Radius changed to:', radius, radiusInRem);
+    }, [radius, mounted]);
+
+    const value = useMemo(() => ({ radius, setRadius }), [radius]);
+
+    return (
+        <RadiusContext.Provider value={value}>
+            {children}
+        </RadiusContext.Provider>
+    );
+}
+
+export const useRadius = () => {
+    const context = useContext(RadiusContext);
+    if (context === undefined) {
+        throw new Error('useRadius must be used within a RadiusProvider');
+    }
+    return context;
+};

package/templates/default/utils/cn.ts

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

package/{dist/utils/font-provider.js → templates/default/utils/font-provider.tsx}

@@ -1,37 +1,61 @@
-'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState, useEffect, useMemo } from 'react';
-const FontContext = createContext(undefined);
-export function FontProvider({ children }) {
-    const [font, setFont] = useState('Poppins');
-    const [mounted, setMounted] = useState(false);
-    useEffect(() => {
-        setMounted(true);
-        const storedFont = localStorage.getItem('app-font');
-        if (storedFont && ['Poppins', 'Oswald', 'Outfit'].includes(storedFont)) {
-            setFont(storedFont);
-        }
-    }, []);
-    useEffect(() => {
-        if (!mounted)
-            return;
-        const fontVariables = {
-            Poppins: 'var(--font-poppins)',
-            Oswald: 'var(--font-oswald)',
-            Outfit: 'var(--font-outfit)',
-        };
-        document.body.style.fontFamily = fontVariables[font];
-        document.documentElement.style.fontFamily = fontVariables[font];
-        localStorage.setItem('app-font', font);
-        console.log('Font changed to:', font, fontVariables[font]);
-    }, [font, mounted]);
-    const value = useMemo(() => ({ font, setFont }), [font]);
-    return (_jsx(FontContext.Provider, { value: value, children: children }));
-}
-export const useFont = () => {
-    const context = useContext(FontContext);
-    if (context === undefined) {
-        throw new Error('useFont must be used within a FontProvider');
-    }
-    return context;
-};
+'use client';
+
+import React, {
+    createContext,
+    useContext,
+    useState,
+    useEffect,
+    useMemo
+} from 'react';
+
+type FontName = 'Poppins' | 'Oswald' | 'Outfit';
+
+interface FontContextType {
+    font: FontName;
+    setFont: (font: FontName) => void;
+}
+
+const FontContext = createContext<FontContextType | undefined>(undefined);
+
+export function FontProvider({ children }: { children: React.ReactNode }) {
+    const [font, setFont] = useState<FontName>('Poppins');
+    const [mounted, setMounted] = useState(false);
+
+    useEffect(() => {
+        setMounted(true);
+        const storedFont = localStorage.getItem('app-font') as FontName;
+        if (storedFont && ['Poppins', 'Oswald', 'Outfit'].includes(storedFont)) {
+            setFont(storedFont);
+        }
+    }, []);
+
+    useEffect(() => {
+        if (!mounted) return;
+
+        const fontVariables: Record<FontName, string> = {
+            Poppins: 'var(--font-poppins)',
+            Oswald: 'var(--font-oswald)',
+            Outfit: 'var(--font-outfit)',
+        };
+        document.body.style.fontFamily = fontVariables[font];
+        document.documentElement.style.fontFamily = fontVariables[font];
+        localStorage.setItem('app-font', font);
+        console.log('Font changed to:', font, fontVariables[font]);
+    }, [font, mounted]);
+
+    const value = useMemo(() => ({ font, setFont }), [font]);
+
+    return (
+        <FontContext.Provider value={value}>
+            {children}
+        </FontContext.Provider>
+    );
+}
+
+export const useFont = () => {
+    const context = useContext(FontContext);
+    if (context === undefined) {
+        throw new Error('useFont must be used within a FontProvider');
+    }
+    return context;
+};

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

@@ -0,0 +1,49 @@
+"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

@@ -0,0 +1,11 @@
+"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>
+}