275 lines
19 KiB
PHP
275 lines
19 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Models\User;
|
|
use Illuminate\Support\Arr;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Validator;
|
|
use Illuminate\Support\Str;
|
|
use Illuminate\Validation\Rule;
|
|
use Illuminate\Validation\ValidationException;
|
|
|
|
final class DeskServiceEditor
|
|
{
|
|
/** @return list<array<string,mixed>> */
|
|
public function listing(): array
|
|
{
|
|
$availability = app(DeskServiceAvailability::class);
|
|
$active = $availability->current()->get()->keyBy('code');
|
|
$upcoming = $availability->upcoming()->get()->groupBy('code')->map(fn ($rows) => $rows->map(fn ($row) => ['version' => (int) $row->version, 'effective_from' => $row->effective_from])->all());
|
|
$rows = DB::table('desk_service_versions')->selectRaw('DISTINCT ON (code) code, version, definition')
|
|
->selectRaw($availability->dateProjection())
|
|
->orderBy('code')->orderByDesc('version')->get()->keyBy('code');
|
|
$services = [];
|
|
foreach (config('virtual-desk.services') as $code => $initial) {
|
|
$row = $rows->get($code);
|
|
$services[] = ['code' => $code, 'version' => (int) ($row->version ?? 0), 'editable' => true,
|
|
'effective_from' => $row->effective_from ?? null, 'activeVersion' => (int) ($active->get($code)->version ?? 0),
|
|
'upcoming' => $upcoming->get($code, []),
|
|
'fixedTypes' => array_map(fn (array $field) => $field['type'], $initial['fields']),
|
|
'definition' => $row ? json_decode($row->definition, true, 512, JSON_THROW_ON_ERROR) : $initial];
|
|
}
|
|
foreach ($rows as $code => $row) {
|
|
if (! array_key_exists($code, config('virtual-desk.services'))) {
|
|
$services[] = ['code' => $code, 'version' => (int) $row->version, 'editable' => false,
|
|
'effective_from' => $row->effective_from ?? null, 'activeVersion' => (int) ($active->get($code)->version ?? 0),
|
|
'upcoming' => $upcoming->get($code, []),
|
|
'definition' => json_decode($row->definition, true, 512, JSON_THROW_ON_ERROR)];
|
|
}
|
|
}
|
|
|
|
return $services;
|
|
}
|
|
|
|
/** @return array<string,mixed> */
|
|
public function history(string $code, int $requestedPage): array
|
|
{
|
|
abort_unless(array_key_exists($code, config('virtual-desk.services')) || DB::table('desk_service_versions')->where('code', $code)->exists(), 404);
|
|
$query = DB::table('desk_service_versions')->where('code', $code);
|
|
$total = (clone $query)->count();
|
|
$pages = max(1, (int) ceil($total / 10));
|
|
$page = min(max(1, $requestedPage), $pages);
|
|
$rows = $query->orderByDesc('version')->forPage($page, 10)->select(['id', 'version', 'status', 'author_id', 'published_by', 'published_at', 'definition', 'source'])
|
|
->selectRaw(app(DeskServiceAvailability::class)->dateProjection())->get();
|
|
$events = DB::table('audit_events')->where('source_system', 'virtual-desk')->where('entity_type', 'desk_service_versions')
|
|
->where('action', 'service_definition_version_published')->whereIn('entity_id', $rows->pluck('id')->all())
|
|
->get(['entity_id', 'after_data'])->keyBy('entity_id');
|
|
|
|
return ['page' => $page, 'pages' => $pages, 'total' => $total, 'data' => $rows->map(function ($row) use ($events): array {
|
|
$event = $events->get($row->id);
|
|
$audit = $event ? json_decode($event->after_data, true, 512, JSON_THROW_ON_ERROR) : [];
|
|
|
|
return ['id' => $row->id, 'version' => (int) $row->version, 'status' => $row->status,
|
|
'author_id' => $row->author_id, 'published_by' => $row->published_by, 'published_at' => $row->published_at,
|
|
'definition' => json_decode($row->definition, true, 512, JSON_THROW_ON_ERROR),
|
|
'effective_from' => $row->effective_from,
|
|
'source' => json_decode($row->source, true, 512, JSON_THROW_ON_ERROR), 'reason' => $audit['reason'] ?? null];
|
|
})->all()];
|
|
}
|
|
|
|
/** @param array<string,mixed> $input */
|
|
public function publish(User $actor, string $code, array $input): \stdClass
|
|
{
|
|
abort_unless(array_key_exists($code, config('virtual-desk.services')), 404);
|
|
$data = Validator::make($input, [
|
|
'base_version' => ['required', 'integer', 'min:0'], 'confirm' => ['accepted'],
|
|
'effective_from' => ['nullable', 'date_format:Y-m-d'],
|
|
'reason' => ['required', 'string', 'min:20', 'max:2000'],
|
|
'definition' => ['required', 'array:title,theme,profile,stage,entity,result,fields'],
|
|
'definition.title' => ['required', 'string', 'max:200'],
|
|
'definition.theme' => ['required', 'string', 'max:150'],
|
|
'definition.profile' => ['required', 'string', 'max:200'],
|
|
'definition.stage' => ['required', 'string', 'max:20'],
|
|
'definition.entity' => ['required', 'string', 'max:300'],
|
|
'definition.result' => ['required', 'string', 'max:2000'],
|
|
'definition.fields' => ['required', 'array', 'min:1', 'max:60'],
|
|
'definition.fields.*' => ['required', 'array:label,type,required,min,options,when,statement,mime_types,max_size_kb,max_files'],
|
|
'definition.fields.*.label' => ['required', 'string', 'max:300'],
|
|
'definition.fields.*.type' => ['required', Rule::in(['text', 'textarea', 'email', 'tel', 'url', 'number', 'date', 'select', 'multiselect', 'consent', 'territory', 'attachment'])],
|
|
'definition.fields.*.mime_types' => ['sometimes', 'array', 'list', 'min:1', 'max:4'],
|
|
'definition.fields.*.mime_types.*' => ['required', 'string', Rule::in(DeskAttachments::MIME_TYPES)],
|
|
'definition.fields.*.max_size_kb' => ['sometimes', 'integer', 'min:1', 'max:10240'],
|
|
'definition.fields.*.max_files' => ['sometimes', 'integer', 'min:1', 'max:100'],
|
|
'definition.fields.*.statement' => ['sometimes', 'string', 'min:3', 'max:5000'],
|
|
'definition.fields.*.required' => ['required', 'boolean'],
|
|
'definition.fields.*.min' => ['sometimes', 'numeric', 'min:0', 'max:999999999999'],
|
|
'definition.fields.*.options' => ['sometimes', 'array', 'min:1', 'max:100'],
|
|
'definition.fields.*.options.*' => ['required', 'string', 'max:300'],
|
|
'definition.fields.*.when' => ['sometimes', 'array:field,equals,operator', 'required_array_keys:field,equals'],
|
|
'definition.fields.*.when.operator' => ['sometimes', Rule::in(['equals', 'contains'])],
|
|
'definition.fields.*.when.field' => ['required_with:definition.fields.*.when', 'string', 'max:64'],
|
|
'definition.fields.*.when.equals' => ['required_with:definition.fields.*.when', 'string', 'max:1000'],
|
|
])->validate();
|
|
$this->checkFields($data['definition']['fields']);
|
|
|
|
return DB::transaction(function () use ($actor, $code, $data): \stdClass {
|
|
DB::select('select pg_advisory_xact_lock(261008, 2)');
|
|
$scheduled = app(DeskServiceAvailability::class)->scheduled();
|
|
if (! $scheduled && ($data['effective_from'] ?? null) !== null) {
|
|
throw ValidationException::withMessages(['effective_from' => 'Instale a actualização das datas de entrada em vigor antes de agendar uma versão.']);
|
|
}
|
|
$latest = DB::table('desk_service_versions')->where('code', $code)->orderByDesc('version')->first();
|
|
$previous = $latest ? json_decode($latest->definition, true, 512, JSON_THROW_ON_ERROR) : config('virtual-desk.services.'.$code);
|
|
if ($data['definition']['stage'] !== $previous['stage']) {
|
|
throw ValidationException::withMessages(['definition.stage' => 'A etapa pertence ao percurso existente e não pode ser alterada neste editor.']);
|
|
}
|
|
foreach (config('virtual-desk.services.'.$code.'.fields') as $key => $canonical) {
|
|
if (isset($data['definition']['fields'][$key]) && $data['definition']['fields'][$key]['type'] !== $canonical['type']) {
|
|
throw ValidationException::withMessages(['definition.fields.'.$key.'.type' => 'Este identificador é interpretado pelo motor existente. Conserve o tipo ou acrescente um novo campo com outro identificador.']);
|
|
}
|
|
}
|
|
// Retry of the same confirmed publication preserves the first version and authorship.
|
|
if ($latest && (int) $latest->version === (int) $data['base_version'] + 1 && $latest->status === 'published'
|
|
&& $this->sameEffectiveRequest($latest, $data, $scheduled)
|
|
&& $this->definitionHash(json_decode($latest->definition, true, 512, JSON_THROW_ON_ERROR)) === $this->definitionHash($data['definition'])) {
|
|
return $latest;
|
|
}
|
|
abort_unless((int) ($latest->version ?? 0) === (int) $data['base_version'], 409, 'O formulário foi alterado. Recarregue e compare a versão actual antes de publicar.');
|
|
if (($data['effective_from'] ?? null) !== null && $data['effective_from'] < now()->toDateString()) {
|
|
throw ValidationException::withMessages(['effective_from' => 'Uma nova publicação começa hoje ou numa data futura; não altera a vigência de pedidos anteriores.']);
|
|
}
|
|
$effective = ($data['effective_from'] ?? null) ?: now()->toDateString();
|
|
if ($latest && $latest->status === 'published' && $this->definitionHash($previous) === $this->definitionHash($data['definition'])
|
|
&& (! $scheduled || ($latest->effective_from ?? null) === $effective || (! ($data['effective_from'] ?? null) && (! ($latest->effective_from ?? null) || $latest->effective_from <= now()->toDateString())))) {
|
|
throw ValidationException::withMessages(['definition' => 'Não há alterações na definição ou na data de início para publicar uma nova versão.']);
|
|
}
|
|
$id = (string) Str::uuid();
|
|
DB::table('desk_service_versions')->insert([
|
|
'id' => $id, 'code' => $code, 'version' => (int) $data['base_version'] + 1, 'status' => 'published',
|
|
...($scheduled ? ['effective_from' => $effective] : []),
|
|
'definition' => json_encode($data['definition'], JSON_THROW_ON_ERROR),
|
|
'source' => $latest->source ?? json_encode(config('virtual-desk.source'), JSON_THROW_ON_ERROR),
|
|
'author_id' => $actor->id, 'published_by' => $actor->id, 'published_at' => now(), 'created_at' => now(), 'updated_at' => now(),
|
|
]);
|
|
DB::table('audit_events')->insert([
|
|
'source_system' => 'virtual-desk', 'entity_type' => 'desk_service_versions', 'entity_id' => $id, 'actor_user_id' => $actor->id,
|
|
'action' => 'service_definition_version_published',
|
|
'before_data' => json_encode(['id' => $latest?->id, 'version' => (int) $data['base_version']], JSON_THROW_ON_ERROR),
|
|
'after_data' => json_encode(['code' => $code, 'version' => (int) $data['base_version'] + 1, 'reason' => $data['reason'],
|
|
'effect' => 'new_requests_only', 'effective_from' => $scheduled ? $effective : null,
|
|
'effective_request_mode' => ($data['effective_from'] ?? null) ? 'dated' : 'immediate',
|
|
'selection' => 'latest_started_effective_date_then_version; undated_legacy_fallback',
|
|
'definition_sha256' => $this->definitionHash($data['definition'])], JSON_THROW_ON_ERROR),
|
|
]);
|
|
|
|
return DB::table('desk_service_versions')->where('id', $id)->firstOrFail();
|
|
});
|
|
}
|
|
|
|
/** @param array<array-key,mixed> $definition */
|
|
private function definitionHash(array $definition): string
|
|
{
|
|
return hash('sha256', json_encode(Arr::sortRecursive($definition), JSON_THROW_ON_ERROR));
|
|
}
|
|
|
|
/** PostgreSQL JSONB does not retain object-key order.
|
|
* @param array<array-key,mixed> $left
|
|
* @param array<array-key,mixed> $right */
|
|
public function sameDefinition(array $left, array $right): bool
|
|
{
|
|
return $this->definitionHash($left) === $this->definitionHash($right);
|
|
}
|
|
|
|
/** @param array<string,mixed> $data */
|
|
private function sameEffectiveRequest(\stdClass $latest, array $data, bool $scheduled): bool
|
|
{
|
|
if (! $scheduled || ($latest->effective_from ?? null) === null) {
|
|
return ! ($data['effective_from'] ?? null);
|
|
}
|
|
if ($data['effective_from'] ?? null) {
|
|
return $latest->effective_from === $data['effective_from'];
|
|
}
|
|
$event = DB::table('audit_events')->where('source_system', 'virtual-desk')->where('entity_type', 'desk_service_versions')
|
|
->where('entity_id', $latest->id)->where('action', 'service_definition_version_published')->orderByDesc('id')->value('after_data');
|
|
|
|
return $event && (json_decode($event, true, 512, JSON_THROW_ON_ERROR)['effective_request_mode'] ?? null) === 'immediate';
|
|
}
|
|
|
|
/** @param array<string,array<string,mixed>> $fields */
|
|
private function checkFields(array $fields): void
|
|
{
|
|
foreach ($fields as $key => $field) {
|
|
$path = 'definition.fields.'.$key;
|
|
if ($field['type'] === 'attachment') {
|
|
if (count(array_unique($field['mime_types'] ?? [])) !== count($field['mime_types'] ?? [])) {
|
|
throw ValidationException::withMessages([$path.'.mime_types' => 'Escolha cada formato apenas uma vez nesta pergunta.']);
|
|
}
|
|
if (! isset($field['mime_types'],$field['max_size_kb'],$field['max_files'])) {
|
|
throw ValidationException::withMessages([$path => 'Defina os formatos, tamanho por ficheiro e quantidade máxima desta pergunta.']);
|
|
}
|
|
if (! app(DeskAttachments::class)->scopedLinksInstalled()) {
|
|
throw ValidationException::withMessages([$path => 'Instale a actualização dos vínculos documentais antes de publicar perguntas de anexos. Os formulários existentes continuam disponíveis.']);
|
|
}
|
|
} elseif (array_intersect(['mime_types', 'max_size_kb', 'max_files'], array_keys($field))) {
|
|
throw ValidationException::withMessages([$path => 'Os limites de ficheiros pertencem apenas a perguntas de anexos.']);
|
|
}
|
|
if (! preg_match('/^[a-z][a-z0-9_]{0,63}$/D', (string) $key) || in_array($key, ['country', 'declared_origin_country_code', 'context_reuse', 'context_opportunity', 'context_opportunity_snapshot'], true)) {
|
|
throw ValidationException::withMessages(['definition.fields' => 'Use identificadores de campo distintos dos campos comuns de país e contexto, com letras minúsculas, números e sublinhado.']);
|
|
}
|
|
if (in_array($field['type'], ['select', 'multiselect'], true) && empty($field['options'])) {
|
|
throw ValidationException::withMessages([$path.'.options' => 'Indique as opções deste campo.']);
|
|
}
|
|
if ((isset($field['min']) && $field['type'] !== 'number') || (isset($field['options']) && ! in_array($field['type'], ['select', 'multiselect'], true))) {
|
|
throw ValidationException::withMessages([$path => 'O mínimo aplica-se apenas a números e as opções apenas a listas de respostas.']);
|
|
}
|
|
if (($field['type'] === 'consent' && trim($field['statement'] ?? '') === '') || (isset($field['statement']) && $field['type'] !== 'consent')) {
|
|
throw ValidationException::withMessages([$path.'.statement' => 'Uma declaração de consentimento exige o texto exacto a apresentar; esse texto pertence apenas a campos de consentimento.']);
|
|
}
|
|
foreach (array_keys($field['options'] ?? []) as $option) {
|
|
if (! preg_match('/^[a-zA-Z0-9_-]{1,80}$/D', (string) $option)) {
|
|
throw ValidationException::withMessages([$path.'.options' => 'Use códigos de opção sem espaços ou pontuação especial.']);
|
|
}
|
|
}
|
|
$visited = [$key];
|
|
$node = $field;
|
|
while (isset($node['when'])) {
|
|
$parent = $node['when']['field'];
|
|
if (! isset($fields[$parent]) || in_array($parent, $visited, true)) {
|
|
throw ValidationException::withMessages([$path.'.when' => 'A condição deve referir outro campo existente, sem dependências circulares.']);
|
|
}
|
|
if (in_array($fields[$parent]['type'], ['number', 'attachment'], true)) {
|
|
throw ValidationException::withMessages([$path.'.when' => 'Use uma resposta de texto, lista ou declaração como origem da condição; números e anexos não são respostas comparáveis por estas condições.']);
|
|
}
|
|
$operator = $node['when']['operator'] ?? 'equals';
|
|
if (($fields[$parent]['type'] === 'multiselect') !== ($operator === 'contains')) {
|
|
throw ValidationException::withMessages([$path.'.when' => 'Use inclusão de uma opção para uma selecção múltipla e igualdade para respostas simples.']);
|
|
}
|
|
if (in_array($fields[$parent]['type'], ['select', 'multiselect'], true) && ! array_key_exists($node['when']['equals'], $fields[$parent]['options'] ?? [])) {
|
|
throw ValidationException::withMessages([$path.'.when' => 'O valor da condição deve corresponder a uma opção do campo escolhido.']);
|
|
}
|
|
if ($fields[$parent]['type'] === 'consent' && ! in_array($node['when']['equals'], ['accepted', 'declined'], true)) {
|
|
throw ValidationException::withMessages([$path.'.when' => 'Compare a declaração com accepted ou declined; uma resposta por preencher não é aceitação.']);
|
|
}
|
|
$visited[] = $parent;
|
|
$node = $fields[$parent];
|
|
}
|
|
}
|
|
if (isset($fields['territory_id'])) {
|
|
if (! isset($fields['location_source'])) {
|
|
throw ValidationException::withMessages(['definition.fields.location_source' => 'A localização exige a respectiva fonte. Mantenha o campo da fonte ou retire também a localização.']);
|
|
}
|
|
$locationConditions = $this->conditions('territory_id', $fields);
|
|
$sourceConditions = $this->conditions('location_source', $fields);
|
|
if (array_diff_assoc($sourceConditions, $locationConditions) !== []) {
|
|
throw ValidationException::withMessages(['definition.fields.location_source.when' => 'A fonte tem de estar disponível sempre que a localização se aplica. Use as mesmas condições ou condições mais abrangentes.']);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Conditions have already been checked for valid references and cycles.
|
|
* @param array<string,array<string,mixed>> $fields
|
|
* @return array<string,string> */
|
|
private function conditions(string $key, array $fields): array
|
|
{
|
|
$conditions = [];
|
|
while (isset($fields[$key]['when'])) {
|
|
$when = $fields[$key]['when'];
|
|
$conditions[$when['field']] = ($when['operator'] ?? 'equals').':'.$when['equals'];
|
|
$key = $when['field'];
|
|
}
|
|
|
|
return $conditions;
|
|
}
|
|
}
|