@greatapps/common 1.1.790 → 1.1.792

package/src/components/account/hooks/useAddCardWithPaymentSwitch.ts

@@ -0,0 +1,70 @@
+'use client';
+
+import { useCallback, useMemo } from 'react';
+import { useCards } from '../../../modules/cards/hooks/cards.hook';
+import { useCurrentSubscription } from '../../../modules/subscriptions/hooks/use-current-subscription.hook';
+import { isFreeSubscription } from '../../../modules/subscriptions/utils/is-free-subscription';
+import { useAuth } from '../../../providers/auth.provider';
+import { useModalManager } from '../../../store/useModalManager';
+
+/**
+ * Abre o cadastro de cartão e, quando faz sentido, oferece em seguida a troca da forma de
+ * pagamento da assinatura.
+ *
+ * A decisão vive num hook porque os pontos que abrem o cadastro (cartões da assinatura, aviso de
+ * primeiro cartão e gestão de cartões) precisam da MESMA regra: espalhá-la é como o fluxo antigo
+ * divergia — o aviso prometia que "a próxima fatura será cobrada neste cartão", promessa que o
+ * backend não cumpria com a assinatura em boleto ou pix.
+ *
+ * `setAsDefault: false` quando vamos perguntar: com `set_default: true` o backend já aplica o
+ * padrão e reaponta as assinaturas cobráveis, e aí "Agora não" não teria o que recusar.
+ */
+export function useAddCardWithPaymentSwitch() {
+  const { openModal } = useModalManager();
+  const { account } = useAuth();
+  const { data: subscriptionData } = useCurrentSubscription();
+  const { data: cardsData } = useCards({ includeVindi: true });
+
+  const activeSubscription = subscriptionData?.data?.[0] ?? null;
+
+  const canOfferSwitch = useMemo(() => {
+    // Vindi não passa por aqui: o cadastro é Stripe (SetupIntent) e a troca atômica vive no
+    // fluxo Stripe — oferecer levaria a conta a um erro sem saída.
+    if (account?.gateway === 'vindi') return false;
+
+    // Sem assinatura paga viva não há forma de pagamento para transferir.
+    if (!activeSubscription) return false;
+
+    // Cancelada não é "sem assinatura": o backend recusa a troca sobre uma assinatura morta.
+    if (!activeSubscription.active && activeSubscription.cancellation_reason) return false;
+
+    if (isFreeSubscription(activeSubscription) || activeSubscription.type === 'trial') return false;
+
+    return true;
+  }, [account?.gateway, activeSubscription]);
+
+  const openAddCard = useCallback(() => {
+    if (!canOfferSwitch) {
+      openModal('addCardModal');
+      return;
+    }
+
+    // Contado ANTES do cadastro: depois que o cartão entra, a lista já foi invalidada e o número
+    // viraria "quantos existem agora", que não distingue a conta que não tinha nenhum.
+    const previousCardsCount = (cardsData?.data ?? []).filter((card) => !card.deleted).length;
+
+    openModal('addCardModal', {
+      setAsDefault: false,
+      onCardAdded: (cardId: string) => {
+        openModal('switchPaymentToCardModal', {
+          cardId,
+          subscriptionId: activeSubscription?.id,
+          currentPaymentMethod: activeSubscription?.payment_method ?? null,
+          previousCardsCount,
+        });
+      },
+    });
+  }, [canOfferSwitch, openModal, activeSubscription, cardsData]);
+
+  return { openAddCard, canOfferSwitch };
+}

package/src/components/account/hooks/useAffiliatesActions.tsx

@@ -0,0 +1,78 @@
+'use client';
+
+import { useTranslations } from 'next-intl';
+import { toast } from 'sonner';
+import { useAccountModals } from '../../../store/useAccountModals';
+import { useAffiliateFlows } from '../../../store/useAffiliateFlows';
+import { useAuth } from '../../../providers/auth.provider';
+import { useEnsureAffiliate } from '../../../modules/affiliates/hooks/use-ensure-affiliate.hook';
+import {
+  AFFILIATE_PROGRAM_TERMS_URL,
+  AFFILIATE_TERMS_URL,
+} from '../../../modules/affiliates/constants/affiliate.constants';
+import type { Affiliate } from '../../../modules/affiliates/types/affiliate.type';
+import { Toast } from '../../ui/feedback/Toast';
+
+/**
+ * Ações da aba Afiliados. Por padrão os fluxos abrem por cima do modal (`AffiliateFlows`); o app
+ * pode substituir qualquer um deles pelos handlers de `<Modals workspaceActions>`.
+ */
+export default function useAffiliatesActions() {
+  const translate = useTranslations();
+  const actions = useAccountModals((state) => state.config.workspaceActions?.affiliates);
+  const { user } = useAuth();
+  const ensureAffiliate = useEnsureAffiliate();
+
+  const openWithdrawal = useAffiliateFlows((state) => state.openWithdrawal);
+  const openReceivingAccount = useAffiliateFlows((state) => state.openReceivingAccount);
+  const openMissingReceivingAccount = useAffiliateFlows((state) => state.openMissingReceivingAccount);
+  const openLeads = useAffiliateFlows((state) => state.openLeads);
+  const openAttachment = useAffiliateFlows((state) => state.openAttachment);
+
+  return {
+    joinProgram: async () => {
+      if (actions?.onJoinProgram) return actions.onJoinProgram();
+      if (!user) return;
+
+      try {
+        await ensureAffiliate.mutateAsync({ gestorName: user.name });
+      } catch (error) {
+        const message =
+          error instanceof Error
+            ? error.message
+            : translate('common.account.workspace.affiliates.joinProgram.joinError');
+        toast.custom((toastId) => <Toast variant="error" message={message} toastId={toastId} />);
+      }
+    },
+    isJoiningProgram: ensureAffiliate.isPending,
+    requestWithdrawal: (affiliate: Affiliate) => {
+      // Mesma regra da tela: sem PIX/titular, o saque vira o aviso de conta de recebimento.
+      const hasReceivingAccount = !!(affiliate.pix && affiliate.holder_name && affiliate.holder_document);
+      if (!hasReceivingAccount) {
+        if (actions?.onMissingReceivingAccount) return actions.onMissingReceivingAccount(affiliate);
+        return openMissingReceivingAccount();
+      }
+      if (actions?.onRequestWithdrawal) return actions.onRequestWithdrawal(affiliate);
+      openWithdrawal();
+    },
+    editReceivingAccount: (affiliate: Affiliate) => {
+      if (actions?.onEditReceivingAccount) return actions.onEditReceivingAccount(affiliate);
+      openReceivingAccount();
+    },
+    listLeads: (affiliate: Affiliate) => {
+      if (actions?.onListLeads) return actions.onListLeads(affiliate);
+      openLeads();
+    },
+    viewAttachment: (attachment: string) => {
+      if (actions?.onViewAttachment) return actions.onViewAttachment(attachment);
+      openAttachment(attachment);
+    },
+    openTerms: () => {
+      window.open(AFFILIATE_TERMS_URL, '_blank', 'noopener,noreferrer');
+    },
+    /** Termo de uso aceito ao entrar no programa (o do menu é a página de regras). */
+    openProgramTerms: () => {
+      window.open(AFFILIATE_PROGRAM_TERMS_URL, '_blank', 'noopener,noreferrer');
+    },
+  };
+}

package/src/components/account/hooks/useMyAccountModal.ts

@@ -0,0 +1,40 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import type { MyAccountSection } from '../../../store/useAccountModals';
+
+interface UseMyAccountModalProps {
+  isOpen: boolean;
+  initialSection?: MyAccountSection;
+  /** Seções que o usuário pode abrir, na ordem do menu (inclui sub-telas sem item de menu). */
+  availableSections: MyAccountSection[];
+  /** Enquanto o perfil não resolve, as permissões ainda não valem e nenhuma seção é escolhida. */
+  isReady: boolean;
+}
+
+export default function useMyAccountModal({
+  isOpen,
+  initialSection,
+  availableSections,
+  isReady,
+}: UseMyAccountModalProps) {
+  const [selectedSection, setSelectedSection] = useState<MyAccountSection | undefined>(initialSection);
+
+  useEffect(() => {
+    if (isOpen) setSelectedSection(initialSection);
+  }, [isOpen, initialSection]);
+
+  const resolvedSection =
+    selectedSection && availableSections.includes(selectedSection) ? selectedSection : availableSections[0];
+  const activeSection = isReady ? resolvedSection : undefined;
+
+  const setActiveSection = (section: string) => {
+    const available = availableSections.find((candidate) => candidate === section);
+    if (available) setSelectedSection(available);
+  };
+
+  return {
+    activeSection,
+    setActiveSection,
+  };
+}

package/src/components/account/hooks/useProjectsActions.ts

@@ -0,0 +1,44 @@
+'use client';
+
+import { useAccountModals } from '../../../store/useAccountModals';
+import { useProjectFlows } from '../../../store/useProjectFlows';
+import { useCancelledSubscriptionGuard } from '../../../modules/subscriptions/hooks/use-cancelled-subscription-guard';
+import { useHasPlanAddon } from '../../../modules/plans/hooks/use-has-plan-addon.hook';
+import { ADDON_IDS } from '../../../modules/subscriptions/constants/addons.constants';
+import type { Project } from '../../../modules/projects/types';
+
+/**
+ * Ações da aba Projetos. Por padrão os fluxos abrem por cima do modal (`ProjectFlows`); o app pode
+ * substituir qualquer um deles pelos handlers de `<Modals workspaceActions>`.
+ */
+export default function useProjectsActions() {
+  const actions = useAccountModals((state) => state.config.workspaceActions?.projects);
+  const openCreateProject = useProjectFlows((state) => state.openCreateProject);
+  const openProjectDetails = useProjectFlows((state) => state.openProjectDetails);
+  const openDeleteProject = useProjectFlows((state) => state.openDeleteProject);
+  const openProjectsDisabled = useProjectFlows((state) => state.openProjectsDisabled);
+  const { guardAction } = useCancelledSubscriptionGuard();
+  const { hasAddon: canCreateProject, isLoading: isLoadingAddon } = useHasPlanAddon(ADDON_IDS.PROJECTS);
+
+  return {
+    createProject: () => {
+      if (isLoadingAddon) return;
+      guardAction(() => {
+        if (!canCreateProject) {
+          return actions?.onProjectsDisabled ? actions.onProjectsDisabled() : openProjectsDisabled();
+        }
+        return actions?.onCreateProject ? actions.onCreateProject() : openCreateProject();
+      });
+    },
+    openProject: (project: Project) => {
+      if (actions?.onOpenProject) return actions.onOpenProject(project);
+      openProjectDetails(project);
+    },
+    deleteProject: (project: Project) => {
+      guardAction(() => {
+        if (actions?.onDeleteProject) return actions.onDeleteProject(project);
+        openDeleteProject(project);
+      });
+    },
+  };
+}

package/src/components/account/hooks/useSubscriptionActions.ts

@@ -0,0 +1,99 @@
+'use client';
+
+import { useAddCardWithPaymentSwitch } from './useAddCardWithPaymentSwitch';
+import { useCards } from '../../../modules/cards/hooks/cards.hook';
+import { useCurrentSubscription } from '../../../modules/subscriptions/hooks/use-current-subscription.hook';
+import { useAccountModals } from '../../../store/useAccountModals';
+import { useModalManager } from '../../../store/useModalManager';
+import { useSubscriptionFlows } from '../../../store/useSubscriptionFlows';
+import { useExternalContracting } from '../../../providers/whitelabel.provider';
+import { WorkspaceSectionType } from '../../../enums/WorkspaceSectionType';
+import type { Charge } from '../../../modules/charges/types/charge.type';
+import type { Subscription } from '../../../modules/subscriptions/types/subscription.type';
+
+type PendingChange = NonNullable<Subscription['pending_change']>;
+
+/**
+ * Ações da aba Assinatura. Cada ação usa o handler que o app registrou em
+ * `<Modals workspaceActions>`; sem handler, leva para a tela de assinatura em `accounts_url`
+ * (deep link quando a tela tem um). Contratação externa do whitelabel tem prioridade, igual à tela.
+ */
+export default function useSubscriptionActions() {
+  const actions = useAccountModals((state) => state.config.workspaceActions?.subscription);
+  const openWorkspace = useAccountModals((state) => state.openWorkspace);
+  const { redirectToExternal } = useExternalContracting();
+  const { openModal } = useModalManager();
+  const { openAddCard } = useAddCardWithPaymentSwitch();
+  const { data: cardsData } = useCards();
+  const { data: subscriptionData } = useCurrentSubscription();
+  const openReceipt = useSubscriptionFlows((state) => state.openReceipt);
+  const openPayChargeFlow = useSubscriptionFlows((state) => state.openPayCharge);
+  const openBillingAddress = useSubscriptionFlows((state) => state.openBillingAddress);
+  const openPlanDetails = useSubscriptionFlows((state) => state.openPlanDetails);
+  const openUsageReport = useSubscriptionFlows((state) => state.openUsageReport);
+  const openCancelPlan = useSubscriptionFlows((state) => state.openCancelPlan);
+  const openChangePlan = useSubscriptionFlows((state) => state.openChangePlan);
+  const openPlansCatalog = useSubscriptionFlows((state) => state.openPlansCatalog);
+  const openPendingChange = useSubscriptionFlows((state) => state.openPendingChange);
+
+  return {
+    choosePlan: () => {
+      if (redirectToExternal('plans')) return;
+      if (actions?.onChoosePlan) return actions.onChoosePlan();
+      openWorkspace(WorkspaceSectionType.SUBSCRIPTION);
+      openPlansCatalog();
+    },
+    changePlan: () => {
+      if (redirectToExternal('contracting')) return;
+      if (actions?.onChangePlan) return actions.onChangePlan();
+      openChangePlan();
+    },
+    cancelPlan: () => {
+      if (redirectToExternal('contracting')) return;
+      if (actions?.onCancelPlan) return actions.onCancelPlan();
+      openCancelPlan();
+    },
+    editBillingAddress: () => {
+      if (redirectToExternal('contracting')) return;
+      if (actions?.onEditBillingAddress) return actions.onEditBillingAddress();
+      openBillingAddress();
+    },
+    viewPlanDetails: () => {
+      if (actions?.onViewPlanDetails) return actions.onViewPlanDetails();
+      openPlanDetails();
+    },
+    viewPendingChange: (pendingChange: PendingChange) => {
+      if (actions?.onViewPendingChange) return actions.onViewPendingChange(pendingChange);
+      openPendingChange(pendingChange);
+    },
+    viewUsageReport: () => {
+      if (actions?.onViewUsageReport) return actions.onViewUsageReport();
+      openUsageReport();
+    },
+    addCard: () => {
+      if (actions?.onAddCard) return actions.onAddCard();
+
+      // Primeiro cartão de quem já tem assinatura: avisa que ele vira a forma de pagamento antes
+      // de abrir o cadastro — o cartão passa a valer para a próxima fatura.
+      const hasCard = (cardsData?.data?.length ?? 0) > 0;
+      if (subscriptionData?.data?.[0] && !hasCard) {
+        openModal('addFirstCardWarningModal');
+        return;
+      }
+
+      openAddCard();
+    },
+    payCharge: (charge: Charge) => {
+      if (redirectToExternal('contracting')) return;
+      if (actions?.onPayCharge) return actions.onPayCharge(charge);
+      openPayChargeFlow(charge);
+    },
+    viewCharge: (charge: Charge) => {
+      if (actions?.onViewCharge) return actions.onViewCharge(charge);
+      openReceipt(charge);
+    },
+    downloadCharge: (url: string) => {
+      window.open(url, '_blank', 'noopener,noreferrer');
+    },
+  };
+}

package/src/components/account/hooks/useTeamActions.ts

@@ -0,0 +1,35 @@
+'use client';
+
+import { useAccountModals } from '../../../store/useAccountModals';
+import { useTeamFlows } from '../../../store/useTeamFlows';
+import { useCancelledSubscriptionGuard } from '../../../modules/subscriptions/hooks/use-cancelled-subscription-guard';
+import type { User } from '../../../modules/users/schema';
+
+/**
+ * Ações da aba Minha equipe. Por padrão os fluxos abrem por cima do modal (`TeamFlows`); o app pode
+ * substituir qualquer um deles pelos handlers de `<Modals workspaceActions>`.
+ */
+export default function useTeamActions() {
+  const actions = useAccountModals((state) => state.config.workspaceActions?.team);
+  const openAddUser = useTeamFlows((state) => state.openAddUser);
+  const openEditUser = useTeamFlows((state) => state.openEditUser);
+  const openDeleteUser = useTeamFlows((state) => state.openDeleteUser);
+  const { guardAction } = useCancelledSubscriptionGuard();
+
+  return {
+    addUser: () => {
+      guardAction(() => {
+        if (actions?.onAddUser) return actions.onAddUser();
+        openAddUser();
+      });
+    },
+    editUser: (user: User) => {
+      if (actions?.onEditUser) return actions.onEditUser(user);
+      openEditUser(user);
+    },
+    deleteUser: (user: User) => {
+      if (actions?.onDeleteUser) return actions.onDeleteUser(user);
+      openDeleteUser(user);
+    },
+  };
+}