mirror of
https://github.com/fsolla/teqo.git
synced 2026-11-17 21:03:06 +00:00
Fold duplicated campanha access, loaders, list/filter/form shells, and scripts into shared modules; reorganize utilities by domain; stabilize e2e; and document prevention-first audit workflow so the same smells cannot creep back in.
272 lines
8.8 KiB
TypeScript
272 lines
8.8 KiB
TypeScript
'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,
|
|
advisorProfileUpdateSchema,
|
|
isPlanilhaPlaceholderEmail,
|
|
type AdvisorCreateInput,
|
|
type AdvisorMunicipalitiesBatchInput,
|
|
type AdvisorPasswordResetInput,
|
|
type AdvisorProfileUpdateInput,
|
|
} from '@/lib/schemas/advisor'
|
|
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'),
|
|
...(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
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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)
|
|
}
|