oportunidades 5
tests / ci (push) Canceled after 0s

This commit is contained in:
2026-10-10 14:15:28 +02:00
parent 6ddafc95ba
commit 01405cbf8a
144 changed files with 28903 additions and 1103 deletions
+34 -7
View File
@@ -1,3 +1,5 @@
import { profileLinks } from '@/components/profile-navigation';
import type { ProfileAccess } from '@/types/profile-access';
import { Link, usePage } from '@inertiajs/react';
import { LayoutGrid } from 'lucide-react';
import { portalNavigation } from '@/lib/portal-navigation';
@@ -15,27 +17,52 @@ import {
} from '@/components/ui/sidebar';
import { dashboard } from '@/routes';
import type { Auth } from '@/types';
import type { OpportunityManagementAccess } from '@/types/opportunity-management';
export function AppSidebar() {
const { auth, existingBusinessEnabled, educationEnabled, aiEnabled } =
usePage<{
auth: Auth;
existingBusinessEnabled?: boolean;
educationEnabled?: boolean;
aiEnabled?: boolean;
}>().props;
const {
auth,
existingBusinessEnabled,
educationEnabled,
aiEnabled,
opportunityManagement,
profileAccess,
} = usePage<{
auth: Auth;
existingBusinessEnabled?: boolean;
educationEnabled?: boolean;
aiEnabled?: boolean;
profileAccess?: ProfileAccess | null;
opportunityManagement?: OpportunityManagementAccess | null;
}>().props;
const groups = portalNavigation({
authenticated: !!auth.user,
manager: auth.canManagePortal,
businesses: existingBusinessEnabled,
education: educationEnabled,
ai: aiEnabled,
opportunityManagement,
});
const items = groups.map((group) => ({
title: group.label,
href: group.children?.find((item) => item.href)?.href ?? '/',
icon: LayoutGrid,
}));
if (auth.canManagePortal && opportunityManagement) {
items.push({
title: opportunityManagement.manage.label,
href: opportunityManagement.manage.href,
icon: LayoutGrid,
});
if (opportunityManagement.installed) {
items.push({
title: opportunityManagement.create.label,
href: opportunityManagement.create.href,
icon: LayoutGrid,
});
}
}
items.push(...profileLinks(profileAccess).map(link => ({...link, icon: LayoutGrid})));
return (
<Sidebar collapsible="icon" variant="inset">
<SidebarHeader>
@@ -40,6 +40,30 @@ export function ProvinceSelect({
const [error, setError] = useState('');
const [retry, setRetry] = useState(0);
const [search, setSearch] = useState('');
const [geometrySelection, setGeometrySelection] = useState<{ value: string; id: string } | null>(null);
const [geometryFeedback, setGeometryFeedback] = useState('');
useEffect(() => {
const controller = new AbortController();
setGeometrySelection(null);
setGeometryFeedback('');
if (!value) return;
// Preserve historical text. Only one exact catalogue match supplies a map ID.
void fetch(`${endpoint}?${new URLSearchParams({ type: 'province', page: '1', q: value })}`, {
signal: controller.signal, headers: { Accept: 'application/json' },
}).then(async (response) => {
if (!response.ok) throw new Error('Não foi possível consultar a correspondência cartográfica.');
const data = await response.json();
const matches = (data.data as Option[]).filter((option) => option.name === value);
if (controller.signal.aborted) return;
if (matches.length === 1 && !data.next_page_url)
setGeometrySelection({ value, id: matches[0].id });
else setGeometryFeedback('Seleção guardada preservada; sem correspondência cartográfica inequívoca neste cadastro.');
}).catch((cause: unknown) => {
if (!controller.signal.aborted) setGeometryFeedback(cause instanceof Error ? cause.message : 'Erro de ligação.');
});
return () => controller.abort();
}, [endpoint, value, retry]);
useEffect(() => {
const controller = new AbortController();
@@ -127,6 +151,12 @@ export function ProvinceSelect({
</button>
</span>
)}
{geometryFeedback && <p role="status">{geometryFeedback}</p>}
<TerritoryGeometryPreview
territoryId={geometrySelection && geometrySelection.value === value ? geometrySelection.id : undefined}
management={endpoint.startsWith('/management/')}
endpoint={endpoint.startsWith('/minhas-oportunidades/') ? '/minhas-oportunidades/territory-geometries' : undefined}
/>
</>
);
}
@@ -181,6 +211,7 @@ export function TerritoryFields({
<TerritoryGeometryPreview
territoryId={path.at(-1)?.id}
management={endpoint.startsWith('/management/')}
endpoint={endpoint.startsWith('/minhas-oportunidades/') ? '/minhas-oportunidades/territory-geometries' : undefined}
/>
</div>
);
@@ -0,0 +1,750 @@
import OpportunityParcelGeometry from "./opportunity-parcel-geometry";
import TerritoryGeometryPreview from "./territory-geometry-preview";
import { control } from "@/pages/management/shared";
type Data = Record<string, unknown>;
type Schema = {
$ref?: string;
type?: string | string[];
properties?: Record<string, Schema>;
items?: Schema;
enum?: unknown[];
const?: unknown;
format?: string;
maxLength?: number;
required?: string[];
};
type Resource = {
id: string;
payload: { title?: string; role?: string; [key: string]: unknown };
file?: { file_name: string };
};
function resourceTerritory(resource?: Resource) {
const p = resource?.payload;
const id =
p?.locality_id ?? p?.admin_post_id ?? p?.district_id ?? p?.province_id;
return typeof id === "string" ? id : undefined;
}
export type CanonicalOptions = {
version: string;
schema: Schema;
definitions: Record<string, Schema>;
contacts: { id: string; full_name: string }[];
activities: {
id: string;
parent_id: string | null;
sector_id: number;
label_pt_mz: string;
}[];
resources: Record<string, Resource[]>;
gates: string[];
countries: { code: string; name: string }[];
authorities: { id: string; label_pt_mz: string }[];
};
const labels: Record<string, string> = {
official_title: "Título oficial",
promoter_type: "Tipo de Promotor",
internal_contact_id: "Contacto interno",
sector_id: "Sector",
subsector_id: "Subsector",
economic_activity_id: "Atividade económica",
location_mode: "Uma ou várias localizações",
geographic_scope: "Âmbito geográfico",
multi_district_rationale: "Justificação territorial",
locations: "Localizações guardadas",
executive_summary: "Resumo executivo",
demand_statement: "Necessidade e proposta",
visibility: "Visibilidade após publicação",
truth_declaration: "Declaração de veracidade",
publication_languages: "Versões por idioma",
language_code: "Idioma",
title: "Título",
summary: "Resumo",
documents: "Documentos guardados",
evidences: "Evidências",
document_id: "Documento associado",
evidence_type: "Tipo de evidência",
description: "Descrição",
images: "Imagens guardadas",
review_due_date: "Data de revisão editorial",
real_estate: "Imobiliário",
land_rights: "DUAT e direitos fundiários",
business_transaction: "Negócio",
transaction_type: "Modalidade",
property_type: "Tipo de imóvel",
construction_status: "Estado construtivo",
property_condition: "Condição do imóvel",
land_area: "Área do terreno",
built_area: "Área construída",
area_unit: "Unidade da área",
units: "Unidades",
rooms: "Compartimentos",
floors: "Pisos",
amenities: "Comodidades",
utilities: "Serviços e acessos",
occupancy_status: "Ocupação",
title_type: "Tipo de título",
registration_number: "Número de registo",
encumbrances: "Ónus e restrições",
price: "Preço do imóvel",
rent: "Renda",
rent_periodicity: "Periodicidade",
deposit: "Caução",
valuation: "Avaliação",
viewing: "Visitas",
planning_permit_document_id: "Licença de construção",
use_license_document_id: "Licença de utilização",
operation_type: "Operação fundiária admissível",
duat_status: "Situação do DUAT",
duat_number: "Número do DUAT",
holder_id: "Titular cadastrado",
holder_name: "Nome do titular",
issuing_authority_id: "Entidade emissora",
issue_date: "Data de emissão",
expiry_date: "Data de validade",
authorized_purpose: "Finalidade autorizada",
exploitation_plan_document_id: "Plano de exploração",
parcels: "Parcelas",
location_id: "Localização associada",
area: "Área",
cadastral_number: "Número cadastral",
overlap_status: "Sobreposição",
improvements: "Benfeitorias",
communities: "Comunidades",
community_consultation: "Consulta comunitária",
overlaps_conflicts: "Sobreposições e conflitos",
required_authorizations: "Autorizações necessárias",
consideration: "Contraprestação",
legal_entity_id: "Entidade representada",
legal_form: "Forma jurídica",
percentage_offered: "Percentagem oferecida",
asking_price: "Valor solicitado",
financial_periods: "Exercícios financeiros",
assets_liabilities: "Ativos e passivos",
employees: "Empregos e obrigações",
contracts_licenses: "Contratos e licenças",
litigation_contingencies: "Litígios e contingências",
reason_for_transaction: "Fundamentação da operação",
partner_contribution: "Contribuição do parceiro",
governance_rights: "Direitos de governação",
franchise_terms: "Condições da franquia",
confidentiality_level: "Confidencialidade",
due_diligence_status: "Preparação da análise",
opportunity_type: "Tipo de investimento",
maturity_stage: "Etapa de maturidade",
investment_modalities: "Modalidades de investimento",
investor_profiles: "Perfis de investidor",
products: "Produtos",
assets: "Ativos",
inputs: "Insumos",
markets: "Mercados",
competitive_advantage: "Vantagem competitiva",
employment: "Emprego",
impact_indicators: "Impactos",
total_investment: "Investimento total",
currency: "Moeda",
investment_breakdown: "Rubricas de investimento",
secured_financing: "Financiamento assegurado",
funding_sought: "Financiamento procurado",
financial_indicators: "Indicadores financeiros",
milestones: "Marcos",
licenses: "Licenças",
environmental_social: "Aspetos ambientais e sociais",
risks: "Riscos",
relations: "Relações",
amount: "Montante",
name: "Nome",
label: "Designação",
status: "Estado",
date: "Data",
method: "Método",
appraiser: "Avaliador",
year: "Exercício",
revenue: "Receita",
profit: "Resultado",
type: "Tipo",
value: "Valor",
details: "Detalhes",
mitigation: "Mitigação",
due_date: "Prazo",
authority: "Entidade competente",
assessment_status: "Estado da avaliação",
environmental_category: "Categoria ambiental",
direct_jobs: "Empregos diretos",
employment_type: "Tipo de emprego",
geometry: "Geometria da parcela",
module_profile_version: "Perfil modular aprovado",
start_date: "Data de início",
end_date: "Data de fim",
responsible_name: "Responsável declarado",
dependencies: "Marcos dos quais depende",
scenario: "Cenário analisado",
npv: "Valor atual líquido",
irr: "Taxa interna de retorno (%)",
payback_years: "Prazo de retorno (anos)",
horizon_years: "Horizonte (anos)",
discount_rate: "Taxa de desconto (%)",
model_document_id: "Modelo financeiro associado",
title_holder_name: "Titular do título",
title_document_id: "Documento do título",
holder_document_id: "Documento do titular",
expected_completion_date: "Conclusão prevista",
occupancy_details: "Condições de ocupação",
occupancy_document_id: "Contrato de ocupação",
urban_limit_document_id: "Fonte do limite urbanístico",
max_built_area: "Área edificável máxima declarada",
amenities_other: "Outra comodidade",
communities_affected: "Existem comunidades afetadas?",
exploitation_plan_required: "Plano de exploração aplicável?",
entity_registration: "Registo e beneficiário efetivo",
tax_identifier: "Identificação fiscal",
legal_document_id: "Documento de constituição/registo",
beneficial_owner_document_id: "Documento do beneficiário efetivo",
available_financial_years: "Exercícios financeiros existentes",
liabilities: "Passivos",
cash_flow: "Fluxo de caixa",
excluded_assets: "Ativos excluídos",
guarantees: "Garantias",
reconciliation_document_id: "Documento de reconciliação",
obligations: "Obrigações",
labor_liabilities: "Passivos laborais",
transferability: "Transmissibilidade",
consent_document_id: "Consentimento de transmissão",
nda_document_id: "Acordo de confidencialidade",
teaser: "Resumo autorizado para publicação",
board: "Órgãos de gestão",
reserved_matters: "Matérias reservadas",
dividends: "Dividendos",
exit: "Saída",
deadlock: "Resolução de impasse",
initial_fee: "Encargo inicial",
royalties: "Royalties e encargos",
support: "Apoio",
exclusivity: "Exclusividade",
renewal: "Renovação",
termination: "Cessação",
brand_license_document_id: "Licença da marca",
publish_contact: "Autoriza publicar o contacto?",
public_contact_id: "Contacto para divulgação",
};
function FieldErrors({
path,
errors,
}: {
path: string;
errors: Record<string, string>;
}) {
const message = errors[path];
return message ? (
<p id={path + "-error"} className="text-red-700" role="alert">
{message}
</p>
) : null;
}
function Editor({
name,
path,
schema,
value,
onChange,
options,
errors,
}: {
name: string;
path: string;
schema: Schema;
value: unknown;
onChange: (v: unknown) => void;
options: CanonicalOptions;
errors: Record<string, string>;
}) {
if (schema.$ref)
schema = options.definitions[schema.$ref.split("/").pop()!] ?? schema;
const types = Array.isArray(schema.type) ? schema.type : [schema.type];
const label = labels[name] ?? name.replaceAll("_", " ");
const props = {
id: path,
"aria-invalid": !!errors[path],
"aria-describedby": errors[path] ? path + "-error" : undefined,
};
let input;
if (name === "geometry")
input = <OpportunityParcelGeometry value={value} onChange={onChange} />;
else if (
name.endsWith("document_id") ||
name === "location_id" ||
name === "image_id"
) {
const kind =
name === "location_id"
? "locations"
: name === "image_id"
? "images"
: "documents";
const rows = options.resources[kind] ?? [];
input = (
<>
<select
{...props}
className={control}
value={String(value ?? "")}
onChange={(e) => onChange(e.target.value || null)}
>
<option value="">Por indicar</option>
{rows.map((r) => (
<option key={r.id} value={r.id}>
{r.payload.title ??
r.payload.role ??
r.file?.file_name ??
r.id}
</option>
))}
</select>
{name === "location_id" && !!value && (
<TerritoryGeometryPreview
territoryId={resourceTerritory(
rows.find((r) => r.id === value),
)}
endpoint="/minhas-oportunidades/territory-geometries"
/>
)}
</>
);
} else if (name === "country_code")
input = (
<select
{...props}
className={control}
value={String(value ?? "")}
onChange={(e) => onChange(e.target.value || null)}
>
<option value="">Por indicar</option>
{options.countries.map((c) => (
<option key={c.code} value={c.code}>
{c.name}
</option>
))}
</select>
);
else if (name === "issuing_authority_id" || name === "authority_id")
input = (
<select
{...props}
className={control}
value={String(value ?? "")}
onChange={(e) => onChange(e.target.value || null)}
>
<option value="">Por indicar</option>
{options.authorities.map((a) => (
<option key={a.id} value={a.id}>
{a.label_pt_mz}
</option>
))}
</select>
);
else if (schema.enum)
input = (
<select
{...props}
className={control}
value={String(value ?? "")}
onChange={(e) => onChange(e.target.value || null)}
>
<option value="">Por indicar</option>
{schema.enum
.filter((v) => v !== null)
.map((v) => (
<option key={String(v)} value={String(v)}>
{String(v).replaceAll("_", " ")}
</option>
))}
</select>
);
else if (types.includes("boolean") || schema.const === true)
input = (
<select
{...props}
className={control}
value={value === true ? "true" : value === false ? "false" : ""}
onChange={(e) =>
onChange(
e.target.value === ""
? null
: e.target.value === "true",
)
}
>
<option value="">Por indicar</option>
<option value="true">Sim</option>
<option value="false">Não</option>
</select>
);
else if (types.includes("array")) {
const rows = Array.isArray(value) ? value : [];
let item = schema.items ?? { type: "string" };
if (item.$ref)
item = options.definitions[item.$ref.split("/").pop()!] ?? item;
const itemTypes = Array.isArray(item.type) ? item.type : [item.type];
return (
<fieldset className="space-y-2 rounded border p-3">
<legend>{label}</legend>
<FieldErrors path={path} errors={errors} />
{rows.map((v, i) => (
<div key={i} className="space-y-2">
<Editor
name={name}
path={path + "." + i}
schema={schema.items ?? { type: "string" }}
value={v}
options={options}
errors={errors}
onChange={(next) =>
onChange(
rows.map((r, j) => (j === i ? next : r)),
)
}
/>
<button
type="button"
className="underline"
onClick={() =>
onChange(rows.filter((_, j) => j !== i))
}
>
Retirar linha {i + 1}
</button>
</div>
))}
<button
type="button"
className="underline"
onClick={() =>
onChange([
...rows,
itemTypes.includes("object")
? {}
: itemTypes.includes("array")
? []
: "",
])
}
>
Adicionar linha
</button>
</fieldset>
);
} else if (types.includes("object") || schema.properties) {
const fields = schema.properties ?? {};
const data =
value && typeof value === "object" && !Array.isArray(value)
? (value as Data)
: {};
return (
<fieldset className="space-y-2 rounded border p-3">
<legend>{label}</legend>
<FieldErrors path={path} errors={errors} />
{Object.entries(fields).map(([key, s]) => (
<Editor
key={key}
name={key}
path={path + "." + key}
schema={s}
value={data[key]}
options={options}
errors={errors}
onChange={(v) => onChange({ ...data, [key]: v })}
/>
))}
{!Object.keys(fields).length && (
<p>
Este detalhe exige definição contratual antes da
submissão.
</p>
)}
</fieldset>
);
} else {
const numeric = types.includes("number") || types.includes("integer");
input =
numeric || schema.format === "date" ? (
<input
{...props}
className={control}
type={numeric ? "number" : "date"}
step={types.includes("integer") ? 1 : "any"}
value={String(value ?? "")}
onChange={(e) =>
onChange(
e.target.value === ""
? null
: numeric
? Number(e.target.value)
: e.target.value,
)
}
/>
) : (
<textarea
{...props}
className={control}
value={String(value ?? "")}
maxLength={schema.maxLength}
onChange={(e) => onChange(e.target.value)}
/>
);
}
return (
<div>
<label htmlFor={path} className="block">
{label}
</label>
{input}
<FieldErrors path={path} errors={errors} />
</div>
);
}
export default function OpportunityCanonicalFields({
value,
onChange,
options,
category,
organization,
actorId,
sectors,
disabled = false,
errors = {},
}: {
value: Data;
onChange: (v: Data) => void;
options: CanonicalOptions;
category: string;
organization: string | null;
actorId: number;
sectors: { id: number; name: string }[];
disabled?: boolean;
errors?: Record<string, string>;
}) {
const set = (key: string, v: unknown) =>
onChange({
...value,
[key]: v,
...(key === "sector_id"
? { subsector_id: null, economic_activity_id: null }
: key === "subsector_id"
? { economic_activity_id: null }
: {}),
opportunity_category: category,
promoter_id: organization ?? actorId,
});
const common = [
"official_title",
"promoter_type",
"internal_contact_id",
"publish_contact",
"public_contact_id",
"sector_id",
"subsector_id",
"economic_activity_id",
"location_mode",
"geographic_scope",
"multi_district_rationale",
"locations",
"executive_summary",
"demand_statement",
"documents",
"evidences",
"publication_languages",
"visibility",
"currency",
"review_due_date",
"images",
"truth_declaration",
];
const specialized =
category === "real_estate"
? ["real_estate"]
: category === "land_rights"
? ["land_rights"]
: ["business_sale", "business_partnership", "franchise"].includes(
category,
)
? ["business_transaction"]
: category === "investment_project"
? [
"opportunity_type",
"maturity_stage",
"investment_modalities",
"investor_profiles",
"products",
"assets",
"inputs",
"markets",
"competitive_advantage",
"employment",
"impact_indicators",
"total_investment",
"currency",
"investment_breakdown",
"secured_financing",
"funding_sought",
"financial_indicators",
"milestones",
"licenses",
"environmental_social",
"risks",
"relations",
]
: ["module_profile_version"];
return (
<fieldset disabled={disabled} className="space-y-4 rounded border p-4">
<legend>Contrato da oportunidade — {category}</legend>
<p>
O rascunho pode ficar incompleto. A submissão verifica os campos
aplicáveis e os recursos guardados. Validação interna não
equivale a autorização externa.
</p>
{Array.from(new Set([...common, ...specialized])).map((key) => {
if (
[
"sector_id",
"subsector_id",
"economic_activity_id",
"internal_contact_id",
"public_contact_id",
].includes(key)
) {
const rows =
key === "sector_id"
? sectors.map((s) => ({ id: s.id, label: s.name }))
: [
"internal_contact_id",
"public_contact_id",
].includes(key)
? options.contacts.map((c) => ({
id: c.id,
label: c.full_name,
}))
: options.activities
.filter((a) =>
key === "subsector_id"
? options.activities.some(
(root) =>
root.sector_id ===
Number(
value.sector_id,
) &&
a.parent_id === root.id,
)
: a.parent_id ===
value.subsector_id,
)
.map((a) => ({
id: a.id,
label: a.label_pt_mz,
}));
return (
<label key={key} className="block">
{labels[key]}
<FieldErrors
path={"canonical." + key}
errors={errors}
/>
<select
className={control}
value={String(value[key] ?? "")}
onChange={(e) =>
set(
key,
e.target.value === ""
? null
: key === "sector_id"
? Number(e.target.value)
: e.target.value,
)
}
>
<option value="">Por indicar</option>
{rows.map((r) => (
<option key={r.id} value={r.id}>
{r.label}
</option>
))}
</select>
</label>
);
}
if (["locations", "documents", "images"].includes(key)) {
const selected = Array.isArray(value[key])
? (value[key] as string[])
: [];
return (
<fieldset key={key}>
<legend>{labels[key]}</legend>
<FieldErrors
path={"canonical." + key}
errors={errors}
/>
{(options.resources[key] ?? []).map((r) => (
<label key={r.id} className="block">
<input
type="checkbox"
checked={selected.includes(r.id)}
onChange={(e) =>
set(
key,
e.target.checked
? [...selected, r.id]
: selected.filter(
(id) => id !== r.id,
),
)
}
/>{" "}
{r.payload.title ??
r.payload.role ??
r.file?.file_name ??
r.id}
<FieldErrors
path={`canonical.${key}.${r.id}`}
errors={errors}
/>
</label>
))}
{key === "locations" &&
selected.map((id) => (
<TerritoryGeometryPreview
key={id}
territoryId={resourceTerritory(
options.resources.locations?.find(
(r) => r.id === id,
),
)}
endpoint="/minhas-oportunidades/territory-geometries"
/>
))}
{!options.resources[key]?.length && (
<p>
Guarde primeiro em Recursos e regresse a
este contrato.
</p>
)}
</fieldset>
);
}
const schema = options.schema.properties?.[key];
return schema ? (
<Editor
key={key}
name={key}
path={"canonical." + key}
errors={errors}
schema={schema}
value={value[key]}
options={options}
onChange={(v) => set(key, v)}
/>
) : null;
})}
</fieldset>
);
}
@@ -0,0 +1,224 @@
import InteractiveInvestmentMap from "./interactive-investment-map";
import { control } from "@/pages/management/shared";
import type { MultiPolygon } from "geojson";
type Point = [number | null, number | null];
export default function OpportunityParcelGeometry({
value,
onChange,
}: {
value: unknown;
onChange: (v: unknown) => void;
}) {
const data =
value && typeof value === "object"
? (value as { coordinates?: Point[][][] })
: {};
const polygons = Array.isArray(data.coordinates) ? data.coordinates : [];
function replace(p: number, r: number, points: Point[]) {
onChange({
type: "MultiPolygon",
coordinates: polygons.map((poly, i) =>
i === p
? poly.map((ring, j) => (j === r ? points : ring))
: poly,
),
});
}
const valid =
polygons.length > 0 &&
polygons.every(
(poly) =>
poly.length > 0 &&
poly.every(
(ring) =>
ring.length >= 4 &&
ring.every(
(point) =>
point.length === 2 &&
point.every(
(c) =>
typeof c === "number" &&
Number.isFinite(c),
),
) &&
ring[0][0] === ring.at(-1)?.[0] &&
ring[0][1] === ring.at(-1)?.[1],
),
);
return (
<section className="space-y-2">
<p>
Indique longitude e latitude do perímetro declarado. O limite
administrativo serve de contexto; não define a parcela.
</p>
{polygons.map((poly, p) => (
<fieldset key={p} className="rounded border p-2">
<legend>Polígono {p + 1}</legend>
{poly.map((ring, r) => (
<section key={r}>
<h4>
{r === 0
? "Anel exterior"
: `Anel interior ${r}`}
</h4>
{ring.map((point, i) => (
<div key={i} className="flex flex-wrap gap-2">
{[0, 1].map((axis) => (
<label key={axis}>
{axis === 0
? "Longitude"
: "Latitude"}
<input
className={control}
type="number"
step="any"
min={axis === 0 ? -180 : -90}
max={axis === 0 ? 180 : 90}
value={point[axis] ?? ""}
onChange={(e) =>
replace(
p,
r,
ring.map((v, j) =>
j === i
? (v.map(
(c, k) =>
k ===
axis
? e
.target
.value ===
""
? null
: Number(
e
.target
.value,
)
: c,
) as Point)
: v,
),
)
}
/>
</label>
))}
<button
type="button"
onClick={() =>
replace(
p,
r,
ring.filter((_, j) => j !== i),
)
}
>
Retirar vértice {i + 1}
</button>
</div>
))}
<button
type="button"
className="underline mr-4"
onClick={() =>
replace(p, r, [...ring, [null, null]])
}
>
Adicionar vértice
</button>
<button
type="button"
className="underline mr-4"
disabled={
!ring.length ||
ring[0].some((c) => c === null)
}
onClick={() =>
replace(p, r, [
...ring,
[...ring[0]] as Point,
])
}
>
Fechar anel
</button>
<button
type="button"
onClick={() =>
onChange({
type: "MultiPolygon",
coordinates: polygons.map((v, i) =>
i === p
? v.filter((_, j) => j !== r)
: v,
),
})
}
>
Retirar anel
</button>
</section>
))}
<button
type="button"
className="underline mr-4"
onClick={() =>
onChange({
type: "MultiPolygon",
coordinates: polygons.map((v, i) =>
i === p ? [...v, []] : v,
),
})
}
>
Adicionar anel interior
</button>
<button
type="button"
onClick={() =>
onChange({
type: "MultiPolygon",
coordinates: polygons.filter((_, i) => i !== p),
})
}
>
Retirar polígono
</button>
</fieldset>
))}
<button
type="button"
className="underline"
onClick={() =>
onChange({
type: "MultiPolygon",
coordinates: [...polygons, [[]]],
})
}
>
Adicionar polígono
</button>
{valid && (
<InteractiveInvestmentMap
points={[]}
contextOnly
areas={[
{
purpose: "declared_parcel",
title: "Perímetro declarado pelo Promotor",
source_reference:
"Declaração do Promotor; revisão cadastral pendente",
url: "#",
geometry: {
type: "MultiPolygon",
coordinates: polygons as [number, number][][][],
} as MultiPolygon,
},
]}
/>
)}
</section>
);
}
@@ -0,0 +1,335 @@
import { router } from '@inertiajs/react';
import { useState } from 'react';
import { profileJson, ProfileValidationError } from '@/lib/profile-json';
import { button, control } from '@/pages/management/shared';
export default function OpportunityProfileActions({
id,
etag,
actions,
gates,
documents,
approvalHash,
onErrors,
participants = [],
publishers = [],
opinions = [],
publicationVisibility,
}: {
id: number;
etag: string;
actions: string[];
gates: string[];
documents: { id: string; title: string }[];
approvalHash?: string;
publicationVisibility?: string;
onErrors?: (errors: Record<string, string>) => void;
publishers?: { id: number; name: string }[];
participants?: {
id: number;
name: string;
technical: boolean;
legal: boolean;
}[];
opinions?: {
id: string;
gate: string;
recipient_id: number;
status: string;
}[];
}) {
const [reason, setReason] = useState('');
const [items, setItems] = useState('');
const [busy, setBusy] = useState(false);
const [message, setMessage] = useState('');
const [gate, setGate] = useState(gates[0] ?? '');
const [decision, setDecision] = useState('approved');
const [evidence, setEvidence] = useState<string[]>([]);
const [assignee, setAssignee] = useState('');
const [confirmed, setConfirmed] = useState(false);
const [recipient, setRecipient] = useState('');
const [opinion, setOpinion] = useState('');
const [actionErrors, setActionErrors] = useState<Record<string, string>>(
{},
);
const labels: Record<string, string> = {
submit: 'Submeter para validação',
approve: 'Aprovar versão',
publish:
publicationVisibility === 'public'
? 'Publicar no catálogo público'
: 'Disponibilizar com acesso restrito',
request_revision: 'Preparar alteração material',
review_gate: 'Guardar revisão especializada',
assign_review: 'Atribuir validação',
assign_publication: 'Atribuir publicação',
appeal_uphold: 'Manter rejeição após recurso',
appeal_reopen: 'Reabrir para correção',
request_archive: 'Solicitar arquivo',
appeal: 'Apresentar recurso',
start_review: 'Iniciar validação',
request_correction: 'Solicitar correções',
pending_opinion: 'Solicitar parecer',
respond_opinion: 'Responder ao parecer',
reject: 'Rejeitar com fundamento',
suspend: 'Suspender',
archive: 'Arquivar',
};
async function send(action: string) {
setBusy(true);
setActionErrors({});
onErrors?.({});
try {
const result = await profileJson(
`/minhas-oportunidades/${id}/workflow`,
{
etag,
action,
reason,
correction_items: items
.split('\n')
.map((v) => v.trim())
.filter(Boolean),
...(['review_gate', 'respond_opinion'].includes(action)
? {
gate,
gate_decision: decision,
evidence_document_ids: evidence,
}
: {}),
...(action === 'pending_opinion'
? { gate, recipient_user_id: Number(recipient) }
: {}),
...(action === 'respond_opinion'
? { opinion_id: opinion }
: {}),
...(['assign_review', 'assign_publication'].includes(action)
? { assignee_user_id: Number(assignee) }
: {}),
...(action === 'publish'
? {
confirm_publication: confirmed,
preview_hash: approvalHash,
}
: {}),
},
);
setMessage(result.message);
router.visit(`/minhas-oportunidades/${id}/view`);
} catch (error) {
if (error instanceof ProfileValidationError) {
setActionErrors(error.fields);
onErrors?.(error.fields);
}
setMessage(
error instanceof Error
? error.message
: 'Resposta indisponível. Confira o estado antes de repetir.',
);
} finally {
setBusy(false);
}
}
return (
<section
className="space-y-3 rounded border p-4"
aria-label="Workflow interno"
>
<h2 className="text-lg font-semibold">Workflow interno</h2>
<p>
Guarde o contrato antes de submeter. Aprovação exige revisões
especializadas desta versão; publicação exige outro utilizador
autorizado. Uma decisão interna não substitui decisão externa.
</p>
<p>
Aprovação interna confirma a revisão desta versão.
Disponibilização restrita não aparece no catálogo público nem dá
acesso a todas as contas. A publicação pública exige âmbito
público e ação independente do Publicador; não representa uma
decisão externa.
</p>
{!!actions.length && (
<>
<label className="block">
Fundamentação
<textarea
className={control}
minLength={20}
maxLength={1000}
value={reason}
onChange={(e) => setReason(e.target.value)}
/>
</label>
{actions.includes('request_correction') && (
<label className="block">
Campos ou documentos a corrigir, um por linha
<textarea
className={control}
value={items}
onChange={(e) => setItems(e.target.value)}
/>
</label>
)}
{(actions.includes('review_gate') ||
actions.includes('pending_opinion') ||
actions.includes('respond_opinion')) && (
<fieldset>
<legend>Revisão especializada</legend>
<label>
Revisão
<select
className={control}
value={gate}
onChange={(e) => setGate(e.target.value)}
>
{gates.map((g) => (
<option key={g} value={g}>
{g.replaceAll('_', ' ')}
</option>
))}
</select>
</label>
<label>
Decisão
<select
className={control}
value={decision}
onChange={(e) =>
setDecision(e.target.value)
}
>
<option value="approved">Aprovada</option>
<option value="rejected">Rejeitada</option>
</select>
</label>
{documents.map((d) => (
<label key={d.id} className="block">
<input
type="checkbox"
checked={evidence.includes(d.id)}
onChange={(e) =>
setEvidence(
e.target.checked
? [...evidence, d.id]
: evidence.filter(
(id) => id !== d.id,
),
)
}
/>{' '}
{d.title}
</label>
))}
</fieldset>
)}
{(actions.includes('assign_review') ||
actions.includes('assign_publication')) && (
<label className="block">
Responsável a designar
<select
className={control}
value={assignee}
onChange={(e) => setAssignee(e.target.value)}
>
<option value="">Por atribuir</option>
{(actions.includes('assign_publication')
? publishers
: participants
).map((p) => (
<option key={p.id} value={p.id}>
{p.name}
</option>
))}
</select>
<span>
O servidor verifica o papel, âmbito e
independência. Nenhum responsável é atribuído
automaticamente.
</span>
</label>
)}
{actions.includes('pending_opinion') && (
<label className="block">
Destinatário do parecer
<select
className={control}
value={recipient}
onChange={(e) => setRecipient(e.target.value)}
>
<option value="">Por designar</option>
{participants
.filter((p) =>
/legal|registry|authority|confidentiality|license/.test(
gate,
)
? p.legal
: p.technical,
)
.map((p) => (
<option key={p.id} value={p.id}>
{p.name}
</option>
))}
</select>
</label>
)}
{actions.includes('respond_opinion') && (
<label className="block">
Parecer atribuído
<select
className={control}
value={opinion}
onChange={(e) => setOpinion(e.target.value)}
>
<option value="">Selecione</option>
{opinions
.filter((o) => o.status === 'pending')
.map((o) => (
<option key={o.id} value={o.id}>
{o.gate.replaceAll('_', ' ')} —
conta {o.recipient_id}
</option>
))}
</select>
</label>
)}
{Object.entries(actionErrors)
.filter(([key]) => !key.startsWith('canonical'))
.map(([key, msg]) => (
<p key={key} role="alert">
{key}: {msg}
</p>
))}
{actions.includes('publish') && (
<label className="block">
<input
type="checkbox"
checked={confirmed}
onChange={(e) => setConfirmed(e.target.checked)}
/>{' '}
Confirmei a pré-visualização e o âmbito de
divulgação desta versão.
</label>
)}
<div className="flex flex-wrap gap-3">
{actions.map((action) => (
<button
key={action}
className={button}
disabled={
busy || (action === 'publish' && !confirmed)
}
onClick={() => void send(action)}
>
{labels[action] ?? action}
</button>
))}
</div>
</>
)}
<p role="status" aria-live="polite">
{message}
</p>
</section>
);
}
@@ -1,5 +1,7 @@
import type { ProfileAccess } from '@/types/profile-access';
import { Link, usePage } from '@inertiajs/react';
import { useEffect, useId, useRef, useState } from 'react';
import type { OpportunityManagementAccess } from '@/types/opportunity-management';
import {
portalNavigation,
currentNavigationGroup,
@@ -14,6 +16,8 @@ export function PortalGroupedMenu() {
educationEnabled?: boolean;
aiEnabled?: boolean;
portalOperator?: string | null;
profileAccess?: ProfileAccess | null;
opportunityManagement?: OpportunityManagementAccess | null;
}>();
const groups = portalNavigation({
authenticated: !!props.auth?.user,
@@ -21,6 +25,8 @@ export function PortalGroupedMenu() {
businesses: props.existingBusinessEnabled,
education: props.educationEnabled,
ai: props.aiEnabled,
opportunityManagement: props.opportunityManagement,
profileAccess: props.profileAccess,
});
const current = currentNavigationGroup(groups, url);
const currentItem = currentNavigationItem(groups, url);
@@ -0,0 +1,56 @@
import { Link, usePage } from '@inertiajs/react';
import type { ProfileAccess } from '@/types/profile-access';
export function profileLinks(access: ProfileAccess | null | undefined) {
if (!access) return [];
return [
...(access.mine
? [{ title: 'Minhas oportunidades', href: access.mine }]
: []),
...(access.create
? [{ title: 'Nova oportunidade', href: access.create }]
: []),
{
title: access.mine
? 'Autorizações de Promotor'
: 'Solicitar perfil de Promotor',
href: access.request,
},
...(!access.mine && access.review
? [{ title: 'Revisão de oportunidades', href: access.review }]
: []),
...(access.audit
? [{ title: 'Auditoria de acessos', href: access.audit }]
: []),
...(access.administration
? [{ title: 'Gestão de perfis', href: access.administration }]
: []),
...(access.administration
? [
{
title: 'Instalação dos perfis 040000',
href: '/management/profile-install',
},
]
: []),
];
}
export default function ProfileNavigation() {
const { profileAccess } = usePage<{
profileAccess?: ProfileAccess | null;
}>().props;
if (!profileAccess) return null;
return (
<nav
aria-label="Perfil e oportunidades"
className="flex flex-wrap gap-4 rounded border p-4"
>
{profileLinks(profileAccess).map((link) => (
<Link key={link.href} href={link.href} className="underline">
{link.title}
</Link>
))}
</nav>
);
}
@@ -13,9 +13,11 @@ type Context = {
export default function TerritoryGeometryPreview({
territoryId,
management = false,
endpoint: suppliedEndpoint,
}: {
territoryId?: string;
management?: boolean;
endpoint?: string;
}) {
const [context, setContext] = useState<Context | null>(null);
const [error, setError] = useState('');
@@ -24,9 +26,9 @@ export default function TerritoryGeometryPreview({
setError('');
if (!territoryId) return;
const controller = new AbortController();
const endpoint = management
const endpoint = suppliedEndpoint ?? (management
? '/management/territory-geometries'
: '/api/v1/investment/territory-geometries';
: '/api/v1/investment/territory-geometries');
void fetch(
`${endpoint}?${new URLSearchParams({ territory_id: territoryId })}`,
{
@@ -51,7 +53,7 @@ export default function TerritoryGeometryPreview({
);
});
return () => controller.abort();
}, [territoryId, management]);
}, [territoryId, management, suppliedEndpoint]);
if (!territoryId) return null;
return (
<section
@@ -66,7 +68,7 @@ export default function TerritoryGeometryPreview({
<p role="status">
{context.selected_geometry_available
? 'Limite administrativo disponível para este território.'
: 'Sem limite administrativo disponível para este território.'}
: 'Sem limite administrativo acessível para este território neste perfil.'}
</p>
<p>
{context.context_geometry_count} limites disponíveis na