@carlonicora/nextjs-jsonapi 1.0.3 → 1.0.5

package/src/features/notification/data/notification.interface.ts

@@ -0,0 +1,14 @@
+import { ApiDataInterface } from "../../../core";
+import { UserInterface } from "../../user";
+
+export type NotificationInput = {
+  id: string;
+  isRead: boolean;
+};
+
+export interface NotificationInterface extends ApiDataInterface {
+  get notificationType(): string;
+  get isRead(): boolean;
+
+  get actor(): UserInterface | undefined;
+}

package/src/features/notification/data/notification.service.ts

@@ -0,0 +1,34 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef } from "../../../core";
+import { NotificationInterface } from "./notification.interface";
+
+export class NotificationService extends AbstractService {
+  static async findMany(params: { isArchived?: boolean; next?: NextRef }): Promise<NotificationInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification });
+
+    if (params.isArchived) endpoint.addAdditionalParam("isArchived", "true");
+
+    return this.callApi<NotificationInterface[]>({
+      type: Modules.Notification,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async markAsRead(params: { data: any }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification });
+    await this.callApi({
+      type: Modules.Notification,
+      method: HttpMethod.PATCH,
+      endpoint: endpoint.generate(),
+      input: params.data,
+      overridesJsonApiCreation: true,
+    });
+  }
+
+  static async archive(params: { id: string }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification, id: params.id, childEndpoint: "archive" });
+
+    await this.callApi({ type: Modules.Notification, method: HttpMethod.POST, endpoint: endpoint.generate() });
+  }
+}

package/src/features/notification/data/notification.ts

@@ -0,0 +1,51 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { UserInterface } from "../../user";
+import { NotificationInput, NotificationInterface } from "./notification.interface";
+
+export class Notification extends AbstractApiData implements NotificationInterface {
+  private _notificationType?: string;
+  private _isRead?: boolean;
+
+  private _actor?: UserInterface;
+
+  get notificationType(): string {
+    if (this._notificationType === undefined) throw new Error("notificationType is not set");
+    return this._notificationType;
+  }
+
+  get isRead(): boolean {
+    return this._isRead === undefined ? false : this._isRead;
+  }
+
+  get actor(): UserInterface | undefined {
+    return this._actor;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._notificationType = data.jsonApi.attributes.notificationType;
+    this._isRead = data.jsonApi.attributes.isRead;
+
+    this._actor = this._readIncluded(data, "actor", Modules.User) as UserInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: NotificationInput) {
+    const response: any = {
+      data: {
+        type: Modules.Notification.name,
+        id: data.id,
+        attributes: {
+          isRead: data.isRead,
+        },
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    return response;
+  }
+}

package/src/features/notification/index.ts

@@ -0,0 +1,2 @@
+export * from "./notification.module";
+export * from "./data";

package/src/features/notification/notification.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Notification } from "./data/notification";
+
+export const NotificationModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/notifications",
+    name: "notifications",
+    model: Notification,
+    moduleId: "9259d704-c670-4e77-a3a1-a728ffc5be3d",
+  });

package/src/features/push/data/index.ts

@@ -0,0 +1,3 @@
+export * from "./push";
+export * from "./push.interface";
+export * from "./push.service";

package/src/features/push/data/push.interface.ts

@@ -0,0 +1,8 @@
+import { ApiDataInterface } from "../../../core";
+
+export type PushInput = {
+  key: string;
+  contentType?: string;
+};
+
+export interface PushInterface extends ApiDataInterface {}

package/src/features/push/data/push.service.ts

@@ -0,0 +1,17 @@
+import { AbstractService, HttpMethod } from "../../../core";
+import { EndpointCreator } from "../../../core";
+import { Modules } from "../../../core";
+
+export class PushService extends AbstractService {
+  static async register(params: { data: any }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Push });
+
+    await this.callApi({
+      type: Modules.Push,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+      input: params.data,
+      overridesJsonApiCreation: true,
+    });
+  }
+}

package/src/features/push/data/push.ts

@@ -0,0 +1,18 @@
+import { AbstractApiData, Modules } from "../../../core";
+import { PushInput, PushInterface } from "./push.interface";
+
+export class Push extends AbstractApiData implements PushInterface {
+  createJsonApi(data: PushInput) {
+    const response: any = {
+      data: {
+        type: Modules.Push.name,
+        attributes: {
+          key: data.key,
+        },
+      },
+      included: [],
+    };
+
+    return response;
+  }
+}

package/src/features/push/index.ts

@@ -0,0 +1,2 @@
+export * from "./push.module";
+export * from "./data";

package/src/features/push/push.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Push } from "./data/push";
+
+export const PushModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/push",
+    name: "push",
+    model: Push,
+    moduleId: "",
+  });

package/src/features/role/components/containers/RoleContainer.tsx

@@ -0,0 +1,18 @@
+"use client";
+
+import { RoleUsersList } from "../../../user/components/lists/RoleUsersList";
+import { useRoleContext } from "../../contexts";
+import { RoleDetails } from "../details";
+
+export function RoleContainer() {
+  const { role } = useRoleContext();
+
+  if (!role) return null;
+
+  return (
+    <>
+      <RoleDetails />
+      <RoleUsersList role={role} />
+    </>
+  );
+}

package/src/features/role/components/containers/index.ts

@@ -0,0 +1 @@
+export * from "./RoleContainer";

package/src/features/role/components/details/RoleDetails.tsx

@@ -0,0 +1,21 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { AttributeElement } from "../../../../components";
+import { Card, CardContent } from "../../../../shadcnui";
+import { useRoleContext } from "../../contexts";
+
+export function RoleDetails() {
+  const { role } = useRoleContext();
+  const t = useTranslations();
+
+  if (!role) return null;
+
+  return (
+    <Card className="w-full">
+      <CardContent className="p-4">
+        <AttributeElement title={t(`foundations.role.fields.description.label`)} value={role.description} />
+      </CardContent>
+    </Card>
+  );
+}

package/src/features/role/components/details/index.ts

@@ -0,0 +1 @@
+export * from "./RoleDetails";

package/src/features/role/components/forms/FormRoles.tsx

@@ -0,0 +1,82 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import {
+  Checkbox,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "../../../../shadcnui";
+import { UserInterface } from "../../../user";
+import { useCurrentUserContext } from "../../../user/contexts";
+import { RoleInterface } from "../../data";
+
+type FormRolesProps = {
+  form: any;
+  id: string;
+  name: string;
+  roles: RoleInterface[];
+};
+
+export function FormRoles({ form, id, name, roles }: FormRolesProps) {
+  const t = useTranslations();
+  const { hasAccesToFeature } = useCurrentUserContext<UserInterface>();
+
+  return (
+    <div className="flex w-full flex-col">
+      <FormField
+        control={form.control}
+        name={id}
+        render={({ field }) => (
+          <FormItem className={`${name ? "mb-5" : "mb-1"}`}>
+            <FormControl>
+              <div>
+                <div className="text-sm font-semibold">{name}</div>
+                {roles
+                  .filter((role: RoleInterface) => role.isSelectable)
+                  .sort((a: RoleInterface, b: RoleInterface) => a.name.localeCompare(b.name))
+                  .map((role: RoleInterface) => {
+                    if (role.requiredFeature && !hasAccesToFeature(role.requiredFeature.id)) return null;
+
+                    return (
+                      <div key={role.id}>
+                        <Checkbox
+                          defaultChecked={(field.value as string[]).some((roleId: string) => roleId === role.id)}
+                          onCheckedChange={(checked) => {
+                            if (checked) {
+                              form.setValue(id, [...(field.value as string[]), role.id]);
+                            } else {
+                              form.setValue(
+                                id,
+                                (field.value as string[]).filter((roleId: string) => roleId !== role.id),
+                              );
+                            }
+                          }}
+                        />
+                        <Tooltip>
+                          <TooltipTrigger asChild>
+                            <FormLabel className="ml-3 font-normal">
+                              {t(`foundations.role.roles`, { role: role.id.replaceAll(`-`, ``) })}
+                            </FormLabel>
+                          </TooltipTrigger>
+                          <TooltipContent>
+                            {t(`foundations.role.roles_descriptions`, { role: role.id.replaceAll(`-`, ``) })}
+                          </TooltipContent>
+                        </Tooltip>
+                      </div>
+                    );
+                  })}
+              </div>
+            </FormControl>
+            <FormMessage />
+          </FormItem>
+        )}
+      />
+    </div>
+  );
+}

package/src/features/role/components/forms/RemoveUserFromRole.tsx

@@ -0,0 +1,108 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { useEffect, useState } from "react";
+import { errorToast } from "../../../../components";
+import { getRoleId } from "../../../../roles";
+import {
+  Button,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "../../../../shadcnui";
+import { UserInterface, UserService } from "../../../user";
+import { RoleInterface, RoleService } from "../../data";
+
+type RemoveUserFromRoleProps = {
+  user: UserInterface;
+  role: RoleInterface;
+  refresh: () => Promise<void>;
+};
+
+export function RemoveUserFromRole({ role, user, refresh }: RemoveUserFromRoleProps) {
+  const [open, setOpen] = useState<boolean>(false);
+  const [canRemove, setCanRemove] = useState<boolean>(false);
+  const t = useTranslations();
+
+  useEffect(() => {
+    async function checkCompanyAdminDeletability(): Promise<void> {
+      const roleUsers = await UserService.findAllUsersByRole({
+        roleId: role.id,
+      });
+
+      if (roleUsers.length > 1) setCanRemove(true);
+    }
+
+    if (role.id !== getRoleId().CompanyAdministrator) {
+      setCanRemove(true);
+      return;
+    }
+
+    checkCompanyAdminDeletability();
+  }, [role]);
+
+  const remove = async () => {
+    try {
+      await RoleService.removeUserFromRole({
+        roleId: role.id,
+        userId: user.id,
+      });
+
+      setOpen(false);
+      refresh();
+    } catch (error) {
+      errorToast({ title: t(`generic.errors.error`), error: error });
+    }
+  };
+
+  const roleName = t(`foundations.role.roles`, { role: role.id.replaceAll(`-`, ``) });
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger
+        onClick={(e) => {
+          e.stopPropagation();
+          e.preventDefault();
+          setOpen(true);
+        }}
+      >
+        <span className="hover:text-destructive cursor-pointer">{t(`foundations.role.remove_user.title`)}</span>
+      </DialogTrigger>
+      <DialogContent className={`flex max-h-[70vh] max-w-3xl flex-col overflow-y-auto`}>
+        <DialogHeader>
+          <DialogTitle>{t(`foundations.role.remove_user.title`)}</DialogTitle>
+          <DialogDescription>
+            {canRemove
+              ? t(`foundations.role.remove_user.subtitle_allowed`)
+              : t(`foundations.role.remove_user.subtitle_not_allowed`)}
+          </DialogDescription>
+        </DialogHeader>
+        {canRemove ? (
+          <>
+            {t(`foundations.role.remove_user.description_allowed`, { role: roleName, user: user.name })}
+            <div className="flex justify-end">
+              <Button className="mr-2" variant={"outline"} type={`button`} onClick={() => setOpen(false)}>
+                {t(`generic.buttons.cancel`)}
+              </Button>
+              <Button
+                type="submit"
+                onClick={(e) => {
+                  e.preventDefault();
+                  remove();
+                }}
+                variant={"destructive"}
+              >
+                {t(`generic.buttons.confirm_delete`)}
+              </Button>
+            </div>
+          </>
+        ) : (
+          <>{t(`foundations.role.remove_user.description_not_allowed`, { role: roleName, user: user.name })}</>
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/features/role/components/forms/UserRoleAdd.tsx

@@ -0,0 +1,128 @@
+"use client";
+
+import { PlusCircle } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+import { useDebounce } from "../../../../hooks";
+import {
+  Button,
+  Command,
+  CommandDialog,
+  CommandEmpty,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  DialogDescription,
+  DialogTitle,
+} from "../../../../shadcnui";
+import { UserInterface } from "../../../user";
+import { RoleInterface, RoleService } from "../../data";
+
+type UserRoleAddProps = {
+  user: UserInterface;
+  refresh: () => Promise<void>;
+};
+
+export function UserRoleAdd({ user, refresh }: UserRoleAddProps) {
+  const [open, setOpen] = useState<boolean>(false);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const [searchTerm, setSearchTerm] = useState<string>("");
+  const [roles, setRoles] = useState<RoleInterface[]>([]);
+  const t = useTranslations();
+
+  const addUserToRole = async (role: RoleInterface) => {
+    await RoleService.addUserToRole({
+      roleId: role.id,
+      userId: user.id,
+    });
+    setRoles(roles.filter((u) => u.id !== role.id));
+
+    toast.message(
+      t(`generic.association.label`, {
+        source: t(`types.roles`, { count: 1 }),
+        destination: t(`types.users`, { count: 1 }),
+      }),
+      {
+        description: t(`generic.association.success`, {
+          source: t(`types.roles`, { count: 1 }),
+          destination: t(`types.users`, { count: 1 }),
+          source_name: role.name,
+          destination_name: user.name,
+        }),
+      },
+    );
+
+    refresh();
+  };
+
+  const searchRoles = useCallback(
+    async (term: string) => {
+      setRoles(
+        await RoleService.findAllRolesUserNotIn({
+          search: term,
+          userId: user.id,
+        }),
+      );
+    },
+    [searchTerm, user],
+  );
+
+  const updateSearchTerm = useDebounce(searchRoles, 500);
+
+  useEffect(() => {
+    if (open) updateSearchTerm(searchTerm);
+  }, [open, searchTerm]);
+
+  useEffect(() => {
+    if (open) searchRoles("");
+  }, [open]);
+
+  return (
+    <>
+      <Button size="sm" onClick={() => setOpen(true)}>
+        <PlusCircle className="mr-3 h-3.5 w-3.5" />
+        {t(`generic.association.label`, {
+          source: t(`types.roles`, { count: 1 }),
+          destination: t(`types.users`, { count: 1 }),
+        })}
+      </Button>
+      <CommandDialog open={open} onOpenChange={setOpen}>
+        <DialogTitle>
+          {t(`generic.association.label`, {
+            source: t(`types.roles`, { count: 1 }),
+            destination: t(`types.users`, { count: 1 }),
+          })}
+        </DialogTitle>
+        <DialogDescription>
+          {t(`generic.association.description`, {
+            source: t(`types.roles`, { count: 1 }),
+            destination: t(`types.users`, { count: 1 }),
+            destination_name: user.name,
+          })}
+        </DialogDescription>
+        <Command shouldFilter={false}>
+          <CommandInput
+            placeholder={t(`generic.search.placeholder`, { type: t(`types.roles`, { count: 1 }) })}
+            value={searchTerm}
+            onValueChange={setSearchTerm}
+            ref={inputRef}
+          />
+          <CommandList className="mt-3 h-auto max-h-96 min-h-96 max-w-full overflow-x-hidden overflow-y-auto">
+            <CommandEmpty>{t(`generic.search.no_results`, { type: t(`types.roles`, { count: 1 }) })}</CommandEmpty>
+            {roles.map((role: RoleInterface) => (
+              <CommandItem
+                className="cursor-pointer"
+                key={role.id}
+                onSelect={() => addUserToRole(role)}
+                onClick={() => addUserToRole(role)}
+              >
+                {t(`foundations.role.roles`, { role: role.id.replaceAll(`-`, ``) })}
+              </CommandItem>
+            ))}
+          </CommandList>
+        </Command>
+      </CommandDialog>
+    </>
+  );
+}

package/src/features/role/components/forms/index.ts

@@ -0,0 +1,3 @@
+export * from "./FormRoles";
+export * from "./RemoveUserFromRole";
+export * from "./UserRoleAdd";

package/src/features/role/components/index.ts

@@ -0,0 +1,4 @@
+export * from "./containers";
+export * from "./details";
+export * from "./forms";
+export * from "./lists";

package/src/features/role/components/lists/RolesList.tsx

@@ -0,0 +1,27 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { ContentListTable } from "../../../../components";
+import { Modules } from "../../../../core";
+import { DataListRetriever, useDataListRetriever } from "../../../../hooks";
+import { RoleFields, RoleInterface, RoleService } from "../../data";
+import "../../hooks/useRoleTableStructure";
+
+export function RolesList() {
+  const t = useTranslations();
+
+  const data: DataListRetriever<RoleInterface> = useDataListRetriever({
+    retriever: (params) => RoleService.findAllRoles(params),
+    retrieverParams: {},
+    module: Modules.Role,
+  });
+
+  return (
+    <ContentListTable
+      data={data}
+      fields={[RoleFields.name, RoleFields.description]}
+      tableGeneratorType={Modules.Role}
+      title={t(`types.roles`, { count: 2 })}
+    />
+  );
+}

package/src/features/role/components/lists/UserRolesList.tsx

@@ -0,0 +1,31 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { ContentListTable } from "../../../../components";
+import { Modules } from "../../../../core";
+import { DataListRetriever, useDataListRetriever } from "../../../../hooks";
+import { UserInterface } from "../../../user";
+import { RoleFields, RoleInterface, RoleService } from "../../data";
+
+type UserRolesListProps = {
+  user: UserInterface;
+};
+
+export function UserRolesList({ user }: UserRolesListProps) {
+  const t = useTranslations();
+
+  const data: DataListRetriever<RoleInterface> = useDataListRetriever({
+    retriever: (params) => RoleService.findAllRolesByUser(params),
+    retrieverParams: { userId: user.id },
+    module: Modules.Role,
+  });
+
+  return (
+    <ContentListTable
+      data={data}
+      fields={[RoleFields.name, RoleFields.description]}
+      tableGeneratorType={Modules.Role}
+      title={t(`types.roles`, { count: 2 })}
+    />
+  );
+}

package/src/features/role/components/lists/index.ts

@@ -0,0 +1,2 @@
+export * from "./RolesList";
+export * from "./UserRolesList";