rkm-conectasus-ci-sandbox/api/app/Services/AtencaoBasica/RelatorioInconsistencia/FichaAvaliacaoElegibilidadeService.php

<?php

namespace App\Services\AtencaoBasica\RelatorioInconsistencia;

use App\Enums\AtencaoBasica\Exportacao\Inconsistencia;
use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Enums\Cadastro\SujeitoAtencao\RacaCor;
use App\Rules\AtencaoBasica\Exportacao\CidAavaliacaoIsDuplicate;
use App\Rules\AtencaoBasica\Exportacao\CidIsRequired;
use App\Rules\AtencaoBasica\Exportacao\CnesIsValid;
use App\Rules\AtencaoBasica\Exportacao\CnsPaciente;
use App\Rules\AtencaoBasica\Exportacao\ConclusaoIsRequired;
use App\Rules\AtencaoBasica\Exportacao\DataAtendimentoIsValid;
use App\Rules\AtencaoBasica\Exportacao\DataNascimentoIsRequired;
use App\Rules\AtencaoBasica\Exportacao\DataNascimentoIsValid;
use App\Rules\AtencaoBasica\Exportacao\IbgeIsValid;
use App\Rules\AtencaoBasica\Exportacao\OcupacaoIsAllowed;
use App\Rules\AtencaoBasica\Exportacao\ProcedenciaIsRequired;
use App\Rules\AtencaoBasica\Exportacao\RacaCorIsRequired;
use App\Rules\AtencaoBasica\Exportacao\SexoIsRequired;
use App\Rules\AtencaoBasica\Exportacao\TurnoIsRequired;
use App\Rules\Cns;
use App\Rules\Cpf;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;

class FichaAvaliacaoElegibilidadeService extends Service
{
    private const FICHA_LABEL = 'Avaliaçăo de elegibilidade e admissăo';

    private const ERROR_MAP = [
        CnesIsValid::class => Inconsistencia::CNES_DA_UNIDADE_COM_TAMANHO_DIFERENTE_DE_7_CARACTERES,
        IbgeIsValid::class => Inconsistencia::IBGE_DO_MUNICIPIO_SEM_PREENCHIMENTO_OU_INVALIDO,
        Cns::class => Inconsistencia::CNS_DO_PROFISSIONAL_INVALIDO,
        OcupacaoIsAllowed::class => Inconsistencia::OCUPACAO_DO_USUARIO_SEM_PERMISSAO_PARA_REGISTRAR_A_FICHA,
        DataAtendimentoIsValid::class => Inconsistencia::DATA_ATENDIMENTO_INVALIDO,
        CnsPaciente::class => Inconsistencia::CNS_DO_PACIENTE_INVALIDO,
        Cpf::class => Inconsistencia::CPF_DO_PACIENTE_INVALIDO,
        DataNascimentoIsRequired::class => Inconsistencia::DATA_NASCIMENTO_SEM_PREENCHIMENTO,
        DataNascimentoIsValid::class => Inconsistencia::DATA_DE_NASCIMENTO_POSTERIOR_A_DATA_DE_ATENDIMENTO_SUPERIOR_A_130_ANOS_OU_NAO_PREENCHIDA,
        TurnoIsRequired::class => Inconsistencia::TURNO_SEM_PREENCHIMENTO,
        SexoIsRequired::class => Inconsistencia::SEXO_DO_PACIENTE_SEM_PREENCHIMENTO,
        RacaCorIsRequired::class => Inconsistencia::RACA_COR_SEM_PREENCHIMENTO,
        ProcedenciaIsRequired::class => Inconsistencia::PROCEDENCIA_SEM_PREENCHIMENTO,
        ConclusaoIsRequired::class => Inconsistencia::CONCLUSAO_SEM_PREENCHIMENTO,
        CidIsRequired::class => Inconsistencia::CID_PRINCIPAL_SEM_PREENCHIMENTO,
        CidAavaliacaoIsDuplicate::class => Inconsistencia::CID_EM_DUPLICIDADE,
    ];

    public static function index()
    {
        $mes_ano = request()->mes_ano;
        $date = Carbon::createFromFormat('mY', $mes_ano);
        $start = $date->copy()->startOfMonth()->toDateString();
        $end = $date->copy()->endOfMonth()->toDateString();

        $inconsistencias = DB::table('atencao_basica_inconsistencia')
            ->select('id', 'descricao')
            ->get()
            ->pluck('descricao', 'id');

        $fichasAvaliacao = DB::table('atencao_basica_avaliacao')
            ->select([
                'atencao_basica_avaliacao.id as id',
                'atencao_basica_avaliacao.usuario_id as usuario_id',
                'atencao_basica_avaliacao.data as data_atendimento',
                'cadastro_unidade.cnes as unidade_cnes',
                'cadastro_municipio.ibge as municipio_ibge',
                'sigtap.ocupacao.codigo as ocupacao_codigo',
                'cadastro_cidadao.cns AS usuario_cns',
                'cadastro_cidadao.nome AS profissional_nome',
                'paciente_cidadao.raca_cor_id as paciente_raca_cor_id',
                'paciente_cidadao.cns as paciente_cns',
                'paciente_cidadao.cpf as paciente_cpf',
                'paciente_cidadao.nome as paciente_nome',
                'paciente_cidadao.nome_social as paciente_nome_social',
                'paciente_cidadao.preferencia_nome_id as paciente_preferencia_nome_id',
                'paciente_cidadao.data_nascimento as paciente_data_nascimento',
                'paciente_cidadao.sexo_id as paciente_sexo_id',
                DB::raw('LPAD(cadastro_paciente.prontuario,7,0) AS paciente_prontuario'),
                'atencao_basica_avaliacao.turno_id',
                'atencao_basica_avaliacao.paciente_id',
                'atencao_basica_avaliacao.procedencia_id',
                'atencao_basica_avaliacao.conclusao_id',
                'atencao_basica_avaliacao.cid_primario',
                'atencao_basica_avaliacao.cid_secundario',
                'atencao_basica_avaliacao.cid_terciario',
                'atencao_basica_avaliacao.cns_cuidador',
                'atencao_basica_avaliacao.cpf_cuidador',
            ])
            ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_avaliacao.equipe_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
            ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'atencao_basica_parametrizacao_equipe.infraestrutura_id')
            ->leftJoin('cadastro_endereco', 'cadastro_endereco.id', 'cadastro_infraestrutura.endereco_id')
            ->leftJoin('cadastro_logradouro', 'cadastro_logradouro.id', 'cadastro_endereco.logradouro_id')
            ->leftJoin('intranet.cadastro_municipio', 'cadastro_municipio.id', 'cadastro_logradouro.municipio_id')
            ->join('cadastro_usuario', 'cadastro_usuario.id', 'atencao_basica_avaliacao.usuario_id')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->join('sigtap.ocupacao', 'sigtap.ocupacao.id', 'atencao_basica_avaliacao.ocupacao_id')
            ->join('cadastro_paciente', 'cadastro_paciente.id', 'atencao_basica_avaliacao.paciente_id')
            ->join('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'cadastro_paciente.cidadao_id')
            ->whereBetween('atencao_basica_avaliacao.data', [$start, $end])
            ->when(request()->unidade_id, fn ($query) => $query->where('atencao_basica_parametrizacao_equipe.unidade_id', request()->unidade_id))
            ->when(request()->infraestrutura_id, fn ($query) => $query->where('atencao_basica_parametrizacao_equipe.infraestrutura_id', request()->infraestrutura_id))
            ->when(request()->usuario_id, fn ($query) => $query->where('atencao_basica_avaliacao.usuario_id', request()->usuario_id))
            ->get();

        $groupedList = [];

        foreach ($fichasAvaliacao as $ficha) {

            $errosHeader = RelatorioInconsistenciaService::validHeader($ficha, Permissao::AVALIACAO_ELEGIBILIDADE_ADMISSAO);
            $errosAtendimento = self::validAtendimento($ficha);

            $errors = $errosHeader->merge($errosAtendimento);
            $errorDescriptions = self::mapErrorsToDescriptions($errors, $inconsistencias);

            if (
                $errosAtendimento->isNotEmpty()
                && ($ficha->cns_cuidador || $ficha->cpf_cuidador)
                && !Cns::isValid($ficha->paciente_cns)
                && !Cpf::isValid($ficha->paciente_cpf)
            ) {

                $descricao = $inconsistencias[Inconsistencia::CNS_DO_CUIDADOR_INVALIDO] ?? null;

                if ($descricao !== null) {
                    $errorDescriptions->push($descricao);
                }
            }

            if ($errorDescriptions->isEmpty()) {
                continue;
            }

            $key = $ficha->data_atendimento . '|' . $ficha->paciente_id . '|' . $ficha->usuario_id;

            if (!isset($groupedList[$key])) {

                $groupedList[$key] = [
                    'data' => (new Carbon($ficha->data_atendimento))->format('d/m/Y'),
                    'ficha' => self::FICHA_LABEL,
                    'paciente_nome' => $ficha->paciente_nome,
                    'paciente_nome_social' => $ficha->paciente_nome_social,
                    'paciente_preferencia_nome_id' => $ficha->paciente_preferencia_nome_id,
                    'paciente_prontuario' => $ficha->paciente_prontuario,
                    'paciente_cns' => $ficha->paciente_cns ? MaskUtil::getCnsMasked($ficha->paciente_cns) : '-',
                    'paciente_cpf' => $ficha->paciente_cpf ? MaskUtil::getCpfMasked($ficha->paciente_cpf) : '-',
                    'profissional' => $ficha->profissional_nome,
                    'erros' => $errorDescriptions,
                ];
            } else {
                $groupedList[$key]['erros'] = $groupedList[$key]['erros']->merge($errorDescriptions);
            }
        }

        $result = [];

        foreach ($groupedList as $group) {

            $unique = $group['erros']->unique();
            $group['erros'] = $unique->implode('<br />');
            $group['total_erros'] = $unique->count();
            $result[] = $group;
        }

        return $result;
    }

    private static function mapErrorsToDescriptions(Collection $errors, Collection $inconsistencias): Collection
    {
        $descriptions = collect();

        foreach ($errors as $error) {

            $inconsistenciaId = self::ERROR_MAP[$error] ?? null;

            if ($inconsistenciaId === null) {
                continue;
            }

            $descricao = $inconsistencias[$inconsistenciaId] ?? null;

            if ($descricao !== null) {
                $descriptions->push($descricao);
            }
        }

        return $descriptions;
    }

    private static function validAtendimento($ficha): Collection
    {
        $errors = collect();

        if (!Cns::isValid($ficha->paciente_cns) && !Cpf::isValid($ficha->paciente_cpf)) {
            $errors->push(CnsPaciente::class);
            $errors->push(Cpf::class);
        }

        if (!DataNascimentoIsRequired::isValid($ficha->paciente_data_nascimento)) {
            $errors->push(DataNascimentoIsRequired::class);
        }

        if (!DataNascimentoIsValid::isValid([
                'data_nascimento' => $ficha->paciente_data_nascimento,
                'data_atendimento' => $ficha->data_atendimento
        ])) {
            $errors->push(DataNascimentoIsValid::class);
        }

        if (!TurnoIsRequired::isValid($ficha->turno_id)) {
            $errors->push(TurnoIsRequired::class);
        }

        if (!SexoIsRequired::isValid($ficha->paciente_sexo_id)) {
            $errors->push(SexoIsRequired::class);
        }

        if (!RacaCorIsRequired::isValid($ficha->paciente_raca_cor_id)) {
            $errors->push(RacaCorIsRequired::class);
        }

        if ($ficha->paciente_raca_cor_id == RacaCor::SEM_INFORMACAO) {
            $errors->push(RacaCorIsRequired::class);
        }

        if (!ProcedenciaIsRequired::isValid($ficha->procedencia_id)) {
            $errors->push(ProcedenciaIsRequired::class);
        }

        if (!ConclusaoIsRequired::isValid($ficha->conclusao_id)) {
            $errors->push(ConclusaoIsRequired::class);
        }

        if (!CidIsRequired::isValid($ficha->cid_primario)) {
            $errors->push(CidIsRequired::class);
        }

        if (!CidAavaliacaoIsDuplicate::isValid($ficha)) {
            $errors->push(CidAavaliacaoIsDuplicate::class);
        }

        return $errors;
    }
}