init commit

api/app/Rules/AtencaoBasica/Exportacao/AlimentosAcabaramIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class AlimentosAcabaramIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'O campo "Nos últimos três meses, os alimentos acabaram antes que você tivesse dinheiro para comprar mais comida?" é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/AlturaLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\Altura;
+use Illuminate\Contracts\Validation\Rule;
+
+class AlturaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (float) $value;
+
+        return $value >= Altura::MINIMO && $value <= Altura::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A altura deve estar entre ' . Altura::MINIMO . ' e '. Altura::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/AplicadoExteriorIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class AplicadoExteriorIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Aplicado exterior é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/BairroIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class BairroIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Bairro é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CepIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class CepIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Cep é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CiapIsDuplicate.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class CiapIsDuplicate implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (($value->ciap_primario_id && $value->ciap_secundario_id) && $value->ciap_primario_id != $value->ciap_secundario_id) {
+            return true;
+        } elseif (!$value->ciap_primario_id || !$value->ciap_secundario_id) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public function message()
+    {
+        return 'Ciap em duplicidade.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CiapIsValid.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Geral\CiapCondicaoAvaliada;
+use Illuminate\Contracts\Validation\Rule;
+
+class CiapIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $condicoesAvaliadas = [
+            CiapCondicaoAvaliada::ASMA,
+            CiapCondicaoAvaliada::DENGUE,
+            CiapCondicaoAvaliada::DESNUTRICAO,
+            CiapCondicaoAvaliada::DIABETES,
+            CiapCondicaoAvaliada::DPOC,
+            CiapCondicaoAvaliada::DST,
+            CiapCondicaoAvaliada::HANSENIASE,
+            CiapCondicaoAvaliada::HIPERTENSAO_ARTERIAL,
+            CiapCondicaoAvaliada::OBESIDADE,
+            CiapCondicaoAvaliada::PRE_NATAL,
+            CiapCondicaoAvaliada::PUERICULTURA,
+            CiapCondicaoAvaliada::PUERPERIO,
+            CiapCondicaoAvaliada::RASTREAMENTO_DE_RISCO_CARDIOVASCULAR,
+            CiapCondicaoAvaliada::REABILITACAO,
+            CiapCondicaoAvaliada::TABAGISMO,
+            CiapCondicaoAvaliada::TUBERCULOSE,
+            CiapCondicaoAvaliada::USUARIO_DE_ALCOOL,
+            CiapCondicaoAvaliada::USUARIO_DE_OUTRAS_DROGAS,
+        ];
+
+        return !in_array($value, $condicoesAvaliadas);
+    }
+
+    public function message()
+    {
+        return 'Ciap inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CidAavaliacaoIsDuplicate.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class CidAavaliacaoIsDuplicate implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if ($value->cid_primario && $value->cid_secundario && $value->cid_terciario) {
+            if ($value->cid_primario != $value->cid_secundario && $value->cid_primario != $value->cid_terciario
+                && $value->cid_secundario != $value->cid_terciario) {
+                return true;
+            }
+        }
+
+        if ($value->cid_primario && $value->cid_secundario) {
+            if ($value->cid_primario != $value->cid_secundario) {
+                return true;
+            }
+        }
+
+        if ($value->cid_primario && $value->cid_terciario) {
+            if ($value->cid_primario != $value->cid_terciario) {
+                return true;
+            }
+        }
+
+        if ($value->cid_secundario && $value->cid_terciario) {
+            if ($value->cid_secundario != $value->cid_terciario) {
+                return true;
+            }
+        }
+
+        if ($value->cid_primario && !$value->cid_secundario && !$value->cid_terciario) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public function message()
+    {
+        return 'Cid em duplicidade.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CidIsDuplicate.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class CidIsDuplicate implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (($value->cid_primario_id && $value->cid_secundario_id) && $value->cid_primario_id != $value->cid_secundario_id) {
+            return true;
+        } elseif (!$value->cid_primario_id || !$value->cid_secundario_id) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public function message()
+    {
+        return 'Cid em duplicidade.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CidIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class CidIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Cid é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CircunferenciaAbdominalLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\CircunferenciaAbdominal;
+use Illuminate\Contracts\Validation\Rule;
+
+class CircunferenciaAbdominalLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (float) $value;
+
+        return $value >= CircunferenciaAbdominal::MINIMO && $value <= CircunferenciaAbdominal::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A circunferência abdominal deve estar entre ' . CircunferenciaAbdominal::MINIMO . ' e '. CircunferenciaAbdominal::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CnesIsValid.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class CnesIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return strlen($value) === 7;
+    }
+
+    public function message()
+    {
+        return 'CNES inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CnsPaciente.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Rules\Cns;
+use Illuminate\Contracts\Validation\Rule;
+
+class CnsPaciente implements Rule
+{
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        return Cns::isValid($value);
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return 'CNS Inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ComeuALgunsAlimentosIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ComeuALgunsAlimentosIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'O campo "Nos últimos três meses, você comeu apenas alguns alimentos que ainda tinha, porque o dinheiro acabou?" é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ComunicanteHanseniaseIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ComunicanteHanseniaseIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Comunicante Hanseniase é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ConclusaoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ConclusaoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Conclusão é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CondicaoAvaliacaoDomiciliarIsValidForFicha.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CondicaoAvaliacaoDomiciliarIsValidForFicha implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        $result = DB::table('atencao_basica_atendimento_domiciliar_condicao')
+            ->where('atendimento_id', $value->id)
+            ->count();
+
+        return $result == 0 || $result > 0 && $value->tipo_atendimento_id != TipoAtendimento::VISITA_DOMICILIAR_POS_OBITO;
+    }
+
+    public function message()
+    {
+        return 'Condição avaliada inválida';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CondicaoAvaliacaoIsRequired.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CondicaoAvaliacaoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        $quantidadeAvaliacoes = DB::table('atencao_basica_atendimento_individual_condicao_avaliada')
+            ->where('atendimento_individual_id', $value->id)
+            ->count();
+
+        return $value->ciap_primario_id || $value->ciap_secundario_id || $value->cid_primario_id
+            || $value->cid_secundario_id || $quantidadeAvaliacoes > 0 ? true : false;
+    }
+
+    public function message()
+    {
+        return 'Problema / condição avaliada é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CondicaoAvaliacaoIsValidForFicha.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\CondicaoAvaliada as EnumsCondicaoAvaliada;
+use App\Enums\Cadastro\SujeitoAtencao\Sexo;
+use App\Enums\Sigtap\Procedimento;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CondicaoAvaliacaoIsValidForFicha implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        $result = DB::table('atencao_basica_atendimento_individual_condicao_avaliada')
+            ->where('atendimento_individual_id', $value->id)
+            ->whereIn('condicao_avaliada_id', [EnumsCondicaoAvaliada::PRE_NATAL, EnumsCondicaoAvaliada::PUERPERIO_ATE_42_DIAS])
+            ->count();
+
+        return $result == 0 || $result > 0 && $value->paciente_sexo_id === Sexo::FEMININO;
+    }
+
+    public function message()
+    {
+        return 'Condição avaliada inválida';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CondutaDesfechoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class CondutaDesfechoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Desfecho é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CondutaEncaminhamentoIsRequired.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CondutaEncaminhamentoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $condutasEncaminhamento = DB::table('atencao_basica_atendimento_odontologico_conduta_encaminhamento')
+            ->where('atendimento_odontologico_id', $value->id)
+            ->count();
+
+        return $condutasEncaminhamento > 0;
+    }
+
+    public function message()
+    {
+        return 'Conduta ou encaminhamento são obrigatórios.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/CondutaEncaminhamentoIsValid.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoOdontologico\CondutaEncaminhamento;
+use App\Enums\AtencaoBasica\AtendimentoOdontologico\TipoConsulta;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class CondutaEncaminhamentoIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $condutasEncaminhamento = DB::table('atencao_basica_atendimento_odontologico_conduta_encaminhamento')
+            ->where('atendimento_odontologico_id', $value->id)
+            ->get();
+
+        foreach ($condutasEncaminhamento as $condutaEncaminhamento) {
+
+            if ($condutaEncaminhamento->conduta_encaminhamento_id == CondutaEncaminhamento::TRATAMENTO_CONCLUIDO
+                && $value->tipo_consulta_id == TipoConsulta::CONSULTA_MANUTENCAO) {
+
+                return false;
+            }
+
+            if ($condutaEncaminhamento->conduta_encaminhamento_id == CondutaEncaminhamento::ALTA_EPISODIO
+                && $value->tipo_consulta_id != TipoConsulta::CONSULTA_MANUTENCAO) {
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'Conduta ou encaminhamento inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DataAtendimentoIsValid.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Carbon\Carbon;
+use Illuminate\Contracts\Validation\Rule;
+
+class DataAtendimentoIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return Carbon::parse($value)->isPast();
+    }
+
+    public function message()
+    {
+        return 'Data de atendimento inválida';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DataEntradaIsRequired.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class DataEntradaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Data de entrada no Brasil é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DataNascimentoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class DataNascimentoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Data de nascimento é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DataNascimentoIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Carbon\Carbon;
+use Illuminate\Contracts\Validation\Rule;
+
+class DataNascimentoIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $dataAtendimento = Carbon::parse($value['data_atendimento']);
+        $dataNascimentoPaciente = Carbon::parse($value['data_nascimento']);
+
+        $limiteInferior = $dataAtendimento->copy()->subYears(130);
+        $limiteSuperior = $dataAtendimento->copy();
+
+        return $dataNascimentoPaciente->isBetween($limiteInferior, $limiteSuperior);
+    }
+
+    public function message()
+    {
+        return 'Data de nascimento inválida';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DataRegistroAnteriorIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class DataRegistroAnteriorIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Data do registro anterior é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DataRegistroAnteriorIsValid.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Carbon\Carbon;
+use Illuminate\Contracts\Validation\Rule;
+
+class DataRegistroAnteriorIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !$value['registro_anterior'] || $value['registro_anterior'] && Carbon::parse($value['data'])->isPast()
+            && Carbon::parse($value['data'])->gt(Carbon::parse($value['data_nascimento']));
+    }
+
+    public function message()
+    {
+        return 'Data do registro anterior inválida.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DesfechoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class DesfechoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Desfecho é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DoseIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class DoseIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Dose é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/DoseIsValid.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Models\Imunizacao\Dose;
+use Illuminate\Contracts\Validation\Rule;
+
+class DoseIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return Dose::where('id', $value)->get()->isNotEmpty();
+    }
+
+    public function message()
+    {
+        return 'Dose inválida.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/EstrategiaIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class EstrategiaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Estratégia é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/EstrategiaIsValid.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Imunizacao\Estrategia;
+use Illuminate\Contracts\Validation\Rule;
+
+class EstrategiaIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return $value && in_array($value, array_column(Estrategia::getConstants(), null));
+    }
+
+    public function message()
+    {
+        return 'Estratégia inválida.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/EstrategiaIsValidForFicha.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Imunizacao\Estrategia;
+use Illuminate\Contracts\Validation\Rule;
+
+class EstrategiaIsValidForFicha implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return is_null($value->estrategia_id) || $value->estrategia_codigo == Estrategia::PESQUISA;
+    }
+
+    public function message()
+    {
+        return 'Estratégia inválida.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/EtniaIndigenaIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class EtniaIndigenaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Etnia é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ExameIsRequired.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ExameIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $fields = [
+            'data_realizacao_teste_olhinho',
+            'data_realizacao_fundo_olho',
+            'data_realizacao_teste_orelhinha',
+            'data_realizacao_us_transfontanela',
+            'data_realizacao_tomografia_computadorizada',
+            'data_realizacao_ressonancia_magnetica'
+        ];
+
+        foreach ($fields as $field) {
+            if (!empty($value->$field)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function message()
+    {
+        return 'Exame é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ExameIsValid.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ExameIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $fields = [
+            ['data_realizacao_teste_olhinho', 'resultado_teste_olhinho_id'],
+            ['data_realizacao_fundo_olho', 'resultado_fundo_olho_id'],
+            ['data_realizacao_teste_orelhinha', 'resultado_teste_orelhinha_id'],
+            ['data_realizacao_us_transfontanela', 'resultado_us_transfontanela_id'],
+            ['data_realizacao_tomografia_computadorizada', 'resultado_tomografia_computadorizada_id'],
+            ['data_realizacao_ressonancia_magnetica', 'resultado_ressonancia_magnetica_id']
+        ];
+
+        foreach ($fields as $field) {
+
+            $dataField = 'atencao_basica_ficha_complementar.' . $field[0];
+            $resultField = 'atencao_basica_ficha_complementar.' . $field[1];
+
+            if (!empty($value->$dataField) && empty($value->$resultField)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'Exame com data preenchida e sem resultado.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/FabricanteIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class FabricanteIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Fabricante é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/FabricanteIsValid.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\Fabricante;
+use App\Enums\AtencaoBasica\Exportacao\VacinaAplicadaExterior;
+use Illuminate\Contracts\Validation\Rule;
+
+class FabricanteIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $fabricanteVacina = [
+            VacinaAplicadaExterior::COVID_19_RECOMBINANTE_ASTRAZENECA_FIOCRUZ_COVISHIELD => Fabricante::OXFORD_ASTRAZENECA,
+            VacinaAplicadaExterior::COVID_19_INATIVADA_SINOVAC_BUTANTAN_CORONAVAC => Fabricante::SINOVAC_BUTANTAN,
+            VacinaAplicadaExterior::COVID_19_RNAM_PFIZER_COMIRNATY => Fabricante::PFIZER_BIONTECH,
+            VacinaAplicadaExterior::COVID_19_RECOMBINANTE_JANSSEN_AD26_COV2_S => Fabricante::JANSSEN_CILAG,
+            VacinaAplicadaExterior::COVID_19_RECOMBINANTE_ASTRAZENECA_COVAX_CHADOX1_S => Fabricante::ASTRAZENECA_CHADOX1_S,
+            VacinaAplicadaExterior::COVID_19_GAMALEYA_SPUTNIK_V_RECOMBINANTE => Fabricante::GAMALEYA_SPUTNIK_V,
+            VacinaAplicadaExterior::COVID_19_COVID_19_BHARAT_COVAXIN_INATIVADA => Fabricante::BHARAT_COVAXIN,
+            VacinaAplicadaExterior::COVID_19_MODERNA_RNAM => Fabricante::MODERNA,
+            VacinaAplicadaExterior::COVID_19_INATIVADA_SINOVAC_CORONAVAC => Fabricante::SINOVAC_CORONAVAC,
+            VacinaAplicadaExterior::COVID_19_RNAM_PFIZER_COMIRNATY_PEDIATRICA => Fabricante::COMIRNATY_PFIZER_BIONTECH,
+            VacinaAplicadaExterior::COVID_19_RNAM_PFIZER_COMIRNATY_PEDIATRICA_MENOR_5_ANOS => Fabricante::COMIRNATY_PFIZER_BIONTECH,
+            VacinaAplicadaExterior::COVID_19_RNAM_PFIZER_COMIRNATY_BIVALENTE => Fabricante::COMIRNATY_PFIZER_BIONTECH,
+        ];
+
+        if (isset($fabricanteVacina[$value['vacina']]) && $value['fabricante'] != $fabricanteVacina[$value['vacina']]) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'Dose inválida.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/FrequenciaCardiacaLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\FrequenciaCardiaca;
+use Illuminate\Contracts\Validation\Rule;
+
+class FrequenciaCardiacaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (int) $value;
+
+        return $value >= FrequenciaCardiaca::MINIMO && $value <= FrequenciaCardiaca::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A frequência cardíaca deve estar entre ' . FrequenciaCardiaca::MINIMO . ' e '. FrequenciaCardiaca::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/FrequenciaRespiratoriaLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\FrequenciaRespiratoria;
+use Illuminate\Contracts\Validation\Rule;
+
+class FrequenciaRespiratoriaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (int) $value;
+
+        return $value >= FrequenciaRespiratoria::MINIMO && $value <= FrequenciaRespiratoria::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A frequência respiratória deve estar entre ' . FrequenciaRespiratoria::MINIMO . ' e '. FrequenciaRespiratoria::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/GestanteIsValidForFicha.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Cadastro\SujeitoAtencao\Sexo;
+use Illuminate\Contracts\Validation\Rule;
+
+class GestanteIsValidForFicha implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !$value->gestante || $value->paciente_sexo_id == Sexo::FEMININO && $value->gestante;
+    }
+
+    public function message()
+    {
+        return 'Gestante inválido para o sexo do paciente';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/GlicemiaIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class GlicemiaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Glicemia é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/GlicemiaLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\Glicemia;
+use Illuminate\Contracts\Validation\Rule;
+
+class GlicemiaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (int) $value;
+
+        return $value >= Glicemia::MINIMO && $value <= Glicemia::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A glicemia deve estar entre ' . Glicemia::MINIMO . ' e '. Glicemia::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/GrupoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class GrupoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Grupo é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/GrupoIsValid.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class GrupoIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return empty($value->grupo_id);
+    }
+
+    public function message()
+    {
+        return 'Grupo não pode ser preenchido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/IbgeIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class IbgeIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'IBGE é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/IbgeIsValid.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class IbgeIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return strlen($value) === 7;
+    }
+
+    public function message()
+    {
+        return 'IBGE inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/LatitudeIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class LatitudeIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Latitude é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/LocalAtendimentoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class LocalAtendimentoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Local de atendimento é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/LocalAtendimentoIsValid.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\LocalAtendimento as EnumsLocalAtendimento;
+use Illuminate\Contracts\Validation\Rule;
+
+class LocalAtendimentoIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !collect([
+            EnumsLocalAtendimento::HOSPITAL,
+            EnumsLocalAtendimento::UNIDADE_PRONTO_ATENDIMENTO,
+            EnumsLocalAtendimento::CACON_UNACON,
+        ])->contains($value);
+    }
+
+    public function message()
+    {
+        return 'Local de atendimento inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/LogradouroIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class LogradouroIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Logradouro é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/LogradouroTipoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class LogradouroTipoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Tipo do logradouro é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/LongitudeIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class LongitudeIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Longitude é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/LoteIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class LoteIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Lote é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/MicroAreaIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class MicroAreaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Microarea é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/MomentoColetaGlicemiaIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class MomentoColetaGlicemiaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Momento da coleta da glicemia é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/MotivoVisitaIsValid.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\CadastroDomiciliar\ImovelTipo;
+use App\Enums\AtencaoBasica\VisitaDomiciliar\MotivoVisita;
+use App\Enums\Cadastro\SujeitoAtencao\Sexo;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class MotivoVisitaIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $motivoVisita = DB::table('atencao_basica_visita_domiciliar_motivo_visita')
+            ->where('visita_domiciliar_id', $value->id)
+            ->whereNotIn('motivo_visita_id', [
+                MotivoVisita::CADASTRAMENTO_ATUALIZACAO,
+                MotivoVisita::ACAO_EDUCATIVA,
+                MotivoVisita::IMOVEL_COM_FOCO,
+                MotivoVisita::ACAO_MECANICA,
+                MotivoVisita::TRATAMENTO_FOCAL,
+                MotivoVisita::CONVITE_PARA_ATIVIDADES_COLETIVAS_CAMPANHA_DE_SAUDE,
+                MotivoVisita::ORIENTACAO_PREVENCAO,
+                MotivoVisita::OUTROS,
+            ])
+            ->get();
+
+        if ($motivoVisita->isNotEmpty()) {
+
+            return self::getTipoImovelValido($value->imovel_tipo_codigo_esus) ? true : false;
+        }
+
+        $motivoVisita = DB::table('atencao_basica_visita_domiciliar_motivo_visita')
+            ->where('visita_domiciliar_id', $value->id)
+            ->whereIn('motivo_visita_id', [
+                MotivoVisita::GESTANTE,
+                MotivoVisita::PUERPERA,
+            ])
+            ->get();
+
+        if ($motivoVisita->isNotEmpty()) {
+
+            return $value->paciente_sexo_id === Sexo::FEMININO ? true : false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'Motivo inválido.';
+    }
+
+    private static function getTipoImovelValido($tipoImovelId) {
+
+        return $tipoImovelId == ImovelTipo::DOMICILIO
+            || $tipoImovelId == ImovelTipo::ABRIGO
+            || $tipoImovelId == ImovelTipo::INSTITUICAO_LONGA_PERMANENCIA_IDOSOS
+            || $tipoImovelId == ImovelTipo::UNIDADE_PRISIONAL
+            || $tipoImovelId == ImovelTipo::UNIDADE_MEDIDA_SOCIO_EDUCATIVA
+            || $tipoImovelId == ImovelTipo::DELEGACIA
+            || $tipoImovelId == ImovelTipo::OUTROS;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/NumeroIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class NumeroIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Número é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/OcupacaoIsAllowed.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class OcupacaoIsAllowed implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        $permissaoOcupacao = DB::table('atencao_basica_parametrizacao_outros_permissao_esus')
+            ->where('permissao_id', $value['permissao_id'])
+            ->where('codigo', $value['ocupacao'])
+            ->get();
+
+        return $permissaoOcupacao->isNotEmpty();
+    }
+
+    public function message()
+    {
+        return 'Ocupação do usuário sem permissão para registrar a ficha';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PaisNascimentoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class PaisNascimentoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'País nascimento é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PaisNascimentoIsValid.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Intranet\Pais;
+use Illuminate\Contracts\Validation\Rule;
+
+class PaisNascimentoIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return $value === Pais::BRASIL;
+    }
+
+    public function message()
+    {
+        return 'País nascimento é inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PerimetroCefalicoLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\PerimetroCefalico;
+use Illuminate\Contracts\Validation\Rule;
+
+class PerimetroCefalicoLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (float) $value;
+
+        return $value >= PerimetroCefalico::MINIMO && $value <= PerimetroCefalico::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A perímetro cefálico deve estar entre ' . PerimetroCefalico::MINIMO . ' e '. PerimetroCefalico::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PerimetroPanturrilhaLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\PerimetroPanturrilha;
+use Illuminate\Contracts\Validation\Rule;
+
+class PerimetroPanturrilhaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (float) $value;
+
+        return $value >= PerimetroPanturrilha::MINIMO && $value <= PerimetroPanturrilha::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'O perímetro da panturrilha deve estar entre ' . PerimetroPanturrilha::MINIMO . ' e '. PerimetroPanturrilha::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PesoLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\Peso;
+use Illuminate\Contracts\Validation\Rule;
+
+class PesoLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (float) $value;
+
+        return $value >= Peso::MINIMO && $value <= Peso::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'O peso deve estar entre ' . Peso::MINIMO . ' e '. Peso::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PressaoArterialDiastolicaLimitIsValid.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\PressaoArterialDiastolica;
+use Illuminate\Contracts\Validation\Rule;
+
+class PressaoArterialDiastolicaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+        else if (!str_contains($value, '/')) {
+
+            return false;
+        }
+
+        $value = (int) explode('/', $value)[1];
+
+        return $value >= PressaoArterialDiastolica::MINIMO && $value <= PressaoArterialDiastolica::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'O pressão arterial diastólica deve estar entre ' . PressaoArterialDiastolica::MINIMO . ' e '. PressaoArterialDiastolica::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PressaoArterialSistolicaLimitIsValid.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\PressaoArterialSistolica;
+use Illuminate\Contracts\Validation\Rule;
+
+class PressaoArterialSistolicaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+        else if (!str_contains($value, '/')) {
+
+            return false;
+        }
+
+        $value = (int) explode('/', $value)[0];
+
+        return $value >= PressaoArterialSistolica::MINIMO && $value <= PressaoArterialSistolica::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'O pressão arterial sistólica deve estar entre ' . PressaoArterialSistolica::MINIMO . ' e '. PressaoArterialSistolica::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProblemaCondicaoCiapIsDuplicated.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ProblemaCondicaoCiapIsDuplicated implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($problemasCondicoes)
+    {
+
+        $problemasCondicoesCiapsIds = $problemasCondicoes->whereNotNull('ciap_id')->pluck('ciap_id');
+
+        if ($problemasCondicoesCiapsIds->count() > $problemasCondicoesCiapsIds->unique()->count()) {
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'CIAP2 duplicado';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProblemaCondicaoCiapIsValid.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Geral\Ciap;
+use App\Enums\Geral\GrupoCiap;
+use App\Enums\Sigtap\Cid;
+use Illuminate\Contracts\Validation\Rule;
+
+class ProblemaCondicaoCiapIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return false;
+    }
+
+    public static function isValid($problemasCondicoes, $idade)
+    {
+        if ($problemasCondicoes->where('ciap_grupo_id', GrupoCiap::PROCEDIMENTOS)->isNotEmpty()) {
+
+            return false;
+        }
+        else if ($problemasCondicoes->whereIn('ciap_codigo', self::getCiapsPreNatal())
+            ->whereIn('cid_codigo', self::getCidsDesfechoGestacao())
+            ->isNotEmpty()
+        ) {
+
+            return false;
+        }
+        else if (!is_null($idade)
+            && $idade < 9
+            && $problemasCondicoes->whereIn('ciap_codigo', self::getCiapsPreNatal())->isNotEmpty()
+        ) {
+
+            return false;
+        }
+        else if ($problemasCondicoes
+            ->where('ciap_codigo', Ciap::GRAVIDEZ)
+            ->whereNotNull('cid_id')
+            ->where('is_cid_familia_Z34', false)
+            ->isNotEmpty()
+        ) {
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'CIAP2 do problema e condição é inválido.';
+    }
+
+    private static function getCiapsPreNatal()
+    {
+        return [
+            Ciap::INFECCOES_QUE_COMPLICAM_A_GRAVIDEZ,
+            Ciap::GRAVIDEZ,
+            Ciap::GRAVIDEZ_NAO_DESEJADA,
+            Ciap::GRAVIDEZ_ECTOPICA,
+            Ciap::TOXEMIA_GRAVIDICA_DHEG,
+            Ciap::GRAVIDEZ_DE_ALTO_RISCO,
+            Ciap::DIABETES_GESTACIONAL,
+        ];
+    }
+
+    private static function getCidsDesfechoGestacao()
+    {
+        return [
+            Cid::OUTROS_PRODUTOS_ANORMAIS_DA_CONCEPCAO,
+            Cid::ABORTO_ESPONTANEO,
+            Cid::ABORTO_POR_RAZOES_MEDICAS_E_LEGAIS,
+            Cid::OUTROS_TIPOS_DE_ABORTO,
+            Cid::ABORTO_NAO_ESPECIFICADO,
+            Cid::RUPTURA_PREMATURA_DE_MEMBRANAS,
+            Cid::DESCOLAMENTO_PREMATURO_DA_PLACENTA_ABRUPTIO_PLACENTAE,
+            Cid::FALHA_NA_INDUCAO_DO_TRABALHO_DE_PARTO,
+            Cid::ANORMALIDADES_DA_CONTRACAO_UTERINA,
+            Cid::TRABALHO_DE_PARTO_PROLONGADO,
+            Cid::OBSTRUCAO_DO_TRABALHO_DE_PARTO_DEVIDA_A_MA_POSICAO_OU_MA_APRESENTACAO_DO_FETO,
+            Cid::OBSTRUCAO_DO_TRABALHO_DE_PARTO_DEVIDA_A_ANORMALIDADE_PELVICA_DA_MAE,
+            Cid::OUTRAS_FORMAS_DE_OBSTRUCAO_DO_TRABALHO_DE_PARTO,
+            Cid::TRABALHO_DE_PARTO_E_PARTO_COMPLICADOS_POR_HEMORRAGIA_INTRAPARTO_NAO_CLASSIFICADOS_EM_OUTRA_PARTE,
+            Cid::TRABALHO_DE_PARTO_E_PARTO_COMPLICADOS_POR_SOFRIMENTO_FETAL,
+            Cid::TRABALHO_DE_PARTO_E_PARTO_COMPLICADOS_POR_ANORMALIDADE_DO_CORDAO_UMBILICAL,
+            Cid::LACERACAO_DO_PERINEO_DURANTE_O_PARTO,
+            Cid::OUTROS_TRAUMATISMOS_OBSTETRICOS,
+            Cid::RETENCAO_DA_PLACENTA_E_DAS_MEMBRANAS_SEM_HEMORRAGIAS,
+            Cid::SOFRIMENTO_MATERNO_DURANTE_O_TRABALHO_DE_PARTO_E_O_PARTO,
+            Cid::CHOQUE_DURANTE_OU_SUBSEQUENTE_AO_TRABALHO_DE_PARTO_E_O_PARTO,
+            Cid::OUTRAS_COMPLICACOES_DE_PROCEDIMENTOS_OU_DE_CIRURGIA_OBSTETRICA,
+            Cid::DEMORA_DO_PARTO_APOS_RUPTURA_ARTIFICIAL_DAS_MEMBRANAS,
+            Cid::DEMORA_DO_PARTO_APOS_RUPTURA_ESPONTANEA_OU_NAO_ESPECIFICADA_DAS_MEMBRANAS,
+            Cid::PARTO_VAGINAL_SUBSEQUENTE_A_CESARIANA_ANTERIOR,
+            Cid::OUTRAS_COMPLICACOES_ESPECIFICADAS_DO_TRABALHO_DE_PARTO_E_DO_PARTO,
+            Cid::COMPLICACOES_DO_TRABALHO_DE_PARTO_E_DO_PARTO_NAO_ESPECIFICADAS,
+            Cid::PARTO_UNICO_ESPONTANEO,
+            Cid::PARTO_UNICO_POR_FORCEPS_OU_VACUO_EXTRATOR,
+            Cid::PARTO_UNICO_POR_CESARIANA,
+            Cid::OUTROS_TIPOS_DE_PARTO_UNICO_ASSISTIDO,
+            Cid::PARTO_MULTIPLO,
+            Cid::EXTRACAO_MENSTRUAL,
+            Cid::NASCIMENTO_UNICO_NATIVIVO_NADO_VIVO,
+            Cid::NASCIMENTO_UNICO_NATIMORTO_FETO_MORTO,
+            Cid::NASCIMENTO_GEMELAR_GEMEOS_AMBOS_NATIVIVOS_NADO_VIVOS,
+            Cid::NASCIMENTO_GEMELAR_UM_DOS_GEMEOS_NATIVIVO_NADO_VIVO_O_OUTRO_NATIMORTO_FETO_MORTO,
+            Cid::NASCIMENTO_GEMELAR_GEMEOS_NATIMORTOS_FETO_MORTOS,
+            Cid::OUTROS_NASCIMENTOS_MULTIPLOS_TODOS_NATIVIVOS_NADO_VIVOS,
+            Cid::OUTROS_NASCIMENTOS_MULTIPLOS_ALGUNS_NATIVIVOS_NADO_VIVOS,
+            Cid::OUTROS_NASCIMENTOS_MULTIPLOS_TODOS_NATIMORTOS_FETO_MORTOS,
+            Cid::NASCIMENTO_NAO_ESPECIFICADO,
+            Cid::NASCIDOS_VIVOS_SEGUNDO_O_LOCAL_DE_NASCIMENTO,
+            Cid::ASSISTENCIA_E_EXAME_POS_NATAL,
+        ];
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProblemaCondicaoCidIsDuplicated.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ProblemaCondicaoCidIsDuplicated implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($problemasCondicoes)
+    {
+        $problemasCondicoesCidsIds = $problemasCondicoes->whereNotNull('cid_id')->pluck('cid_id');
+
+        if ($problemasCondicoesCidsIds->count() > $problemasCondicoesCidsIds->unique()->count()) {
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'CID10 duplicado.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProblemaCondicaoCidIsValid.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ProblemaCondicaoCidIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($problemasCondicoes)
+    {
+        if ($problemasCondicoes->where('is_cid_familia_Z34', true)->count() > 1) {
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'CID10 do problema e condição é inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProblemaCondicaoCidOuCiapIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ProblemaCondicaoCidOuCiapIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($problemasCondicoes)
+    {
+        return $problemasCondicoes->whereNull('ciap_id')->whereNull('cid_id')->isEmpty();
+    }
+
+    public function message()
+    {
+        return 'CIAP2 ou CID10 é obrigatório para o problema e condição';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProblemaCondicaoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ProblemaCondicaoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($problemasCondicoes)
+    {
+        return $problemasCondicoes->isNotEmpty();
+    }
+
+    public function message()
+    {
+        return 'É obrigatório pelo menos um problema ou condição';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProcedenciaIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ProcedenciaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Procedência é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProcedimentoIsDuplicate.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoIsDuplicate implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        $result = DB::table('atencao_basica_procedimento_atendimento_procedimento')
+            ->where('procedimento_atendimento_id', $value->procedimento_atendimento_id)
+            ->where('procedimento_id', $value->procedimento_id)
+            ->count();
+
+        return $result > 1;
+    }
+
+    public function message()
+    {
+        return 'Procedimento em duplicidade.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProcedimentoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ProcedimentoIsRequired implements Rule
+{
+    public function passes($value, $quantidade)
+    {
+        return self::isValid($value, $quantidade);
+    }
+
+    public static function isValid($value, $quantidade)
+    {
+        return $value->escuta_inicial || !$value->escuta_inicial && $quantidade > 0;
+    }
+
+    public function message()
+    {
+        return 'Procedimento é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProcedimentoIsValidForFicha.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Sigtap\Procedimento;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoIsValidForFicha implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        $result = DB::table('sigtap.procedimento')
+            ->where('id', $value->procedimento_id)
+            ->orderBy('id', 'desc')
+            ->first();
+
+        return $result->codigo != Procedimento::ESCUTA_INICIAL_ORIENTACAO_ACOLHIMENTO_A_DEMANDA_ESPONT_NEA;
+    }
+
+    public function message()
+    {
+        return 'Procedimento inválido';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ProcedimentoLimitIsValid.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Procedimento\Limite;
+use Illuminate\Contracts\Validation\Rule;
+
+class ProcedimentoLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return $value < Limite::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A quantidade de procedimentos deve estar entre ' . Limite::MINIMO . ' e '. Limite::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PuerperaAndGestanteIsChecked.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class PuerperaAndGestanteIsChecked implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return $value->puerpera && $value->gestante;
+    }
+
+    public function message()
+    {
+        return 'Não é possível fornecer informações simultâneas sobre gestantes e puérperas.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/PuerperaIsValidForFicha.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\Cadastro\SujeitoAtencao\Sexo;
+use Illuminate\Contracts\Validation\Rule;
+
+class PuerperaIsValidForFicha implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !$value->puerpera || $value->paciente_sexo_id == Sexo::FEMININO && $value->puerpera;
+    }
+
+    public function message()
+    {
+        return 'Puerpera inválido para o sexo do paciente';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/RacaCorIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class RacaCorIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Raça é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ResponsavelTecnicoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ResponsavelTecnicoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Nome do responsável técnico é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/SaturacaoO2LimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\SaturacaoO2;
+use Illuminate\Contracts\Validation\Rule;
+
+class SaturacaoO2LimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (int) $value;
+
+        return $value >= SaturacaoO2::MINIMO && $value <= SaturacaoO2::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A saturação de O2 deve estar entre ' . SaturacaoO2::MINIMO . ' e '. SaturacaoO2::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/SexoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class SexoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Turno é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TelefoneIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class TelefoneIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Telefone é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TemperaturaLimitIsValid.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\Temperatura;
+use Illuminate\Contracts\Validation\Rule;
+
+class TemperaturaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        if (is_null($value)) {
+
+            return true;
+        }
+
+        $value = (float) $value;
+
+        return $value >= Temperatura::MINIMO && $value <= Temperatura::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A temperatura deve estar entre ' . Temperatura::MINIMO . ' e '. Temperatura::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoAtendimentoDomiciliarIsValid.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento as EnumsTipoAtendimento;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class TipoAtendimentoDomiciliarIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        $tipoAtendimento = DB::table('atencao_basica_cadastro_tipo_atendimento')
+            ->where('id', $value)
+            ->whereIn('id', [
+                EnumsTipoAtendimento::ATENDIMENTO_PROGRAMADO,
+                EnumsTipoAtendimento::ATENDIMENTO_NAO_PROGRAMADO,
+                EnumsTipoAtendimento::VISITA_DOMICILIAR_POS_OBITO,
+            ])
+            ->get();
+
+        return $tipoAtendimento->isNotEmpty();
+    }
+
+    public function message()
+    {
+        return 'Tipo de atendimento inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoAtendimentoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class TipoAtendimentoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Tipo de atendimento é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoAtendimentoIsValid.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento as EnumsTipoAtendimento;
+use Illuminate\Contracts\Validation\Rule;
+
+class TipoAtendimentoIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !collect([
+            EnumsTipoAtendimento::ATENDIMENTO_PROGRAMADO,
+            EnumsTipoAtendimento::ATENDIMENTO_NAO_PROGRAMADO,
+            EnumsTipoAtendimento::VISITA_DOMICILIAR_POS_OBITO,
+        ])->contains($value);
+    }
+
+    public function message()
+    {
+        return 'Tipo de atendimento inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoConsultaIsRequired.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
+use Illuminate\Contracts\Validation\Rule;
+
+
+class TipoConsultaIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        if ($value->tipo_atendimento_id == TipoAtendimento::CONSULTA_AGENDADA && $value->tipo_consulta_id == null) {
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'Tipo de consulta é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoConsultaIsValid.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
+use App\Enums\AtencaoBasica\AtendimentoOdontologico\TipoConsulta;
+use Illuminate\Contracts\Validation\Rule;
+
+
+class TipoConsultaIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        if ($value->tipo_atendimento_id == TipoAtendimento::ESCUTA_INICIAL_ORIENTACAO && $value->tipo_consulta_id) {
+
+            return false;
+        }
+
+        if ($value->tipo_atendimento_id == TipoAtendimento::ATENDIMENTO_DE_URGENCIA
+            && $value->tipo_consulta_id == TipoConsulta::CONSULTA_RETORNO) {
+
+                return false;
+        }
+
+        return true;
+    }
+
+    public function message()
+    {
+        return 'Tipo de consulta é inválido.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoImovelsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class TipoImovelsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Tipo de imovél é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoModalidadeIsRequired.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
+use Illuminate\Contracts\Validation\Rule;
+
+
+class TipoModalidadeIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        return $value->tipo_atendimento_id != TipoAtendimento::VISITA_DOMICILIAR_POS_OBITO
+            && !$value->modalidade_id ? false : true;
+    }
+
+    public function message()
+    {
+        return 'A modalidade é obrigatória.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TipoModalidadeIsValid.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
+use App\Enums\AtencaoBasica\Avaliacao\Conclusao;
+use Illuminate\Contracts\Validation\Rule;
+
+
+class TipoModalidadeIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+
+        return ($value->tipo_atendimento_id == TipoAtendimento::VISITA_DOMICILIAR_POS_OBITO
+            && $value->modalidade_id) || ($value->modalidade_id == Conclusao::INELEGIVEL) ? false : true;
+    }
+
+    public function message()
+    {
+        return 'A modalidade é inválida.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/TurnoIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class TurnoIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Turno é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/UfIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class UfIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return !empty($value);
+    }
+
+    public function message()
+    {
+        return 'Uf é obrigatório.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/VacinaIsDuplicate.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class VacinaIsDuplicate implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        $result = DB::table('atencao_basica_vacinacao_paciente_item')
+            ->where('registro_anterior', false)
+            ->where('vacinacao_paciente_id', $value->vacinacao_paciente_id)
+            ->where('vacina_id', $value->vacina_id)
+            ->count();
+
+        return $result > 1;
+    }
+
+    public function message()
+    {
+        return 'Vacina em duplicidade.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/VacinaIsValid.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Support\Facades\DB;
+
+class VacinaIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return DB::table('atencao_basica_vacinacao_regra')
+            ->where('codigo', $value->vacina_codigo)
+            ->where('dose', $value->dose_codigo)
+            ->where('estrategia', $value->estrategia_codigo)
+            ->exists();
+    }
+
+    public function message()
+    {
+        return 'Vacina inválida.';
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/VacinaLimitIsValid.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use App\Enums\AtencaoBasica\Exportacao\Limite;
+use Illuminate\Contracts\Validation\Rule;
+
+class VacinaLimitIsValid implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return $value >= Limite::MINIMO && $value <= Limite::MAXIMO;
+    }
+
+    public function message()
+    {
+        return 'A quantidade de registros deve estar entre ' . Limite::MINIMO . ' e '. Limite::MAXIMO;
+    }
+}

api/app/Rules/AtencaoBasica/Exportacao/ViajanteIsRequired.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Rules\AtencaoBasica\Exportacao;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class ViajanteIsRequired implements Rule
+{
+    public function passes($attribute, $value)
+    {
+        return self::isValid($value);
+    }
+
+    public static function isValid($value)
+    {
+        return is_bool($value);
+    }
+
+    public function message()
+    {
+        return 'Viajante é obrigatório.';
+    }
+}