@controleonline/ui-customers 1.0.81

package/src/react/components/tabs/salesmanTabSession.js

@@ -0,0 +1,39 @@
+import { app_type } from '@appType';
+
+const resolveAppType = () => {
+  // MANAGER is normally defined by the build. localStorage is only populated
+  // when an ADMIN build lets the user switch views, so it cannot be the source
+  // of truth for regular MANAGER deployments.
+  if (app_type) {
+    return String(app_type).trim();
+  }
+  try {
+    if (typeof localStorage !== 'undefined') {
+      return String(localStorage.getItem('app-type') || '').trim();
+    }
+  } catch (_) {
+    /* noop */
+  }
+  return '';
+};
+
+const resolveSessionUser = authStore => {
+  const fromStore = authStore?.getters?.user || authStore?.state?.user;
+  if (fromStore && typeof fromStore === 'object') {
+    return fromStore;
+  }
+  try {
+    if (typeof localStorage !== 'undefined') {
+      const raw = localStorage.getItem('session');
+      if (raw) {
+        return JSON.parse(raw);
+      }
+    }
+  } catch (_) {
+    /* noop */
+  }
+  return null;
+};
+
+
+export { resolveAppType, resolveSessionUser };

package/src/react/components/tabs/useEmployeeUnlink.js

@@ -0,0 +1,58 @@
+import {useCallback} from 'react';
+import {
+  confirmEmployeeRemoval,
+  extractEmployeeUnlinkIds,
+  filterEmployeesAfterUnlink,
+  removeEmployeeFromCompany,
+} from './employeeUnlink';
+
+export const useEmployeeUnlink = ({
+  removePeople,
+  removePeopleLink,
+  showDialog,
+  showError,
+  showSuccess,
+  setEmployees,
+}) => {
+  const handleRemoveEmployee = useCallback(
+    employee => {
+      const ids = extractEmployeeUnlinkIds(employee);
+      if (!ids.peopleId && !ids.linkId) {
+        showError?.('Não foi possível identificar o colaborador para remover.');
+        return;
+      }
+
+      confirmEmployeeRemoval({
+        showDialog,
+        onConfirm: async () => {
+          try {
+            await removeEmployeeFromCompany({
+              ...ids,
+              removePeople,
+              removePeopleLink,
+            });
+            showSuccess?.('Colaborador removido com sucesso.');
+            setEmployees?.(prev => filterEmployeesAfterUnlink(prev, ids));
+          } catch (error) {
+            showError?.(
+              error?.message ||
+                'Não foi possível remover o colaborador. Verifique vínculos e tente novamente.',
+            );
+          }
+        },
+      });
+    },
+    [
+      removePeople,
+      removePeopleLink,
+      showDialog,
+      showError,
+      showSuccess,
+      setEmployees,
+    ],
+  );
+
+  return {handleRemoveEmployee};
+};
+
+export default useEmployeeUnlink;

package/src/react/components/tabs/useFranchiseLinksManage.js

@@ -0,0 +1,215 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  buildAvailableFranchiseOptions,
+  buildFranchiseLinkReadParams,
+  buildFranchiseSavePayload,
+  canManageFranchiseLinks,
+  normalizeFranchiseLink,
+  toPeopleIri,
+} from './franchiseLinksTab.helpers';
+import { extractId } from './salesmanTabHelpers';
+import { buildFranchiseLinksFromPeopleLinks } from './franchiseLinksTab.helpers';
+import { normalizeCollection } from './salesmanTabMedia';
+
+/**
+ * Administrative manage (link/edit/remove) for FranchiseLinksTab when APP_TYPE=MANAGER.
+ */
+export function useFranchiseLinksManage({
+  appType,
+  client,
+  clientId,
+  currentCompanyId,
+  links,
+  setLinks,
+  setIsLoading,
+  peopleActions,
+  getPeopleLinks,
+  savePeopleLink,
+  removePeopleLink,
+  showDialog,
+  showError,
+  showSuccess,
+}) {
+  const canManage = useMemo(() => canManageFranchiseLinks(appType), [appType]);
+  const companyIri = useMemo(() => toPeopleIri(client), [client]);
+  const [availableCandidates, setAvailableCandidates] = useState([]);
+  const [linkedNormalized, setLinkedNormalized] = useState([]);
+  const [showManageModal, setShowManageModal] = useState(false);
+  const [editingManageLink, setEditingManageLink] = useState(null);
+  const [manageForm, setManageForm] = useState({
+    linkedIri: '',
+    linkType: 'franchisee',
+    comission: '',
+    minimumComission: '',
+  });
+  const [isManageSaving, setIsManageSaving] = useState(false);
+
+  useEffect(() => {
+    setLinkedNormalized(
+      (Array.isArray(links) ? links : [])
+        .map(item => normalizeFranchiseLink(item))
+        .filter(Boolean),
+    );
+  }, [links]);
+
+  useEffect(() => {
+    let cancelled = false;
+    if (!canManage || !peopleActions?.getItems) {
+      setAvailableCandidates([]);
+      return undefined;
+    }
+    // PJ candidates only
+    peopleActions
+      .getItems({
+        peopleType: 'J',
+        itemsPerPage: 100,
+      })
+      .then(response => {
+        if (!cancelled) {
+          const items = Array.isArray(response)
+            ? response
+            : normalizeCollection(response);
+          // Exclude current client itself
+          setAvailableCandidates(
+            items.filter(
+              item => extractId(item?.id || item?.['@id']) !== String(clientId),
+            ),
+          );
+        }
+      })
+      .catch(() => {
+        if (!cancelled) setAvailableCandidates([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [canManage, peopleActions, clientId]);
+
+  const franchiseOptions = useMemo(
+    () =>
+      buildAvailableFranchiseOptions({
+        candidates: availableCandidates,
+        linkedItems: linkedNormalized,
+        editingLink: editingManageLink,
+      }),
+    [availableCandidates, linkedNormalized, editingManageLink],
+  );
+
+  const openManageModal = useCallback(link => {
+    setEditingManageLink(link || null);
+    setManageForm({
+      linkedIri: link?.linkedIri || '',
+      linkType: link?.linkType || 'franchisee',
+      comission: String(link?.comission ?? ''),
+      minimumComission: String(link?.minimumComission ?? ''),
+    });
+    setShowManageModal(true);
+  }, []);
+
+  const closeManageModal = useCallback(() => {
+    setShowManageModal(false);
+    setEditingManageLink(null);
+  }, []);
+
+  const reloadLinks = useCallback(async () => {
+    if (!getPeopleLinks || !clientId) {
+      return;
+    }
+    const response = await getPeopleLinks(buildFranchiseLinkReadParams(clientId));
+    const next = buildFranchiseLinksFromPeopleLinks(response, {
+      companyId: clientId,
+    });
+    setLinks(next);
+  }, [getPeopleLinks, clientId, setLinks]);
+
+  const handleManageSave = useCallback(async () => {
+    if (!savePeopleLink || !companyIri) {
+      showError?.('Não foi possível salvar o vínculo neste momento.');
+      return;
+    }
+    const payload = buildFranchiseSavePayload({
+      editingLink: editingManageLink,
+      formData: manageForm,
+      companyIri,
+    });
+    if (!payload) {
+      showError?.('Selecione uma pessoa jurídica e o tipo de vínculo.');
+      return;
+    }
+    setIsManageSaving(true);
+    try {
+      await savePeopleLink(payload);
+      showSuccess?.(
+        editingManageLink
+          ? 'Vínculo atualizado com sucesso!'
+          : 'Vínculo criado com sucesso!',
+      );
+      closeManageModal();
+      setIsLoading?.(true);
+      await reloadLinks();
+    } catch {
+      showError?.(
+        editingManageLink
+          ? 'Não foi possível atualizar o vínculo.'
+          : 'Não foi possível criar o vínculo.',
+      );
+    } finally {
+      setIsManageSaving(false);
+      setIsLoading?.(false);
+    }
+  }, [
+    savePeopleLink,
+    companyIri,
+    editingManageLink,
+    manageForm,
+    showError,
+    showSuccess,
+    closeManageModal,
+    setIsLoading,
+    reloadLinks,
+  ]);
+
+  const handleManageDelete = useCallback(
+    link => {
+      if (!link?.id || !removePeopleLink) {
+        showError?.('Não foi possível identificar o vínculo para remover.');
+        return;
+      }
+      showDialog?.({
+        title: 'Remover vínculo',
+        message: 'Deseja realmente remover este vínculo de franquia/filial?',
+        confirmLabel: 'Remover',
+        cancelLabel: 'Cancelar',
+        onConfirm: async () => {
+          try {
+            await removePeopleLink(link.id);
+            showSuccess?.('Vínculo removido com sucesso!');
+            setLinks(prev =>
+              (prev || []).filter(
+                item => extractId(item?.id) !== extractId(link.id),
+              ),
+            );
+          } catch {
+            showError?.('Não foi possível remover o vínculo.');
+          }
+        },
+      });
+    },
+    [removePeopleLink, showDialog, showError, showSuccess, setLinks],
+  );
+
+  return {
+    canManage,
+    linkedNormalized,
+    showManageModal,
+    editingManageLink,
+    manageForm,
+    setManageForm,
+    isManageSaving,
+    franchiseOptions,
+    openManageModal,
+    closeManageModal,
+    handleManageSave,
+    handleManageDelete,
+  };
+}

package/src/react/components/tabs/useSalesmanManage.js

@@ -0,0 +1,222 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  buildAvailableSalesmanOptions,
+  buildSalesmanSavePayload,
+  canManageSalesmen,
+  normalizeSalesmanLink,
+  toPeopleIri,
+} from './salesmanTab.helpers';
+import { extractId } from './salesmanTabHelpers';
+import {
+  buildPeopleLinkReadParams,
+  buildSalesmanLinksFromPeopleLinks,
+} from './employeeContacts';
+import { normalizeCollection } from './salesmanTabMedia';
+
+/**
+ * Administrative manage (link/edit/remove) for SalesmanTab when APP_TYPE=MANAGER.
+ */
+export function useSalesmanManage({
+  appType,
+  client,
+  clientId,
+  currentCompanyId,
+  linkType,
+  clients,
+  setClients,
+  setIsLoading,
+  peopleActions,
+  getPeopleLinks,
+  savePeopleLink,
+  removePeopleLink,
+  loadDefaultSalesmanLinks,
+  showDialog,
+  showError,
+  showSuccess,
+}) {
+  const canManage = useMemo(() => canManageSalesmen(appType), [appType]);
+  const clientIri = useMemo(() => toPeopleIri(client), [client]);
+  const [availableSalesmen, setAvailableSalesmen] = useState([]);
+  const [linkedNormalized, setLinkedNormalized] = useState([]);
+  const [showManageModal, setShowManageModal] = useState(false);
+  const [editingManageLink, setEditingManageLink] = useState(null);
+  const [manageForm, setManageForm] = useState({
+    sellerIri: '',
+    commission: '0',
+    minimumCommission: '0',
+  });
+  const [isManageSaving, setIsManageSaving] = useState(false);
+
+  useEffect(() => {
+    setLinkedNormalized(
+      (Array.isArray(clients) ? clients : [])
+        .map(item => normalizeSalesmanLink(item))
+        .filter(Boolean),
+    );
+  }, [clients]);
+
+  useEffect(() => {
+    let cancelled = false;
+    if (!canManage || !currentCompanyId || !peopleActions?.getItems) {
+      setAvailableSalesmen([]);
+      return undefined;
+    }
+    peopleActions
+      .getItems({
+        'link.company': `/people/${currentCompanyId}`,
+        'link.linkType': 'salesman',
+        peopleType: 'F',
+        itemsPerPage: 100,
+      })
+      .then(response => {
+        if (!cancelled) {
+          setAvailableSalesmen(
+            Array.isArray(response) ? response : normalizeCollection(response),
+          );
+        }
+      })
+      .catch(() => {
+        if (!cancelled) setAvailableSalesmen([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [canManage, currentCompanyId, peopleActions]);
+
+  const salesmanOptions = useMemo(
+    () =>
+      buildAvailableSalesmanOptions({
+        salesmen: availableSalesmen,
+        linkedSalesmen: linkedNormalized,
+        editingLink: editingManageLink,
+      }),
+    [availableSalesmen, linkedNormalized, editingManageLink],
+  );
+
+  const openManageModal = useCallback(link => {
+    setEditingManageLink(link || null);
+    setManageForm({
+      sellerIri: link?.sellerIri || '',
+      commission: String(link?.commission ?? 0),
+      minimumCommission: String(link?.minimumCommission ?? 0),
+    });
+    setShowManageModal(true);
+  }, []);
+
+  const closeManageModal = useCallback(() => {
+    setShowManageModal(false);
+    setEditingManageLink(null);
+  }, []);
+
+  const handleManageSave = useCallback(async () => {
+    if (!savePeopleLink || !clientIri) {
+      showError('Nao foi possivel salvar o vendedor neste momento.');
+      return;
+    }
+    const payload = buildSalesmanSavePayload({
+      editingLink: editingManageLink,
+      formData: manageForm,
+      clientIri,
+      linkType: linkType || 'sellers-client',
+    });
+    if (!payload) {
+      showError('Selecione um vendedor valido.');
+      return;
+    }
+    setIsManageSaving(true);
+    try {
+      await savePeopleLink(payload);
+      showSuccess(
+        editingManageLink
+          ? 'Vendedor atualizado com sucesso!'
+          : 'Vendedor vinculado com sucesso!',
+      );
+      closeManageModal();
+      setIsLoading(true);
+      if (getPeopleLinks && clientId) {
+        const params = buildPeopleLinkReadParams({
+          clientId,
+          linkType: linkType || 'sellers-client',
+        });
+        const items = await getPeopleLinks(params);
+        const nextClients = buildSalesmanLinksFromPeopleLinks(items, {
+          clientId,
+          linkType: linkType || 'sellers-client',
+        });
+        setClients(nextClients);
+        if (loadDefaultSalesmanLinks) {
+          await loadDefaultSalesmanLinks(
+            nextClients.map(item => item?.company?.id || item?.company?.['@id']),
+          );
+        }
+      }
+    } catch {
+      showError(
+        editingManageLink
+          ? 'Nao foi possivel atualizar o vendedor.'
+          : 'Nao foi possivel vincular o vendedor.',
+      );
+    } finally {
+      setIsManageSaving(false);
+      setIsLoading(false);
+    }
+  }, [
+    savePeopleLink,
+    clientIri,
+    editingManageLink,
+    manageForm,
+    linkType,
+    showError,
+    showSuccess,
+    closeManageModal,
+    setIsLoading,
+    getPeopleLinks,
+    clientId,
+    setClients,
+    loadDefaultSalesmanLinks,
+  ]);
+
+  const handleManageDelete = useCallback(
+    link => {
+      if (!link?.id || !removePeopleLink) {
+        showError('Nao foi possivel identificar o vinculo para remover.');
+        return;
+      }
+      showDialog({
+        title: 'Remover vendedor',
+        message: 'Deseja realmente remover este vendedor do cliente?',
+        confirmLabel: 'Remover',
+        cancelLabel: 'Cancelar',
+        onConfirm: async () => {
+          try {
+            await removePeopleLink(link.id);
+            showSuccess('Vendedor removido com sucesso!');
+            setClients(prev =>
+              (prev || []).filter(
+                item => extractId(item?.id) !== extractId(link.id),
+              ),
+            );
+          } catch {
+            showError('Nao foi possivel remover o vendedor.');
+          }
+        },
+      });
+    },
+    [removePeopleLink, showDialog, showError, showSuccess, setClients],
+  );
+
+  return {
+    canManage,
+    linkedNormalized,
+    showManageModal,
+    editingManageLink,
+    manageForm,
+    setManageForm,
+    isManageSaving,
+    salesmanOptions,
+    openManageModal,
+    closeManageModal,
+    handleManageSave,
+    handleManageDelete,
+  };
+}