@solidstarters/solid-core-ui 0.1.26

package/src/redux/api/menuItemsApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const menuItemsApi = createApi({
+    reducerPath: 'menuItemApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getmenuItems: builder.query({
+            query: (qs) => {
+                return `/radix-menu-item-v2?populate[]=menu&populate[]=parentMenuItems&populate[]=category&${qs}`
+            },
+            // query: () => '/menuItem?populate[]=menu&populate[]=parentMenuItem',
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmenuItemById: builder.query({
+            query: (id) => `/radix-menu-item-v2/${id}?populate[]=menu&populate[]=parentMenuItems&populate[]=category&populateMedia[]=menuIcon`,
+        }),
+        createmenuItem: builder.mutation({
+            query: (menuItem) => ({
+                url: '/radix-menu-item-v2',
+                method: 'POST',
+                body: menuItem
+            })
+        }),
+        updatemenuItem: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-menu-item-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMenuItems: builder.mutation({
+            query: (data) => ({
+                url: `/menuItem/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deletemenuItem: builder.mutation({
+            query: (id) => ({
+                url: `/menuItem/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetmenuItemsQuery, useLazyGetmenuItemsQuery,useLazyGetmenuItemByIdQuery, useDeleteMultipleMenuItemsMutation, useGetmenuItemByIdQuery, useUpdatemenuItemMutation, useCreatemenuItemMutation, useDeletemenuItemMutation } = menuItemsApi  

package/src/redux/api/modelApi.ts

@@ -0,0 +1,70 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const modelsApi = createApi({
+    reducerPath: 'modelApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getModels: builder.query({
+            query: (qs) => {
+                return `/model-metadata?populate[0]=module&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmodelById: builder.query({
+            query: (id) => `/model-metadata/${id}?populate[0]=fields&populate[1]=module&populate[2]=fields.mediaStorageProvider`,
+        }),
+        createmodel: builder.mutation({
+            query: (model) => ({
+                url: '/model-metadata',
+                method: 'POST',
+                body: model
+            }),
+        }),
+        generateCodeForModel: builder.mutation({
+            query: (model) => ({
+                url: `/model-metadata/${model.id}/generate-code`,
+                method: 'POST',
+                body: model
+            }),
+        }),
+       
+        updatemodel: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/model-metadata/${id}`,
+                method: 'Put',
+                body: data,
+            }), 
+        }),
+        // deleteMultiplemodels: builder.mutation({
+        //     query: (data) => ({
+        //         url: `/model/bulk/`,
+        //         method: 'DELETE',
+        //         body:data
+        //     }),
+        // }),
+        deleteMultipleModels: builder.mutation({
+            query: (data) => ({
+                url: `/model-metadata/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deletemodel: builder.mutation({
+            query: (id) => ({
+                url: `/model-metadata/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetModelsQuery,useLazyGetModelsQuery, useLazyGetmodelByIdQuery, useGetmodelByIdQuery, useCreatemodelMutation,useGenerateCodeForModelMutation,useUpdatemodelMutation, useDeleteMultipleModelsMutation ,useDeletemodelMutation } = modelsApi  

package/src/redux/api/moduleApi.ts

@@ -0,0 +1,72 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const modulesApi = createApi({
+    reducerPath: 'moduleApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getmodules: builder.query({
+            query: (qs) => {
+                return `/module-metadata?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmoduleById: builder.query({
+            query: (id) => `/module-metadata/${id}`,
+        }),
+        createmodule: builder.mutation({
+            query: (module) => ({
+                url: '/module-metadata',
+                method: 'POST',
+                body: module
+            }),
+        }),
+        generateCodeFormodule: builder.mutation({
+            query: (module) => ({
+                url: `/module-metadata/${module.id}/generate-code`,
+                method: 'POST',
+                body: module
+            }),
+        }),
+        refreshPermissions: builder.mutation({
+            query: (module) => ({
+                url: `/module-metadata/refresh-permission`,
+                method: 'POST',
+                body: module
+            }),
+        }),
+        updatemodule: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/module-metadata/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultiplemodules: builder.mutation({
+            query: (data) => ({
+                url: `/module-metadata/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletemodule: builder.mutation({
+            query: (id) => ({
+                url: `/module-metadata/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+        getDefaultDataSource: builder.query({
+            query: () => `/module-metadata/fetch-default-datasource`,
+        }),
+    })
+})
+
+export const { useGetmodulesQuery, useLazyGetmodulesQuery, useLazyGetmoduleByIdQuery, useGetmoduleByIdQuery, useCreatemoduleMutation, useGenerateCodeFormoduleMutation, useRefreshPermissionsMutation, useUpdatemoduleMutation, useDeletemoduleMutation, useDeleteMultiplemodulesMutation, useGetDefaultDataSourceQuery, useLazyGetDefaultDataSourceQuery } = modulesApi  

package/src/redux/api/orderAttributeApi.tsx

@@ -0,0 +1,37 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const orderAttributeApi = createApi({
+    reducerPath: 'orderAttribute',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getRadixModelMetadataOrderAttributes: builder.query({
+            query: (radixModelMetadata) => {
+                return `radix-model-metadata-v2?populate[]=orderAttributeMetadatas&filters[name][$eqi]=${radixModelMetadata}`
+            }
+        }),
+        createOrderAttribute: builder.mutation({
+            query: (orderAttribute) => ({
+                url: '/radix-order-attribute-metadata-v2',
+                method: 'POST',
+                body: orderAttribute
+            })
+        }),
+        deleteMultipleOrderAttributes: builder.mutation({
+            query: (data) => ({
+                url: `/radix-order-attribute-metadata-v2/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        updateOrderAttribute: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-order-attribute-metadata-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+    })
+})
+
+export const { useUpdateOrderAttributeMutation, useLazyGetRadixModelMetadataOrderAttributesQuery } = orderAttributeApi  

package/src/redux/api/permissionApi.ts

@@ -0,0 +1,32 @@
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+export const permissionApi = createApi({
+  reducerPath: "permissionApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    getpermissions: builder.query({
+      query: (qs) => {
+        return `/permissions?${qs}`
+      },
+      transformResponse: (response: any) => {
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return {
+            records: response.data.records,
+            meta: response.data.meta
+        }
+      }
+    }),
+    getpermissionsById: builder.query({
+        query: (id) => `/permissions/${id}?offset=0&limit=5`,
+    }),
+  }),
+});
+
+export const {
+  useGetpermissionsByIdQuery,
+  useGetpermissionsQuery,
+  useLazyGetpermissionsQuery
+} = permissionApi;

package/src/redux/api/pincodeApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const pincodesApi = createApi({
+    reducerPath: 'pincodesApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getPincodes: builder.query({
+            query: (qs) => {
+                return `/pincode?populate[]=city&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getPincodeById: builder.query({
+            query: (id) => `/pincode/${id}?populate[]=city`,
+        }),
+        createPincode: builder.mutation({
+            query: (pincode) => ({
+                url: '/pincode',
+                method: 'POST',
+                body: pincode
+            }),
+        }),
+        // updatePincode: builder.mutation({
+        //     query: ({ id, data }) => ({
+        //         url: `/pincode/${id}`,
+        //         method: 'Patch',
+        //         body: data,
+        //     }),
+        // }),
+
+        deleteMultiplePincodes: builder.mutation({
+            query: (data) => ({
+                url: `/pincode/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletePincode: builder.mutation({
+            query: (id) => ({
+                url: `/pincode/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useLazyGetPincodesQuery, useCreatePincodeMutation, useDeletePincodeMutation, useDeleteMultiplePincodesMutation, useGetPincodesQuery, useGetPincodeByIdQuery, useLazyGetPincodeByIdQuery, usePrefetch } = pincodesApi  

package/src/redux/api/productData.tsx

@@ -0,0 +1,87 @@
+export const ProductService = {
+  getProductsData() {
+    return [
+      {
+        id: "12dqwq1212",
+        titleText: "PID Temperature Control",
+        titleTextFontColour: "#000",
+        subText: "Full Featured",
+        subTextFontColour: "#FF0000",
+        description: "Safe,Relaible & High Quality",
+        descriptionFontColour: "#FF0000",
+        videoUrl: "https://www.youtube.com/watch?v=x91MPoITQ3I",
+        videoBtnFontColour: "#FF0000",
+        ctaBtnText: "Play",
+        ctaBtnTextFontColour: "#FF0000",
+        ctaBtnUrl: "#",
+        backgroundAssetUrl:
+          "https://cdn.pixabay.com/photo/2019/11/29/09/46/garden-4660938_640.jpg",
+        foregroundAssetUrl:
+          "https://cdn.pixabay.com/photo/2019/11/29/09/46/garden-4660938_640.jpg",
+      },
+      {
+        id: "12dqwq1213",
+        titleText: "HIP Temperature Control 2",
+        titleTextFontColour: "#000",
+        subText: "Full Featured",
+        subTextFontColour: "#FF0000",
+        description: "Safe,Relaible & High Quality",
+        descriptionFontColour: "#FF0000",
+        videoUrl: "https://www.youtube.com/watch?v=x91MPoITQ3I",
+        videoBtnFontColour: "#FF0000",
+        ctaBtnText: "Play",
+        ctaBtnTextFontColour: "#FF0000",
+        ctaBtnUrl: "#",
+        backgroundAssetUrl:
+          "https://cdn.pixabay.com/photo/2019/11/29/09/46/garden-4660938_640.jpg",
+        foregroundAssetUrl:
+          "https://cdn.pixabay.com/photo/2019/11/29/09/46/garden-4660938_640.jpg",
+      },
+      {
+        id: "12dqwq1214",
+        titleText: "CID Temperature Control 3",
+        titleTextFontColour: "#000",
+        subText: "Full Featured",
+        subTextFontColour: "#FF0000",
+        description: "Safe,Relaible & High Quality",
+        descriptionFontColour: "#FF0000",
+        videoUrl: "https://www.youtube.com/watch?v=x91MPoITQ3I",
+        videoBtnFontColour: "#FF0000",
+        ctaBtnText: "Play",
+        ctaBtnTextFontColour: "#FF0000",
+        ctaBtnUrl: "#",
+        backgroundAssetUrl:
+          "https://cdn.pixabay.com/photo/2019/11/29/09/46/garden-4660938_640.jpg",
+        foregroundAssetUrl:
+          "https://cdn.pixabay.com/photo/2019/11/29/09/46/garden-4660938_640.jpg",
+      },
+      //   {
+      //     id: '1002',
+      //     name: 'EMS for RH, T and DP in Clean Room Area',
+      //     image: 'bamboo-watch.jpg',
+      //     date: "2024-07-03",
+      //     price: 17500,
+      //     quantity: 1,
+      //     orderStatus: 'On The Way',
+      //     slug: 'form-view'
+      // },
+    ];
+  },
+  getProductById(id: any){
+    
+      const filterbyId = this.getProductsData().filter((e: any) => e.id == id);
+      return Promise.resolve(filterbyId[0]);
+
+  },
+  // getProductsMini() {
+  //     return Promise.resolve(this.getProductsData().slice(0, 5));
+  // },
+
+  // getProductsSmall() {
+  //     return Promise.resolve(this.getProductsData().slice(0, 10));
+  // },
+
+  getProducts() {
+    return Promise.resolve(this.getProductsData());
+  },
+};

package/src/redux/api/radixExtraModelAttributeApi.tsx

@@ -0,0 +1,37 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const radixExtraModelAttributeApi = createApi({
+    reducerPath: 'radixExtraModelAttribute',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getRadixModelMetadataExtraAttributes: builder.query({
+            query: (radixModelMetadata) => {
+                return `radix-model-metadata-v2?populate[]=radixExtraModelAttributeMetadatas&filters[name][$eqi]=${radixModelMetadata}`
+            }
+        }),
+        createRadixExtraModelAttribute: builder.mutation({
+            query: (radixExtramodelAttributeMetadata) => ({
+                url: '/radix-extra-model-attribute-metadata-v2',
+                method: 'POST',
+                body: radixExtramodelAttributeMetadata
+            })
+        }),
+        deleteMultipleRadixExtraModelAttributes: builder.mutation({
+            query: (data) => ({
+                url: `/radix-extra-model-attribute-metadata-v2/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        updateRadixExtraModelAttribute: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-extra-model-attribute-metadata-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+    })
+})
+
+export const { useCreateRadixExtraModelAttributeMutation, useUpdateRadixExtraModelAttributeMutation , useGetRadixModelMetadataExtraAttributesQuery, useLazyGetRadixModelMetadataExtraAttributesQuery} = radixExtraModelAttributeApi  

package/src/redux/api/radixModelMetadataApi.tsx

@@ -0,0 +1,62 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const radixModelsMetadataApi = createApi({
+    reducerPath: 'radixModelMetadataApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getRadixModelsMetadata: builder.query({
+            query: (qs) => {
+                return `/radix-model-metadata-v2?populate[0]=categorys&populate[1]=radixExtraModelAttributeMetadatas&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getRadixModelMetadataById: builder.query({
+            query: (id) => `/radix-model-metadata-v2/${id}?populate[0]=categorys&populate[1]=radixExtraModelAttributeMetadatas&populate[2]=orderAttributeMetadatas`,
+        }),
+        createRadixModelMetadata: builder.mutation({
+            query: (radixModelMetadata) => ({
+                url: '/radix-model-metadata-v2',
+                method: 'POST',
+                body: radixModelMetadata
+            })
+        }),
+        updateRadixModelMetadata: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-model-metadata-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleRadixModelsMetadata: builder.mutation({
+            query: (data) => ({
+                url: `/radix-model-metadata-v2/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deleteRadixModelMetadata: builder.mutation({
+            query: (id) => ({
+                url: `/radix-model-metadata-v2/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+        uploadRadixModelMetadata: builder.mutation({
+            query: (radixModelMetadata) => ({
+                url: '/radix-model-metadata-v2/uploadOrderCode',
+                method: 'POST',
+                body: radixModelMetadata
+            })
+        }),
+    })
+})
+
+export const { useGetRadixModelsMetadataQuery, useGetRadixModelMetadataByIdQuery, useDeleteMultipleRadixModelsMetadataMutation, useLazyGetRadixModelsMetadataQuery, useUpdateRadixModelMetadataMutation,useCreateRadixModelMetadataMutation, useDeleteRadixModelMetadataMutation, useUploadRadixModelMetadataMutation } = radixModelsMetadataApi  

package/src/redux/api/radixModelsApi.tsx

@@ -0,0 +1,64 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const radixModelsApi = createApi({
+    reducerPath: 'radixModelsApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getRadixModels: builder.query({
+            query: (qs) => {
+                return `/radix-model?${qs}`
+            },
+        }),
+        getRadixModelsById: builder.query({
+            query: (id) => `/radix-model/${id}`,
+        }),
+        getRadixModelsFiltersByExtraAttributes: builder.query({
+            query: (productType:string) => {
+                return `/radix-model/distinct-counts/${productType}`
+            }
+        }),
+        createRadixModels: builder.mutation({
+            query: (radixModel) => ({
+                url: '/radix-model',
+                method: 'POST',
+                body: radixModel
+            })
+        }),
+        updateRadixModels: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-model/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteRadixModelsAsset: builder.mutation({
+            query: (data) => ({
+                url: `/radix-model/delete-assets`,
+                method: 'POST',
+                body:data
+            }),
+        }),
+        deleteRadixModelsAssetDownload: builder.mutation({
+            query: (data) => ({
+                url: `/radix-model/delete-assets-download`,
+                method: 'POST',
+                body:data
+            }),
+        }),
+        deleteMultipleRadixModels: builder.mutation({
+            query: (data) => ({
+                url: `/radix-model/delete-many`,
+                method: 'POST',
+                body:data
+            }),
+        }),
+        deleteRadixModels: builder.mutation({
+            query: (id) => ({
+                url: `/radix-model/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+export const { useGetRadixModelsQuery, useLazyGetRadixModelsQuery, useDeleteRadixModelsAssetMutation, useDeleteRadixModelsAssetDownloadMutation, useDeleteRadixModelsMutation, useLazyGetRadixModelsByIdQuery, useGetRadixModelsByIdQuery, useDeleteMultipleRadixModelsMutation, useUpdateRadixModelsMutation, useGetRadixModelsFiltersByExtraAttributesQuery, useLazyGetRadixModelsFiltersByExtraAttributesQuery, useCreateRadixModelsMutation} = radixModelsApi  

package/src/redux/api/ratingApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const ratingApi = createApi({
+    reducerPath: 'ratingApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getrating: builder.query({
+            query: (qs) => {
+                return `/radix-rating-v2?${qs}`
+            }, 
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getratingById: builder.query({
+            query: (id) => `/radix-rating-v2/${id}?populate[]=user`,
+        }),
+        createrating: builder.mutation({
+            query: (rating) => ({
+                url: '/radix-rating-v2',
+                method: 'POST',
+                body: rating
+            }),
+        }),
+        updaterating: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-rating-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleRatings: builder.mutation({
+            query: (data) => ({
+                url: `/radix-rating-v2/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deleterating: builder.mutation({
+            query: (id) => ({
+                url: `/radix-rating-v2/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetratingQuery, useLazyGetratingQuery, useDeleteMultipleRatingsMutation, useCreateratingMutation, useGetratingByIdQuery, useUpdateratingMutation, useDeleteratingMutation } = ratingApi