init commit

api/app/Services/Bpa/ExportRelatorioInconsistenciaService.php

@@ -0,0 +1,182 @@
+<?php
+
+namespace App\Services\Bpa;
+
+use App\Enums\Sigtap\Registro;
+use App\Models\Bpa\Inconsistencia;
+use App\Services\Service;
+use Illuminate\Support\Facades\DB;
+
+class ExportRelatorioInconsistenciaService extends Service
+{
+    public static function index()
+    {
+        switch (request()->query('registro_codigo')) {
+            case Registro::BPA_CONSOLIDADO:
+                return self::getProcedimentosConsolidados(request()->query());
+                break;
+
+            case Registro::BPA_INDIVIDUALIZADO:
+                return self::getProcedimentosIndividualizados(request()->query());
+                break;
+        }
+    }
+
+    private static function getProcedimentosConsolidados($params)
+    {
+        return DB::table('bpa_procedimento')
+            ->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
+            ->join('sigtap.competencia', 'competencia.id', 'bpa_procedimento.competencia_id')
+            ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->join('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
+            ->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
+            ->join('bpa_procedimento_inconsistencia', 'bpa_procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+            ->join('bpa_inconsistencia', 'bpa_inconsistencia.id', 'bpa_procedimento_inconsistencia.inconsistencia_id')
+            ->select([
+                'bpa_procedimento.id',
+                'bpa_procedimento.origem',
+                'cadastro_unidade.id AS unidade_id',
+                'cadastro_unidade.nome_fantasia AS unidade_nome',
+                'competencia.id AS competencia_id',
+                'competencia.valor AS competencia_valor',
+                'procedimento.id AS procedimento_id',
+                'procedimento.codigo AS procedimento_codigo',
+                'procedimento.nome AS procedimento_nome',
+                'registro.id AS registro_id',
+                'registro.codigo AS registro_codigo',
+                'ocupacao.id AS ocupacao_id',
+                'ocupacao.codigo AS ocupacao_codigo',
+                'ocupacao.nome AS ocupacao_nome',
+                'bpa_procedimento.idade',
+                'bpa_inconsistencia.codigo AS inconsistencia_codigo',
+                'bpa_inconsistencia.descricao AS inconsistencia_descricao',
+                DB::raw('SUM(bpa_procedimento.quantidade) AS quantidade'),
+            ])
+            ->whereNull('bpa_procedimento.deleted_at')
+            ->where([
+                'bpa_procedimento.unidade_id' => $params['unidade_id'],
+                'bpa_procedimento.competencia_id' => $params['competencia_id'],
+            ])
+            ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+            ->whereExists(function($query) {
+                $query->select(DB::raw(1))
+                    ->from('bpa_procedimento_inconsistencia')
+                    ->whereColumn('bpa_procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id');
+            })
+            ->groupBy([
+                'bpa_procedimento.origem',
+                'cadastro_unidade.id',
+                'cadastro_unidade.nome_fantasia',
+                'competencia.valor',
+                'procedimento.id',
+                'procedimento.codigo',
+                'procedimento.nome',
+                'registro.id',
+                'registro.codigo',
+                'ocupacao.id',
+                'ocupacao.codigo',
+                'ocupacao.nome',
+                'bpa_procedimento.idade',
+            ])
+            ->get();
+    }
+
+    private static function getProcedimentosIndividualizados($params)
+    {
+        return DB::table('bpa_procedimento')
+            ->select([
+                'bpa_procedimento.origem',
+                'cadastro_unidade.id AS unidade_id',
+                'cadastro_unidade.nome_fantasia AS unidade_nome',
+                'competencia.id AS competencia_id',
+                'competencia.valor AS competencia_valor',
+                'cadastro_cidadao_usuario.nome AS usuario_nome',
+                'cadastro_paciente.id AS paciente_id',
+                'cadastro_cidadao_paciente.nome AS paciente_nome',
+                'procedimento.id AS procedimento_id',
+                'procedimento.codigo AS procedimento_codigo',
+                'procedimento.nome AS procedimento_nome',
+                'ocupacao.id AS ocupacao_id',
+                'ocupacao.codigo AS ocupacao_codigo',
+                'ocupacao.nome AS ocupacao_nome',
+                'bpa_procedimento.quantidade',
+                'registro.codigo AS registro_codigo',
+                'bpa_inconsistencia.codigo AS inconsistencia_codigo',
+                'bpa_inconsistencia.descricao AS inconsistencia_descricao',
+            ])
+            ->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
+            ->join('sigtap.competencia', 'competencia.id', 'bpa_procedimento.competencia_id')
+            ->join('cadastro_usuario', 'cadastro_usuario.id', 'bpa_procedimento.usuario_id')
+            ->join('cadastro_cidadao AS cadastro_cidadao_usuario', 'cadastro_cidadao_usuario.id', 'cadastro_usuario.cidadao_id')
+            ->join('cadastro_paciente', 'cadastro_paciente.id', 'bpa_procedimento.paciente_id')
+            ->join('cadastro_cidadao AS cadastro_cidadao_paciente', 'cadastro_cidadao_paciente.id', 'cadastro_paciente.cidadao_id')
+            ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
+            ->join('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
+            ->join('bpa_procedimento_inconsistencia', 'bpa_procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+            ->join('bpa_inconsistencia', 'bpa_inconsistencia.id', 'bpa_procedimento_inconsistencia.inconsistencia_id')
+            ->whereNull('bpa_procedimento.deleted_at')
+            ->where([
+                'bpa_procedimento.unidade_id' => $params['unidade_id'],
+                'bpa_procedimento.competencia_id' => $params['competencia_id'],
+            ])
+            ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+            ->whereExists(function($query) {
+                $query->select(DB::raw(1))
+                    ->from('bpa_procedimento_inconsistencia')
+                    ->whereColumn('bpa_procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id');
+            })
+            ->get();
+    }
+
+    public static function getPrintExportData() {
+        $resultado = self::index();
+        $colunas = collect(request()->selectedCols);
+
+        $colunas = $colunas->reject(function ($item) {
+            return $item['key'] === 'actions';
+        });
+
+        $colunasAdicionais = [
+            [
+                "key" => "inconsistencia_codigo",
+                "label" => "Código",
+                "class" => null
+            ],
+            [
+                "key" => "inconsistencia_descricao",
+                "label" => "Descrição",
+                "class" => null
+            ]
+        ];
+
+
+        $colunas = $colunas->map(function ($item) {
+            return [
+                'key' => $item['key'] === 'ocupacao' ? 'ocupacao_nome' : ($item['key'] === 'procedimento' ? 'procedimento_nome' : $item['key']),
+                'label' => $item['key'] === 'ocupacao' ? 'Ocupação' : ($item['key'] === 'procedimento' ? 'Procedimento' : $item['label']),
+                'class' => $item['class'],
+            ];
+        });
+
+        $colunas = $colunas->merge($colunasAdicionais);
+        $instrumento_registro = '';
+
+        if(Registro::BPA_CONSOLIDADO == request()->registro_codigo){
+            $instrumento_registro = 'BPA - Consolidado';
+        }
+
+        if(Registro::BPA_INDIVIDUALIZADO == request()->registro_codigo){
+            $instrumento_registro = 'BPA - Individualizado';
+        }
+
+        return [
+            'itens' => $resultado,
+            'colunas' => $colunas,
+            'unidade' => $resultado->firstWhere('unidade_id', request()->unidade_id)->unidade_nome,
+            'competencia' => $resultado->firstWhere('competencia_id', request()->competencia_id)->competencia_valor,
+            'instrumento_registro' => $instrumento_registro,
+            'total' => $resultado->count(),
+        ];
+    }
+}

api/app/Services/Bpa/RelatorioBpaConsolidadoService.php

@@ -0,0 +1,520 @@
+<?php
+
+namespace App\Services\Bpa;
+
+use App\Enums\Sigtap\Registro;
+use App\Models\Cadastro\Estabelecimento\Unidade;
+use App\Models\Sigtap\Competencia;
+use App\Models\Sigtap\Ocupacao;
+use App\Models\Sigtap\Procedimento;
+use App\Services\Service;
+use App\Utils\DataUtil;
+use App\Utils\MaskUtil;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+
+class RelatorioBpaConsolidadoService extends Service
+{
+    public static function index()
+    {
+        $totalizadores = (object) [
+            'quantidade' => 0,
+        ];
+
+        $params = self::getParams();
+
+        $procedimentosBuilder = DB::table('bpa_procedimento as bpa_procedimento')
+            ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+            ->join('cadastro_unidade as unidade', 'unidade.id', 'bpa_procedimento.unidade_id')
+            ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
+            ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+            ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+            ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+            ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+            ->when($params->procedimento_codigo, fn ($q, $codigo) => $q->where('procedimento.codigo', $codigo))
+            ->when($params->com_inconsistencia === true, fn ($q) => $q->whereExists(fn ($q) => $q
+                ->selectRaw(1)
+                ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+            ))
+            ->when($params->com_inconsistencia === false, fn ($q) => $q->whereNotExists(fn ($q) => $q
+                ->selectRaw(1)
+                ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+            ))
+            ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
+                ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
+            ))
+            ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
+                ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
+            ))
+            ->selectRaw("
+                procedimento.id as procedimento_id,
+                procedimento.codigo as procedimento_codigo,
+                procedimento.nome as procedimento_nome,
+                unidade.id as unidade_id,
+                CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes))) as unidade_descricao,
+                ocupacao.id as ocupacao_id,
+                ocupacao.codigo as ocupacao_codigo,
+                ocupacao.nome as ocupacao_nome,
+                bpa_procedimento.idade,
+                IF (EXISTS(
+                        SELECT      1
+                        FROM        bpa_procedimento_inconsistencia as procedimento_inconsistencia
+                        WHERE       procedimento_inconsistencia.procedimento_id = bpa_procedimento.id
+                    ),
+                    1,
+                    0
+                ) as com_inconsistencia,
+                bpa_procedimento.origem as origem,
+                SUM(bpa_procedimento.quantidade) as quantidade
+            ")
+            ->groupByRaw("
+                procedimento.id,
+                procedimento.codigo,
+                procedimento.nome,
+                unidade.id,
+                CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes))),
+                ocupacao.id,
+                ocupacao.codigo,
+                ocupacao.nome,
+                bpa_procedimento.idade,
+                com_inconsistencia,
+                origem
+            ");
+
+        self::setOrderBy($procedimentosBuilder);
+
+        $procedimentos = $procedimentosBuilder->get();
+
+        $procedimentos->each(function ($item) use ($totalizadores) {
+
+            $item->procedimento_codigo = MaskUtil::getProcedimentoMasked($item->procedimento_codigo);
+
+            $item->procedimento_descricao = "{$item->procedimento_codigo} - {$item->procedimento_nome}";
+            $item->ocupacao_descricao = "{$item->ocupacao_codigo} - {$item->ocupacao_nome}";
+            $item->com_inconsistencia_value = (bool) $item->com_inconsistencia;
+            $item->com_inconsistencia = $item->com_inconsistencia_value ? 'SIM' : 'NÃO';
+
+            unset(
+                $item->procedimento_codigo,
+                $item->procedimento_nome,
+                $item->ocupacao_codigo,
+                $item->ocupacao_nome,
+            );
+
+            $totalizadores->quantidade += $item->quantidade;
+        });
+
+        return compact('procedimentos', 'totalizadores');
+    }
+
+    private static function setOrderBy($builder)
+    {
+        $columns = [
+            'procedimento_descricao' => "CONCAT(procedimento.codigo, ' - ', procedimento.nome)",
+            'unidade_descricao' => "CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes)))",
+            'ocupacao_descricao' => "CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)",
+            'idade' => 'bpa_procedimento.idade',
+            'com_inconsistencia' => 'com_inconsistencia',
+            'origem' => 'bpa_procedimento.origem',
+            'quantidade' => 'quantidade'
+        ];
+
+        if (is_null(request()->sortBy)) {
+
+            $builder->orderByRaw(join(', ', $columns));
+
+            return;
+        }
+
+        $column = $columns[request()->sortBy];
+        $direction = DataUtil::getBooleanValueFromStringBoolean(request()->sortDesc) ? 'DESC' : 'ASC';
+
+        unset($columns[request()->sortBy]);
+
+        $builder->orderByRaw(
+            "{$column} {$direction}, " . join(', ', $columns)
+        );
+    }
+
+    public static function list()
+    {
+        $data = (object) [
+            'form' => [],
+            'model' => [],
+        ];
+
+        $params = self::getParams();
+
+        $sets = [
+            'ano' => function () use ($data, $params) {
+
+                $anosData = self::getAnosData();
+
+                $data->form['anos'] = $anosData['form'];
+                $data->model['ano'] = $anosData['model'];
+
+                $params->ano = $data->model['ano'];
+            },
+            'competencia' => function () use ($data, $params) {
+
+                $competenciasData = self::getCompetenciasData($params);
+
+                $data->form['competencias'] = $competenciasData['form'];
+                $data->model['competencia_id'] = $competenciasData['model'];
+
+                $params->competencia_id = $data->model['competencia_id'];
+            },
+            'unidade' => function () use ($data, $params) {
+
+                $unidadesData = self::getUnidadesData($params);
+
+                $data->form['unidades'] = $unidadesData['form'];
+                $data->model['unidade_id'] = $unidadesData['model'];
+
+                $params->unidade_id = $data->model['unidade_id'];
+            },
+            'ocupacao' => function () use ($data, $params) {
+
+                $ocupacoesData = self::getOcupacoesData($params);
+
+                $data->form['ocupacoes'] = $ocupacoesData['form'];
+                $data->model['ocupacao_id'] = $ocupacoesData['model'];
+
+                $params->ocupacao_id = $data->model['ocupacao_id'];
+            },
+            'procedimento' => function () use ($data, $params) {
+
+                $procedimentosData = self::getProcedimentosData($params);
+
+                $data->form['procedimentos'] = $procedimentosData['form'];
+                $data->model['procedimento_codigo'] = $procedimentosData['model'];
+
+                $params->procedimento_codigo = $data->model['procedimento_codigo'];
+            },
+            'inconsistencia' => function () use ($data, $params) {
+
+                $inconsistenciasData = self::getInconsistenciasData($params);
+
+                $data->form['inconsistencias'] = $inconsistenciasData['form'];
+                $data->model['com_inconsistencia'] = $inconsistenciasData['model'];
+
+                $params->com_inconsistencia = $data->model['com_inconsistencia'];
+            },
+            'idade' => function () use ($data, $params) {
+
+                $data->model['idade'] = ['de' => null, 'ate' => null];
+
+                $params->idade = $data->model['idade'];
+            },
+        ];
+
+        $firstLoad = $load = is_null(request()->load_from);
+
+        foreach ($sets as $field => $set) {
+
+            if ($load) {
+
+                if (!$firstLoad && collect(['idade'])->contains($field)) {
+
+                    continue;
+                }
+
+                $set();
+            }
+            else if ($field === request()->load_from) {
+
+                $load = true;
+            }
+        }
+
+        foreach ($data as $property => $itens) {
+
+            if (empty($itens)) {
+
+                unset($data->{$property});
+            }
+        }
+
+        return $data;
+    }
+
+    private static function getParams()
+    {
+        $params = (object) request()->only([
+            'ano',
+            'competencia_id',
+            'unidade_id',
+            'ocupacao_id',
+            'procedimento_codigo',
+            'com_inconsistencia',
+            'idade',
+        ]);
+
+        if (isset($params->com_inconsistencia)) {
+
+            $params->com_inconsistencia = DataUtil::isStringBoolean($params->com_inconsistencia)
+                ? DataUtil::getBooleanValueFromStringBoolean($params->com_inconsistencia)
+                : null;
+        }
+
+        return $params;
+    }
+
+    private static function getAnosData()
+    {
+        $anos = DB::table('sigtap.competencia as competencia')
+            ->whereExists(fn ($q) => $q
+                ->selectRaw(1)
+                ->from('bpa_procedimento as bpa_procedimento')
+                ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
+                ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+            )
+            ->selectRaw("
+                SUBSTRING(competencia.valor, 1, 4) as ano
+            ")
+            ->orderByRaw("SUBSTRING(competencia.valor, 1, 4) DESC")
+            ->distinct()
+            ->get();
+
+        $ano = null;
+
+        return ['form' => $anos, 'model' => $ano];
+    }
+
+    private static function getCompetenciasData($params)
+    {
+        $competencias = collect();
+        $id = null;
+
+        if (!is_null($params->ano)) {
+
+            $competencias = DB::table('sigtap.competencia as competencia')
+                ->whereRaw("SUBSTRING(competencia.valor, 1, 4) = '{$params->ano}'")
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
+                    ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+                )
+                ->selectRaw("
+                    competencia.id,
+                    SUBSTRING(competencia.valor, 5, 7) as mes
+                ")
+                ->orderByRaw("SUBSTRING(competencia.valor, 5, 7)")
+                ->get();
+        }
+
+        return ['form' => $competencias, 'model' => $id];
+    }
+
+    private static function getUnidadesData($params)
+    {
+        $unidades = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $unidades = DB::table('cadastro_unidade as unidade')
+                ->whereNull('unidade.deleted_at')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.unidade_id', 'unidade.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+                )
+                ->selectRaw("
+                    unidade.id,
+                    CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes))) as descricao
+                ")
+                ->orderByRaw("CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes)))")
+                ->get();
+        }
+
+        return ['form' => $unidades, 'model' => $id];
+    }
+
+    private static function getOcupacoesData($params)
+    {
+        $ocupacoes = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $ocupacoes = DB::table('sigtap.ocupacao as ocupacao')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.ocupacao_id', 'ocupacao.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                )
+                ->selectRaw("
+                    ocupacao.id,
+                    CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as descricao
+                ")
+                ->orderByRaw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)")
+                ->get();
+        }
+
+        return ['form' => $ocupacoes, 'model' => $id];
+    }
+
+    private static function getProcedimentosData($params)
+    {
+        $procedimentos = collect();
+        $codigo = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $procedimentos = DB::table('sigtap.procedimento as procedimento')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.procedimento_id', 'procedimento.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                )
+                ->selectRaw("
+                    procedimento.codigo,
+                    procedimento.nome
+                ")
+                ->orderByRaw("CONCAT(procedimento.codigo, ' - ', procedimento.nome)")
+                ->distinct()
+                ->get()
+                ->map(fn ($procedimento) => (object) [
+                    'codigo' => $procedimento->codigo,
+                    'descricao' => MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}",
+                ]);
+        }
+
+        return ['form' => $procedimentos, 'model' => $codigo];
+    }
+
+    private static function getInconsistenciasData($params)
+    {
+        $inconsistencias = collect();
+        $value = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $exists = function ($comInconsistencia) use ($params) {
+
+                return DB::table('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                    ->when($params->procedimento_codigo, fn ($q, $codigo) => $q->where('procedimento.codigo', $codigo))
+                    ->when($comInconsistencia,
+                        fn ($q) => $q->whereExists(fn ($q) => $q
+                            ->selectRaw(1)
+                            ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                            ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+                        ),
+                        fn ($q) => $q->whereNotExists(fn ($q) => $q
+                            ->selectRaw(1)
+                            ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                            ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+                        )
+                    )
+                    ->exists();
+            };
+
+            if ($exists(false)) {
+
+                $inconsistencias->push((object) ['value' => false, 'text' => 'NÃO']);
+            }
+
+            if ($exists(true)) {
+
+                $inconsistencias->push((object) ['value' => true, 'text' => 'SIM']);
+            }
+        }
+
+        return ['form' => $inconsistencias->sortBy('text')->values(), 'model' => $value];
+    }
+
+    public static function getInconsistencias()
+    {
+        return DB::table('bpa_inconsistencia as inconsistencia')
+            ->join(
+                'bpa_procedimento_inconsistencia as procedimento_inconsistencia',
+                'procedimento_inconsistencia.inconsistencia_id',
+                'inconsistencia.id'
+            )
+            ->join(
+                'bpa_procedimento as bpa_procedimento',
+                'bpa_procedimento.id',
+                'procedimento_inconsistencia.procedimento_id'
+            )
+            ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->where('bpa_procedimento.competencia_id', request()->competencia_id)
+            ->where('bpa_procedimento.unidade_id', request()->unidade_id)
+            ->where('procedimento.codigo', request()->procedimento_codigo)
+            ->where('bpa_procedimento.ocupacao_id', request()->ocupacao_id)
+            ->where('bpa_procedimento.idade', request()->idade)
+            ->where('bpa_procedimento.origem', request()->origem)
+            ->selectRaw("
+                inconsistencia.id,
+                inconsistencia.descricao
+            ")
+            ->orderBy('inconsistencia.descricao')
+            ->distinct()
+            ->get();
+    }
+
+    public static function getPrintExportData()
+    {
+        $resultado = self::index();
+        $itens = $resultado['procedimentos'];
+
+        $params = self::getParams();
+
+        $competencia = Competencia::find($params->competencia_id);
+        $unidade = $params->unidade_id ? Unidade::find($params->unidade_id) : null;
+        $ocupacao = $params->ocupacao_id ? Ocupacao::find($params->ocupacao_id) : null;
+
+        $procedimento = $params->procedimento_codigo
+            ? Procedimento::where('competencia_id', '<=', $params->competencia_id)
+                ->where('codigo', $params->procedimento_codigo)
+                ->orderByDesc('competencia_id')
+                ->first()
+            : null;
+
+        return [
+            'ano' => Str::substr($competencia->valor, 0, 4),
+            'mes' => Str::substr($competencia->valor, 4, 2),
+            'unidade' => $unidade
+                ? ($unidade->nome_fantasia . ($unidade->cnes ? " - {$unidade->cnes}": ''))
+                : 'Todas',
+            'ocupacao' => $ocupacao
+                ? "{$ocupacao->codigo} - {$ocupacao->nome}"
+                : 'Todas',
+            'procedimento' => $procedimento
+                ? MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}"
+                : 'Todos',
+            'comInconsistencia' => $params->com_inconsistencia === null
+                ? 'Todas'
+                : ($params->com_inconsistencia ? 'SIM' : 'NÃO'),
+            'idadeDe' => $params->idade['de'],
+            'idadeAte' => $params->idade['ate'],
+            'colunas' => collect(request()->selectedCols),
+            'itens' => $itens,
+            'totalizadores' => $resultado['totalizadores'],
+        ];
+    }
+}

api/app/Services/Bpa/RelatorioBpaIndividualizadoService.php

@@ -0,0 +1,610 @@
+<?php
+
+namespace App\Services\Bpa;
+
+use App\Enums\Sigtap\Registro;
+use App\Models\Bpa\Procedimento as BpaProcedimento;
+use App\Models\Cadastro\Estabelecimento\Unidade;
+use App\Models\Cadastro\SujeitoAtencao\Usuario;
+use App\Models\Sigtap\Cid;
+use App\Models\Sigtap\Competencia;
+use App\Models\Sigtap\Ocupacao;
+use App\Models\Sigtap\Procedimento;
+use App\Services\Service;
+use App\Utils\DataUtil;
+use App\Utils\MaskUtil;
+use Carbon\Carbon;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+
+class RelatorioBpaIndividualizadoService extends Service
+{
+    public static function index()
+    {
+        $totalizadores = (object) [
+            'quantidade' => 0,
+        ];
+
+        $params = self::getParams();
+
+        $procedimentosBuilder = DB::table('bpa_procedimento as bpa_procedimento')
+            ->join('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
+            ->join('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.id')
+            ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+            ->join('cadastro_unidade as unidade', 'unidade.id', 'bpa_procedimento.unidade_id')
+            ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
+            ->leftJoin('cadastro_usuario as usuario', 'usuario.id', 'bpa_procedimento.usuario_id')
+            ->leftJoin('cadastro_cidadao as usuario_cidadao', 'usuario_cidadao.id', 'usuario.cidadao_id')
+            ->leftJoin('sigtap.cid as cid', 'cid.id', 'bpa_procedimento.cid_id')
+            ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+            ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+            ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+            ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+            ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
+            ->when($params->procedimento_codigo, fn ($q, $codigo) => $q->where('procedimento.codigo', $codigo))
+            ->when($params->cid_id, fn ($q, $id) => $q->where('bpa_procedimento.cid_id', $id))
+            ->when($params->com_inconsistencia === true, fn ($q) => $q->whereExists(fn ($q) => $q
+                ->selectRaw(1)
+                ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+            ))
+            ->when($params->com_inconsistencia === false, fn ($q) => $q->whereNotExists(fn ($q) => $q
+                ->selectRaw(1)
+                ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+            ))
+            ->selectRaw("
+                bpa_procedimento.id,
+                procedimento.codigo as procedimento_codigo,
+                procedimento.nome as procedimento_nome,
+                unidade.id as unidade_id,
+                CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes))) as unidade_descricao,
+                ocupacao.codigo as ocupacao_codigo,
+                ocupacao.nome as ocupacao_nome,
+                CONCAT(usuario_cidadao.nome, IF (usuario_cidadao.cns IS NULL, '', CONCAT(' - ', usuario_cidadao.cns))) as usuario_descricao,
+                TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) AS idade,
+                cid.codigo as cid_codigo,
+                cid.nome as cid_nome,
+                bpa_procedimento.data_atendimento,
+                IF (EXISTS(
+                        SELECT      1
+                        FROM        bpa_procedimento_inconsistencia as procedimento_inconsistencia
+                        WHERE       procedimento_inconsistencia.procedimento_id = bpa_procedimento.id
+                    ),
+                    1,
+                    0
+                ) as com_inconsistencia,
+                bpa_procedimento.origem as origem,
+                bpa_procedimento.quantidade
+            ");
+
+        self::setOrderBy($procedimentosBuilder);
+
+        $procedimentos = $procedimentosBuilder->get();
+
+        $procedimentos->each(function ($item) use ($totalizadores) {
+
+            $item->procedimento_codigo = MaskUtil::getProcedimentoMasked($item->procedimento_codigo);
+            $item->cid_codigo = $item->cid_codigo ? MaskUtil::getCidMasked($item->cid_codigo) : null;
+
+            $item->procedimento_descricao = "{$item->procedimento_codigo} - {$item->procedimento_nome}";
+            $item->ocupacao_descricao = "{$item->ocupacao_codigo} - {$item->ocupacao_nome}";
+            $item->cid_descricao = $item->cid_codigo ? "{$item->cid_codigo} - {$item->cid_nome}" : null;
+            $item->com_inconsistencia_value = (bool) $item->com_inconsistencia;
+            $item->com_inconsistencia = $item->com_inconsistencia_value ? 'SIM' : 'NÃO';
+
+            unset(
+                $item->procedimento_codigo,
+                $item->procedimento_nome,
+                $item->ocupacao_codigo,
+                $item->ocupacao_nome,
+                $item->cid_codigo,
+                $item->cid_nome
+            );
+
+            $totalizadores->quantidade += $item->quantidade;
+        });
+
+        return compact('procedimentos', 'totalizadores');
+    }
+
+    private static function setOrderBy($builder)
+    {
+        $columns = [
+            'procedimento_descricao' => "CONCAT(procedimento.codigo, ' - ', procedimento.nome)",
+            'unidade_descricao' => "CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes)))",
+            'ocupacao_descricao' => "CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)",
+            'usuario_descricao' => "CONCAT(usuario_cidadao.nome, IF (usuario_cidadao.cns IS NULL, '', CONCAT(' - ', usuario_cidadao.cns)))",
+            'idade' => 'TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW())',
+            'cid_descricao' => "CONCAT(cid.codigo, ' - ', cid.nome)",
+            'data_atendimento' => 'bpa_procedimento.data_atendimento',
+            'com_inconsistencia' => 'com_inconsistencia',
+            'origem' => 'bpa_procedimento.origem',
+            'quantidade' => 'quantidade',
+        ];
+
+        if (is_null(request()->sortBy)) {
+
+            $builder->orderByRaw('bpa_procedimento.id');
+
+            return;
+        }
+
+        $column = $columns[request()->sortBy];
+        $direction = DataUtil::getBooleanValueFromStringBoolean(request()->sortDesc) ? 'DESC' : 'ASC';
+
+        unset($columns[request()->sortBy]);
+
+        $builder->orderByRaw("{$column} {$direction}, bpa_procedimento.id");
+    }
+
+    public static function list()
+    {
+        $data = (object) [
+            'form' => [],
+            'model' => [],
+        ];
+
+        $params = self::getParams();
+
+        $sets = [
+            'ano' => function () use ($data, $params) {
+
+                $anosData = self::getAnosData();
+
+                $data->form['anos'] = $anosData['form'];
+                $data->model['ano'] = $anosData['model'];
+
+                $params->ano = $data->model['ano'];
+            },
+            'competencia' => function () use ($data, $params) {
+
+                $competenciasData = self::getCompetenciasData($params);
+
+                $data->form['competencias'] = $competenciasData['form'];
+                $data->model['competencia_id'] = $competenciasData['model'];
+
+                $params->competencia_id = $data->model['competencia_id'];
+            },
+            'unidade' => function () use ($data, $params) {
+
+                $unidadesData = self::getUnidadesData($params);
+
+                $data->form['unidades'] = $unidadesData['form'];
+                $data->model['unidade_id'] = $unidadesData['model'];
+
+                $params->unidade_id = $data->model['unidade_id'];
+            },
+            'ocupacao' => function () use ($data, $params) {
+
+                $ocupacoesData = self::getOcupacoesData($params);
+
+                $data->form['ocupacoes'] = $ocupacoesData['form'];
+                $data->model['ocupacao_id'] = $ocupacoesData['model'];
+
+                $params->ocupacao_id = $data->model['ocupacao_id'];
+            },
+            'usuario' => function () use ($data, $params) {
+
+                $usuariosData = self::getUsuariosData($params);
+
+                $data->form['usuarios'] = $usuariosData['form'];
+                $data->model['usuario_id'] = $usuariosData['model'];
+
+                $params->usuario_id = $data->model['usuario_id'];
+            },
+            'procedimento' => function () use ($data, $params) {
+
+                $procedimentosData = self::getProcedimentosData($params);
+
+                $data->form['procedimentos'] = $procedimentosData['form'];
+                $data->model['procedimento_codigo'] = $procedimentosData['model'];
+
+                $params->procedimento_codigo = $data->model['procedimento_codigo'];
+            },
+            'cid' => function () use ($data, $params) {
+
+                $cidsData = self::getCidsData($params);
+
+                $data->form['cids'] = $cidsData['form'];
+                $data->model['cid_id'] = $cidsData['model'];
+
+                $params->cid_id = $data->model['cid_id'];
+            },
+            'inconsistencia' => function () use ($data, $params) {
+
+                $inconsistenciasData = self::getInconsistenciasData($params);
+
+                $data->form['inconsistencias'] = $inconsistenciasData['form'];
+                $data->model['com_inconsistencia'] = $inconsistenciasData['model'];
+
+                $params->com_inconsistencia = $data->model['com_inconsistencia'];
+            },
+        ];
+
+        $load = is_null(request()->load_from);
+
+        foreach ($sets as $field => $set) {
+
+            if ($load) {
+
+                $set();
+            }
+            else if ($field === request()->load_from) {
+
+                $load = true;
+            }
+        }
+
+        foreach ($data as $property => $itens) {
+
+            if (empty($itens)) {
+
+                unset($data->{$property});
+            }
+        }
+
+        return $data;
+    }
+
+    private static function getParams()
+    {
+        $params = (object) request()->only([
+            'ano',
+            'competencia_id',
+            'unidade_id',
+            'ocupacao_id',
+            'usuario_id',
+            'procedimento_codigo',
+            'cid_id',
+            'com_inconsistencia',
+        ]);
+
+        if (isset($params->com_inconsistencia)) {
+
+            $params->com_inconsistencia = DataUtil::isStringBoolean($params->com_inconsistencia)
+                ? DataUtil::getBooleanValueFromStringBoolean($params->com_inconsistencia)
+                : null;
+        }
+
+        return $params;
+    }
+
+    private static function getAnosData()
+    {
+        $anos = DB::table('sigtap.competencia as competencia')
+            ->whereExists(fn ($q) => $q
+                ->selectRaw(1)
+                ->from('bpa_procedimento as bpa_procedimento')
+                ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
+                ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+            )
+            ->selectRaw("
+                SUBSTRING(competencia.valor, 1, 4) as ano
+            ")
+            ->orderByRaw("SUBSTRING(competencia.valor, 1, 4) DESC")
+            ->distinct()
+            ->get();
+
+        $ano = null;
+
+        return ['form' => $anos, 'model' => $ano];
+    }
+
+    private static function getCompetenciasData($params)
+    {
+        $competencias = collect();
+        $id = null;
+
+        if (!is_null($params->ano)) {
+
+            $competencias = DB::table('sigtap.competencia as competencia')
+                ->whereRaw("SUBSTRING(competencia.valor, 1, 4) = '{$params->ano}'")
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
+                    ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+                )
+                ->selectRaw("
+                    competencia.id,
+                    SUBSTRING(competencia.valor, 5, 7) as mes
+                ")
+                ->orderByRaw("SUBSTRING(competencia.valor, 5, 7)")
+                ->get();
+        }
+
+        return ['form' => $competencias, 'model' => $id];
+    }
+
+    private static function getUnidadesData($params)
+    {
+        $unidades = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $unidades = DB::table('cadastro_unidade as unidade')
+                ->whereNull('unidade.deleted_at')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.unidade_id', 'unidade.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+                )
+                ->selectRaw("
+                    unidade.id,
+                    CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes))) as descricao
+                ")
+                ->orderByRaw("CONCAT(unidade.nome_fantasia, IF (unidade.cnes IS NULL, '', CONCAT(' - ', unidade.cnes)))")
+                ->get();
+        }
+
+        return ['form' => $unidades, 'model' => $id];
+    }
+
+    private static function getOcupacoesData($params)
+    {
+        $ocupacoes = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $ocupacoes = DB::table('sigtap.ocupacao as ocupacao')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.ocupacao_id', 'ocupacao.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                )
+                ->selectRaw("
+                    ocupacao.id,
+                    CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as descricao
+                ")
+                ->orderByRaw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)")
+                ->get();
+        }
+
+        return ['form' => $ocupacoes, 'model' => $id];
+    }
+
+    private static function getUsuariosData($params)
+    {
+        $ocupacoes = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $ocupacoes = DB::table('cadastro_usuario as usuario')
+                ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
+                ->whereNull('usuario.deleted_at')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.usuario_id', 'usuario.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                )
+                ->selectRaw("
+                    usuario.id,
+                    CONCAT(cidadao.nome, IF (cidadao.cns IS NULL, '', CONCAT(' - ', cidadao.cns))) as descricao
+                ")
+                ->orderByRaw("CONCAT(cidadao.nome, IF (cidadao.cns IS NULL, '', CONCAT(' - ', cidadao.cns)))")
+                ->get();
+        }
+
+        return ['form' => $ocupacoes, 'model' => $id];
+    }
+
+    private static function getProcedimentosData($params)
+    {
+        $procedimentos = collect();
+        $codigo = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $procedimentos = DB::table('sigtap.procedimento as procedimento')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->whereColumn('bpa_procedimento.procedimento_id', 'procedimento.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                    ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
+                )
+                ->selectRaw("
+                    procedimento.codigo,
+                    procedimento.nome
+                ")
+                ->orderByRaw("CONCAT(procedimento.codigo, ' - ', procedimento.nome)")
+                ->distinct()
+                ->get()
+                ->map(fn ($procedimento) => (object) [
+                    'codigo' => $procedimento->codigo,
+                    'descricao' => MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}",
+                ]);
+        }
+
+        return ['form' => $procedimentos, 'model' => $codigo];
+    }
+
+    private static function getCidsData($params)
+    {
+        $cids = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $cids = DB::table('sigtap.cid as cid')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+                    ->whereColumn('bpa_procedimento.cid_id', 'cid.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                    ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
+                    ->when($params->procedimento_codigo, fn ($q, $codigo) => $q->where('procedimento.codigo', $codigo))
+                )
+                ->selectRaw("
+                    cid.id,
+                    cid.codigo,
+                    cid.nome
+                ")
+                ->orderByRaw("CONCAT(cid.codigo, ' - ', cid.nome)")
+                ->get()
+                ->map(fn ($cid) => (object) [
+                    'id' => $cid->id,
+                    'descricao' => MaskUtil::getCidMasked($cid->codigo) . " - {$cid->nome}",
+                ]);
+        }
+
+        return ['form' => $cids, 'model' => $id];
+    }
+
+    private static function getInconsistenciasData($params)
+    {
+        $inconsistencias = collect();
+        $value = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $exists = function ($comInconsistencia) use ($params) {
+
+                return DB::table('bpa_procedimento as bpa_procedimento')
+                    ->join('sigtap.registro as registro', 'registro.id', 'bpa_procedimento.registro_id')
+                    ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                    ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
+                    ->when($params->procedimento_codigo, fn ($q, $codigo) => $q->where('procedimento.codigo', $codigo))
+                    ->when($params->cid_id, fn ($q, $id) => $q->where('bpa_procedimento.cid_id', $id))
+                    ->when($comInconsistencia,
+                        fn ($q) => $q->whereExists(fn ($q) => $q
+                            ->selectRaw(1)
+                            ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                            ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+                        ),
+                        fn ($q) => $q->whereNotExists(fn ($q) => $q
+                            ->selectRaw(1)
+                            ->from('bpa_procedimento_inconsistencia as procedimento_inconsistencia')
+                            ->whereColumn('procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id')
+                        )
+                    )
+                    ->exists();
+            };
+
+            if ($exists(false)) {
+
+                $inconsistencias->push((object) ['value' => false, 'text' => 'NÃO']);
+            }
+
+            if ($exists(true)) {
+
+                $inconsistencias->push((object) ['value' => true, 'text' => 'SIM']);
+            }
+        }
+
+        return ['form' => $inconsistencias->sortBy('text')->values(), 'model' => $value];
+    }
+
+    public static function getInconsistencias($bpaProcedimentoId)
+    {
+        $bpaProcedimento = BpaProcedimento::findOrFail($bpaProcedimentoId);
+
+        $inconsistencias = DB::table('bpa_inconsistencia as inconsistencia')
+            ->join(
+                'bpa_procedimento_inconsistencia as procedimento_inconsistencia',
+                'procedimento_inconsistencia.inconsistencia_id',
+                'inconsistencia.id'
+            )
+            ->where('procedimento_inconsistencia.procedimento_id', $bpaProcedimentoId)
+            ->selectRaw("
+                inconsistencia.id,
+                inconsistencia.descricao
+            ")
+            ->orderBy('inconsistencia.descricao')
+            ->get();
+
+        return [
+            'paciente_nome' => $bpaProcedimento->paciente->cidadao->nome,
+            'usuario_nome' => $bpaProcedimento->usuario->cidadao->nome ?? null,
+            'unidade_nome_fantasia' => $bpaProcedimento->unidade->nome_fantasia,
+            'data_atendimento' => Carbon::create($bpaProcedimento->data_atendimento)->format('d/m/Y'),
+            'inconsistencias' => $inconsistencias,
+        ];
+    }
+
+    public static function getPrintExportData()
+    {
+        $resultado = self::index();
+        $itens = $resultado['procedimentos'];
+
+        $itens->each(function ($item) {
+
+            if ($item->data_atendimento) {
+
+                $item->data_atendimento = (new Carbon($item->data_atendimento))->format('d/m/Y');
+            }
+        });
+
+        $params = self::getParams();
+
+        $competencia = Competencia::find($params->competencia_id);
+        $unidade = $params->unidade_id ? Unidade::find($params->unidade_id) : null;
+        $ocupacao = $params->ocupacao_id ? Ocupacao::find($params->ocupacao_id) : null;
+        $usuario = $params->usuario_id ? Usuario::find($params->usuario_id)->cidadao->nome : null;
+
+        $procedimento = $params->procedimento_codigo
+            ? Procedimento::where('competencia_id', '<=', $params->competencia_id)
+                ->where('codigo', $params->procedimento_codigo)
+                ->orderByDesc('competencia_id')
+                ->first()
+            : null;
+
+        $cid = $params->cid_id ? Cid::find($params->cid_id) : null;
+
+        return [
+            'ano' => Str::substr($competencia->valor, 0, 4),
+            'mes' => Str::substr($competencia->valor, 4, 2),
+            'unidade' => $unidade
+                ? ($unidade->nome_fantasia . ($unidade->cnes ? " - {$unidade->cnes}": ''))
+                : 'Todas',
+            'ocupacao' => $ocupacao
+                ? "{$ocupacao->codigo} - {$ocupacao->nome}"
+                : 'Todas',
+            'usuario' => $usuario ?? 'Todos',
+            'procedimento' => $procedimento
+                ? MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}"
+                : 'Todos',
+            'cid' => $cid
+                ? MaskUtil::getCidMasked($cid->codigo) . " - {$cid->nome}"
+                : 'Todos',
+            'comInconsistencia' => $params->com_inconsistencia === null
+                ? 'Todas'
+                : ($params->com_inconsistencia ? 'SIM' : 'NÃO'),
+            'colunas' => collect(request()->selectedCols),
+            'itens' => $itens,
+            'totalizadores' => $resultado['totalizadores'],
+        ];
+    }
+}

api/app/Services/Bpa/RelatorioInconsistenciaService.php

@@ -0,0 +1,200 @@
+<?php
+
+namespace App\Services\Bpa;
+
+use App\Enums\Sigtap\Registro;
+use App\Models\Bpa\Inconsistencia;
+use App\Models\Cadastro\Estabelecimento\Unidade;
+use App\Models\Sigtap\Competencia;
+use App\Services\Service;
+use Illuminate\Support\Facades\DB;
+
+class RelatorioInconsistenciaService extends Service
+{
+    public static function index()
+    {
+        switch (request()->query('registro_codigo')) {
+            case Registro::BPA_CONSOLIDADO:
+                return self::getProcedimentosConsolidados(request()->query());
+                break;
+
+            case Registro::BPA_INDIVIDUALIZADO:
+                return self::getProcedimentosIndividualizados(request()->query());
+                break;
+
+            default:
+                return self::get(Inconsistencia::class)->select(['codigo', 'descricao'])
+                    ->whereHas('procedimentos', function($query) {
+                        $query->where([
+                            'bpa_procedimento.origem' => request()->query('origem'),
+                            'bpa_procedimento.unidade_id' => request()->query('unidade_id'),
+                            'bpa_procedimento.competencia_id' => request()->query('competencia_id'),
+                            'bpa_procedimento.paciente_id' => request()->query('paciente_id'),
+                            'bpa_procedimento.procedimento_id' => request()->query('procedimento_id'),
+                            'bpa_procedimento.ocupacao_id' => request()->query('ocupacao_id'),
+                        ]);
+                    })
+                    ->get();
+            break;
+        }
+    }
+
+    public static function list()
+    {
+        return [
+            'form' => self::getForm(),
+            'model' => self::getModel(),
+        ];
+    }
+
+    public static function show($id)
+    {
+        return self::get(Inconsistencia::class)->select(['codigo', 'descricao'])
+            ->whereHas('procedimentos', function($query) use ($id) {
+                $query->where('id', $id);
+            })
+            ->get();
+    }
+
+    private static function getUnidades()
+    {
+        return Unidade::orderBy('nome_fantasia')
+            ->where('cnes', '<>', '')
+            ->get()
+            ->map(function($query) {
+                return [
+                    'id' => $query->id,
+                    'nome_fantasia' => $query->nome_fantasia,
+                ];
+            });
+    }
+
+    private static function getCompetencias()
+    {
+        return Competencia::select('id', 'valor')
+            ->orderBy('valor', 'desc')
+            ->take(4)
+            ->get();
+    }
+
+    private static function getForm()
+    {
+        return [
+            'unidades' => self::getUnidades(),
+            'competencias' => self::getCompetencias(),
+            'instrumentos_registro' => [
+                ['codigo' => Registro::BPA_CONSOLIDADO, 'nome' => 'BPA - Consolidado'],
+                ['codigo' => Registro::BPA_INDIVIDUALIZADO, 'nome' => 'BPA - Individualizado'],
+            ],
+        ];
+    }
+
+    private static function getModel()
+    {
+        return [
+            'unidade_id' => null,
+            'competencia_id' => null,
+            'registro_codigo' => null,
+        ];
+    }
+
+    private static function getProcedimentosConsolidados($params)
+    {
+        return DB::table('bpa_procedimento')
+            ->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
+            ->join('sigtap.competencia', 'competencia.id', 'bpa_procedimento.competencia_id')
+            ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->join('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
+            ->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
+            ->select([
+                'bpa_procedimento.id',
+                'bpa_procedimento.origem',
+                'cadastro_unidade.id AS unidade_id',
+                'cadastro_unidade.nome_fantasia AS unidade_nome',
+                'competencia.id AS competencia_id',
+                'competencia.valor AS competencia_valor',
+                'procedimento.id AS procedimento_id',
+                'procedimento.codigo AS procedimento_codigo',
+                'procedimento.nome AS procedimento_nome',
+                'registro.id AS registro_id',
+                'registro.codigo AS registro_codigo',
+                'ocupacao.id AS ocupacao_id',
+                'ocupacao.codigo AS ocupacao_codigo',
+                'ocupacao.nome AS ocupacao_nome',
+                'bpa_procedimento.idade',
+                DB::raw('SUM(bpa_procedimento.quantidade) AS quantidade'),
+            ])
+            ->whereNull('bpa_procedimento.deleted_at')
+            ->where([
+                'bpa_procedimento.unidade_id' => $params['unidade_id'],
+                'bpa_procedimento.competencia_id' => $params['competencia_id'],
+            ])
+            ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
+            ->whereExists(function($query) {
+                $query->select(DB::raw(1))
+                    ->from('bpa_procedimento_inconsistencia')
+                    ->whereColumn('bpa_procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id');
+            })
+            ->groupBy([
+                'bpa_procedimento.origem',
+                'cadastro_unidade.id',
+                'cadastro_unidade.nome_fantasia',
+                'competencia.valor',
+                'procedimento.id',
+                'procedimento.codigo',
+                'procedimento.nome',
+                'registro.id',
+                'registro.codigo',
+                'ocupacao.id',
+                'ocupacao.codigo',
+                'ocupacao.nome',
+                'bpa_procedimento.idade',
+            ])
+            ->get();
+    }
+
+    private static function getProcedimentosIndividualizados($params)
+    {
+        return DB::table('bpa_procedimento')
+            ->select([
+                'bpa_procedimento.origem',
+                'cadastro_unidade.id AS unidade_id',
+                'cadastro_unidade.nome_fantasia AS unidade_nome',
+                'competencia.id AS competencia_id',
+                'competencia.valor AS competencia_valor',
+                'cadastro_cidadao_usuario.nome AS usuario_nome',
+                'cadastro_paciente.id AS paciente_id',
+                'cadastro_cidadao_paciente.nome AS paciente_nome',
+                'procedimento.id AS procedimento_id',
+                'procedimento.codigo AS procedimento_codigo',
+                'procedimento.nome AS procedimento_nome',
+                'ocupacao.id AS ocupacao_id',
+                'ocupacao.codigo AS ocupacao_codigo',
+                'ocupacao.nome AS ocupacao_nome',
+                'bpa_procedimento.quantidade',
+                'registro.codigo AS registro_codigo',
+                DB::raw("DATE_FORMAT(bpa_procedimento.data_atendimento, '%d/%m/%Y') AS data_atendimento"),
+            ])
+            ->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
+            ->join('sigtap.competencia', 'competencia.id', 'bpa_procedimento.competencia_id')
+            ->join('cadastro_usuario', 'cadastro_usuario.id', 'bpa_procedimento.usuario_id')
+            ->join('cadastro_cidadao AS cadastro_cidadao_usuario', 'cadastro_cidadao_usuario.id', 'cadastro_usuario.cidadao_id')
+            ->join('cadastro_paciente', 'cadastro_paciente.id', 'bpa_procedimento.paciente_id')
+            ->join('cadastro_cidadao AS cadastro_cidadao_paciente', 'cadastro_cidadao_paciente.id', 'cadastro_paciente.cidadao_id')
+            ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
+            ->join('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
+            ->whereNull('bpa_procedimento.deleted_at')
+            ->where([
+                'bpa_procedimento.unidade_id' => $params['unidade_id'],
+                'bpa_procedimento.competencia_id' => $params['competencia_id'],
+            ])
+            ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
+            ->whereExists(function($query) {
+                $query->select(DB::raw(1))
+                    ->from('bpa_procedimento_inconsistencia')
+                    ->whereColumn('bpa_procedimento_inconsistencia.procedimento_id', 'bpa_procedimento.id');
+            })
+            ->get();
+    }
+}

api/app/Services/Bpa/RelatorioQuantitativoProducaoService.php

@@ -0,0 +1,570 @@
+<?php
+
+namespace App\Services\Bpa;
+
+use App\Models\Cadastro\Estabelecimento\Unidade;
+use App\Models\Cadastro\SujeitoAtencao\Usuario;
+use App\Models\Sigtap\Competencia;
+use App\Models\Sigtap\Ocupacao;
+use App\Models\Sigtap\Procedimento;
+use App\Services\Service;
+use App\Utils\DataUtil;
+use App\Utils\MaskUtil;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+
+class RelatorioQuantitativoProducaoService extends Service
+{
+    public static function index()
+    {
+        $totalizadores = (object) [
+            'quantidade' => 0,
+            'tipos' => collect()
+        ];
+
+        $params = self::getParams();
+
+        $producaoBuilder = DB::table('bpa_procedimento as bpa_procedimento')
+            ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
+            ->join('cadastro_unidade as unidade', 'unidade.id', 'bpa_procedimento.unidade_id')
+            ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
+            ->leftJoin('cadastro_usuario as usuario', 'usuario.id', 'bpa_procedimento.usuario_id')
+            ->leftJoin('cadastro_cidadao as usuario_cidadao', 'usuario_cidadao.id', 'usuario.cidadao_id')
+            ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
+            ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
+            ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+            ->whereNull('unidade.deleted_at')
+            ->whereNull('bpa_procedimento.deleted_at')
+            ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
+            ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+            ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
+                ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
+                ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
+            ))
+            ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
+                ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
+                ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
+            ))
+            ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+            ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
+            ->when($params->procedimento_id, fn ($q, $id) => $q->where('bpa_procedimento.procedimento_id', $id))
+            ->when($params->status, fn ($q) => $q
+                ->when($params->status === 'exportado', fn ($q) => $q->whereNotNull('bpa_procedimento.exportacao_id'))
+                ->when($params->status === 'nao_exportado', fn ($q) => $q->whereNull('bpa_procedimento.exportacao_id'))
+            )
+            ->selectRaw("
+                bpa_procedimento.origem,
+                unidade.nome_fantasia as unidade_nome_fantasia,
+                procedimento.codigo as procedimento_codigo,
+                procedimento.nome as procedimento_nome,
+                ocupacao.codigo as ocupacao_codigo,
+                ocupacao.nome as ocupacao_nome,
+                usuario_cidadao.nome as usuario_nome,
+                IF (bpa_procedimento.exportacao_id IS NULL,
+                    '" . self::getStatus()->where('value', 'nao_exportado')->first()->text . "',
+                    '" . self::getStatus()->where('value', 'exportado')->first()->text . "'
+                ) as status,
+                SUM(quantidade) as quantidade
+            ")
+            ->groupByRaw("
+                bpa_procedimento.origem,
+                unidade.nome_fantasia,
+                procedimento.codigo,
+                procedimento.nome,
+                ocupacao.codigo,
+                ocupacao.nome,
+                usuario_cidadao.nome,
+                status
+            ");
+
+        self::setOrderBy($producaoBuilder);
+
+        $producao = $producaoBuilder->get();
+
+        $producao->each(function ($item) use ($totalizadores) {
+
+            $item->procedimento_codigo = MaskUtil::getProcedimentoMasked($item->procedimento_codigo);
+
+            $totalizadores->quantidade += $item->quantidade;
+        });
+
+        return compact('producao', 'totalizadores');
+    }
+
+    private static function setOrderBy($builder)
+    {
+        $columns = [
+            'origem' => 'bpa_procedimento.origem',
+            'unidade_nome_fantasia' => 'unidade.nome_fantasia',
+            'procedimento_codigo' => 'procedimento.codigo',
+            'procedimento_nome' => 'procedimento.nome',
+            'ocupacao_codigo' => 'ocupacao.codigo',
+            'ocupacao_nome' => 'ocupacao.nome',
+            'usuario_nome' => 'usuario_cidadao.nome',
+            'status' => "IF (bpa_procedimento.exportacao_id IS NULL,
+                '" . self::getStatus()->where('value', 'nao_exportado')->first()->text . "',
+                '" . self::getStatus()->where('value', 'exportado')->first()->text . "'
+            )",
+            'quantidade' => 'quantidade'
+        ];
+
+        if (is_null(request()->sortBy)) {
+
+            $builder->orderByRaw(join(', ', $columns));
+
+            return;
+        }
+
+        $column = $columns[request()->sortBy];
+        $direction = DataUtil::getBooleanValueFromStringBoolean(request()->sortDesc) ? 'DESC' : 'ASC';
+
+        unset($columns[request()->sortBy]);
+
+        $builder->orderByRaw(
+            "{$column} {$direction}, " . join(', ', $columns)
+        );
+    }
+
+    public static function list()
+    {
+        $data = (object) [
+            'form' => [],
+            'model' => [],
+        ];
+
+        $params = self::getParams();
+
+        $sets = [
+            'ano' => function () use ($data, $params) {
+
+                $anosData = self::getAnosData();
+
+                $data->form['anos'] = $anosData['form'];
+                $data->model['ano'] = $anosData['model'];
+
+                $params->ano = $data->model['ano'];
+            },
+            'competencia' => function () use ($data, $params) {
+
+                $competenciasData = self::getCompetenciasData($params);
+
+                $data->form['competencias'] = $competenciasData['form'];
+                $data->model['competencia_id'] = $competenciasData['model'];
+
+                $params->competencia_id = $data->model['competencia_id'];
+            },
+            'origem' => function () use ($data, $params) {
+
+                $origensData = self::getOrigensData($params);
+
+                $data->form['origens'] = $origensData['form'];
+                $data->model['origem'] = $origensData['model'];
+
+                $params->origem = $data->model['origem'];
+            },
+            'unidade' => function () use ($data, $params) {
+
+                $unidadesData = self::getUnidadesData($params);
+
+                $data->form['unidades'] = $unidadesData['form'];
+                $data->model['unidade_id'] = $unidadesData['model'];
+
+                $params->unidade_id = $data->model['unidade_id'];
+            },
+            'idade' => function () use ($data, $params) {
+
+                $data->model['idade'] = ['de' => null, 'ate' => null];
+
+                $params->idade = $data->model['idade'];
+            },
+            'ocupacao' => function () use ($data, $params) {
+
+                $ocupacoesData = self::getOcupacoesData($params);
+
+                $data->form['ocupacoes'] = $ocupacoesData['form'];
+                $data->model['ocupacao_id'] = $ocupacoesData['model'];
+
+                $params->ocupacao_id = $data->model['ocupacao_id'];
+            },
+            'usuario' => function () use ($data, $params) {
+
+                $usuariosData = self::getUsuariosData($params);
+
+                $data->form['usuarios'] = $usuariosData['form'];
+                $data->model['usuario_id'] = $usuariosData['model'];
+
+                $params->usuario_id = $data->model['usuario_id'];
+            },
+            'procedimento' => function () use ($data, $params) {
+
+                $procedimentosData = self::getProcedimentosData($params);
+
+                $data->form['procedimentos'] = $procedimentosData['form'];
+                $data->model['procedimento_id'] = $procedimentosData['model'];
+
+                $params->procedimento_id = $data->model['procedimento_id'];
+            },
+            'status' => function () use ($data, $params) {
+
+                $statusData = self::getStatusData($params);
+
+                $data->form['status'] = $statusData['form'];
+                $data->model['status'] = $statusData['model'];
+
+                $params->status = $data->model['status'];
+            },
+        ];
+
+        $firstLoad = $load = is_null(request()->load_from);
+
+        foreach ($sets as $field => $set) {
+
+            if ($load) {
+
+                if (!$firstLoad && $field === 'idade') {
+
+                    continue;
+                }
+
+                $set();
+            }
+            else if ($field === request()->load_from) {
+
+                $load = true;
+            }
+        }
+
+        foreach ($data as $property => $itens) {
+
+            if (empty($itens)) {
+
+                unset($data->{$property});
+            }
+        }
+
+        return $data;
+    }
+
+    private static function getParams()
+    {
+        return (object) request()->only([
+            'ano',
+            'competencia_id',
+            'origem',
+            'unidade_id',
+            'idade',
+            'ocupacao_id',
+            'usuario_id',
+            'procedimento_id',
+            'status',
+        ]);
+    }
+
+    private static function getAnosData()
+    {
+        $anos = DB::table('sigtap.competencia as competencia')
+            ->whereExists(fn ($q) => $q
+                ->selectRaw(1)
+                ->from('bpa_procedimento as bpa_procedimento')
+                ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
+            )
+            ->selectRaw("
+                SUBSTRING(competencia.valor, 1, 4) as ano
+            ")
+            ->orderByRaw("SUBSTRING(competencia.valor, 1, 4) DESC")
+            ->distinct()
+            ->get();
+
+        $ano = null;
+
+        return ['form' => $anos, 'model' => $ano];
+    }
+
+    private static function getCompetenciasData($params)
+    {
+        $competencias = collect();
+        $id = null;
+
+        if (!is_null($params->ano)) {
+
+            $competencias = DB::table('sigtap.competencia as competencia')
+                ->whereRaw("SUBSTRING(competencia.valor, 1, 4) = '{$params->ano}'")
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
+                )
+                ->selectRaw("
+                    competencia.id,
+                    SUBSTRING(competencia.valor, 5, 7) as mes
+                ")
+                ->orderByRaw("SUBSTRING(competencia.valor, 5, 7)")
+                ->get();
+        }
+
+        return ['form' => $competencias, 'model' => $id];
+    }
+
+    private static function getOrigensData($params)
+    {
+        $origens = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $origens = DB::table('bpa_procedimento as bpa_procedimento')
+                ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                ->selectRaw("
+                    bpa_procedimento.origem
+                ")
+                ->orderBy('bpa_procedimento.origem')
+                ->distinct()
+                ->get();
+        }
+
+        return ['form' => $origens, 'model' => $id];
+    }
+
+    private static function getUnidadesData($params)
+    {
+        $unidades = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $unidades = DB::table('cadastro_unidade as unidade')
+                ->whereNull('unidade.deleted_at')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
+                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
+                    ->whereColumn('bpa_procedimento.unidade_id', 'unidade.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
+                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
+                    ))
+                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
+                    ))
+                )
+                ->selectRaw("
+                    unidade.id,
+                    unidade.nome_fantasia
+                ")
+                ->orderBy('unidade.nome_fantasia')
+                ->get();
+        }
+
+        return ['form' => $unidades, 'model' => $id];
+    }
+
+    private static function getOcupacoesData($params)
+    {
+        $ocupacoes = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $ocupacoes = DB::table('sigtap.ocupacao as ocupacao')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
+                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
+                    ->whereColumn('bpa_procedimento.ocupacao_id', 'ocupacao.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
+                    ))
+                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
+                    ))
+                )
+                ->selectRaw("
+                    ocupacao.id,
+                    CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as descricao
+                ")
+                ->orderByRaw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)")
+                ->get();
+        }
+
+        return ['form' => $ocupacoes, 'model' => $id];
+    }
+
+    private static function getUsuariosData($params)
+    {
+        $usuarios = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $usuarios = DB::table('cadastro_usuario as usuario')
+                ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
+                ->whereNull('usuario.deleted_at')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
+                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
+                    ->whereColumn('bpa_procedimento.usuario_id', 'usuario.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
+                    ))
+                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
+                    ))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                )
+                ->orderBy('cidadao.nome')
+                ->selectRaw("
+                    usuario.id,
+                    cidadao.nome
+                ")
+                ->get();
+        }
+
+        return ['form' => $usuarios, 'model' => $id];
+    }
+
+    private static function getProcedimentosData($params)
+    {
+        $procedimentos = collect();
+        $id = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $procedimentos = DB::table('sigtap.procedimento as procedimento')
+                ->whereExists(fn ($q) => $q
+                    ->selectRaw(1)
+                    ->from('bpa_procedimento as bpa_procedimento')
+                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
+                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
+                    ->whereColumn('bpa_procedimento.procedimento_id', 'procedimento.id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
+                    ))
+                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
+                    ))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                    ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
+                )
+                ->selectRaw("
+                    procedimento.id,
+                    CONCAT(procedimento.codigo, ' - ', procedimento.nome) as descricao
+                ")
+                ->orderByRaw("CONCAT(procedimento.codigo, ' - ', procedimento.nome)")
+                ->get();
+        }
+
+        return ['form' => $procedimentos, 'model' => $id];
+    }
+
+    private static function getStatusData($params)
+    {
+        $status = collect();
+        $value = null;
+
+        if (!is_null($params->competencia_id)) {
+
+            $exists = function ($exportado) use ($params) {
+
+                return DB::table('bpa_procedimento as bpa_procedimento')
+                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
+                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
+                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
+                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
+                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
+                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
+                    ))
+                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
+                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
+                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
+                    ))
+                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
+                    ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
+                    ->when($params->procedimento_id, fn ($q, $id) => $q->where('bpa_procedimento.procedimento_id', $id))
+                    ->when($exportado,
+                        fn ($q) => $q->whereNotNull('bpa_procedimento.exportacao_id'),
+                        fn ($q) => $q->whereNull('bpa_procedimento.exportacao_id')
+                    )
+                    ->exists();
+            };
+
+            if ($exists(false)) {
+
+                $status->push(self::getStatus()->where('value', 'nao_exportado')->first());
+            }
+
+            if ($exists(true)) {
+
+                $status->push(self::getStatus()->where('value', 'exportado')->first());
+            }
+        }
+
+        return ['form' => $status->sortBy('text')->values(), 'model' => $value];
+    }
+
+    private static function getStatus()
+    {
+        return collect([
+            (object) ['value' => 'nao_exportado', 'text' => 'NÃO EXPORTADO'],
+            (object) ['value' => 'exportado', 'text' => 'EXPORTADO']
+        ]);
+    }
+
+    public static function getPrintExportData()
+    {
+        $resultado = self::index();
+        $itens = $resultado['producao'];
+
+        $params = self::getParams();
+
+        $competencia = Competencia::find($params->competencia_id);
+        $unidade = $params->unidade_id ? Unidade::find($params->unidade_id) : null;
+        $ocupacao = $params->ocupacao_id ? Ocupacao::find($params->ocupacao_id) : null;
+        $usuario = $params->usuario_id ? Usuario::find($params->usuario_id) : null;
+        $procedimento = $params->procedimento_id ? Procedimento::find($params->procedimento_id) : null;
+        $status = $params->status ? self::getStatus()->where('value', $params->status)->first() : null;
+
+        return [
+            'ano' => Str::substr($competencia->valor, 0, 4),
+            'mes' => Str::substr($competencia->valor, 4, 2),
+            'origem' => $params->origem ?? 'Todos',
+            'unidade' => $unidade->nome_fantasia ?? 'Todas',
+            'idadeDe' => $params->idade['de'],
+            'idadeAte' => $params->idade['ate'],
+            'ocupacao' => $ocupacao
+                ? "{$ocupacao->codigo} - {$ocupacao->nome}"
+                : 'Todas',
+            'usuario' => $usuario->cidadao->nome ?? 'Todos',
+            'procedimento' => $procedimento
+                ? "{$procedimento->codigo} - {$procedimento->nome}"
+                : 'Todos',
+            'status' => $status->text ?? 'Todos',
+            'colunas' => collect(request()->selectedCols),
+            'itens' => $itens,
+            'totalizadores' => $resultado['totalizadores'],
+        ];
+    }
+}