@solidstarters/solid-core-ui 1.1.69 → 1.1.71

package/dist/nextAuth/authProviders.tsx

@@ -0,0 +1,221 @@
+import CredentialsProvider from "next-auth/providers/credentials";
+import GoogleProvider from "next-auth/providers/google";
+import { NextRequest } from "next/server";
+import { jwtDecode } from "jwt-decode";
+import { JWT } from "next-auth/jwt";
+import axios from "axios";
+import { signOut } from "next-auth/react";
+import { refreshAccessToken } from "./refreshAccessToken";
+import { NextAuthOptions } from "next-auth";
+
+type Credentials = {
+    username: string,
+    email: string,
+    password: string,
+    accessToken: string,
+    accessCode: string,
+};
+
+const authProviders: NextAuthOptions = {
+    session: {
+        strategy: "jwt",
+    },
+    providers: [
+        GoogleProvider({
+            clientId: process.env.GOOGLE_ID!,
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET!
+        }),
+        CredentialsProvider({
+            // @ts-ignore
+            async authorize(credentials: Credentials) {
+                const { username, email, password, accessToken, accessCode } = credentials;
+
+                try {
+                    if (accessCode) {
+                        let config = {
+                            method: 'get',
+                            url: `${process.env.API_URL}/api/iam/google/authenticate?accessCode=${accessCode}`,
+                        };
+
+
+                        const loginResponse = await axios.request(config);
+                        console.log("loginResponse", loginResponse.data);
+
+                        if (loginResponse.status == 400) {
+                            throw new Error(loginResponse.data.message);
+                        }
+                        if (loginResponse.status == 401) {
+                            throw new Error(loginResponse.data.message);
+                        }
+
+                        let base64decoded = jwtDecode(loginResponse.data.data.accessToken);
+                        let accessTokenExpires = base64decoded.exp;
+
+                        return {
+                            accessToken: loginResponse.data.data.accessToken,
+                            refreshToken: loginResponse.data.data.refreshToken,
+                            accessTokenExpires: accessTokenExpires,
+                            ...loginResponse.data.data,
+                        };
+
+                    } else {
+                        if (accessToken) {
+                            let data = JSON.stringify({
+                                username: email,
+                                email: email,
+                                password: password
+                            });
+
+                            let config = {
+                                method: 'get',
+                                url: `${process.env.API_URL}/api/iam/me`,
+                                headers: {
+                                    'accept': '*/*',
+                                    'Content-Type': 'application/json',
+                                    'Authorization': `Bearer ${accessToken}`
+                                }
+                            };
+
+
+                            const loginResponse = await axios.request(config);
+
+                            if (loginResponse.status == 400) {
+                                throw new Error(loginResponse.data.message);
+                            }
+                            if (loginResponse.status == 401) {
+                                throw new Error(loginResponse.data.message);
+                            }
+
+                            let base64decoded = jwtDecode(loginResponse.data.data.accessToken);
+                            let accessTokenExpires = base64decoded.exp;
+
+                            return {
+                                accessToken: loginResponse.data.data.accessToken,
+                                refreshToken: loginResponse.data.data.refreshToken,
+                                accessTokenExpires: accessTokenExpires,
+                                ...loginResponse.data.data,
+                            };
+
+                        } else {
+
+                            let data = JSON.stringify({
+                                username: email,
+                                email: email,
+                                password: password
+                            });
+
+                            let config = {
+                                method: 'post',
+                                maxBodyLength: Infinity,
+                                url: `${process.env.API_URL}/api/iam/authenticate`,
+                                headers: {
+                                    'accept': '*/*',
+                                    'Content-Type': 'application/json'
+                                },
+                                data: data
+                            };
+
+
+                            const loginResponse = await axios.request(config);
+
+                            // const authenticateResponse = await fetch(
+                            //   `${process.env.API_URL}/api/iam/authenticate`,
+                            //   {
+                            //     method: "Post",
+                            //     headers: {
+                            //     'accept': '*/*', 
+                            //       "Content-Type": "application/json"
+                            //     },
+                            //     body: JSON.stringify({
+                            //       username: email,
+                            //       email: email,
+                            //       password: password
+                            //     })
+                            //   }
+                            // );
+
+                            // const loginResponse = await authenticateResponse.json();
+
+                            // const response = await fetch(
+                            //   `${process.env.API_URL}/api/iam/me`,
+                            //   {
+                            //     method: "Get",
+                            //     headers: {
+                            //       "Content-Type": "application/json",
+                            //       "Authorization": `Bearer ${loginResponse.data.accessToken}`,
+                            //     },
+                            //   }
+                            // );
+
+                            // const responseData = await response.json();
+
+                            if (loginResponse.status == 400) {
+                                throw new Error(loginResponse.data.message);
+                            }
+                            if (loginResponse.status == 401) {
+                                throw new Error(loginResponse.data.data.message);
+                            }
+                            let base64decoded = jwtDecode(loginResponse.data.data.accessToken);
+                            let accessTokenExpires = base64decoded.exp;
+                            const returnResponse = {
+                                accessToken: loginResponse.data.data.accessToken,
+                                refreshToken: loginResponse.data.data.refreshToken,
+                                accessTokenExpires: accessTokenExpires,
+                                ...loginResponse.data.data,
+                            }
+                            return returnResponse;
+                        }
+                    }
+                } catch (error: any) {
+                    throw new Error(error.message ? error.message : error?.response?.data?.message);
+                }
+            },
+        }),
+    ],
+    callbacks: {
+        // @ts-ignore
+        jwt: async ({ token, user }) => {
+            const bufferTime = 60000;
+            if (Date.now() >= (token.accessTokenExpires as number - bufferTime)) {
+                return await refreshAccessToken(token); // Call the refresh token function
+            }
+
+            // If there is no user (first time login or session), we return the user data
+            if (user) {
+                const base64decoded = jwtDecode(user.accessToken);
+                const accessTokenExpires = base64decoded.exp && base64decoded.exp * 1000; // Convert from seconds to milliseconds
+                return {
+                    ...token,
+                    accessToken: user.accessToken,
+                    refreshToken: user.refreshToken,
+                    accessTokenExpires: accessTokenExpires,
+                    user: user,  // Include the user data here
+                };
+            }
+
+            return token; // If no update needed, just return the existing token
+        },
+        // @ts-ignore
+        session: async ({ session, token }) => {
+            const user = token.user || {};  // Default to an empty object if user is undefined or null
+            session.error = token.error ? token.error : null;
+            // if (token.error) {
+            //   return null
+            // }
+            session.user = {
+                ...user, // Include the user info from the token
+                accessToken: token?.accessToken,  // Add the access token to session for client use
+                refreshToken: token?.refreshToken,  // Add refresh token to session for future use
+                accessTokenExpires: token?.accessTokenExpires && token?.accessTokenExpires,  // Store the expiry time
+            };
+            return session;
+
+        },
+    },
+    pages: {
+        signIn: "/auth/login",
+    },
+    secret: process.env.NEXTAUTH_SECRET,
+}
+
+export default authProviders

package/dist/nextAuth/refreshAccessToken.tsx

@@ -0,0 +1,27 @@
+import axios from "axios";
+import { jwtDecode } from "jwt-decode";
+
+export async function refreshAccessToken(token: any) {
+    try {
+      const response = await axios.post(
+        `${process.env.NEXT_PUBLIC_BACKEND_API_URL}/api/iam/refresh-tokens`,
+        { refreshToken: token.refreshToken }
+      );
+  
+      const { accessToken, refreshToken } = response.data.data;
+      const { exp: accessTokenExpires } = jwtDecode<{ exp: number }>(accessToken);
+  
+      return {
+        ...token,
+        accessToken,
+        refreshToken,
+        accessTokenExpires: accessTokenExpires * 1000, // Convert seconds to milliseconds
+      };
+    } catch (error: any) {
+      console.error("Failed to refresh access token:", error.message || error.response?.data);
+      return {
+        // ...token,
+        error: "RefreshAccessTokenError",
+      };
+    }
+  }

package/dist/redux/api/articleApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const articleApi = createApi({
+    reducerPath: 'articleApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getarticle: builder.query({
+            query: (qs) => {
+                return `/radix-article-v2?${qs}`
+            }, 
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getarticleById: builder.query({
+            query: (id) => `/radix-article-v2/${id}?populateMedia[]=icon`,
+        }),
+        createarticle: builder.mutation({
+            query: (article) => ({
+                url: '/radix-article-v2',
+                method: 'POST',
+                body: article
+            }),
+        }),
+        updatearticle: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-article-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleArticles: builder.mutation({
+            query: (data) => ({
+                url: `/article/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deletearticle: builder.mutation({
+            query: (id) => ({
+                url: `/article/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetarticleQuery, useLazyGetarticleQuery, useDeleteMultipleArticlesMutation, useCreatearticleMutation, useGetarticleByIdQuery, useUpdatearticleMutation, useDeletearticleMutation } = articleApi  

package/dist/redux/api/authApi.ts

@@ -0,0 +1,131 @@
+
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+export const authApi = createApi({
+  reducerPath: "authApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    initateLogin: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/login/initiate",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    confirmOtpLogin: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/login/confirm",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    register: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/register",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    initateRegister: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/register/initiate",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    confirmOtpRegister: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/register/confirm",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    registerPrivate: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/register-private",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    updateUser: builder.mutation({
+      query: ({ id, data }) => ({
+        url: `/user/${id}/update-user-and-roles`,
+        method: 'PATCH',
+        body: data,
+      }),
+    }),
+    forgotPassword: builder.mutation({
+      query(body) {
+        return {
+          url: "/password/forgot",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    resetPassword: builder.mutation({
+      query({ token, body }) {
+        return {
+          url: `/password/reset/${token}`,
+          method: "PUT",
+          body,
+        };
+      },
+    }),
+    initiateChangePassword: builder.mutation({
+      query(body) {
+        return {
+          url: '/iam/initiate/forgot-password',
+          method: "POST",
+          body,
+        }
+      }
+    }),
+    confirmForgotPassword: builder.mutation({
+      query(body) {
+        return {
+          url: '/iam/confirm/forgot-password',
+          method: "POST",
+          body
+        }
+      }
+    }),
+    changePassword: builder.mutation({
+      query(body) {
+        return {
+          url: `/iam/change-password`,
+          method: "POST",
+          body,
+        };
+      },
+    }),
+  }),
+});
+
+export const {
+  useRegisterMutation,
+  useRegisterPrivateMutation,
+  useUpdateUserMutation,
+  useForgotPasswordMutation,
+  useResetPasswordMutation,
+  useInitiateChangePasswordMutation,
+  useConfirmForgotPasswordMutation,
+  useChangePasswordMutation,
+  useInitateLoginMutation,
+  useConfirmOtpLoginMutation,
+  useInitateRegisterMutation,
+  useConfirmOtpRegisterMutation,
+} = authApi;

package/dist/redux/api/automationApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const automationApi = createApi({
+    reducerPath: 'automationApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getautomations: builder.query({
+            query: (qs) => {
+                return `/automation?populate[]=category&populateMedia[]=bannerImage&populateMedia[]=automationThumbnailIcon&populateMedia[]=galleryImages&populateMedia[]=downloads&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getautomationById: builder.query({
+            query: (id) => `/automation/${id}?populate[]=category&populateMedia[]=bannerImage&populateMedia[]=automationThumbnailIcon&populateMedia[]=galleryImages&populateMedia[]=downloads`,
+        }),
+        createautomation: builder.mutation({
+            query: (automation) => ({
+                url: '/automation',
+                method: 'POST',
+                body: automation
+            })
+        }),
+        updateautomation: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/automation/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleAutomations: builder.mutation({
+            query: (data) => ({
+                url: `/automation/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteautomation: builder.mutation({
+            query: (id) => ({
+                url: `/automation/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetautomationsQuery, useLazyGetautomationsQuery, useDeleteMultipleAutomationsMutation, useGetautomationByIdQuery, useUpdateautomationMutation, useCreateautomationMutation, useDeleteautomationMutation } = automationApi  

package/dist/redux/api/categoryApi.tsx

@@ -0,0 +1,46 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const categorysApi = createApi({
+    reducerPath: 'categoryApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getcategorys: builder.query({   
+            query: (qs) => {
+                return `/radix-category-v2?populateMedia[]=bannerImage&populateMedia[]=thumbnailImage&populateMedia[]=thumbnailBackgroundImage&populateMedia[]=thumbnailIcon&populate[]=parentCategory&${qs}`
+            }
+        }),
+        getcategoryById: builder.query({
+            query: (id) => `/radix-category-v2/${id}?populateMedia[]=bannerImage&populateMedia[]=thumbnailImage&populateMedia[]=thumbnailBackgroundImage&populateMedia[]=thumbnailIcon&populate[]=parentCategory`,
+        }),
+        createcategory: builder.mutation({
+            query: (category) => ({
+                url: '/radix-category-v2',
+                method: 'POST',
+                body: category
+            })
+        }),
+        updatecategory: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-category-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleCategorys: builder.mutation({
+            query: (data) => ({
+                url: `/category/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deletecategory: builder.mutation({
+            query: (id) => ({
+                url: `/category/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetcategorysQuery, useLazyGetcategorysQuery, useGetcategoryByIdQuery, useDeleteMultipleCategorysMutation, useUpdatecategoryMutation,useCreatecategoryMutation, useDeletecategoryMutation } = categorysApi  

package/dist/redux/api/cityApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const citiesApi = createApi({
+    reducerPath: 'citiesApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getCities: builder.query({
+            query: (qs) => {
+                return `/city?populate[]=state&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getCityById: builder.query({
+            query: (id) => `/city/${id}?populate[]=state`,
+        }),
+        createCity: builder.mutation({
+            query: (city) => ({
+                url: '/city',
+                method: 'POST',
+                body: city
+            }),
+        }),
+        // updateCity: builder.mutation({
+        //     query: ({ id, data }) => ({
+        //         url: `/city/${id}`,
+        //         method: 'Patch',
+        //         body: data,
+        //     }),
+        // }),
+
+        deleteMultipleCities: builder.mutation({
+            query: (data) => ({
+                url: `/city/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteCity: builder.mutation({
+            query: (id) => ({
+                url: `/city/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useLazyGetCitiesQuery, useCreateCityMutation, useDeleteCityMutation, useDeleteMultipleCitiesMutation, useGetCitiesQuery, useGetCityByIdQuery, useLazyGetCityByIdQuery, usePrefetch } = citiesApi  

package/dist/redux/api/cmsBannerImageApi.tsx

@@ -0,0 +1,55 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const cmsBannerImagesApi = createApi({
+    reducerPath: 'cmsBannerImageApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getcmsBannerImages: builder.query({
+            query: (qs) => {
+                    return `/cmsBannerImage?populateMedia[]=backgroundAssetUrl&populateMedia[]=foregroundAssetUrl&${qs}`
+                },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getCmsBannerImageById: builder.query({
+            query: (id) => `/radix-cms-banner-image-v2/${id}?populateMedia[]=backgroundAssetUrl&populateMedia[]=foregroundAssetUrl`,
+        }),
+        createCmsBannerImage: builder.mutation({
+            query: (cmsBannerImage) => ({
+                url: '/radix-cms-banner-image-v2',
+                method: 'POST',
+                body: cmsBannerImage
+            })
+        }),
+        updateCmsBannerImage: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-cms-banner-image-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleCmsBannerImages: builder.mutation({
+            query: (data) => ({
+                url: `/cmsBannerImage/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deleteCmsBannerImage: builder.mutation({
+            query: (id) => ({
+                url: `/cmsBannerImage/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetcmsBannerImagesQuery, useLazyGetcmsBannerImagesQuery, useDeleteMultipleCmsBannerImagesMutation, useGetCmsBannerImageByIdQuery, useUpdateCmsBannerImageMutation,useCreateCmsBannerImageMutation, useDeleteCmsBannerImageMutation } = cmsBannerImagesApi