@hedhog/admin 0.48.5 → 0.48.7

package/frontend/dashboard-component/react-query/requests.ts.ejs

@@ -0,0 +1,61 @@
+import { useApp } from "@/hooks/use-app";
+import { Delete, PaginationParams, PaginationResult } from "@/types";
+import { DashboardComponent } from "@/types/models";
+import { HttpMethod } from "@/types/http-method";
+import { formatDataWithLocale } from "@hedhog/utils";
+
+export function requests() {
+  const { request } = useApp();
+
+  const dashboardComponentList = async (params: PaginationParams) => {
+    return request<PaginationResult<DashboardComponent>>({
+      url: "/dashboard-component",
+      params,
+    }).then((res) => res.data);
+  };
+
+  const dashboardComponentGet = async (id: number) => {
+    return request<DashboardComponent>({
+      url: `/dashboard-component/${id}`,
+    }).then((res) => res.data);
+  };
+
+  const dashboardComponentCreate = async (params: {
+    data: DashboardComponent;
+  }) => {
+    const { data } = params;
+    return request<DashboardComponent>({
+      url: "/dashboard-component",
+      method: HttpMethod.POST,
+      data: formatDataWithLocale(data),
+    }).then((res) => res.data);
+  };
+
+  const dashboardComponentDelete = async (ids: number[]) => {
+    return request<Delete>({
+      url: "/dashboard-component",
+      data: { ids },
+      method: HttpMethod.DELETE,
+    }).then((res) => res.data);
+  };
+
+  const dashboardComponentUpdate = async (params: {
+    id: number;
+    data: DashboardComponent;
+  }) => {
+    const { id, data } = params;
+    return request<DashboardComponent>({
+      url: `/dashboard-component/${id}`,
+      method: HttpMethod.PATCH,
+      data: formatDataWithLocale(data),
+    }).then((res) => res.data);
+  };
+
+  return {
+    dashboardComponentCreate,
+    dashboardComponentUpdate,
+    dashboardComponentDelete,
+    dashboardComponentList,
+    dashboardComponentGet,
+  };
+}

package/frontend/dashboard-item/components/create-panel.tsx.ejs

@@ -0,0 +1,108 @@
+import FormPanel, { FormPanelRef } from '@/components/panels/form-panel'
+import { EnumFieldType } from '@/enums/EnumFieldType'
+import { useDashboardItemCreate } from '@/features/dashboard/dashboard-item'
+import { DashboardItem } from '@/types/models'
+import { forwardRef, useImperativeHandle, useRef } from 'react'
+import { useTranslation } from 'react-i18next'
+
+export type DashboardItemCreatePanelRef = {
+  submit: () => void
+}
+
+export type DashboardItemCreatePanelProps = {
+  onCreated?: (data: DashboardItem) => void
+}
+
+const DashboardItemCreatePanel = forwardRef(
+  ({ onCreated }: DashboardItemCreatePanelProps, ref) => {
+    const formRef = useRef<FormPanelRef>(null)
+    const { t } = useTranslation(['actions', 'fields', 'translations'])
+    const { mutateAsync: createDashboardItem } = useDashboardItemCreate()
+
+    useImperativeHandle(
+      ref,
+      () => ({
+        submit: () => {
+          formRef.current?.submit()
+        },
+      }),
+      [formRef]
+    )
+
+    return (
+      <FormPanel
+        ref={formRef}
+        fields={[
+          {
+            name: 'component_id',
+            label: { text: t('dashboard-item.component_id', { ns: 'fields' }) },
+            type: EnumFieldType.COMBOBOX,
+            required: true,
+            url: '/dashboard-component',
+            displayName: 'component',
+            valueName: 'id',
+          },
+
+          {
+            name: 'dashboard_id',
+            label: { text: t('dashboard-item.dashboard_id', { ns: 'fields' }) },
+            type: EnumFieldType.COMBOBOX,
+            required: true,
+            url: '/dashboard',
+            displayName: 'dashboard',
+            valueName: 'id',
+          },
+
+          {
+            name: 'width',
+            label: { text: t('dashboard-user.width', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+
+          {
+            name: 'height',
+            label: { text: t('dashboard-user.height', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+
+          {
+            name: 'x_axis',
+            label: { text: t('dashboard-user.x_axis', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+
+          {
+            name: 'y_axis',
+            label: { text: t('dashboard-user.y_axis', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+        ]}
+        button={{ text: t('create', { ns: 'actions' }) }}
+        onSubmit={async (data) => {
+          const createdData = await createDashboardItem({
+            data: {
+              ...data,
+              component_id: Number(data.component_id),
+              dashboard_id: Number(data.dashboard_id),
+              width: Number(data.width),
+              height: Number(data.height),
+              x_axis: Number(data.x_axis),
+              y_axis: Number(data.y_axis),
+            },
+          })
+          if (typeof onCreated === 'function') {
+            onCreated(createdData as any)
+          }
+        }}
+      />
+    )
+  }
+)
+
+DashboardItemCreatePanel.displayName = 'DashboardItemCreatePanel'
+
+export default DashboardItemCreatePanel

package/frontend/dashboard-item/components/dashboard-item.screen.tsx.ejs

@@ -0,0 +1,133 @@
+import { PageTitle } from '@/components/custom/page-title'
+import DataPanel from '@/components/panels/data-panel'
+import { useDashboardItemDelete } from '@/features/dashboard/dashboard-item'
+import { useApp } from '@/hooks/use-app'
+import { isPlural } from '@/lib/utils'
+import { DashboardItem } from '@/types/models'
+import { IconEdit, IconPlus, IconTrash } from '@tabler/icons-react'
+import { useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import DashboardItemCreatePanel from './components/dashboard-item-create-panel'
+import DashboardItemUpdatePanel from './components/dashboard-item-update-panel'
+import DashboardItemCard from '@/components/cards/dashboard-item-card'
+
+export default function Page() {
+  const [selectedItems, setSelectedItems] = useState<DashboardItem[]>([])
+  const { mutate: deleteDashboarditem } = useDashboardItemDelete()
+  const { openSheet, confirm, closeSheet } = useApp()
+  const { t } = useTranslation([
+    'dashboard.dashboard-item',
+    'modules',
+    'actions',
+    'fields',
+  ])
+
+  const openCreate = () => {
+    const id = openSheet({
+      title: t('create', { ns: 'dashboard.dashboard-item' }),
+      description: t('createText', {
+        ns: 'dashboard.dashboard-item',
+      }),
+      children: () => (
+        <DashboardItemCreatePanel onCreated={() => closeSheet(id)} />
+      ),
+    })
+
+    return id
+  }
+
+  const openDelete = (items: DashboardItem[]) => {
+    return confirm({
+      title: `${t('delete', { ns: 'dashboard.dashboard-item' })} ${items.length} ${isPlural(items.length) ? t('items', { ns: 'actions' }) : t('item', { ns: 'actions' })}`,
+      description: t('deleteText', {
+        ns: 'dashboard.dashboard-item',
+      }),
+    })
+      .then(() =>
+        deleteDashboarditem(
+          items
+            .map((item) => (item as any).item_id)
+            .filter((id) => id !== undefined)
+        )
+      )
+      .catch(() => setSelectedItems(items))
+  }
+
+  const openUpdate = (item: DashboardItem) => {
+    const id = openSheet({
+      children: () => (
+        <DashboardItemUpdatePanel
+          data={item}
+          onUpdated={() => closeSheet(id)}
+        />
+      ),
+      title: t('edit', { ns: 'dashboard.dashboard-item' }),
+      description: t('editText', {
+        ns: 'dashboard.dashboard-item',
+      }),
+    })
+
+    return id
+  }
+
+  return (
+    <>
+      <PageTitle title={t('dashboard_item', { ns: 'modules' })} />
+      <DataPanel
+        url='/dashboard-item'
+        layout='grid'
+        id='dashboard-item'
+        selectable
+        render={(item: DashboardItem) => <DashboardItemCard item={item} />}
+        responsiveColumns={{
+          default: 1,
+          sm: 2,
+          md: 1,
+          lg: 2,
+          xl: 3,
+        }}
+        selected={selectedItems as DashboardItem[]}
+        multiple
+        hasSearch
+        onItemDoubleClick={(item) => openUpdate(item)}
+        menuActions={[
+          {
+            icon: <IconEdit className='mr-1 w-8 cursor-pointer' />,
+            label: t('edit', { ns: 'actions' }),
+            tooltip: t('editTooltip', {
+              ns: 'dashboard.dashboard-item',
+            }),
+            handler: (items: DashboardItem[]) => {
+              if (items.length === 1) openUpdate(items[0])
+            },
+            show: 'once',
+          },
+          {
+            icon: <IconTrash className='mr-1 w-8 cursor-pointer' />,
+            label: t('delete', { ns: 'actions' }),
+            tooltip: t('deleteTooltip', {
+              ns: 'dashboard.dashboard-item',
+            }),
+            variant: 'destructive',
+            handler: (items: DashboardItem[]) => {
+              openDelete(items)
+            },
+            show: 'some',
+          },
+          {
+            icon: <IconPlus className='mr-1 w-8 cursor-pointer' />,
+            label: t('create', { ns: 'actions' }),
+            tooltip: t('createTooltip', {
+              ns: 'dashboard.dashboard-item',
+            }),
+            variant: 'default',
+            handler: () => {
+              openCreate()
+            },
+            show: 'none',
+          },
+        ]}
+      />
+    </>
+  )
+}

package/frontend/dashboard-item/components/update-panel.tsx.ejs

@@ -0,0 +1,141 @@
+import FormPanel, { FormPanelRef } from '@/components/panels/form-panel'
+import { Overlay } from '@/components/custom/overlay'
+import { TabPanel } from '@/components/panels/tab-panel'
+import {
+  useDashboardItemGet,
+  useDashboardItemUpdate,
+} from '@/features/dashboard/dashboard-item'
+import useEffectAfterFirstUpdate from '@/hooks/use-effect-after-first-update'
+import { DashboardItem } from '@/types/models'
+import { forwardRef, useImperativeHandle, useRef } from 'react'
+import { useTranslation } from 'react-i18next'
+import { EnumFieldType } from '@/enums/EnumFieldType'
+
+export type DashboardItemUpdatePanelProps = {
+  data: DashboardItem
+  onUpdated?: (data: DashboardItem) => void
+}
+
+const DashboardItemUpdatePanel = forwardRef(
+  ({ data, onUpdated }: DashboardItemUpdatePanelProps, ref) => {
+    const { t } = useTranslation(['actions', 'fields', 'translations'])
+    const { data: item, isLoading } = useDashboardItemGet(
+      (data as any).id as number
+    )
+    const { mutate: dashboardItemUpdate } = useDashboardItemUpdate()
+    const formRef = useRef<FormPanelRef>(null)
+
+    useEffectAfterFirstUpdate(() => {
+      if (item && formRef.current) {
+        formRef.current.setValuesFromItem(item)
+      }
+    }, [item])
+
+    useImperativeHandle(ref, () => ({}))
+
+    return (
+      <TabPanel
+        activeTabIndex={0}
+        tabs={[
+          {
+            title: t('details', { ns: 'actions' }),
+            children: (
+              <Overlay loading={isLoading}>
+                <FormPanel
+                  ref={formRef}
+                  fields={[
+                    {
+                      name: 'component_id',
+                      label: {
+                        text: t('dashboard-item.component_id', {
+                          ns: 'fields',
+                        }),
+                      },
+                      type: EnumFieldType.COMBOBOX,
+                      required: true,
+                      url: '/dashboard-component',
+                      displayName: 'component',
+                      valueName: 'id',
+                    },
+
+                    {
+                      name: 'dashboard_id',
+                      label: {
+                        text: t('dashboard-item.dashboard_id', {
+                          ns: 'fields',
+                        }),
+                      },
+                      type: EnumFieldType.COMBOBOX,
+                      required: true,
+                      url: '/dashboard',
+                      displayName: 'dashboard',
+                      valueName: 'id',
+                    },
+
+                    {
+                      name: 'width',
+                      label: {
+                        text: t('dashboard-user.width', { ns: 'fields' }),
+                      },
+                      type: EnumFieldType.NUMBER,
+                      required: true,
+                    },
+
+                    {
+                      name: 'height',
+                      label: {
+                        text: t('dashboard-user.height', { ns: 'fields' }),
+                      },
+                      type: EnumFieldType.NUMBER,
+                      required: true,
+                    },
+
+                    {
+                      name: 'x_axis',
+                      label: {
+                        text: t('dashboard-user.x_axis', { ns: 'fields' }),
+                      },
+                      type: EnumFieldType.NUMBER,
+                      required: true,
+                    },
+
+                    {
+                      name: 'y_axis',
+                      label: {
+                        text: t('dashboard-user.y_axis', { ns: 'fields' }),
+                      },
+                      type: EnumFieldType.NUMBER,
+                      required: true,
+                    },
+                  ]}
+                  button={{ text: t('save', { ns: 'actions' }) }}
+                  onSubmit={(data) => {
+                    dashboardItemUpdate({
+                      id: data.id,
+                      data: {
+                        ...data,
+                        component_id: Number(data.component_id),
+                        dashboard_id: Number(data.dashboard_id),
+                        width: Number(data.width),
+                        height: Number(data.height),
+                        x_axis: Number(data.x_axis),
+                        y_axis: Number(data.y_axis),
+                      },
+                    })
+                    if (typeof onUpdated === 'function') {
+                      onUpdated(data)
+                    }
+                  }}
+                />
+              </Overlay>
+            ),
+          },
+        ]}
+      />
+    )
+  }
+)
+
+DashboardItemUpdatePanel.displayName = 'DashboardItemUpdatePanel'
+
+export default DashboardItemUpdatePanel

package/frontend/dashboard-item/locales/en/dashboard.dashboard-item.json

@@ -0,0 +1,11 @@
+{
+  "create": "Create dashboard item",
+  "createText": "Fill the dashboard item informations.",
+  "createTooltip": "Create new dashboard item",
+  "delete": "Delete dashboard item",
+  "deleteText": "Are you sure to delete these dashboard item?",
+  "deleteTooltip": "Delete the selected dashboard item",
+  "edit": "Edit dashboard item",
+  "editText": "View and edit dashboard item information.",
+  "editTooltip": "Edit the selected dashboard item"
+}

package/frontend/dashboard-item/locales/pt/dashboard.dashboard-item.json

@@ -0,0 +1,11 @@
+{
+  "create": "Criar item do painel",
+  "createText": "Preencha as informações do item do painel.",
+  "createTooltip": "Criar novo item do painel",
+  "delete": "Excluir item do painel",
+  "deleteText": "Você tem certeza que deseja excluir esses itens do painel?",
+  "deleteTooltip": "Excluir o(s) item(ns) do painel selecionado(s)",
+  "edit": "Editar item do painel",
+  "editText": "Visualizar e editar informações do item do painel.",
+  "editTooltip": "Editar o item do painel selecionado"
+}

package/frontend/dashboard-item/react-query/handlers.ts.ejs

@@ -0,0 +1,28 @@
+import { useDefaultMutation } from "@/hooks/use-default-mutation";
+import { useQuery } from "@tanstack/react-query";
+import { requests } from "./requests";
+
+const scope = "dashboard-item";
+
+export function useDashboardItemCreate() {
+  const { dashboardItemCreate } = requests();
+  return useDefaultMutation(scope, "create", dashboardItemCreate);
+}
+
+export function useDashboardItemDelete() {
+  const { dashboardItemDelete } = requests();
+  return useDefaultMutation(scope, "delete", dashboardItemDelete);
+}
+
+export function useDashboardItemUpdate() {
+  const { dashboardItemUpdate } = requests();
+  return useDefaultMutation(scope, "update", dashboardItemUpdate);
+}
+
+export function useDashboardItemGet(id: number) {
+  const { dashboardItemGet } = requests();
+  return useQuery({
+    queryKey: [scope, "get"],
+    queryFn: () => dashboardItemGet(id),
+  });
+}

package/frontend/dashboard-item/react-query/requests.ts.ejs

@@ -0,0 +1,58 @@
+import { useApp } from "@/hooks/use-app";
+import { Delete, PaginationParams, PaginationResult } from "@/types";
+import { DashboardItem } from "@/types/models";
+import { HttpMethod } from "@/types/http-method";
+
+export function requests() {
+  const { request } = useApp();
+
+  const dashboardItemList = async (params: PaginationParams) => {
+    return request<PaginationResult<DashboardItem>>({
+      url: "/dashboard-item",
+      params,
+    }).then((res) => res.data);
+  };
+
+  const dashboardItemGet = async (id: number) => {
+    return request<DashboardItem>({
+      url: `/dashboard-item/${id}`,
+    }).then((res) => res.data);
+  };
+
+  const dashboardItemCreate = async (params: { data: DashboardItem }) => {
+    const { data } = params;
+    return request<DashboardItem>({
+      url: "/dashboard-item",
+      method: HttpMethod.POST,
+      data: data,
+    }).then((res) => res.data);
+  };
+
+  const dashboardItemDelete = async (ids: number[]) => {
+    return request<Delete>({
+      url: "/dashboard-item",
+      data: { ids },
+      method: HttpMethod.DELETE,
+    }).then((res) => res.data);
+  };
+
+  const dashboardItemUpdate = async (params: {
+    id: number;
+    data: DashboardItem;
+  }) => {
+    const { id, data } = params;
+    return request<DashboardItem>({
+      url: `/dashboard-item/${id}`,
+      method: HttpMethod.PATCH,
+      data: data,
+    }).then((res) => res.data);
+  };
+
+  return {
+    dashboardItemCreate,
+    dashboardItemUpdate,
+    dashboardItemDelete,
+    dashboardItemList,
+    dashboardItemGet,
+  };
+}

package/frontend/dashboard-user/components/create-panel.tsx.ejs

@@ -0,0 +1,108 @@
+import FormPanel, { FormPanelRef } from '@/components/panels/form-panel'
+import { EnumFieldType } from '@/enums/EnumFieldType'
+import { useDashboardUserCreate } from '@/features/dashboard/dashboard-user'
+import { DashboardUser } from '@/types/models'
+import { forwardRef, useImperativeHandle, useRef } from 'react'
+import { useTranslation } from 'react-i18next'
+
+export type DashboardUserCreatePanelRef = {
+  submit: () => void
+}
+
+export type DashboardUserCreatePanelProps = {
+  onCreated?: (data: DashboardUser) => void
+}
+
+const DashboardUserCreatePanel = forwardRef(
+  ({ onCreated }: DashboardUserCreatePanelProps, ref) => {
+    const formRef = useRef<FormPanelRef>(null)
+    const { t } = useTranslation(['actions', 'fields', 'translations'])
+    const { mutateAsync: createDashboardUser } = useDashboardUserCreate()
+
+    useImperativeHandle(
+      ref,
+      () => ({
+        submit: () => {
+          formRef.current?.submit()
+        },
+      }),
+      [formRef]
+    )
+
+    return (
+      <FormPanel
+        ref={formRef}
+        fields={[
+          {
+            name: 'item_id',
+            label: { text: t('dashboard-user.item_id', { ns: 'fields' }) },
+            type: EnumFieldType.COMBOBOX,
+            required: true,
+            url: '/dashboard-item',
+            displayName: 'item',
+            valueName: 'id',
+          },
+
+          {
+            name: 'user_id',
+            label: { text: t('dashboard-user.user_id', { ns: 'fields' }) },
+            type: EnumFieldType.COMBOBOX,
+            required: true,
+            url: '/user',
+            displayName: 'user',
+            valueName: 'id',
+          },
+
+          {
+            name: 'width',
+            label: { text: t('dashboard-user.width', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+
+          {
+            name: 'height',
+            label: { text: t('dashboard-user.height', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+
+          {
+            name: 'x_axis',
+            label: { text: t('dashboard-user.x_axis', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+
+          {
+            name: 'y_axis',
+            label: { text: t('dashboard-user.y_axis', { ns: 'fields' }) },
+            type: EnumFieldType.NUMBER,
+            required: true,
+          },
+        ]}
+        button={{ text: t('create', { ns: 'actions' }) }}
+        onSubmit={async (data) => {
+          const createdData = await createDashboardUser({
+            data: {
+              ...data,
+              item_id: Number(data.item_id),
+              user_id: Number(data.user_id),
+              width: Number(data.width),
+              height: Number(data.height),
+              x_axis: Number(data.x_axis),
+              y_axis: Number(data.y_axis),
+            },
+          })
+          if (typeof onCreated === 'function') {
+            onCreated(createdData as any)
+          }
+        }}
+      />
+    )
+  }
+)
+
+DashboardUserCreatePanel.displayName = 'DashboardUserCreatePanel'
+
+export default DashboardUserCreatePanel