commit de armazens
tests / ci (push) Canceled after 0s

This commit is contained in:
2026-11-04 09:40:26 +02:00
parent e753f7a0a4
commit 63d20b10fc
245 changed files with 10847 additions and 230 deletions
+165
View File
@@ -0,0 +1,165 @@
<?php
namespace App\Services;
use Illuminate\Support\Facades\Schema;
use Illuminate\Validation\ValidationException;
class AdministrativeGeography
{
public const ISSUES = [
'blank_designation' => 'Designação vazia',
'incomplete_code_path' => 'Percurso de códigos incompleto',
'duplicate_code_path' => 'Código repetido',
'missing_parent' => 'Nível superior ausente',
'ambiguous_parent' => 'Nível superior ambíguo',
'ancestor_requires_review' => 'Ascendente por rever',
];
/** @var array<string,mixed>|null */
private ?array $data = null;
/** @return array<string,mixed> */
public function catalogue(): array
{
if ($this->data === null) {
$content = file_get_contents(resource_path('data/geography/cartografia-moz.json'));
abort_unless(is_string($content) && hash_equals((string) config('geography.catalogue_sha256'), hash('sha256', $content)), 503, 'A integridade do catálogo precisa de verificação.');
$data = json_decode($content, true, 32, JSON_THROW_ON_ERROR);
abort_unless(is_array($data) && ($data['manifest']['source_sha256'] ?? null) === config('geography.source_sha256'), 503, 'Catálogo geográfico indisponível.');
$this->data = $data;
}
return $this->data;
}
public function enabled(): bool
{
return config('geography.enabled') === true
&& Schema::hasColumn('suppliers', 'geography_reference')
&& Schema::hasColumn('tenants', 'geography_reference');
}
public function availableFor(string $table): bool
{
return in_array($table, ['tenants', 'suppliers', 'warehouses', 'equipment'], true)
&& (! in_array($table, ['warehouses', 'equipment'], true) || config('geography.operational_enabled') === true)
&& $this->enabled() && Schema::hasColumn($table, 'geography_reference');
}
/** @return array<string,string> */
public function referenceRules(string $table): array
{
return ['geography_reference' => $this->availableFor($table) ? 'sometimes|nullable|array:country,catalogue,record_id' : 'prohibited',
'geography_reference.catalogue' => 'required_with:geography_reference|string|size:64',
'geography_reference.record_id' => 'required_with:geography_reference|string|regex:/^[0-9]+$/D|max:20'];
}
/** @param array<string,mixed>|null $reference
* @return array<string,mixed>|null
*/
public function canonicalFor(string $table, ?array $reference): ?array
{
abort_unless($this->availableFor($table), 503, 'A localização deste cadastro ainda não está instalada.');
return $this->canonical($reference);
}
/** @return array<string,mixed> */
public function record(string $id): array
{
foreach ($this->catalogue()['records'] as $record) {
if ($record['id'] === $id) {
return $record;
}
}
throw ValidationException::withMessages(['geography_reference' => 'Localização não encontrada no catálogo.']);
}
/** @param array<string,mixed>|null $reference
* @return array<string,mixed>|null
*/
public function canonical(?array $reference): ?array
{
abort_unless($this->enabled(), 503, 'A localização administrativa ainda não está disponível.');
if ($reference === null) {
return null;
}
if (($reference['catalogue'] ?? null) !== $this->catalogue()['manifest']['source_sha256']) {
throw ValidationException::withMessages(['geography_reference' => 'O catálogo foi alterado. Reabra a ficha antes de guardar.']);
}
$record = $this->record((string) ($reference['record_id'] ?? ''));
if (! $record['selectable']) {
throw ValidationException::withMessages(['geography_reference' => 'Este registo ou a sua hierarquia precisa de revisão. Escolha um nível superior confirmado.']);
}
return ['country' => 'MZ', 'catalogue' => $reference['catalogue'], 'record_id' => $record['id']];
}
/** @param array<string,mixed>|null $reference
* @return array<string,mixed>|null
*/
public function describe(?array $reference): ?array
{
if ($reference === null) {
return null;
}
if (($reference['catalogue'] ?? null) !== $this->catalogue()['manifest']['source_sha256']) {
return ['reference' => $reference, 'path' => [], 'requires_review' => true];
}
$record = $this->record((string) $reference['record_id']);
$path = [$record];
while ($record['parent_id'] !== null) {
$record = $this->record($record['parent_id']);
array_unshift($path, $record);
}
return ['reference' => $reference, 'path' => array_map(fn ($node) => $this->summary($node), $path), 'requires_review' => ! $path[count($path) - 1]['selectable']];
}
/** @param array<string,mixed> $record
* @return array<string,mixed>
*/
private function summary(array $record): array
{
return array_intersect_key($record, array_flip(['id', 'name', 'level', 'parent_id']));
}
/** @return array<string,mixed> */
public function children(?string $parent, int $page = 1): array
{
if ($parent !== null && ! $this->record($parent)['selectable']) {
throw ValidationException::withMessages(['parent' => 'Hierarquia pendente de revisão.']);
}
$records = array_values(array_filter($this->catalogue()['records'], fn ($record) => $record['selectable'] && $record['parent_id'] === $parent));
usort($records, fn ($a, $b) => strcmp($a['name'], $b['name']) ?: strcmp($a['id'], $b['id']));
return ['data' => array_map(fn ($record) => $this->summary($record), array_slice($records, ($page - 1) * 50, 50)), 'page' => $page, 'has_more' => count($records) > $page * 50, 'catalogue' => $this->catalogue()['manifest']['source_sha256']];
}
/** @return list<string> */
public function descendants(string $id): array
{
$root = $this->record($id);
if (! $root['selectable']) {
throw ValidationException::withMessages(['location' => 'Localização pendente de revisão.']);
}
$prefix = array_slice($root['codes'], 0, $root['level']);
return array_values(array_map(fn ($record) => $record['id'], array_filter($this->catalogue()['records'], fn ($record) => $record['selectable'] && array_slice($record['codes'], 0, count($prefix)) === $prefix)));
}
/** @param array<string,mixed> $filters
* @return list<array<string,mixed>>
*/
public function inconsistencies(array $filters): array
{
$search = trim($filters['search'] ?? '');
$issue = $filters['issue'] ?? '';
return array_values(array_filter($this->catalogue()['records'], fn ($record) => ! $record['selectable']
&& ($issue === '' || in_array($issue, $record['issues'], true))
&& ($search === '' || $record['id'] === $search || mb_stripos($record['name'], $search) !== false)));
}
}
+89
View File
@@ -0,0 +1,89 @@
<?php
namespace App\Services;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
class CandidateGeography
{
/** @param array<string,mixed> $input
* @return array<string,mixed>
*/
public function resolve(array $input): array
{
if (($input['availability_reference'] ?? null) !== null) {
$data = Validator::make($input, ['availability_reference' => 'required|array:country,catalogue,record_id', 'availability_reference.catalogue' => 'required|string|size:64', 'availability_reference.record_id' => 'required|string|regex:/^[0-9]+$/D|max:20'])->validate();
$resolved = $this->locality($data['availability_reference'], 'availability_reference');
$input['availability_reference'] = $resolved['reference'];
$input['availability'] = $resolved['location'];
}
if (array_key_exists('additional_availability_references', $input)) {
$data = Validator::make($input, ['additional_availability' => 'present|array|list|max:20', 'additional_availability.*' => 'array',
'additional_availability_references' => 'present|array|list|max:20', 'additional_availability_references.*' => 'nullable|array:country,catalogue,record_id',
'additional_availability_references.*.catalogue' => 'required_with:additional_availability_references.*|string|size:64',
'additional_availability_references.*.record_id' => 'required_with:additional_availability_references.*|string|regex:/^[0-9]+$/D|max:20'])->validate();
if (count($data['additional_availability']) !== count($data['additional_availability_references'])) {
throw ValidationException::withMessages(['additional_availability_references' => 'Cada local adicional deve ter uma referência correspondente ou vazia.']);
}
foreach ($data['additional_availability_references'] as $index => $reference) {
if ($reference !== null) {
$resolved = $this->locality($reference, 'additional_availability_references.'.$index);
$input['additional_availability'][$index] = $resolved['location'];
$input['additional_availability_references'][$index] = $resolved['reference'];
}
}
}
return $input;
}
/** @param array<string,mixed> $value
* @return array{reference:array<string,mixed>,location:array<string,string>}
*/
private function locality(array $value, string $field): array
{
$geography = app(AdministrativeGeography::class);
try {
$reference = $geography->canonical($value);
} catch (ValidationException $error) {
throw ValidationException::withMessages([$field => array_merge(...array_values($error->errors()))]);
}
abort_unless($reference !== null, 422);
$record = $geography->record($reference['record_id']);
if ($record['level'] !== 4) {
throw ValidationException::withMessages([$field => 'Seleccione um percurso completo até à localidade. Não se presume um distrito ou localidade em falta.']);
}
$description = $geography->describe($reference);
abort_unless($description !== null, 422);
$names = array_column($description['path'], 'name', 'level');
return ['reference' => $reference, 'location' => ['province' => $names[1], 'district' => $names[2], 'locality' => $names[4]]];
}
/** @param array<string,mixed> $data
* @param array<string,mixed> $previous
* @return array<string,mixed>
*/
public function preserve(array $data, array $previous): array
{
if (! array_key_exists('availability_reference', $data) && isset($previous['availability_reference']) && array_map(fn ($key) => $data['availability'][$key], ['province', 'district', 'locality']) === array_map(fn ($key) => $previous['availability'][$key], ['province', 'district', 'locality'])) {
$data['availability_reference'] = $previous['availability_reference'];
}
if (! array_key_exists('additional_availability_references', $data) && array_key_exists('additional_availability_references', $previous)) {
$known = [];
foreach ($previous['additional_availability'] ?? [] as $index => $location) {
$key = json_encode(array_map(fn ($part) => $location[$part], ['province', 'district', 'locality']), JSON_THROW_ON_ERROR);
$known[$key] = $previous['additional_availability_references'][$index] ?? null;
}
$data['additional_availability_references'] = array_map(function ($location) use ($known) {
$key = json_encode(array_map(fn ($part) => $location[$part], ['province', 'district', 'locality']), JSON_THROW_ON_ERROR);
return $known[$key] ?? null;
}, $data['additional_availability']);
}
return $data;
}
}
+5 -1
View File
@@ -76,9 +76,12 @@ class CandidateProfiles
$sessionVersion = $account->session_version;
$account = CandidateAccount::query()->where('tenant_id', $account->tenant_id)->where('id', $account->id)->lockForUpdate()->firstOrFail();
abort_unless($account->session_version === $sessionVersion, 401);
$input = app(CandidateGeography::class)->resolve($input);
$data = Validator::make($input, ['version' => 'required|integer|min:0', 'name' => 'required|string|min:3|max:200', 'phone' => 'nullable|string|max:50',
'availability_reference' => 'sometimes|nullable|array:country,catalogue,record_id',
'summary' => 'required|string|min:10|max:5000', 'availability' => 'required|array:province,district,locality',
'availability.province' => 'required|string|max:150', 'availability.district' => 'required|string|max:150', 'availability.locality' => 'required|string|max:150',
'additional_availability_references' => 'sometimes|array|list|max:20',
'additional_availability' => 'sometimes|array|list|max:20',
'additional_availability.*' => 'required|array:province,district,locality',
'additional_availability.*.province' => 'required|string|max:150',
@@ -87,6 +90,7 @@ class CandidateProfiles
'reason' => 'required|string|min:10|max:4000'])->validate();
$previous = $this->profile($account);
$data['additional_availability'] ??= $previous['data']['additional_availability'] ?? [];
$data = app(CandidateGeography::class)->preserve($data, $previous['data']);
$seen = [];
foreach ([$data['availability'], ...$data['additional_availability']] as $location) {
$key = json_encode(array_map(fn ($part) => mb_strtolower(trim($location[$part])), ['province', 'district', 'locality']), JSON_THROW_ON_ERROR);
@@ -99,7 +103,7 @@ class CandidateProfiles
throw ValidationException::withMessages(['version' => 'O perfil mudou. Actualize e confira antes de guardar.']);
}
$id = DB::table('candidate_profile_versions')->insertGetId(['tenant_id' => $account->tenant_id, 'candidate_account_id' => $account->id,
'version' => $previous['version'] + 1, 'data' => json_encode(array_intersect_key($data, array_flip(['name', 'phone', 'summary', 'availability', 'additional_availability'])), JSON_THROW_ON_ERROR),
'version' => $previous['version'] + 1, 'data' => json_encode(array_intersect_key($data, array_flip(['name', 'phone', 'summary', 'availability', 'additional_availability', 'availability_reference', 'additional_availability_references'])), JSON_THROW_ON_ERROR),
'reason' => $data['reason'], 'created_at' => now()]);
$this->event($account, 'profile.version_created', ['profile_version_id' => $id, 'version' => $previous['version'] + 1]);
});
+39
View File
@@ -0,0 +1,39 @@
<?php
namespace App\Services;
use Illuminate\Database\Connection;
use Illuminate\Database\Query\Builder;
class CandidateTerritory
{
/** Filter only immutable received snapshots; never consult the current candidate profile. */
public function apply(Builder $query, string $location): void
{
$geography = app(AdministrativeGeography::class);
abort_unless($geography->enabled(), 503);
$ids = $geography->descendants($location);
$edition = $geography->catalogue()['manifest']['source_sha256'];
$connection = $query->getConnection();
abort_unless($connection instanceof Connection, 503);
$driver = $connection->getDriverName();
abort_unless(in_array($driver, ['sqlite', 'pgsql'], true), 503, 'Filtro territorial ainda não disponível nesta base.');
$parameters = implode(',', array_fill(0, count($ids), '?'));
if ($driver === 'pgsql') {
$source = "candidate_submissions.snapshot::jsonb #> '{profile,data,additional_availability_references}'";
$array = "CASE WHEN jsonb_typeof($source) = 'array' THEN $source ELSE '[]'::jsonb END";
$additional = "EXISTS (SELECT 1 FROM jsonb_array_elements($array) AS territory(value) WHERE territory.value->>'catalogue' = ? AND territory.value->>'country' = 'MZ' AND territory.value->>'record_id' IN ($parameters))";
} else {
$source = "json_extract(candidate_submissions.snapshot, '$.profile.data.additional_availability_references')";
$array = "CASE WHEN json_type(candidate_submissions.snapshot, '$.profile.data.additional_availability_references') = 'array' THEN $source ELSE '[]' END";
$object = "CASE WHEN territory.type = 'object' THEN territory.value ELSE '{}' END";
$additional = "EXISTS (SELECT 1 FROM json_each($array) AS territory WHERE json_extract($object, '$.catalogue') = ? AND json_extract($object, '$.country') = 'MZ' AND json_extract($object, '$.record_id') IN ($parameters))";
}
$query->where(function (Builder $group) use ($ids, $edition, $additional) {
$group->where(fn (Builder $main) => $main->where('candidate_submissions.snapshot->profile->data->availability_reference->catalogue', $edition)
->where('candidate_submissions.snapshot->profile->data->availability_reference->country', 'MZ')
->whereIn('candidate_submissions.snapshot->profile->data->availability_reference->record_id', $ids))
->orWhereRaw($additional, [$edition, ...$ids]);
});
}
}
@@ -0,0 +1,49 @@
<?php
namespace App\Services;
use App\Models\Equipment;
use App\Models\User;
use Illuminate\Contracts\Pagination\LengthAwarePaginator;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
class EquipmentWarehouseRequests
{
/** Read-only projection; consumers must not insert rows into the paginator.
* @return LengthAwarePaginator<int,covariant array<string,mixed>>|null
*/
public function page(User $actor, Equipment $equipment): ?LengthAwarePaginator
{
$canRead = $actor->hasFunctions(['admin', 'warehouse_request_read', 'warehouse_request_prepare'])
|| ($actor->hasFunctions(['warehouse_request_review']) && $actor->department_id !== null)
|| ($actor->hasFunctions(['warehouse_request_deliver']) && $actor->hasFunctions(['warehouse']));
if (! $canRead || ! Schema::hasTable('warehouse_requests')) {
return null;
}
$query = app(WarehouseWorkdesk::class)->visible($actor);
if (DB::getDriverName() === 'pgsql') {
$query->whereRaw("EXISTS (SELECT 1 FROM json_array_elements(warehouse_requests.snapshot->'lines') AS line(value) WHERE line.value->'equipment'->>'id' = ?)", [(string) $equipment->id]);
} elseif (DB::getDriverName() === 'sqlite') {
$query->whereRaw("EXISTS (SELECT 1 FROM json_each(json_extract(warehouse_requests.snapshot, '$.lines')) AS line WHERE json_extract(line.value, '$.equipment.id') = ?)", [$equipment->id]);
} else {
return null;
}
return $query->oldest('id')->paginate(15, ['id', 'snapshot'], 'requests_page')->withQueryString()->through(function ($record) use ($equipment) {
$p = app(WarehouseFulfilment::class)->progress($record);
$lines = [];
foreach ($record->snapshot['lines'] as $index => $line) {
if (($line['equipment']['id'] ?? null) !== $equipment->id) {
continue;
}
$lines[] = ['line' => $index + 1, 'item' => $line['item'], 'destination' => $line['destination'],
'requested_milli' => $line['quantity_milli'], 'reserved_milli' => $p['reserved'][$index],
'delivered_milli' => $p['delivered'][$index], 'remaining_milli' => $p['remaining'][$index], 'cancelled_milli' => $p['cancelled'][$index]];
}
return ['id' => $record->id, 'state' => $p['state'], 'version' => $p['version'],
'reservation_ready' => $p['reservation_ready'], 'lines' => $lines];
});
}
}
+1
View File
@@ -101,6 +101,7 @@ class InvoiceWorkflow
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Finance]);
$this->access($user);
$order = PurchaseOrder::query()->lockForUpdate()->findOrFail($order->id);
app(OrderCancellationWorkflow::class)->assertOperational($order);
$request = Requisition::query()->findOrFail($order->requisition_id);
app(ConflictGuard::class)->assertProcess($request, $order->supplier_id, $user);
$number = Str::upper(Str::squish($data['number']));
+37
View File
@@ -0,0 +1,37 @@
<?php
namespace App\Services;
use LogicException;
use Throwable;
/** Read-only composition of existing technical inspections; never runs recovery or repairs. */
class OperationalHealth
{
/** @return array<string,mixed> */
public function inspect(int $documentLimit = 1000): array
{
abort_unless(app()->runningInConsole() && ! auth()->check() && ! request()->hasSession(), 403);
if ($documentLimit < 1 || $documentLimit > 10000) {
throw new LogicException('Limite fora do intervalo permitido.');
}
$checks = [];
$startedAt = now()->toIso8601String();
foreach (['replenishment' => fn () => app(ReplenishmentQueue::class)->health(),
'receipt_documents' => fn () => app(ReceiptDocumentHealth::class)->inspect($documentLimit)] as $key => $read) {
try {
$result = $read();
$complete = $result['complete'] ?? true;
$checks[$key] = ['status' => ! $complete ? 'incomplete' : ($result['ok'] ? 'passed' : 'attention'), 'result' => $result];
} catch (Throwable $error) {
report($error);
$checks[$key] = ['status' => 'unavailable', 'result' => ['checked_at' => now()->toIso8601String(), 'ok' => false, 'complete' => false, 'reasons' => ['unavailable']]];
}
}
return ['schema_version' => 1, 'started_at' => $startedAt, 'checked_at' => now()->toIso8601String(),
'ok' => collect($checks)->every(fn ($check) => $check['status'] === 'passed'),
'complete' => collect($checks)->every(fn ($check) => in_array($check['status'], ['passed', 'attention'], true)),
'checks' => $checks];
}
}
@@ -0,0 +1,73 @@
<?php
namespace App\Services;
use App\Models\PurchaseControlPolicy;
use App\Models\PurchaseControlReview;
use App\Models\User;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\Schema;
class OrderCancellationPolicyWorkflow extends PurchaseControlPolicyWorkflow
{
public function canReview(User $actor, PurchaseControlPolicy $policy): bool
{
return (bool) config('order_cancellation.enabled') && $actor->tenant_id === $policy->tenant_id && $actor->hasFunctions(['admin'])
&& ! app(OrganizationAccess::class)->maintenanceOnly($actor) && $policy->getTable() === 'order_cancellation_policies'
&& $policy->status === 'pending' && $policy->created_by !== $actor->id && $policy->revision === $this->policies()->max('revision')
&& ! $this->reviews()->where('purchase_control_policy_id', $policy->id)->where('reviewed_by', $actor->id)->exists();
}
/** @return Builder<PurchaseControlPolicy> */
protected function policies(): Builder
{
return (new PurchaseControlPolicy)->setTable('order_cancellation_policies')->newQuery();
}
/** @return Builder<PurchaseControlReview> */
protected function reviews(): Builder
{
return (new PurchaseControlReview)->setTable('order_cancellation_policy_reviews')->newQuery();
}
protected function mode(): string
{
return 'issued_order';
}
protected function auditPrefix(): string
{
return 'order_cancellation_policy';
}
private function enabled(): void
{
abort_unless(config('order_cancellation.enabled') && Schema::hasTable('order_cancellation_policies'), 503, 'Cancelamento de ordens não activado.');
}
public function propose(User $user, array $data): PurchaseControlPolicy
{
$this->enabled();
abort_if(app(OrganizationAccess::class)->maintenanceOnly($user), 403);
validator($data, ['previous_id' => 'required|integer|min:0', 'mode' => 'required|in:issued_order', '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'])->validate();
return parent::propose($user, $data);
}
public function review(User $user, PurchaseControlPolicy $policy, string $decision, string $reason): void
{
$this->enabled();
abort_if(app(OrganizationAccess::class)->maintenanceOnly($user), 403);
parent::review($user, $policy, $decision, $reason);
}
public function requireCurrent(): PurchaseControlPolicy
{
$this->enabled();
$policy = $this->current();
abort_unless($policy && $policy->enabled && $policy->mode === 'issued_order' && $policy->valid_until >= today()->format('Y-m-d'), 422, 'É necessária política vigente de cancelamento de ordens, com duas aprovações administrativas independentes.');
return $policy;
}
}
+199
View File
@@ -0,0 +1,199 @@
<?php
namespace App\Services;
use App\Enums\PurchasingRole;
use App\Models\GoodsReceipt;
use App\Models\Invoice;
use App\Models\OrderCancellation;
use App\Models\PurchaseAward;
use App\Models\PurchaseOrder;
use App\Models\Requisition;
use App\Models\User;
use Brick\Math\BigDecimal;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use Illuminate\Validation\ValidationException;
use Tempo\Finance\Budget\BudgetContext;
use Tempo\Finance\OrderCancellation\CommitmentReversal;
class OrderCancellationWorkflow
{
public function canRevise(User $actor, OrderCancellation $record): bool
{
if (! config('order_cancellation.enabled') || $record->tenant_id !== $actor->tenant_id || $record->status !== 'approved' || $record->revised_requisition_id
|| app(OrganizationAccess::class)->maintenanceOnly($actor) || ! app(OrganizationAccess::class)->canRequest($actor)) {
return false;
}
$order = PurchaseOrder::query()->visibleTo($actor)->find($record->purchase_order_id);
return $order && Requisition::query()->whereKey($order->requisition_id)->where('requester_id', $actor->id)->where('department_id', $actor->department_id)->exists();
}
public function canRequest(User $actor, PurchaseOrder $order): bool
{
if (! config('order_cancellation.enabled') || ! Schema::hasTable('order_cancellations') || ! $actor->hasFunctions([PurchasingRole::Procurement])
|| app(OrganizationAccess::class)->maintenanceOnly($actor) || $actor->tenant_id !== $order->tenant_id || $this->state($order) !== 'issued') {
return false;
}
$request = Requisition::query()->visibleTo($actor)->find($order->requisition_id);
$policy = app(OrderCancellationPolicyWorkflow::class)->current();
return $request && $request->requester_id !== $actor->id && $policy && $policy->enabled && $policy->mode === 'issued_order'
&& $policy->valid_until >= today()->format('Y-m-d')
&& ! GoodsReceipt::query()->where('purchase_order_id', $order->id)->exists() && ! Invoice::query()->where('purchase_order_id', $order->id)->exists()
&& ! app(ConflictGuard::class)->processBlocked($request, $order->supplier_id, $actor);
}
public function canDecide(User $actor, OrderCancellation $record): bool
{
if (! config('order_cancellation.enabled') || $record->tenant_id !== $actor->tenant_id || $record->status !== 'pending' || ! $actor->hasFunctions([PurchasingRole::Finance]) || app(OrganizationAccess::class)->maintenanceOnly($actor)) {
return false;
}
$order = PurchaseOrder::query()->visibleTo($actor)->find($record->purchase_order_id);
$request = $order ? Requisition::query()->find($order->requisition_id) : null;
$award = $order ? PurchaseAward::query()->find($order->purchase_award_id) : null;
return $order && $request && $award && ! in_array($actor->id, [$record->created_by, $request->requester_id, $award->created_by, $order->issued_by], true);
}
private function enabled(): void
{
abort_unless(config('order_cancellation.enabled') && Schema::hasTable('order_cancellations'), 503, 'Cancelamento de ordens não activado.');
}
public function state(PurchaseOrder $order): string
{
if (! Schema::hasTable('order_cancellations')) {
return $order->status;
}
$states = OrderCancellation::query()->where('purchase_order_id', $order->id)->pluck('status');
return $states->contains('approved') ? 'cancelled' : ($states->contains('pending') ? 'cancellation_pending' : $order->status);
}
/** Holds survive disabling the feature; hiding a command must not unblock an order. */
public function assertOperational(PurchaseOrder $order): void
{
if (in_array($this->state($order), ['cancelled', 'cancellation_pending'], true)) {
throw ValidationException::withMessages(['order' => 'Ordem cancelada ou com pedido de cancelamento pendente. Não é permitida nova execução.']);
}
}
private function source(PurchaseOrder $order): void
{
if ($order->getRawOriginal('status') !== 'issued' || $order->currency !== 'MZN' || GoodsReceipt::query()->where('purchase_order_id', $order->id)->exists()
|| Invoice::query()->where('purchase_order_id', $order->id)->exists()) {
throw ValidationException::withMessages(['order' => 'Este circuito exige ordem emitida em MZN sem qualquer recepção, factura ou pagamento.']);
}
}
private function basis(PurchaseOrder $order): string
{
return hash('sha256', json_encode(['order' => $order->getAttributes(), 'items' => $order->items()->orderBy('id')->get()->toArray(),
'budget' => DB::table('budget_entries')->where('tenant_id', $order->tenant_id)->where('requisition_id', $order->requisition_id)->orderBy('id')->get()->toArray()], JSON_THROW_ON_ERROR));
}
/** @param array<string,mixed> $input */
public function request(User $actor, PurchaseOrder $order, array $input): OrderCancellation
{
$this->enabled();
$data = validator($input, ['operation_key' => 'required|uuid', 'reason' => 'required|string|min:10|max:4000', 'evidence' => 'required|string|min:10|max:4000'])->validate();
$data['operation_key'] = strtolower($data['operation_key']);
$hash = hash('sha256', json_encode([$order->id, $data], JSON_THROW_ON_ERROR));
return DB::transaction(function () use ($actor, $order, $data, $hash) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Procurement]);
abort_if(app(OrganizationAccess::class)->maintenanceOnly($actor), 403);
$order = PurchaseOrder::query()->visibleTo($actor)->lockForUpdate()->findOrFail($order->id);
$request = Requisition::query()->lockForUpdate()->findOrFail($order->requisition_id);
abort_if($actor->id === $request->requester_id, 403);
app(ConflictGuard::class)->assertProcess($request, $order->supplier_id, $actor);
$old = OrderCancellation::query()->where('created_by', $actor->id)->where('operation_key', $data['operation_key'])->first();
if ($old) {
abort_unless($old->input_hash === $hash, 422, 'Chave utilizada com outro conteúdo.');
return $old;
}
$this->assertOperational($order);
$this->source($order);
$policy = app(OrderCancellationPolicyWorkflow::class)->requireCurrent();
$record = OrderCancellation::query()->create(['tenant_id' => $actor->tenant_id, 'purchase_order_id' => $order->id, 'policy_id' => $policy->id,
'created_by' => $actor->id, ...$data, 'input_hash' => $hash, 'basis_hash' => $this->basis($order),
'snapshot' => ['order_number' => $order->number, 'policy' => $policy->toArray(), 'original_order_status' => $order->status]]);
app(RequisitionWorkflow::class)->audit($actor, 'order_cancellation.requested', $request, null, ['cancellation_id' => $record->id, 'order_id' => $order->id]);
return $record;
});
}
public function decide(User $actor, OrderCancellation $record, string $decision, string $reason): void
{
$this->enabled();
validator(['decision' => $decision, 'reason' => $reason], ['decision' => 'required|in:approved,rejected', 'reason' => 'required|string|min:10|max:4000'])->validate();
DB::transaction(function () use ($actor, $record, $decision, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor, [PurchasingRole::Finance]);
abort_if(app(OrganizationAccess::class)->maintenanceOnly($actor), 403);
$record = OrderCancellation::query()->lockForUpdate()->findOrFail($record->id);
$order = PurchaseOrder::query()->visibleTo($actor)->lockForUpdate()->findOrFail($record->purchase_order_id);
$request = Requisition::query()->lockForUpdate()->findOrFail($order->requisition_id);
$award = PurchaseAward::query()->findOrFail($order->purchase_award_id);
abort_if(in_array($actor->id, [$record->created_by, $request->requester_id, $award->created_by, $order->issued_by], true), 403);
app(ConflictGuard::class)->assertProcess($request, $order->supplier_id, $actor);
if ($record->status !== 'pending') {
abort_unless($record->status === $decision && $record->review_reason === $reason && $record->reviewed_by === $actor->id, 409, 'Decisão imutável.');
return;
}
$entry = null;
if ($decision === 'approved') {
$this->source($order);
abort_unless($record->basis_hash === $this->basis($order), 409, 'A base da ordem ou do compromisso mudou.');
$policy = app(OrderCancellationPolicyWorkflow::class)->requireCurrent();
abort_unless($policy->id === $record->policy_id, 409, 'Política alterada; rejeite o pedido para retomar o circuito.');
abort_unless(DB::table('tenants')->where('id', $actor->tenant_id)->value('currency') === 'MZN', 422);
if (! empty($order->snapshot['budget_control']) && ! DB::table('budget_entries')->where('tenant_id', $actor->tenant_id)->where('requisition_id', $request->id)->exists()) {
throw ValidationException::withMessages(['budget' => 'A ordem indica controlo orçamental, mas o compromisso não está disponível.']);
}
$path = base_path('packages/order-cancellation/src/CommitmentReversal.php');
abort_unless(is_file($path) && hash_file('sha256', $path) === config('order_cancellation.reversal_sha256'), 503, 'Capacidade de reversão indisponível.');
require_once $path;
try {
$entry = (new CommitmentReversal)->reverse(DB::connection(), new BudgetContext($actor->id, ['tenant_id' => (int) $actor->tenant_id], (int) now()->year, 'MZN'), $request->id, $order->id);
} catch (\LogicException $error) {
throw ValidationException::withMessages(['budget' => 'O compromisso não está integralmente disponível para reversão ou a sua base é inconsistente. Reveja o controlo orçamental.']);
}
$request->update(['status' => 'cancelled']);
}
$record->update(['status' => $decision, 'reviewed_by' => $actor->id, 'review_reason' => $reason, 'reviewed_at' => now()]);
app(RequisitionWorkflow::class)->audit($actor, 'order_cancellation.'.$decision, $request, null, ['cancellation_id' => $record->id, 'order_id' => $order->id, 'budget_reversal_entry_id' => $entry]);
});
}
public function revise(User $actor, OrderCancellation $record, string $neededBy, string $reason): Requisition
{
$this->enabled();
validator(['needed_by' => $neededBy, 'reason' => $reason], ['needed_by' => 'required|date_format:Y-m-d|after_or_equal:today', 'reason' => 'required|string|min:10|max:4000'])->validate();
return DB::transaction(function () use ($actor, $record, $neededBy, $reason) {
app(ConflictGuard::class)->lockCompany($actor);
$actor = app(CurrentActor::class)->lock($actor);
abort_if(app(OrganizationAccess::class)->maintenanceOnly($actor), 403);
$record = OrderCancellation::query()->lockForUpdate()->findOrFail($record->id);
$order = PurchaseOrder::query()->findOrFail($record->purchase_order_id);
$source = Requisition::query()->lockForUpdate()->findOrFail($order->requisition_id);
abort_unless($actor->id === $source->requester_id && $actor->department_id === $source->department_id && $record->status === 'approved', 403);
if ($record->revised_requisition_id) {
return Requisition::query()->findOrFail($record->revised_requisition_id);
}
$items = $source->items()->get()->map(fn ($item) => [...$item->only(['description', 'category', 'purchase_type', 'quantity', 'unit', 'tax_rate', 'production_area', 'equipment_id', 'spare_part_id']), 'unit_price' => BigDecimal::of($item->unit_price_minor)->dividedBy(100, 2)->__toString()])->all();
$revised = app(RequisitionWorkflow::class)->save($actor, ['cost_center_id' => $source->cost_center_id, 'priority' => $source->priority, 'needed_by' => $neededBy, 'justification' => $reason, 'items' => $items]);
$record->update(['revised_requisition_id' => $revised->id]);
app(RequisitionWorkflow::class)->audit($actor, 'order_cancellation.revision_created', $revised, null, ['source_requisition_id' => $source->id, 'cancellation_id' => $record->id]);
return $revised;
});
}
}
+1
View File
@@ -10,6 +10,7 @@ use Illuminate\Support\Facades\Schema;
class OrganizationAccess
{
public const PERMISSIONS = [
'audit_metadata_read' => 'Consultar e exportar metadados de eventos de todos os módulos da empresa, sem conteúdos privados',
'warehouse_return_read' => 'Consultar devoluções de excedentes de entregas internas',
'warehouse_return_prepare' => 'Declarar excedente não consumido de entrega interna própria',
'warehouse_return_confirm' => 'Conferir ou recusar recepção independente do excedente no armazém (exige função de armazém)',
+37
View File
@@ -0,0 +1,37 @@
<?php
namespace App\Services;
use App\Models\PeopleProcess;
use App\Models\User;
/** One permission-aware projection shared by consultation and portable process dossiers. */
class PeopleProcessProjection
{
/** @return array{process:array<string,mixed>,candidates:list<array<string,mixed>>} */
public function read(User $actor, PeopleProcess $record): array
{
$access = app(PeopleAccess::class);
abort_unless($access->can($actor, $record, 'view'), 403);
$workflow = app(PeopleHiring::class);
$snapshot = $workflow->snapshot($record);
$rows = $workflow->matrix($record);
if (! $access->can($actor, $record, 'financial')) {
unset($snapshot['rules']['annex']['fields']['financial']);
unset($snapshot['selection']['rules']['annex']['fields']['financial']);
}
if (! $access->can($actor, $record, 'interviews')) {
$rows = array_map(fn ($row) => [...$row, 'reviews' => []], $rows);
if (isset($snapshot['selection']['rows'])) {
$snapshot['selection']['rows'] = array_map(fn ($row) => [...$row, 'reviews' => []], $snapshot['selection']['rows']);
}
}
if (! $access->can($actor, $record, 'contract') && ! $access->can($actor, $record, 'contract_view')) {
$snapshot['contract'] = null;
}
$rows = app(ReceivedCandidateAvailability::class)->attach($actor, $record, $rows);
return ['process' => $snapshot, 'candidates' => $rows];
}
}
+37 -13
View File
@@ -6,11 +6,34 @@ use App\Enums\PurchasingRole;
use App\Models\PurchaseControlPolicy;
use App\Models\PurchaseControlReview;
use App\Models\User;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
class PurchaseControlPolicyWorkflow
{
/** @return Builder<PurchaseControlPolicy> */
protected function policies(): Builder
{
return PurchaseControlPolicy::query();
}
/** @return Builder<PurchaseControlReview> */
protected function reviews(): Builder
{
return PurchaseControlReview::query();
}
protected function mode(): string
{
return 'unissued_award';
}
protected function auditPrefix(): string
{
return 'purchase_control';
}
private function admin(User $user): void
{
abort_unless(auth()->id() === $user->id && $user->tenant_id !== null && $user->hasFunctions([PurchasingRole::Admin]), 403);
@@ -25,12 +48,12 @@ class PurchaseControlPolicyWorkflow
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') {
$latest = $this->policies()->latest('revision')->first();
if ((int) $data['previous_id'] !== ($latest->id ?? 0) || $data['mode'] !== $this->mode()) {
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());
$policy = $this->policies()->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, $this->auditPrefix().'.proposed', null, null, $policy->toArray());
return $policy;
});
@@ -39,6 +62,7 @@ class PurchaseControlPolicyWorkflow
public function review(User $user, PurchaseControlPolicy $policy, string $decision, string $reason): void
{
$this->admin($user);
abort_unless($policy->getTable() === $this->policies()->getModel()->getTable(), 403);
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.']);
@@ -47,8 +71,8 @@ class PurchaseControlPolicyWorkflow
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();
$policy = $this->policies()->lockForUpdate()->findOrFail($policy->id);
$existing = $this->reviews()->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.']);
@@ -56,35 +80,35 @@ class PurchaseControlPolicyWorkflow
return;
}
if ($policy->status !== 'pending' || PurchaseControlPolicy::query()->max('revision') !== $policy->revision) {
if ($policy->status !== 'pending' || $this->policies()->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();
$ids = $this->reviews()->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->hasFunctions([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()]);
$this->reviews()->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) {
} elseif ($this->reviews()->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]);
app(RequisitionWorkflow::class)->audit($user, $this->auditPrefix().'.'.$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();
return $this->policies()->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) {
if (! $policy || $policy->valid_until < today()->format('Y-m-d') || $policy->mode !== $this->mode() || ! $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.']);
}
+2
View File
@@ -123,6 +123,8 @@ class PurchaseWorkflow
// An already committed issue is returned, never re-created or re-snapshotted.
$existing = PurchaseOrder::query()->where('requisition_id', $requisition->id)->first();
if ($existing) {
app(OrderCancellationWorkflow::class)->assertOperational($existing);
return $existing;
}
$this->assertNoPendingCancellation($award);
+98
View File
@@ -0,0 +1,98 @@
<?php
namespace App\Services;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Facades\Storage;
use LogicException;
/** Global technical inspection, with aggregate output only. Never repairs or removes files. */
class ReceiptDocumentHealth
{
/** @return array<string,mixed> */
public function inspect(int $limit = 1000): array
{
abort_unless(app()->runningInConsole() && ! auth()->check(), 403, 'Verificação reservada à operação técnica.');
if ($limit < 1 || $limit > 10000) {
throw new LogicException('Limite fora do intervalo permitido.');
}
$result = ['checked_at' => now()->toIso8601String(), 'ok' => false, 'complete' => false, 'reasons' => [],
'documents_checked' => 0, 'files_checked' => 0, 'missing' => 0, 'invalid_reference' => 0, 'altered' => 0,
'unreferenced_recent' => 0, 'unreferenced_older' => 0];
if (! Schema::hasTable('receipt_documents')) {
return [...$result, 'reasons' => ['not_installed']];
}
return DB::transaction(function () use ($limit, $result) {
if (DB::getDriverName() === 'pgsql' && DB::transactionLevel() === 1) {
DB::statement('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY');
}
$disk = Storage::disk('receipt_documents');
$root = realpath($disk->path(''));
if ($root === false) {
return [...$result, 'reasons' => ['storage_unavailable']];
}
$records = DB::table('receipt_documents')->orderBy('id')->limit($limit + 1)->get();
$limited = $records->count() > $limit;
foreach ($records->take($limit) as $document) {
$result['documents_checked']++;
$prefix = $document->tenant_id.'/'.$document->goods_receipt_id.'/';
$name = substr($document->path, strlen($prefix));
if (! str_starts_with($document->path, $prefix) || ! preg_match('/\A[A-Za-z0-9_-]+\.[A-Za-z0-9]+\z/D', $name)
|| ! DB::table('goods_receipts')->where('id', $document->goods_receipt_id)->where('tenant_id', $document->tenant_id)->exists()) {
$result['invalid_reference']++;
continue;
}
$path = realpath($disk->path($document->path));
if ($path === false || ! is_file($path)) {
$result['missing']++;
continue;
}
$normalizedPath = str_replace('\\', '/', $path);
$normalizedRoot = str_replace('\\', '/', $root).'/';
$withinRoot = PHP_OS_FAMILY === 'Windows'
? str_starts_with(strtolower($normalizedPath), strtolower($normalizedRoot))
: str_starts_with($normalizedPath, $normalizedRoot);
if (! $withinRoot) {
$result['invalid_reference']++;
continue;
}
$size = filesize($path);
if ($size !== (int) $document->size || $size < 1 || $size > 2097152 || hash_file('sha256', $path) !== $document->sha256) {
$result['altered']++;
}
}
// Lazy listing and an independent ceiling also bound unreferenced-file inspection.
foreach ($disk->getDriver()->listContents('', true) as $entry) {
if (! $entry->isFile()) {
continue;
}
if ($result['files_checked'] >= $limit) {
$limited = true;
break;
}
$result['files_checked']++;
if (! DB::table('receipt_documents')->where('path', $entry->path())->exists()) {
$age = now()->getTimestamp() - $disk->lastModified($entry->path());
$result[$age >= 3600 ? 'unreferenced_older' : 'unreferenced_recent']++;
}
}
$result['complete'] = ! $limited;
foreach (['missing', 'invalid_reference', 'altered', 'unreferenced_recent', 'unreferenced_older'] as $reason) {
if ($result[$reason] > 0) {
$result['reasons'][] = $reason;
}
}
if ($limited) {
$result['reasons'][] = 'limit_reached';
}
$result['ok'] = $result['reasons'] === [];
return $result;
});
}
}
+6 -1
View File
@@ -77,6 +77,7 @@ class ReceiptWorkflow
$this->conflicts->lockCompany($user);
$user = app(CurrentActor::class)->lock($user, [PurchasingRole::Warehouse]);
$order = PurchaseOrder::query()->lockForUpdate()->findOrFail($order->id);
app(OrderCancellationWorkflow::class)->assertOperational($order);
Gate::forUser($user)->authorize('create', [GoodsReceipt::class, $order]);
$deliveryNote = Str::squish(Str::upper($data['delivery_note']));
if ($deliveryNote === '') {
@@ -219,7 +220,11 @@ class ReceiptWorkflow
$writer = app(ReceiptStockMovement::class)->for($user);
$basis = $writer->preview($item->id);
$result = $writer->write($item->id, $basis['source_hash']);
$movement = StockMovement::query()->findOrFail($result['movement_id']);
$movementId = $result['movement_id'] ?? null;
if (! is_int($movementId)) {
throw new \LogicException('Resposta inválida do escritor de stock da recepção.');
}
$movement = StockMovement::query()->findOrFail($movementId);
$sourceInput = collect($inputs)->firstWhere('purchase_order_item_id', $line['purchase_order_item_id']);
app(InventoryLots::class)->receive($user, $movement, $sourceInput['lots'] ?? [], $data['received_on']);
app(AutomaticPurchases::class)->signal($user, $line['stock_item_id'], $warehouse->id);
@@ -0,0 +1,80 @@
<?php
namespace App\Services;
use App\Models\PeopleProcess;
use App\Models\User;
use Illuminate\Database\Query\JoinClause;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
class ReceivedCandidateAvailability
{
/** Add received availability only to the authorized read projection, never to decision matrices.
* @param list<array<string,mixed>> $rows
* @return list<array<string,mixed>>
*/
public function attach(User $actor, PeopleProcess $record, array $rows): array
{
if ($rows === [] || ! Schema::hasTable('candidate_triage') || ! Schema::hasTable('candidate_submissions')) {
return $rows;
}
$current = User::query()->where('tenant_id', $record->tenant_id)->whereKey($actor->id)->first();
if ($current === null || ! app(CandidateTriage::class)->canRead($current, $record)) {
return $rows;
}
$sources = DB::table('candidate_triage as t')->join('candidate_submissions as s', function (JoinClause $join) {
$join->on('s.id', '=', 't.candidate_submission_id')->on('s.tenant_id', '=', 't.tenant_id')->on('s.people_process_id', '=', 't.people_process_id');
})->where('t.tenant_id', $record->tenant_id)->where('t.people_process_id', $record->id)->where('t.outcome', 'accepted_for_analysis')
->whereIn('t.people_application_id', array_column($rows, 'id'))
->get(['t.people_application_id', 't.profile_version', 's.id', 's.reference', 's.snapshot'])->keyBy('people_application_id');
return array_map(function (array $row) use ($sources) {
$source = $sources->get($row['id']);
if ($source === null) {
return $row;
}
$snapshot = json_decode($source->snapshot, true, 32, JSON_THROW_ON_ERROR);
$data = $snapshot['profile']['data'] ?? [];
$main = $this->location($data['availability'] ?? null);
if ($main === null || ($snapshot['profile']['version'] ?? null) !== $source->profile_version) {
return $row;
}
$additional = [];
$references = [];
foreach ($data['additional_availability'] ?? [] as $index => $location) {
$value = $this->location($location);
if ($value !== null) {
$additional[] = $value;
$references[] = $this->reference($data['additional_availability_references'][$index] ?? null);
}
}
return [...$row, 'received_availability' => ['submission_id' => $source->id, 'reference' => $source->reference, 'profile_version' => $source->profile_version,
'availability' => $main, 'additional_availability' => $additional,
'availability_reference' => $this->reference($data['availability_reference'] ?? null), 'additional_availability_references' => $references]];
}, $rows);
}
/** @return array{province:string,district:string,locality:string}|null */
private function location(mixed $value): ?array
{
if (! is_array($value) || ! is_string($value['province'] ?? null) || ! is_string($value['district'] ?? null) || ! is_string($value['locality'] ?? null)
|| trim($value['province']) === '' || trim($value['district']) === '' || trim($value['locality']) === '') {
return null;
}
return ['province' => $value['province'], 'district' => $value['district'], 'locality' => $value['locality']];
}
/** @return array{country:string,catalogue:string,record_id:string}|null */
private function reference(mixed $value): ?array
{
if (! is_array($value) || ($value['country'] ?? null) !== 'MZ' || ! is_string($value['catalogue'] ?? null) || ! preg_match('/^[a-f0-9]{64}$/D', $value['catalogue'])
|| ! is_string($value['record_id'] ?? null) || ! preg_match('/^[0-9]{1,20}$/D', $value['record_id'])) {
return null;
}
return ['country' => 'MZ', 'catalogue' => $value['catalogue'], 'record_id' => $value['record_id']];
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Services;
use App\Models\Supplier;
use Illuminate\Database\Eloquent\Builder;
class SupplierGeography
{
/** Current supplier registration only; never infer geography from address text or evaluation snapshots.
* @return Builder<Supplier>
*/
public function matching(string $location): Builder
{
$geography = app(AdministrativeGeography::class);
abort_unless($geography->enabled(), 503);
return Supplier::query()->where('geography_reference->country', 'MZ')
->where('geography_reference->catalogue', $geography->catalogue()['manifest']['source_sha256'])
->whereIn('geography_reference->record_id', $geography->descendants($location));
}
}
+2
View File
@@ -104,6 +104,7 @@ class SupplyCoordination
if ($kind === 'delivery') {
$line = PurchaseOrderItem::query()->whereKey($data['purchase_order_item_id'])->firstOrFail();
$order = PurchaseOrder::query()->whereKey($line->purchase_order_id)->firstOrFail();
app(OrderCancellationWorkflow::class)->assertOperational($order);
$snapshot['order'] = $order->only(['id', 'number']);
$snapshot['order_line'] = $line->only(['id', 'quantity', 'unit', 'description']);
}
@@ -204,6 +205,7 @@ class SupplyCoordination
if ($kind === 'delivery') {
$line = PurchaseOrderItem::query()->whereKey($data['purchase_order_item_id'])->firstOrFail();
$order = PurchaseOrder::query()->whereKey($line->purchase_order_id)->firstOrFail();
app(OrderCancellationWorkflow::class)->assertOperational($order);
$stock = StockItem::query()->whereKey($data['stock_item_id'])->firstOrFail();
$linked = $order->snapshot['catalogue_sources'][$line->requisition_item_id]['stock_item_id'] ?? null;
$this->require($order->status === 'issued' && $line->unit === $stock->unit && ($linked === null || $linked === $stock->id), 'data.stock_item_id', 'A confirmação deve respeitar o artigo e unidade da ordem emitida.');
+3
View File
@@ -153,6 +153,9 @@ class SupplyPlanning
$warehouse = isset($data['warehouse_id']) ? Warehouse::query()->whereKey($data['warehouse_id'])->firstOrFail() : null;
$supplier = isset($data['supplier_id']) ? Supplier::query()->whereKey($data['supplier_id'])->lockForUpdate()->firstOrFail() : null;
$order = isset($data['purchase_order_id']) ? PurchaseOrder::query()->whereKey($data['purchase_order_id'])->firstOrFail() : null;
if ($order !== null) {
app(OrderCancellationWorkflow::class)->assertOperational($order);
}
if ($kind === 'agreement' && $state === 'approved') {
$this->check($supplier !== null && $supplier->eligible(), 'supplier_id', 'O fornecedor deve estar activo e com revisão documental vigente.');
$this->check(! app(ConflictGuard::class)->hasConflict($actor->id, $supplier->id, null), 'supplier_id', 'Existe conflito declarado com este fornecedor.');
+21
View File
@@ -15,6 +15,27 @@ use Illuminate\Support\Facades\Schema;
/** Read-only workdesk over the existing request, event and reservation journals. */
class WarehouseWorkdesk
{
/** @param array<string,mixed> $filters
* @return Builder<WarehouseRequest>
*/
public function filteredBase(User $actor, array $filters): Builder
{
$base = $this->visible($actor);
if (! empty($filters['warehouse_id'])) {
$base->where('warehouse_id', $filters['warehouse_id']);
}
if (! empty($filters['search'])) {
$search = trim($filters['search']);
if (preg_match('/^(?:RA-)?([1-9][0-9]{0,9})$/iD', $search, $match)) {
$base->whereKey($match[1]);
} else {
$base->where(fn ($q) => $q->whereLike('snapshot->requester->name', '%'.$search.'%')->orWhereLike('snapshot->destination', '%'.$search.'%'));
}
}
return $base;
}
public function canView(User $actor, WarehouseRequest $request): bool
{
return $actor->tenant_id === $request->tenant_id && (
+25
View File
@@ -5,6 +5,8 @@ namespace App\Services;
use App\Models\AdmissionDecision;
use App\Models\ExternalPayment;
use App\Models\Invoice;
use App\Models\OrderCancellation;
use App\Models\OrderCancellationPolicy;
use App\Models\PeopleProcess;
use App\Models\PurchaseAward;
use App\Models\QualificationAssessment;
@@ -35,6 +37,29 @@ class WorkflowTaskInbox
$rows = $area === 'people' ? $this->people($actor) : [...$this->purchases($actor), ...$this->suppliers($actor), ...$this->quotations($actor), ...$this->documentary($actor), ...$this->formalReviews($actor), ...$this->supply($actor), ...$this->suggestions($actor), ...$this->awards($actor), ...$this->warehouse($actor), ...$this->inventoryCorrections($actor), ...$this->lotSetups($actor), ...$this->finance($actor)];
if ($area === 'procurement') {
$rows = [...$rows, ...$this->supplierImprovements($actor), ...$this->supplierQuality($actor), ...$this->supplyFollowUp($actor), ...$this->lotQuality($actor)];
if (config('order_cancellation.enabled') && Schema::hasTable('order_cancellations')) {
foreach (OrderCancellation::query()->where('status', 'pending')->lazyById(100) as $record) {
if (app(OrderCancellationWorkflow::class)->canDecide($actor, $record)) {
$rows[] = ['id' => 'order-cancellation:'.$record->id, 'module' => 'finance', 'reference' => $record->snapshot['order_number'],
'label' => 'Conferir cancelamento de ordem emitida', 'task' => 'order_cancellation_review', 'status' => 'pending', 'blocked' => false,
'created_at' => $this->date($record->created_at), 'due_on' => null, 'href' => '/ordens/cancelamentos?cancellation_id='.$record->id.'#cancellation-'.$record->id];
}
}
foreach (OrderCancellationPolicy::query()->where('status', 'pending')->lazyById(100) as $policy) {
if (app(OrderCancellationPolicyWorkflow::class)->canReview($actor, $policy)) {
$rows[] = ['id' => 'order-cancellation-policy:'.$policy->id, 'module' => 'finance', 'reference' => 'Política de cancelamento v'.$policy->revision,
'label' => 'Conferir política de cancelamento de ordens', 'task' => 'order_cancellation_policy_review', 'status' => 'pending', 'blocked' => false,
'created_at' => $this->date($policy->created_at), 'due_on' => null, 'href' => '/ordens/cancelamentos#policy-'.$policy->id];
}
}
foreach (OrderCancellation::query()->where('status', 'approved')->whereNull('revised_requisition_id')->lazyById(100) as $record) {
if (app(OrderCancellationWorkflow::class)->canRevise($actor, $record)) {
$rows[] = ['id' => 'order-cancellation-revision:'.$record->id, 'module' => 'purchases', 'reference' => $record->snapshot['order_number'],
'label' => 'Preparar nova requisição após cancelamento de ordem', 'task' => 'order_cancellation_revision', 'status' => 'approved', 'blocked' => false,
'created_at' => $this->date($record->reviewed_at), 'due_on' => null, 'href' => '/ordens/cancelamentos?cancellation_id='.$record->id.'#cancellation-'.$record->id];
}
}
}
}
usort($rows, fn ($a, $b) => strcmp($a['created_at'] ?? '', $b['created_at'] ?? '') ?: strnatcmp($a['id'], $b['id']));