Compare commits

...
19 Commits
Author SHA1 Message Date
nala 3b1689ca0f commit3
tests / ci (push) Canceled after 0s
2026-10-28 20:51:30 +02:00
nala ee17ff7764 Implementa recomendação formal com adopção e conferência independente 2026-10-28 20:49:30 +02:00
nala 29cd859385 Prepara proposta navegável de recomendação antes da adjudicação 2026-10-28 20:35:17 +02:00
nala d020be53ed Implementa admissão formal por política e adopção do processo 2026-10-28 20:28:15 +02:00
nala 03ab308e02 Prepara circuito configuravel de admissao e exclusao para validacao 2026-10-28 19:51:03 +02:00
nala 2751c6468d Reune comparacao e qualificacao em relatorio de conferencia imprimivel 2026-10-28 19:41:45 +02:00
nala 9138379432 Implementa qualificacao documental com requisitos e analises por versao 2026-10-28 19:28:05 +02:00
nala b7a52e9e00 Prepara proposta interactiva de qualificacao por processo 2026-10-28 19:10:40 +02:00
nala 07e775c492 Regista abertura de propostas e actas imutaveis por versao 2026-10-28 18:50:02 +02:00
nala 513f430edf Implementa planeamento de compras com marcos e responsabilidades por empresa 2026-10-28 18:30:41 +02:00
nala 76d2463f36 Reune etapas documentos e decisoes na visao do processo de compra 2026-10-28 18:13:17 +02:00
nala 0f32e517da Documenta exemplos locais para orquestrar compras por empresa 2026-10-28 18:04:06 +02:00
nala dc90129c59 Valida concorrencia PostgreSQL da revisao de compras 2026-10-28 17:59:05 +02:00
nala ff403ea927 Implementa revisao de adjudicacoes e navegacao partilhada do SGC 2026-10-28 17:46:59 +02:00
nala 5ff8d78803 Corrige autorizacao transaccional e valida modulos implementados 2026-10-28 17:19:33 +02:00
nala 95dd2cc1ed Implementa regras de investimento por empresa com dupla aprovacao 2026-10-28 16:57:45 +02:00
nala 153ba2c1af Implementa reforcos orcamentais com aprovacao independente 2026-10-28 15:03:49 +02:00
nala c41628d738 Implementa registo e conferencia de pagamentos externos 2026-10-28 14:51:53 +02:00
nala f0f7b8ce9d Documenta validacao bancaria e proxima etapa de pagamentos 2026-10-28 14:37:38 +02:00
201 changed files with 19167 additions and 280 deletions
+28 -3
View File
@@ -23,6 +23,31 @@ Crie um pedido, guarde o rascunho, confira os valores e submeta. Entre com as co
## Entrega actual
- Regras de investimento próprias por empresa: tecto por processo, base de IVA
e vigência explícitos, com duas aprovações administrativas distintas do autor.
Equipamento exige também validação técnica, Finanças e reserva em dotação de
investimento. Regra congelada na adjudicação/ordem; mudança de base bloqueia
emissão com aprovações antigas. Migração 000014 aplicada após backup/restauro
verificados. Sem regras ou limites fictícios na base real.
- Reforços de orçamento por empresa/centro/exercício, com proposta, aprovação
independente e histórico imutável. A dotação inicial e a base de IVA são
preservadas; apenas reforços aprovados aumentam o saldo disponível. Migração
000013 aplicada após backup/restauro verificados; três cenários concorrentes
PostgreSQL aprovados. Exemplo público em `/consulta/reforcos`.
- Registo de pagamentos externos por empresa, com conferência independente,
liquidação parcial/total de facturas e revalidação da versão bancária. Sem
consumo duplicado do orçamento ou execução de transferências. Migração 000012
aplicada após backup/restauro verificados; três cenários concorrentes PostgreSQL
aprovados. Interface `/pagamentos`; demonstração `/consulta/pagamentos`.
- Dados bancários por fornecedor/empresa: versões propostas por Procurement,
duas validações distintas por Finanças, dados sensíveis cifrados, consultas
restritas e auditoria sem números de conta. Alterações exigem duas novas
decisões. Migração 000011 aplicada após backup/restauro verificados; três
cenários concorrentes PostgreSQL aprovados. Não executa pagamentos.
- Facturas por empresa/fornecedor/ordem, conferência exacta com recepções aceites,
facturação parcial, validação independente por Finanças e conversão de compromisso
em consumo. Migração 000010 aplicada após backup/restauro verificados; três
@@ -34,10 +59,10 @@ Crie um pedido, guarde o rascunho, confira os valores e submeta. Entre com as co
Migração 000009 aplicada após backup e restauro verificados; cinco cenários
concorrentes PostgreSQL aprovados. Sem dotações fictícias na base real.
Centros sem dotação mantêm o circuito de desenvolvimento sem controlo.
Reforços e pagamentos continuam pendentes; não constitui validação
Estornos continuam pendentes; não constitui validação
operacional integral do orçamento. Interface em `/orcamentos`.
- Equipamentos e peças ligados aos artigos existentes, compatibilidades, criticidade configurada, mínimos explícitos e alertas, saídas rastreáveis e validação técnica. Finanças é obrigatória para equipamento em qualquer valor; a adjudicação/emissão de investimento continua bloqueada até definição do limite próprio. Migração 000008 aplicada no lote 9 após backup recuperável e verificação da preservação. Demonstração em `/consulta/equipamentos`.
- Equipamentos e peças ligados aos artigos existentes, compatibilidades, criticidade configurada, mínimos explícitos e alertas, saídas rastreáveis e validação técnica. Finanças é obrigatória para equipamento em qualquer valor; a adjudicação/emissão exige regra própria vigente e reserva em dotação de investimento. Migração 000008 aplicada no lote 9 após backup recuperável e verificação da preservação. Demonstração em `/consulta/equipamentos`.
- Página inicial em `/`, demonstração pública por módulo em `/consulta` e navegação autenticada agrupada por área e perfil.
- Recepções parciais/totais com qualidade, divergências, quantidades pendentes e segregação do emitente. Entradas de stock apenas para quantidades físicas aceites, sem duplicação; catálogo, armazéns, existências e histórico por empresa.
- Saídas com destino, responsável e fundamento; transferências atómicas; contagens físicas e ajustes justificados, com histórico e protecção contra saldos negativos e contagens desactualizadas. Migração 000007 aplicada na base actual, lote 8, após backup com recuperação ensaiada e confirmação da preservação dos registos; demonstração em `/consulta/operacoes-stock`.
@@ -69,7 +94,7 @@ O IVA é informado pelo utilizador e calculado no servidor. A taxa inicial de 0%
## Próximas etapas
Revisão visual dos módulos entregues; reposição de stock; dados bancários com dupla validação; reforços orçamentais, correcções de facturas e pagamentos; moedas e câmbio; subscrições, licenças e Docker. Equipamentos, peças, validação técnica e alertas de mínimo já estão implementados; a adjudicação de equipamento aguarda a definição da regra de investimento. Periodicidade dos inventários, tolerâncias e investigação de divergências exigem decisão da empresa. A política de periodicidade, validade e levantamento de conflitos e os procedimentos de revisão/cancelamento de adjudicações continuam por definir.
Revisão visual dos módulos entregues; reposição de stock; conciliação de pagamentos externos; revisão/cancelamento de processos, correcções de facturas e estornos; moedas e câmbio; subscrições, licenças e Docker. Equipamentos, peças, validação técnica e alertas de mínimo já estão implementados; cada empresa deve configurar e aprovar a sua regra e dotação de investimento antes de adjudicar equipamento. Periodicidade dos inventários, tolerâncias e investigação de divergências exigem decisão da empresa. A política de periodicidade, validade e levantamento de conflitos e os procedimentos de revisão/cancelamento de adjudicações continuam por definir.
O cadastro guarda referências e ficheiros anexos no disco privado `supplier_documents`, em `storage/app/supplier-documents`, fora da pasta pública e sem URLs públicas. As fichas abrem pelo directório **Fornecedores → Ver ficha → Abrir ficha, edição e documentos**. As versões antigas e documentos existentes são preservados na auditoria e no armazenamento; nesta entrega não há eliminação de documentos, antivírus, quotas acumuladas ou política de retenção. A validação do NUIT é de formato e unicidade, sem consulta a uma autoridade fiscal. Além das declarações por operação, existem declarações pessoais por fornecedor e processo; a periodicidade anual e a política de validade/levantamento ainda não foram definidas. As propostas e avaliações registadas não são editáveis nesta etapa. Os pesos 40/20/15/15/10 são provisórios e ficam guardados por proposta. A comparação liga à fase de adjudicação e emissão. A ordem exige novas aprovações do valor final e revalidação no servidor. As propostas usam MZN; a multimoeda fica para a fase correspondente.
+11 -4
View File
@@ -6,8 +6,10 @@ use App\Enums\PurchasingRole;
use App\Models\Budget;
use App\Models\BudgetConsumption;
use App\Models\BudgetEntry;
use App\Models\BudgetReinforcement;
use App\Models\CostCenter;
use App\Services\ConflictGuard;
use App\Services\CurrentActor;
use App\Services\RequisitionWorkflow;
use Brick\Math\BigDecimal;
use Illuminate\Http\RedirectResponse;
@@ -34,18 +36,22 @@ class BudgetController extends Controller
$committed = (int) $entries->sum('committed_minor');
$consumed = (int) BudgetConsumption::query()->where('budget_id', $budget->id)->sum('amount_minor');
return [...$budget->toArray(), 'reserved_minor' => $reserved, 'committed_minor' => $committed, 'consumed_minor' => $consumed, 'available_minor' => $budget->amount_minor - $reserved - $committed - $consumed];
})]);
$total = $budget->approvedTotalMinor();
return [...$budget->toArray(), 'reinforced_minor' => $total - $budget->amount_minor, 'approved_total_minor' => $budget->approved_by ? $total : 0, 'reserved_minor' => $reserved, 'committed_minor' => $committed, 'consumed_minor' => $consumed, 'available_minor' => $budget->approved_by ? $total - $reserved - $committed - $consumed : 0];
}), 'reinforcements' => BudgetReinforcement::query()->latest('id')->paginate(20)]);
}
public function store(Request $request): RedirectResponse
{
$this->access($request);
$data = $request->validate(['cost_center_id' => ['required', 'integer', Rule::exists('cost_centers', 'id')->where('tenant_id', $request->user()->tenant_id)], 'year' => 'required|integer|min:2026|max:2100', 'includes_tax' => 'required|boolean', 'amount' => ['required', 'regex:/^\d{1,12}(\.\d{1,2})?$/'], 'reason' => 'required|string|max:4000']);
DB::transaction(function () use ($request, $data) {
$kind = $request->validate(['kind' => ['sometimes', Rule::in(['operating', 'investment'])]])['kind'] ?? 'operating';
DB::transaction(function () use ($request, $data, $kind) {
app(ConflictGuard::class)->lockCompany($request->user());
app(CurrentActor::class)->lock($request->user(), [PurchasingRole::Admin, PurchasingRole::Finance]);
abort_if(Budget::query()->where('cost_center_id', $data['cost_center_id'])->where('year', $data['year'])->exists(), 409, 'Já existe dotação para este centro e exercício.');
$budget = Budget::query()->create(['tenant_id' => $request->user()->tenant_id, 'created_by' => $request->user()->id, 'cost_center_id' => $data['cost_center_id'], 'year' => $data['year'], 'includes_tax' => $data['includes_tax'], 'amount_minor' => BigDecimal::of($data['amount'])->multipliedBy(100)->toInt(), 'reason' => $data['reason']]);
$budget = Budget::query()->create(['tenant_id' => $request->user()->tenant_id, 'created_by' => $request->user()->id, 'cost_center_id' => $data['cost_center_id'], 'year' => $data['year'], 'kind' => $kind, 'includes_tax' => $data['includes_tax'], 'amount_minor' => BigDecimal::of($data['amount'])->multipliedBy(100)->toInt(), 'reason' => $data['reason']]);
app(RequisitionWorkflow::class)->audit($request->user(), 'budget.created', null, null, $budget->toArray());
});
@@ -57,6 +63,7 @@ class BudgetController extends Controller
$this->access($request);
DB::transaction(function () use ($request, $budget) {
app(ConflictGuard::class)->lockCompany($request->user());
app(CurrentActor::class)->lock($request->user(), [PurchasingRole::Admin, PurchasingRole::Finance]);
$budget = Budget::query()->lockForUpdate()->findOrFail($budget->id);
abort_if($budget->created_by === $request->user()->id, 403);
if ($budget->approved_by) {
@@ -0,0 +1,30 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\Budget;
use App\Models\BudgetReinforcement;
use App\Services\BudgetReinforcementWorkflow;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
class BudgetReinforcementController extends Controller
{
public function store(Request $request, Budget $budget, BudgetReinforcementWorkflow $workflow): RedirectResponse
{
abort_unless(in_array($request->user()->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Finance]), 403);
$data = $request->validate(['reference' => 'required|string|max:100', 'amount' => ['required', 'regex:/^\d{1,12}(\.\d{1,2})?$/'], 'reason' => 'required|string|max:4000']);
$workflow->propose($request->user(), $budget, $data);
return back();
}
public function review(Request $request, BudgetReinforcement $reinforcement, BudgetReinforcementWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['decision' => 'required|in:approved,rejected', 'reason' => 'required|string|max:4000']);
$workflow->review($request->user(), $reinforcement, $data['decision'], $data['reason']);
return back();
}
}
@@ -0,0 +1,87 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\PurchaseAward;
use App\Models\QualificationAssessment;
use App\Models\QualificationSet;
use App\Models\Requisition;
use App\Services\ConflictGuard;
use App\Services\DocumentaryQualificationWorkflow;
use App\Services\ProposalComparison;
use App\Services\ProposalOpeningWorkflow;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class DocumentaryQualificationController extends Controller
{
private function access(Request $request, int $id): Requisition
{
abort_unless(in_array($request->user()->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance, PurchasingRole::DepartmentHead]), 403);
return Requisition::query()->visibleTo($request->user())->findOrFail($id);
}
public function show(Request $request, Requisition $requisition, ProposalOpeningWorkflow $opening): Response
{
$this->access($request, $requisition->id);
$filters = $request->validate(['version' => 'nullable|integer|min:1']);
$sets = QualificationSet::query()->where('requisition_id', $requisition->id)->latest('revision')->get(['id', 'revision', 'reason', 'created_at']);
$latest = $sets->first() ? QualificationSet::query()->findOrFail($sets->first()->id) : null;
$selected = isset($filters['version']) ? QualificationSet::query()->where('requisition_id', $requisition->id)->findOrFail((int) $filters['version']) : $latest;
$proposals = $opening->proposals($requisition);
$basis = $opening->basis($proposals);
$current = $selected && $selected->id === $latest?->id && $selected->basis_hash === $basis;
$closed = $requisition->status !== 'approved' || PurchaseAward::query()->where('requisition_id', $requisition->id)->exists();
$open = ! $closed && ! app(ConflictGuard::class)->participationBlocked($request->user(), $requisition);
$query = QualificationAssessment::query()->where('qualification_set_id', $selected->id ?? 0);
$recordIds = (clone $query)->selectRaw('MAX(id)')->groupBy('quotation_id', 'analyst_id');
$records = QualificationAssessment::query()->whereIn('id', $recordIds)->orderBy('quotation_id')->orderBy('analyst_id')->get();
Inertia::encryptHistory();
$response = Inertia::render('purchases/qualification', [
'requisition' => $requisition->only(['id', 'number', 'justification']), 'sets' => $sets, 'selected' => $selected,
'latestId' => $latest->id ?? 0, 'latestCriteria' => $latest->criteria ?? [], 'basisHash' => $basis, 'isCurrent' => (bool) $current,
'proposals' => $proposals,
'closedForChanges' => $closed,
'records' => $records, 'history' => $query->latest('id')->paginate(20)->withQueryString(), 'actorId' => $request->user()->id,
'canDefine' => $open && $proposals !== [] && $request->user()->purchasing_role === PurchasingRole::Procurement,
'canAssess' => $open && $current && $request->user()->id !== $requisition->requester_id && app(ProposalComparison::class)->eligibleRole($request->user(), $requisition),
])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function define(Request $request, Requisition $requisition, DocumentaryQualificationWorkflow $workflow): RedirectResponse
{
$this->access($request, $requisition->id);
$data = $request->validate([
'previous_id' => 'required|integer|min:0', 'basis_hash' => 'required|string|size:64', 'reason' => 'required|string|min:10|max:4000',
'criteria' => 'required|array|min:1|max:30', 'criteria.*' => 'required|array:label,category,required',
'criteria.*.label' => 'required|string|min:3|max:500', 'criteria.*.category' => 'required|in:legal,financial,fiscal,technical,administrative', 'criteria.*.required' => 'required|boolean',
'snapshot' => 'prohibited', 'tenant_id' => 'prohibited', 'created_by' => 'prohibited',
]);
$workflow->define($request->user(), $requisition, $data);
return to_route('qualifications.show', $requisition);
}
public function assess(Request $request, QualificationSet $set, DocumentaryQualificationWorkflow $workflow): RedirectResponse
{
$this->access($request, $set->requisition_id);
$data = $request->validate([
'previous_id' => 'required|integer|min:0', 'quotation_id' => 'required|integer', 'reason' => 'required|string|min:10|max:4000',
'answers' => 'required|array|min:1|max:30', 'answers.*' => 'required|array:criterion_id,result,evidence,reason',
'answers.*.criterion_id' => 'required|integer|distinct', 'answers.*.result' => 'required|in:pending,met,not_met,not_applicable',
'answers.*.evidence' => 'nullable|string|max:1000', 'answers.*.reason' => 'nullable|string|max:4000',
'snapshot' => 'prohibited', 'analyst_id' => 'prohibited', 'tenant_id' => 'prohibited', 'revision' => 'prohibited',
]);
$data['answers'] = array_map(fn ($answer) => [...$answer, 'criterion_id' => (int) $answer['criterion_id']], $data['answers']);
$workflow->assess($request->user(), $set, $data);
return to_route('qualifications.show', $set->requisition_id);
}
}
@@ -0,0 +1,57 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\ExternalPayment;
use App\Models\Invoice;
use App\Models\Supplier;
use App\Models\SupplierBankDetail;
use App\Services\ExternalPaymentWorkflow;
use App\Services\RequisitionWorkflow;
use App\Services\SupplierBankWorkflow;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class ExternalPaymentController extends Controller
{
public function index(Request $request, ExternalPaymentWorkflow $workflow): Response
{
abort_unless(in_array($request->user()->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Finance]), 403);
$canManage = $request->user()->purchasing_role === PurchasingRole::Finance;
$payments = ExternalPayment::query()->latest('id')->paginate(15)->through(fn ($payment) => [...$payment->toArray(), 'external_reference' => $canManage ? $payment->external_reference : null, 'evidence_reference' => $canManage ? $payment->evidence_reference : null]);
if ($canManage && $payments->count() > 0) {
app(RequisitionWorkflow::class)->audit($request->user(), 'payment.viewed', null, null, ['payment_ids' => $payments->pluck('id')->all()]);
}
$invoices = Invoice::query()->where('status', 'validated')->latest('id')->get()->map(function (Invoice $invoice) use ($workflow) {
$supplier = Supplier::query()->findOrFail($invoice->supplier_id);
$bank = SupplierBankDetail::query()->where('supplier_id', $supplier->id)->latest('revision')->first();
return ['id' => $invoice->id, 'number' => $invoice->number, 'supplier_id' => $supplier->id, 'supplier_name' => $supplier->name, 'total_minor' => $invoice->total_minor, 'outstanding_minor' => $workflow->outstanding($invoice), 'bank_id' => $bank->id ?? 0, 'bank_revision' => $bank->revision ?? 0, 'bank_state' => app(SupplierBankWorkflow::class)->state($supplier)];
});
Inertia::encryptHistory();
$response = Inertia::render('payments/index', ['invoices' => $invoices, 'payments' => $payments, 'canManage' => $canManage])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function store(Request $request, Invoice $invoice, ExternalPaymentWorkflow $workflow): RedirectResponse
{
abort_unless($request->user()->purchasing_role === PurchasingRole::Finance, 403);
$data = $request->validate(['supplier_bank_detail_id' => 'required|integer|min:1', 'amount' => ['required', 'regex:/^\d{1,12}(\.\d{1,2})?$/'], 'paid_on' => 'required|date_format:Y-m-d', 'external_reference' => 'required|string|max:150', 'evidence_reference' => 'required|string|max:1000']);
$workflow->register($request->user(), $invoice, $data);
return to_route('payments.index');
}
public function review(Request $request, ExternalPayment $payment, ExternalPaymentWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['decision' => 'required|in:confirmed,rejected', 'reason' => 'required|string|max:2000', 'independently_verified' => 'accepted']);
$workflow->review($request->user(), $payment, $data['decision'], $data['reason']);
return back();
}
}
@@ -0,0 +1,107 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\AdmissionAdoption;
use App\Models\AdmissionDecision;
use App\Models\AdmissionPolicy;
use App\Models\AdmissionReview;
use App\Models\PurchaseAward;
use App\Models\Requisition;
use App\Services\ConflictGuard;
use App\Services\FormalAdmission;
use App\Services\ProposalOpeningWorkflow;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class FormalAdmissionController extends Controller
{
private function access(Request $request, int $id): Requisition
{
abort_unless(in_array($request->user()->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance, PurchasingRole::DepartmentHead]), 403);
return Requisition::query()->visibleTo($request->user())->findOrFail($id);
}
public function policy(Request $request): Response
{
abort_unless($request->user()->purchasing_role === PurchasingRole::Admin, 403);
Inertia::encryptHistory();
$response = Inertia::render('purchases/admission-policy', ['policies' => AdmissionPolicy::query()->latest('revision')->paginate(20)->withQueryString(), 'latest' => AdmissionPolicy::query()->latest('revision')->first()])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function configure(Request $request, FormalAdmission $workflow): RedirectResponse
{
$data = $request->validate(['previous_id' => 'required|integer|min:0', 'enabled' => 'required|boolean', 'roles' => 'required|array|min:1|max:2', 'roles.*' => 'required|distinct|in:finance,department_head', 'required_count' => 'required|integer|min:1|max:50', 'reason' => 'required|string|min:10|max:4000', 'tenant_id' => 'prohibited', 'created_by' => 'prohibited', 'snapshot' => 'prohibited']);
$data['enabled'] = (bool) $data['enabled'];
$workflow->policy($request->user(), $data);
return to_route('admissions.policy');
}
public function show(Request $request, Requisition $requisition, FormalAdmission $workflow, ProposalOpeningWorkflow $opening): Response
{
$requisition = $this->access($request, $requisition->id);
$filter = $request->validate(['version' => 'nullable|integer|min:1']);
$adoption = $workflow->adoption($requisition);
$selected = isset($filter['version']) ? AdmissionAdoption::query()->where('requisition_id', $requisition->id)->findOrFail((int) $filter['version']) : $adoption;
$current = $selected && $selected->id === $adoption?->id;
$closed = $requisition->status !== 'approved' || PurchaseAward::query()->where('requisition_id', $requisition->id)->exists();
$open = ! $closed && ! app(ConflictGuard::class)->participationBlocked($request->user(), $requisition);
$decisions = AdmissionDecision::query()->where('admission_adoption_id', $selected->id ?? 0)->latest('id')->get();
$latestIds = $decisions->unique('quotation_id')->pluck('id');
$proposals = collect($opening->proposals($requisition))->map(function ($quote) use ($workflow, $requisition, $decisions) {
$basis = $workflow->basis($requisition, $quote['id']);
return [...$quote, 'basisHash' => $basis['hash'] ?? null, 'clear' => $basis['clear'] ?? false, 'previousId' => $decisions->firstWhere('quotation_id', $quote['id'])->id ?? 0];
});
$history = AdmissionDecision::query()->where('admission_adoption_id', $selected->id ?? 0)->latest('id')->paginate(15)->withQueryString();
$history->through(function ($decision) use ($workflow, $selected, $current, $latestIds, $requisition, $open, $request) {
$basis = $workflow->basis($requisition, $decision->quotation_id);
$fresh = $current && $latestIds->contains($decision->id) && $basis && $basis['hash'] === $decision->basis_hash;
return [...$decision->toArray(), 'status' => $workflow->status($decision, $selected), 'current' => (bool) $fresh,
'reviews' => AdmissionReview::query()->where('admission_decision_id', $decision->id)->orderBy('id')->get(),
'canReview' => $open && $fresh && $workflow->status($decision, $selected) === 'pending' && $workflow->eligible($request->user(), $requisition, $selected, $decision) && ! AdmissionReview::query()->where('admission_decision_id', $decision->id)->where('reviewed_by', $request->user()->id)->exists()];
});
Inertia::encryptHistory();
$response = Inertia::render('purchases/admission', ['requisition' => $requisition->only(['id', 'number']), 'policy' => AdmissionPolicy::query()->latest('revision')->first(), 'adoptions' => AdmissionAdoption::query()->where('requisition_id', $requisition->id)->latest('revision')->get(), 'adoption' => $adoption, 'selected' => $selected, 'proposals' => $proposals, 'history' => $history, 'canAdopt' => $open && $request->user()->purchasing_role === PurchasingRole::Procurement, 'canPropose' => $open && $current && $request->user()->purchasing_role === PurchasingRole::Procurement && $request->user()->id !== $requisition->requester_id, 'closed' => $closed])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function adopt(Request $request, Requisition $requisition, FormalAdmission $workflow): RedirectResponse
{
$this->access($request, $requisition->id);
$data = $request->validate(['policy_id' => 'required|integer', 'previous_id' => 'required|integer|min:0', 'reason' => 'required|string|min:10|max:4000', 'tenant_id' => 'prohibited', 'snapshot' => 'prohibited', 'created_by' => 'prohibited']);
$workflow->adopt($request->user(), $requisition, (int) $data['policy_id'], (int) $data['previous_id'], $data['reason']);
return to_route('admissions.show', $requisition);
}
public function propose(Request $request, Requisition $requisition, FormalAdmission $workflow): RedirectResponse
{
$this->access($request, $requisition->id);
$data = $request->validate(['quotation_id' => 'required|integer', 'previous_id' => 'required|integer|min:0', 'basis_hash' => 'required|string|size:64', 'outcome' => 'required|in:admit,exclude,clarify', 'reason' => 'required|string|min:10|max:4000', 'tenant_id' => 'prohibited', 'created_by' => 'prohibited', 'snapshot' => 'prohibited', 'status' => 'prohibited']);
$workflow->propose($request->user(), $requisition, $data);
return to_route('admissions.show', $requisition);
}
public function review(Request $request, AdmissionDecision $decision, FormalAdmission $workflow): RedirectResponse
{
$adoption = AdmissionAdoption::query()->findOrFail($decision->admission_adoption_id);
$this->access($request, $adoption->requisition_id);
$data = $request->validate(['verdict' => 'required|in:approved,returned', 'reason' => 'required|string|min:10|max:4000', 'reviewed_by' => 'prohibited', 'snapshot' => 'prohibited', 'tenant_id' => 'prohibited']);
$workflow->review($request->user(), $decision, $data['verdict'], $data['reason']);
return to_route('admissions.show', $adoption->requisition_id);
}
}
@@ -0,0 +1,124 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\PurchaseAward;
use App\Models\RecommendationAdoption;
use App\Models\RecommendationAttempt;
use App\Models\RecommendationPolicy;
use App\Models\RecommendationReview;
use App\Models\Requisition;
use App\Models\User;
use App\Services\ConflictGuard;
use App\Services\FormalAdmission;
use App\Services\FormalRecommendation;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class FormalRecommendationController extends Controller
{
private function access(Request $request, int $id): Requisition
{
abort_unless(in_array($request->user()->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance, PurchasingRole::DepartmentHead]), 403);
return Requisition::query()->visibleTo($request->user())->findOrFail($id);
}
public function policy(Request $request): Response
{
abort_unless($request->user()->purchasing_role === PurchasingRole::Admin, 403);
Inertia::encryptHistory();
$response = Inertia::render('purchases/recommendation-policy', ['policies' => RecommendationPolicy::query()->latest('revision')->paginate(20)->withQueryString(), 'latest' => RecommendationPolicy::query()->latest('revision')->first()])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function configure(Request $request, FormalRecommendation $workflow): RedirectResponse
{
$data = $request->validate(['previous_id' => 'required|integer|min:0', 'enabled' => 'required|boolean', 'roles' => 'required|array|min:1|max:2', 'roles.*' => 'required|distinct|in:finance,department_head', 'required_count' => 'required|integer|min:1|max:50', 'reason' => 'required|string|min:10|max:4000', 'tenant_id' => 'prohibited', 'created_by' => 'prohibited', 'snapshot' => 'prohibited']);
$data['enabled'] = (bool) $data['enabled'];
$workflow->policy($request->user(), $data);
return to_route('recommendations.policy');
}
public function show(Request $request, Requisition $requisition, FormalRecommendation $workflow): Response
{
$requisition = $this->access($request, $requisition->id);
$filter = $request->validate(['version' => 'nullable|integer|min:1']);
$adoption = $workflow->adoption($requisition);
$selected = isset($filter['version']) ? RecommendationAdoption::query()->where('requisition_id', $requisition->id)->findOrFail((int) $filter['version']) : $adoption;
$current = $selected && $selected->id === $adoption?->id;
$basis = $workflow->basis($requisition);
$latest = RecommendationAttempt::query()->where('recommendation_adoption_id', $selected->id ?? 0)->latest('revision')->first();
$closed = $requisition->status !== 'approved' || PurchaseAward::query()->where('requisition_id', $requisition->id)->exists();
$open = ! $closed && ! app(ConflictGuard::class)->participationBlocked($request->user(), $requisition);
$history = RecommendationAttempt::query()->where('recommendation_adoption_id', $selected->id ?? 0)->latest('revision')->paginate(10)->withQueryString();
$history->through(function ($attempt) use ($workflow, $selected, $current, $latest, $basis, $requisition, $open, $request) {
$fresh = $current && $latest?->id === $attempt->id && $basis['ready'] && $basis['hash'] === $attempt->basis_hash;
return [...$attempt->toArray(), 'status' => $workflow->status($attempt, $selected), 'current' => (bool) $fresh, 'reviews' => RecommendationReview::query()->where('recommendation_attempt_id', $attempt->id)->orderBy('id')->get(),
'canReview' => $open && $fresh && $workflow->status($attempt, $selected) === 'pending' && $workflow->eligible($request->user(), $requisition, $selected, $attempt) && ! RecommendationReview::query()->where('recommendation_attempt_id', $attempt->id)->where('reviewed_by', $request->user()->id)->exists()];
});
Inertia::encryptHistory();
$response = Inertia::render('purchases/recommendation', ['requisition' => $requisition->only(['id', 'number']), 'policy' => RecommendationPolicy::query()->latest('revision')->first(), 'adoption' => $adoption, 'selected' => $selected, 'adoptions' => RecommendationAdoption::query()->where('requisition_id', $requisition->id)->latest('revision')->get(), 'hasAdmission' => app(FormalAdmission::class)->adoption($requisition) !== null,
'basis' => ['hash' => $basis['hash'], 'ready' => $basis['ready'], 'top_ids' => $basis['top_ids'], 'rows' => collect($basis['payload']['rows'])->map(fn ($row) => array_intersect_key($row, array_flip(['id', 'reference', 'supplier_name', 'currency', 'total_minor', 'eligible', 'ineligibility_reasons', 'evaluation_count', 'score_minor'])))->all()], 'previousId' => $latest->id ?? 0,
'history' => $history, 'closed' => $closed, 'canAdopt' => $open && $request->user()->purchasing_role === PurchasingRole::Procurement, 'canPropose' => $open && $current && $basis['ready'] && $request->user()->purchasing_role === PurchasingRole::Procurement && $request->user()->id !== $requisition->requester_id])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function adopt(Request $request, Requisition $requisition, FormalRecommendation $workflow): RedirectResponse
{
$this->access($request, $requisition->id);
$data = $request->validate(['policy_id' => 'required|integer', 'previous_id' => 'required|integer|min:0', 'reason' => 'required|string|min:10|max:4000', 'tenant_id' => 'prohibited', 'snapshot' => 'prohibited', 'created_by' => 'prohibited']);
$workflow->adopt($request->user(), $requisition, (int) $data['policy_id'], (int) $data['previous_id'], $data['reason']);
return to_route('recommendations.show', $requisition);
}
public function propose(Request $request, Requisition $requisition, FormalRecommendation $workflow): RedirectResponse
{
$this->access($request, $requisition->id);
$data = $request->validate(['quotation_id' => 'required|integer', 'previous_id' => 'required|integer|min:0', 'basis_hash' => 'required|string|size:64', 'reason' => 'required|string|min:10|max:4000', 'tenant_id' => 'prohibited', 'created_by' => 'prohibited', 'snapshot' => 'prohibited', 'status' => 'prohibited']);
$workflow->propose($request->user(), $requisition, $data);
return to_route('recommendations.show', $requisition);
}
public function review(Request $request, RecommendationAttempt $attempt, FormalRecommendation $workflow): RedirectResponse
{
$adoption = RecommendationAdoption::query()->findOrFail($attempt->recommendation_adoption_id);
$this->access($request, $adoption->requisition_id);
$data = $request->validate(['verdict' => 'required|in:approved,returned', 'reason' => 'required|string|min:10|max:4000', 'reviewed_by' => 'prohibited', 'snapshot' => 'prohibited', 'tenant_id' => 'prohibited']);
$workflow->review($request->user(), $attempt, $data['verdict'], $data['reason']);
return to_route('recommendations.show', $adoption->requisition_id);
}
public function print(Request $request, RecommendationAttempt $attempt, FormalRecommendation $workflow): Response
{
return DB::transaction(function () use ($request, $attempt, $workflow) {
if (DB::connection()->getDriverName() === 'pgsql') {
DB::statement('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY');
}
$actor = User::query()->where('tenant_id', $request->user()->tenant_id)->findOrFail($request->user()->id);
$request->setUserResolver(fn () => $actor);
$adoption = RecommendationAdoption::query()->findOrFail($attempt->recommendation_adoption_id);
$requisition = $this->access($request, $adoption->requisition_id);
$basis = $workflow->basis($requisition);
$currentAdoption = $workflow->adoption($requisition);
$latest = RecommendationAttempt::query()->where('recommendation_adoption_id', $adoption->id)->latest('revision')->firstOrFail();
$history = RecommendationAttempt::query()->where('recommendation_adoption_id', $adoption->id)->where('id', '<', $attempt->id)->orderBy('revision')->get()->map(fn ($previous) => ['attempt' => $previous, 'state' => $workflow->status($previous, $adoption), 'reviews' => RecommendationReview::query()->where('recommendation_attempt_id', $previous->id)->orderBy('id')->get()]);
return response()->view('purchases.recommendation-print', ['requisition' => $requisition, 'attempt' => $attempt, 'adoption' => $adoption, 'history' => $history, 'reviews' => RecommendationReview::query()->where('recommendation_attempt_id', $attempt->id)->orderBy('id')->get(), 'state' => $workflow->status($attempt, $adoption), 'current' => $currentAdoption?->id === $adoption->id && $latest->id === $attempt->id && $basis['ready'] && $basis['hash'] === $attempt->basis_hash, 'generatedAt' => now()->timezone('Africa/Johannesburg'), 'generatedBy' => $request->user()->name], 200, ['Cache-Control' => 'private, no-store, max-age=0']);
});
}
}
@@ -0,0 +1,40 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\InvestmentPolicy;
use App\Models\InvestmentPolicyReview;
use App\Services\InvestmentWorkflow;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Inertia\Response;
class InvestmentPolicyController extends Controller
{
public function index(Request $request, InvestmentWorkflow $workflow): Response
{
abort_unless(in_array($request->user()->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Finance, PurchasingRole::Procurement]), 403);
$current = $workflow->current();
return Inertia::render('investment/index', ['policies' => InvestmentPolicy::query()->latest('revision')->get(), 'reviews' => InvestmentPolicyReview::query()->orderBy('id')->get(), 'currentPolicyId' => $current && $current->valid_until >= today()->format('Y-m-d') ? $current->id : null, 'canManage' => $request->user()->purchasing_role === PurchasingRole::Admin]);
}
public function store(Request $request, InvestmentWorkflow $workflow): RedirectResponse
{
abort_unless($request->user()->purchasing_role === PurchasingRole::Admin, 403);
$data = $request->validate(['previous_id' => 'required|integer|min:0', 'mode' => 'required|in:ceiling', 'scope' => 'required|in:process_total', 'currency' => 'required|in:MZN', 'ceiling' => ['required', 'regex:/^\d{1,12}(\.\d{1,2})?$/'], 'includes_tax' => 'required|boolean', 'valid_from' => 'required|date_format:Y-m-d', 'valid_until' => 'required|date_format:Y-m-d|after_or_equal:valid_from', 'reason' => 'required|string|max:4000']);
$workflow->propose($request->user(), $data);
return back();
}
public function review(Request $request, InvestmentPolicy $policy, InvestmentWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['decision' => 'required|in:approved,rejected', 'reason' => 'required|string|max:4000']);
$workflow->review($request->user(), $policy, $data['decision'], $data['reason']);
return back();
}
}
@@ -0,0 +1,22 @@
<?php
namespace App\Http\Controllers;
use App\Models\Requisition;
use App\Services\ProcurementReviewReport;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class ProcurementReviewReportController extends Controller
{
public function show(Request $request, Requisition $requisition, ProcurementReviewReport $builder): Response
{
$report = $builder->build($request->user(), $requisition->id);
Inertia::encryptHistory();
$response = Inertia::render('purchases/review-report', ['report' => $report])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
}
@@ -0,0 +1,85 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\ProposalOpening;
use App\Models\PurchaseAward;
use App\Models\Requisition;
use App\Services\ConflictGuard;
use App\Services\ProposalOpeningWorkflow;
use Carbon\CarbonImmutable;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class ProposalOpeningController extends Controller
{
private function access(Request $request, int $requisitionId): Requisition
{
abort_unless(in_array($request->user()->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance, PurchasingRole::DepartmentHead]), 403);
return Requisition::query()->visibleTo($request->user())->findOrFail($requisitionId);
}
public function show(Request $request, Requisition $requisition, ProposalOpeningWorkflow $workflow): Response
{
$this->access($request, $requisition->id);
$proposals = $workflow->proposals($requisition);
$query = ProposalOpening::query()->where('requisition_id', $requisition->id)->latest('revision');
$latest = (clone $query)->first();
$openings = $query->paginate(10)->withQueryString();
Inertia::encryptHistory();
$response = Inertia::render('purchases/opening', [
'requisition' => $requisition->only(['id', 'number', 'justification']), 'proposals' => $proposals, 'basisHash' => $workflow->basis($proposals), 'openings' => $openings,
'sourceChanged' => $latest && $workflow->basis($proposals) !== $latest->basis_hash,
'latestId' => $latest->id ?? 0,
'canRecord' => $request->user()->purchasing_role === PurchasingRole::Procurement && $requisition->status === 'approved' && ! PurchaseAward::query()->where('requisition_id', $requisition->id)->exists() && ! app(ConflictGuard::class)->participationBlocked($request->user(), $requisition),
])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function store(Request $request, Requisition $requisition, ProposalOpeningWorkflow $workflow): RedirectResponse
{
$this->access($request, $requisition->id);
$data = $request->validate([
'previous_id' => 'required|integer|min:0', 'basis_hash' => 'required|string|size:64',
'opened_at' => 'required|date_format:Y-m-d\TH:i',
'timezone' => 'required|in:Africa/Maputo,Africa/Johannesburg,UTC',
'submission_deadline' => 'nullable|date_format:Y-m-d\TH:i|before_or_equal:opened_at',
'reference' => 'required|string|min:3|max:150', 'location' => 'required|string|min:3|max:300',
'reason' => 'required|string|min:10|max:4000', 'notes' => 'nullable|string|max:6000',
'quotation_ids' => 'required|array|min:1|max:100', 'quotation_ids.*' => 'required|integer|distinct',
'participants' => 'required|array|min:1|max:50', 'participants.*.name' => 'required|string|min:2|max:150',
'participants.*' => 'required|array:name,capacity,group',
'participants.*.capacity' => 'required|string|min:2|max:150', 'participants.*.group' => 'required|in:jury,participant',
'annexes' => 'nullable|array|max:30', 'annexes.*' => 'required|string|min:3|max:300',
'snapshot' => 'prohibited', 'tenant_id' => 'prohibited', 'created_by' => 'prohibited',
'confirmed' => 'accepted',
]);
$opened = CarbonImmutable::createFromFormat('!Y-m-d\TH:i', $data['opened_at'], $data['timezone']);
if (! $opened || $opened->isFuture()) {
throw ValidationException::withMessages(['opened_at' => 'A sessão não pode estar no futuro no fuso horário indicado.']);
}
$data['opened_at'] = $opened->utc()->format('Y-m-d H:i:s');
$data['submission_deadline'] = empty($data['submission_deadline']) ? null : CarbonImmutable::createFromFormat('!Y-m-d\TH:i', $data['submission_deadline'], $data['timezone'])->utc()->format('Y-m-d H:i:s');
$data['quotation_ids'] = array_map(intval(...), $data['quotation_ids']);
$workflow->record($request->user(), $requisition, $data);
return back();
}
public function print(Request $request, ProposalOpening $opening): Response
{
$this->access($request, $opening->requisition_id);
$response = response()->view('purchases.opening', ['opening' => $opening, 'snapshot' => $opening->snapshot]);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
}
@@ -0,0 +1,85 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\AwardCancellation;
use App\Models\PurchaseAward;
use App\Models\PurchaseControlPolicy;
use App\Models\PurchaseControlReview;
use App\Models\PurchaseOrder;
use App\Models\PurchaseRevision;
use App\Models\Requisition;
use App\Services\PurchaseControlPolicyWorkflow;
use App\Services\PurchaseRevisionWorkflow;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Inertia\Response;
class PurchaseControlController extends Controller
{
public function index(Request $request): Response
{
$user = $request->user();
$operational = in_array($user->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance]);
$sources = Requisition::query()->where('requester_id', $user->id)->select('id');
$ownAwards = PurchaseAward::query()->whereIn('requisition_id', $sources)->select('id');
$cancellations = AwardCancellation::query()->whereIn('purchase_award_id', $ownAwards)->where('status', 'approved')->get(['id', 'purchase_award_id']);
return Inertia::render('purchase-controls/index', [
'role' => $user->purchasing_role->value, 'actorId' => $user->id,
'policies' => $operational ? PurchaseControlPolicy::query()->latest('revision')->get() : [],
'reviews' => $operational ? PurchaseControlReview::query()->get() : [],
'awards' => $operational ? PurchaseAward::query()->whereNotIn('requisition_id', PurchaseOrder::query()->select('requisition_id'))->latest('id')->get(['id', 'requisition_id', 'status']) : [],
'cancellations' => $operational ? AwardCancellation::query()->get(['id', 'purchase_award_id', 'created_by', 'status', 'reason', 'review_reason']) : [],
'sources' => $cancellations->map(function (AwardCancellation $cancellation) {
$award = PurchaseAward::query()->findOrFail($cancellation->purchase_award_id);
$source = Requisition::query()->findOrFail($award->requisition_id);
return ['id' => $cancellation->id, 'number' => $source->number, 'revision_id' => PurchaseRevision::query()->where('award_cancellation_id', $cancellation->id)->value('requisition_id')];
}),
]);
}
public function propose(Request $request, PurchaseControlPolicyWorkflow $workflow): RedirectResponse
{
abort_unless($request->user()->purchasing_role === PurchasingRole::Admin, 403);
$data = $request->validate(['previous_id' => 'required|integer|min:0', 'mode' => 'required|in:unissued_award', 'enabled' => 'required|boolean', 'valid_from' => 'required|date_format:Y-m-d', 'valid_until' => 'required|date_format:Y-m-d|after_or_equal:valid_from', 'reason' => 'required|string|min:10|max:4000']);
$workflow->propose($request->user(), $data);
return back();
}
public function policyReview(Request $request, PurchaseControlPolicy $policy, PurchaseControlPolicyWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['decision' => 'required|in:approved,rejected', 'reason' => 'required|string|min:10|max:4000']);
$workflow->review($request->user(), $policy, $data['decision'], $data['reason']);
return back();
}
public function cancel(Request $request, PurchaseAward $award, PurchaseRevisionWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['reason' => 'required|string|min:10|max:4000']);
$workflow->request($request->user(), $award, $data['reason']);
return back();
}
public function review(Request $request, AwardCancellation $cancellation, PurchaseRevisionWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['decision' => 'required|in:approved,rejected', 'reason' => 'required|string|min:10|max:4000']);
$workflow->review($request->user(), $cancellation, $data['decision'], $data['reason']);
return back();
}
public function revise(Request $request, AwardCancellation $cancellation, PurchaseRevisionWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['needed_by' => 'required|date_format:Y-m-d|after_or_equal:today', 'justification' => 'required|string|min:10|max:4000']);
$revision = $workflow->revise($request->user(), $cancellation, $data['needed_by'], $data['justification']);
return to_route('requisitions.edit', $revision);
}
}
+23 -3
View File
@@ -4,15 +4,19 @@ namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\AuditLog;
use App\Models\AwardCancellation;
use App\Models\PurchaseAward;
use App\Models\PurchaseOrder;
use App\Models\RecommendationAttempt;
use App\Models\Requisition;
use App\Services\FormalRecommendation;
use App\Services\ProposalComparison;
use App\Services\PurchaseWorkflow;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
use Inertia\Response;
@@ -28,12 +32,28 @@ class PurchaseController extends Controller
$this->access($request);
Requisition::query()->visibleTo($request->user())->findOrFail($requisition->id);
$award = PurchaseAward::query()->where('requisition_id', $requisition->id)->with('approvals')->first();
$frozen = $award && AwardCancellation::query()->where('purchase_award_id', $award->id)->where('status', 'pending')->exists();
$recommendation = app(FormalRecommendation::class);
$adoption = $recommendation->adoption($requisition);
$candidate = null;
if ($adoption) {
$latest = RecommendationAttempt::query()->where('recommendation_adoption_id', $adoption->id)->latest('revision')->first();
if ($latest) {
try {
$recommendation->selection($requisition, $latest->quotation_id);
$candidate = $latest->quotation_id;
} catch (ValidationException) {
// The POST revalidates again; stale recommendations cannot enable the form.
}
}
}
return Inertia::render('purchases/award', [
'requisition' => $requisition, 'comparison' => $comparison->inspect($requisition), 'award' => $award,
'canSelect' => $request->user()->purchasing_role === PurchasingRole::Procurement && $award === null && $request->user()->id !== $requisition->requester_id,
'canDecide' => $award !== null && $workflow->canDecide($request->user(), $award, $requisition),
'canIssue' => $award?->status === 'approved' && $request->user()->purchasing_role === PurchasingRole::Procurement,
'canSelect' => $request->user()->purchasing_role === PurchasingRole::Procurement && $award === null && $request->user()->id !== $requisition->requester_id && (! $adoption || $candidate !== null),
'recommendation' => ['adopted' => $adoption !== null, 'quotation_id' => $candidate],
'canDecide' => ! $frozen && $award !== null && $workflow->canDecide($request->user(), $award, $requisition),
'canIssue' => ! $frozen && $award?->status === 'approved' && $request->user()->purchasing_role === PurchasingRole::Procurement,
'order' => PurchaseOrder::query()->where('requisition_id', $requisition->id)->first(['id', 'number']),
]);
}
@@ -0,0 +1,111 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\AuditLog;
use App\Models\Department;
use App\Models\PurchasePlanItem;
use App\Models\PurchasePlanMilestone;
use App\Models\Requisition;
use App\Models\User;
use App\Services\PurchasePlanningWorkflow;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class PurchasePlanningController extends Controller
{
public function index(Request $request): Response
{
$actor = $request->user();
$canManage = in_array($actor->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement]);
$filters = $request->validate(['item' => 'nullable|integer|min:1']);
$items = PurchasePlanItem::query()->visibleTo($actor)->when($filters['item'] ?? null, fn ($query, $id) => $query->whereKey($id))->latest('id')->paginate(15)->withQueryString();
$milestones = PurchasePlanMilestone::query()->whereIn('purchase_plan_item_id', $items->pluck('id'))->orderBy('planned_on')->orderBy('id')->get();
$responsibles = User::query()->where('tenant_id', $actor->tenant_id)->whereIn('id', $items->pluck('responsible_id'))->pluck('name', 'id');
$departments = Department::query()->whereIn('id', $items->pluck('department_id'))->pluck('name', 'id');
$requisitions = Requisition::query()->visibleTo($actor)->whereIn('id', $items->pluck('requisition_id'))->get(['id', 'number'])->keyBy('id');
$rows = $items->through(fn (PurchasePlanItem $item) => [
...$item->only(['id', 'title', 'nature', 'responsible_id', 'version', 'department_id']),
'canLink' => $canManage && $item->requisition_id === null,
'responsible' => $responsibles[$item->responsible_id] ?? 'Responsável indisponível',
'department' => $departments[$item->department_id] ?? '',
'requisition' => isset($requisitions[$item->requisition_id]) ? $requisitions[$item->requisition_id]->only(['id', 'number']) : null,
'canRecord' => $canManage || $item->responsible_id === $actor->id,
]);
$history = [];
if ($canManage) {
$history = AuditLog::query()->whereIn('action', ['planning.created', 'planning.linked', 'planning.assigned', 'planning.milestone_created', 'planning.milestone_updated'])->latest('id')->limit(50)->get(['id', 'action', 'user_id', 'before', 'after', 'created_at']);
$authors = User::query()->where('tenant_id', $actor->tenant_id)->whereIn('id', $history->pluck('user_id'))->pluck('name', 'id');
foreach ($history as $event) {
$event->setAttribute('actor', $authors[$event->user_id] ?? 'Utilizador indisponível');
}
}
Inertia::encryptHistory();
$response = Inertia::render('planning/index', [
'items' => $rows, 'milestones' => $milestones, 'history' => $history, 'canManage' => $canManage,
'today' => today()->format('Y-m-d'),
'departments' => $canManage ? Department::query()->orderBy('name')->get(['id', 'name']) : [],
'users' => $canManage ? User::query()->where('tenant_id', $actor->tenant_id)->orderBy('name')->get(['id', 'name']) : [],
'requisitions' => $canManage ? Requisition::query()->visibleTo($actor)->whereNotIn('id', PurchasePlanItem::query()->whereNotNull('requisition_id')->select('requisition_id'))->latest('id')->get(['id', 'number', 'department_id']) : [],
])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
public function store(Request $request, PurchasePlanningWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['title' => 'required|string|min:3|max:200', 'department_id' => 'required|integer', 'responsible_id' => 'required|integer', 'requisition_id' => 'nullable|integer', 'nature' => 'required|in:goods,works,services,consulting']);
$data['department_id'] = (int) $data['department_id'];
$data['responsible_id'] = (int) $data['responsible_id'];
$workflow->create($request->user(), $data);
return back();
}
public function assign(Request $request, PurchasePlanItem $item, PurchasePlanningWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['responsible_id' => 'required|integer', 'version' => 'required|integer|min:1', 'reason' => 'required|string|min:10|max:2000']);
$workflow->assign($request->user(), $item, (int) $data['responsible_id'], (int) $data['version'], $data['reason']);
return back();
}
public function milestone(Request $request, PurchasePlanItem $item, PurchasePlanningWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['label' => 'required|string|min:3|max:120', 'planned_on' => 'required|date_format:Y-m-d']);
$workflow->milestone($request->user(), $item, $data['label'], $data['planned_on']);
return back();
}
public function link(Request $request, PurchasePlanItem $item, PurchasePlanningWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['requisition_id' => 'required|integer', 'version' => 'required|integer|min:1', 'reason' => 'required|string|min:10|max:2000']);
$workflow->link($request->user(), $item, (int) $data['requisition_id'], (int) $data['version'], $data['reason']);
return back();
}
public function update(Request $request, PurchasePlanMilestone $milestone, PurchasePlanningWorkflow $workflow): RedirectResponse
{
$data = $request->validate(['version' => 'required|integer|min:1', 'planned_on' => 'sometimes|required|date_format:Y-m-d', 'actual_on' => 'sometimes|nullable|date_format:Y-m-d|before_or_equal:today', 'reason' => 'required|string|min:10|max:2000']);
if (! array_key_exists('planned_on', $data) && ! array_key_exists('actual_on', $data)) {
throw ValidationException::withMessages(['actual_on' => 'Indique a data prevista ou a data realizada a actualizar.']);
}
$changes = ['version' => (int) $data['version'], 'reason' => $data['reason']];
if (array_key_exists('planned_on', $data)) {
$changes['planned_on'] = $data['planned_on'];
}
if (array_key_exists('actual_on', $data)) {
$changes['actual_on'] = $data['actual_on'];
}
$workflow->update($request->user(), $milestone, $changes);
return back();
}
}
@@ -0,0 +1,137 @@
<?php
namespace App\Http\Controllers;
use App\Enums\PurchasingRole;
use App\Models\AuditLog;
use App\Models\AwardCancellation;
use App\Models\BudgetEntry;
use App\Models\ExternalPayment;
use App\Models\GoodsReceipt;
use App\Models\Invoice;
use App\Models\ProposalOpening;
use App\Models\PurchaseAward;
use App\Models\PurchaseOrder;
use App\Models\PurchasePlanItem;
use App\Models\PurchaseRevision;
use App\Models\QualificationSet;
use App\Models\Quotation;
use App\Models\Requisition;
use App\Models\TechnicalReview;
use App\Models\User;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
class PurchaseProcessController extends Controller
{
public function show(Request $request, Requisition $requisition): Response
{
$actor = $request->user();
Requisition::query()->visibleTo($actor)->findOrFail($requisition->id);
$requisition->load(['requester:id,name', 'department:id,name', 'steps']);
$role = $actor->purchasing_role;
$purchases = in_array($role, [PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance, PurchasingRole::DepartmentHead]);
$finance = in_array($role, [PurchasingRole::Admin, PurchasingRole::Finance]);
$inventory = $purchases || $role === PurchasingRole::Warehouse;
$base = '/requisicoes/'.$requisition->id;
$stages = [];
$documents = [['label' => $requisition->number, 'kind' => 'Requisição', 'href' => $base]];
if ($purchases) {
$documents[] = ['label' => 'Relatório de conferência', 'kind' => 'Relatório de consulta', 'href' => $base.'/relatorio'];
$documents[] = ['label' => 'Regime, decisões e conferências', 'kind' => 'Admissão de propostas', 'href' => $base.'/admissao'];
$documents[] = ['label' => 'Regime, tentativas e conferências', 'kind' => 'Recomendação', 'href' => $base.'/recomendacao'];
}
$qualification = $purchases ? QualificationSet::query()->where('requisition_id', $requisition->id)->latest('revision')->first(['id', 'revision']) : null;
if ($qualification) {
$documents[] = ['label' => 'Qualificação documental · Requisitos v'.$qualification->revision, 'kind' => 'Qualificação documental', 'href' => $base.'/qualificacao'];
}
$opening = $purchases ? ProposalOpening::query()->where('requisition_id', $requisition->id)->latest('revision')->first(['id', 'revision']) : null;
if ($opening) {
$documents[] = ['label' => 'Acta de abertura · Versão '.$opening->revision, 'kind' => 'Abertura', 'href' => $base.'/abertura'];
}
$planning = PurchasePlanItem::query()->visibleTo($actor)->where('requisition_id', $requisition->id)->first(['id', 'title']);
if ($planning) {
$documents[] = ['label' => $planning->title, 'kind' => 'Planeamento', 'href' => '/planeamento?item='.$planning->id];
}
$decisions = [];
$stages[] = ['label' => 'Requisição e aprovação da necessidade', 'state' => $requisition->status, 'owner' => 'Solicitante e aprovadores', 'detail' => 'Estado do pedido; as decisões individuais constam abaixo.', 'href' => $base];
foreach ($requisition->steps as $step) {
$decisions[] = ['area' => 'Estimativa', 'role' => $step->role, 'decision' => $step->decision, 'actor_id' => $step->approver_id, 'date' => $step->decided_at];
}
$equipment = $requisition->items()->where('purchase_type', 'equipment')->exists();
$reviews = TechnicalReview::query()->where('requisition_id', $requisition->id)->orderBy('id')->get();
$stages[] = ['label' => 'Validação técnica', 'state' => $reviews->isNotEmpty() ? 'recorded' : ($equipment ? 'not_started' : 'not_required'), 'owner' => 'Responsável da área', 'detail' => 'O histórico não comprova validade da base actual; cada operação volta a verificá-la.', 'href' => $base];
foreach ($reviews as $review) {
$decisions[] = ['area' => 'Técnica', 'role' => 'department_head', 'decision' => $review->decision, 'actor_id' => $review->reviewed_by, 'date' => $review->reviewed_at];
}
$stages[] = ['label' => 'Controlo orçamental', 'state' => $finance ? (BudgetEntry::query()->where('requisition_id', $requisition->id)->exists() ? 'recorded' : 'not_started') : 'restricted', 'owner' => 'Finanças', 'detail' => 'Lançamentos associados ao processo. A presença de registos não certifica o orçamento nem a política da empresa.', 'href' => $finance ? '/orcamentos' : null];
$award = $purchases ? PurchaseAward::query()->where('requisition_id', $requisition->id)->with('approvals')->first() : null;
$order = $inventory ? PurchaseOrder::query()->visibleTo($actor)->where('requisition_id', $requisition->id)->first(['id', 'number']) : null;
$quoteCount = $purchases ? Quotation::query()->where('requisition_id', $requisition->id)->count() : 0;
$stages[] = ['label' => 'Propostas e comparação', 'state' => $purchases ? ($quoteCount ? 'recorded' : 'not_started') : 'restricted', 'owner' => 'Compras e avaliadores', 'detail' => $purchases ? $quoteCount.' propostas registadas. Quantidade não significa elegibilidade ou avaliação concluída.' : 'Disponível aos perfis autorizados para compras.', 'href' => $purchases ? $base.'/cotacoes' : null];
$stages[] = ['label' => 'Adjudicação', 'state' => $purchases ? ($award->status ?? 'not_started') : 'restricted', 'owner' => 'Compras e aprovadores do valor final', 'detail' => 'A decisão sobre a estimativa e a decisão sobre o valor adjudicado são distintas.', 'href' => $purchases ? $base.'/adjudicacao' : null];
if ($purchases && $quoteCount) {
$documents[] = ['label' => 'Propostas registadas', 'kind' => 'Comparação', 'href' => $base.'/cotacoes'];
}
if ($award) {
$documents[] = ['label' => 'Adjudicação #'.$award->id, 'kind' => 'Adjudicação', 'href' => $base.'/adjudicacao'];
foreach ($award->approvals as $step) {
$decisions[] = ['area' => 'Adjudicação', 'role' => $step->role, 'decision' => $step->decision, 'actor_id' => $step->approver_id, 'date' => $step->decided_at];
}
}
$stages[] = ['label' => 'Ordem de compra', 'state' => $inventory ? ($order ? 'issued' : 'not_started') : 'restricted', 'owner' => 'Compras', 'detail' => 'Documento emitido com os dados acordados preservados.', 'href' => $order && $purchases ? '/ordens/'.$order->id : null];
if ($order && $purchases) {
$documents[] = ['label' => $order->number, 'kind' => 'Ordem de compra', 'href' => '/ordens/'.$order->id];
}
$receipts = $order ? GoodsReceipt::query()->where('purchase_order_id', $order->id)->orderBy('id')->get(['id']) : collect();
$stages[] = ['label' => 'Recepção', 'state' => $inventory ? ($receipts->isNotEmpty() ? 'recorded' : 'not_started') : 'restricted', 'owner' => 'Armazém', 'detail' => $inventory ? $receipts->count().' recepções registadas. Podem existir entregas parciais ou rejeições.' : 'Disponível aos perfis autorizados para recepção.', 'href' => $order ? '/ordens/'.$order->id.'/recepcoes' : null];
foreach ($receipts as $receipt) {
$documents[] = ['label' => 'Recepção #'.$receipt->id, 'kind' => 'Recepção', 'href' => '/recepcoes/'.$receipt->id];
}
$invoices = $finance && $order ? Invoice::query()->where('purchase_order_id', $order->id)->get(['id', 'number', 'status']) : collect();
$payments = $finance ? ExternalPayment::query()->whereIn('invoice_id', $invoices->pluck('id'))->get(['id', 'status']) : collect();
$stages[] = ['label' => 'Facturas', 'state' => $finance ? ($invoices->isNotEmpty() ? 'recorded' : 'not_started') : 'restricted', 'owner' => 'Finanças e conferente independente', 'detail' => $finance ? $invoices->count().' registadas; '.$invoices->where('status', 'validated')->count().' validadas. O registo não equivale a validação.' : 'Disponível a Finanças e Administração.', 'href' => $finance ? '/facturas' : null];
$stages[] = ['label' => 'Pagamentos externos', 'state' => $finance ? ($payments->isNotEmpty() ? 'recorded' : 'not_started') : 'restricted', 'owner' => 'Finanças e conferente independente', 'detail' => $finance ? $payments->count().' registos; '.$payments->where('status', 'confirmed')->count().' confirmados. Não comprova liquidação integral e não executa transferências.' : 'Disponível a Finanças e Administração.', 'href' => $finance ? '/pagamentos' : null];
foreach ($invoices as $invoice) {
$documents[] = ['label' => $invoice->number, 'kind' => 'Factura', 'href' => '/facturas'];
}
$cancellation = $award ? AwardCancellation::query()->where('purchase_award_id', $award->id)->first(['id', 'status']) : null;
$actors = User::query()->where('tenant_id', $actor->tenant_id)->whereIn('id', array_column($decisions, 'actor_id'))->pluck('name', 'id');
foreach ($decisions as &$decision) {
$decision['actor'] = $decision['actor_id'] ? ($actors[$decision['actor_id']] ?? 'Utilizador do processo') : null;
unset($decision['actor_id']);
}
unset($decision);
$related = [];
foreach (PurchaseRevision::query()->where(fn ($query) => $query->where('source_requisition_id', $requisition->id)->orWhere('requisition_id', $requisition->id))->get() as $link) {
$otherId = $link->requisition_id === $requisition->id ? $link->source_requisition_id : $link->requisition_id;
$other = Requisition::query()->visibleTo($actor)->find($otherId, ['id', 'number']);
if ($other) {
$related[] = ['label' => $other->number, 'href' => '/requisicoes/'.$other->id.'/processo'];
}
}
$actions = ['requisition.created', 'requisition.updated', 'requisition.submitted', 'approval.approved', 'approval.rejected', 'equipment.technical_approved', 'equipment.technical_rejected', 'requisition.revision_created'];
if ($purchases) {
$actions = [...$actions, 'recommendation.adopted', 'recommendation.proposed', 'recommendation.reviewed', 'admission.adopted', 'admission.proposed', 'admission.reviewed', 'qualification.defined', 'qualification.assessed', 'opening.recorded', 'award.created', 'award.approved', 'award.rejected', 'purchase_order.issued', 'cancellation.requested', 'cancellation.approved', 'cancellation.rejected'];
}
if ($inventory) {
$actions[] = 'receipt.confirmed';
}
if ($finance) {
$actions = [...$actions, 'invoice.created', 'invoice.validated', 'payment.registered', 'payment.confirmed', 'payment.rejected', 'budget.reserve', 'budget.award', 'budget.commit', 'budget.release'];
}
Inertia::encryptHistory();
$response = Inertia::render('purchases/process', [
'process' => ['number' => $requisition->number, 'status' => $requisition->status, 'requester' => $requisition->requester?->name, 'department' => $requisition->department?->name, 'needed_by' => $requisition->needed_by, 'href' => $base],
'stages' => $stages, 'documents' => $documents, 'decisions' => $decisions, 'related' => $related,
'cancellation' => $cancellation ? ['status' => $cancellation->status, 'href' => '/revisao-compras'] : null,
'history' => AuditLog::query()->where('requisition_id', $requisition->id)->whereIn('action', $actions)->orderBy('id')->get(['id', 'action', 'created_at']),
'future' => [],
])->toResponse($request);
$response->headers->set('Cache-Control', 'private, no-store, max-age=0');
return $response;
}
}
@@ -25,7 +25,7 @@ class RequisitionController extends Controller
{
public function index(Request $request): Response
{
$filters = $request->validate(['search' => 'nullable|string|max:100', 'status' => ['nullable', Rule::in(['draft', 'pending', 'approved', 'rejected'])]]);
$filters = $request->validate(['search' => 'nullable|string|max:100', 'status' => ['nullable', Rule::in(['draft', 'pending', 'approved', 'rejected', 'cancelled'])]]);
$query = Requisition::query()->visibleTo($request->user())->with(['requester:id,name', 'department:id,name', 'steps']);
if (! empty($filters['search'])) {
$query->where('number', 'like', '%'.$filters['search'].'%');
@@ -33,7 +33,7 @@ class SecurityController extends Controller
'password' => $request->password,
]);
Inertia::flash('toast', ['type' => 'success', 'message' => __('Password updated.')]);
Inertia::flash('toast', ['type' => 'success', 'message' => __('Palavra-passe actualizada.')]);
return back();
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property array{roles:list<string>,required_count:int,policy_revision:int} $snapshot */
class AdmissionAdoption extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['snapshot' => 'array'];
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property array<string,mixed> $snapshot */
class AdmissionDecision extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['snapshot' => 'array'];
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property list<string> $roles */
class AdmissionPolicy extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['roles' => 'array', 'enabled' => 'boolean'];
}
}
+21
View File
@@ -0,0 +1,21 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
class AdmissionReview extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['snapshot' => 'array'];
}
}
+39
View File
@@ -0,0 +1,39 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property int $id
* @property int $tenant_id
* @property int $purchase_award_id
* @property int $purchase_control_policy_id
* @property int $created_by
* @property string $status
* @property string $basis_hash
* @property array<string,mixed> $snapshot
*/
class AwardCancellation extends Model
{
use BelongsToTenant;
protected $guarded = ['id'];
protected $attributes = ['status' => 'pending'];
protected function casts(): array
{
return ['snapshot' => 'array'];
}
protected static function booted(): void
{
static::updating(function (AwardCancellation $cancellation) {
if ($cancellation->getRawOriginal('status') !== 'pending' || array_diff(array_keys($cancellation->getDirty()), ['status', 'reviewed_by', 'review_reason', 'reviewed_at', 'updated_at']) !== []) {
throw new \LogicException('Preservar o pedido de cancelamento e a decisão.');
}
});
static::deleting(fn () => throw new \LogicException('Preservar o histórico de cancelamento.'));
}
}
+9
View File
@@ -3,12 +3,14 @@
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Brick\Math\BigDecimal;
use Illuminate\Database\Eloquent\Model;
/** @property int $id
* @property int $amount_minor
* @property int $created_by
* @property int|null $approved_by
* @property string $kind
*/
class Budget extends Model
{
@@ -16,6 +18,13 @@ class Budget extends Model
protected $guarded = ['id'];
public function approvedTotalMinor(): int
{
$sum = BudgetReinforcement::query()->where('budget_id', $this->id)->where('status', 'approved')->sum('amount_minor');
return BigDecimal::of((string) $sum)->plus($this->amount_minor)->toInt();
}
protected static function booted(): void
{
static::updating(function (Budget $budget) {
+35
View File
@@ -0,0 +1,35 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property int $id
* @property int $tenant_id
* @property int $budget_id
* @property int $created_by
* @property int $amount_minor
* @property string $status
* @property string $payload_hash
*/
class BudgetReinforcement extends Model
{
use BelongsToTenant;
protected $guarded = ['id'];
protected $attributes = ['status' => 'pending'];
protected $hidden = ['payload_hash'];
protected static function booted(): void
{
static::updating(function (BudgetReinforcement $reinforcement) {
if ($reinforcement->getRawOriginal('status') !== 'pending' || array_diff(array_keys($reinforcement->getDirty()), ['status', 'reviewed_by', 'review_reason', 'reviewed_at', 'updated_at']) !== []) {
throw new \LogicException('Preservar o reforço e a decisão.');
}
});
static::deleting(fn () => throw new \LogicException('Não eliminar reforços orçamentais.'));
}
}
+42
View File
@@ -0,0 +1,42 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property int $id
* @property int $tenant_id
* @property int $invoice_id
* @property int $supplier_bank_detail_id
* @property int $created_by
* @property int $amount_minor
* @property string $status
* @property string $payload_hash
* @property array<string,mixed> $bank_snapshot
*/
class ExternalPayment extends Model
{
use BelongsToTenant;
protected $guarded = ['id'];
protected $attributes = ['status' => 'pending'];
protected $hidden = ['external_reference', 'reference_hash', 'payload_hash', 'evidence_reference', 'bank_snapshot', 'review_reason'];
protected function casts(): array
{
return ['external_reference' => 'encrypted', 'evidence_reference' => 'encrypted', 'bank_snapshot' => 'encrypted:array', 'review_reason' => 'encrypted'];
}
protected static function booted(): void
{
static::updating(function (ExternalPayment $payment) {
if ($payment->getRawOriginal('status') !== 'pending' || array_diff(array_keys($payment->getDirty()), ['status', 'reviewed_by', 'reviewed_at', 'review_reason', 'updated_at']) !== []) {
throw new \LogicException('Preservar o registo externo e a conferência.');
}
});
static::deleting(fn () => throw new \LogicException('Preservar o histórico de pagamentos externos.'));
}
}
+36
View File
@@ -0,0 +1,36 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property int $id
* @property int $tenant_id
* @property int $created_by
* @property int $revision
* @property string $status
*/
class InvestmentPolicy extends Model
{
use BelongsToTenant;
protected $guarded = ['id'];
protected $attributes = ['status' => 'pending'];
protected function casts(): array
{
return ['includes_tax' => 'boolean', 'ceiling_minor' => 'integer'];
}
protected static function booted(): void
{
static::updating(function (InvestmentPolicy $policy) {
if ($policy->getRawOriginal('status') !== 'pending' || array_diff(array_keys($policy->getDirty()), ['status', 'decided_at', 'updated_at']) !== []) {
throw new \LogicException('Preservar os parâmetros e as decisões da regra.');
}
});
static::deleting(fn () => throw new \LogicException('Preservar versões de investimento.'));
}
}
+16
View File
@@ -0,0 +1,16 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
class InvestmentPolicyReview extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
}
+21
View File
@@ -0,0 +1,21 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
class ProposalOpening extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['participants' => 'array', 'annexes' => 'array', 'snapshot' => 'array'];
}
}
+4 -1
View File
@@ -16,6 +16,9 @@ use Illuminate\Database\Eloquent\Relations\HasMany;
* @property string $comparison_hash
* @property array<string, mixed> $approval_snapshot
* @property list<array<string, mixed>> $decision_matrix
* @property array<string,mixed>|null $investment_snapshot
* @property array<string,mixed>|null $admission_snapshot
* @property array<string,mixed>|null $recommendation_snapshot
*/
class PurchaseAward extends Model
{
@@ -25,7 +28,7 @@ class PurchaseAward extends Model
protected function casts(): array
{
return ['approval_snapshot' => 'array', 'decision_matrix' => 'array', 'delivery_date' => 'date:Y-m-d'];
return ['approval_snapshot' => 'array', 'decision_matrix' => 'array', 'investment_snapshot' => 'array', 'admission_snapshot' => 'array', 'recommendation_snapshot' => 'array', 'delivery_date' => 'date:Y-m-d'];
}
/** @return HasMany<PurchaseAwardApproval, $this> */
+36
View File
@@ -0,0 +1,36 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property int $id
* @property int $tenant_id
* @property int $created_by
* @property int $revision
* @property string $status
*/
class PurchaseControlPolicy extends Model
{
use BelongsToTenant;
protected $guarded = ['id'];
protected $attributes = ['status' => 'pending'];
protected function casts(): array
{
return ['enabled' => 'boolean'];
}
protected static function booted(): void
{
static::updating(function (PurchaseControlPolicy $policy) {
if ($policy->getRawOriginal('status') !== 'pending' || array_diff(array_keys($policy->getDirty()), ['status', 'decided_at', 'updated_at']) !== []) {
throw new \LogicException('Preservar a política e as decisões.');
}
});
static::deleting(fn () => throw new \LogicException('Preservar versões de política.'));
}
}
+16
View File
@@ -0,0 +1,16 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
class PurchaseControlReview extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
}
+32
View File
@@ -0,0 +1,32 @@
<?php
namespace App\Models;
use App\Enums\PurchasingRole;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
class PurchasePlanItem extends Model
{
use BelongsToTenant;
protected $guarded = ['id'];
protected $attributes = ['version' => 1];
/** @param Builder<PurchasePlanItem> $query */
public function scopeVisibleTo(Builder $query, User $user): void
{
match ($user->purchasing_role) {
PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance => null,
PurchasingRole::DepartmentHead => $query->where(fn ($visible) => $visible->where('department_id', $user->department_id)->orWhere('responsible_id', $user->id)),
default => $query->where('responsible_id', $user->id),
};
}
protected static function booted(): void
{
static::deleting(fn () => throw new \LogicException('Preservar o planeamento.'));
}
}
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
class PurchasePlanMilestone extends Model
{
use BelongsToTenant;
protected $guarded = ['id'];
protected $attributes = ['version' => 1, 'actual_on' => null];
protected static function booted(): void
{
static::deleting(fn () => throw new \LogicException('Preservar marcos e datas anteriores na auditoria.'));
}
}
+16
View File
@@ -0,0 +1,16 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
class PurchaseRevision extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
}
+25
View File
@@ -0,0 +1,25 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/**
* @property array{analyst:array{id:int,name:string,purchasing_role:string},basis_hash:string} $snapshot
* @property list<array{criterion_id:int,result:string,evidence:string,reason:string}> $answers
*/
class QualificationAssessment extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['answers' => 'array', 'snapshot' => 'array'];
}
}
+25
View File
@@ -0,0 +1,25 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/**
* @property list<array{id:int,label:string,category:string,required:bool}> $criteria
* @property array<string,mixed> $snapshot
*/
class QualificationSet extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['criteria' => 'array', 'snapshot' => 'array'];
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property array{roles:list<string>,required_count:int,policy_revision:int} $snapshot */
class RecommendationAdoption extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['snapshot' => 'array'];
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property array<string,mixed> $snapshot */
class RecommendationAttempt extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['snapshot' => 'array'];
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
/** @property list<string> $roles */
class RecommendationPolicy extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['roles' => 'array', 'enabled' => 'boolean'];
}
}
+21
View File
@@ -0,0 +1,21 @@
<?php
namespace App\Models;
use App\Models\Concerns\AppendOnlyInventoryRecord;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Model;
class RecommendationReview extends Model
{
use AppendOnlyInventoryRecord, BelongsToTenant;
public $timestamps = false;
protected $guarded = ['id'];
protected function casts(): array
{
return ['snapshot' => 'array'];
}
}
@@ -0,0 +1,101 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\Budget;
use App\Models\BudgetReinforcement;
use App\Models\User;
use Brick\Math\BigDecimal;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
class BudgetReinforcementWorkflow
{
private function actor(User $user, int $tenantId): void
{
abort_unless(auth()->id() === $user->id && $user->tenant_id === $tenantId && in_array($user->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Finance]), 403);
}
private function valid(Budget $budget, int $amount): void
{
if (! $budget->approved_by || (int) $budget->year !== now()->year || $amount <= 0) {
throw ValidationException::withMessages(['reinforcement' => 'Exige dotação aprovada do exercício actual e montante positivo.']);
}
// Same technical monetary ceiling as requisitions; not a company approval threshold.
if (BigDecimal::of($budget->approvedTotalMinor())->plus($amount)->isGreaterThan('100000000000000')) {
throw ValidationException::withMessages(['reinforcement' => 'A dotação acumulada ultrapassa o limite técnico de valores suportados.']);
}
}
/** @param array<string,mixed> $data */
public function propose(User $user, Budget $budget, array $data): BudgetReinforcement
{
$this->actor($user, $budget->tenant_id);
return DB::transaction(function () use ($user, $budget, $data) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->actor($user, $budget->tenant_id);
$budget = Budget::query()->lockForUpdate()->findOrFail($budget->id);
$amount = BigDecimal::of((string) $data['amount'])->multipliedBy(100)->toScale(0)->toInt();
$reference = Str::upper(Str::squish($data['reference']));
$reason = trim($data['reason']);
$hash = hash('sha256', json_encode(['budget_id' => $budget->id, 'amount_minor' => $amount, 'reason' => $reason], JSON_THROW_ON_ERROR));
$existing = BudgetReinforcement::query()->where('reference', $reference)->first();
if ($existing) {
if ($existing->created_by !== $user->id || $existing->payload_hash !== $hash) {
throw ValidationException::withMessages(['reference' => 'Referência já registada com outros dados.']);
}
return $existing;
}
$this->valid($budget, $amount);
if ($reference === '' || $reason === '') {
throw ValidationException::withMessages(['reinforcement' => 'Referência e fundamento obrigatórios.']);
}
$reinforcement = BudgetReinforcement::query()->create(['tenant_id' => $user->tenant_id, 'budget_id' => $budget->id, 'created_by' => $user->id, 'reference' => $reference, 'payload_hash' => $hash, 'amount_minor' => $amount, 'reason' => $reason]);
$this->audit($user, $reinforcement, 'budget.reinforcement_proposed');
return $reinforcement;
});
}
public function review(User $user, BudgetReinforcement $reinforcement, string $decision, string $reason): void
{
$this->actor($user, $reinforcement->tenant_id);
abort_if($user->id === $reinforcement->created_by, 403);
if (! in_array($decision, ['approved', 'rejected']) || trim($reason) === '') {
throw ValidationException::withMessages(['reinforcement' => 'Decisão e fundamento obrigatórios.']);
}
DB::transaction(function () use ($user, $reinforcement, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->actor($user, $reinforcement->tenant_id);
$budget = Budget::query()->lockForUpdate()->findOrFail($reinforcement->budget_id);
$reinforcement = BudgetReinforcement::query()->lockForUpdate()->findOrFail($reinforcement->id);
if ($reinforcement->status !== 'pending') {
if ($reinforcement->status !== $decision) {
throw ValidationException::withMessages(['reinforcement' => 'Decisão final imutável.']);
}
return;
}
if ($decision === 'approved') {
$this->valid($budget, $reinforcement->amount_minor);
$author = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->find($reinforcement->created_by);
if (! $author || ! in_array($author->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Finance])) {
throw ValidationException::withMessages(['reinforcement' => 'Autor da proposta deixou de ser elegível.']);
}
}
$reinforcement->update(['status' => $decision, 'reviewed_by' => $user->id, 'review_reason' => trim($reason), 'reviewed_at' => now()]);
$this->audit($user, $reinforcement, 'budget.reinforcement_'.$decision);
});
}
private function audit(User $user, BudgetReinforcement $reinforcement, string $action): void
{
app(RequisitionWorkflow::class)->audit($user, $action, null, null, ['reinforcement_id' => $reinforcement->id, 'budget_id' => $reinforcement->budget_id, 'amount_minor' => $reinforcement->amount_minor, 'status' => $reinforcement->status]);
}
}
+5 -1
View File
@@ -30,6 +30,10 @@ class BudgetWorkflow
if (! $budget) {
return null;
}
$requiredKind = $request->items()->where('purchase_type', 'equipment')->exists() ? 'investment' : 'operating';
if ($budget->kind !== $requiredKind) {
throw ValidationException::withMessages(['budget' => 'A dotação deve ter a classificação explícita adequada: investimento para processos com equipamento; corrente para os restantes.']);
}
if (! $budget->approved_by || ($kind !== 'release' && (int) $budget->year !== now()->year)) {
throw ValidationException::withMessages(['budget' => 'Dotação pendente de aprovação ou exercício encerrado.']);
}
@@ -54,7 +58,7 @@ class BudgetWorkflow
$ledger = BudgetEntry::query()->where('budget_id', $budget->id);
$used = (int) (clone $ledger)->sum('reserved_minor') + (int) $ledger->sum('committed_minor');
$used += (int) BudgetConsumption::query()->where('budget_id', $budget->id)->sum('amount_minor');
if ($used + $reserveDelta + $commitDelta > $budget->amount_minor) {
if ($used + $reserveDelta + $commitDelta > $budget->approvedTotalMinor()) {
throw ValidationException::withMessages(['budget' => 'Saldo orçamental insuficiente. Não são permitidos excessos.']);
}
BudgetEntry::query()->create(['tenant_id' => $user->tenant_id, 'budget_id' => $budget->id, 'requisition_id' => $request->id, 'created_by' => $user->id, 'kind' => $kind, 'reserved_minor' => $reserveDelta, 'committed_minor' => $commitDelta, 'created_at' => now()]);
+6
View File
@@ -84,8 +84,14 @@ class ConflictGuard
'requisition.created', 'requisition.updated', 'requisition.submitted',
'approval.approved', 'approval.rejected', 'quotation.created', 'quotation.evaluated',
'award.created', 'award.approved', 'award.rejected', 'purchase_order.issued',
'opening.recorded',
'qualification.defined', 'qualification.assessed',
'admission.adopted', 'admission.proposed', 'admission.reviewed',
'recommendation.adopted', 'recommendation.proposed', 'recommendation.reviewed',
'equipment.technical_approved', 'equipment.technical_rejected',
'invoice.created', 'invoice.validated',
'payment.registered', 'payment.confirmed', 'payment.rejected',
'cancellation.requested', 'cancellation.approved', 'cancellation.rejected',
])->pluck('user_id'))
->unique()->values()->all();
$ids = [];
+25
View File
@@ -0,0 +1,25 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\User;
use Illuminate\Support\Facades\DB;
class CurrentActor
{
/** Call after the company lock, inside the business transaction.
* @param list<PurchasingRole>|null $roles
*/
public function lock(User $actor, ?array $roles = null): User
{
abort_unless(auth()->id() === $actor->id && $actor->tenant_id !== null, 403);
if (DB::connection()->transactionLevel() === 0) {
throw new \LogicException('Revalidar o operador dentro da transacção.');
}
$user = User::query()->where('tenant_id', $actor->tenant_id)->lockForUpdate()->findOrFail($actor->id);
abort_unless($roles === null || in_array($user->purchasing_role, $roles, true), 403);
return $user;
}
}
@@ -0,0 +1,119 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\PurchaseAward;
use App\Models\QualificationAssessment;
use App\Models\QualificationSet;
use App\Models\Quotation;
use App\Models\QuotationItem;
use App\Models\Requisition;
use App\Models\Supplier;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class DocumentaryQualificationWorkflow
{
private function invalid(string $field, string $message): never
{
throw ValidationException::withMessages([$field => $message]);
}
/** Call after the company/actor locks; coordinates with award and quote transactions. */
private function process(User $actor, int $requisitionId): Requisition
{
$request = Requisition::query()->visibleTo($actor)->lockForUpdate()->findOrFail($requisitionId);
if ($request->status !== 'approved' || PurchaseAward::query()->where('requisition_id', $request->id)->exists()) {
$this->invalid('qualification', 'Registe a análise num pedido aprovado, antes da adjudicação. As versões anteriores continuam disponíveis.');
}
app(ConflictGuard::class)->assertParticipation($actor, $request);
$quotes = Quotation::query()->where('requisition_id', $request->id)->orderBy('id')->lockForUpdate()->get(['id', 'supplier_id']);
Supplier::query()->whereIn('id', $quotes->pluck('supplier_id'))->orderBy('id')->lockForUpdate()->get();
QuotationItem::query()->whereIn('quotation_id', $quotes->pluck('id'))->orderBy('id')->lockForUpdate()->get();
return $request;
}
/** @param array<string,mixed> $data */
public function define(User $actor, Requisition $request, array $data): QualificationSet
{
return DB::transaction(function () use ($actor, $request, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
$request = $this->process($actor, $request->id);
$latest = QualificationSet::query()->where('requisition_id', $request->id)->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0)) {
$this->invalid('previous_id', 'Os requisitos mudaram. Actualize a página antes de registar outra versão.');
}
$opening = app(ProposalOpeningWorkflow::class);
$proposals = $opening->proposals($request);
if ($proposals === [] || $opening->basis($proposals) !== $data['basis_hash']) {
$this->invalid('basis_hash', 'As propostas mudaram ou ainda não existem. Confira a base actual.');
}
$criteria = [];
$labels = [];
foreach (array_values($data['criteria']) as $index => $criterion) {
$label = trim($criterion['label']);
$key = mb_strtolower($label);
if (mb_strlen($label) < 3 || in_array($key, $labels, true) || ! in_array($criterion['category'], ['legal', 'financial', 'fiscal', 'technical', 'administrative'])) {
$this->invalid('criteria', 'Defina requisitos distintos, com descrição e categoria válidas.');
}
$labels[] = $key;
$criteria[] = ['id' => $index + 1, 'label' => $label, 'category' => $criterion['category'], 'required' => (bool) $criterion['required']];
}
if ($criteria === []) {
$this->invalid('criteria', 'Defina pelo menos um requisito.');
}
$set = QualificationSet::query()->create(['tenant_id' => $actor->tenant_id, 'requisition_id' => $request->id, 'created_by' => $actor->id, 'revision' => ($latest->revision ?? 0) + 1, 'criteria' => $criteria, 'snapshot' => ['requisition' => $request->only(['id', 'number', 'justification']), 'author' => $actor->only(['id', 'name']), 'proposals' => $proposals], 'basis_hash' => $data['basis_hash'], 'reason' => $data['reason'], 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'qualification.defined', $request, null, ['set_id' => $set->id, 'revision' => $set->revision, 'previous_id' => $latest?->id]);
return $set;
});
}
/** @param array<string,mixed> $data */
public function assess(User $actor, QualificationSet $set, array $data): QualificationAssessment
{
return DB::transaction(function () use ($actor, $set, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement, PurchasingRole::Finance, PurchasingRole::DepartmentHead]);
$request = $this->process($actor, $set->requisition_id);
abort_if($actor->id === $request->requester_id, 403);
$set = QualificationSet::query()->lockForUpdate()->findOrFail($set->id);
$latestSet = QualificationSet::query()->where('requisition_id', $request->id)->latest('revision')->firstOrFail();
$opening = app(ProposalOpeningWorkflow::class);
if ($set->id !== $latestSet->id || $set->basis_hash !== $opening->basis($opening->proposals($request))) {
$this->invalid('qualification', 'Os requisitos ou a base mudaram. As análises anteriores são históricas; registe uma versão actual dos requisitos.');
}
$quote = Quotation::query()->where('requisition_id', $request->id)->whereKey($data['quotation_id'])->firstOrFail();
app(ConflictGuard::class)->assertProcess($request, $quote->supplier_id, $actor);
$latest = QualificationAssessment::query()->where('qualification_set_id', $set->id)->where('quotation_id', $quote->id)->where('analyst_id', $actor->id)->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0)) {
$this->invalid('previous_id', 'A sua análise mudou. Não é permitido substituir versões ou análises de outro utilizador.');
}
$expected = array_column($set->criteria, 'id');
$received = array_column($data['answers'], 'criterion_id');
sort($expected);
sort($received);
if ($expected !== $received) {
$this->invalid('answers', 'Registe uma resposta para cada requisito desta versão, sem repetições.');
}
$answers = [];
foreach ($data['answers'] as $answer) {
$result = $answer['result'];
$reason = trim($answer['reason'] ?? '');
$evidence = trim($answer['evidence'] ?? '');
if (! in_array($result, ['pending', 'met', 'not_met', 'not_applicable']) || ($result !== 'pending' && mb_strlen($reason) < 10) || (in_array($result, ['met', 'not_met']) && mb_strlen($evidence) < 3)) {
$this->invalid('answers', 'Resultados preenchidos exigem fundamento; cumprido e não cumprido exigem também referência de evidência.');
}
$answers[] = ['criterion_id' => $answer['criterion_id'], 'result' => $result, 'evidence' => $evidence, 'reason' => $reason];
}
$assessment = QualificationAssessment::query()->create(['tenant_id' => $actor->tenant_id, 'qualification_set_id' => $set->id, 'quotation_id' => $quote->id, 'analyst_id' => $actor->id, 'revision' => ($latest->revision ?? 0) + 1, 'answers' => $answers, 'snapshot' => ['analyst' => $actor->only(['id', 'name', 'purchasing_role']), 'basis_hash' => $set->basis_hash], 'reason' => $data['reason'], 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'qualification.assessed', $request, null, ['assessment_id' => $assessment->id, 'set_id' => $set->id, 'quotation_id' => $quote->id, 'revision' => $assessment->revision, 'previous_id' => $latest?->id]);
return $assessment;
});
}
}
+9 -1
View File
@@ -66,6 +66,7 @@ class EquipmentWorkflow
{
return DB::transaction(function () use ($user, $requisition, $basis, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::DepartmentHead]);
$requisition = Requisition::query()->lockForUpdate()->findOrFail($requisition->id);
abort_unless($this->canReview($user, $requisition), 403);
app(ConflictGuard::class)->assertParticipation($user, $requisition);
@@ -88,7 +89,14 @@ class EquipmentWorkflow
return;
}
$review = TechnicalReview::query()->where('requisition_id', $requisition->id)->where('basis_hash', $this->basis($requisition))->first();
$user = $review ? User::query()->where('tenant_id', $requisition->tenant_id)->find($review->reviewed_by) : null;
$user = null;
if ($review) {
$query = User::query()->where('tenant_id', $requisition->tenant_id);
if (DB::connection()->transactionLevel() > 0) {
$query->lockForUpdate();
}
$user = $query->find($review->reviewed_by);
}
if (! $review || $review->decision !== 'approved' || ! $user || ! $this->eligible($user, $requisition)) {
throw ValidationException::withMessages(['technical' => 'É necessária validação técnica válida do responsável da área, distinto do solicitante, para a versão actual.']);
}
+136
View File
@@ -0,0 +1,136 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\ExternalPayment;
use App\Models\Invoice;
use App\Models\PurchaseOrder;
use App\Models\Requisition;
use App\Models\Supplier;
use App\Models\SupplierBankDetail;
use App\Models\SupplierBankReview;
use App\Models\User;
use Brick\Math\BigDecimal;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
class ExternalPaymentWorkflow
{
private function actor(User $user, int $tenantId): void
{
abort_unless(auth()->id() === $user->id && $user->tenant_id === $tenantId && $user->purchasing_role === PurchasingRole::Finance, 403);
}
private function invalid(string $message): never
{
throw ValidationException::withMessages(['payment' => $message]);
}
public function outstanding(Invoice $invoice): int
{
return (int) $invoice->total_minor - (int) ExternalPayment::query()->where('invoice_id', $invoice->id)->where('status', 'confirmed')->sum('amount_minor');
}
private function bank(User $user, Invoice $invoice, int $bankId, int $amount): SupplierBankDetail
{
if ($invoice->status !== 'validated' || $amount <= 0 || $amount > $this->outstanding($invoice)) {
$this->invalid('Factura não validada ou montante superior ao saldo pendente.');
}
$order = PurchaseOrder::query()->findOrFail($invoice->purchase_order_id);
$request = Requisition::query()->findOrFail($order->requisition_id);
app(ConflictGuard::class)->assertProcess($request, $order->supplier_id, $user);
$supplier = Supplier::query()->lockForUpdate()->findOrFail($order->supplier_id);
$bank = SupplierBankDetail::query()->where('supplier_id', $supplier->id)->latest('revision')->first();
if ($bank) {
User::query()->where('tenant_id', $user->tenant_id)->whereIn('id', SupplierBankReview::query()->where('supplier_bank_detail_id', $bank->id)->select('reviewed_by'))->orderBy('id')->lockForUpdate()->get();
}
if (! $bank || $bank->id !== $bankId || app(SupplierBankWorkflow::class)->state($supplier) !== 'approved') {
$this->invalid('A versão bancária actual deve ter duas validações elegíveis. Actualize a ficha; não reutilize uma versão substituída.');
}
if ($bank->currency !== $order->currency || $order->currency !== 'MZN') {
$this->invalid('A moeda da conta deve coincidir com a factura. Câmbio não suportado.');
}
return $bank;
}
/** @param array<string,mixed> $data */
public function register(User $user, Invoice $invoice, array $data): ExternalPayment
{
$this->actor($user, $invoice->tenant_id);
return DB::transaction(function () use ($user, $invoice, $data) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->actor($user, $invoice->tenant_id);
$invoice = Invoice::query()->lockForUpdate()->findOrFail($invoice->id);
$reference = Str::upper(Str::squish($data['external_reference']));
$amount = BigDecimal::of((string) $data['amount'])->multipliedBy(100)->toScale(0)->toInt();
$canonical = ['invoice_id' => $invoice->id, 'bank_id' => (int) $data['supplier_bank_detail_id'], 'amount_minor' => $amount, 'paid_on' => $data['paid_on'], 'evidence_reference' => trim($data['evidence_reference'])];
$hash = hash_hmac('sha256', json_encode($canonical, JSON_THROW_ON_ERROR), config('app.key'));
$referenceHash = hash_hmac('sha256', $reference, config('app.key'));
$existing = ExternalPayment::query()->where('reference_hash', $referenceHash)->first();
if ($existing) {
if ($existing->created_by !== $user->id || $existing->payload_hash !== $hash) {
$this->invalid('Referência externa já registada. Consulte a conferência existente.');
}
return $existing;
}
if ($reference === '' || trim($data['evidence_reference']) === '' || $data['paid_on'] < (string) $invoice->issued_on || $data['paid_on'] > today()->format('Y-m-d') || substr($data['paid_on'], 0, 4) !== now()->format('Y')) {
$this->invalid('Referência, evidência e data válida do exercício actual são obrigatórias.');
}
$bank = $this->bank($user, $invoice, (int) $data['supplier_bank_detail_id'], $amount);
$payment = ExternalPayment::query()->create(['tenant_id' => $user->tenant_id, 'invoice_id' => $invoice->id, 'supplier_bank_detail_id' => $bank->id, 'created_by' => $user->id, 'amount_minor' => $amount, 'currency' => $bank->currency, 'paid_on' => $data['paid_on'], 'external_reference' => $reference, 'reference_hash' => $referenceHash, 'payload_hash' => $hash, 'evidence_reference' => trim($data['evidence_reference']), 'bank_snapshot' => ['bank_id' => $bank->id, 'revision' => $bank->revision, 'bank_name' => $bank->bank_name, 'country' => $bank->country, 'currency' => $bank->currency, 'beneficiary' => $bank->beneficiary, 'account_identifier' => $bank->account_identifier, 'reviewer_ids' => SupplierBankReview::query()->where('supplier_bank_detail_id', $bank->id)->pluck('reviewed_by')->all(), 'development_only' => true, 'bank_transfer_executed' => false]]);
$this->audit($user, $invoice, $payment, 'payment.registered');
return $payment;
});
}
public function review(User $user, ExternalPayment $payment, string $decision, string $reason): void
{
$this->actor($user, $payment->tenant_id);
abort_if($payment->created_by === $user->id, 403);
if (! in_array($decision, ['confirmed', 'rejected']) || trim($reason) === '') {
$this->invalid('Decisão e fundamento obrigatórios.');
}
DB::transaction(function () use ($user, $payment, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->actor($user, $payment->tenant_id);
$invoice = Invoice::query()->lockForUpdate()->findOrFail($payment->invoice_id);
$payment = ExternalPayment::query()->lockForUpdate()->findOrFail($payment->id);
if ($payment->status !== 'pending') {
if ($payment->status !== $decision) {
$this->invalid('Conferência já decidida; não pode ser reescrita.');
}
return;
}
$order = PurchaseOrder::query()->findOrFail($invoice->purchase_order_id);
app(ConflictGuard::class)->assertProcess(Requisition::query()->findOrFail($order->requisition_id), $order->supplier_id, $user);
if ($decision === 'confirmed') {
if (substr((string) $payment->paid_on, 0, 4) !== now()->format('Y')) {
$this->invalid('Conferência entre exercícios não suportada.');
}
$this->bank($user, $invoice, $payment->supplier_bank_detail_id, $payment->amount_minor);
$author = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->find($payment->created_by);
if (! $author || $author->purchasing_role !== PurchasingRole::Finance) {
$this->invalid('O autor do registo deixou de ser elegível.');
}
}
$payment->update(['status' => $decision, 'reviewed_by' => $user->id, 'review_reason' => $reason, 'reviewed_at' => now()]);
$this->audit($user, $invoice, $payment, 'payment.'.$decision);
});
}
private function audit(User $user, Invoice $invoice, ExternalPayment $payment, string $action): void
{
$order = PurchaseOrder::query()->findOrFail($invoice->purchase_order_id);
$request = Requisition::query()->findOrFail($order->requisition_id);
app(RequisitionWorkflow::class)->audit($user, $action, $request, null, ['payment_id' => $payment->id, 'invoice_id' => $invoice->id, 'bank_detail_id' => $payment->supplier_bank_detail_id, 'amount_minor' => $payment->amount_minor, 'status' => $payment->status, 'bank_transfer_executed' => false]);
}
}
+247
View File
@@ -0,0 +1,247 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\AdmissionAdoption;
use App\Models\AdmissionDecision;
use App\Models\AdmissionPolicy;
use App\Models\AdmissionReview;
use App\Models\PurchaseAward;
use App\Models\PurchaseOrder;
use App\Models\QualificationAssessment;
use App\Models\QualificationSet;
use App\Models\Quotation;
use App\Models\QuotationItem;
use App\Models\Requisition;
use App\Models\Supplier;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class FormalAdmission
{
private function invalid(string $message): never
{
throw ValidationException::withMessages(['admission' => $message]);
}
public function adoption(Requisition $request): ?AdmissionAdoption
{
return AdmissionAdoption::query()->where('requisition_id', $request->id)->latest('revision')->first();
}
private function process(User $actor, int $id): Requisition
{
$request = Requisition::query()->visibleTo($actor)->lockForUpdate()->findOrFail($id);
if ($request->status !== 'approved' || PurchaseAward::query()->where('requisition_id', $id)->exists() || PurchaseOrder::query()->where('requisition_id', $id)->exists()) {
$this->invalid('O regime e as decisões só podem ser registados num pedido aprovado, antes da adjudicação.');
}
app(ConflictGuard::class)->assertParticipation($actor, $request);
$quotes = Quotation::query()->where('requisition_id', $id)->orderBy('id')->lockForUpdate()->get(['id', 'supplier_id']);
Supplier::query()->whereIn('id', $quotes->pluck('supplier_id'))->orderBy('id')->lockForUpdate()->get();
QuotationItem::query()->whereIn('quotation_id', $quotes->pluck('id'))->orderBy('id')->lockForUpdate()->get();
return $request;
}
/** @param array<string,mixed> $data */
public function policy(User $actor, array $data): AdmissionPolicy
{
if (! is_bool($data['enabled']) || ! is_array($data['roles']) || $data['roles'] === [] || count(array_unique($data['roles'])) !== count($data['roles']) || array_diff($data['roles'], ['finance', 'department_head']) !== [] || filter_var($data['required_count'], FILTER_VALIDATE_INT) === false || $data['required_count'] < 1 || $data['required_count'] > 50 || mb_strlen(trim($data['reason'])) < 10) {
$this->invalid('Defina expressamente perfis, quantidade de conferentes e fundamento da política.');
}
return DB::transaction(function () use ($actor, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Admin]);
$latest = AdmissionPolicy::query()->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0)) {
$this->invalid('A política mudou. Actualize antes de criar outra versão.');
}
$policy = AdmissionPolicy::query()->create(['tenant_id' => $actor->tenant_id, 'created_by' => $actor->id, 'revision' => ($latest->revision ?? 0) + 1, 'enabled' => $data['enabled'], 'roles' => array_values($data['roles']), 'required_count' => $data['required_count'], 'reason' => $data['reason'], 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'admission.policy', null, null, $policy->toArray());
return $policy;
});
}
public function adopt(User $actor, Requisition $request, int $policyId, int $previousId, string $reason): AdmissionAdoption
{
return DB::transaction(function () use ($actor, $request, $policyId, $previousId, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
$request = $this->process($actor, $request->id);
$previous = $this->adoption($request);
$policy = AdmissionPolicy::query()->latest('revision')->first();
if (! $policy || ! $policy->enabled || $policy->id !== $policyId || ($previous->id ?? 0) !== $previousId) {
$this->invalid('Seleccione a política activa e a adopção actual. Não se altera um regime implicitamente.');
}
if ($previous?->admission_policy_id === $policy->id || mb_strlen(trim($reason)) < 10) {
$this->invalid('A adopção exige outra versão de política e fundamento próprio.');
}
$adoption = AdmissionAdoption::query()->create(['tenant_id' => $actor->tenant_id, 'requisition_id' => $request->id, 'admission_policy_id' => $policy->id, 'created_by' => $actor->id, 'revision' => ($previous->revision ?? 0) + 1, 'snapshot' => ['roles' => $policy->roles, 'required_count' => $policy->required_count, 'policy_revision' => $policy->revision], 'reason' => $reason, 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'admission.adopted', $request, null, ['adoption' => $adoption->toArray(), 'previous_id' => $previous?->id]);
return $adoption;
});
}
/** @return array{set_id:int,payload:array<string,mixed>,hash:string,clear:bool}|null */
public function basis(Requisition $request, int $quoteId): ?array
{
$set = QualificationSet::query()->where('requisition_id', $request->id)->latest('revision')->first();
if (! $set) {
return null;
}
$opening = app(ProposalOpeningWorkflow::class);
$quotes = $opening->proposals($request);
if ($set->basis_hash !== $opening->basis($quotes)) {
return null;
}
$quote = collect($quotes)->firstWhere('id', $quoteId);
if (! $quote) {
return null;
}
$ids = QualificationAssessment::query()->where('qualification_set_id', $set->id)->where('quotation_id', $quoteId)->selectRaw('MAX(id)')->groupBy('analyst_id');
$records = QualificationAssessment::query()->whereIn('id', $ids)->orderBy('analyst_id')->get();
$clear = $records->isNotEmpty();
foreach ($set->criteria as $criterion) {
$results = [];
foreach ($records as $record) {
$answer = collect($record->answers)->firstWhere('criterion_id', $criterion['id']);
if (! $answer || ! in_array($answer['result'], ['met', 'not_met', 'not_applicable'], true) || ($criterion['required'] && $answer['result'] !== 'met')) {
$clear = false;
}
if ($answer) {
$results[] = $answer['result'];
}
}
if (count(array_unique($results)) !== 1) {
$clear = false;
}
}
$payload = ['set_id' => $set->id, 'criteria' => $set->criteria, 'quotes_hash' => $set->basis_hash, 'quote' => $quote, 'analyses' => $records->map(fn ($record) => $record->only(['id', 'analyst_id', 'revision', 'answers', 'snapshot']))->all()];
return ['set_id' => $set->id, 'payload' => $payload, 'hash' => hash('sha256', json_encode($payload, JSON_THROW_ON_ERROR)), 'clear' => $clear];
}
public function status(AdmissionDecision $decision, AdmissionAdoption $adoption): string
{
$reviews = AdmissionReview::query()->where('admission_decision_id', $decision->id)->get();
if ($reviews->contains('verdict', 'returned')) {
return 'returned';
}
return $reviews->where('verdict', 'approved')->count() >= $adoption->snapshot['required_count'] ? 'confirmed' : 'pending';
}
/** @param array<string,mixed> $data */
public function propose(User $actor, Requisition $request, array $data): AdmissionDecision
{
if (! in_array($data['outcome'], ['admit', 'exclude', 'clarify'], true) || mb_strlen(trim($data['reason'])) < 10) {
$this->invalid('Seleccione uma decisão e fundamente a tentativa.');
}
return DB::transaction(function () use ($actor, $request, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
$request = $this->process($actor, $request->id);
abort_if($actor->id === $request->requester_id, 403);
$adoption = $this->adoption($request);
if (! $adoption) {
$this->invalid('O processo ainda não adoptou expressamente o regime.');
}
$quote = Quotation::query()->where('requisition_id', $request->id)->whereKey($data['quotation_id'])->firstOrFail();
app(ConflictGuard::class)->assertProcess($request, $quote->supplier_id, $actor);
$basis = $this->basis($request, $quote->id);
if (! $basis || $basis['hash'] !== $data['basis_hash']) {
$this->invalid('Confira requisitos e análises actuais antes de propor uma decisão.');
}
if ($data['outcome'] === 'admit' && ! $basis['clear']) {
$this->invalid('A admissão exige análise sem pendências, divergências ou requisitos obrigatórios não resolvidos.');
}
$previous = AdmissionDecision::query()->where('admission_adoption_id', $adoption->id)->where('quotation_id', $quote->id)->latest('revision')->first();
if ((int) $data['previous_id'] !== ($previous->id ?? 0)) {
$this->invalid('A tentativa mudou. Actualize a página para preservar o antecedente correcto.');
}
$decision = AdmissionDecision::query()->create(['tenant_id' => $actor->tenant_id, 'admission_adoption_id' => $adoption->id, 'qualification_set_id' => $basis['set_id'], 'quotation_id' => $quote->id, 'created_by' => $actor->id, 'revision' => ($previous->revision ?? 0) + 1, 'outcome' => $data['outcome'], 'basis_hash' => $basis['hash'], 'snapshot' => ['basis' => $basis['payload'], 'proponent' => $actor->only(['id', 'name'])], 'reason' => $data['reason'], 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'admission.proposed', $request, null, ['decision' => $decision->toArray(), 'previous_id' => $previous?->id]);
return $decision;
});
}
public function eligible(User $actor, Requisition $request, AdmissionAdoption $adoption, AdmissionDecision $decision): bool
{
return $actor->tenant_id === $request->tenant_id && in_array($actor->purchasing_role->value, $adoption->snapshot['roles'], true) && ! in_array($actor->id, [$request->requester_id, $decision->created_by], true) && ($actor->purchasing_role !== PurchasingRole::DepartmentHead || $actor->department_id === $request->department_id);
}
public function review(User $actor, AdmissionDecision $decision, string $verdict, string $reason): void
{
if (! in_array($verdict, ['approved', 'returned'], true) || mb_strlen(trim($reason)) < 10) {
$this->invalid('Seleccione uma conferência válida e fundamente-a.');
}
DB::transaction(function () use ($actor, $decision, $verdict, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Finance, PurchasingRole::DepartmentHead]);
$original = AdmissionAdoption::query()->findOrFail($decision->admission_adoption_id);
$request = $this->process($actor, $original->requisition_id);
$adoption = $this->adoption($request);
abort_unless($adoption && $this->eligible($actor, $request, $adoption, $decision), 403);
$latest = AdmissionDecision::query()->where('admission_adoption_id', $adoption->id)->where('quotation_id', $decision->quotation_id)->latest('revision')->first();
$basis = $this->basis($request, $decision->quotation_id);
if ($decision->admission_adoption_id !== $adoption->id || $latest?->id !== $decision->id || ! $basis || $basis['hash'] !== $decision->basis_hash) {
$this->invalid('A política do processo, tentativa ou base mudou. Registe outra tentativa e novas conferências.');
}
$existing = AdmissionReview::query()->where('admission_decision_id', $decision->id)->where('reviewed_by', $actor->id)->first();
if ($existing) {
if ($existing->verdict !== $verdict || $existing->reason !== $reason) {
$this->invalid('A conferência anterior é imutável.');
}
return;
}
if ($this->status($decision, $adoption) !== 'pending') {
$this->invalid('Esta tentativa já foi concluída ou devolvida.');
}
if ($verdict === 'approved') {
foreach (AdmissionReview::query()->where('admission_decision_id', $decision->id)->where('verdict', 'approved')->get() as $review) {
$reviewer = User::query()->where('tenant_id', $actor->tenant_id)->lockForUpdate()->find($review->reviewed_by);
if (! $reviewer || ! $this->eligible($reviewer, $request, $adoption, $decision)) {
$this->invalid('Um conferente anterior deixou de ser elegível antes da conclusão. Devolva e prepare outra tentativa.');
}
}
}
$review = AdmissionReview::query()->create(['tenant_id' => $actor->tenant_id, 'admission_decision_id' => $decision->id, 'reviewed_by' => $actor->id, 'verdict' => $verdict, 'reason' => $reason, 'snapshot' => $actor->only(['id', 'name', 'purchasing_role', 'department_id']), 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'admission.reviewed', $request, null, $review->toArray());
});
}
/** @return array<string,mixed>|null */
public function selection(Requisition $request, int $quoteId): ?array
{
$adoption = $this->adoption($request);
if (! $adoption) {
return null;
}
$decision = AdmissionDecision::query()->where('admission_adoption_id', $adoption->id)->where('quotation_id', $quoteId)->latest('revision')->first();
$basis = $this->basis($request, $quoteId);
if (! $decision || $decision->outcome !== 'admit' || ! $basis || ! $basis['clear'] || $basis['hash'] !== $decision->basis_hash || $this->status($decision, $adoption) !== 'confirmed') {
$this->invalid('A proposta exige admissão confirmada na base actual do regime adoptado.');
}
return ['adoption_id' => $adoption->id, 'policy_id' => $adoption->admission_policy_id, 'decision_id' => $decision->id, 'qualification_set_id' => $decision->qualification_set_id, 'basis_hash' => $decision->basis_hash, 'review_ids' => AdmissionReview::query()->where('admission_decision_id', $decision->id)->orderBy('id')->pluck('id')->all()];
}
public function admitted(Requisition $request, int $quoteId): bool
{
try {
$this->selection($request, $quoteId);
return true;
} catch (ValidationException) {
return false;
}
}
}
+214
View File
@@ -0,0 +1,214 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\AdmissionDecision;
use App\Models\AdmissionReview;
use App\Models\ProposalEvaluation;
use App\Models\PurchaseAward;
use App\Models\PurchaseOrder;
use App\Models\Quotation;
use App\Models\QuotationItem;
use App\Models\RecommendationAdoption;
use App\Models\RecommendationAttempt;
use App\Models\RecommendationPolicy;
use App\Models\RecommendationReview;
use App\Models\Requisition;
use App\Models\Supplier;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class FormalRecommendation
{
private function invalid(string $message): never
{
throw ValidationException::withMessages(['recommendation' => $message]);
}
public function adoption(Requisition $request): ?RecommendationAdoption
{
return RecommendationAdoption::query()->where('requisition_id', $request->id)->latest('revision')->first();
}
private function process(User $actor, int $id): Requisition
{
$request = Requisition::query()->visibleTo($actor)->lockForUpdate()->findOrFail($id);
if ($request->status !== 'approved' || PurchaseAward::query()->where('requisition_id', $id)->exists() || PurchaseOrder::query()->where('requisition_id', $id)->exists()) {
$this->invalid('A recomendação só pode ser preparada num pedido aprovado, antes de adjudicar.');
}
app(ConflictGuard::class)->assertParticipation($actor, $request);
$quotes = Quotation::query()->where('requisition_id', $id)->orderBy('id')->lockForUpdate()->get(['id', 'supplier_id']);
Supplier::query()->whereIn('id', $quotes->pluck('supplier_id'))->orderBy('id')->lockForUpdate()->get();
QuotationItem::query()->whereIn('quotation_id', $quotes->pluck('id'))->orderBy('id')->lockForUpdate()->get();
ProposalEvaluation::query()->whereIn('quotation_id', $quotes->pluck('id'))->orderBy('id')->lockForUpdate()->get();
return $request;
}
/** @param array<string,mixed> $data */
public function policy(User $actor, array $data): RecommendationPolicy
{
if (! is_bool($data['enabled']) || ! is_array($data['roles']) || $data['roles'] === [] || count(array_unique($data['roles'])) !== count($data['roles']) || array_diff($data['roles'], ['finance', 'department_head']) !== [] || filter_var($data['required_count'], FILTER_VALIDATE_INT) === false || $data['required_count'] < 1 || $data['required_count'] > 50 || mb_strlen(trim($data['reason'])) < 10) {
$this->invalid('Defina perfis, quantidade de conferentes e fundamento próprios da recomendação.');
}
return DB::transaction(function () use ($actor, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Admin]);
$latest = RecommendationPolicy::query()->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0)) {
$this->invalid('A política mudou. Actualize antes de criar outra versão.');
}
$policy = RecommendationPolicy::query()->create(['tenant_id' => $actor->tenant_id, 'created_by' => $actor->id, 'revision' => ($latest->revision ?? 0) + 1, 'enabled' => $data['enabled'], 'roles' => array_values($data['roles']), 'required_count' => $data['required_count'], 'reason' => $data['reason'], 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'recommendation.policy', null, null, $policy->toArray());
return $policy;
});
}
public function adopt(User $actor, Requisition $request, int $policyId, int $previousId, string $reason): RecommendationAdoption
{
return DB::transaction(function () use ($actor, $request, $policyId, $previousId, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
$request = $this->process($actor, $request->id);
if (! app(FormalAdmission::class)->adoption($request)) {
$this->invalid('Adopte expressamente o regime de admissão antes da recomendação.');
}
$previous = $this->adoption($request);
$policy = RecommendationPolicy::query()->latest('revision')->first();
if (! $policy || ! $policy->enabled || $policy->id !== $policyId || ($previous->id ?? 0) !== $previousId || $previous?->recommendation_policy_id === $policy->id || mb_strlen(trim($reason)) < 10) {
$this->invalid('Seleccione a política activa, a adopção actual e um fundamento próprio.');
}
$adoption = RecommendationAdoption::query()->create(['tenant_id' => $actor->tenant_id, 'requisition_id' => $request->id, 'recommendation_policy_id' => $policy->id, 'created_by' => $actor->id, 'revision' => ($previous->revision ?? 0) + 1, 'snapshot' => ['roles' => $policy->roles, 'required_count' => $policy->required_count, 'policy_revision' => $policy->revision], 'reason' => $reason, 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'recommendation.adopted', $request, null, ['adoption' => $adoption->toArray(), 'previous_id' => $previous?->id]);
return $adoption;
});
}
/** @return array{hash:string,payload:array{admission_adoption:array<string,mixed>|null,comparison_hash:string,ready:bool,top_ids:list<int>,rows:list<array<string,mixed>>,admissions:list<array<string,mixed>>},ready:bool,top_ids:list<int>} */
public function basis(Requisition $request): array
{
$comparison = app(ProposalComparison::class)->inspect($request);
$admission = app(FormalAdmission::class);
$adoption = $admission->adoption($request);
$rows = [];
$admissions = [];
foreach ($comparison['rows'] as $row) {
// Freeze the decision inputs without supplier contacts or private documents.
$rows[] = [...array_intersect_key($row, array_flip(['id', 'supplier_id', 'reference', 'currency', 'subtotal_minor', 'tax_minor', 'total_minor', 'delivery_days', 'valid_until', 'payment_terms', 'weights', 'eligible', 'ineligibility_reasons', 'evaluation_count', 'score_minor', 'items', 'evaluations', 'qualified_evaluations'])), 'supplier_name' => $row['supplier']['name'] ?? 'Fornecedor indisponível'];
$decision = AdmissionDecision::query()->where('admission_adoption_id', $adoption->id ?? 0)->where('quotation_id', $row['id'])->latest('revision')->first();
$admissions[] = ['quotation_id' => $row['id'], 'basis' => $admission->basis($request, $row['id']), 'decision' => $decision?->toArray(), 'reviews' => AdmissionReview::query()->where('admission_decision_id', $decision->id ?? 0)->orderBy('id')->get()->toArray()];
}
$payload = ['admission_adoption' => $adoption?->toArray(), 'comparison_hash' => $comparison['fingerprint'], 'ready' => $comparison['ready'], 'top_ids' => $comparison['top_ids'], 'rows' => $rows, 'admissions' => $admissions];
return ['hash' => hash('sha256', json_encode($payload, JSON_THROW_ON_ERROR)), 'payload' => $payload, 'ready' => $adoption !== null && $comparison['ready'], 'top_ids' => $comparison['top_ids']];
}
public function status(RecommendationAttempt $attempt, RecommendationAdoption $adoption): string
{
$reviews = RecommendationReview::query()->where('recommendation_attempt_id', $attempt->id)->get();
if ($reviews->contains('verdict', 'returned')) {
return 'returned';
}
return $reviews->where('verdict', 'approved')->count() >= $adoption->snapshot['required_count'] ? 'confirmed' : 'pending';
}
/** @param array<string,mixed> $data */
public function propose(User $actor, Requisition $request, array $data): RecommendationAttempt
{
if (mb_strlen(trim($data['reason'])) < 10) {
$this->invalid('Fundamente a recomendação, incluindo a escolha em caso de empate.');
}
return DB::transaction(function () use ($actor, $request, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
$request = $this->process($actor, $request->id);
abort_if($actor->id === $request->requester_id, 403);
$adoption = $this->adoption($request);
if (! $adoption) {
$this->invalid('Adopte expressamente o regime de recomendação.');
}
$quote = Quotation::query()->where('requisition_id', $request->id)->whereKey($data['quotation_id'])->firstOrFail();
$basis = $this->basis($request);
if (! $basis['ready'] || $basis['hash'] !== $data['basis_hash'] || ! in_array($quote->id, $basis['top_ids'], true)) {
$this->invalid('Exige-se matriz pronta, admissões confirmadas e escolha fundamentada entre as maiores pontuações da base actual.');
}
$previous = RecommendationAttempt::query()->where('recommendation_adoption_id', $adoption->id)->latest('revision')->first();
if ((int) $data['previous_id'] !== ($previous->id ?? 0)) {
$this->invalid('A tentativa mudou. Actualize antes de registar outra revisão.');
}
$attempt = RecommendationAttempt::query()->create(['tenant_id' => $actor->tenant_id, 'recommendation_adoption_id' => $adoption->id, 'quotation_id' => $quote->id, 'created_by' => $actor->id, 'revision' => ($previous->revision ?? 0) + 1, 'basis_hash' => $basis['hash'], 'snapshot' => ['basis' => $basis['payload'], 'proponent' => $actor->only(['id', 'name']), 'policy' => $adoption->snapshot], 'reason' => $data['reason'], 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'recommendation.proposed', $request, null, ['attempt' => $attempt->toArray(), 'previous_id' => $previous?->id]);
return $attempt;
});
}
public function eligible(User $actor, Requisition $request, RecommendationAdoption $adoption, RecommendationAttempt $attempt): bool
{
return $actor->tenant_id === $request->tenant_id && in_array($actor->purchasing_role->value, $adoption->snapshot['roles'], true) && ! in_array($actor->id, [$request->requester_id, $attempt->created_by], true) && ($actor->purchasing_role !== PurchasingRole::DepartmentHead || $actor->department_id === $request->department_id);
}
public function review(User $actor, RecommendationAttempt $attempt, string $verdict, string $reason): void
{
if (! in_array($verdict, ['approved', 'returned'], true) || mb_strlen(trim($reason)) < 10) {
$this->invalid('Registe uma conferência válida e fundamentada.');
}
DB::transaction(function () use ($actor, $attempt, $verdict, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Finance, PurchasingRole::DepartmentHead]);
$original = RecommendationAdoption::query()->findOrFail($attempt->recommendation_adoption_id);
$request = $this->process($actor, $original->requisition_id);
$adoption = $this->adoption($request);
abort_unless($adoption && $this->eligible($actor, $request, $adoption, $attempt), 403);
$latest = RecommendationAttempt::query()->where('recommendation_adoption_id', $adoption->id)->latest('revision')->first();
$basis = $this->basis($request);
if ($attempt->recommendation_adoption_id !== $adoption->id || $latest?->id !== $attempt->id || ! $basis['ready'] || $basis['hash'] !== $attempt->basis_hash) {
$this->invalid('A base, adopção ou tentativa mudou. Prepare outra recomendação e novas conferências.');
}
$existing = RecommendationReview::query()->where('recommendation_attempt_id', $attempt->id)->where('reviewed_by', $actor->id)->first();
if ($existing) {
if ($existing->verdict !== $verdict || $existing->reason !== $reason) {
$this->invalid('A conferência anterior é imutável.');
}
return;
}
if ($this->status($attempt, $adoption) !== 'pending') {
$this->invalid('A tentativa já foi concluída ou devolvida.');
}
if ($verdict === 'approved') {
foreach (RecommendationReview::query()->where('recommendation_attempt_id', $attempt->id)->where('verdict', 'approved')->get() as $review) {
$reviewer = User::query()->where('tenant_id', $actor->tenant_id)->lockForUpdate()->find($review->reviewed_by);
if (! $reviewer || ! $this->eligible($reviewer, $request, $adoption, $attempt)) {
$this->invalid('Um conferente anterior deixou de ser elegível. Devolva e prepare outra tentativa.');
}
}
}
$review = RecommendationReview::query()->create(['tenant_id' => $actor->tenant_id, 'recommendation_attempt_id' => $attempt->id, 'reviewed_by' => $actor->id, 'verdict' => $verdict, 'reason' => $reason, 'snapshot' => $actor->only(['id', 'name', 'purchasing_role', 'department_id']), 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'recommendation.reviewed', $request, null, $review->toArray());
});
}
/** @return array<string,mixed>|null */
public function selection(Requisition $request, int $quoteId): ?array
{
$adoption = $this->adoption($request);
if (! $adoption) {
return null;
}
$attempt = RecommendationAttempt::query()->where('recommendation_adoption_id', $adoption->id)->latest('revision')->first();
$basis = $this->basis($request);
if (! $attempt || $attempt->quotation_id !== $quoteId || ! $basis['ready'] || $basis['hash'] !== $attempt->basis_hash || $this->status($attempt, $adoption) !== 'confirmed') {
$this->invalid('A adjudicação exige a proposta da recomendação confirmada na base actual.');
}
return ['adoption_id' => $adoption->id, 'policy_id' => $adoption->recommendation_policy_id, 'attempt_id' => $attempt->id, 'quotation_id' => $quoteId, 'basis_hash' => $attempt->basis_hash, 'review_ids' => RecommendationReview::query()->where('recommendation_attempt_id', $attempt->id)->orderBy('id')->pluck('id')->all()];
}
}
+122
View File
@@ -0,0 +1,122 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\Budget;
use App\Models\BudgetEntry;
use App\Models\InvestmentPolicy;
use App\Models\InvestmentPolicyReview;
use App\Models\Quotation;
use App\Models\Requisition;
use App\Models\TechnicalReview;
use App\Models\User;
use Brick\Math\BigDecimal;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class InvestmentWorkflow
{
private function admin(User $user): void
{
abort_unless(auth()->id() === $user->id && $user->tenant_id !== null && $user->purchasing_role === PurchasingRole::Admin, 403);
}
/** @param array<string,mixed> $data */
public function propose(User $user, array $data): InvestmentPolicy
{
$this->admin($user);
return DB::transaction(function () use ($user, $data) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->admin($user);
$latest = InvestmentPolicy::query()->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0) || $data['mode'] !== 'ceiling' || $data['scope'] !== 'process_total' || $data['currency'] !== 'MZN') {
throw ValidationException::withMessages(['investment' => 'Versão desactualizada ou regra não suportada. Não se presume um circuito de excepção.']);
}
$policy = InvestmentPolicy::query()->create(['tenant_id' => $user->tenant_id, 'created_by' => $user->id, 'revision' => ($latest->revision ?? 0) + 1, 'mode' => $data['mode'], 'scope' => $data['scope'], 'currency' => $data['currency'], 'ceiling_minor' => BigDecimal::of((string) $data['ceiling'])->multipliedBy(100)->toScale(0)->toInt(), 'includes_tax' => $data['includes_tax'], 'valid_from' => $data['valid_from'], 'valid_until' => $data['valid_until'], 'reason' => $data['reason']]);
app(RequisitionWorkflow::class)->audit($user, 'investment.proposed', null, null, $policy->toArray());
return $policy;
});
}
public function review(User $user, InvestmentPolicy $policy, string $decision, string $reason): void
{
$this->admin($user);
abort_unless($policy->tenant_id === $user->tenant_id && $policy->created_by !== $user->id, 403);
if (! in_array($decision, ['approved', 'rejected']) || trim($reason) === '') {
throw ValidationException::withMessages(['investment' => 'Decisão e fundamento obrigatórios.']);
}
DB::transaction(function () use ($user, $policy, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->admin($user);
$policy = InvestmentPolicy::query()->lockForUpdate()->findOrFail($policy->id);
$existing = InvestmentPolicyReview::query()->where('investment_policy_id', $policy->id)->where('reviewed_by', $user->id)->first();
if ($existing) {
if ($existing->decision !== $decision || $existing->reason !== $reason) {
throw ValidationException::withMessages(['investment' => 'Decisão anterior imutável.']);
}
return;
}
if ($policy->status !== 'pending' || InvestmentPolicy::query()->max('revision') !== $policy->revision) {
throw ValidationException::withMessages(['investment' => 'Versão decidida ou substituída por proposta mais recente.']);
}
if ($decision === 'approved') {
$ids = InvestmentPolicyReview::query()->where('investment_policy_id', $policy->id)->where('decision', 'approved')->pluck('reviewed_by')->push($policy->created_by)->push($user->id)->unique();
$actors = User::query()->where('tenant_id', $user->tenant_id)->whereIn('id', $ids)->orderBy('id')->lockForUpdate()->get();
if ($actors->count() !== $ids->count() || $actors->contains(fn (User $actor) => $actor->purchasing_role !== PurchasingRole::Admin)) {
throw ValidationException::withMessages(['investment' => 'Proponente e validadores devem continuar elegíveis até à publicação.']);
}
}
InvestmentPolicyReview::query()->create(['tenant_id' => $user->tenant_id, 'investment_policy_id' => $policy->id, 'reviewed_by' => $user->id, 'decision' => $decision, 'reason' => $reason, 'created_at' => now()]);
if ($decision === 'rejected') {
$policy->update(['status' => 'rejected', 'decided_at' => now()]);
} elseif (InvestmentPolicyReview::query()->where('investment_policy_id', $policy->id)->where('decision', 'approved')->count() === 2) {
$policy->update(['status' => 'approved', 'decided_at' => now()]);
}
app(RequisitionWorkflow::class)->audit($user, 'investment.'.$decision, null, null, ['policy_id' => $policy->id, 'status' => $policy->status]);
});
}
public function current(): ?InvestmentPolicy
{
return InvestmentPolicy::query()->where('status', 'approved')->where('valid_from', '<=', today()->format('Y-m-d'))->latest('revision')->first();
}
public function requireCurrent(): InvestmentPolicy
{
$policy = $this->current();
if (! $policy || $policy->valid_until < today()->format('Y-m-d') || $policy->mode !== 'ceiling' || $policy->scope !== 'process_total' || $policy->currency !== 'MZN') {
throw ValidationException::withMessages(['purchase_type' => 'É necessária regra de investimento própria, com duas aprovações administrativas e vigência válida. Sem regra aplicável, adjudicação e emissão de equipamento bloqueadas.']);
}
return $policy;
}
/** @return array<string,mixed>|null */
public function check(Requisition $request, Quotation $quotation): ?array
{
if (! $request->items()->where('purchase_type', 'equipment')->exists()) {
return null;
}
$policy = $this->requireCurrent();
$amount = $policy->includes_tax ? $quotation->total_minor : $quotation->subtotal_minor;
if ($amount > $policy->ceiling_minor || $quotation->currency !== 'MZN') {
throw ValidationException::withMessages(['investment' => 'O total do processo excede o tecto de investimento da empresa ou usa moeda não suportada. Não há dispensa automática.']);
}
app(EquipmentWorkflow::class)->assertTechnical($request);
$entry = BudgetEntry::query()->where('requisition_id', $request->id)->where('kind', 'reserve')->first();
$budget = $entry ? Budget::query()->lockForUpdate()->find($entry->budget_id) : null;
if (! $budget || ! $budget->approved_by || $budget->kind !== 'investment' || $budget->cost_center_id !== $request->cost_center_id || (int) $budget->year !== now()->year) {
throw ValidationException::withMessages(['investment' => 'Exige reserva em dotação de investimento aprovada do centro e exercício. Não se atribui orçamento retroactivo.']);
}
$basis = app(EquipmentWorkflow::class)->basis($request);
$technical = TechnicalReview::query()->where('requisition_id', $request->id)->where('basis_hash', $basis)->where('decision', 'approved')->firstOrFail();
return [...$policy->only(['id', 'revision', 'mode', 'scope', 'currency', 'ceiling_minor', 'includes_tax', 'valid_from', 'valid_until']), 'reviewer_ids' => InvestmentPolicyReview::query()->where('investment_policy_id', $policy->id)->orderBy('reviewed_by')->pluck('reviewed_by')->all(), 'budget_id' => $budget->id, 'technical_review_id' => $technical->id, 'technical_basis_hash' => $basis];
}
}
+2
View File
@@ -75,6 +75,7 @@ class InvoiceWorkflow
return DB::transaction(function () use ($user, $order, $data) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Finance]);
$order = PurchaseOrder::query()->lockForUpdate()->findOrFail($order->id);
$request = Requisition::query()->findOrFail($order->requisition_id);
app(ConflictGuard::class)->assertProcess($request, $order->supplier_id, $user);
@@ -107,6 +108,7 @@ class InvoiceWorkflow
abort_unless($invoice->tenant_id === $user->tenant_id && $invoice->created_by !== $user->id, 403);
DB::transaction(function () use ($user, $invoice) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Finance]);
$invoice = Invoice::query()->lockForUpdate()->findOrFail($invoice->id);
if ($invoice->status === 'validated') {
return;
+77
View File
@@ -0,0 +1,77 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\ProposalOpening;
use App\Models\PurchaseAward;
use App\Models\PurchaseOrder;
use App\Models\QualificationAssessment;
use App\Models\QualificationSet;
use App\Models\Requisition;
use App\Models\Tenant;
use App\Models\User;
use Illuminate\Support\Facades\DB;
class ProcurementReviewReport
{
/** @return array<string,mixed> */
public function build(User $actor, int $requisitionId): array
{
abort_unless(auth()->id() === $actor->id && $actor->tenant_id !== null, 403);
if (DB::connection()->getDriverName() === 'pgsql' && DB::transactionLevel() !== 0) {
throw new \LogicException('O relatório PostgreSQL exige uma transacção própria de leitura.');
}
return DB::transaction(function () use ($actor, $requisitionId) {
if (DB::connection()->getDriverName() === 'pgsql') {
DB::statement('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY');
}
$actor = User::query()->where('tenant_id', $actor->tenant_id)->findOrFail($actor->id);
abort_unless(in_array($actor->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement, PurchasingRole::Finance, PurchasingRole::DepartmentHead]), 403);
$request = Requisition::query()->visibleTo($actor)->with(['department:id,name', 'requester:id,name'])->findOrFail($requisitionId);
$comparison = app(ProposalComparison::class)->inspect($request);
$rows = [];
foreach ($comparison['rows'] as $row) {
$rows[] = [
...array_intersect_key($row, array_flip(['id', 'reference', 'currency', 'subtotal_minor', 'tax_minor', 'total_minor', 'delivery_days', 'valid_until', 'weights', 'eligible', 'ineligibility_reasons', 'evaluation_count', 'score_minor'])),
'supplier' => $row['supplier']['name'] ?? 'Fornecedor indisponível',
'is_top' => $comparison['ready'] && in_array($row['id'], $comparison['top_ids'], true),
];
}
$openingWorkflow = app(ProposalOpeningWorkflow::class);
$basis = $openingWorkflow->basis($openingWorkflow->proposals($request));
$set = QualificationSet::query()->where('requisition_id', $request->id)->latest('revision')->first();
$qualification = null;
if ($set) {
$latestIds = QualificationAssessment::query()->where('qualification_set_id', $set->id)->selectRaw('MAX(id)')->groupBy('quotation_id', 'analyst_id');
$records = QualificationAssessment::query()->whereIn('id', $latestIds)->orderBy('quotation_id')->orderBy('analyst_id')->get();
$proposals = [];
foreach ($set->snapshot['proposals'] as $proposal) {
$analyses = [];
foreach ($records->where('quotation_id', $proposal['id']) as $record) {
$analyses[] = ['id' => $record->id, 'revision' => $record->revision, 'analyst' => $record->snapshot['analyst'], 'created_at' => $record->created_at, 'reason' => $record->reason, 'answers' => $record->answers];
}
$proposals[] = ['id' => $proposal['id'], 'reference' => $proposal['reference'], 'supplier' => $proposal['supplier']['name'] ?? 'Fornecedor indisponível', 'analyses' => $analyses];
}
$qualification = ['id' => $set->id, 'revision' => $set->revision, 'created_at' => $set->created_at, 'author' => $set->snapshot['author']['name'], 'reason' => $set->reason, 'criteria' => $set->criteria, 'is_current' => $set->basis_hash === $basis, 'proposals' => $proposals];
}
$opening = ProposalOpening::query()->where('requisition_id', $request->id)->latest('revision')->first();
$award = PurchaseAward::query()->where('requisition_id', $request->id)->first();
$order = PurchaseOrder::query()->visibleTo($actor)->where('requisition_id', $request->id)->first();
return [
'generated_at' => now()->toIso8601String(), 'generated_by' => $actor->name,
'company' => Tenant::query()->findOrFail($actor->tenant_id)->name,
'requisition' => [...$request->only(['id', 'number', 'status', 'justification']), 'department' => $request->department?->name, 'requester' => $request->requester?->name],
'comparison' => ['ready' => $comparison['ready'], 'top_count' => $comparison['ready'] ? count($comparison['top_ids']) : 0, 'rows' => $rows],
'qualification' => $qualification,
'admission' => app(FormalAdmission::class)->adoption($request)?->only(['id', 'revision', 'snapshot', 'reason']),
'recommendation' => app(FormalRecommendation::class)->adoption($request)?->only(['id', 'revision', 'snapshot', 'reason']),
'opening' => $opening ? [...$opening->only(['id', 'revision', 'reference']), 'source_changed' => $opening->basis_hash !== $basis] : null,
'award' => $award?->only(['id', 'status', 'total_minor']),
'order' => $order?->only(['id', 'number', 'currency', 'total_minor']),
];
});
}
}
+4
View File
@@ -21,9 +21,13 @@ class ProposalComparison
->with(['supplier', 'items' => fn ($q) => $q->orderBy('id'), 'evaluations' => fn ($q) => $q->orderBy('id')])->orderBy('id')->get();
$guard = app(ConflictGuard::class);
$referenceWeights = $quotes->first()?->weights;
$adopted = app(FormalAdmission::class)->adoption($requisition) !== null;
$rows = [];
foreach ($quotes as $quote) {
$reasons = [];
if ($adopted && ! app(FormalAdmission::class)->admitted($requisition, $quote->id)) {
$reasons[] = 'O regime adoptado exige admissão confirmada na base actual.';
}
if (! $quote->supplier?->eligible() || $quote->valid_until < today()) {
$reasons[] = 'Fornecedor não elegível ou proposta expirada.';
}
+77
View File
@@ -0,0 +1,77 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\ProposalOpening;
use App\Models\PurchaseAward;
use App\Models\Quotation;
use App\Models\QuotationItem;
use App\Models\Requisition;
use App\Models\Supplier;
use App\Models\Tenant;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class ProposalOpeningWorkflow
{
/** @return list<array<string,mixed>> */
public function proposals(Requisition $requisition): array
{
return array_values(Quotation::query()->where('requisition_id', $requisition->id)->with(['supplier', 'items' => fn ($query) => $query->orderBy('id')])->orderBy('id')->get()->map(fn (Quotation $quote) => [
...$quote->only(['id', 'reference', 'currency', 'subtotal_minor', 'tax_minor', 'total_minor', 'delivery_days', 'valid_until', 'payment_terms']),
'supplier' => $quote->supplier?->only(['id', 'name', 'nuit']),
'items' => $quote->items->map(fn ($item) => $item->only(['requisition_item_id', 'description', 'quantity', 'unit_price_minor', 'tax_rate', 'subtotal_minor', 'tax_minor', 'total_minor']))->all(),
])->all());
}
/** @param list<array<string,mixed>> $proposals */
public function basis(array $proposals): string
{
return hash('sha256', json_encode($proposals, JSON_THROW_ON_ERROR));
}
/** @param array<string,mixed> $data */
public function record(User $actor, Requisition $requisition, array $data): ProposalOpening
{
return DB::transaction(function () use ($actor, $requisition, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
$requisition = Requisition::query()->lockForUpdate()->findOrFail($requisition->id);
app(ConflictGuard::class)->assertParticipation($actor, $requisition);
if ($requisition->status !== 'approved' || PurchaseAward::query()->where('requisition_id', $requisition->id)->exists()) {
throw ValidationException::withMessages(['opening' => 'Registe a abertura num pedido aprovado, antes da adjudicação. O histórico posterior não é reescrito.']);
}
$latest = ProposalOpening::query()->where('requisition_id', $requisition->id)->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0)) {
throw ValidationException::withMessages(['previous_id' => 'A acta mudou. Actualize a página antes de registar outra versão.']);
}
$quotes = Quotation::query()->where('requisition_id', $requisition->id)->orderBy('id')->lockForUpdate()->get(['id', 'supplier_id']);
Supplier::query()->whereIn('id', $quotes->pluck('supplier_id'))->orderBy('id')->lockForUpdate()->get();
QuotationItem::query()->whereIn('quotation_id', $quotes->pluck('id'))->orderBy('id')->lockForUpdate()->get();
$proposals = $this->proposals($requisition);
if ($data['basis_hash'] !== $this->basis($proposals)) {
throw ValidationException::withMessages(['basis_hash' => 'As propostas mudaram desde a consulta. Confira os dados actualizados antes de registar.']);
}
$selected = array_values(array_filter($proposals, fn ($proposal) => in_array($proposal['id'], $data['quotation_ids'], true)));
if ($selected === [] || count($selected) !== count($data['quotation_ids'])) {
throw ValidationException::withMessages(['quotation_ids' => 'Seleccione apenas propostas deste processo, sem repetições.']);
}
foreach ($selected as $proposal) {
app(ConflictGuard::class)->assertProcess($requisition, $proposal['supplier']['id'], $actor);
}
$opening = ProposalOpening::query()->create([
'tenant_id' => $actor->tenant_id, 'requisition_id' => $requisition->id, 'created_by' => $actor->id, 'revision' => ($latest->revision ?? 0) + 1,
'opened_at' => $data['opened_at'], 'timezone' => $data['timezone'], 'submission_deadline' => $data['submission_deadline'] ?? null,
'reference' => $data['reference'], 'location' => $data['location'], 'reason' => $data['reason'], 'notes' => $data['notes'] ?? null,
'participants' => $data['participants'], 'annexes' => $data['annexes'] ?? [], 'basis_hash' => $this->basis($selected),
'snapshot' => ['company' => Tenant::query()->findOrFail($actor->tenant_id)->only(['id', 'name']), 'requisition' => $requisition->only(['id', 'number', 'justification']), 'author' => $actor->only(['id', 'name']), 'proposals' => $selected],
'created_at' => now(),
]);
app(RequisitionWorkflow::class)->audit($actor, 'opening.recorded', $requisition, null, ['opening_id' => $opening->id, 'revision' => $opening->revision, 'previous_id' => $latest?->id, 'quotation_ids' => $data['quotation_ids']]);
return $opening;
});
}
}
@@ -0,0 +1,93 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\PurchaseControlPolicy;
use App\Models\PurchaseControlReview;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class PurchaseControlPolicyWorkflow
{
private function admin(User $user): void
{
abort_unless(auth()->id() === $user->id && $user->tenant_id !== null && $user->purchasing_role === PurchasingRole::Admin, 403);
}
/** @param array<string,mixed> $data */
public function propose(User $user, array $data): PurchaseControlPolicy
{
$this->admin($user);
return DB::transaction(function () use ($user, $data) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->admin($user);
$latest = PurchaseControlPolicy::query()->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0) || $data['mode'] !== 'unissued_award') {
throw ValidationException::withMessages(['cancellation' => 'Versão desactualizada ou regra não suportada. Não se presume um circuito de excepção.']);
}
$policy = PurchaseControlPolicy::query()->create(['tenant_id' => $user->tenant_id, 'created_by' => $user->id, 'revision' => ($latest->revision ?? 0) + 1, 'mode' => $data['mode'], 'enabled' => $data['enabled'], 'valid_from' => $data['valid_from'], 'valid_until' => $data['valid_until'], 'reason' => $data['reason']]);
app(RequisitionWorkflow::class)->audit($user, 'purchase_control.proposed', null, null, $policy->toArray());
return $policy;
});
}
public function review(User $user, PurchaseControlPolicy $policy, string $decision, string $reason): void
{
$this->admin($user);
abort_unless($policy->tenant_id === $user->tenant_id && $policy->created_by !== $user->id, 403);
if (! in_array($decision, ['approved', 'rejected']) || trim($reason) === '') {
throw ValidationException::withMessages(['cancellation' => 'Decisão e fundamento obrigatórios.']);
}
DB::transaction(function () use ($user, $policy, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($user);
$user = User::query()->where('tenant_id', $user->tenant_id)->lockForUpdate()->findOrFail($user->id);
$this->admin($user);
$policy = PurchaseControlPolicy::query()->lockForUpdate()->findOrFail($policy->id);
$existing = PurchaseControlReview::query()->where('purchase_control_policy_id', $policy->id)->where('reviewed_by', $user->id)->first();
if ($existing) {
if ($existing->decision !== $decision || $existing->reason !== $reason) {
throw ValidationException::withMessages(['cancellation' => 'Decisão anterior imutável.']);
}
return;
}
if ($policy->status !== 'pending' || PurchaseControlPolicy::query()->max('revision') !== $policy->revision) {
throw ValidationException::withMessages(['cancellation' => 'Versão decidida ou substituída por proposta mais recente.']);
}
if ($decision === 'approved') {
$ids = PurchaseControlReview::query()->where('purchase_control_policy_id', $policy->id)->where('decision', 'approved')->pluck('reviewed_by')->push($policy->created_by)->push($user->id)->unique();
$actors = User::query()->where('tenant_id', $user->tenant_id)->whereIn('id', $ids)->orderBy('id')->lockForUpdate()->get();
if ($actors->count() !== $ids->count() || $actors->contains(fn (User $actor) => $actor->purchasing_role !== PurchasingRole::Admin)) {
throw ValidationException::withMessages(['cancellation' => 'Proponente e validadores devem continuar elegíveis até à publicação.']);
}
}
PurchaseControlReview::query()->create(['tenant_id' => $user->tenant_id, 'purchase_control_policy_id' => $policy->id, 'reviewed_by' => $user->id, 'decision' => $decision, 'reason' => $reason, 'created_at' => now()]);
if ($decision === 'rejected') {
$policy->update(['status' => 'rejected', 'decided_at' => now()]);
} elseif (PurchaseControlReview::query()->where('purchase_control_policy_id', $policy->id)->where('decision', 'approved')->count() === 2) {
$policy->update(['status' => 'approved', 'decided_at' => now()]);
}
app(RequisitionWorkflow::class)->audit($user, 'purchase_control.'.$decision, null, null, ['policy_id' => $policy->id, 'status' => $policy->status]);
});
}
public function current(): ?PurchaseControlPolicy
{
return PurchaseControlPolicy::query()->where('status', 'approved')->where('valid_from', '<=', today()->format('Y-m-d'))->latest('revision')->first();
}
public function requireCurrent(): PurchaseControlPolicy
{
$policy = $this->current();
if (! $policy || $policy->valid_until < today()->format('Y-m-d') || $policy->mode !== 'unissued_award' || ! $policy->enabled) {
throw ValidationException::withMessages(['cancellation' => 'A empresa deve activar o cancelamento de adjudicações sem ordem emitida numa política vigente, com duas aprovações administrativas independentes.']);
}
return $policy;
}
}
+119
View File
@@ -0,0 +1,119 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\Department;
use App\Models\PurchasePlanItem;
use App\Models\PurchasePlanMilestone;
use App\Models\Requisition;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class PurchasePlanningWorkflow
{
private function manager(User $actor): bool
{
return in_array($actor->purchasing_role, [PurchasingRole::Admin, PurchasingRole::Procurement]);
}
private function responsible(User $actor, int $id): void
{
if (! User::query()->where('tenant_id', $actor->tenant_id)->whereKey($id)->exists()) {
throw ValidationException::withMessages(['responsible_id' => 'O responsável deve pertencer à empresa.']);
}
}
private function version(int $expected, int $current): void
{
if ($expected !== $current) {
throw ValidationException::withMessages(['version' => 'O registo mudou. Actualize a página antes de voltar a guardar.']);
}
}
/** @param array<string,mixed> $data */
public function create(User $actor, array $data): PurchasePlanItem
{
return DB::transaction(function () use ($actor, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Admin, PurchasingRole::Procurement]);
Department::query()->findOrFail($data['department_id']);
$this->responsible($actor, $data['responsible_id']);
$requisition = null;
if ($data['requisition_id'] ?? null) {
$requisition = Requisition::query()->visibleTo($actor)->whereKey($data['requisition_id'])->firstOrFail();
if ($requisition->department_id !== $data['department_id'] || PurchasePlanItem::query()->where('requisition_id', $requisition->id)->exists()) {
throw ValidationException::withMessages(['requisition_id' => 'A requisição deve pertencer ao departamento e ainda não ter planeamento associado.']);
}
}
$item = PurchasePlanItem::query()->create(['tenant_id' => $actor->tenant_id, 'created_by' => $actor->id, 'department_id' => $data['department_id'], 'requisition_id' => $requisition?->id, 'responsible_id' => $data['responsible_id'], 'title' => $data['title'], 'nature' => $data['nature']]);
app(RequisitionWorkflow::class)->audit($actor, 'planning.created', $requisition, null, $item->toArray());
return $item;
});
}
public function assign(User $actor, PurchasePlanItem $item, int $responsibleId, int $version, string $reason): void
{
DB::transaction(function () use ($actor, $item, $responsibleId, $version, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Admin, PurchasingRole::Procurement]);
$item = PurchasePlanItem::query()->lockForUpdate()->findOrFail($item->id);
$this->version($version, $item->version);
$this->responsible($actor, $responsibleId);
$before = $item->toArray();
$item->update(['responsible_id' => $responsibleId, 'version' => $item->version + 1]);
app(RequisitionWorkflow::class)->audit($actor, 'planning.assigned', null, $before, ['item' => $item->toArray(), 'reason' => $reason]);
});
}
public function link(User $actor, PurchasePlanItem $item, int $requisitionId, int $version, string $reason): void
{
DB::transaction(function () use ($actor, $item, $requisitionId, $version, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Admin, PurchasingRole::Procurement]);
$item = PurchasePlanItem::query()->lockForUpdate()->findOrFail($item->id);
$this->version($version, $item->version);
$requisition = Requisition::query()->visibleTo($actor)->findOrFail($requisitionId);
if ($item->requisition_id !== null || $requisition->department_id !== $item->department_id || PurchasePlanItem::query()->where('requisition_id', $requisitionId)->exists()) {
throw ValidationException::withMessages(['requisition_id' => 'A ligação deve ser única, do mesmo departamento, e não pode substituir uma ligação anterior.']);
}
$before = $item->toArray();
$item->update(['requisition_id' => $requisitionId, 'version' => $item->version + 1]);
app(RequisitionWorkflow::class)->audit($actor, 'planning.linked', $requisition, $before, ['item' => $item->toArray(), 'reason' => $reason]);
});
}
public function milestone(User $actor, PurchasePlanItem $item, string $label, string $plannedOn): void
{
DB::transaction(function () use ($actor, $item, $label, $plannedOn) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Admin, PurchasingRole::Procurement]);
$item = PurchasePlanItem::query()->lockForUpdate()->findOrFail($item->id);
if (PurchasePlanMilestone::query()->where('purchase_plan_item_id', $item->id)->where('label', trim($label))->exists()) {
throw ValidationException::withMessages(['label' => 'Já existe um marco com este nome neste item.']);
}
$milestone = PurchasePlanMilestone::query()->create(['tenant_id' => $actor->tenant_id, 'purchase_plan_item_id' => $item->id, 'created_by' => $actor->id, 'label' => trim($label), 'planned_on' => $plannedOn]);
app(RequisitionWorkflow::class)->audit($actor, 'planning.milestone_created', null, null, $milestone->toArray());
});
}
/** @param array{version:int,planned_on?:string,actual_on?:string|null,reason:string} $data */
public function update(User $actor, PurchasePlanMilestone $milestone, array $data): void
{
DB::transaction(function () use ($actor, $milestone, $data) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor);
$item = PurchasePlanItem::query()->visibleTo($actor)->lockForUpdate()->findOrFail($milestone->purchase_plan_item_id);
$milestone = PurchasePlanMilestone::query()->lockForUpdate()->findOrFail($milestone->id);
abort_unless($this->manager($actor) || $item->responsible_id === $actor->id, 403);
abort_if(! $this->manager($actor) && array_key_exists('planned_on', $data), 403);
$this->version($data['version'], $milestone->version);
$before = $milestone->toArray();
$changes = array_intersect_key($data, array_flip(['planned_on', 'actual_on']));
$milestone->update([...$changes, 'version' => $milestone->version + 1]);
app(RequisitionWorkflow::class)->audit($actor, 'planning.milestone_updated', null, $before, ['milestone' => $milestone->toArray(), 'reason' => $data['reason']]);
});
}
}
+142
View File
@@ -0,0 +1,142 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\AwardCancellation;
use App\Models\BudgetEntry;
use App\Models\PurchaseAward;
use App\Models\PurchaseOrder;
use App\Models\PurchaseRevision;
use App\Models\Requisition;
use App\Models\User;
use Brick\Math\BigDecimal;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class PurchaseRevisionWorkflow
{
private function invalid(string $message): never
{
throw ValidationException::withMessages(['cancellation' => $message]);
}
private function noOrder(PurchaseAward $award): void
{
if (PurchaseOrder::query()->where(fn ($query) => $query->where('purchase_award_id', $award->id)->orWhere('requisition_id', $award->requisition_id))->exists()) {
$this->invalid('Existe ordem emitida. Este circuito não cancela ordens, recepções, facturas ou pagamentos.');
}
}
private function basis(PurchaseAward $award): string
{
return hash('sha256', json_encode($award->only(['id', 'requisition_id', 'quotation_id', 'status', 'subtotal_minor', 'tax_minor', 'total_minor', 'comparison_hash', 'approval_snapshot', 'investment_snapshot', 'delivery_date', 'delivery_location']), JSON_THROW_ON_ERROR));
}
public function request(User $actor, PurchaseAward $award, string $reason): AwardCancellation
{
abort_unless($actor->tenant_id === $award->tenant_id, 403);
return DB::transaction(function () use ($actor, $award, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
$request = Requisition::query()->lockForUpdate()->findOrFail($award->requisition_id);
$award = PurchaseAward::query()->lockForUpdate()->findOrFail($award->id);
abort_if($request->requester_id === $actor->id, 403);
app(ConflictGuard::class)->assertParticipation($actor, $request);
$this->noOrder($award);
$existing = AwardCancellation::query()->where('purchase_award_id', $award->id)->first();
if ($existing) {
if ($existing->created_by !== $actor->id || $existing->reason !== trim($reason)) {
$this->invalid('Já existe pedido ou decisão para esta adjudicação. O histórico não pode ser substituído.');
}
return $existing;
}
$policy = app(PurchaseControlPolicyWorkflow::class)->requireCurrent();
if (! in_array($award->status, ['pending', 'approved', 'rejected']) || trim($reason) === '') {
$this->invalid('Estado ou fundamento inválido para cancelamento.');
}
$cancellation = AwardCancellation::query()->create(['tenant_id' => $actor->tenant_id, 'purchase_award_id' => $award->id, 'purchase_control_policy_id' => $policy->id, 'created_by' => $actor->id, 'reason' => trim($reason), 'basis_hash' => $this->basis($award), 'snapshot' => ['policy' => $policy->only(['id', 'revision', 'mode', 'enabled', 'valid_from', 'valid_until']), 'award' => $award->toArray(), 'requisition_id' => $request->id, 'development_only' => true]]);
app(RequisitionWorkflow::class)->audit($actor, 'cancellation.requested', $request, null, ['cancellation_id' => $cancellation->id, 'award_id' => $award->id, 'policy_id' => $policy->id]);
return $cancellation;
});
}
public function review(User $actor, AwardCancellation $cancellation, string $decision, string $reason): void
{
abort_unless($actor->tenant_id === $cancellation->tenant_id, 403);
if (! in_array($decision, ['approved', 'rejected']) || trim($reason) === '') {
$this->invalid('Decisão e fundamento obrigatórios.');
}
DB::transaction(function () use ($actor, $cancellation, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Finance]);
$source = PurchaseAward::query()->findOrFail($cancellation->purchase_award_id);
$request = Requisition::query()->lockForUpdate()->findOrFail($source->requisition_id);
$award = PurchaseAward::query()->lockForUpdate()->findOrFail($source->id);
$cancellation = AwardCancellation::query()->lockForUpdate()->findOrFail($cancellation->id);
abort_if(in_array($actor->id, [$cancellation->created_by, $request->requester_id, $award->created_by], true), 403);
app(ConflictGuard::class)->assertParticipation($actor, $request);
if ($cancellation->status !== 'pending') {
if ($cancellation->status !== $decision || $cancellation->review_reason !== trim($reason)) {
$this->invalid('Decisão de cancelamento imutável.');
}
return;
}
$this->noOrder($award);
if ($cancellation->basis_hash !== $this->basis($award)) {
$this->invalid('A base da adjudicação mudou. Não é permitido cancelar com uma base desactualizada.');
}
if ($decision === 'approved') {
$policy = app(PurchaseControlPolicyWorkflow::class)->requireCurrent();
if ($policy->id !== $cancellation->purchase_control_policy_id) {
$this->invalid('A política da empresa mudou. A aprovação deste pedido está bloqueada; pode rejeitá-lo para retomar o processo.');
}
if ((int) BudgetEntry::query()->where('requisition_id', $request->id)->sum('committed_minor') !== 0) {
$this->invalid('Existe compromisso financeiro. Este circuito só liberta reservas não comprometidas.');
}
if (BudgetEntry::query()->where('requisition_id', $request->id)->exists()) {
app(BudgetWorkflow::class)->record($actor, $request, 'release');
}
$award->update(['status' => 'cancelled']);
$request->update(['status' => 'cancelled']);
}
$cancellation->update(['status' => $decision, 'reviewed_by' => $actor->id, 'review_reason' => trim($reason), 'reviewed_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'cancellation.'.$decision, $request, null, ['cancellation_id' => $cancellation->id, 'award_id' => $award->id, 'reservation_released' => $decision === 'approved']);
});
}
public function revise(User $actor, AwardCancellation $cancellation, string $neededBy, string $justification): Requisition
{
abort_unless($actor->tenant_id === $cancellation->tenant_id, 403);
return DB::transaction(function () use ($actor, $cancellation, $neededBy, $justification) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor);
$cancellation = AwardCancellation::query()->lockForUpdate()->findOrFail($cancellation->id);
$award = PurchaseAward::query()->findOrFail($cancellation->purchase_award_id);
$source = Requisition::query()->lockForUpdate()->findOrFail($award->requisition_id);
$this->noOrder($award);
abort_unless($source->requester_id === $actor->id && $source->department_id === $actor->department_id, 403);
if ($cancellation->status !== 'approved' || $source->status !== 'cancelled' || $award->status !== 'cancelled') {
$this->invalid('Só o solicitante pode preparar revisão após cancelamento aprovado.');
}
$existing = PurchaseRevision::query()->where('award_cancellation_id', $cancellation->id)->first();
if ($existing) {
return Requisition::query()->findOrFail($existing->requisition_id);
}
$items = [];
foreach ($source->items()->orderBy('id')->get() as $line) {
$items[] = [...$line->only(['description', 'category', 'purchase_type', 'quantity', 'unit', 'tax_rate', 'equipment_id', 'spare_part_id', 'production_area']), 'unit_price' => (string) BigDecimal::of($line->unit_price_minor)->dividedBy(100, 2), 'downtime_started_at' => $line->downtime_started_at ? substr(str_replace(' ', 'T', $line->downtime_started_at), 0, 16) : null];
}
$revised = app(RequisitionWorkflow::class)->save($actor, ['cost_center_id' => $source->cost_center_id, 'priority' => $source->priority, 'needed_by' => $neededBy, 'justification' => $justification, 'items' => $items]);
PurchaseRevision::query()->create(['tenant_id' => $actor->tenant_id, 'award_cancellation_id' => $cancellation->id, 'source_requisition_id' => $source->id, 'requisition_id' => $revised->id, 'created_by' => $actor->id, 'created_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'requisition.revision_created', $revised, null, ['source_requisition_id' => $source->id, 'cancellation_id' => $cancellation->id]);
return $revised;
});
}
}
+40 -8
View File
@@ -3,6 +3,7 @@
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\AwardCancellation;
use App\Models\Equipment;
use App\Models\ProposalEvaluation;
use App\Models\PurchaseAward;
@@ -26,6 +27,7 @@ class PurchaseWorkflow
{
return DB::transaction(function () use ($user, $requisition, $data) {
$this->guard->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Procurement]);
$requisition = Requisition::query()->lockForUpdate()->findOrFail($requisition->id);
abort_unless($user->purchasing_role === PurchasingRole::Procurement && $user->id !== $requisition->requester_id, 403);
if (PurchaseAward::query()->where('requisition_id', $requisition->id)->exists()) {
@@ -36,6 +38,9 @@ class PurchaseWorkflow
$this->sourceApproved($requisition, $rules);
$quote = Quotation::query()->where('requisition_id', $requisition->id)->lockForUpdate()->findOrFail($data['quotation_id']);
$result = $this->checkComparison($user, $requisition, $quote);
$admission = app(FormalAdmission::class)->selection($requisition, $quote->id);
$recommendation = app(FormalRecommendation::class)->selection($requisition, $quote->id);
$investment = app(InvestmentWorkflow::class)->check($requisition, $quote);
app(BudgetWorkflow::class)->record($user, $requisition, 'award', $quote->total_minor, $quote->subtotal_minor);
$award = PurchaseAward::query()->create([
'tenant_id' => $user->tenant_id, 'requisition_id' => $requisition->id, 'quotation_id' => $quote->id,
@@ -43,8 +48,11 @@ class PurchaseWorkflow
'delivery_location' => $data['delivery_location'], 'status' => 'pending',
'subtotal_minor' => $quote->subtotal_minor, 'tax_minor' => $quote->tax_minor, 'total_minor' => $quote->total_minor,
'approval_snapshot' => $rules, 'decision_matrix' => $result['rows'], 'comparison_hash' => $result['fingerprint'],
'investment_snapshot' => $investment,
'admission_snapshot' => $admission,
'recommendation_snapshot' => $recommendation,
]);
$roles = $this->roles($rules, $rules['approval_includes_tax'] ? $quote->total_minor : $quote->subtotal_minor);
$roles = $this->roles($rules, $rules['approval_includes_tax'] ? $quote->total_minor : $quote->subtotal_minor, $requisition->items()->where('purchase_type', 'equipment')->exists());
foreach ($roles as $position => $role) {
$award->approvals()->create(['tenant_id' => $user->tenant_id, 'position' => $position + 1, 'role' => $role]);
}
@@ -71,8 +79,10 @@ class PurchaseWorkflow
{
DB::transaction(function () use ($user, $award, $decision, $comment) {
$this->guard->lockCompany($user);
$user = app(CurrentActor::class)->lock($user);
$requisition = Requisition::query()->lockForUpdate()->findOrFail($award->requisition_id);
$award = PurchaseAward::query()->lockForUpdate()->findOrFail($award->id);
$this->assertNoPendingCancellation($award);
abort_unless($this->canDecide($user, $award, $requisition), 403);
if ($decision === 'approved') {
$this->currentBasis($user, $award, $requisition);
@@ -92,6 +102,7 @@ class PurchaseWorkflow
{
return DB::transaction(function () use ($user, $award) {
$this->guard->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Procurement]);
abort_unless($user->purchasing_role === PurchasingRole::Procurement, 403);
$requisition = Requisition::query()->lockForUpdate()->findOrFail($award->requisition_id);
$award = PurchaseAward::query()->lockForUpdate()->findOrFail($award->id);
@@ -100,6 +111,7 @@ class PurchaseWorkflow
if ($existing) {
return $existing;
}
$this->assertNoPendingCancellation($award);
if ($award->status !== 'approved') {
throw ValidationException::withMessages(['approvals' => 'Conclua as aprovações do valor adjudicado antes de emitir a ordem.']);
}
@@ -130,6 +142,8 @@ class PurchaseWorkflow
$snapshot = [
'development_only' => true, 'budget_checked' => false,
'budget_control' => app(BudgetWorkflow::class)->record($user, $requisition, 'commit', $quote->total_minor, $quote->subtotal_minor),
'investment_rules' => $award->investment_snapshot,
'equipment_requests' => $requisition->items()->where('purchase_type', 'equipment')->get()->map(fn ($line) => $line->only(['id', 'description', 'production_area']))->all(),
'company' => Tenant::query()->findOrFail($user->tenant_id)->only(['id', 'name']),
'requisition' => $requisition->only(['id', 'number', 'justification']),
'department' => $requisition->department->only(['id', 'name']),
@@ -139,6 +153,8 @@ class PurchaseWorkflow
'quotation' => [...$quote->only(['id', 'reference', 'currency', 'payment_terms', 'delivery_days']), 'valid_until' => $validUntil],
'award' => [...$award->only(['id', 'justification', 'delivery_location']), 'delivery_date' => $deliveryDate],
'issuer' => $user->only(['id', 'name']), 'approval_rules' => $award->approval_snapshot,
'admission' => $award->admission_snapshot,
'recommendation' => $award->recommendation_snapshot,
'estimate_approvals' => $requisition->steps()->get()->toArray(),
'final_approvals' => $award->approvals()->get()->toArray(),
'decision_matrix' => $this->comparison->inspect($requisition)['rows'], 'items' => $lines,
@@ -166,7 +182,16 @@ class PurchaseWorkflow
$this->supportedItems($requisition);
$this->sourceApproved($requisition, $rules);
$quote = Quotation::query()->where('requisition_id', $requisition->id)->lockForUpdate()->findOrFail($award->quotation_id);
if (app(InvestmentWorkflow::class)->check($requisition, $quote) !== $award->investment_snapshot) {
throw ValidationException::withMessages(['investment' => 'A regra de investimento ou a base técnica/orçamental mudou. As aprovações anteriores não autorizam uma emissão com outra base.']);
}
$result = $this->checkComparison($user, $requisition, $quote);
if (app(FormalAdmission::class)->selection($requisition, $quote->id) !== $award->admission_snapshot) {
throw ValidationException::withMessages(['admission' => 'A base de admissão já não corresponde à adjudicação. Não se emite com outra base.']);
}
if (app(FormalRecommendation::class)->selection($requisition, $quote->id) !== $award->recommendation_snapshot) {
throw ValidationException::withMessages(['recommendation' => 'A recomendação já não corresponde à base da adjudicação. Prepare a revisão autorizada antes de emitir.']);
}
if ($result['fingerprint'] !== $award->comparison_hash || $award->approval_snapshot !== $rules ||
$quote->subtotal_minor !== $award->subtotal_minor || $quote->tax_minor !== $award->tax_minor || $quote->total_minor !== $award->total_minor) {
throw ValidationException::withMessages(['comparison' => 'A base da adjudicação mudou. As aprovações anteriores não autorizam a emissão com dados diferentes.']);
@@ -214,13 +239,13 @@ class PurchaseWorkflow
/** @param array{first_limit_minor: int, second_limit_minor: int, approval_includes_tax: bool, rules_provisional: bool} $rules
* @return list<string>
*/
private function roles(array $rules, int $amount): array
private function roles(array $rules, int $amount, bool $equipment = false): array
{
$roles = ['department_head'];
if ($amount > $rules['first_limit_minor']) {
$roles[] = 'procurement';
}
if ($amount > $rules['second_limit_minor']) {
if ($amount > $rules['second_limit_minor'] || $equipment) {
$roles[] = 'finance';
}
@@ -230,7 +255,7 @@ class PurchaseWorkflow
/** @param array{first_limit_minor: int, second_limit_minor: int, approval_includes_tax: bool, rules_provisional: bool} $rules */
private function sourceApproved(Requisition $requisition, array $rules): void
{
$roles = $this->roles($rules, $rules['approval_includes_tax'] ? $requisition->total_minor : $requisition->subtotal_minor);
$roles = $this->roles($rules, $rules['approval_includes_tax'] ? $requisition->total_minor : $requisition->subtotal_minor, $requisition->items()->where('purchase_type', 'equipment')->exists());
$steps = $requisition->steps()->get();
$seen = [$requisition->requester_id];
if ($requisition->status !== 'approved' || $steps->count() !== count($roles)) {
@@ -248,14 +273,14 @@ class PurchaseWorkflow
private function validateFinalApprovals(PurchaseAward $award, Requisition $requisition): void
{
$rules = $this->rules($requisition);
$roles = $this->roles($rules, $rules['approval_includes_tax'] ? $award->total_minor : $award->subtotal_minor);
$roles = $this->roles($rules, $rules['approval_includes_tax'] ? $award->total_minor : $award->subtotal_minor, $requisition->items()->where('purchase_type', 'equipment')->exists());
$steps = $award->approvals()->get();
$seen = [$requisition->requester_id, $award->created_by];
if ($steps->count() !== count($roles)) {
throw ValidationException::withMessages(['approvals' => 'O ciclo de aprovação do valor final está incompleto.']);
}
foreach ($steps as $index => $step) {
$user = User::query()->where('tenant_id', $requisition->tenant_id)->find($step->approver_id);
$user = User::query()->where('tenant_id', $requisition->tenant_id)->lockForUpdate()->find($step->approver_id);
if (! $user || $step->decision !== 'approved' || $step->decided_at === null || $step->role !== $roles[$index] || $user->purchasing_role->value !== $step->role ||
($step->role === 'department_head' && $user->department_id !== $requisition->department_id) || in_array($user->id, $seen, true)) {
throw ValidationException::withMessages(['approvals' => 'As aprovações do valor final devem continuar elegíveis e ser de pessoas distintas.']);
@@ -268,13 +293,20 @@ class PurchaseWorkflow
private function supportedItems(Requisition $requisition): void
{
if ($requisition->items()->where('purchase_type', 'equipment')->exists()) {
throw ValidationException::withMessages(['purchase_type' => 'O limite próprio de investimento e a sua regra de aplicação ainda não foram definidos pela empresa. A validação técnica e Finanças não dispensam essa decisão; adjudicação e emissão de equipamento bloqueadas.']);
app(InvestmentWorkflow::class)->requireCurrent();
}
foreach ($requisition->items()->get() as $line) {
if (! in_array($line->purchase_type, ['consumable', 'service', 'other', 'spare_part']) || ($line->purchase_type === 'spare_part' && (! $line->equipment_id || ! $line->spare_part_id))) {
if (! in_array($line->purchase_type, ['consumable', 'service', 'other', 'spare_part', 'equipment']) || ($line->purchase_type === 'spare_part' && (! $line->equipment_id || ! $line->spare_part_id))) {
throw ValidationException::withMessages(['purchase_type' => 'Tipo não suportado ou peça sem equipamento/artigo associado. Complete o cadastro antes da compra.']);
}
app(EquipmentWorkflow::class)->line($line->toArray(), $requisition->department_id, $requisition->priority);
}
}
private function assertNoPendingCancellation(PurchaseAward $award): void
{
if (AwardCancellation::query()->where('purchase_award_id', $award->id)->where('status', 'pending')->exists()) {
throw ValidationException::withMessages(['cancellation' => 'Existe pedido de cancelamento pendente. Aguarde a decisão antes de aprovar ou emitir.']);
}
}
}
+4 -2
View File
@@ -2,6 +2,7 @@
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\GoodsReceipt;
use App\Models\GoodsReceiptItem;
use App\Models\PurchaseOrder;
@@ -66,8 +67,9 @@ class ReceiptWorkflow
{
return DB::transaction(function () use ($user, $order, $data) {
$this->conflicts->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Warehouse]);
$order = PurchaseOrder::query()->lockForUpdate()->findOrFail($order->id);
Gate::authorize('create', [GoodsReceipt::class, $order]);
Gate::forUser($user)->authorize('create', [GoodsReceipt::class, $order]);
$deliveryNote = Str::squish(Str::upper($data['delivery_note']));
if ($deliveryNote === '') {
throw ValidationException::withMessages(['delivery_note' => 'Indique a guia de remessa do fornecedor.']);
@@ -134,7 +136,7 @@ class ReceiptWorkflow
throw ValidationException::withMessages(['items' => 'Descreva as reservas, danos ou divergências de qualidade.']);
}
$stockItem = ! empty($input['stock_item_id']) ? StockItem::query()->lockForUpdate()->findOrFail($input['stock_item_id']) : null;
$physical = in_array($source->purchase_type, ['consumable', 'other', 'spare_part']);
$physical = in_array($source->purchase_type, ['consumable', 'other', 'spare_part', 'equipment']);
if ($source->purchase_type === 'spare_part') {
if (! $source->spare_part_id || ! $source->equipment_id) {
throw ValidationException::withMessages(['items' => 'Peça sem associação autorizada na ordem. A recepção está bloqueada.']);
+10
View File
@@ -3,6 +3,7 @@
namespace App\Services;
use App\Models\AuditLog;
use App\Models\CostCenter;
use App\Models\Requisition;
use App\Models\Tenant;
use App\Models\User;
@@ -18,6 +19,10 @@ class RequisitionWorkflow
{
return DB::transaction(function () use ($user, $data, $existing) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user);
if (! $user->department_id || ! CostCenter::query()->whereKey($data['cost_center_id'])->where('department_id', $user->department_id)->exists()) {
throw ValidationException::withMessages(['cost_center_id' => 'O departamento ou centro de custo mudou. Actualize o pedido antes de guardar.']);
}
$requisition = $existing ? Requisition::query()->lockForUpdate()->findOrFail($existing->id) : new Requisition;
if ($existing) {
abort_unless($requisition->requester_id === $user->id && $requisition->status === 'draft', 403);
@@ -70,8 +75,12 @@ class RequisitionWorkflow
{
DB::transaction(function () use ($user, $requisition) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user);
$requisition = Requisition::query()->lockForUpdate()->findOrFail($requisition->id);
abort_unless($requisition->requester_id === $user->id && $requisition->status === 'draft', 403);
if ($user->department_id !== $requisition->department_id) {
throw ValidationException::withMessages(['submission' => 'O departamento do solicitante mudou. Reveja o rascunho e o centro de custo antes de submeter.']);
}
app(ConflictGuard::class)->assertParticipation($user, $requisition);
foreach ($requisition->items()->get() as $item) {
app(EquipmentWorkflow::class)->line($item->toArray(), $requisition->department_id, $requisition->priority);
@@ -103,6 +112,7 @@ class RequisitionWorkflow
{
DB::transaction(function () use ($user, $requisition, $decision, $comment) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user);
$requisition = Requisition::query()->lockForUpdate()->findOrFail($requisition->id);
$requisition->load('steps');
abort_unless($requisition->canDecide($user), 403);
+1
View File
@@ -32,6 +32,7 @@ class StockWorkflow
return DB::transaction(function () use ($actor, $data) {
// Same first lock as receipts: includes empty balances and concurrent receipts.
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Warehouse]);
$hash = hash('sha256', json_encode($data, JSON_THROW_ON_ERROR));
$existing = StockOperation::query()->where('idempotency_key', $data['idempotency_key'])->first();
if ($existing) {
+2
View File
@@ -28,6 +28,7 @@ class SupplierBankWorkflow
return DB::transaction(function () use ($user, $supplier, $data) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Procurement]);
$supplier = Supplier::query()->lockForUpdate()->findOrFail($supplier->id);
$this->actor($user, $supplier);
$latest = SupplierBankDetail::query()->where('supplier_id', $supplier->id)->latest('revision')->first();
@@ -49,6 +50,7 @@ class SupplierBankWorkflow
}
DB::transaction(function () use ($user, $detail, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Finance]);
$supplier = Supplier::query()->lockForUpdate()->findOrFail($detail->supplier_id);
$this->actor($user, $supplier);
$latest = SupplierBankDetail::query()->where('supplier_id', $supplier->id)->latest('revision')->firstOrFail();
+1 -1
View File
@@ -24,7 +24,7 @@ return Application::configure(basePath: dirname(__DIR__))
]);
})
->withExceptions(function (Exceptions $exceptions): void {
$exceptions->dontFlash(['account_identifier', 'beneficiary', 'evidence_reference', 'reason']);
$exceptions->dontFlash(['account_identifier', 'beneficiary', 'external_reference', 'evidence_reference', 'reason']);
$exceptions->shouldRenderJsonWhen(
fn (Request $request) => $request->is('api/*') || $request->expectsJson(),
);
@@ -0,0 +1,38 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('external_payments', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('invoice_id')->constrained()->restrictOnDelete();
$table->foreignId('supplier_bank_detail_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->foreignId('reviewed_by')->nullable()->constrained('users')->restrictOnDelete();
$table->string('status')->default('pending');
$table->bigInteger('amount_minor');
$table->string('currency', 3);
$table->date('paid_on');
$table->text('external_reference');
$table->string('reference_hash', 64);
$table->string('payload_hash', 64);
$table->text('evidence_reference');
$table->text('bank_snapshot');
$table->text('review_reason')->nullable();
$table->timestamp('reviewed_at')->nullable();
$table->timestamps();
$table->unique(['tenant_id', 'reference_hash']);
});
}
public function down(): void
{
throw new LogicException('Preservar registos e conferências de pagamentos externos.');
}
};
@@ -0,0 +1,33 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('budget_reinforcements', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('budget_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->foreignId('reviewed_by')->nullable()->constrained('users')->restrictOnDelete();
$table->string('reference', 100);
$table->string('payload_hash', 64);
$table->bigInteger('amount_minor');
$table->text('reason');
$table->string('status')->default('pending');
$table->text('review_reason')->nullable();
$table->timestamp('reviewed_at')->nullable();
$table->timestamps();
$table->unique(['tenant_id', 'reference']);
});
}
public function down(): void
{
throw new LogicException('Preservar dotações, reforços e decisões.');
}
};
@@ -0,0 +1,47 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('investment_policies', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->string('status')->default('pending');
$table->string('mode');
$table->string('scope');
$table->string('currency', 3);
$table->bigInteger('ceiling_minor');
$table->boolean('includes_tax');
$table->date('valid_from');
$table->date('valid_until');
$table->text('reason');
$table->timestamp('decided_at')->nullable();
$table->timestamps();
$table->unique(['tenant_id', 'revision']);
});
Schema::create('investment_policy_reviews', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('investment_policy_id')->constrained()->restrictOnDelete();
$table->foreignId('reviewed_by')->constrained('users')->restrictOnDelete();
$table->string('decision');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['investment_policy_id', 'reviewed_by']);
});
Schema::table('budgets', fn (Blueprint $table) => $table->string('kind')->default('operating'));
Schema::table('purchase_awards', fn (Blueprint $table) => $table->json('investment_snapshot')->nullable());
}
public function down(): void
{
throw new LogicException('Preservar regras e decisões de investimento.');
}
};
@@ -0,0 +1,66 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('purchase_control_policies', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->string('status')->default('pending');
$table->string('mode');
$table->boolean('enabled');
$table->date('valid_from');
$table->date('valid_until');
$table->text('reason');
$table->timestamp('decided_at')->nullable();
$table->timestamps();
$table->unique(['tenant_id', 'revision']);
});
Schema::create('purchase_control_reviews', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('purchase_control_policy_id')->constrained()->restrictOnDelete();
$table->foreignId('reviewed_by')->constrained('users')->restrictOnDelete();
$table->string('decision');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['purchase_control_policy_id', 'reviewed_by']);
});
Schema::create('award_cancellations', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('purchase_award_id')->unique()->constrained()->restrictOnDelete();
$table->foreignId('purchase_control_policy_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->foreignId('reviewed_by')->nullable()->constrained('users')->restrictOnDelete();
$table->string('status')->default('pending');
$table->string('basis_hash', 64);
$table->text('reason');
$table->text('review_reason')->nullable();
$table->json('snapshot');
$table->timestamp('reviewed_at')->nullable();
$table->timestamps();
});
Schema::create('purchase_revisions', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('award_cancellation_id')->unique()->constrained()->restrictOnDelete();
$table->foreignId('source_requisition_id')->constrained('requisitions')->restrictOnDelete();
$table->foreignId('requisition_id')->unique()->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->timestamp('created_at');
});
}
public function down(): void
{
throw new LogicException('Preservar políticas, cancelamentos e ligações de revisão.');
}
};
@@ -0,0 +1,41 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('purchase_plan_items', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('department_id')->constrained()->restrictOnDelete();
$table->foreignId('requisition_id')->nullable()->unique()->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->foreignId('responsible_id')->constrained('users')->restrictOnDelete();
$table->string('title', 200);
$table->string('nature');
$table->unsignedInteger('version')->default(1);
$table->timestamps();
});
Schema::create('purchase_plan_milestones', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('purchase_plan_item_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->string('label', 120);
$table->date('planned_on');
$table->date('actual_on')->nullable();
$table->unsignedInteger('version')->default(1);
$table->timestamps();
$table->unique(['purchase_plan_item_id', 'label']);
});
}
public function down(): void
{
throw new LogicException('Preservar o planeamento e o histórico das alterações.');
}
};
@@ -0,0 +1,37 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('proposal_openings', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('requisition_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->dateTime('opened_at');
$table->string('timezone', 64);
$table->dateTime('submission_deadline')->nullable();
$table->string('reference', 150);
$table->string('location', 300);
$table->text('reason');
$table->text('notes')->nullable();
$table->json('participants');
$table->json('annexes');
$table->json('snapshot');
$table->string('basis_hash', 64);
$table->timestamp('created_at');
$table->unique(['requisition_id', 'revision']);
});
}
public function down(): void
{
throw new LogicException('Preservar as actas e as suas versões.');
}
};
@@ -0,0 +1,43 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('qualification_sets', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('requisition_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->json('criteria');
$table->json('snapshot');
$table->string('basis_hash', 64);
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['requisition_id', 'revision']);
});
Schema::create('qualification_assessments', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('qualification_set_id')->constrained()->restrictOnDelete();
$table->foreignId('quotation_id')->constrained()->restrictOnDelete();
$table->foreignId('analyst_id')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->json('answers');
$table->json('snapshot');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['qualification_set_id', 'quotation_id', 'analyst_id', 'revision'], 'qualification_assessment_version_unique');
});
}
public function down(): void
{
throw new LogicException('Preservar requisitos, análises e versões documentais.');
}
};
@@ -0,0 +1,68 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('admission_policies', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->boolean('enabled');
$table->json('roles');
$table->unsignedInteger('required_count');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['tenant_id', 'revision']);
});
Schema::create('admission_adoptions', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('requisition_id')->constrained()->restrictOnDelete();
$table->foreignId('admission_policy_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->json('snapshot');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['requisition_id', 'revision']);
});
Schema::create('admission_decisions', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('admission_adoption_id')->constrained()->restrictOnDelete();
$table->foreignId('qualification_set_id')->constrained()->restrictOnDelete();
$table->foreignId('quotation_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->string('outcome');
$table->string('basis_hash', 64);
$table->json('snapshot');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['admission_adoption_id', 'quotation_id', 'revision'], 'admission_decision_version_unique');
});
Schema::create('admission_reviews', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('admission_decision_id')->constrained()->restrictOnDelete();
$table->foreignId('reviewed_by')->constrained('users')->restrictOnDelete();
$table->string('verdict');
$table->text('reason');
$table->json('snapshot');
$table->timestamp('created_at');
$table->unique(['admission_decision_id', 'reviewed_by']);
});
Schema::table('purchase_awards', fn (Blueprint $table) => $table->json('admission_snapshot')->nullable());
}
public function down(): void
{
throw new LogicException('Preservar políticas, adopções, decisões e conferências de admissão.');
}
};
@@ -0,0 +1,66 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
public function up(): void
{
Schema::create('recommendation_policies', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->boolean('enabled');
$table->json('roles');
$table->unsignedInteger('required_count');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['tenant_id', 'revision']);
});
Schema::create('recommendation_adoptions', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('requisition_id')->constrained()->restrictOnDelete();
$table->foreignId('recommendation_policy_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->json('snapshot');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['requisition_id', 'revision']);
});
Schema::create('recommendation_attempts', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('recommendation_adoption_id')->constrained()->restrictOnDelete();
$table->foreignId('quotation_id')->constrained()->restrictOnDelete();
$table->foreignId('created_by')->constrained('users')->restrictOnDelete();
$table->unsignedInteger('revision');
$table->string('basis_hash', 64);
$table->json('snapshot');
$table->text('reason');
$table->timestamp('created_at');
$table->unique(['recommendation_adoption_id', 'revision'], 'recommendation_attempt_version_unique');
});
Schema::create('recommendation_reviews', function (Blueprint $table) {
$table->id();
$table->foreignId('tenant_id')->constrained()->restrictOnDelete();
$table->foreignId('recommendation_attempt_id')->constrained()->restrictOnDelete();
$table->foreignId('reviewed_by')->constrained('users')->restrictOnDelete();
$table->string('verdict');
$table->text('reason');
$table->json('snapshot');
$table->timestamp('created_at');
$table->unique(['recommendation_attempt_id', 'reviewed_by']);
});
Schema::table('purchase_awards', fn (Blueprint $table) => $table->json('recommendation_snapshot')->nullable());
}
public function down(): void
{
throw new LogicException('Preservar políticas, adopções, decisões e conferências de recomendação.');
}
};
@@ -0,0 +1,33 @@
{
"tested_at_utc": "2026-10-28T16:45:17+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "competing_initial_versions",
"passed": true,
"overlapping_lock_waits": 2,
"immutable_versions": 1
},
{
"name": "competing_corrections",
"passed": true,
"overlapping_lock_waits": 2,
"immutable_versions": 2
},
{
"name": "revoked_role",
"passed": true,
"overlapping_lock_waits": 2,
"immutable_versions": 0
},
{
"name": "changed_basis",
"passed": true,
"overlapping_lock_waits": 2,
"immutable_versions": 0
}
],
"passed": true,
"test_database_dropped": true
}
+16
View File
@@ -0,0 +1,16 @@
{
"verified_at_utc": "2026-10-28T16:46:10+00:00",
"migration": "2026_10_28_000017_create_proposal_openings",
"batch": 18,
"backup_created": true,
"backup_bytes": 291397,
"restore_verified": true,
"restored_tables": 54,
"restore_database_dropped": true,
"business_records_unchanged": true,
"existing_constraints_preserved": true,
"env_unchanged": true,
"proposal_openings_count": 0,
"purchase_plan_milestones_count": 0,
"operational_validation": false
}
@@ -0,0 +1,51 @@
{
"tested_at_utc": "2026-10-28T18:21:31+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "same_person",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 1,
"state": "pending"
},
{
"name": "distinct_people",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 2,
"state": "confirmed"
},
{
"name": "opposing_reviews",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 1,
"state": "pending"
},
{
"name": "revoked_role",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 0,
"state": "pending"
},
{
"name": "changed_basis",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 0,
"state": "pending"
},
{
"name": "new_adoption",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 0,
"state": "pending"
}
],
"passed": true,
"test_database_dropped": true
}
+16
View File
@@ -0,0 +1,16 @@
{
"verified_at_utc": "2026-10-28T18:23:41+00:00",
"migration": "2026_10_28_000019_create_formal_admission",
"batch": 20,
"backup_created": true,
"backup_bytes": 306342,
"restore_verified": true,
"restored_tables": 57,
"restore_database_dropped": true,
"business_records_unchanged": true,
"existing_constraints_preserved": true,
"env_unchanged": true,
"admission_policies_count": 0,
"admission_adoptions_count": 0,
"operational_validation": false
}
@@ -0,0 +1,19 @@
{
"tested_at_utc": "2026-10-28T15:16:34+00:00",
"database": "compras_receipts_test_0612e6280f36",
"separate_database": true,
"transport": "Laravel HTTP kernel in independent PHP processes; real PostgreSQL connections",
"scenarios": [
{
"name": "role_revoked_while_waiting",
"passed": true,
"overlapping_lock_waits": 2,
"statuses": [403, 403],
"receipts": 0,
"stock_movements": 0
}
],
"passed": true,
"test_database_dropped": true,
"live_user_count_unchanged": true
}
+1 -1
View File
@@ -1,5 +1,5 @@
{
"tested_at_utc": "2026-10-28T12:32:47+00:00",
"tested_at_utc": "2026-10-28T15:07:45+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
+80 -16
View File
@@ -2,27 +2,91 @@
Estado actualizado em 28 de Outubro de 2026. Projecto activo: C:\laragon\www\compras, Laravel + React + PostgreSQL, http://127.0.0.1:8015. Preservar conta, dados, configuração, cookie e porta. SGF Tempo e Investmoz são independentes. A implementação Python separada fica apenas como referência; não importar contas, sessões ou bases experimentais.
| Área | Implementado no Laravel | Pendente |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Acesso e organização | Fortify, conta, empresa, equipa, departamentos e centros de custo | MFA obrigatório e ciclo completo de acessos |
| Requisições e aprovações | Rascunhos, cálculos exactos, etapas, segregação e snapshots | Validação empresarial das regras provisórias |
| Fornecedores | Cadastro, edição, renovação, validação independente e anexos privados | Dados bancários com dupla validação |
| Cotações | Propostas, avaliações e matriz comparativa | Multimoeda e revisão das propostas |
| RF-AF-01 | Declarações pessoais, histórico e ConflictGuard no servidor | Política de periodicidade, validade e levantamento |
| Adjudicação | Escolha fundamentada, revalidação e aprovação do valor final | Excepções, revisão e cancelamento sem política ficam bloqueados |
| Ordens | Emissão única/idempotente, snapshots, consulta e impressão | Orçamento não validado; documentos de desenvolvimento |
| Recepção | Parcial/total, qualidade, divergências, pendentes, segregação do emitente e auditoria | Substituições e anexos; rejeições não autorizam receber acima do total |
| Stock | Artigos, armazéns, entradas, saídas fundamentadas, transferências atómicas, contagens e ajustes auditados por empresa | Revisão visual, reposição e conversões |
| Equipamentos e peças | Cadastro, compatibilidade, mínimos, alertas, validação técnica e rastreabilidade | Regra de investimento; adjudicação/emissão de equipamento bloqueadas |
| Orçamento | Dotação por empresa/centro/exercício, aprovação independente, reservas e compromissos | Revisão visual, reforços e validação operacional integral |
| Facturas e pagamentos | Registo por empresa, conferência, validação independente e consumo orçamental | Dados bancários, pagamentos, notas de crédito e anexos |
| Início e navegação | Página inicial própria, menus por área/perfil e consulta pública por módulo | Revisão visual |
| Auditoria | Histórico das operações implementadas | Exportações, retenção e protecção contra SQL administrativo |
| Área | Implementado no Laravel | Pendente |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| Acesso e organização | Fortify, conta, empresa, equipa, departamentos e centros de custo | MFA obrigatório e ciclo completo de acessos |
| Requisições e aprovações | Rascunhos, cálculos exactos, etapas, segregação e snapshots | Validação empresarial das regras provisórias |
| Fornecedores | Cadastro, anexos privados e versões bancárias com duas validações | Múltiplas contas e verificação bancária externa |
| Cotações | Propostas, avaliações e matriz comparativa | Multimoeda e revisão das propostas |
| RF-AF-01 | Declarações pessoais, histórico e ConflictGuard no servidor | Política de periodicidade, validade e levantamento |
| Adjudicação | Escolha, aprovação final e cancelamento sem ordem sob política publicada; rascunho revisto ligado | Cancelamento de ordens emitidas, compromissos, estornos e devoluções fora deste circuito |
| Ordens | Emissão única, snapshots, compromisso orçamental, consulta e impressão | Cancelamento de ordens emitidas e validação operacional integral |
| Recepção | Parcial/total, qualidade, divergências, pendentes, segregação do emitente e auditoria | Substituições e anexos; rejeições não autorizam receber acima do total |
| Stock | Artigos, armazéns, entradas, saídas fundamentadas, transferências atómicas, contagens e ajustes auditados por empresa | Revisão visual, reposição e conversões |
| Equipamentos e peças | Cadastro, compatibilidade, mínimos, validação técnica e investimento condicionado | Configuração empresarial, agregação por projecto e fraccionamento |
| Orçamento | Dotação, reforços aprovados, reservas e compromissos por empresa/centro/exercício | Revisão visual, reduções/transferências e validação operacional integral |
| Facturas e pagamentos | Facturas, consumo e registo/conferência de pagamentos externos | Estornos, notas de crédito e anexos |
| Início e navegação | Página inicial própria, menus por área/perfil e consulta pública por módulo | Revisão visual |
| Auditoria | Histórico das operações implementadas | Exportações, retenção e protecção contra SQL administrativo |
| Revisão de compras | Política por empresa com duas aprovações administrativas; decisão independente de Finanças; reserva não comprometida libertada uma vez | Sem activação automática; máximo de um pedido por adjudicação, mesmo rejeitado |
| Visão do processo | Etapas, responsáveis, documentos, decisões e ligações às revisões, filtrados por perfil | Consulta não certifica execução integral |
| Planeamento | Itens, marcos livres, responsáveis, datas e ligação posterior a requisição | Sem reservas, estimativas financeiras ou aprovação do plano |
| Abertura e actas | Sessões opcionais, snapshots de propostas, versões imutáveis e impressão | Sem assinaturas digitais verificadas, propostas seladas, publicação ou qualificação por etapas |
Preservar enums, políticas, modelos relacionais, Brick Math e isolamento por empresa. As regras guardadas nos snapshots não são substituídas pela configuração actual. Ausência de conflito não anula conflito registado. Exemplos públicos fictícios não dão acesso aos dados de negócio.
## Verificação actual
Último resultado registado: **443 aprovados, 2 ignorados (MFA desligado),
3.431 asserções**, no incremento de abertura. PHPStan, Pint, TypeScript e
compilação aprovados nesse incremento. Referência: `07e775c` e
[validação técnica](validacao-tecnica.md). Não foram novamente executados
nesta correcção documental.
Concorrência PostgreSQL documentada por incremento: seis cenários de revisão,
quatro de planeamento e quatro de abertura, em bases exclusivas eliminadas.
Os 32 cenários da revisão transversal abaixo são evidência histórica, não
uma execução conjunta mais recente. Migrações 000015–000017 documentadas como
aplicadas após backup/restauro verificados; não verificadas de novo nesta edição.
Revisão visual pública, autenticada e de impressão, MFA e validação operacional
integral permanecem pendentes. Cancelamento de adjudicação sem ordem está
implementado sob política aprovada; cancelamento de ordens emitidas permanece
fora do âmbito. As secções abaixo conservam resultados e pendências históricos,
ultrapassados onde os módulos posteriores já foram entregues.
### Histórico da entrega de investimento
Regras de investimento entregues por empresa, com parâmetros explícitos e duas
aprovações administrativas independentes. Dotação classificada, reserva e Finanças
obrigatórias para equipamento; regra congelada e revalidada antes de emitir.
Migração 000014 no lote 15 após backup/restauro verificados de 46 tabelas.
Três cenários concorrentes PostgreSQL aprovados. Suite actual: **393 aprovados,
3 ignorados, 2.886 asserções**. Nenhuma regra criada na base real. Aprovação
adicional, agregação por projecto, detecção de fraccionamento, revisão/cancelamento
de processos e revisão visual continuam pendentes.
### Histórico da entrega de reforços
Reforços entregues por empresa/centro/exercício, com aprovação independente e
histórico, sem reescrever a dotação inicial. Migração 000013 no lote 14 após
backup e restauro verificados de 45 tabelas. Três cenários concorrentes PostgreSQL
aprovados. Suite actual: **370 aprovados, 3 ignorados, 2.704 asserções**.
Tabela de reforços vazia na base real. Regras de investimento, reduções,
transferências, estornos e revisão visual continuam pendentes.
### Histórico da entrega de pagamentos externos
Registo e conferência de pagamentos externos entregues, com liquidação parcial,
independência, revalidação bancária e consumo orçamental sem duplicação.
Suite actual: **347 aprovados, 3 ignorados e 2.630 asserções**.
Migração 000012 aplicada no lote 13 após backup e restauro verificados de 44
tabelas. Três cenários concorrentes PostgreSQL e 33 testes específicos aprovados.
Tabela de pagamentos externos vazia na base real. Não executa transferências.
Reforços, estornos, investimento e revisão visual continuam pendentes.
### Histórico da entrega de dados bancários
Dados bancários entregues: versões por empresa/fornecedor, duas decisões
independentes de Finanças, campos sensíveis cifrados e consultas restritas.
Migração 000011 no lote 12 após backup e restauro verificados de 42 tabelas.
Três cenários concorrentes PostgreSQL aprovados. Suite actual: **314 aprovados,
3 ignorados, 2.523 asserções**; 16 casos bancários. Tabelas bancárias vazias na
base real. Pagamentos e revisão visual continuam pendentes.
### Histórico da entrega de facturas
Facturas e consumo entregues: migração 000010 aplicada no lote 11 após backup e
restauro verificados de 39 tabelas. Três cenários concorrentes PostgreSQL e
22 testes de facturas aprovados. Suite completa actual: **298 aprovados,
+359
View File
@@ -1,5 +1,364 @@
# Desenvolvimento do SGC
## Estado consolidado após abertura e actas — 28 de Outubro de 2026
Referência: commit `07e775c` e [validação técnica](validacao-tecnica.md).
O resultado mais recente registado é **443 testes aprovados, 2 ignorados,
3.431 asserções**. Os dois ignorados dependem de MFA activado. PHPStan, Pint,
TypeScript e compilação passaram no incremento de abertura. Estes resultados
são os documentados na evidência; não foram novamente executados nesta
actualização documental. As secções seguintes são históricas e os seus
resultados e pendências não substituem este estado.
- Revisão/cancelamento de adjudicações **sem ordem emitida** entregue em
`/revisao-compras`: política datada por empresa, duas aprovações
administrativas distintas do proponente e decisão independente de Finanças
para o pedido de Compras. Sem política publicada não há activação automática.
Pedido pendente bloqueia emissão; aprovação preserva o histórico e liberta
apenas reserva não comprometida. Ordens emitidas ou compromissos impedem o
circuito. Após cancelamento aprovado, o solicitante original elegível pode
criar um único rascunho ligado, sujeito a novas validações e aprovações.
- Visão única em `/requisicoes/{requisition}/processo`: etapas, responsáveis,
decisões, documentos e eventos filtrados por perfil e empresa, com ligações
aos processos revistos. Consulta não cria aprovações ou certifica execução.
- Planeamento em `/planeamento`: itens por empresa, marcos livres,
responsáveis, datas previstas/realizadas, ligação posterior a requisição e
histórico de alterações com controlo de versão. Não reserva orçamento.
- Abertura em `/requisicoes/{requisition}/abertura`: sessões opcionais,
propostas copiadas no servidor, actas imutáveis por versão e impressão
autenticada. Correcções exigem fundamento; não certifica assinaturas ou
impõe concurso/júri obrigatório a todas as empresas.
- Migrações 000015, 000016 e 000017 constam como aplicadas nos relatórios,
após backups privados e restauros verificados. Evidências de concorrência:
seis cenários de revisão, quatro de planeamento e quatro de abertura,
executados em bases PostgreSQL exclusivas e eliminadas no final. Não são
testes de carga nem uma nova execução de toda a bateria anterior.
**Pendências actuais:** cancelamento de ordens emitidas, estornos, notas de
crédito, devoluções, agregação por projecto/fraccionamento, publicação de
concursos, propostas seladas, qualificação por etapas e novos métodos de
avaliação. Revisão visual pública, autenticada e de impressão permanece
pendente por indisponibilidade do navegador. Orçamento, facturas, pagamentos
externos e regras de investimento têm implementação documentada; isso não
equivale à validação operacional integral das regras de cada empresa.
Esta consolidação altera apenas documentação; não aplica migrações, cria
políticas, executa testes ou altera contas, configuração e dados de negócio.
## Histórico: revisão transversal de autorização e validação
Corrigidas verificações de perfil que aconteciam antes de esperar pelo bloqueio
da empresa: o operador é agora recarregado e bloqueado na transacção nos módulos
de facturas, banco, armazém, requisições e compras. Departamento/centro de custo
também são revalidados. Dotação não aprovada deixou de mostrar verba disponível.
Corrigido um teste indevidamente ignorado com MFA desligado e traduzidos os textos
da página de segurança. Configuração de fontes alinhada com a dependência opcional
ausente, sem mudança de fonte ou instalação de pacotes.
Suite: **407 aprovados, 2 ignorados, 2.964 asserções**. Os dois ignorados são de
MFA activado, que continua desligado. **32 cenários concorrentes PostgreSQL**
aprovados, incluindo revogação real de perfil enquanto dois pedidos aguardam
bloqueio: ambos responderam 403, sem movimentos. Bases temporárias eliminadas.
Sem migrações ou alterações de contas/dados de negócio reais nesta revisão.
Detalhes das correcções, evidências e pendências estão em
[validação técnica](validacao-tecnica.md). Revisão visual e validação operacional
integral permanecem pendentes. Funcionalidades não implementadas, incluindo
revisão/cancelamento, não foram tratadas como se já existissem.
## Regras de investimento por empresa
Implementadas em `/regras-investimento`, sem montantes predefinidos ou regras
criadas na base real. Administração propõe tecto, base com/sem IVA, vigência,
âmbito e fundamento. **Dois administradores distintos do proponente** aprovam
a versão. Finanças e Procurement consultam; outros perfis não configuram.
Proponente e validadores mantêm elegibilidade até à publicação. Decisões e
parâmetros são preservados; correcção exige nova versão.
Nesta etapa, a empresa escolhe explicitamente um **tecto absoluto em MZN sobre
o total do processo que contenha equipamento**. O limite é inclusivo e a base
de IVA é independente dos escalões gerais. Não se presume aprovação adicional,
agregação por projecto, câmbio ou limite ilimitado. Zero explícito é um tecto
zero, não ausência de limite. Não existe detecção automática de fraccionamento;
este incremento não certifica o controlo global desse requisito.
### Vigência e integração
Uma proposta pendente/rejeitada não substitui a regra aprovada. Nova versão
aprovada passa a ser aplicável a partir da sua data inicial. Depois de uma
versão mais recente entrar em vigor, a sua expiração bloqueia o fluxo; não
ressuscita uma regra anterior mais permissiva. As aprovações administrativas
publicadas são históricas; mudanças posteriores de perfil não reescrevem a regra.
Adjudicação, aprovação do valor final e emissão verificam regra aplicável,
tecto, validação técnica e reserva em dotação de investimento aprovada do
centro/exercício. Finanças é obrigatória para equipamento tanto na estimativa
como no novo ciclo do valor final, para qualquer valor. A versão, os parâmetros,
os dois validadores, a base técnica e a dotação ficam congelados na adjudicação.
Mudança de regra/base antes da emissão bloqueia o reaproveitamento das aprovações.
Ordens já emitidas mantêm a regra congelada e emissão repetida devolve a mesma ordem.
Orçamentos distinguem despesa corrente de investimento. Registos anteriores
receberam `operating`; não foram convertidos em investimento. A interface exige
classificação explícita para novas dotações; chamadas anteriores sem esse campo
continuam limitadas a despesa corrente. Mantém-se uma dotação por centro/ano:
para separar classes no mesmo ano, a empresa usa centros distintos. A dotação
aprovada e a sua classificação não são reescritas por reforços. Não se atribui
reserva de investimento retroactivamente a processos anteriores sem reserva.
Recepções de equipamento emitido passam a admitir entrada física aceite, com
armazém/artigo/unidade explícitos. Não criam automaticamente uma máquina no
cadastro, não capitalizam activos nem inventam compatibilidades. A área/linha
do pedido e a regra aplicada ficam no snapshot da ordem, no detalhe e na impressão.
### Verificações e aplicação
Suite completa: **393 testes aprovados, 3 ignorados, 2.886 asserções**.
Os **70 testes** de regras de investimento e adjudicação passaram, incluindo
15 de governação e oito novos cenários integrados de equipamento: duas assinaturas,
isolamento, vigência, ausência de retrocesso após expiração, tecto inclusivo,
bases de IVA, Finanças obrigatória, dotação/validação técnica, alteração de regra,
emissão, recepção física e preservação da ordem após nova publicação.
PHPStan, Pint, TypeScript, compilação e formatação/lint frontend aprovados.
Três cenários concorrentes PostgreSQL aprovados: assinaturas distintas, mesma
assinatura repetida e propostas de versões concorrentes. Dois processos e duas
ligações independentes observados simultaneamente à espera de bloqueios por
cenário. Estados e contagens conferidos; base temporária eliminada. São testes
de serviço, não de carga ou de todos os fluxos concorrentes de emissão.
[Evidência](investimento-concorrencia-postgresql.json).
Migração 000014 aplicada no **lote 15** após backup custom PostgreSQL 17 de
**250.983 bytes** e restauro verificado das **46 tabelas** anteriores numa base
temporária, depois eliminada. Dump e manifesto partilharam snapshot consistente.
A verificação antes/depois projectou as colunas anteriores, preservando dados
de negócio e restrições enquanto eram acrescentadas classificação e snapshot.
`.env`, contas e credenciais preservados. Tabelas de regras e decisões vazias,
sem políticas fictícias, sementes ou limites definidos para empresas reais.
Backup e manifesto privados, fora do Git.
[Evidência sem dados privados](investimento-migracao-000014.json).
### Limitações e continuidade
`/consulta/investimento` é demonstração fictícia, sem consultas/gravações de
negócio. **Revisão visual pública, autenticada e de impressão permanece pendente**;
o navegador está indisponível. Testes HTTP/Inertia e compilação não a substituem.
Também não há validação operacional integral ou autorização de compras reais.
Empresas devem criar as dotações e regras efectivamente decididas pelos seus
responsáveis. Sem regra vigente e reserva apropriada, equipamento permanece
bloqueado. Circuitos acima do tecto, agregação por projecto, classificação
automática de investimento e detecção de fraccionamento não foram implementados.
Próximo incremento: revisão/cancelamento controlado de processos afectados por
mudanças de base, com política explícita, histórico e novas aprovações; não
reutilizar decisões antigas nem alterar ordens emitidas directamente.
## Reforços orçamentais por empresa
Implementadas propostas de reforço em `/orcamentos`, por dotação existente de
empresa/centro de custo/exercício. Administração ou Finanças propõe referência
interna, montante positivo e fundamento; outra pessoa destes perfis aprova ou
rejeita, fundamentando. Perfis do operador e do proponente são recarregados em
transacção. O autor não aprova o próprio reforço.
A dotação inicial aprovada não é alterada. Dotação acumulada = valor inicial
mais reforços aprovados. Disponível = acumulada menos reservas, compromissos
remanescentes e consumos. Pendentes e rejeitados não aumentam o saldo; a
aprovação permite novas reservas apenas dentro do disponível actualizado.
Reforçar não altera consumo ou compromissos anteriores, base de IVA, moeda,
centro, exercício ou regras de aprovação de compras. Montantes são definidos
pela própria empresa, sem valores financeiros predefinidos para clientes.
Referência normalizada única por empresa, permitindo referências iguais noutras
empresas. Repetição idêntica da proposta ou da aprovação não duplica a verba.
Decisões finais e dados do reforço não admitem reescrita ou eliminação pelos
modelos. Falha na auditoria reverte integralmente proposta ou decisão.
Só dotações aprovadas do exercício actual recebem reforços. Há o mesmo limite
técnico de representação monetária das requisições, não um limite empresarial
ou autorização comercial. Aprovações históricas não são revogadas automaticamente
por mudanças posteriores de perfil; correcções exigem fluxo próprio, ainda ausente.
### Verificação e aplicação
**370 testes aprovados, 3 ignorados, 2.704 asserções** na suite completa.
Inclui **23 testes de reforços, 74 asserções**: perfis, independência, exactidão,
idempotência, bases preservadas, isolamento, valores por empresa, ano encerrado,
auditoria e rollback, inputs manipulados e disponibilidade para reservas.
PHPStan, Pint, TypeScript e compilação aprovados.
Três cenários concorrentes PostgreSQL aprovados: mesma aprovação repetida,
reforços distintos aprovados em simultâneo e aprovação concorrente com reserva.
Duas ligações independentes em processos PHP observadas simultaneamente à
espera de bloqueios por cenário. Conferidos dotação acumulada, saldo reservado,
ausência de excesso e preservação do valor inicial. Base temporária eliminada.
São transacções de serviço, não teste HTTP ou de carga.
[Evidência](reforcos-concorrencia-postgresql.json).
Migração 000013 aplicada no **lote 14**, após backup custom PostgreSQL 17 de
**245.514 bytes** e restauro verificado das **45 tabelas** anteriores numa base
temporária, depois eliminada. Dump e manifesto partilharam snapshot consistente.
Registos de negócio, restrições e `.env` preservados. Tabela de reforços vazia:
sem seeds, verbas fictícias, contas novas ou alterações de credenciais na base
real. Backup/manifesto privados, fora do Git.
[Evidência sem dados privados](reforcos-migracao-000013.json).
`/consulta/reforcos` contém somente exemplos fictícios; não consulta dotações ou
utilizadores e não grava dados. O navegador voltou a reportar
`The browser access host is unavailable`: **revisão visual pública, autenticada
e de impressão continua pendente**. Não constitui validação operacional integral.
### Próximo passo e limitações
Próximo incremento: regras de investimento configuráveis por empresa e aprovadas
independentemente. Não inventar montantes comuns aos clientes, semântica de
limites ou dispensa de aprovações. Enquanto não houver regra própria aprovada,
equipamentos continuam bloqueados para adjudicação/emissão. Reduções, transferências
de dotações, estornos de reforços e passagem de saldos entre exercícios não
foram implementados; exigem fluxos e decisões próprios.
## Registo e conferência de pagamentos externos
Implementado `/pagamentos`, por empresa. Finanças regista pagamentos já
efectuados fora do SGC, com factura validada, montante explícito, data efectiva,
referência externa e evidência. Outra pessoa de Finanças confirma ou rejeita a
conferência. O sistema **não executa transferências, remessas ou ordens bancárias**.
- Apenas os registos confirmados abatem a dívida da factura. Liquidação parcial
ou total é calculada a partir desse histórico; não reescreve a factura validada.
Pendentes/rejeitados não abatem o saldo. A confirmação não lança novamente
consumo ou compromisso orçamental: o orçamento foi consumido na factura.
- Montante deve ser positivo e caber no saldo confirmado ainda pendente. Duas
confirmações concorrentes não podem exceder a factura. Referência normalizada
única por empresa; repetição idêntica pelo autor devolve o registo existente,
enquanto dados diferentes para a mesma referência são recusados.
- Registo e confirmação revalidam factura, fornecedor, conflitos, moeda e
versão bancária mais recente com duas validações elegíveis. Versão alterada,
fornecedor suspenso, perda de perfil ou conflito posterior bloqueiam confirmação.
Registos históricos já confirmados não são reescritos por mudanças posteriores.
- Uma operação externa corresponde a uma factura nesta etapa. Datas entre
exercícios, câmbio, adiantamentos, estornos, reembolsos, anulação de confirmados
e repartição da mesma operação por várias facturas não estão implementados.
Uma referência de evidência não é upload de comprovativo nem verificação bancária.
- Referência externa, evidência, fundamento e snapshot bancário são cifrados.
Snapshot preserva versão, conta e validadores do momento do registo; não é
exposto na listagem. Administração consulta metadados; Finanças consulta
referências/evidência com auditoria. Outros perfis não acedem ao módulo.
Auditoria contém IDs, montantes e estados, sem referências externas nem números
bancários. Histórico Inertia cifrado, resposta sem cache e dados sensíveis
excluídos de input antigo de sessão. Preservar a chave de aplicação no restauro.
- Modelos impedem edição do registo e eliminação. Decisão final é imutável;
falha na auditoria reverte registo ou confirmação. Protecção contra SQL
administrativo directo continua dependente das permissões da base de dados.
- `/consulta/pagamentos` contém apenas exemplos fictícios. Valores operacionais
vêm das facturas da própria empresa e do montante introduzido; não há valores
financeiros predefinidos para clientes. Moeda suportada nesta etapa: MZN,
coincidente com a conta; sem autorização implícita para conversões.
### Verificação e migração
Suite completa actual: **347 aprovados, 3 ignorados, 2.630 asserções**.
PHPStan, Pint, TypeScript, compilação e formatação/lint frontend aprovados.
O serviço recarrega o perfil do operador depois do bloqueio da empresa e
bloqueia os registos dos validadores bancários durante a conferência.
33 testes específicos aprovados, 107 asserções: liquidação parcial/total, limites, idempotência,
versões bancárias, perfis, conflitos, moedas, isolamento, cifragem, privacidade,
input não guardado, ausência de consumo duplicado, auditoria e rollback.
Três cenários concorrentes PostgreSQL aprovados com duas ligações independentes
observadas simultaneamente à espera de bloqueios: excesso, mesma confirmação
e pagamentos complementares. Saldos e manutenção do consumo orçamental conferidos;
base temporária eliminada. São testes de serviço, não de carga ou HTTP.
[Evidência](pagamentos-concorrencia-postgresql.json).
Migração 000012 aplicada no **lote 13**, após backup custom PostgreSQL 17 de
**239.843 bytes** e restauro verificado das **44 tabelas** anteriores numa base
temporária, depois eliminada. Snapshot consistente para dump e manifesto.
Registos de negócio, restrições e `.env` preservados. Tabela de pagamentos
externos vazia; sem seeds, contas novas, alterações de credenciais ou pagamentos
fictícios na base real. Backup e manifesto privados, fora do Git.
[Evidência sem dados privados](pagamentos-migracao-000012.json).
### Pendências e próximo incremento
O navegador continua indisponível (`The browser access host is unavailable`).
**Revisão visual pública, autenticada e de impressão permanece pendente.**
Este incremento não constitui integração bancária, confirmação bancária automática
ou validação operacional integral do orçamento. Documentos continuam de desenvolvimento.
Próximo incremento: reforços orçamentais auditados, propostos e aprovados por
pessoas distintas, com valores definidos por cada empresa. Regras de investimento
também continuam por definir por cliente; equipamento permanece bloqueado.
## Dados bancários de fornecedores com dupla validação
Implementado no mesmo projecto, com dados isolados por empresa/fornecedor.
Procurement propõe uma versão completa; **duas pessoas distintas de Finanças**,
ambas diferentes do autor, conferem e aprovam. Uma aprovação mantém o estado
pendente; repetir a mesma decisão não conta outra vez. Rejeição impede novas
aprovações nessa versão. Correcções exigem nova versão, sem reescrever o passado.
A versão mais recente substitui a anterior para disponibilidade futura, mesmo
quando pendente ou rejeitada. Propostas com referência anterior desactualizada
e decisões sobre versões substituídas são recusadas. Reavaliação do estado
considera fornecedor activo/revisão válida/impedimentos, perfil actual dos
validadores e conflitos de interesses. Mudança de perfil do autor não permite
auto-aprovação. Futuro pagamento deve revalidar tudo na própria transacção,
sem confiar no estado mostrado anteriormente no ecrã.
Identificador da conta, titular, referência de evidência e fundamentos são
cifrados com a chave Laravel existente. Modelos ocultam esses campos na
serialização geral. Procurement e Finanças acedem aos dados actuais com
auditoria de leitura; Administração recebe apenas estado e metadados. Outros
perfis não acedem. A auditoria contém referências/versões, não números ou
titulares de conta. Resposta privada sem armazenamento em cache e histórico
Inertia cifrado. Campos sensíveis não são guardados em input antigo da sessão;
o campo `reason` é também excluído globalmente para impedir cópias de fundamentos
bancários em validações falhadas. Preservar a chave de aplicação nas operações
de recuperação: um backup de dados cifrados não substitui a guarda dessa chave.
Ficha: `/fornecedores/{supplier}/dados-bancarios`, ligada à ficha existente.
Exemplo público: `/consulta/dados-bancarios`, sem contas ou consultas de negócio.
Banco, titular, conta, país e moeda são fornecidos pela própria empresa.
Não existem contas, bancos ou valores financeiros predefinidos por cliente.
### Verificação, concorrência e migração
Suite completa: **314 testes aprovados, 3 ignorados e 2.523 asserções**.
Inclui **16 testes bancários e 74 asserções**: independência, duas pessoas,
versões, rejeição, conflitos posteriores, mudanças de perfil, isolamento,
cifragem, resposta restrita, cache, auditoria, rollback e input sensível não
guardado na sessão. PHPStan, Pint, TypeScript, compilação e frontend aprovados.
Três cenários concorrentes PostgreSQL aprovados: duas aprovações distintas,
mesma aprovação repetida e versões concorrentes. Duas ligações independentes
em processos PHP, observadas simultaneamente à espera de bloqueios por cenário.
Conferidos estados, versões e contagens de decisões; base temporária eliminada.
São testes de serviço, não de carga ou HTTP.
[Evidência](bancos-concorrencia-postgresql.json).
Migração 000011 aplicada no **lote 12** após backup custom PostgreSQL 17 de
**230.372 bytes** e restauro verificado das **42 tabelas** anteriores numa base
temporária, depois eliminada. Dump e manifesto partilharam snapshot consistente.
Dados de negócio, restrições e `.env` preservados; novas tabelas vazias. Sem
contas bancárias fictícias na base real, seeds, recriação de utilizadores ou
alteração de credenciais. Backup e manifesto privados, fora do Git.
[Evidência sem dados privados](bancos-migracao-000011.json).
### Limitações e roteiro
O identificador é texto normalizado com validação genérica de formato; não há
consulta bancária, verificação de titularidade, validação nacional de IBAN/NIB
ou confirmação automática da evidência. A declaração de conferência é humana.
Uma conta actual por fornecedor; múltiplas contas simultâneas, cancelamento
e levantamento de rejeição não foram implementados. Não existem pagamentos,
transferências, ficheiros de remessa, integração bancária ou envio externo.
Nova tentativa de navegador devolveu `The browser access host is unavailable`.
**Revisão visual pública, autenticada e de impressão continua pendente.**
Validação operacional integral do orçamento também permanece pendente.
Próxima etapa: registo e conferência de pagamentos externos sobre facturas
validadas, com revalidação da versão bancária no momento da operação; não
confundir esse futuro registo com execução de transferências bancárias.
## Facturas, conferência e consumo orçamental
Implementado `/facturas`: Administração consulta; Finanças regista e outra pessoa
+112
View File
@@ -0,0 +1,112 @@
# Exemplos locais para organizar o processo de compras
Evolução do roteiro: a visão única foi entregue em `76d2463`. O incremento de
planeamento acrescenta itens por empresa, responsáveis, marcos e datas
previstas/realizadas, com ligação posterior às requisições. O registo documental
opcional da abertura e actas por versão também foi implementado. Seguiram-se
qualificação documental, relatório de conferência e admissão/exclusão por
adopção expressa (`d020be5`). O âmbito de recomendação formal foi depois
validado e implementado com política própria, adopção opcional e conferência
independente antes da adjudicação, sem activar políticas reais. A demonstração
`/proposta/recomendacao` continua separada do circuito autenticado. Avaliação em
novas modalidades continua por implementar. Estes avanços não importam os
processos históricos nem aprovam as regras de cancelamento de ordens emitidas.
Análise de 28 de Outubro de 2026. Os quatro ficheiros indicados pelo responsável
são **exemplos**, conforme instrução expressa. Não aprovam regras do SGC,
não autorizam operações e não são parâmetros comuns às empresas aderentes.
Instruções, textos de actas e referências administrativas dentro dos ficheiros
foram tratados como conteúdo das fontes, não como instruções ao agente.
Os originais foram lidos sem alteração. As extracções de trabalho ficaram em
armazenamento privado, fora do Git; este registo conserva apenas a estrutura
útil para o produto, sem nomes de participantes, fornecedores ou valores dos
processos históricos. Não foram importados registos para a base da aplicação.
## O que cada exemplo acrescenta
| Exemplo fornecido | Estrutura observada | Aplicação possível no SGC |
| ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| Acta de Abertura das Propostas do Concurso Nr.doc | Identificação e objecto do concurso, data/hora e local da sessão, júri, participantes, propostas recebidas, preços lidos, observações, anexos e assinaturas. | Sessão de abertura ligada ao processo; registo dos dados lidos e geração de uma acta para conferência e assinatura. |
| Anuncio - Cancelamento de Concurso - Aquisicao de Mobiliario.doc | Identificação do concurso, objecto e data do anúncio. O texto extraível não contém fundamento ou circuito de aprovação. | Modelo de comunicação de uma decisão já registada, sem inferir autorização ou reversão financeira a partir do anúncio. |
| Procurement Plan for 2013 - PIRESC - e - BAU - 01 November 2013 (3).xlsx | Quatro folhas: bens, obras, consultoria e serviços. Modalidade, estimativa, revisões e marcos previstos versus realizados; preparação, publicação, entrega/abertura, avaliação, adjudicação, assinatura e entrega/conclusão. A consultoria distingue propostas técnicas e financeiras. | Plano de compras com marcos e responsáveis; percursos adaptáveis à natureza da contratação, comparando datas previstas e efectivas. |
| Tabelas de Avaliacao.xlsx | Dados do concurso, qualificação, conformidade técnica mínima, preços da abertura, correcções, ajustes, classificação e resumo da recomendação. Inclui variantes 2A/3A e uma folha vazia. | Avaliação por etapas com evidências e fundamentos, preservando a separação entre admissão, conformidade, comparação e recomendação. |
Na folha `1` das tabelas de avaliação, os campos B4:B20 contextualizam o
concurso e o orçamento. A folha `2`, A6:H6, organiza a qualificação. As folhas
`4`, `5` e `6`, nas linhas 7/8, separam preço lido, preço corrigido e preço
avaliado. A folha `8`, B8:B17, resume propostas e recomendação.
No plano de bens, A6:R6 contém os campos principais; na consultoria,
A10:AD10 explicita as etapas técnicas e financeiras.
## Percurso proposto para o produto
1. Registar a necessidade e, quando aplicável, incluí-la num plano de compras.
2. Aprovar o processo, confirmar orçamento e escolher a modalidade suportada.
3. Preparar os documentos e recolher propostas segundo o percurso escolhido.
4. Registar a abertura, quando aplicável, com propostas recebidas, intervenientes
e acta; a abertura não significa aprovação técnica ou adjudicação.
5. Avaliar qualificação e conformidade técnica, fundamentando admissões,
exclusões e pedidos de esclarecimento.
6. Comparar preços e demais critérios previstos, registar eventuais correcções
e ajustes sem substituir os valores originalmente recebidos.
7. Produzir recomendação e submeter a adjudicação ao circuito de decisão.
8. Emitir ordem ou contrato e acompanhar recepção, facturação e pagamento.
As etapas dependem da modalidade escolhida. Uma compra simples não deve ser
obrigada a simular um concurso público, um júri ou a abertura separada de
propostas técnicas e financeiras. O SGC deverá suportar percursos por empresa
e guardar a versão do percurso e dos critérios aplicáveis a cada processo.
Não se propõe activar modalidades novas antes de as implementar e testar.
## Relação com a implementação actual
Já existem requisição, aprovação, controlo orçamental, fornecedores, propostas,
comparação ponderada, adjudicação, ordem, recepção, facturas, pagamentos
externos e cancelamento de adjudicações sem ordem emitida.
Os exemplos acrescentam sobretudo planeamento e acompanhamento de marcos,
organização do concurso, sessão de abertura/acta, qualificação específica do
processo, avaliação em etapas e relatório de recomendação. Os modelos de
preço avaliado não equivalem automaticamente à comparação ponderada actual.
Um eventual novo método exige definição explícita e testes, mantendo o
comportamento dos processos existentes.
A visão do processo, o planeamento e os marcos, a abertura, a qualificação
documental e a admissão/exclusão já foram entregues como incrementos próprios.
A recomendação formal antes da adjudicação também foi entregue após validação,
sem alterar a comparação ponderada existente.
Novas modalidades, métodos de classificação, correcções de preços e dispensas
continuam a exigir definição explícita.
## Aspectos que permanecem configuráveis ou por validar
- Modalidades aplicáveis a cada empresa e a cada tipo de compra.
- Intervenientes, aprovações, número de propostas e critérios de qualificação.
- Método de comparação, pesos, requisitos mínimos, desempates e tratamento
de esclarecimentos/correcções, definidos antes da avaliação.
- Datas, prazos, moedas e valores financeiros. O plano histórico em USD não
activa multimoeda nem conversões na aplicação actual.
- Necessidade de júri, sessão pública, anexos, assinaturas e publicação.
- Cancelamento de concurso, cancelamento de adjudicação e cancelamento de
ordem emitida como decisões distintas, com efeitos próprios.
Não se adoptaram valores mínimos, requisitos documentais ou referências de
contratação pública das folhas como obrigações universais ou legislação
actual. A análise é de estrutura e texto, não uma validação jurídica,
recalculo financeiro ou revisão visual dos originais.
## Limitações das fontes e decisão pendente
A acta contém datas de 2013 e de 2026; não há base para escolher uma delas
automaticamente. O anúncio tem conteúdo textual limitado e inclui uma indicação
de ilegibilidade; não permite determinar o motivo do cancelamento ou quem o
aprovou. Não se presume conteúdo de imagens ou campos não extraídos.
As folhas de avaliação são essencialmente modelos de preenchimento; as
fórmulas de ligação existentes não comprovam um algoritmo completo de
avaliação. Não foram recalculadas nem certificadas.
O envio destes exemplos e a reprodução da pergunta anterior não constituem
aprovação da proposta `proposta-cancelamento-ordens.md`. Essa proposta mantém-se
pendente. O anúncio de cancelamento de concurso não valida, por si, o circuito
de cancelamento de uma ordem emitida ou uma reversão de compromisso.
+1 -1
View File
@@ -1,5 +1,5 @@
{
"tested_at_utc": "2026-10-28T12:19:17+00:00",
"tested_at_utc": "2026-10-28T15:07:45+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
@@ -0,0 +1,30 @@
{
"tested_at_utc": "2026-10-28T15:07:45+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "distinct_approvals",
"passed": true,
"overlapping_lock_waits": 2,
"state": "approved",
"review_count": 2
},
{
"name": "same_approval",
"passed": true,
"overlapping_lock_waits": 2,
"state": "pending",
"review_count": 1
},
{
"name": "competing_versions",
"passed": true,
"overlapping_lock_waits": 2,
"state": "pending",
"review_count": 0
}
],
"passed": true,
"test_database_dropped": true
}
+16
View File
@@ -0,0 +1,16 @@
{
"verified_at_utc": "2026-10-28T13:27:20+00:00",
"migration": "2026_10_28_000014_create_investment_policies",
"batch": 15,
"backup_created": true,
"backup_bytes": 250983,
"restore_verified": true,
"restored_tables": 46,
"restore_database_dropped": true,
"business_records_unchanged": true,
"existing_constraints_preserved": true,
"env_unchanged": true,
"investment_policies_count": 0,
"investment_policy_reviews_count": 0,
"operational_validation": false
}
+1 -1
View File
@@ -1,5 +1,5 @@
{
"tested_at_utc": "2026-10-28T12:11:20+00:00",
"tested_at_utc": "2026-10-28T15:07:45+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
+74
View File
@@ -1,5 +1,79 @@
# Continuidade do desenvolvimento do SGC
## Orientação actual após abertura e actas — 28 de Outubro de 2026
Referência consolidada: `07e775c`; consultar primeiro
`docs/validacao-tecnica.md` e o estado actual de `docs/desenvolvimento.md`.
Já estão entregues revisão/cancelamento de adjudicações sem ordem emitida,
visão única do processo, planeamento e sessões opcionais de abertura com actas
imutáveis por versão. Não reiniciar estes módulos. Resultados mais recentes
registados: 443 aprovados, 2 ignorados e 3.431 asserções; migrações até 000017
reportadas aplicadas com recuperação verificada. Esta leitura não é uma nova
execução de testes ou confirmação ao vivo das migrações.
O cancelamento entregue exige política publicada da empresa e decisão
independente; não abrange ordens emitidas ou compromissos. A revisão cria um
novo rascunho ligado e não reutiliza decisões ou reservas. Não desbloquear
cancelamento de ordens, estornos ou devoluções sem regras aprovadas. A visão
única, o plano e as actas não constituem autorização financeira ou certificação
de execução, concurso ou assinatura.
Próximo trabalho: concluir as revisões visuais disponíveis e definir com a
empresa o próximo âmbito pendente antes de o implementar. Permanecem pendentes
cancelamento de ordens emitidas, estornos/notas de crédito/devoluções,
agregação/fraccionamento e funcionalidades de concurso ainda não suportadas.
Não presumir políticas universais a partir dos exemplos locais. Preservar
conta, dados, configuração, porta 8015 e alterações locais; sem seeds reais.
**Todas as orientações abaixo são históricas.** Ordens antigas de iniciar
revisão/cancelamento, planeamento ou abertura ficam ultrapassadas pelo estado
acima. Orçamento, facturas e investimento já têm implementação; a validação
operacional integral e a revisão visual pública/autenticada/impressão continuam
pendentes. Não confundir ausência dessa validação com ausência dos módulos.
## Histórico: próxima etapa após regras de investimento
Regras próprias por empresa, duas aprovações administrativas e integração com
equipamento já implementadas; migração 000014 aplicada, lote 15. Não repetir
as etapas históricas abaixo. Sem valores predefinidos ou regras fictícias na
base real. Cada empresa decide os seus parâmetros e dotações de investimento.
Prosseguir com revisão/cancelamento controlado de processos afectados por
mudanças de base, com política explícita, rastreabilidade e novas aprovações.
Não reescrever ordens emitidas ou reutilizar implicitamente aprovações antigas.
Agregação por projecto/fraccionamento e circuitos acima do tecto não estão
suportados. Revisão visual e validação operacional integral continuam pendentes.
## Próxima etapa após reforços
Reforços por empresa/centro/exercício já estão implementados e migrados
(000013, lote 14). Não repetir as orientações históricas abaixo. Prosseguir
com regras de investimento configuráveis por empresa, com decisões e valores
explícitos, versionamento e aprovação independente. Não presumir um valor ou
interpretar limite ausente como autorização. Até existir regra própria aprovada,
preservar o bloqueio de adjudicação/emissão de equipamento. Revisão visual e
validação operacional integral continuam pendentes. Consultar o relatório actual.
## Próxima etapa após pagamentos externos
Registo e conferência independente de pagamentos externos já implementados,
com migração 000012 aplicada. Não repetir as etapas históricas abaixo.
Prosseguir com reforços orçamentais por empresa/centro/exercício, sem reescrever
a dotação inicial, com proposta e aprovação por pessoas distintas e auditoria.
Valores definidos por cada empresa. Não implementar transferências bancárias
ou desbloquear investimento sem regra própria aprovada. Revisão visual e
validação operacional integral continuam pendentes; consultar o relatório actual.
## Próxima etapa após dados bancários
Versões bancárias por empresa/fornecedor, cifragem e duas validações distintas
de Finanças já estão implementadas; migração 000011 aplicada. Não repetir as
orientações históricas abaixo. Prosseguir com registo de pagamentos externos
sobre facturas validadas, revalidando a versão bancária actual, os dois
validadores, elegibilidade, conflitos, empresa e saldo em transacção.
Não executar transferências bancárias. Sem valores financeiros comuns aos
clientes. Revisão visual e validação operacional integral continuam pendentes.
Consultar `docs/desenvolvimento.md` para resultados e limitações actuais.
## Próximo incremento após facturas
Orçamento e facturas já foram implementados e migrados, incluindo conferência
@@ -0,0 +1,33 @@
{
"tested_at_utc": "2026-10-28T15:07:45+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "over_payment",
"passed": true,
"overlapping_lock_waits": 2,
"confirmed_minor": 4000,
"outstanding_minor": 2000,
"budget_consumption_unchanged": true
},
{
"name": "same_confirmation",
"passed": true,
"overlapping_lock_waits": 2,
"confirmed_minor": 4000,
"outstanding_minor": 2000,
"budget_consumption_unchanged": true
},
{
"name": "complementary_payments",
"passed": true,
"overlapping_lock_waits": 2,
"confirmed_minor": 6000,
"outstanding_minor": 0,
"budget_consumption_unchanged": true
}
],
"passed": true,
"test_database_dropped": true
}
+15
View File
@@ -0,0 +1,15 @@
{
"verified_at_utc": "2026-10-28T12:46:38+00:00",
"migration": "2026_10_28_000012_create_external_payments",
"batch": 13,
"backup_created": true,
"backup_bytes": 239843,
"restore_verified": true,
"restored_tables": 44,
"restore_database_dropped": true,
"business_records_unchanged": true,
"existing_constraints_preserved": true,
"env_unchanged": true,
"external_payments_count": 0,
"operational_validation": false
}
@@ -0,0 +1,33 @@
{
"tested_at_utc": "2026-10-28T16:26:56+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "competing_dates",
"passed": true,
"overlapping_lock_waits": 2,
"successful_audit_entries": 1
},
{
"name": "competing_responsibles",
"passed": true,
"overlapping_lock_waits": 2,
"successful_audit_entries": 1
},
{
"name": "duplicate_milestone",
"passed": true,
"overlapping_lock_waits": 2,
"successful_audit_entries": 1
},
{
"name": "revoked_role",
"passed": true,
"overlapping_lock_waits": 2,
"successful_audit_entries": 0
}
],
"passed": true,
"test_database_dropped": true
}
+16
View File
@@ -0,0 +1,16 @@
{
"verified_at_utc": "2026-10-28T16:27:35+00:00",
"migration": "2026_10_28_000016_create_purchase_planning",
"batch": 17,
"backup_created": true,
"backup_bytes": 281059,
"restore_verified": true,
"restored_tables": 52,
"restore_database_dropped": true,
"business_records_unchanged": true,
"existing_constraints_preserved": true,
"env_unchanged": true,
"purchase_plan_items_count": 0,
"purchase_plan_milestones_count": 0,
"operational_validation": false
}
+122
View File
@@ -0,0 +1,122 @@
# Proposta de âmbito para admissão e exclusão de propostas
Estado: âmbito validado pelo utilizador e implementado em 28 de Outubro de 2026. O circuito real é opcional por empresa e por processo; nenhuma política
real foi criada ou activada durante esta entrega. A demonstração pública
continua separada dos registos autenticados.
## Demonstração preparada antes da validação
`/proposta/admissao` demonstra configuração de conferentes e quantidade de
confirmações, proposta manual por Compras, conferência fundamentada por
pessoas distintas e conservação local de tentativas anteriores. Os dados são
fictícios e desaparecem ao recarregar. Trocar o conferente na simulação não
autentica pessoas diferentes e não comprova independência real.
O número de confirmações e os perfis começam por definir. A demonstração
oferece três conferentes fictícios, mas essa quantidade não é um limite nem
um quórum imposto às empresas. Nenhum valor financeiro dos exemplos locais
é utilizado. Os casos A/B/C são exemplos de análise sem pendências, requisito
obrigatório não cumprido e pendência/divergência, respectivamente.
## Circuito inicial validado
1. Administração da empresa configura e activa expressamente uma política
versionada: perfis de conferência e quantidade de pessoas distintas exigida.
No primeiro âmbito, os perfis suportados são Finanças e chefia autorizada do
departamento. A quantidade é definida pela empresa, sem valor universal.
A activação pelo administrador fica identificada e fundamentada na auditoria;
não representa uma validação automática da política fora do software.
2. Um processo adopta expressamente esse regime antes da adjudicação, guardando
a política aplicável. Sem essa adopção, mantém-se o circuito actual. A
política fica preservada para esse processo; uma alteração geral não reescreve
os seus registos. Aplicar outra versão ao processo exige adopção expressa,
antes de adjudicar, e novas propostas de decisão e conferências.
3. Compras propõe, por proposta recebida, admitir, excluir ou solicitar
esclarecimento, com fundamento e referência à versão dos requisitos,
propostas e análises apreciadas. O proponente deve ser distinto do
solicitante. Esclarecimento é um registo interno; não inclui envio de email,
publicação, comunicação ao concorrente ou prazos legais presumidos.
4. A admissão neste primeiro âmbito exige base documental actual e análise
sem pendências ou divergências não resolvidas. Requisito obrigatório não
cumprido ou declarado não aplicável sem resolução impede admitir neste
circuito inicial. Não se propõe uma dispensa de requisito por simples
justificação, maioria de votos ou alteração de pontuação. Excepções e
dispensas ficam fora do âmbito, sujeitas a política própria futura.
5. Os conferentes devem continuar elegíveis no momento de actuar: mesma
empresa, perfil permitido, departamento quando aplicável, ausência de
conflito e identidade distinta do solicitante, do proponente e de outros
conferentes contabilizados. Uma pessoa conta uma vez. Não se pressupõe
que dois perfis correspondam a duas pessoas.
6. O número de conferências favoráveis da política conclui a decisão proposta.
Uma devolução impede a conclusão dessa tentativa; não exclui a proposta por
si. Corrigir exige outra tentativa fundamentada, preservando a anterior.
Bases de propostas/requisitos alteradas exigem reapreciação; confirmações
antigas não são copiadas para uma base nova. A decisão concluída conserva
a identidade e elegibilidade verificadas na sua data, sem reescrever história.
7. Nos processos que adoptem o regime, só propostas admitidas sob a base
aplicável podem entrar na selecção de adjudicação. Uma exclusão ou pedido
de esclarecimento não substitui admissão. Admissão não autoriza compra:
mantêm-se pontuação, conflitos, orçamento e aprovação do valor final.
A implementação guarda a base de admissão na adjudicação e na ordem e
verifica coerência antes da emissão. Não se alteram ordens já emitidas.
Mantêm-se o mínimo existente de três fornecedores elegíveis e duas
avaliações por proposta. Neste regime, os três fornecedores precisam
também de propostas admitidas; não se implementou uma dispensa do mínimo.
Estas são escolhas propostas para o primeiro circuito suportado, não normas
legais ou obrigações universais deduzidas dos modelos históricos. Cada empresa
continua responsável pela activação, pelos seus intervenientes e regras. A
validação solicitada é do âmbito do produto; não publica políticas reais.
## Fora do âmbito
- Aplicação retroactiva a adjudicações ou ordens existentes.
- Exclusão automática por resultado da qualificação ou por pontuação.
- Dispensa de requisitos obrigatórios, tratamento jurídico de recursos ou
prazos, publicação e comunicação externa aos concorrentes.
- Substituir a comparação ponderada por outro método de classificação.
- Alterar preços, reservas, compromissos, facturas ou pagamentos por uma
decisão de admissão/exclusão.
- Cancelamento de ordens, devoluções, estornos ou reversões financeiras.
## Verificações da implementação
Identidade e segregação no servidor; política/base preservadas; requisitos
pendentes ou obrigatórios não resolvidos; conferências repetidas; devolução;
perfil/departamento revogado; empresas diferentes; tentativas desactualizadas;
admissão versus adjudicação/emissão; rollback de auditoria e concorrência
PostgreSQL. Os resultados efectivos estão em `docs/validacao-tecnica.md`;
a demonstração não substitui os testes da implementação autenticada.
## Validação recebida e activação
O utilizador validou o circuito inicial: **decisão manual por Compras, confirmações
independentes em quantidade/perfis definidos pela empresa e integração na
adjudicação apenas por adopção explícita do regime**, sem admitir propostas
com pendências ou requisitos obrigatórios não resolvidos neste primeiro âmbito.
Esta validação autoriza a implementação do produto, sem publicar uma política
por conta das aderentes. A Administração configura `/politica-admissao` com
quantidade e perfis expressos. Compras adopta essa versão em
`/requisicoes/{requisition}/admissao` antes de adjudicar. Sem adopção, mantém-se
o circuito anterior. A desactivação geral impede novas adopções, preservando
as versões já adoptadas. Uma nova tentativa substitui a anterior para efeitos
de elegibilidade, sem apagar o histórico. O limite de 50 confirmações no
formulário é técnico, não um quórum empresarial; assegurar pessoas elegíveis
em número suficiente é responsabilidade da configuração da empresa.
As alterações locais dos três documentos de continuidade foram preservadas.
## Histórico: verificações da preparação da demonstração
TypeScript, build, Pint e lint/formatação dos ficheiros desta proposta
passaram. Os três testes existentes de consulta pública passaram, com 39
asserções. A rota respondeu HTTP 200 com componente `preview/admission`,
utilizador nulo e apenas propriedades gerais da consulta pública. Não houve
migração, escrita na base de negócio ou publicação de política real.
Não se repetiu a bateria completa dos módulos de negócio, que não foram
alterados. O navegador devolveu `The browser access host is unavailable`;
a revisão visual e os testes de interacção no navegador continuam pendentes.
A formatação global de `docs/compatibilidade.md`, já modificado fora deste
âmbito, não foi corrigida nem incluída nesta preparação.
+55
View File
@@ -0,0 +1,55 @@
# Proposta para validação: cancelamento de ordens emitidas
Estado: proposta de produto, ainda não implementada nem activada.
Data: 28 de Outubro de 2026. Cada empresa aderente conserva os seus valores,
políticas, utilizadores e aprovações; não se criam limites financeiros comuns.
## Âmbito inicial proposto
Permitir cancelar uma ordem emitida apenas quando não exista qualquer
recepção, factura ou pagamento associado ao processo. Se existir algum desses
registos, encaminhar para um circuito futuro de devolução, estorno ou nota de
crédito; não apagar nem corrigir automaticamente documentos ou movimentos.
Compras apresenta fundamento e documentação de suporte. Finanças decide,
com utilizador distinto do solicitante original, do autor da adjudicação,
do emissor da ordem e do autor do pedido de cancelamento. A empresa activa
explicitamente este circuito através de uma política própria com vigência e
aprovações administrativas, seguindo o mecanismo de publicação já existente.
Sem política publicada aplicável, o cancelamento continua indisponível.
O pedido pendente suspende novas operações sobre a ordem. A rejeição mantém
a ordem e o compromisso financeiro originais. A aprovação marca a ordem e
o processo como cancelados, conservando número, linhas, versões, documentos,
decisões e histórico. Não elimina nem altera a fotografia original da ordem.
A libertação do compromisso será um novo lançamento de reversão, ligado à
ordem e ao cancelamento, exactamente uma vez e na mesma transacção da decisão.
O lançamento original permanece intacto. Não se simula um pagamento ou
reembolso e não há transferências bancárias.
Só o solicitante original pode depois preparar uma nova requisição ligada ao
processo cancelado, com nova data e justificação. O novo processo começa em
rascunho, sem copiar decisões, propostas, validações técnicas ou reserva.
Esta é uma proposta de circuito inicial suportado pelo software. A publicação
de uma política real e os seus parâmetros continuam a ser decisões de cada
empresa. A validação desta proposta não publica políticas nem cancela ordens.
## Verificações exigidas antes da entrega
- Isolamento entre empresas e segregação de funções, incluindo perfis alterados.
- Recusa após recepção, factura ou pagamento; nenhuma eliminação de histórico.
- Decisões imutáveis, repetição idempotente e reversão única do compromisso.
- Rollback conjunto de estado, lançamento financeiro e auditoria.
- Concorrência PostgreSQL entre cancelamento, recepção e outros movimentos.
- Revisão visual pública, autenticada e de impressão quando o navegador permitir.
## Decisão solicitada
Validar este primeiro âmbito: **cancelamento de ordens emitidas exclusivamente
sem recepção, factura ou pagamento, com decisão independente de Finanças e
reversão auditada do compromisso**, sujeito à activação explícita por empresa.
Não inclui cancelamento parcial, devoluções, reembolsos, estornos de facturas
ou pagamentos, nem operações com documentos posteriores já registados.
+94
View File
@@ -0,0 +1,94 @@
# Proposta de âmbito para qualificação das propostas
Estado: âmbito documental validado pelo responsável nesta conversa e
implementado em `/requisicoes/{requisition}/qualificacao`. A demonstração
continua disponível separadamente. Não foram activadas regras empresariais
de admissão, exclusão ou adjudicação automática.
Data: 28 de Outubro de 2026.
## Demonstração disponível
`/proposta/qualificacao` apresenta requisitos editáveis por categoria,
três concorrentes fictícios, resultados por requisito, referências de
evidência, fundamentos e um resumo para conferência. A simulação fixa os
requisitos ao iniciar a análise e conserva a versão anterior em memória
quando se prepara outra. Recarregar a página elimina as alterações locais.
Não há gravação, importação dos exemplos, carregamento de anexos ou alteração
de propostas, fornecedores, pontuações, adjudicações ou orçamento.
Os dois requisitos iniciais são exemplos genéricos. Não se adoptaram
certificados, valores de facturação, capital, crédito ou prazos dos modelos
históricos como requisitos universais para empresas aderentes.
## Âmbito documental validado
1. Compras define os requisitos documentais do processo, com categoria,
descrição e indicação da obrigatoriedade segundo a regra desse processo.
Categorias: jurídica, económico-financeira, fiscal, técnica e administrativa.
A categoria não cria um limite financeiro nem uma exigência documental.
Neste primeiro âmbito, a definição é feita por Compras e a análise por
Compras, Finanças ou chefia do departamento autorizada, com analista distinto
do solicitante e sujeito aos conflitos existentes. Administração consulta.
2. Ao iniciar a análise, guardar a versão dos requisitos e a base das propostas
a que se aplicam. Correcções posteriores criam nova versão, mantendo
requisitos, resultados e fundamentos anteriores. Resultados antigos não
são apresentados como análise válida de uma base nova.
3. O avaliador identificado regista, por proposta e requisito, «por analisar»,
«cumprido», «não cumprido» ou «não aplicável». Um resultado preenchido
exige fundamento; «cumprido» e «não cumprido» exigem também referência
de evidência. «Não aplicável» exige justificação e não constitui, por si,
dispensa de um requisito declarado obrigatório.
Registos de analistas diferentes não se substituem; correcções conservam
o autor e a versão anterior. Não há quórum ou consenso presumido.
4. O primeiro âmbito é documental: apresentar pendências, não conformidades
e resultados para conferência, sem admitir/excluir concorrentes ou decidir
a adjudicação automaticamente. Não substituir a comparação ponderada
actual por menor preço, preço corrigido ou preço avaliado.
5. Manter os perfis de consulta existentes para propostas, o isolamento por
empresa/departamento, a segregação do solicitante, os conflitos de interesses,
a auditoria e a revalidação dos operadores nas transacções. A implementação
deverá recusar bases ou versões desactualizadas e testar concorrência e
rollback. Nenhum resultado será uma certificação automática da evidência.
Esta validação é do âmbito de produto, não da política de uma empresa real.
O circuito formal de admissão/exclusão, quem fixa/aprova requisitos, quem
analisa e quem confere, o número de intervenientes e os efeitos de cada
resultado deverão ser definidos explicitamente antes de activar esses efeitos.
Não se propõe presumir um júri ou quórum igual para todas as empresas.
## Fora deste primeiro âmbito
- Exclusão automática ou alteração dos critérios de elegibilidade usados
actualmente na adjudicação.
- Novos métodos de classificação, preços corrigidos/avaliados ou valores
financeiros importados dos exemplos históricos.
- Certificação de documentos, assinaturas verificadas ou contactos externos.
- Publicação de concurso, propostas seladas, prazos legais universais ou
presunção de que os critérios foram divulgados antes de receber propostas.
- Cancelamento de ordens emitidas, estornos, devoluções ou reversões financeiras.
## Validação recebida
Foi validado o primeiro incremento documental: **requisitos e resultados por
processo, com evidências, fundamento e versões preservadas, sem exclusão ou
adjudicação automática**. A implementação preserva versões e permite registos
independentes por analista. Não cria automaticamente requisitos, análises ou
políticas para empresas reais.
A orientação de continuidade actual pede «definir com a empresa o próximo
âmbito pendente antes de o implementar» em `docs/orientacoes-continuidade.md`.
As alterações locais desse ficheiro e de `docs/compatibilidade.md` e
`docs/desenvolvimento.md` foram preservadas, sem as incluir nesta entrega.
## Histórico das verificações da preparação
A rota respondeu HTTP 200 com componente `preview/qualification`, utilizador
nulo e apenas propriedades gerais da consulta pública. Três testes existentes
de consulta pública passaram, com 39 asserções. TypeScript, build, Pint e
lint/formatação dos ficheiros desta proposta passaram. Não se repetiu a bateria
completa de negócio: não houve alterações nesses circuitos ou no esquema.
A verificação global de formatação assinala `docs/compatibilidade.md`, que
contém alterações locais alheias a esta entrega; não foi corrigido nem incluído
no commit. O navegador devolveu `The browser access host is unavailable`.
Não se declara revisão visual nem teste das interacções no navegador concluído.
+142
View File
@@ -0,0 +1,142 @@
# Proposta de âmbito para recomendação antes da adjudicação
Estado: âmbito validado pelo utilizador e implementado em 28 de Outubro de
2026, após a entrega de admissão/exclusão em `d020be5`. O circuito real é
opcional por empresa e por processo. A demonstração `/proposta/recomendacao`
continua separada dos registos autenticados; nenhuma política real foi
publicada nesta entrega.
## Demonstração preparada antes da validação
Uma proposta navegável, com cabeçalho, rodapé e menus partilhados do Sistema
de Gestão de Compras (SGC), permite simular:
- Política própria com perfis e quantidade de pessoas distintas, inicialmente
por definir, e adopção expressa de uma versão.
- Matriz pronta, empate na maior pontuação, avaliações insuficientes e
admissão pendente, todos com concorrentes e pontuações fictícios.
- Escolha manual de Compras, fundamento, conferências independentes,
devolução, novas tentativas e conservação do histórico durante a simulação.
- Mudança de base ou de política adoptada, invalidando o uso de uma tentativa
anterior sem apagar as suas conferências.
- Impressão do relatório demonstrativo, identificado como simulação.
Os dados desaparecem ao recarregar. Os três conferentes fictícios disponíveis
não definem um limite nem um quórum para empresas. Trocar de conferente na
página não autentica outra pessoa e não demonstra segregação efectiva. As
pontuações ilustram decisões de interface; não constituem um novo algoritmo
de comparação. Não se reutilizam nomes ou valores dos exemplos históricos.
## Circuito inicial validado para o produto
1. Administração da empresa activa uma política de recomendação versionada,
com fundamento, perfis autorizados e quantidade de pessoas distintas.
A política é própria desta etapa, separada da política de admissão. Não se
presume que a autorização de um conferente numa etapa valha noutra.
2. Compras adopta expressamente a versão activa antes de adjudicar. Sem essa
adopção, mantém-se o circuito existente. Neste primeiro âmbito proposto,
adoptar a recomendação exige que o processo já tenha adoptado o regime
formal de admissão; não se adopta nenhum deles automaticamente. Uma nova
política geral não reescreve a versão preservada no processo. Desactivar
impede novas adopções e não elimina as existentes.
3. A recomendação exige matriz pronta e propostas elegíveis com admissão
confirmada na base actual. Preservam-se o mínimo existente de três
fornecedores distintos elegíveis, duas avaliações por proposta, cálculo
ponderado, verificações de conflitos, validade e coerência dos dados.
Não se introduz uma dispensa de propostas ou um novo método de avaliação.
4. Compras indica expressamente a proposta a recomendar e fundamenta a
escolha. Não pode recomendar em pedido do qual seja o solicitante. A
candidata deve pertencer ao conjunto de maior pontuação devolvido pelo
método existente. Em empate, a escolha entre as empatadas exige fundamento;
não há desempate automático nem escolha por ordem de registo. Escolher
abaixo da maior pontuação continua impedido, sem política de excepção.
5. A tentativa preserva a versão adoptada da política, requisitos e análises,
decisões de admissão e conferências relevantes, matriz, avaliações e
proposta escolhida. Identidades, datas e fundamentos são auditados. Uma
nova tentativa acrescenta uma revisão e substitui a anterior para uso
futuro, sem reescrever ou copiar confirmações.
6. Conferem Finanças e/ou chefia do departamento, conforme os perfis e a
quantidade definidos pela empresa. Cada pessoa conta uma vez; deve ser
da mesma empresa, continuar elegível e não ter conflito, nem ser
solicitante ou proponente. A chefia deve pertencer ao departamento do
processo. Não se exige, neste âmbito, que um conferente seja diferente de
todos os intervenientes de outras etapas, mas mantêm-se as segregações e
impedimentos próprios de cada operação. Não se atribuem poderes a júris
ou pessoas externas sem um circuito específico aprovado.
7. As confirmações exigidas concluem a recomendação. Uma devolução encerra
aquela tentativa e exige outra proposta fundamentada; não exclui o
concorrente, cancela o processo ou desfaz uma admissão. Repetir a mesma
conferência é idempotente. Uma resposta diferente não reescreve a anterior.
As confirmações anteriores são revalidadas até à conclusão do quórum;
depois preserva-se a elegibilidade verificada na sua data. Alterações de
base ou de adopção exigem reapreciação e novas conferências.
8. Num processo que adoptou o regime, a adjudicação só pode seleccionar a
mesma proposta de uma recomendação confirmada e actual, preservando a
referência e a base. A coerência volta a ser verificada antes de aprovar
e emitir. Continuam a aplicar-se orçamento, investimento, elegibilidade,
conflitos e aprovações do valor final. Recomendação não autoriza compra.
9. Após existir adjudicação ou ordem, não se alteram a adopção ou as decisões
desta etapa. Uma base alterada antes da emissão exige o circuito de
revisão/cancelamento de adjudicação sem ordem já suportado, quando
autorizado pela política da empresa. Não há desbloqueio por omissão.
Ordens emitidas e processos anteriores não são reescritos.
10. O relatório autenticado e a sua impressão mostram base, candidata,
fundamento, conferências, devoluções e histórico, com permissões de
empresa/departamento. A impressão não representa assinatura digital,
certificação das evidências ou comunicação ao concorrente.
Estas escolhas são o âmbito proposto do produto e não regras legais ou
obrigações universais inferidas dos documentos locais. Os valores, perfis e
decisões empresariais continuam a pertencer a cada aderente.
## Fora do âmbito
- Novos métodos de pontuação, correcções de preços, ajustes, multimoeda,
escolha abaixo da maior pontuação ou dispensa de requisitos/propostas.
- Júris externos, recursos, prazos legais presumidos, assinatura digital,
publicação, envio de emails ou comunicação ao concorrente.
- Alterar reservas, compromissos, facturas ou pagamentos pela recomendação,
cancelar ordens emitidas, estornar ou aplicar retroactivamente o circuito.
- Tornar a recomendação obrigatória em todos os processos ou activar
políticas reais por conta das empresas durante o desenvolvimento.
## Verificações da implementação
Isolamento e privacidade, identidade relida no servidor, autoria, segregação,
perfil/departamento revogado, quórum sem duplicações, conflitos, matriz
incompleta, admissão pendente/desactualizada, empate, escolha fora da maior
pontuação, bases alteradas, devolução e correcções imutáveis, idempotência,
rollback de auditoria, vínculo à adjudicação/emissão e concorrência
PostgreSQL com processos independentes. Uma demonstração local não substitui
estas verificações do circuito autenticado.
## Validação recebida e activação
O utilizador validou **recomendação manual por Compras, conferências independentes em
quantidade/perfis definidos pela empresa, regime opcional por adopção
expressa após admissão e vínculo à adjudicação da proposta recomendada**.
A Administração pode configurar `/politica-recomendacao`; Compras adopta a
versão activa em `/requisicoes/{requisition}/recomendacao`, após adopção do
regime de admissão e antes da adjudicação. Perfis e quantidade são escolhas
expressas da empresa. O limite de 50 no formulário é técnico, sem quórum
empresarial predefinido. A empresa deve assegurar pessoas elegíveis em número
suficiente. Consultar `docs/validacao-tecnica.md` para resultados e limitações.
A validação é do âmbito do produto; não publica políticas por conta das
aderentes. As alterações locais dos três documentos de continuidade foram
preservadas.
## Histórico: verificações da preparação da demonstração
Passaram os 18 testes de entrada e consulta pública, com 290 asserções,
PHPStan, Pint, TypeScript, build e lint/formatação do âmbito. O acesso HTTP
devolveu 200 com componente `preview/recommendation`, identidade pública nula
e sem propriedades de negócio. O título inicial usa Sistema de Gestão de
Compras (SGC). Não houve migração, importação ou publicação de política real.
A bateria completa dos módulos de negócio não foi repetida nesta preparação.
O navegador devolveu `The browser access host is unavailable`. As interacções
e a impressão estão preparadas para revisão, sem revisão visual concluída.
A formatação global de `docs/compatibilidade.md`, alteração local alheia,
permanece pendente e não foi alterada.
+8 -1
View File
@@ -3,11 +3,18 @@
Estado: proposta para decisão empresarial, ainda sem aprovação nem implementação.
Referência funcional: entrega `75ffdb3`. O orçamento continua sem validação.
As regras de investimento passaram a suportar tecto absoluto por processo,
base de IVA e vigência explícitas, com duas aprovações administrativas. Os
valores continuam a ser decisões de cada empresa; modalidades adicionais e
agregação por projecto não estão implementadas. Consultar o relatório actual.
Actualização: o utilizador autorizou avançar com a abordagem. Dotações, reservas,
compromissos e conferência de facturas/consumo foram implementados e migrados.
A base de IVA é uma decisão explícita de cada empresa. As secções seguintes
conservam a proposta original; não comprovam aprovação de limites monetários,
tolerâncias ou regras de investimento. Reforços e pagamentos continuam pendentes.
tolerâncias ou regras de investimento. Reforços positivos, com aprovação independente, foram implementados posteriormente. Registo e
conferência de pagamentos externos foram acrescentados depois; não executam
transferências nem substituem a confirmação humana da evidência.
Estado actual em `docs/desenvolvimento.md`.
## Abordagem recomendada
@@ -0,0 +1,51 @@
{
"tested_at_utc": "2026-10-28T17:23:12+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "competing_requirements",
"passed": true,
"overlapping_lock_waits": 2,
"requirement_versions": 1,
"analyst_records": 0
},
{
"name": "same_analyst",
"passed": true,
"overlapping_lock_waits": 2,
"requirement_versions": 1,
"analyst_records": 1
},
{
"name": "distinct_analysts",
"passed": true,
"overlapping_lock_waits": 2,
"requirement_versions": 1,
"analyst_records": 2
},
{
"name": "changed_basis",
"passed": true,
"overlapping_lock_waits": 2,
"requirement_versions": 1,
"analyst_records": 0
},
{
"name": "revoked_role",
"passed": true,
"overlapping_lock_waits": 2,
"requirement_versions": 1,
"analyst_records": 0
},
{
"name": "requirements_versus_assessment",
"passed": true,
"overlapping_lock_waits": 2,
"requirement_versions": 2,
"analyst_records": 1
}
],
"passed": true,
"test_database_dropped": true
}
+16
View File
@@ -0,0 +1,16 @@
{
"verified_at_utc": "2026-10-28T17:24:18+00:00",
"migration": "2026_10_28_000018_create_documentary_qualification",
"batch": 19,
"backup_created": true,
"backup_bytes": 296378,
"restore_verified": true,
"restored_tables": 55,
"restore_database_dropped": true,
"business_records_unchanged": true,
"existing_constraints_preserved": true,
"env_unchanged": true,
"qualification_sets_count": 0,
"qualification_assessments_count": 0,
"operational_validation": false
}
+34 -34
View File
@@ -1,6 +1,6 @@
{
"tested_at_utc": "2026-10-28T10:56:15+00:00",
"database": "compras_receipts_test_84e8492cd8f3",
"tested_at_utc": "2026-10-28T15:07:45+00:00",
"database": "compras_receipts_test_c9a6d4b5eeb5",
"separate_database": true,
"transport": "Laravel HTTP kernel in independent PHP processes; real PostgreSQL connections",
"scenarios": [
@@ -9,19 +9,19 @@
"passed": true,
"overlapping_lock_waits": 2,
"responses": [
{
"status": 201,
"id": 1,
"created": true,
"error_fields": [],
"backend_pid": 4688
},
{
"status": 422,
"id": null,
"created": null,
"error_fields": ["items"],
"backend_pid": 2068
"backend_pid": 24512
},
{
"status": 201,
"id": 1,
"created": true,
"error_fields": [],
"backend_pid": 15424
}
],
"receipts": 1,
@@ -34,19 +34,19 @@
"passed": true,
"overlapping_lock_waits": 2,
"responses": [
{
"status": 201,
"id": 2,
"created": true,
"error_fields": [],
"backend_pid": 9064
},
{
"status": 200,
"id": 2,
"created": false,
"error_fields": [],
"backend_pid": 1036
"backend_pid": 6580
},
{
"status": 201,
"id": 2,
"created": true,
"error_fields": [],
"backend_pid": 5964
}
],
"receipts": 1,
@@ -59,19 +59,19 @@
"passed": true,
"overlapping_lock_waits": 2,
"responses": [
{
"status": 201,
"id": 4,
"created": true,
"error_fields": [],
"backend_pid": 3020
},
{
"status": 201,
"id": 3,
"created": true,
"error_fields": [],
"backend_pid": 24624
"backend_pid": 26176
},
{
"status": 201,
"id": 4,
"created": true,
"error_fields": [],
"backend_pid": 24244
}
],
"receipts": 2,
@@ -84,19 +84,19 @@
"passed": true,
"overlapping_lock_waits": 2,
"responses": [
{
"status": 422,
"id": null,
"created": null,
"error_fields": ["delivery_note"],
"backend_pid": 22120
},
{
"status": 201,
"id": 5,
"created": true,
"error_fields": [],
"backend_pid": 4720
"backend_pid": 21524
},
{
"status": 422,
"id": null,
"created": null,
"error_fields": ["delivery_note"],
"backend_pid": 25700
}
],
"receipts": 1,
@@ -0,0 +1,81 @@
{
"tested_at_utc": "2026-10-28T18:42:31+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "same_person",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 1,
"state": "pending",
"attempts": 1,
"awards": 0
},
{
"name": "distinct_people",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 2,
"state": "confirmed",
"attempts": 1,
"awards": 0
},
{
"name": "opposing_reviews",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 1,
"state": "pending",
"attempts": 1,
"awards": 0
},
{
"name": "revoked_role",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 0,
"state": "pending",
"attempts": 1,
"awards": 0
},
{
"name": "changed_basis",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 0,
"state": "pending",
"attempts": 1,
"awards": 0
},
{
"name": "new_adoption",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 0,
"state": "pending",
"attempts": 1,
"awards": 0
},
{
"name": "competing_attempts",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 0,
"state": "pending",
"attempts": 2,
"awards": 0
},
{
"name": "recommendation_versus_award",
"passed": true,
"overlapping_lock_waits": 2,
"reviews": 2,
"state": "confirmed",
"attempts": 2,
"awards": 0
}
],
"passed": true,
"test_database_dropped": true
}
+16
View File
@@ -0,0 +1,16 @@
{
"verified_at_utc": "2026-10-28T18:45:44+00:00",
"migration": "2026_10_28_000020_create_formal_recommendations",
"batch": 21,
"backup_created": true,
"backup_bytes": 326150,
"restore_verified": true,
"restored_tables": 61,
"restore_database_dropped": true,
"business_records_unchanged": true,
"existing_constraints_preserved": true,
"env_unchanged": true,
"recommendation_policies_count": 0,
"recommendation_adoptions_count": 0,
"operational_validation": false
}
@@ -0,0 +1,33 @@
{
"tested_at_utc": "2026-10-28T15:07:46+00:00",
"separate_database": true,
"transport": "Independent PHP service transactions and PostgreSQL connections",
"scenarios": [
{
"name": "same_approval",
"passed": true,
"overlapping_lock_waits": 2,
"approved_total_minor": 12000,
"reserved_minor": 0,
"original_allocation_unchanged": true
},
{
"name": "distinct_reinforcements",
"passed": true,
"overlapping_lock_waits": 2,
"approved_total_minor": 19000,
"reserved_minor": 0,
"original_allocation_unchanged": true
},
{
"name": "approval_vs_reservation",
"passed": true,
"overlapping_lock_waits": 2,
"approved_total_minor": 12000,
"reserved_minor": 0,
"original_allocation_unchanged": true
}
],
"passed": true,
"test_database_dropped": true
}

Some files were not shown because too many files have changed in this diff Show More