rkm-conectasus-ci-sandbox/api/app/Services/Integracao/Esus/GerenciamentoEnvio/Ficha/FichaAtividadeColetiva.php

<?php

namespace App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha;

use App\Enums\AtencaoBasica\AtividadeColetiva\AtividadeTipo as AtividadeColetivaAtividadeTipo;
use App\Models\AtencaoBasica\AtividadeColetiva\AtividadeTipo;
use App\Models\AtencaoBasica\AtividadeColetiva\Profissional;
use App\Models\AtencaoBasica\AtividadeColetiva\PublicoAlvo;
use App\Models\AtencaoBasica\AtividadeColetiva\ReuniaoTema;
use App\Models\AtencaoBasica\AtividadeColetiva\SaudePratica;
use App\Models\AtencaoBasica\AtividadeColetiva\SaudeTema;
use App\Models\AtencaoBasica\AtividadeColetiva\Turno;
use App\Models\Sigtap\Ocupacao;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;

class FichaAtividadeColetiva extends Ficha
{
    public function __construct($xmlEnvio, $inconsistenciaModel)
    {
        parent::__construct($xmlEnvio, $inconsistenciaModel);

        $this->domx->registerNamespace('ns4', 'http://esus.ufsc.br/fichaatividadecoletiva');
    }

    public function __invoke()
    {
        $path = '//ns4:fichaAtividadeColetivaTransport';

        $this->setCadastro($path);
        $this->setProfissionalResponsavel($path);
        $this->setOutrosProfissionais($path);
        $this->setAtividade($path);
        $this->setTemasReuniao($path);
        $this->setPublicoAlvo($path);
        $this->setTemasSaude($path);
        $this->setPraticasSaude($path);
        $this->setParticipantes($path);

        return $this->ficha;
    }

    private function setCadastro($fichaAtividadeColetivaTransportPath)
    {
        $headerTransportPath = "{$fichaAtividadeColetivaTransportPath}/headerTransport";

        $campos = (object) [
            'dataAtendimento' => $this->getDateString($this->getFirstNodeValue("{$headerTransportPath}/dataAtendimento")),
            'pseEducacao' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue("$fichaAtividadeColetivaTransportPath/pseEducacao"))),
            'pseSaude' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue("$fichaAtividadeColetivaTransportPath/pseSaude"))),
            'inep' => $this->getFirstNodeValue("$fichaAtividadeColetivaTransportPath/inep"),
            'outraLocalidade' => $this->getFirstNodeValue("$fichaAtividadeColetivaTransportPath/outraLocalidade"),
            'cnesLocalAtividade' => $this->getFirstNodeValue("$fichaAtividadeColetivaTransportPath/cnesLocalAtividade"),
            'turno' => $this->getFirstNodeValue("$fichaAtividadeColetivaTransportPath/turno")
                ? Turno::find($this->getFirstNodeValue("$fichaAtividadeColetivaTransportPath/turno"))->descricao
                : null,
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Data', fn () => $this->inconsistencias->headerTransport->dataAtendimento],
            ['PSE educação', fn () => $this->inconsistencias->pseEducacao],
            ['PSE saúde', fn () => $this->inconsistencias->pseSaude],
            ['INEP', fn () => $this->inconsistencias->inep],
            ['Outra localidade', fn () => $this->inconsistencias->outraLocalidade],
            ['CNES', fn () => $this->inconsistencias->cnesLocalAtividade],
            ['Turno', fn () => $this->inconsistencias->turno],
        ]);

        $this->ficha->cadastro = (object) compact('campos', 'inconsistencias');
    }

    private function setProfissionalResponsavel($fichaAtividadeColetivaTransportPath)
    {
        $headerTransportPath = "{$fichaAtividadeColetivaTransportPath}/headerTransport";

        $ocupacao = $this->getFirstNodeValue("{$headerTransportPath}/cboCodigo_2002")
            ? Ocupacao::where('codigo', $this->getFirstNodeValue("{$headerTransportPath}/cboCodigo_2002"))->first()
            : null;

        $campos = (object) [
            'codigoIbgeMunicipio' => $this->getFirstNodeValue("{$headerTransportPath}/codigoIbgeMunicipio"),
            'profissionalNome' => $this->inconsistenciaModel->atividadeColetiva->usuario->cidadao->nome,
            'profissionalCNS' => MaskUtil::getCnsMasked($this->getFirstNodeValue("{$headerTransportPath}/profissionalCNS")),
            'cboCodigo_2002' => $ocupacao ? "{$ocupacao->codigo} - {$ocupacao->nome}" : null,
            'cnes' => $this->getFirstNodeValue("{$headerTransportPath}/cnes"),
            'ine' => $this->getFirstNodeValue("{$headerTransportPath}/ine"),
        ];

        $profissionalInconsistencia = collect($this->inconsistencias->profissionais ?? [])
            ->pluck('cnsProfissional')
            ->filter()
            ->first();

        $inconsistencias = $this->getInconsistencias([
            ['IBGE', fn () => $this->inconsistencias->headerTransport->codigoIbgeMunicipio],
            ['CNS', fn () => $profissionalInconsistencia],
            ['CBO', fn () => $this->inconsistencias->headerTransport->cboCodigo_2002],
            ['CNES', fn () => $this->inconsistencias->headerTransport->cnes],
            ['INE', fn () => $this->inconsistencias->headerTransport->ine],
        ]);

        $this->ficha->profissional_responsavel = (object) compact('campos', 'inconsistencias');
    }

    private function setOutrosProfissionais($fichaAtividadeColetivaTransportPath)
    {
        $path = $fichaAtividadeColetivaTransportPath;

        $profissionais = [];

        foreach ($this->domx->query("{$path}/profissionais") as $context) {

            $ocupacao = $this->getFirstNodeValue('codigoCbo2002', $context)
                ? Ocupacao::where('codigo', $this->getFirstNodeValue('codigoCbo2002', $context))->first()
                : null;

            $profissionais[] = (object) [
                'nomeProfissional' => Profissional::where('atividade_coletiva_id', $this->inconsistenciaModel->atividadeColetiva->id)
                    ->whereHas('usuario', fn ($q) => $q
                        ->whereHas('cidadao', fn ($q) => $q
                            ->where('cns', $this->getFirstNodeValue('cnsProfissional', $context))
                        )
                    )
                    ->first()->usuario->cidadao->nome
                    ?? ($this->inconsistenciaModel->atividadeColetiva->usuario->cidadao->cns
                        === $this->getFirstNodeValue('cnsProfissional', $context)
                        ? $this->inconsistenciaModel->atividadeColetiva->usuario->cidadao->nome : null),
                'cnsProfissional' => MaskUtil::getCnsMasked($this->getFirstNodeValue('cnsProfissional', $context)),
                'codigoCbo2002' => $ocupacao ? "{$ocupacao->codigo} - {$ocupacao->nome}" : null,
            ];
        }

        $this->ficha->outros_profissionais = (object) [
            'lista' => $profissionais,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $this->inconsistencias->profissionais,
            ]),
        ];
    }

    private function setAtividade($fichaAtividadeColetivaTransportPath)
    {
        $path = $fichaAtividadeColetivaTransportPath;

        $atividadeTipoId = $this->getFirstNodeValue("{$path}/atividadeTipo");

        $campos = (object) [
            'showTemasReuniao' => collect([
                AtividadeColetivaAtividadeTipo::REUNIAO_COM_OUTRAS_EQUIPES_DE_SAUDE,
                AtividadeColetivaAtividadeTipo::REUNIAO_DE_EQUIPE,
                AtividadeColetivaAtividadeTipo::REUNIAO_INTERSETORIAL_CONSELHO_LOCAL_DE_SAUDE_CONTROLE_SOCIAL,
            ])->contains($atividadeTipoId),
            'showPublicoAlvoTemasSaude' => collect([
                AtividadeColetivaAtividadeTipo::EDUCACAO_EM_SAUDE,
                AtividadeColetivaAtividadeTipo::ATENDIMENTO_EM_GRUPO,
                AtividadeColetivaAtividadeTipo::AVALIACAO_PROCEDIMENTO_COLETIVO,
                AtividadeColetivaAtividadeTipo::MOBILIZACAO_SOCIAL,
            ])->contains($atividadeTipoId),
            'showPraticasSaude' => collect([
                AtividadeColetivaAtividadeTipo::ATENDIMENTO_EM_GRUPO,
                AtividadeColetivaAtividadeTipo::AVALIACAO_PROCEDIMENTO_COLETIVO,
            ])->contains($atividadeTipoId),
            'atividadeTipo' => $atividadeTipoId
                ? AtividadeTipo::find($atividadeTipoId)->descricao
                : null,
            'numParticipantes' => $this->getFirstNodeValue("{$path}/numParticipantes"),
            'numAvaliacoesAlteradas' => $this->getFirstNodeValue("{$path}/numAvaliacoesAlteradas"),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Atividade', fn () => $this->inconsistencias->atividadeTipo],
            ['Participantes', fn () => $this->inconsistencias->numParticipantes],
            ['Avaliações alteradas', fn () => $this->inconsistencias->numAvaliacoesAlteradas],
        ]);

        $this->ficha->atividade = (object) compact('campos', 'inconsistencias');
    }

    private function setTemasReuniao($fichaAtividadeColetivaTransportPath)
    {
        $path = $fichaAtividadeColetivaTransportPath;

        $temas = [];

        foreach ($this->domx->query("{$path}/temasParaReuniao") as $context) {

            $temas[] = ReuniaoTema::find($context->nodeValue)->descricao;
        }

        $this->ficha->temas_reuniao = (object) [
            'lista' => $temas,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $this->inconsistencias->temasParaReuniao,
            ]),
        ];
    }

    private function setPublicoAlvo($fichaAtividadeColetivaTransportPath)
    {
        $path = $fichaAtividadeColetivaTransportPath;

        $publicosAlvos = [];

        foreach ($this->domx->query("{$path}/publicoAlvo") as $context) {

            $publicosAlvos[] = PublicoAlvo::find($context->nodeValue)->descricao;
        }

        $this->ficha->publico_alvo = (object) [
            'lista' => $publicosAlvos,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $this->inconsistencias->publicoAlvo,
            ]),
        ];
    }

    private function setTemasSaude($fichaAtividadeColetivaTransportPath)
    {
        $path = $fichaAtividadeColetivaTransportPath;

        $temasSaude = [];

        foreach ($this->domx->query("{$path}/temasParaSaude") as $context) {

            $temasSaude[] = SaudeTema::find($context->nodeValue)->descricao;
        }

        $this->ficha->temas_saude = (object) [
            'lista' => $temasSaude,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $this->inconsistencias->temasParaSaude,
            ]),
        ];
    }

    private function setPraticasSaude($fichaAtividadeColetivaTransportPath)
    {
        $path = $fichaAtividadeColetivaTransportPath;

        $praticasSaude = [];

        foreach ($this->domx->query("{$path}/praticasEmSaude") as $context) {

            $praticasSaude[] = SaudePratica::find($context->nodeValue)->descricao;
        }

        $this->ficha->praticas_saude = (object) [
            'lista' => $praticasSaude,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $this->inconsistencias->praticasEmSaude,
            ]),
        ];
    }

    private function setParticipantes($fichaAtividadeColetivaTransportPath)
    {
        $path = "{$fichaAtividadeColetivaTransportPath}/participantes";

        $participantes = [];

        foreach ($this->domx->query($path) as $i => $context) {

            $posicao = $i + 1;

            $participanteModel = $this->inconsistenciaModel->atividadeColetivaParticipantes()
                ->wherePivot('posicao', $posicao)
                ->first();

            $inconsistencias = $this->inconsistencias->participantes->{$posicao} ?? [];

            $participantes[] = (object) [
                'campos' => (object) [
                    'nomeParticipante' => $participanteModel->paciente->cidadao->nome,
                    'cnsParticipante' => MaskUtil::getCnsMasked($this->getFirstNodeValue('cnsParticipante', $context)),
                    'cpfParticipante' => MaskUtil::getCpfMasked($this->getFirstNodeValue('cpfParticipante', $context)),
                    'dataNascimento' => $this->getDateString($this->getFirstNodeValue('dataNascimento', $context)),
                    'avaliacaoAlterada' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                        $this->getFirstNodeValue('avaliacaoAlterada', $context))),
                    'peso' => $this->getFirstNodeValue('peso', $context),
                    'altura' => $this->getFirstNodeValue('altura', $context),
                    'cessouHabitoFumar' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                        $this->getFirstNodeValue('cessouHabitoFumar', $context))),
                    'abandonouGrupo' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                        $this->getFirstNodeValue('abandonouGrupo', $context))),
                    'sexo' => $this->getSexo($this->getFirstNodeValue('sexo', $context)),
                ],
                'inconsistencias' => $this->getInconsistencias([
                    ['CNS', fn () => $inconsistencias->cnsParticipante],
                    ['CPF', fn () => $inconsistencias->cpfParticipante],
                    ['Data de nascimento', fn () => $inconsistencias->dataNascimento],
                    ['Alterada', fn () => $inconsistencias->avaliacaoAlterada],
                    ['Peso', fn () => $inconsistencias->peso],
                    ['Altura', fn () => $inconsistencias->altura],
                    ['Parou de fumar', fn () => $inconsistencias->cessouHabitoFumar],
                    ['Abandonou grupo', fn () => $inconsistencias->abandonouGrupo],
                    ['Sexo', fn () => $inconsistencias->sexo],
                ]),
            ];
        }

        $this->ficha->participantes = (object) [
            'lista' => $participantes,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $this->inconsistencias->participantes,
            ]),
        ];
    }
}