@hed-hog/lms 0.0.358 → 0.0.364

package/hedhog/frontend/app/xp/skills/page.tsx.ejs

@@ -0,0 +1,811 @@
+'use client';
+
+import {
+  EmptyState,
+  Page,
+  PageHeader,
+  PaginationFooter,
+  SearchBar,
+} from '@/components/entity-list';
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from '@/components/ui/alert-dialog';
+import { Badge } from '@/components/ui/badge';
+import { Button } from '@/components/ui/button';
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '@/components/ui/form';
+import { IconActionGroup } from '@/components/ui/icon-action-group';
+import { Input } from '@/components/ui/input';
+import { KpiCardsGrid } from '@/components/ui/kpi-cards-grid';
+import { ResizableSheetContent } from '@/components/ui/resizable-sheet-content';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { Sheet, SheetHeader, SheetTitle } from '@/components/ui/sheet';
+import { Skeleton } from '@/components/ui/skeleton';
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table';
+import { Textarea } from '@/components/ui/textarea';
+import { usePersistedPageSize } from '@/hooks/use-persisted-page-size';
+import { cn } from '@/lib/utils';
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+import { zodResolver } from '@hookform/resolvers/zod';
+import {
+  CheckCircle2,
+  Code2,
+  Link2Off,
+  Pencil,
+  Plus,
+  Trash2,
+  XCircle,
+} from 'lucide-react';
+import { useTranslations } from 'next-intl';
+import { useEffect, useMemo, useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { toast } from 'sonner';
+import * as z from 'zod';
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+type XpAreaOption = {
+  id: number;
+  slug: string;
+  name: string;
+};
+
+type XpSkill = {
+  id: number;
+  slug: string;
+  status: 'active' | 'inactive';
+  sortOrder: number;
+  xpAreaId: number | null;
+  name: string;
+};
+
+type XpSkillDetail = {
+  id: number;
+  slug: string;
+  status: 'active' | 'inactive';
+  sortOrder: number;
+  xpAreaId: number | null;
+  translations: Record<string, { name: string; description: string | null }>;
+};
+
+type PaginatedResult<T> = {
+  data: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  lastPage?: number;
+};
+
+// ─── Zod schema ───────────────────────────────────────────────────────────────
+
+const createSchema = (t: ReturnType<typeof useTranslations>) =>
+  z.object({
+    slug: z
+      .string()
+      .min(1, t('form.validation.required'))
+      .max(100, t('form.validation.max100'))
+      .regex(/^[a-z0-9-]+$/, t('form.validation.slugPattern')),
+    namePt: z.string().min(1, t('form.validation.required')),
+    nameEn: z.string().min(1, t('form.validation.required')),
+    descriptionPt: z.string().optional(),
+    descriptionEn: z.string().optional(),
+    xpAreaId: z.coerce.number().int().positive().nullable().optional(),
+    sortOrder: z.coerce.number().int().min(0).default(0),
+    status: z.enum(['active', 'inactive']),
+  });
+
+type SkillFormValues = z.infer<ReturnType<typeof createSchema>>;
+
+// ─── SkillFormSheet ────────────────────────────────────────────────────────────
+
+interface SkillFormSheetProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  skillToEdit: XpSkill | null;
+  areas: XpAreaOption[];
+  onSaved: () => void;
+}
+
+function SkillFormSheet({
+  open,
+  onOpenChange,
+  skillToEdit,
+  areas,
+  onSaved,
+}: SkillFormSheetProps) {
+  const { request } = useApp();
+  const t = useTranslations('lms.XpSkillsPage');
+  const [isSaving, setIsSaving] = useState(false);
+  const [isLoadingDetail, setIsLoadingDetail] = useState(false);
+
+  const form = useForm<SkillFormValues>({
+    resolver: zodResolver(createSchema(t)),
+    defaultValues: {
+      slug: '',
+      namePt: '',
+      nameEn: '',
+      descriptionPt: '',
+      descriptionEn: '',
+      xpAreaId: null,
+      sortOrder: 0,
+      status: 'active',
+    },
+  });
+
+  useEffect(() => {
+    if (!open) return;
+
+    if (skillToEdit) {
+      setIsLoadingDetail(true);
+      request<{ data: XpSkillDetail }>({
+        url: `/lms/xp/skills/${skillToEdit.id}`,
+        method: 'GET',
+      })
+        .then((res) => {
+          const d = res.data as unknown as XpSkillDetail;
+          form.reset({
+            slug: d.slug,
+            namePt: d.translations?.pt?.name ?? '',
+            nameEn: d.translations?.en?.name ?? '',
+            descriptionPt: d.translations?.pt?.description ?? '',
+            descriptionEn: d.translations?.en?.description ?? '',
+            xpAreaId: d.xpAreaId ?? null,
+            sortOrder: d.sortOrder ?? 0,
+            status: d.status,
+          });
+        })
+        .catch(() => toast.error(t('messages.saveError')))
+        .finally(() => setIsLoadingDetail(false));
+    } else {
+      form.reset({
+        slug: '',
+        namePt: '',
+        nameEn: '',
+        descriptionPt: '',
+        descriptionEn: '',
+        xpAreaId: null,
+        sortOrder: 0,
+        status: 'active',
+      });
+    }
+  }, [open, skillToEdit]);
+
+  const onSubmit = async (values: SkillFormValues) => {
+    try {
+      setIsSaving(true);
+      const payload = {
+        slug: values.slug,
+        namePt: values.namePt,
+        nameEn: values.nameEn,
+        descriptionPt: values.descriptionPt || null,
+        descriptionEn: values.descriptionEn || null,
+        xpAreaId: values.xpAreaId ?? null,
+        sortOrder: values.sortOrder,
+        status: values.status,
+      };
+
+      if (skillToEdit) {
+        await request({
+          url: `/lms/xp/skills/${skillToEdit.id}`,
+          method: 'PATCH',
+          data: payload,
+        });
+        toast.success(t('messages.updateSuccess'));
+      } else {
+        await request({
+          url: '/lms/xp/skills',
+          method: 'POST',
+          data: payload,
+        });
+        toast.success(t('messages.createSuccess'));
+      }
+
+      onSaved();
+      onOpenChange(false);
+    } catch {
+      toast.error(t('messages.saveError'));
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  return (
+    <Sheet open={open} onOpenChange={onOpenChange}>
+      <ResizableSheetContent
+        sheetId="lms-xp-skills-form-sheet"
+        defaultWidth={620}
+        minWidth={420}
+        maxWidth={900}
+        className="overflow-y-auto"
+      >
+        <SheetHeader>
+          <SheetTitle>
+            {skillToEdit ? t('sheet.editTitle') : t('sheet.createTitle')}
+          </SheetTitle>
+        </SheetHeader>
+
+        {isLoadingDetail ? (
+          <div className="space-y-3 p-4">
+            {Array.from({ length: 5 }).map((_, i) => (
+              <Skeleton key={i} className="h-10 w-full" />
+            ))}
+          </div>
+        ) : (
+          <Form {...form}>
+            <form
+              onSubmit={form.handleSubmit(onSubmit)}
+              className="flex flex-col gap-4 px-4 py-4"
+            >
+              <div className="grid grid-cols-2 gap-4">
+                <FormField
+                  control={form.control}
+                  name="slug"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.slug')}</FormLabel>
+                      <FormControl>
+                        <Input
+                          placeholder={t('form.slugPlaceholder')}
+                          {...field}
+                        />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+
+                <FormField
+                  control={form.control}
+                  name="status"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.status')}</FormLabel>
+                      <Select
+                        onValueChange={field.onChange}
+                        value={field.value}
+                      >
+                        <FormControl>
+                          <SelectTrigger className="w-full">
+                            <SelectValue
+                              placeholder={t('form.statusPlaceholder')}
+                            />
+                          </SelectTrigger>
+                        </FormControl>
+                        <SelectContent>
+                          <SelectItem value="active">
+                            {t('status.active')}
+                          </SelectItem>
+                          <SelectItem value="inactive">
+                            {t('status.inactive')}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+              </div>
+
+              <div className="grid grid-cols-2 gap-4">
+                <FormField
+                  control={form.control}
+                  name="namePt"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.namePt')}</FormLabel>
+                      <FormControl>
+                        <Input
+                          placeholder={t('form.namePtPlaceholder')}
+                          {...field}
+                        />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+
+                <FormField
+                  control={form.control}
+                  name="nameEn"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.nameEn')}</FormLabel>
+                      <FormControl>
+                        <Input
+                          placeholder={t('form.nameEnPlaceholder')}
+                          {...field}
+                        />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+              </div>
+
+              <div className="grid grid-cols-2 gap-4">
+                <FormField
+                  control={form.control}
+                  name="descriptionPt"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.descriptionPt')}</FormLabel>
+                      <FormControl>
+                        <Textarea
+                          rows={3}
+                          placeholder={t('form.descriptionPtPlaceholder')}
+                          {...field}
+                        />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+
+                <FormField
+                  control={form.control}
+                  name="descriptionEn"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.descriptionEn')}</FormLabel>
+                      <FormControl>
+                        <Textarea
+                          rows={3}
+                          placeholder={t('form.descriptionEnPlaceholder')}
+                          {...field}
+                        />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+              </div>
+
+              <div className="grid grid-cols-2 gap-4">
+                <FormField
+                  control={form.control}
+                  name="xpAreaId"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.area')}</FormLabel>
+                      <Select
+                        onValueChange={(val) =>
+                          field.onChange(
+                            val === '__none__' ? null : Number(val)
+                          )
+                        }
+                        value={
+                          field.value != null ? String(field.value) : '__none__'
+                        }
+                      >
+                        <FormControl>
+                          <SelectTrigger className="w-full">
+                            <SelectValue
+                              placeholder={t('form.areaPlaceholder')}
+                            />
+                          </SelectTrigger>
+                        </FormControl>
+                        <SelectContent>
+                          <SelectItem value="__none__">
+                            {t('form.areaNone')}
+                          </SelectItem>
+                          {areas.map((a) => (
+                            <SelectItem key={a.id} value={String(a.id)}>
+                              {a.name}
+                            </SelectItem>
+                          ))}
+                        </SelectContent>
+                      </Select>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+
+                <FormField
+                  control={form.control}
+                  name="sortOrder"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t('form.sortOrder')}</FormLabel>
+                      <FormControl>
+                        <Input type="number" min={0} {...field} />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+              </div>
+
+              <div className="flex justify-end gap-2 pt-2">
+                <Button
+                  type="button"
+                  variant="outline"
+                  onClick={() => onOpenChange(false)}
+                  disabled={isSaving}
+                >
+                  {t('actions.cancel')}
+                </Button>
+                <Button type="submit" disabled={isSaving}>
+                  {isSaving ? t('actions.saving') : t('actions.save')}
+                </Button>
+              </div>
+            </form>
+          </Form>
+        )}
+      </ResizableSheetContent>
+    </Sheet>
+  );
+}
+
+// ─── Page ─────────────────────────────────────────────────────────────────────
+
+export default function XpSkillsPage() {
+  const { request } = useApp();
+  const t = useTranslations('lms.XpSkillsPage');
+
+  const [page, setPage] = useState(1);
+  const [pageSize, setPageSize] = usePersistedPageSize({
+    storageKey: 'pagination:global:pageSize',
+    defaultValue: 12,
+    allowedValues: [6, 12, 24, 48],
+  });
+  const [searchInput, setSearchInput] = useState('');
+  const [debouncedSearch, setDebouncedSearch] = useState('');
+  const [sheetOpen, setSheetOpen] = useState(false);
+  const [skillToEdit, setSkillToEdit] = useState<XpSkill | null>(null);
+  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+  const [skillToDelete, setSkillToDelete] = useState<XpSkill | null>(null);
+  const [isDeleting, setIsDeleting] = useState(false);
+
+  useEffect(() => {
+    const timeout = setTimeout(() => {
+      setDebouncedSearch(searchInput.trim());
+      setPage(1);
+    }, 300);
+    return () => clearTimeout(timeout);
+  }, [searchInput]);
+
+  const { data: statsData, refetch: refetchStats } = useQuery<{
+    total: number;
+    active: number;
+    inactive: number;
+    unassigned: number;
+  }>({
+    queryKey: ['lms-xp-skills-stats'],
+    queryFn: async () => {
+      const response = await request<{
+        total: number;
+        active: number;
+        inactive: number;
+        unassigned: number;
+      }>({
+        url: '/lms/xp/skills/stats',
+        method: 'GET',
+      });
+      return response.data;
+    },
+  });
+
+  const { data: areas = [] } = useQuery<XpAreaOption[]>({
+    queryKey: ['lms-xp-areas-all'],
+    queryFn: async () => {
+      const res = await request<XpAreaOption[]>({
+        url: '/lms/xp/areas/all',
+        method: 'GET',
+      });
+      return res.data;
+    },
+    placeholderData: [],
+  });
+
+  const areaMap = useMemo(() => {
+    const map = new Map<number, string>();
+    for (const a of areas) map.set(a.id, a.name);
+    return map;
+  }, [areas]);
+
+  const {
+    data: paginate = { data: [], total: 0, page: 1, pageSize, lastPage: 1 },
+    isLoading,
+    refetch: refetchList,
+  } = useQuery<PaginatedResult<XpSkill>>({
+    queryKey: ['lms-xp-skills', page, pageSize, debouncedSearch],
+    queryFn: async () => {
+      const params = new URLSearchParams({
+        page: String(page),
+        pageSize: String(pageSize),
+      });
+      if (debouncedSearch) params.set('search', debouncedSearch);
+      const response = await request<PaginatedResult<XpSkill>>({
+        url: `/lms/xp/skills?${params.toString()}`,
+        method: 'GET',
+      });
+      return response.data;
+    },
+    placeholderData: (prev) =>
+      prev ?? { data: [], total: 0, page: 1, pageSize, lastPage: 1 },
+  });
+
+  const totalPages = Math.max(
+    1,
+    (paginate.lastPage ?? Math.ceil((paginate.total || 0) / pageSize)) || 1
+  );
+
+  useEffect(() => {
+    if (page > totalPages) setPage(totalPages);
+  }, [page, totalPages]);
+
+  const openCreateSheet = () => {
+    setSkillToEdit(null);
+    setSheetOpen(true);
+  };
+
+  const openEditSheet = (skill: XpSkill) => {
+    setSkillToEdit(skill);
+    setSheetOpen(true);
+  };
+
+  const handleDeleteConfirm = async () => {
+    if (!skillToDelete) return;
+    try {
+      setIsDeleting(true);
+      await request({
+        url: `/lms/xp/skills/${skillToDelete.id}`,
+        method: 'DELETE',
+      });
+      toast.success(t('messages.deleteSuccess'));
+      setDeleteDialogOpen(false);
+      setSkillToDelete(null);
+      await Promise.all([refetchList(), refetchStats()]);
+    } catch {
+      toast.error(t('messages.deleteError'));
+    } finally {
+      setIsDeleting(false);
+    }
+  };
+
+  return (
+    <Page>
+      <PageHeader
+        breadcrumbs={[
+          { label: t('breadcrumbs.home'), href: '/' },
+          { label: t('breadcrumbs.lms'), href: '/lms' },
+          { label: t('breadcrumbs.xp'), href: '/lms/xp' },
+          { label: t('breadcrumbs.current') },
+        ]}
+        title={t('title')}
+        description={t('description')}
+        actions={[
+          {
+            label: t('actions.create'),
+            onClick: openCreateSheet,
+            icon: <Plus className="h-4 w-4" />,
+          },
+        ]}
+      />
+
+      <KpiCardsGrid
+        columns={4}
+        items={[
+          {
+            key: 'total',
+            title: t('kpis.total.label'),
+            value: statsData?.total ?? 0,
+            description: t('kpis.total.description'),
+            icon: Code2,
+            accentClassName: 'from-sky-500/20 via-blue-400/10 to-transparent',
+            iconContainerClassName: 'bg-sky-50 text-sky-700',
+            layout: 'compact',
+          },
+          {
+            key: 'active',
+            title: t('kpis.active.label'),
+            value: statsData?.active ?? 0,
+            description: t('kpis.active.description'),
+            icon: CheckCircle2,
+            accentClassName:
+              'from-emerald-500/20 via-green-400/10 to-transparent',
+            iconContainerClassName: 'bg-emerald-50 text-emerald-700',
+            layout: 'compact',
+          },
+          {
+            key: 'inactive',
+            title: t('kpis.inactive.label'),
+            value: statsData?.inactive ?? 0,
+            description: t('kpis.inactive.description'),
+            icon: XCircle,
+            accentClassName:
+              'from-amber-500/20 via-orange-400/10 to-transparent',
+            iconContainerClassName: 'bg-amber-50 text-amber-700',
+            layout: 'compact',
+          },
+          {
+            key: 'unassigned',
+            title: t('kpis.unassigned.label'),
+            value: statsData?.unassigned ?? 0,
+            description: t('kpis.unassigned.description'),
+            icon: Link2Off,
+            accentClassName: 'from-rose-500/20 via-red-400/10 to-transparent',
+            iconContainerClassName: 'bg-rose-50 text-rose-700',
+            layout: 'compact',
+          },
+        ]}
+      />
+
+      <SearchBar
+        searchQuery={searchInput}
+        onSearchChange={setSearchInput}
+        onSearch={() => setPage(1)}
+        placeholder={t('filters.searchPlaceholder')}
+      />
+
+      {isLoading ? (
+        <div className="space-y-3 p-4">
+          {Array.from({ length: 6 }).map((_, i) => (
+            <Skeleton key={i} className="h-14 w-full" />
+          ))}
+        </div>
+      ) : paginate.data.length === 0 ? (
+        <EmptyState
+          icon={<Code2 className="h-12 w-12" />}
+          title={t('empty.title')}
+          description={t('empty.description')}
+          actionLabel={t('actions.create')}
+          actionIcon={<Plus className="mr-2 h-4 w-4" />}
+          onAction={openCreateSheet}
+        />
+      ) : (
+        <div className="overflow-x-auto">
+          <Table>
+            <TableHeader>
+              <TableRow>
+                <TableHead>{t('table.name')}</TableHead>
+                <TableHead>{t('table.slug')}</TableHead>
+                <TableHead>{t('table.area')}</TableHead>
+                <TableHead>{t('table.status')}</TableHead>
+                <TableHead className="w-10" />
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {paginate.data.map((skill) => (
+                <TableRow
+                  key={skill.id}
+                  className="cursor-pointer"
+                  onDoubleClick={() => openEditSheet(skill)}
+                >
+                  <TableCell className="font-medium">{skill.name}</TableCell>
+                  <TableCell>
+                    <span className="font-mono text-sm text-muted-foreground">
+                      {skill.slug}
+                    </span>
+                  </TableCell>
+                  <TableCell>
+                    {skill.xpAreaId ? (
+                      <span className="text-sm text-muted-foreground">
+                        {areaMap.get(skill.xpAreaId) ?? `#${skill.xpAreaId}`}
+                      </span>
+                    ) : (
+                      <span className="text-sm text-muted-foreground/40">
+                        —
+                      </span>
+                    )}
+                  </TableCell>
+                  <TableCell>
+                    <Badge
+                      variant="outline"
+                      className={cn(
+                        'border px-2.5 py-1 text-xs font-medium',
+                        skill.status === 'active'
+                          ? 'border-green-500/20 bg-green-500/10 text-green-600'
+                          : 'border-gray-500/20 bg-gray-500/10 text-gray-600'
+                      )}
+                    >
+                      {skill.status === 'active'
+                        ? t('status.active')
+                        : t('status.inactive')}
+                    </Badge>
+                  </TableCell>
+                  <TableCell>
+                    <IconActionGroup
+                      className="ml-auto"
+                      actions={[
+                        {
+                          key: 'edit',
+                          label: t('actions.edit'),
+                          icon: <Pencil className="size-4" />,
+                          onClick: () => openEditSheet(skill),
+                        },
+                        {
+                          key: 'delete',
+                          label: t('actions.delete'),
+                          icon: <Trash2 className="size-4" />,
+                          onClick: () => {
+                            setSkillToDelete(skill);
+                            setDeleteDialogOpen(true);
+                          },
+                          destructive: true,
+                        },
+                      ]}
+                    />
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        </div>
+      )}
+
+      <PaginationFooter
+        currentPage={page}
+        pageSize={pageSize}
+        totalItems={paginate.total}
+        onPageChange={setPage}
+        onPageSizeChange={(next) => {
+          setPageSize(next);
+          setPage(1);
+        }}
+        pageSizeOptions={[6, 12, 24, 48]}
+      />
+
+      <SkillFormSheet
+        open={sheetOpen}
+        onOpenChange={setSheetOpen}
+        skillToEdit={skillToEdit}
+        areas={areas}
+        onSaved={() => {
+          refetchList();
+          refetchStats();
+        }}
+      />
+
+      <AlertDialog open={deleteDialogOpen} onOpenChange={setDeleteDialogOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>{t('deleteDialog.title')}</AlertDialogTitle>
+            <AlertDialogDescription>
+              {t('deleteDialog.description', {
+                slug: skillToDelete?.slug ?? '',
+              })}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <div className="flex justify-end gap-2">
+            <AlertDialogCancel disabled={isDeleting}>
+              {t('actions.cancel')}
+            </AlertDialogCancel>
+            <AlertDialogAction
+              onClick={handleDeleteConfirm}
+              disabled={isDeleting}
+              className="bg-red-600 hover:bg-red-700"
+            >
+              {isDeleting ? t('actions.deleting') : t('actions.delete')}
+            </AlertDialogAction>
+          </div>
+        </AlertDialogContent>
+      </AlertDialog>
+    </Page>
+  );
+}