init commit

api/app/Rules/Sigtap/CidBelongsToProcedimento.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Sigtap\Cid;
+use App\Models\Sigtap\Procedimento;
+use Illuminate\Contracts\Validation\Rule;
+
+class CidBelongsToProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        $procedimento = Procedimento::findOrFail($this->procedimentoId);
+
+        if ($procedimento->hasCidPrincipal) {
+
+            return $procedimento->cidsPrincipais->contains($value);
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return "CID não permitido para o procedimento selecionado.";
+    }
+}

api/app/Rules/Sigtap/CidExists.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CidExists implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return DB::table('sigtap.cid')->where('id', $value)->exists();
+    }
+
+    public function message()
+    {
+        return 'CID inválido.';
+    }
+}

api/app/Rules/Sigtap/CidIsRelatedToProcedimento.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CidIsRelatedToProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->procedimentoId, $value);
+    }
+
+    public static function isValid($procedimentoId, $cidId)
+    {
+        return DB::table('sigtap.procedimento_cid as procedimento_cid')
+            ->where('procedimento_cid.procedimento_id', $procedimentoId)
+            ->where('procedimento_cid.cid_id', $cidId)
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'CID inválido para o procedimento informado.';
+    }
+}

api/app/Rules/Sigtap/CidIsRequiredForProcedimento.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Sigtap\Procedimento;
+use Illuminate\Contracts\Validation\Rule;
+
+class CidIsRequiredForProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        $procedimento = Procedimento::findOrFail($this->procedimentoId);
+
+        return ($procedimento->hasCidPrincipal && is_numeric($value)) || !$procedimento->hasCidPrincipal;
+    }
+
+    public function message()
+    {
+        return "CID é obrigatório para o procedimento selecionado.";
+    }
+}

api/app/Rules/Sigtap/CidIsValidForSexo.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CidIsValidForSexo implements Rule
+{
+    private $sexo;
+
+    public function __construct($sexo)
+    {
+        $this->sexo = $sexo;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->sexo, $value);
+    }
+
+    public static function isValid($sexo, $value)
+    {
+        return DB::table('sigtap.cid')->where('id', $value)
+            ->where(function($query) use ($sexo) {
+                $query->where('sexo', 'I')
+                    ->orWhere('sexo', 'N')
+                    ->orWhere('sexo', $sexo);
+            })
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'CID inválido para o sexo informado.';
+    }
+}

api/app/Rules/Sigtap/CidPrincipalIsValidForProcedimento.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CidPrincipalIsValidForProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->procedimentoId, $value);
+    }
+
+    public static function isValid($procedimentoId, $cidId)
+    {
+        return DB::table('sigtap.procedimento_cid as procedimento_cid')
+            ->where('procedimento_cid.procedimento_id', $procedimentoId)
+            ->where('procedimento_cid.cid_id', $cidId)
+            ->where('procedimento_cid.principal', 'S')
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'CID principal inválido para o procedimento informado.';
+    }
+}

api/app/Rules/Sigtap/CidSecundarioIsValidForProcedimento.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CidSecundarioIsValidForProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->procedimentoId, $value);
+    }
+
+    public static function isValid($procedimentoId, $cidId)
+    {
+        return DB::table('sigtap.procedimento_cid as procedimento_cid')
+            ->where('procedimento_cid.procedimento_id', $procedimentoId)
+            ->where('procedimento_cid.cid_id', $cidId)
+            ->where('procedimento_cid.principal', 'N')
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'CID secundário inválido para o procedimento informado.';
+    }
+}

api/app/Rules/Sigtap/ClassificacaoIsValidForProcedimento.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ClassificacaoIsValidForProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->procedimentoId, $value);
+    }
+
+    public static function isValid($procedimentoId, $value)
+    {
+        $ids = collect($value)
+        ->flatMap(function ($item) {
+            return collect($item)->pluck('id');
+        })
+        ->filter()
+        ->unique()
+        ->values();
+
+        return DB::table('sigtap.classificacao')
+        ->whereIn('id', $ids)
+        ->whereExists(function ($query) use ($procedimentoId) {
+            $query->select(DB::raw(1))
+                ->from('sigtap.procedimento_classificacao')
+                ->whereColumn('sigtap.procedimento_classificacao.classificacao_id', 'sigtap.classificacao.id')
+                ->where('sigtap.procedimento_classificacao.procedimento_id', $procedimentoId);
+        })
+        ->exists();
+    }
+
+    public function message()
+    {
+        return "Classificação inválida para o procedimento informado.";
+    }
+}

api/app/Rules/Sigtap/ClassificacaoIsValidForServico.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ClassificacaoIsValidForServico implements Rule
+{
+    private $servicoId;
+
+    public function __construct($servicoId)
+    {
+        $this->servicoId = $servicoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->servicoId, $value);
+    }
+
+    public static function isValid($servicoId, $value)
+    {
+        $servicoIds = collect($servicoId)
+            ->map(fn($s) => $s->id ?? null)
+            ->filter()
+            ->unique()
+            ->values();
+
+        $classificacaoIds = collect($value)
+            ->flatMap(fn($sub) => collect($sub)->pluck('id'))
+            ->filter()
+            ->unique()
+            ->values();
+
+        if ($servicoIds->isEmpty() || $classificacaoIds->isEmpty()) {
+            return false;
+        }
+
+        return DB::table('sigtap.classificacao')
+            ->whereIn('id', $classificacaoIds->all())
+            ->whereIn('servico_id', $servicoIds->all())
+            ->exists();
+    }
+
+    public function message()
+    {
+        return "Classificação inválida para para o serviço informado.";
+    }
+}

api/app/Rules/Sigtap/CompetenciaAtualIsValidForProcedimento.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Sigtap\Procedimento;
+use App\Services\Sigtap\ProcedimentoValidationService;
+use Illuminate\Contracts\Validation\Rule;
+
+class CompetenciaAtualIsValidForProcedimento implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        $procedimento = Procedimento::findOrFail($value);
+        $validation = new ProcedimentoValidationService($procedimento);
+
+        return $validation->isOnValidCompetencia();
+    }
+
+    public function message()
+    {
+        return 'Competência não permitida para o procedimento selecionado.';
+    }
+}

api/app/Rules/Sigtap/CompetenciaIsValid.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CompetenciaIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value, $competenciaExportacaoId = null)
+    {
+        $competencias = DB::table('sigtap.competencia')
+            ->select('id')
+            ->when(is_numeric($competenciaExportacaoId), function ($query) use ($competenciaExportacaoId) {
+                $query->where('sigtap.competencia.id', '<=', $competenciaExportacaoId);
+            })
+            ->orderByDesc('valor')
+            ->limit(4)
+            ->pluck('id');
+
+        return $competencias->contains($value);
+    }
+
+    public function message()
+    {
+        return 'Competência inválida.';
+    }
+}

api/app/Rules/Sigtap/FinanciamentoIsValidForCompetencia.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Sigtap\Financiamento;
+use Illuminate\Contracts\Validation\Rule;
+
+class FinanciamentoIsValidForCompetencia implements Rule
+{
+    private $competenciaId;
+
+    public function __construct($competenciaId)
+    {
+        $this->competenciaId = $competenciaId;        
+    }
+
+    public function passes($attribute, $value)
+    {
+        if (is_numeric($value)) {
+            return Financiamento::where('id', $value)
+                ->where('competencia_id', $this->competenciaId)
+                ->exists();
+        } else {
+            $response = true;
+
+            foreach ($value as $financiamentoId) {
+                $financiamento = Financiamento::where('id', $financiamentoId)
+                    ->where('competencia_id', $this->competenciaId)
+                    ->exists();
+
+                if ($financiamento === false) {
+                    $response = false;
+                }
+            }
+
+            return $response;
+        }
+    }
+
+    public function message()
+    {
+        return "Financiamento inválido para a competência informada.";
+    }
+}

api/app/Rules/Sigtap/OcupacaoBelongsToProcedimento.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Sigtap\Ocupacao;
+use Illuminate\Contracts\Validation\Rule;
+
+class OcupacaoBelongsToProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;        
+    }
+
+    public function passes($attribute, $value)
+    {        
+        return Ocupacao::where('id', $value)
+            ->whereHas('procedimentos', function($query) {
+                $query->where('id', $this->procedimentoId);
+            })
+            ->exists();
+    }
+
+    public function message()
+    {
+        return "CBO não permitido para o procedimento selecionado.";
+    }
+}

api/app/Rules/Sigtap/OcupacaoExists.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class OcupacaoExists implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return DB::table('sigtap.ocupacao')->where('id', $value)->exists();
+    }
+
+    public function message()
+    {
+        return 'CBO inválido.';
+    }
+}

api/app/Rules/Sigtap/Procedimento/Idade.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Rules\Sigtap\Procedimento;
+
+use App\Models\Sigtap\Procedimento;
+use App\Services\Sigtap\ProcedimentoValidationService;
+use Illuminate\Contracts\Validation\Rule;
+
+class Idade implements Rule
+{
+    private Procedimento $procedimento;
+    private int $idadeAnos;
+
+    public function __construct(Procedimento $procedimento, int $idadeAnos)
+    {
+        $this->procedimento = $procedimento;
+        $this->idadeAnos = $idadeAnos;
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        $validation = new ProcedimentoValidationService($this->procedimento);
+
+        return $validation->isIdadeValid($this->idadeAnos);
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return ":attribute não permitido para a idade do paciente.";
+    }
+}

api/app/Rules/Sigtap/Procedimento/Ocupacao.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Rules\Sigtap\Procedimento;
+
+use App\Models\Sigtap\Ocupacao as OcupacaoSigtap;
+use App\Models\Sigtap\Procedimento;
+use App\Services\Sigtap\ProcedimentoValidationService;
+use Illuminate\Contracts\Validation\Rule;
+
+class Ocupacao implements Rule
+{
+    private Procedimento $procedimento;
+    private OcupacaoSigtap $ocupacao;
+    private $field;
+
+    public function __construct(Procedimento $procedimento, OcupacaoSigtap $ocupacao, $field = null)
+    {
+        $this->procedimento = $procedimento;
+        $this->ocupacao = $ocupacao;
+        $this->field = $field;
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        $validation = new ProcedimentoValidationService($this->procedimento);
+
+        return $validation->isOcupacaoValid($this->ocupacao);
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return ($this->field ?? ':attribute') . ' não permitido para o CBO.';
+    }
+}

api/app/Rules/Sigtap/Procedimento/Quantidade.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Rules\Sigtap\Procedimento;
+
+use App\Models\Sigtap\Procedimento;
+use App\Services\Sigtap\ProcedimentoValidationService;
+use Illuminate\Contracts\Validation\Rule;
+
+class Quantidade implements Rule
+{
+    private Procedimento $procedimento;
+    private ?int $quantidade;
+
+    public function __construct(Procedimento $procedimento, ?int $quantidade = null)
+    {
+        $this->procedimento = $procedimento;
+        $this->quantidade = $quantidade;
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        $validation = new ProcedimentoValidationService($this->procedimento);
+
+        return $validation->isQuantidadeValid($this->quantidade ?? $value);
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return "Quantidade máxima atingida para o :attribute";
+    }
+}

api/app/Rules/Sigtap/Procedimento/Sexo.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Rules\Sigtap\Procedimento;
+
+use App\Models\Cadastro\SujeitoAtencao\Sexo as CidadaoSexo;
+use App\Models\Sigtap\Procedimento;
+use App\Services\Sigtap\ProcedimentoValidationService;
+use Illuminate\Contracts\Validation\Rule;
+
+class Sexo implements Rule
+{
+    private CidadaoSexo $sexo;
+    private Procedimento $procedimento;
+
+    public function __construct(Procedimento $procedimento, CidadaoSexo $sexo)
+    {
+        $this->procedimento = $procedimento;
+        $this->sexo = $sexo;
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        $validation = new ProcedimentoValidationService($this->procedimento);
+
+        return $validation->isSexoValid($this->sexo);
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return ":attribute não permitido para o sexo do paciente.";
+    }
+}

api/app/Rules/Sigtap/Procedimento/ValidCompetencia.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Rules\Sigtap\Procedimento;
+
+use App\Models\Sigtap\Procedimento;
+use App\Services\Sigtap\ProcedimentoValidationService;
+use Illuminate\Contracts\Validation\Rule;
+
+class ValidCompetencia implements Rule
+{
+    private Procedimento $procedimento;
+
+    public function __construct(Procedimento $procedimento)
+    {
+        $this->procedimento = $procedimento;
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        $validation = new ProcedimentoValidationService($this->procedimento);
+
+        return $validation->isOnValidCompetencia();
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return "Competência do :attribute inválida.";
+    }
+}

api/app/Rules/Sigtap/ProcedimentoExists.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoExists implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return DB::table('sigtap.procedimento')->where('id', $value)->exists();
+    }
+
+    public function message()
+    {
+        return 'Procedimento inválido.';
+    }
+}

api/app/Rules/Sigtap/ProcedimentoIsConsolidado.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Sigtap\Procedimento;
+use Illuminate\Contracts\Validation\Rule;
+
+class ProcedimentoIsConsolidado implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return Procedimento::where('id', $value)
+            ->whereHas('registros', function($query) {
+                $query->where('codigo', '01');
+            })
+            ->exists();
+    }
+
+    public function message()
+    {
+        return "Procedimento selecionado não é consolidado.";
+    }
+}

api/app/Rules/Sigtap/ProcedimentoIsValidForCid.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoIsValidForCid implements Rule
+{
+    private $cidId;
+
+    public function __construct($cidId)
+    {
+        $this->cidId = $cidId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->cidId, $value);
+    }
+
+    public static function isValid($cidId, $value)
+    {
+        $procedimentoRequerCid = DB::table('sigtap.procedimento')->where('id', $value)
+            ->whereExists(function ($query) {
+
+                $query->select(DB::raw(1))
+                    ->from('sigtap.procedimento_cid')
+                    ->whereColumn('sigtap.procedimento_cid.procedimento_id', 'sigtap.procedimento.id')
+                    ->where('principal', 'S');
+            })->exists();
+
+        if($procedimentoRequerCid){
+
+            $cidValidoParaProceidmento = DB::table('sigtap.procedimento')->where('id', $value)
+            ->whereExists(function ($query) use ($cidId) {
+
+                $query->select(DB::raw(1))
+                    ->from('sigtap.procedimento_cid')
+                    ->whereColumn('sigtap.procedimento_cid.procedimento_id', 'sigtap.procedimento.id')
+                    ->where('sigtap.procedimento_cid.cid_id', $cidId);
+            })
+            ->exists();
+
+            if($cidValidoParaProceidmento){
+
+                return true;                
+            }else{
+
+                return false;
+            }
+        }else{
+
+            return true;
+        }        
+    }
+
+    public function message()
+    {
+        return 'Procedimento inválido para o CID informado.';
+    }
+}

api/app/Rules/Sigtap/ProcedimentoIsValidForCompetencia.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoIsValidForCompetencia implements Rule
+{
+    private $competencias;
+
+    public function __construct($competencias)
+    {
+        $this->competencias = $competencias;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->competencias, $value);
+    }
+
+    public static function isValid($competencias, $value)
+    {
+        return DB::table('sigtap.procedimento')->where('id', $value)
+            ->whereIn('competencia_id', $competencias->pluck('id'))
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'Procedimento inválido para a competência informada.';
+    }
+}

api/app/Rules/Sigtap/ProcedimentoIsValidForIdade.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoIsValidForIdade implements Rule
+{
+    private $idade;
+
+    public function __construct($idade)
+    {
+        $this->idade = $idade;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->idade, $value);
+    }
+
+    public static function isValid($idade, $value)
+    {
+        $idade *= 12;
+
+        $procedimento = DB::table('sigtap.procedimento')
+            ->where('id', $value)
+            ->select('idade_minima', 'idade_maxima')
+            ->first();
+
+        return
+            ($idade >= $procedimento->idade_minima || $procedimento->idade_minima === 9999) &&
+            ($idade <= $procedimento->idade_maxima || $procedimento->idade_maxima === 9999);
+    }
+
+    public function message()
+    {
+        return 'Procedimento inválido para a idade informada.';
+    }
+}

api/app/Rules/Sigtap/ProcedimentoIsValidForOcupacao.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoIsValidForOcupacao implements Rule
+{
+    private $ocupacaoId;
+
+    public function __construct($ocupacaoId)
+    {
+        $this->ocupacaoId = $ocupacaoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->ocupacaoId, $value);
+    }
+
+    public static function isValid($ocupacaoId, $value)
+    {
+        return DB::table('sigtap.procedimento')->where('id', $value)
+            ->where(function ($query) use ($ocupacaoId) {
+
+                $query->whereExists(function ($query) use ($ocupacaoId) {
+
+                    $query->select(DB::raw(1))
+                        ->from('sigtap.procedimento_ocupacao')
+                        ->whereColumn('sigtap.procedimento_ocupacao.procedimento_id', 'sigtap.procedimento.id')
+                        ->where('sigtap.procedimento_ocupacao.ocupacao_id', $ocupacaoId);
+                })->orWhereNotExists(function ($query) {
+
+                    $query->select(DB::raw(1))
+                        ->from('sigtap.procedimento_ocupacao')
+                        ->whereColumn('sigtap.procedimento_ocupacao.procedimento_id', 'sigtap.procedimento.id');
+                });
+            })
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'Procedimento inválido para a ocupação informada.';
+    }
+}

api/app/Rules/Sigtap/ProcedimentoIsValidForSexo.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoIsValidForSexo implements Rule
+{
+    private $sexo;
+
+    public function __construct($sexo)
+    {
+        $this->sexo = $sexo;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->sexo, $value);
+    }
+
+    public static function isValid($sexo, $value)
+    {
+        return DB::table('sigtap.procedimento')->where('id', $value)
+            ->where(function($query) use ($sexo) {
+                $query->where('sexo', 'I')
+                    ->orWhere('sexo', 'N')
+                    ->orWhere('sexo', $sexo);
+            })
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'Procedimento inválido para o sexo informado.';
+    }
+}

api/app/Rules/Sigtap/ProcedimentoRequireCid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoRequireCid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !DB::table('sigtap.procedimento')->where('id', $value)
+            ->whereExists(function ($query) {
+
+                $query->select(DB::raw(1))
+                    ->from('sigtap.procedimento_cid')
+                    ->whereColumn('sigtap.procedimento_cid.procedimento_id', 'sigtap.procedimento.id')
+                    ->where('principal', 'S');
+            })->exists();
+    }
+
+    public function message()
+    {
+        return "Procedimento exige CID.";
+    }
+}

api/app/Rules/Sigtap/QuantidadeIsValid.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class QuantidadeIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return is_int((int)$value) && $value > 0;
+    }
+
+    public function message()
+    {
+        return 'Quantidade informada deve ser maior que zero.';
+    }
+}

api/app/Rules/Sigtap/QuantidadeIsValidForProcedimento.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Sigtap\Procedimento;
+use App\Utils\MaskUtil;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class QuantidadeIsValidForProcedimento implements Rule
+{
+    private $procedimentoId;
+
+    public function __construct($procedimentoId)
+    {
+        $this->procedimentoId = $procedimentoId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        return self::isValid($this->procedimentoId, $value);
+    }
+
+    public static function isValid($procedimentoId, $value)
+    {
+        $procedimento = DB::table('sigtap.procedimento')
+            ->where('id', $procedimentoId)
+            ->select('quantidade_maxima_execucao')
+            ->first();
+
+        return $value >= 0
+            && $value <= $procedimento->quantidade_maxima_execucao;
+    }
+
+    public function message()
+    {
+        $procedimento = Procedimento::where('id', $this->procedimentoId)
+            ->first(['codigo', 'nome', 'quantidade_maxima_execucao']);
+
+        $descricao = MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}";
+
+        return "A quantidade máxima permitida para o procedimento {$descricao} é "
+            . $procedimento->quantidade_maxima_execucao;
+    }
+}

api/app/Rules/Sigtap/SexoIsValidForProcedimento.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Rules\Sigtap;
+
+use App\Models\Cadastro\SujeitoAtencao\Paciente;
+use App\Models\Sigtap\Procedimento;
+use App\Services\Sigtap\ProcedimentoValidationService;
+use Illuminate\Contracts\Validation\Rule;
+
+class SexoIsValidForProcedimento implements Rule
+{
+    private $pacienteId;
+
+    public function __construct($pacienteId)
+    {
+        $this->pacienteId = $pacienteId;
+    }
+
+    public function passes($attribute, $value)
+    {
+        $procedimento = Procedimento::findOrFail($value);
+        $paciente = Paciente::findOrFail($this->pacienteId);
+        $validation = new ProcedimentoValidationService($procedimento);
+
+        return $validation->isSexoValid($paciente->cidadao->sexo);
+    }
+
+    public function message()
+    {
+        return 'Sexo não permitido para o procedimento selecionado.';
+    }
+}