@solidstarters/solid-core-ui 0.1.26

package/src/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/src/redux/api/authApi.ts

@@ -0,0 +1,60 @@
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+export const authApi = createApi({
+  reducerPath: "authApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    register: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/register",
+          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}`,
+        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,
+        };
+      },
+    }),
+  }),
+});
+
+export const {
+  useRegisterMutation,
+  useRegisterPrivateMutation,
+  useUpdateUserMutation,
+  useForgotPasswordMutation,
+  useResetPasswordMutation,
+} = authApi;

package/src/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/src/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/src/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/src/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  

package/src/redux/api/countryApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const countriesApi = createApi({
+    reducerPath: 'countriesApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getCountries: builder.query({
+            query: (qs) => {
+                return `/custom-countries?&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getCountryById: builder.query({
+            query: (id) => `/custom-countries/${id}`,
+        }),
+        createCountry: builder.mutation({
+            query: (country) => ({
+                url: '/custom-countries',
+                method: 'POST',
+                body: country
+            }),
+        }),
+        updateCountry: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/custom-countries/${id}`,
+                method: 'Patch',
+                body: data,
+            }),
+        }),
+
+        deleteMultipleCountries: builder.mutation({
+            query: (data) => ({
+                url: `/custom-countries/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteCountry: builder.mutation({
+            query: (id) => ({
+                url: `/custom-countries/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useLazyGetCountriesQuery, useCreateCountryMutation, useDeleteCountryMutation, useDeleteMultipleCountriesMutation, useGetCountriesQuery, useGetCountryByIdQuery, useLazyGetCountryByIdQuery, usePrefetch, useUpdateCountryMutation } = countriesApi  

package/src/redux/api/fetchBaseQuery.tsx

@@ -0,0 +1,15 @@
+import { fetchBaseQuery } from "@reduxjs/toolkit/dist/query";
+import { getSession } from "next-auth/react";
+
+const baseUrl = `${process.env.NEXT_PUBLIC_BACKEND_API_URL}/api`; // Base URL for the API endpoints
+// Updated fetchBaseQuery to include accessToken in headers
+export const baseQueryWithAuth = fetchBaseQuery({
+    baseUrl,
+    prepareHeaders: async (headers) => {
+        const session = await getSession(); // Fetch session data
+        if (session?.user.accessToken) {
+            headers.set('authorization', `Bearer ${session?.user?.accessToken}`); // Add access token to headers
+        }
+        return headers;
+    },
+});

package/src/redux/api/fieldApi.ts

@@ -0,0 +1,78 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const fieldsApi = createApi({
+    reducerPath: 'fieldApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getfields: builder.query({
+            query: (qs) => {
+                return `/field-metadata?populate[0]=model&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+
+        getfieldById: builder.query({
+            query: (id) => `/field-metadata/${id}`,
+        }),
+        getFieldDefaultMetaData: builder.query({
+            query: () => `/field-metadata/default`,
+        }),
+        getSelectionDynamicValues: builder.query({
+            query: (qs) => `/field-metadata/selection-dynamic-values?${qs}`,
+        }),
+        getSelectionDynamicValue: builder.query({
+            query: (qs) => `/field-metadata/selection-dynamic-value?${qs}`,
+        }),
+        createfield: builder.mutation({
+            query: (field) => ({
+                url: '/field-metadata',
+                method: 'POST',
+                body: field
+            }),
+        }),
+        // updatefield: builder.mutation({
+        //     query: ({ id, data }) => ({
+        //         url: `/field-metadata/${id}`,
+        //         method: 'PUT',
+        //         body: data,
+        //     }), 
+        // }),
+        // deleteMultiplefields: builder.mutation({
+        //     query: (data) => ({
+        //         url: `/field/bulk/`,
+        //         method: 'DELETE',
+        //         body:data
+        //     }),
+        // }),
+        deletefield: builder.mutation({
+            query: (id) => ({
+                url: `/field/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const {
+    useGetfieldsQuery,
+    useLazyGetfieldsQuery,
+    useLazyGetfieldByIdQuery,
+    useGetFieldDefaultMetaDataQuery,
+    useGetSelectionDynamicValuesQuery,
+    useLazyGetSelectionDynamicValuesQuery,
+    useGetSelectionDynamicValueQuery,
+    useLazyGetSelectionDynamicValueQuery,
+    useLazyGetFieldDefaultMetaDataQuery,
+    useGetfieldByIdQuery,
+    useCreatefieldMutation,
+    useDeletefieldMutation
+} = fieldsApi  

package/src/redux/api/mediaApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const mediaApi = createApi({
+    reducerPath: 'mediaApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getMedias: builder.query({
+            query: (qs) => {
+                return `/media?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getMediaById: builder.query({
+            query: (id) => `/media/${id}`,
+        }),
+        createMedia: builder.mutation({
+            query: (Media) => ({
+                url: '/media',
+                method: 'POST',
+                body: Media
+            }),
+        }),
+        updateMedia: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/media/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMedias: builder.mutation({
+            query: (data) => ({
+                url: `/media/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteMedia: builder.mutation({
+            query: (id) => ({
+                url: `/media/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetMediasQuery, useLazyGetMediaByIdQuery, useLazyGetMediasQuery, useGetMediaByIdQuery, useCreateMediaMutation, useUpdateMediaMutation, useDeleteMediaMutation, useDeleteMultipleMediasMutation } = mediaApi  

package/src/redux/api/mediaStorageProviderApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const mediaStorageProviderApi = createApi({
+    reducerPath: 'mediaStorageProviderApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getMediaStorageProviders: builder.query({
+            query: (qs) => {
+                return `/media-storage-provider-metadata?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getMediaStorageProivderById: builder.query({
+            query: (id) => `/media-storage-provider-metadata/${id}`,
+        }),
+        createMediaStorageProivder: builder.mutation({
+            query: (MediaStorageProivder) => ({
+                url: '/media-storage-provider-metadata',
+                method: 'POST',
+                body: MediaStorageProivder
+            }),
+        }),
+        updateMediaStorageProivder: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/media-storage-provider-metadata/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMediaStorageProviders: builder.mutation({
+            query: (data) => ({
+                url: `/media-storage-provider-metadata/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteMediaStorageProivder: builder.mutation({
+            query: (id) => ({
+                url: `/media-storage-provider-metadata/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetMediaStorageProvidersQuery, useLazyGetMediaStorageProivderByIdQuery, useLazyGetMediaStorageProvidersQuery, useGetMediaStorageProivderByIdQuery, useCreateMediaStorageProivderMutation, useUpdateMediaStorageProivderMutation, useDeleteMediaStorageProivderMutation, useDeleteMultipleMediaStorageProvidersMutation } = mediaStorageProviderApi  

package/src/redux/api/menuApi.tsx

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const menusApi = createApi({
+    reducerPath: 'menuApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getmenus: builder.query({
+            query: (qs) => {
+                return `/radix-menu-v2?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmenuById: builder.query({
+            query: (id) => `/menu/${id}`,
+        }),
+        createmenu: builder.mutation({
+            query: (menu) => ({
+                url: '/menu',
+                method: 'POST',
+                body: menu
+            }),
+        }),
+        updatemenu: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/menu/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMenus: builder.mutation({
+            query: (data) => ({
+                url: `/menu/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletemenu: builder.mutation({
+            query: (id) => ({
+                url: `/menu/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetmenusQuery, useLazyGetmenusQuery, useLazyGetmenuByIdQuery, useGetmenuByIdQuery, useUpdatemenuMutation, useCreatemenuMutation, useDeletemenuMutation, useDeleteMultipleMenusMutation } = menusApi