389 lines
14 KiB
PHP
389 lines
14 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Console\Commands;
|
|
|
|
use App\Enums\FormBuilder\FormFieldType;
|
|
use App\Enums\FormBuilder\FormPurpose;
|
|
use App\FormBuilder\Purposes\PurposeRegistry;
|
|
use Illuminate\Console\Command;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Schema;
|
|
|
|
/**
|
|
* Exit codes:
|
|
* 0 — all checks passed
|
|
* 1 — at least one check failed (strict or non-strict)
|
|
*
|
|
* Checks always run to completion; the final exit code reflects the worst
|
|
* result across all checks.
|
|
*/
|
|
final class VerifyFormsDataIntegrity extends Command
|
|
{
|
|
protected $signature = 'forms:verify-data-integrity {--strict : Also run strict reachability and activity-log spot-checks}';
|
|
|
|
protected $description = 'Verify integrity of form-builder data (schemas, fields, submissions, values, user_profiles)';
|
|
|
|
private bool $hasFailure = false;
|
|
|
|
public function handle(): int
|
|
{
|
|
$this->checkSchemaCoherence();
|
|
$this->checkFieldCoherence();
|
|
$this->checkSubmissionCoherence();
|
|
$this->checkValueCoherence();
|
|
$this->checkUserProfileCoherence();
|
|
$this->checkDataMigrationCounts();
|
|
$this->checkOrphans();
|
|
$this->checkRelationConsistency();
|
|
|
|
if ((bool) $this->option('strict')) {
|
|
$this->checkStrictReachability();
|
|
}
|
|
|
|
return $this->hasFailure ? self::FAILURE : self::SUCCESS;
|
|
}
|
|
|
|
private function recordPass(string $check, string $note = ''): void
|
|
{
|
|
$this->info("[PASS] {$check}".($note !== '' ? ": {$note}" : ''));
|
|
}
|
|
|
|
private function recordFailure(string $check, string $detail, string $fix = ''): void
|
|
{
|
|
$this->hasFailure = true;
|
|
$this->error("[FAIL] {$check}: {$detail}");
|
|
if ($fix !== '') {
|
|
$this->line(" → Suggested fix: {$fix}");
|
|
}
|
|
}
|
|
|
|
// ---- 1. schemas ----
|
|
private function checkSchemaCoherence(): void
|
|
{
|
|
$total = DB::table('form_schemas')->count();
|
|
$purposeValues = FormPurpose::values();
|
|
|
|
$invalidPurpose = DB::table('form_schemas')
|
|
->whereNotIn('purpose', $purposeValues)
|
|
->count();
|
|
|
|
$publicTokenDupes = DB::table('form_schemas')
|
|
->whereNotNull('public_token')
|
|
->select('public_token')
|
|
->groupBy('public_token')
|
|
->havingRaw('COUNT(*) > 1')
|
|
->count();
|
|
|
|
if ($invalidPurpose > 0 || $publicTokenDupes > 0) {
|
|
$this->recordFailure('Schema coherence',
|
|
"{$invalidPurpose} invalid purpose, {$publicTokenDupes} duplicate public_tokens"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Schema coherence', "{$total} schemas verified");
|
|
}
|
|
|
|
// ---- 2. fields ----
|
|
private function checkFieldCoherence(): void
|
|
{
|
|
$total = DB::table('form_fields')->count();
|
|
|
|
$orphanSchema = DB::table('form_fields')
|
|
->leftJoin('form_schemas', 'form_fields.form_schema_id', '=', 'form_schemas.id')
|
|
->whereNull('form_schemas.id')
|
|
->count();
|
|
|
|
$builtInTypes = FormFieldType::values();
|
|
$customTypes = array_keys((array) config('form_builder.custom_field_types', []));
|
|
$validTypes = array_merge($builtInTypes, $customTypes);
|
|
|
|
$invalidType = DB::table('form_fields')
|
|
->whereNotIn('field_type', $validTypes)
|
|
->count();
|
|
|
|
$nonFilterableMarkedFilterable = DB::table('form_fields')
|
|
->where('is_filterable', true)
|
|
->whereIn('field_type', [
|
|
FormFieldType::TEXTAREA->value,
|
|
FormFieldType::FILE_UPLOAD->value,
|
|
FormFieldType::IMAGE_UPLOAD->value,
|
|
FormFieldType::SIGNATURE->value,
|
|
FormFieldType::HEADING->value,
|
|
FormFieldType::PARAGRAPH->value,
|
|
FormFieldType::TABLE_ROWS->value,
|
|
FormFieldType::SECTION_PRIORITY->value,
|
|
FormFieldType::AVAILABILITY_PICKER->value,
|
|
])
|
|
->count();
|
|
|
|
// slug uniqueness within schema (non-deleted)
|
|
$dupSlugs = DB::table('form_fields')
|
|
->whereNull('deleted_at')
|
|
->select('form_schema_id', 'slug')
|
|
->groupBy('form_schema_id', 'slug')
|
|
->havingRaw('COUNT(*) > 1')
|
|
->count();
|
|
|
|
// Binding registry cross-check (WS-5a: relational form_field_bindings).
|
|
$registry = (array) config('form_binding', []);
|
|
$badBindings = 0;
|
|
$bindingRows = DB::table('form_field_bindings')
|
|
->select(['mode', 'target_entity', 'target_attribute'])
|
|
->get();
|
|
foreach ($bindingRows as $row) {
|
|
if (! in_array($row->mode, ['entity_owned', 'mirrored'], true)) {
|
|
$badBindings++;
|
|
|
|
continue;
|
|
}
|
|
if (! isset($registry[$row->target_entity][$row->target_attribute])) {
|
|
$badBindings++;
|
|
|
|
continue;
|
|
}
|
|
if (($registry[$row->target_entity][$row->target_attribute]['writable'] ?? false) !== true) {
|
|
$badBindings++;
|
|
}
|
|
}
|
|
|
|
if ($orphanSchema > 0 || $invalidType > 0 || $nonFilterableMarkedFilterable > 0 || $dupSlugs > 0 || $badBindings > 0) {
|
|
$this->recordFailure('Field coherence',
|
|
"{$orphanSchema} orphan schema, {$invalidType} invalid field_type, {$nonFilterableMarkedFilterable} unfilterable-but-marked, {$dupSlugs} duplicate slugs, {$badBindings} invalid bindings"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Field coherence', "{$total} fields verified");
|
|
}
|
|
|
|
// ---- 3. submissions ----
|
|
private function checkSubmissionCoherence(): void
|
|
{
|
|
$total = DB::table('form_submissions')->count();
|
|
|
|
$subjectMismatch = DB::table('form_submissions')
|
|
->where(function ($q): void {
|
|
$q->whereNotNull('subject_type')->whereNull('subject_id');
|
|
})
|
|
->orWhere(function ($q): void {
|
|
$q->whereNull('subject_type')->whereNotNull('subject_id');
|
|
})
|
|
->count();
|
|
|
|
$subjectTypes = app(PurposeRegistry::class)->allSubjectTypes();
|
|
$invalidSubjectType = DB::table('form_submissions')
|
|
->whereNotNull('subject_type')
|
|
->whereNotIn('subject_type', $subjectTypes)
|
|
->count();
|
|
|
|
$submittedWithoutTs = DB::table('form_submissions')
|
|
->where('status', 'submitted')
|
|
->whereNull('submitted_at')
|
|
->count();
|
|
|
|
$draftWithTs = DB::table('form_submissions')
|
|
->where('status', 'draft')
|
|
->whereNotNull('submitted_at')
|
|
->count();
|
|
|
|
if ($subjectMismatch > 0 || $invalidSubjectType > 0 || $submittedWithoutTs > 0 || $draftWithTs > 0) {
|
|
$this->recordFailure('Submission coherence',
|
|
"{$subjectMismatch} subject_type/id mismatch, {$invalidSubjectType} invalid subject_type, {$submittedWithoutTs} submitted without submitted_at, {$draftWithTs} draft with submitted_at"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Submission coherence', "{$total} submissions verified");
|
|
}
|
|
|
|
// ---- 4. values ----
|
|
private function checkValueCoherence(): void
|
|
{
|
|
$total = DB::table('form_values')->count();
|
|
|
|
$orphanSub = DB::table('form_values')
|
|
->leftJoin('form_submissions', 'form_values.form_submission_id', '=', 'form_submissions.id')
|
|
->whereNull('form_submissions.id')
|
|
->count();
|
|
|
|
$orphanField = DB::table('form_values')
|
|
->leftJoin('form_fields', 'form_values.form_field_id', '=', 'form_fields.id')
|
|
->whereNull('form_fields.id')
|
|
->count();
|
|
|
|
$dup = DB::table('form_values')
|
|
->select('form_submission_id', 'form_field_id')
|
|
->groupBy('form_submission_id', 'form_field_id')
|
|
->havingRaw('COUNT(*) > 1')
|
|
->count();
|
|
|
|
$longIndexed = DB::table('form_values')
|
|
->whereNotNull('value_indexed')
|
|
->whereRaw('CHAR_LENGTH(value_indexed) > 255')
|
|
->count();
|
|
|
|
$nonFilterableIndexed = DB::table('form_values')
|
|
->join('form_fields', 'form_values.form_field_id', '=', 'form_fields.id')
|
|
->whereNotNull('form_values.value_indexed')
|
|
->where('form_fields.is_filterable', false)
|
|
->count();
|
|
|
|
$multiValueIndexed = DB::table('form_values')
|
|
->join('form_fields', 'form_values.form_field_id', '=', 'form_fields.id')
|
|
->whereNotNull('form_values.value_indexed')
|
|
->whereIn('form_fields.field_type', [
|
|
FormFieldType::MULTISELECT->value,
|
|
FormFieldType::CHECKBOX_LIST->value,
|
|
FormFieldType::TAG_PICKER->value,
|
|
])
|
|
->count();
|
|
|
|
if ($orphanSub > 0 || $orphanField > 0 || $dup > 0 || $longIndexed > 0 || $multiValueIndexed > 0 || $nonFilterableIndexed > 0) {
|
|
$this->recordFailure('Value coherence',
|
|
"{$orphanSub} orphan submission, {$orphanField} orphan field, {$dup} duplicate pairs, {$longIndexed} over-length value_indexed, {$multiValueIndexed} multi-value rows with value_indexed set, {$nonFilterableIndexed} value_indexed set on non-filterable field",
|
|
'observer should only populate value_indexed when field.is_filterable=true — re-save affected rows to let FormValueObserver reconcile'
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Value coherence', "{$total} values verified");
|
|
}
|
|
|
|
// ---- 5. user profiles ----
|
|
private function checkUserProfileCoherence(): void
|
|
{
|
|
$userCount = DB::table('users')->whereNull('deleted_at')->count();
|
|
$profilesCount = DB::table('user_profiles')->count();
|
|
|
|
$missing = DB::table('users')
|
|
->whereNull('deleted_at')
|
|
->whereNotIn('id', DB::table('user_profiles')->select('user_id'))
|
|
->count();
|
|
|
|
$orphans = DB::table('user_profiles')
|
|
->whereNotIn('user_id', DB::table('users')->select('id'))
|
|
->count();
|
|
|
|
$outOfRange = DB::table('user_profiles')
|
|
->where(function ($q): void {
|
|
$q->where('reliability_score', '<', 0.00)
|
|
->orWhere('reliability_score', '>', 5.00);
|
|
})
|
|
->count();
|
|
|
|
if ($missing > 0 || $orphans > 0 || $outOfRange > 0) {
|
|
$this->recordFailure('User profile coherence',
|
|
"{$missing} users without profile, {$orphans} orphan profiles, {$outOfRange} score out of [0,5]"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('User profile coherence', "{$profilesCount} profiles (users: {$userCount})");
|
|
}
|
|
|
|
// ---- 6. data migration counts (only if legacy tables present) ----
|
|
private function checkDataMigrationCounts(): void
|
|
{
|
|
if (! Schema::hasTable('registration_form_fields')) {
|
|
$this->recordPass('Data migration counts', 'legacy tables already dropped, skipping');
|
|
|
|
return;
|
|
}
|
|
|
|
$legacyFields = DB::table('registration_form_fields')->count();
|
|
$legacyValues = DB::table('person_field_values')->count();
|
|
$legacyTemplates = DB::table('registration_field_templates')->count();
|
|
|
|
$newFields = DB::table('form_fields')->whereNull('deleted_at')->count();
|
|
$newValues = DB::table('form_values')->count();
|
|
$newTemplates = DB::table('form_templates')->count();
|
|
|
|
if ($legacyFields === 0 && $legacyValues === 0 && $legacyTemplates === 0) {
|
|
$this->recordPass('Data migration counts', 'legacy tables are empty, nothing to verify');
|
|
|
|
return;
|
|
}
|
|
|
|
$ok = $newFields >= $legacyFields && $newValues >= $legacyValues && $newTemplates >= $legacyTemplates;
|
|
|
|
if (! $ok) {
|
|
$this->recordFailure('Data migration counts',
|
|
"fields: legacy={$legacyFields} new={$newFields}; values: legacy={$legacyValues} new={$newValues}; templates: legacy={$legacyTemplates} new={$newTemplates}"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Data migration counts', "fields {$legacyFields}→{$newFields}, values {$legacyValues}→{$newValues}, templates {$legacyTemplates}→{$newTemplates}");
|
|
}
|
|
|
|
// ---- 7. orphans ----
|
|
private function checkOrphans(): void
|
|
{
|
|
$orphanPivotValue = DB::table('form_value_options')
|
|
->leftJoin('form_values', 'form_value_options.form_value_id', '=', 'form_values.id')
|
|
->whereNull('form_values.id')
|
|
->count();
|
|
|
|
$orphanSectionStatus = DB::table('form_submission_section_statuses')
|
|
->leftJoin('form_submissions', 'form_submission_section_statuses.form_submission_id', '=', 'form_submissions.id')
|
|
->whereNull('form_submissions.id')
|
|
->count();
|
|
|
|
if ($orphanPivotValue > 0 || $orphanSectionStatus > 0) {
|
|
$this->recordFailure('Orphan records', "{$orphanPivotValue} orphan form_value_options, {$orphanSectionStatus} orphan section_statuses");
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Orphan records', 'none');
|
|
}
|
|
|
|
// ---- 8. relation consistency ----
|
|
private function checkRelationConsistency(): void
|
|
{
|
|
$mismatchedSection = DB::table('form_fields as ff')
|
|
->join('form_schema_sections as fss', 'ff.form_schema_section_id', '=', 'fss.id')
|
|
->whereColumn('ff.form_schema_id', '!=', 'fss.form_schema_id')
|
|
->count();
|
|
|
|
if ($mismatchedSection > 0) {
|
|
$this->recordFailure('Relation consistency',
|
|
"{$mismatchedSection} form_fields.form_schema_section_id points at a section in a different schema"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Relation consistency', 'all section/schema relations aligned');
|
|
}
|
|
|
|
// ---- 9. strict ----
|
|
private function checkStrictReachability(): void
|
|
{
|
|
$unreachableValues = DB::table('form_values as fv')
|
|
->join('form_submissions as fs', 'fv.form_submission_id', '=', 'fs.id')
|
|
->join('form_fields as ff', 'fv.form_field_id', '=', 'ff.id')
|
|
->whereColumn('ff.form_schema_id', '!=', 'fs.form_schema_id')
|
|
->count();
|
|
|
|
if ($unreachableValues > 0) {
|
|
$this->recordFailure('Strict reachability',
|
|
"{$unreachableValues} form_values where field.schema != submission.schema"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->recordPass('Strict reachability', 'all values reachable via submission.schema→field');
|
|
}
|
|
}
|