Files
Investidor-V2/resources/js/components/investment-zone-operational-details.tsx
T
nala cf003c8623
tests / ci (push) Canceled after 0s
versao nrgocios 4
2026-10-18 15:57:06 +02:00

708 lines
32 KiB
TypeScript

import ParkIntegralEditor, {
ParkIntegralPublic,
type ParkIntegral,
} from '@/components/investment-zone-integral-details';
import { useRef } from 'react';
import { Field, input, button, card } from '@/pages/investment/shared';
type Group = 'responsibilities' | 'conditions' | 'risks';
export type ParkDetail = {
id?: string;
label: string;
knowledge: 'unknown' | 'documented' | 'disputed';
disclosure: boolean;
source_reference?: string | null;
source_date?: string | null;
scope?: string | null;
private_note?: string | null;
support_document_ids?: string[];
role?: string;
organization_id?: string | null;
organization_name?: string;
documentary_name?: string | null;
private_contact?: string | null;
public_contact?: string | null;
value?: string | number | null;
currency?: string | null;
unit?: string | null;
period?: string | null;
valid_from?: string | null;
valid_until?: string | null;
declared_nature?: string | null;
management_model?: string | null;
modality?: string | null;
risk_type?: string | null;
mitigation?: string | null;
responsible_role?: string | null;
channel?: string | null;
channel_owner?: string | null;
};
export type ParkReview = {
source_reference?: string | null;
source_date?: string | null;
scope?: string | null;
confidence?: string | null;
last_reviewed_at?: string | null;
next_review_at?: string | null;
private_note?: string | null;
};
export type ParkDetails = {
integral?: ParkIntegral;
schema_version: number;
responsibilities: ParkDetail[];
conditions: ParkDetail[];
risks: ParkDetail[];
review: ParkReview;
remove_ids?: Partial<Record<Group, string[]>>;
};
export const emptyParkDetails = (): ParkDetails => ({
schema_version: 1,
responsibilities: [],
conditions: [],
risks: [],
review: {},
});
const groups: Record<Group, string> = {
responsibilities: 'Entidades e funções',
conditions: 'Condições e tarifas declaradas',
risks: 'Riscos e canal de esclarecimento',
};
const roles: Record<string, string> = {
owner: 'Proprietário',
promoter: 'Promotor',
operator: 'Operador',
manager: 'Gestor',
};
const knowledge = {
unknown: 'Não informado',
documented: 'Documentado pela fonte',
disputed: 'Divergente',
};
const reviewLabels: Record<keyof ParkReview, string> = {
source_reference: 'Fonte da revisão',
source_date: 'Data da fonte',
scope: 'Âmbito da revisão',
confidence: 'Qualidade documental',
last_reviewed_at: 'Última revisão',
next_review_at: 'Próxima revisão',
private_note: 'Nota de revisão privada',
};
export function ParkDetailsPublic({ value }: { value?: Partial<ParkDetails> }) {
if (!value) return null;
return (
<section className={card} aria-label="Detalhes operacionais publicados">
<h2 className="font-semibold">Detalhes operacionais publicados</h2>
<p>
A informação não constitui reserva, disponibilidade confirmada
ou autorização de instalação. Uma tarifa desconhecida não é
gratuita.
</p>
{(Object.keys(groups) as Group[]).map((g) => (
<section key={g} className="my-4 space-y-2">
<h3 className="font-semibold">{groups[g]}</h3>
{!value[g]?.length && <p>Não informado nesta versão.</p>}
{value[g]?.map((item, index) => (
<article key={index} className="rounded border p-3">
<p>
{item.label} · {knowledge[item.knowledge]}
</p>
{g === 'responsibilities' && (
<p>
{roles[item.role ?? ''] ??
'Função não informada'}
:{' '}
{item.organization_name ?? 'Não informado'}
{item.public_contact
? ` · ${item.public_contact}`
: ''}
</p>
)}
{g === 'responsibilities' && (
<p>
Natureza declarada:{' '}
{item.declared_nature || 'Não informada'} ·
modelo de gestão:{' '}
{item.management_model || 'Não informado'}
</p>
)}
{g === 'conditions' && (
<p>
Valor:{' '}
{item.value == null
? 'Não informado'
: `${item.value} ${item.currency ?? ''} / ${item.unit ?? ''}`}{' '}
· período: {item.period ?? 'Não informado'}{' '}
· vigência:{' '}
{item.valid_from ?? 'Não informada'} a{' '}
{item.valid_until ?? 'Não informada'}
</p>
)}
{g === 'conditions' && (
<p>
Modalidade de acesso declarada:{' '}
{item.modality || 'Não informada'}
</p>
)}
{g === 'risks' && (
<>
<p>
Tipo:{' '}
{item.risk_type || 'Não informado'} ·
mitigação:{' '}
{item.mitigation || 'Não informada'} ·
função responsável:{' '}
{roles[item.responsible_role ?? ''] ||
'Não informada'}
</p>
<p>
Canal:{' '}
{item.channel_owner === 'tempo' ? (
<a
className="underline"
href="/apoio"
>
Apoio da Tempo — não é a gestão
do parque
</a>
) : item.channel_owner === 'park' ? (
`${item.channel || 'Não informado'} (canal próprio do parque segundo a fonte)`
) : (
'Não informado'
)}
</p>
</>
)}
<p>
Fonte:{' '}
{item.source_reference || 'Não informada'} ·
data: {item.source_date || 'Não informada'} ·
âmbito: {item.scope || 'Não informado'}
</p>
</article>
))}
</section>
))}
<ParkIntegralPublic value={value.integral} />
<h3 className="font-semibold">Revisão documental</h3>
<dl>
{(Object.keys(reviewLabels) as (keyof ParkReview)[])
.filter((k) => k !== 'private_note')
.map((k) => (
<div key={k}>
<dt>{reviewLabels[k]}</dt>
<dd>
{k === 'confidence'
? ({
unknown: 'Não informada',
reported: 'Declarada',
documented: 'Documentada',
disputed: 'Divergente',
}[value.review?.[k] ?? ''] ??
'Não informada')
: value.review?.[k] || 'Não informado'}
</dd>
</div>
))}
</dl>
</section>
);
}
export default function ParkDetailsEditor({
value,
onChange,
organizations,
documents,
geometries,
links,
}: {
value: ParkDetails;
onChange: (next: ParkDetails) => void;
organizations: { id: string; name: string }[];
documents: { id: string; title: string }[];
geometries?: { id: string; name: string }[];
links?: { id: string; name: string }[];
}) {
const persistedIds = useRef(
new Set(
[
...value.responsibilities,
...value.conditions,
...value.risks,
].flatMap((item) => (item.id ? [item.id] : [])),
),
);
function update(g: Group, index: number, next: Partial<ParkDetail>) {
onChange({
...value,
[g]: value[g].map((item, i) =>
i === index ? { ...item, ...next } : item,
),
});
}
function field(
g: Group,
index: number,
item: ParkDetail,
key: keyof ParkDetail,
label: string,
type = 'text',
) {
return (
<Field key={key} label={label}>
<input
className={input}
type={type}
step={type === 'number' ? 'any' : undefined}
value={String(item[key] ?? '')}
onChange={(e) =>
update(g, index, {
[key]:
key === 'value' && e.target.value === ''
? null
: e.target.value,
})
}
/>
</Field>
);
}
return (
<section
className="space-y-4 md:col-span-2"
aria-label="Complemento operacional L1"
>
<h2 className="font-semibold">Complemento operacional</h2>
<p>
Uma entidade pode exercer várias funções. Guardar prepara em
privado; divulgar exige seleção por detalhe e publicação
expressa. Contactos pessoais, notas e suporte permanecem
privados.
</p>
<ParkIntegralEditor
value={value.integral}
onChange={(integral) => onChange({ ...value, integral })}
organizations={organizations}
documents={documents}
geometries={geometries}
links={links}
/>
{(Object.keys(groups) as Group[]).map((g) => (
<fieldset key={g} className="space-y-3 rounded border p-3">
<legend>{groups[g]}</legend>
{value[g].map((item, index) => (
<div
key={item.id ?? index}
className="grid gap-3 rounded border p-3 md:grid-cols-2"
>
{field(
g,
index,
item,
'label',
'Descrição do detalhe',
)}
<Field label="Situação da informação">
<select
className={input}
value={item.knowledge}
onChange={(e) =>
update(g, index, {
knowledge: e.target
.value as ParkDetail['knowledge'],
...(e.target.value === 'unknown'
? { value: null }
: {}),
})
}
>
{Object.entries(knowledge).map(([k, v]) => (
<option key={k} value={k}>
{v}
</option>
))}
</select>
</Field>
{g === 'responsibilities' && (
<>
<Field label="Função">
<select
className={input}
value={item.role ?? 'owner'}
onChange={(e) =>
update(g, index, {
role: e.target.value,
})
}
>
{Object.entries(roles).map(
([k, v]) => (
<option key={k} value={k}>
{v}
</option>
),
)}
</select>
</Field>
<Field label="Entidade existente">
<select
className={input}
value={item.organization_id ?? ''}
onChange={(e) =>
update(g, index, {
organization_id:
e.target.value || null,
})
}
>
<option value="">
Menção preliminar / não
identificada
</option>
{organizations.map((o) => (
<option key={o.id} value={o.id}>
{o.name}
</option>
))}
</select>
</Field>
{field(
g,
index,
item,
'documentary_name',
'Menção documental por corresponder (privada)',
)}
{field(
g,
index,
item,
'private_contact',
'Contacto pessoal / focal (privado)',
)}
{field(
g,
index,
item,
'public_contact',
'Contacto institucional autorizado para divulgação',
)}
{field(
g,
index,
item,
'declared_nature',
'Natureza organizacional declarada pela fonte',
)}
{field(
g,
index,
item,
'management_model',
'Modelo de gestão declarado pela fonte',
)}
</>
)}
{g === 'conditions' && (
<>
{field(
g,
index,
item,
'modality',
'Modalidade de acesso declarada',
)}
{field(
g,
index,
item,
'value',
'Valor (vazio = desconhecido)',
'number',
)}
{field(
g,
index,
item,
'currency',
'Moeda (código de três letras, quando aplicável)',
)}
{field(
g,
index,
item,
'unit',
'Unidade / base de cobrança',
)}
{field(
g,
index,
item,
'period',
'Período de cobrança, quando aplicável',
)}
{field(
g,
index,
item,
'valid_from',
'Vigência desde, quando conhecida',
'date',
)}
{field(
g,
index,
item,
'valid_until',
'Vigência até, quando conhecida',
'date',
)}
</>
)}
{g === 'risks' && (
<>
{field(
g,
index,
item,
'risk_type',
'Tipo de risco segundo a fonte',
)}
{field(
g,
index,
item,
'mitigation',
'Mitigação declarada',
)}
<Field label="Função responsável pela mitigação">
<select
className={input}
value={
item.responsible_role ??
'unknown'
}
onChange={(e) =>
update(g, index, {
responsible_role:
e.target.value,
})
}
>
<option value="unknown">
Não informada
</option>
{Object.entries(roles).map(
([k, v]) => (
<option key={k} value={k}>
{v}
</option>
),
)}
</select>
</Field>
<Field label="Origem do canal">
<select
className={input}
value={
item.channel_owner ?? 'unknown'
}
onChange={(e) =>
update(g, index, {
channel_owner:
e.target.value,
})
}
>
<option value="unknown">
Não informada
</option>
<option value="park">
Canal próprio do parque,
documentado
</option>
<option value="tempo">
Apoio da Tempo, distinto do
gestor do parque
</option>
</select>
</Field>
{field(
g,
index,
item,
'channel',
'Canal próprio declarado (se documentado)',
)}
</>
)}
{field(
g,
index,
item,
'source_reference',
'Fonte / citação (vazio = desconhecida)',
)}
{field(
g,
index,
item,
'source_date',
'Data da fonte (vazio = desconhecida)',
'date',
)}
{field(g, index, item, 'scope', 'Âmbito aplicável')}
{field(
g,
index,
item,
'private_note',
'Nota interna (privada)',
)}
<Field label="Suporte privado já associado (não publica o anexo)">
<select
multiple
className={input}
value={item.support_document_ids ?? []}
onChange={(e) =>
update(g, index, {
support_document_ids: Array.from(
e.target.selectedOptions,
(o) => o.value,
),
})
}
>
{documents.map((d) => (
<option key={d.id} value={d.id}>
{d.title}
</option>
))}
</select>
</Field>
<label className="flex items-center gap-2">
<input
type="checkbox"
checked={item.disclosure}
onChange={(e) =>
update(g, index, {
disclosure: e.target.checked,
})
}
/>
Incluir os campos públicos deste detalhe na
próxima publicação expressa
</label>
<button
className={button}
type="button"
onClick={() =>
onChange({
...value,
[g]: value[g].filter(
(_, i) => i !== index,
),
remove_ids: {
...value.remove_ids,
[g]: [
...(value.remove_ids?.[g] ??
[]),
...(item.id &&
persistedIds.current.has(
item.id,
)
? [item.id]
: []),
],
},
})
}
>
Remover este detalhe na próxima gravação
</button>
</div>
))}
<button
type="button"
className={button}
onClick={() =>
onChange({
...value,
[g]: [
...value[g],
{
id: crypto.randomUUID(),
label: '',
knowledge: 'unknown',
disclosure: false,
...(g === 'responsibilities'
? { role: 'owner' }
: {}),
},
],
})
}
>
Acrescentar {groups[g].toLocaleLowerCase()}
</button>
</fieldset>
))}
<fieldset className="grid gap-3 md:grid-cols-2">
<legend>Qualidade e revisão documental</legend>
{(Object.keys(reviewLabels) as (keyof ParkReview)[]).map((k) =>
k === 'confidence' ? (
<Field key={k} label={reviewLabels[k]}>
<select
className={input}
value={value.review[k] ?? 'unknown'}
onChange={(e) =>
onChange({
...value,
review: {
...value.review,
[k]: e.target.value,
},
})
}
>
{Object.entries({
unknown: 'Não informada',
reported: 'Declarada',
documented: 'Documentada',
disputed: 'Divergente',
}).map(([v, t]) => (
<option key={v} value={v}>
{t}
</option>
))}
</select>
</Field>
) : (
<Field key={k} label={reviewLabels[k]}>
<input
className={input}
type={
k.includes('date') || k.endsWith('_at')
? 'date'
: 'text'
}
value={value.review[k] ?? ''}
onChange={(e) =>
onChange({
...value,
review: {
...value.review,
[k]: e.target.value || null,
},
})
}
/>
</Field>
),
)}
</fieldset>
</section>
);
}