1  <?php
  2  
  3  namespace App\Http\Services;
  4  
  5  use App\Models\Dossier;
  6  use App\Models\RequirementTemplate;
  7  use App\Models\ValidationType;
  8  use Exception;
  9  use Illuminate\Support\Facades\DB;
 10  
 11  class ValidationTypeService
 12  {
 13      /**
 14       * Display a listing of the resource.
 15       *
 16       * @return \Illuminate\Http\Response
 17       */
 18      public static function find(int $validationTypeId)
 19      {
 20          return ValidationType::where('id', $validationTypeId)->first();
 21      }
 22  
 23      public static function validationTypesName()
 24      {
 25          return ValidationType::select('name')->distinct()->orderBy('name')->get();
 26      }
 27  
 28      /**
 29       * Create resources
 30       *
 31       * @return \Illuminate\Http\Response
 32       */
 33      public static function searchValidationTypes(string $name, string $searchString, string $sortField, string $sortDirection, array|null $filters)
 34      {
 35          /*
 36          match ($filter) {
 37              'All' => $validationTypesQuery = Validation::withTrashed(),
 38              'Disabled' => $validationTypesQuery = Validation::onlyTrashed(),
 39              'Active' => $validationTypesQuery = Validation::query(),
 40              default => $validationTypesQuery = Validation::query(),
 41          };
 42          */
 43  
 44          $validationTypesQuery = ValidationType::where('name', $name);
 45  
 46          if ($filters && $filters['withTrashed']) {
 47              $validationTypesQuery->withTrashed();
 48          }
 49  
 50          $validationTypesQuery
 51              ->where(function ($query) use ($searchString) {
 52                  $query
 53                      ->where('name', 'like', '%' . $searchString . '%');
 54              });
 55  
 56          if ($filters && $filters['created_at_since']) {
 57              $validationTypesQuery->where('created_at', '>=', $filters['created_at_since']);
 58          }
 59  
 60          if ($filters && $filters['created_at_to']) {
 61              $validationTypesQuery->where('created_at', '<=', $filters['created_at_to']);
 62          }
 63  
 64          if ($sortField && $sortDirection) {
 65              $validationTypesQuery->orderBy($sortField, $sortDirection);
 66          }
 67  
 68          return $validationTypesQuery;
 69      }
 70  
 71      /**
 72       * Create a resource
 73       *
 74       * @return \Illuminate\Http\Response
 75       */
 76      public static function createRequirement(array $requirementData, array $relation): bool|Exception
 77      {
 78          try {
 79              DB::beginTransaction();
 80  
 81  
 82              $requirement = RequirementTemplate::create([
 83                  'title' => $requirementData['title'],
 84                  'description' => $requirementData['description'],
 85                  'validation_type_id' => $relation['validation_type_id'],
 86                  'automagic_class' => $requirementData['automagic_class'],
 87                  // 'workbook_id' =>  $relation['workbook_id'],
 88              ]);
 89  
 90              ExpertTipService::updateOrCreate($requirement, $requirementData['expertTip']);
 91  
 92              DB::commit();
 93  
 94              return true;
 95          } catch (Exception $e) {
 96              DB::rollBack();
 97              throw new Exception($e->getMessage());
 98          }
 99      }
100  
101      /**
102       * Update a resource
103       *
104       * @return bool
105       * @throws Exception
106       */
107      public static function updateRequirement(array $data, int $requirementId)
108      {
109          try {
110              DB::beginTransaction();
111  
112              /** @var RequirementTemplate $requirement */
113              $requirement = RequirementTemplate::findOrFail($requirementId);
114              $requirement->title = $data['title'];
115              $requirement->description = $data['description'];
116              $requirement->automagic_class = $data['automagic_class'];
117              $expertTipId = $requirement->expertTip ? $requirement->expertTip->id : null;
118              ExpertTipService::updateOrCreate($requirement, $data['expertTip'], $expertTipId);
119              $requirement->save();
120  
121              DB::commit();
122  
123              return true;
124          } catch (Exception $e) {
125              DB::rollBack();
126              logger()->error($e->getMessage());
127              throw new Exception(__('dossiers.validation.requirements.notifications.update.error.message'));
128          }
129      }
130  
131      /**
132       * Destroy a resource
133       *
134       * @return bool
135       * @throws Exception
136       */
137      public static function removeRequirement(int $requirementId)
138      {
139          try {
140              DB::beginTransaction();
141              RequirementTemplate::destroy($requirementId);
142              DB::commit();
143  
144              return true;
145          } catch (Exception $e) {
146              DB::rollBack();
147              throw new Exception(__('dossiers.validation.requirements.notifications.remove.error.message'));
148          }
149      }
150  
151      public static function getValidationTypesSelect(Dossier $dossier)
152      {
153          $norm = $dossier->norm ?? null;
154          if (!$norm) {
155              return collect();
156          }
157  
158          return $norm->validationTypes()
159              ->whereNotIn('name', ['ValidacionJson'])
160              ->select('id', 'name')
161              ->get()
162              ->map(function ($validationType) {
163                  return [
164                      'id' => $validationType->id,
165                      'name' => __('dossiers.template.validation.types.' . $validationType->name),
166                  ];
167              });
168      }
169  }