teqo-backup/src/app/(campaign)/campanha/actions/advisor.ts

332 lines
11 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use server'
import { randomBytes } from 'node:crypto'
import { revalidatePath } from 'next/cache'
import type { Payload } from 'payload'
import { nextAdvisorIdsAfterMembership } from '@/lib/municipalityAdvisorMembership'
import { uniqueRelationshipIds } from '@/lib/relationship'
import {
ADVISOR_EMAIL_CONFLICT_MESSAGE,
ADVISOR_ROLE_REQUIRED_MESSAGE,
ADVISOR_SELF_ACCOUNT_MESSAGE,
ADVISOR_UNRESTRICTED_MESSAGE,
PLACEHOLDER_RESET_MESSAGE,
advisorCreateSchema,
advisorMunicipalitiesBatchSchema,
advisorPasswordResetSchema,
advisorPermissionUpdateSchema,
advisorProfileUpdateSchema,
isPlanilhaPlaceholderEmail,
type AdvisorCreateInput,
type AdvisorMunicipalitiesBatchInput,
type AdvisorPasswordResetInput,
type AdvisorPermissionUpdateInput,
type AdvisorProfileUpdateInput,
} from '@/lib/schemas/advisor'
import { contactPhonesSchema } from '@/lib/schemas/contact'
import type { CampaignUser } from '@/payload-types'
import {
getCampaignActionContext,
reloadUnrestrictedActor,
} from '@/utilities/campaignActionContext'
import {
assertCampaignEmailConfigured,
isCampaignEmailConfigured,
} from '@/utilities/campaignPasswordReset'
import { hookFilledCreateData } from '@/utilities/hookFilledData'
import { revalidateMunicipalityListPaths } from '@/utilities/municipality/municipalityRevalidation'
import { withPayloadTransaction } from '@/utilities/payloadTransaction'
import { acquireTextAdvisoryLocks } from '@/utilities/postgresTransactionLocks'
const revalidateAdvisorDetailPath = (advisorId: number) => {
revalidatePath(`/campanha/assessores/${advisorId}`, 'page')
}
/** For writes that change the LIST itself — a new advisor, or a renamed one. */
const revalidateAdvisorPaths = (advisorId?: number) => {
revalidatePath('/campanha/assessores', 'page')
if (advisorId !== undefined) revalidateAdvisorDetailPath(advisorId)
}
type AdvisorAccount = {
id: number
name: string
email?: string | null
phone?: string | null
role: CampaignUser['role']
}
const assertTargetAdvisor = async (
payload: Payload,
advisorId: number,
actorId: number,
): Promise<AdvisorAccount> => {
const target = await payload.findByID({
collection: 'campaignUser',
id: advisorId,
depth: 0,
select: { name: true, email: true, phone: true, role: true },
overrideAccess: true,
})
if (target.role !== 'advisor') {
throw new Error(ADVISOR_ROLE_REQUIRED_MESSAGE)
}
if (String(target.id) === String(actorId)) {
throw new Error(ADVISOR_SELF_ACCOUNT_MESSAGE)
}
return target
}
const translateUniqueEmailConflict = (error: unknown): never => {
const message = error instanceof Error ? error.message : String(error)
// Payload may surface the unique email collision as email, username, or a
// generic "field is invalid" ValidationError depending on auth config.
if (/email|username|duplicate key|unique/i.test(message)) {
throw new Error(ADVISOR_EMAIL_CONFLICT_MESSAGE)
}
throw error instanceof Error ? error : new Error(String(error))
}
export const createAdvisorRecord = async (
payload: Payload,
actor: CampaignUser,
input: AdvisorCreateInput,
) => {
const data = advisorCreateSchema.parse(input)
const currentActor = await reloadUnrestrictedActor(payload, actor, ADVISOR_UNRESTRICTED_MESSAGE)
try {
const created = await payload.create({
collection: 'campaignUser',
data: hookFilledCreateData<'campaignUser'>({
name: data.name,
email: data.email,
role: 'advisor',
password: randomBytes(24).toString('base64url'),
visibility: data.visibility,
editing: data.editing,
...(data.phone !== undefined ? { phone: data.phone } : {}),
}),
depth: 0,
user: currentActor,
overrideAccess: false,
})
return created
} catch (error) {
return translateUniqueEmailConflict(error)
}
}
export const createAdvisor = async (input: AdvisorCreateInput) => {
const { payload, actor } = await getCampaignActionContext()
const created = await createAdvisorRecord(payload, actor, input)
revalidateAdvisorPaths()
return created
}
export const updateAdvisorProfileRecord = async (
payload: Payload,
actor: CampaignUser,
input: AdvisorProfileUpdateInput,
) => {
const { id, ...fields } = advisorProfileUpdateSchema.parse(input)
const currentActor = await reloadUnrestrictedActor(payload, actor, ADVISOR_UNRESTRICTED_MESSAGE)
await assertTargetAdvisor(payload, id, currentActor.id)
const data: {
name?: string
email?: string
phone?: string | null
} = {}
if (fields.name !== undefined) data.name = fields.name
if (fields.email !== undefined) data.email = fields.email
if (fields.phone !== undefined) data.phone = fields.phone
try {
const updated = await payload.update({
collection: 'campaignUser',
id,
data,
depth: 0,
user: currentActor,
overrideAccess: false,
})
return updated
} catch (error) {
return translateUniqueEmailConflict(error)
}
}
export const updateAdvisorProfile = async (input: AdvisorProfileUpdateInput) => {
const { payload, actor } = await getCampaignActionContext()
const updated = await updateAdvisorProfileRecord(payload, actor, input)
revalidateAdvisorPaths(updated.id)
return updated
}
/**
* C112 — write the advisor's ficha (Contact) phone list. The advisor page is
* unrestricted-staff gated; the ficha is the person's record, distinct from
* the account's single channel phone.
*/
export const updateAdvisorContactFicha = async (input: { contactId: number; phones: string[] }) => {
const { payload, actor } = await getCampaignActionContext()
await reloadUnrestrictedActor(payload, actor, ADVISOR_UNRESTRICTED_MESSAGE)
// Same zod gate as the other ficha editors: valid mobiles, no duplicates.
const parsed = contactPhonesSchema.parse(input.phones)
await payload.update({
collection: 'contact',
id: input.contactId,
data: { phones: parsed.map((value) => ({ value })) },
depth: 0,
// Intentional admin bypass: the unrestricted route gate above established
// staff scope; the ficha is the advisor's own normalized Contact.
overrideAccess: true,
})
revalidatePath('/campanha/assessores', 'page')
}
export const setAdvisorMunicipalitiesBatchRecord = async (
payload: Payload,
actor: CampaignUser,
input: AdvisorMunicipalitiesBatchInput,
) => {
const { advisorId, municipalityIds, assigned } = advisorMunicipalitiesBatchSchema.parse(input)
const uniqueMunicipalityIds = [...municipalityIds].sort((left, right) => left - right)
return withPayloadTransaction(
payload,
async ({ req }) => {
const currentActor = await reloadUnrestrictedActor(
payload,
actor,
ADVISOR_UNRESTRICTED_MESSAGE,
req,
)
await assertTargetAdvisor(payload, advisorId, currentActor.id)
await acquireTextAdvisoryLocks(
payload,
req,
uniqueMunicipalityIds.map((id) => `municipality-advisors:${id}`),
)
// Every município actually changed, not just the last one: since B34 this
// is the only advisor write path, and a território chip moves up to 30 in
// one call — revalidating one would leave 29 detail pages stale.
const changedSlugs: string[] = []
for (const municipalityId of uniqueMunicipalityIds) {
const municipality = await payload.findByID({
collection: 'municipality',
id: municipalityId,
depth: 0,
select: { advisors: true, slug: true },
overrideAccess: true,
req,
})
const currentAdvisorIDs = uniqueRelationshipIds(municipality.advisors)
const nextAdvisorIDs = nextAdvisorIdsAfterMembership(currentAdvisorIDs, advisorId, assigned)
if (nextAdvisorIDs === null) continue
// Intentional admin bypass: unrestricted role verified above; advisors
// field update access is admin-only in the collection config.
await payload.update({
collection: 'municipality',
id: municipalityId,
data: { advisors: nextAdvisorIDs },
depth: 0,
overrideAccess: true,
req,
})
if (typeof municipality.slug === 'string') changedSlugs.push(municipality.slug)
}
return { slugs: changedSlugs }
},
{ beginFailureMessage: 'Não foi possível atualizar a carteira do assessor.' },
)
}
export const setAdvisorMunicipalitiesBatch = async (input: AdvisorMunicipalitiesBatchInput) => {
const { payload, actor } = await getCampaignActionContext()
const result = await setAdvisorMunicipalitiesBatchRecord(payload, actor, input)
// A no-op batch changed nothing, so there is nothing to revalidate — the guard
// the other three chip wrappers already had. `/campanha/assessores` itself
// stays out: the cell that calls this is on it and already shows the toggle.
if (result.slugs.length > 0) {
revalidateMunicipalityListPaths({ scope: 'list' })
for (const slug of result.slugs) {
revalidateMunicipalityListPaths({ slug, scope: 'detail' })
}
revalidateAdvisorDetailPath(input.advisorId)
}
return result
}
/**
* C141 — set the advisor's permission profile (Visão × Edição). The coherence
* rule (Edição "Tudo" ⇒ Visão "Tudo") is enforced by the zod schema AND the
* collection's `enforceCoherentAdvisorProfile` beforeValidate hook; the field
* update access (`canManageCampaignUserRole`) re-checks the unrestricted role.
*/
export const updateAdvisorPermissionRecord = async (
payload: Payload,
actor: CampaignUser,
input: AdvisorPermissionUpdateInput,
) => {
const { id, visibility, editing } = advisorPermissionUpdateSchema.parse(input)
const currentActor = await reloadUnrestrictedActor(payload, actor, ADVISOR_UNRESTRICTED_MESSAGE)
await assertTargetAdvisor(payload, id, currentActor.id)
return payload.update({
collection: 'campaignUser',
id,
data: { visibility, editing },
depth: 0,
user: currentActor,
overrideAccess: false,
})
}
export const updateAdvisorPermission = async (input: AdvisorPermissionUpdateInput) => {
const { payload, actor } = await getCampaignActionContext()
const updated = await updateAdvisorPermissionRecord(payload, actor, input)
revalidateAdvisorPaths(updated.id)
return updated
}
export const sendAdvisorPasswordResetRecord = async (
payload: Payload,
actor: CampaignUser,
input: AdvisorPasswordResetInput,
) => {
const { advisorId } = advisorPasswordResetSchema.parse(input)
const currentActor = await reloadUnrestrictedActor(payload, actor, ADVISOR_UNRESTRICTED_MESSAGE)
const target = await assertTargetAdvisor(payload, advisorId, currentActor.id)
if (!target.email || isPlanilhaPlaceholderEmail(target.email)) {
throw new Error(PLACEHOLDER_RESET_MESSAGE)
}
assertCampaignEmailConfigured()
await payload.forgotPassword({
collection: 'campaignUser',
data: { email: target.email },
disableEmail: !isCampaignEmailConfigured(),
})
return { email: target.email }
}
export const sendAdvisorPasswordReset = async (input: AdvisorPasswordResetInput) => {
const { payload, actor } = await getCampaignActionContext()
return sendAdvisorPasswordResetRecord(payload, actor, input)
}