@philipe1993/list-color 1.0.0 → 1.0.2

package/index.tsx

@@ -0,0 +1,2 @@
+export { ListColor } from "./src/index";
+// export { default as colorStore } from "./store/colorStore";

package/package.json

@@ -2,16 +2,19 @@
     "name": "@philipe1993/list-color",
     "main": "src/index.js",
     "types": "src/index.d.ts",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "peerDependencies": {
-        "react": "^18.3.1",
-        "mobx": "^6.13.5",
-        "axios": "^1.7.7",
         "antd": "^5.22.0",
-        "tailwindcss": "^3.4.12",
-        "mobx-react-lite": "^4.0.7"
+        "axios": "^1.7.7",
+        "mobx": "^6.13.5",
+        "mobx-react-lite": "^4.0.7",
+        "react": "^18.3.1",
+        "tailwindcss": "^3.4.12"
     },
     "devDependencies": {
         "typescript": "^5.6.2"
+    },
+    "dependencies": {
+        "@philipe1993/shared": "^1.0.2"
     }
 }

package/services/ColorService.ts

@@ -0,0 +1,56 @@
+
+import URLS from '../../shared/src/config/urls';
+import { Color } from '../types/Color';
+import { getAPIInstance } from "@philipe1993/shared";
+
+
+const api = getAPIInstance();
+
+class ColorService {
+    async getList(params: any): Promise<any> {
+        try {
+            const response = await api.get(`${URLS.COLORS}/search`, { params });
+            return response; // Retorna a resposta da API
+        } catch (e) {
+            return { error: "Erro ao trazer listagem" }; // Retorna um objeto de erro
+        }
+    }
+
+    async createColor(color: Color): Promise<any> {
+        try {
+            const response = await api.post(`${URLS.COLORS}`, color);
+            return response; // Retorna a resposta da API
+        } catch (error) {
+            return { error: "Erro ao cadastrar", details: error };  // Retorna um objeto de erro
+        }
+    }
+
+    async editColor(color: Color, uuid: string | undefined): Promise<any> {
+        try {
+            const response = await api.put(`${URLS.COLORS}/${uuid}`, color);
+            return response; // Retorna a resposta da API
+        } catch (error) {
+            return { error: "Erro ao cadastrar", details: error }; // Retorna um objeto de erro
+        }
+    }
+
+    async getColorByUuid(uuid: any): Promise<any> {
+        try {
+            const response = await api.get(`${URLS.COLORS}/${uuid}`);
+            return response; // Retorna a resposta da API
+        } catch (e) {
+            return { error: "Erro ao buscar dados" }; // Retorna um objeto de erro
+        }
+    }
+
+    async deleteColor(uuid: any): Promise<any> {
+        try {
+            const response = await api.delete(`${URLS.COLORS}/${uuid}`);
+            return response; // Retorna a resposta da API
+        } catch (e) {
+            return { error: "Erro ao deletar" }; // Retorna um objeto de erro
+        }
+    }
+}
+
+export default new ColorService();

package/src/index.tsx

@@ -27,12 +27,10 @@ const breadCrumb = [
     },
 ]
 
-const ListColor: React.FC = observer(() => {
+export const ListColor: React.FC = observer(() => {
     return (
         <>
             <p>TESTE</p>
         </>
     );
-});
-
-export default ListColor;
+});

package/store/colorStore.ts

@@ -0,0 +1,135 @@
+import { message } from 'antd';
+import { makeAutoObservable, runInAction } from 'mobx';
+import { Color } from '../types/Color';
+import ColorService from '../services/ColorService';
+import { DEFAULT_PAGE_SIZE } from "@philipe1993/shared";
+
+class ColorStore {
+    loading: boolean = false;
+    colorList: Color[] = [];
+    colorSelectList: any;
+    sort?: string = 'created,desc';
+    totalPages: number = 0;
+    color: Color | undefined;
+    page: number = 0;
+    totalElements: number = 0;
+    size: number = DEFAULT_PAGE_SIZE;
+    defaultparams = {
+        size: DEFAULT_PAGE_SIZE,
+        page: 0,
+        sort: 'created,desc',
+        search: '',
+    }
+
+    reset() {
+        this.color = undefined;
+        this.colorList = [];
+        this.colorSelectList = [];
+    }
+
+    constructor() {
+        makeAutoObservable(this);
+    }
+
+    async getList(params: any) {
+        this.loading = true;
+        const response = await ColorService.getList(params);
+
+        runInAction(() => {
+            if (!response.error) {
+                this.colorList = response.data.content;
+                this.totalPages = response.data.totalPages;
+                this.page = response.data.number;
+                this.totalElements = response.data.totalElements;
+                this.size = response.data.size;
+            }
+            this.loading = false;
+        });
+
+        return response;
+    }
+
+    async createColor(color: Color) {
+        this.loading = true;
+        const response = await ColorService.createColor(color);
+
+        runInAction(() => {
+            if (response.error) {
+                message.error(response?.details?.response?.data?.message);
+                this.color = color;
+            } else {
+                message.success('Cor cadastrado com sucesso!');
+            }
+            this.loading = false;
+        });
+
+        return response;
+    }
+
+    async editColor(color: Color, uuid: string | undefined) {
+        this.loading = true;
+        const response = await ColorService.editColor(color, uuid);
+
+        runInAction(() => {
+            if (response.error) {
+                message.error(response?.details?.response?.data?.message);
+                this.color = color;
+            } else {
+                message.success('Cor editado com sucesso!');
+            }
+            this.loading = false;
+        });
+
+        return response;
+    }
+
+    async getColorByUuid(uuid: string) {
+        this.loading = true;
+        const response = await ColorService.getColorByUuid(uuid);
+
+        runInAction(() => {
+            if (response.error) {
+                message.error('Erro ao buscar Cor');
+                return;
+            }
+            this.color = response.data;
+            this.loading = false;
+        });
+
+        return response;
+    }
+
+    async deleteColor(uuid: string) {
+        this.loading = true;
+        const response = await ColorService.deleteColor(uuid);
+
+        runInAction(() => {
+            if (response.error) {
+                message.error('Erro ao deletar Cor');
+            } else {
+                message.success('Cor deletado com sucesso!');
+                this.color = undefined;
+            }
+            this.loading = false;
+        });
+
+        return response;
+    }
+
+    async deleteColorAll(uuid: string) {
+        this.loading = true;
+        const response = await ColorService.deleteColor(uuid);
+
+        runInAction(() => {
+            if (!response.error) {
+                this.color = undefined;
+            }
+            this.loading = false;
+        });
+
+        return response;
+    }
+}
+
+const colorStore = new ColorStore();
+export default colorStore;

package/types/Color.ts

@@ -0,0 +1,10 @@
+export interface Color {
+    uuid: string;
+    created?: string;
+    modified?: string;
+    active?: boolean;
+    deleted?: boolean;
+    hexColorCode: string;
+    name: string;
+    shortName: string;
+}