wearable

src/stores/admin/unit/wearable/wearable.ts

@@ -0,0 +1,108 @@
+import { defineStore } from "pinia";
+import type {
+  WearableViewModel,
+  CreateWearableViewModel,
+  UpdateWearableViewModel,
+} from "@/viewmodels/admin/unit/wearable/wearable.models";
+import { http } from "@/serverCom";
+import type { AxiosResponse } from "axios";
+import { wearableDemoData } from "../../../../demodata/wearable";
+
+export const useWearableStore = defineStore("wearable", {
+  state: () => {
+    return {
+      wearables: [] as Array<WearableViewModel & { tab_pos: number }>,
+      totalCount: 0 as number,
+      loading: "loading" as "loading" | "fetched" | "failed",
+      activeWearable: null as string | null,
+      activeWearableObj: null as WearableViewModel | null,
+      loadingActive: "loading" as "loading" | "fetched" | "failed",
+    };
+  },
+  actions: {
+    fetchWearables(offset = 0, count = 25, search = "", clear = false) {
+      this.wearables = wearableDemoData.map((e, i) => ({ ...e, tab_pos: i }));
+      this.totalCount = this.wearables.length;
+      this.loading = "fetched";
+      return;
+      if (clear) this.wearables = [];
+      this.loading = "loading";
+      http
+        .get(`/admin/wearable?offset=${offset}&count=${count}${search != "" ? "&search=" + search : ""}`)
+        .then((result) => {
+          this.totalCount = result.data.total;
+          result.data.wearables
+            .filter((elem: WearableViewModel) => this.wearables.findIndex((m) => m.id == elem.id) == -1)
+            .map((elem: WearableViewModel, index: number): WearableViewModel & { tab_pos: number } => {
+              return {
+                ...elem,
+                tab_pos: index + offset,
+              };
+            })
+            .forEach((elem: WearableViewModel & { tab_pos: number }) => {
+              this.wearables.push(elem);
+            });
+          this.loading = "fetched";
+        })
+        .catch((err) => {
+          this.loading = "failed";
+        });
+    },
+    async getAllWearables(): Promise<AxiosResponse<any, any>> {
+      return await http.get(`/admin/wearable?noLimit=true`).then((res) => {
+        return { ...res, data: res.data.wearables };
+      });
+    },
+    async getWearablesByIds(ids: Array<string>): Promise<AxiosResponse<any, any>> {
+      return await http
+        .post(`/admin/wearable/ids`, {
+          ids,
+        })
+        .then((res) => {
+          return { ...res, data: res.data.wearables };
+        });
+    },
+    async searchWearables(search: string): Promise<AxiosResponse<any, any>> {
+      return await http.get(`/admin/wearable?search=${search}&noLimit=true`).then((res) => {
+        return { ...res, data: res.data.wearables };
+      });
+    },
+    fetchWearableByActiveId() {
+      this.activeWearableObj = wearableDemoData.find((e) => e.id == this.activeWearable) as WearableViewModel;
+      this.loading = "fetched";
+      return;
+      this.loadingActive = "loading";
+      http
+        .get(`/admin/wearable/${this.activeWearable}`)
+        .then((res) => {
+          this.activeWearableObj = res.data;
+          this.loadingActive = "fetched";
+        })
+        .catch((err) => {
+          this.loadingActive = "failed";
+        });
+    },
+    fetchWearableById(id: string) {
+      return http.get(`/admin/wearable/${id}`);
+    },
+    async createWearable(wearable: CreateWearableViewModel): Promise<AxiosResponse<any, any>> {
+      const result = await http.post(`/admin/wearable`, {
+        // TODO: data
+      });
+      this.fetchWearables();
+      return result;
+    },
+    async updateActiveWearable(wearable: UpdateWearableViewModel): Promise<AxiosResponse<any, any>> {
+      const result = await http.patch(`/admin/wearable/${wearable.id}`, {
+        // TODO: data
+      });
+      this.fetchWearables();
+      return result;
+    },
+    async deleteWearable(wearable: number): Promise<AxiosResponse<any, any>> {
+      const result = await http.delete(`/admin/wearable/${wearable}`);
+      this.fetchWearables();
+      return result;
+    },
+  },
+});

src/stores/admin/unit/wearableType/wearableType.ts

@@ -0,0 +1,81 @@
+import { defineStore } from "pinia";
+import type {
+  WearableTypeViewModel,
+  CreateWearableTypeViewModel,
+  UpdateWearableTypeViewModel,
+} from "@/viewmodels/admin/unit/wearableType/wearableType.models";
+import { http } from "@/serverCom";
+import type { AxiosResponse } from "axios";
+import { wearableTypeDemoData } from "../../../../demodata/wearableType";
+
+export const useWearableTypeStore = defineStore("wearableType", {
+  state: () => {
+    return {
+      wearableTypes: [] as Array<WearableTypeViewModel & { tab_pos: number }>,
+      totalCount: 0 as number,
+      loading: "loading" as "loading" | "fetched" | "failed",
+    };
+  },
+  actions: {
+    fetchWearableTypes(offset = 0, count = 25, search = "", clear = false) {
+      this.wearableTypes = wearableTypeDemoData.map((e, i) => ({ ...e, tab_pos: i }));
+      this.totalCount = this.wearableTypes.length;
+      this.loading = "fetched";
+      return;
+      if (clear) this.wearableTypes = [];
+      this.loading = "loading";
+      http
+        .get(`/admin/wearableType?offset=${offset}&count=${count}${search != "" ? "&search=" + search : ""}`)
+        .then((result) => {
+          this.totalCount = result.data.total;
+          result.data.wearables
+            .filter((elem: WearableTypeViewModel) => this.wearableTypes.findIndex((m) => m.id == elem.id) == -1)
+            .map((elem: WearableTypeViewModel, index: number): WearableTypeViewModel & { tab_pos: number } => {
+              return {
+                ...elem,
+                tab_pos: index + offset,
+              };
+            })
+            .forEach((elem: WearableTypeViewModel & { tab_pos: number }) => {
+              this.wearableTypes.push(elem);
+            });
+          this.loading = "fetched";
+        })
+        .catch((err) => {
+          this.loading = "failed";
+        });
+    },
+    async getAllWearableTypes(): Promise<AxiosResponse<any, any>> {
+      return await http.get(`/admin/wearableType?noLimit=true`).then((res) => {
+        return { ...res, data: res.data.wearables };
+      });
+    },
+    async searchWearableTypes(search: string): Promise<AxiosResponse<any, any>> {
+      return await http.get(`/admin/wearableType?search=${search}&noLimit=true`).then((res) => {
+        return { ...res, data: res.data.wearables };
+      });
+    },
+    fetchWearableTypeById(id: string) {
+      return http.get(`/admin/wearableType/${id}`);
+    },
+    async createWearableType(wearableType: CreateWearableTypeViewModel): Promise<AxiosResponse<any, any>> {
+      const result = await http.post(`/admin/wearableType`, {
+        // TODO: data
+      });
+      this.fetchWearableTypes();
+      return result;
+    },
+    async updateWearableType(wearableType: UpdateWearableTypeViewModel): Promise<AxiosResponse<any, any>> {
+      const result = await http.patch(`/admin/wearableType/${wearableType.id}`, {
+        // TODO: data
+      });
+      this.fetchWearableTypes();
+      return result;
+    },
+    async deleteWearableType(wearableType: number): Promise<AxiosResponse<any, any>> {
+      const result = await http.delete(`/admin/wearableType/${wearableType}`);
+      this.fetchWearableTypes();
+      return result;
+    },
+  },
+});