1135 lines
53 KiB
PHP
1135 lines
53 KiB
PHP
<?php
|
|
|
|
namespace App\Services\Bpa;
|
|
|
|
use App\Enums\AtencaoBasica\CadastroDomiciliar\CadastroDomicilioTipo;
|
|
use App\Enums\Bpa\ExportacaoStatus;
|
|
use App\Enums\Bpa\Inconsistencia;
|
|
use App\Enums\Sigtap\Registro;
|
|
use App\Exceptions\Bpa\ExportacaoEmAndamentoException;
|
|
use App\Jobs\Bpa\ExportacaoJob;
|
|
use App\Models\Bpa\Exportacao;
|
|
use App\Models\Bpa\Procedimento;
|
|
use App\Rules\Bpa\BairroIsRequired;
|
|
use App\Rules\Bpa\CaraterAtendimentoExists;
|
|
use App\Rules\Bpa\CepIsValid;
|
|
use App\Rules\Bpa\CnesIsValid;
|
|
use App\Rules\Bpa\DataAtendimentoIsValid;
|
|
use App\Rules\Bpa\EtniaIndigenaIsValid;
|
|
use App\Rules\Bpa\IdadeIsRequired;
|
|
use App\Rules\Bpa\LogradouroIsRequired;
|
|
use App\Rules\Bpa\LogradouroTipoIsValid;
|
|
use App\Rules\Bpa\NumeroIsRequired;
|
|
use App\Rules\Bpa\PacienteNomeIsRequired;
|
|
use App\Rules\Cns as CnsPacienteIsValid;
|
|
use App\Rules\Cns as CnsUsuarioIsValid;
|
|
use App\Rules\Sigtap\CidExists;
|
|
use App\Rules\Sigtap\CidIsValidForSexo;
|
|
use App\Rules\Sigtap\ClassificacaoIsValidForProcedimento;
|
|
use App\Rules\Sigtap\ClassificacaoIsValidForServico;
|
|
use App\Rules\Sigtap\CompetenciaIsValid;
|
|
use App\Rules\Sigtap\FinanciamentoIsValidForCompetencia;
|
|
use App\Rules\Sigtap\OcupacaoExists;
|
|
use App\Rules\Sigtap\ProcedimentoExists;
|
|
use App\Rules\Sigtap\ProcedimentoIsValidForCid;
|
|
use App\Rules\Sigtap\ProcedimentoIsValidForCompetencia;
|
|
use App\Rules\Sigtap\ProcedimentoIsValidForIdade;
|
|
use App\Rules\Sigtap\ProcedimentoIsValidForOcupacao;
|
|
use App\Rules\Sigtap\ProcedimentoIsValidForSexo;
|
|
use App\Rules\Sigtap\ProcedimentoRequireCid;
|
|
use App\Rules\Sigtap\QuantidadeIsValid;
|
|
use App\Rules\Sigtap\QuantidadeIsValidForProcedimento;
|
|
use App\Services\Service;
|
|
use Carbon\Carbon;
|
|
use Exception;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Illuminate\Support\Str;
|
|
|
|
class ExportacaoService extends Service
|
|
{
|
|
const BASE_PATH = 'faturamento' . DIRECTORY_SEPARATOR . 'bpa' . DIRECTORY_SEPARATOR;
|
|
|
|
public static function create()
|
|
{
|
|
return [
|
|
'form' => self::getForm(),
|
|
'model' => self::getModel(),
|
|
];
|
|
}
|
|
|
|
public static function store($request)
|
|
{
|
|
if (self::hasExportacaoEmAndamento()) {
|
|
throw new ExportacaoEmAndamentoException();
|
|
}
|
|
|
|
self::validate($request);
|
|
|
|
DB::transaction(function () use ($request) {
|
|
$exportacao = Exportacao::create([
|
|
'status_id' => ExportacaoStatus::AGUARDANDO_PROCESSAMENTO,
|
|
'competencia_id' => $request->competencia_id,
|
|
]);
|
|
|
|
$unidades = DB::table('cadastro_unidade')
|
|
->select(['cadastro_unidade.id'])
|
|
->whereExists(fn ($q) => $q
|
|
->select(DB::raw(1))
|
|
->from('bpa_procedimento')
|
|
->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->where('bpa_procedimento.competencia_id', $request->competencia_id)
|
|
->whereIn('procedimento.competencia_id', self::getCompetencias($request->competencia_id)->pluck('id'))
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
|
|
->whereColumn('bpa_procedimento.unidade_id', 'cadastro_unidade.id')
|
|
)
|
|
->when($request->cnes, fn ($q) => $q->where('cadastro_unidade.cnes', $request->cnes))
|
|
->when($request->unidade_id, fn ($q) => $q->where('cadastro_unidade.id', $request->unidade_id))
|
|
->get();
|
|
|
|
$exportacao->unidades()->sync($unidades->pluck('id'));
|
|
$exportacao->financiamentos()->sync($request->financiamentos);
|
|
|
|
ExportacaoJob::dispatch(app('config')->get('database.default'), $exportacao->id);
|
|
});
|
|
}
|
|
|
|
public static function update($request, $id)
|
|
{
|
|
return Exportacao::findOrFail($id)->update([
|
|
'encaminhado' => $request->encaminhado
|
|
]);
|
|
}
|
|
|
|
public static function destroy($id)
|
|
{
|
|
$exportacao = Exportacao::where('id', $id)
|
|
->where('encaminhado', false)
|
|
->firstOrFail();
|
|
|
|
DB::transaction(function() use ($exportacao) {
|
|
Procedimento::where('exportacao_id', $exportacao->id)->get()->each(function ($procedimento) {
|
|
$procedimento->inconsistencias()->sync([]);
|
|
$procedimento->update(['exportacao_id' => null]);
|
|
});
|
|
|
|
$filePath = self::BASE_PATH . app('config')->get('database.default') . DIRECTORY_SEPARATOR . $exportacao->arquivo;
|
|
|
|
if (Storage::exists($filePath)) {
|
|
Storage::delete($filePath);
|
|
}
|
|
|
|
$exportacao->delete();
|
|
});
|
|
|
|
return $exportacao;
|
|
}
|
|
|
|
public static function list()
|
|
{
|
|
$params = self::getParams();
|
|
|
|
switch (request()->listar) {
|
|
case 'meses': {
|
|
return [
|
|
'meses' => self::getMeses($params),
|
|
];
|
|
}
|
|
case 'cnes': {
|
|
return [
|
|
'cnes' => self::getCnes($params),
|
|
'financiamentos' => self::getFinanciamentos($params),
|
|
];
|
|
}
|
|
case 'unidades': {
|
|
return [
|
|
'unidades' => self::getUnidades($params),
|
|
];
|
|
}
|
|
}
|
|
}
|
|
|
|
public static function datatable()
|
|
{
|
|
return DB::table('bpa_exportacao')
|
|
->select([
|
|
'bpa_exportacao.id',
|
|
'bpa_exportacao.created_at AS data_hora_exportacao',
|
|
'competencia.valor AS competencia_valor',
|
|
DB::raw("
|
|
(
|
|
SELECT GROUP_CONCAT(DISTINCT(cadastro_unidade.cnes) SEPARATOR ', ')
|
|
FROM bpa_exportacao_unidade
|
|
INNER JOIN cadastro_unidade
|
|
ON cadastro_unidade.id = bpa_exportacao_unidade.unidade_id
|
|
WHERE bpa_exportacao_unidade.exportacao_id = bpa_exportacao.id
|
|
ORDER BY cadastro_unidade.cnes
|
|
) AS unidade_cnes
|
|
"),
|
|
DB::raw("
|
|
(
|
|
SELECT GROUP_CONCAT(financiamento.nome SEPARATOR ', ')
|
|
FROM bpa_exportacao_financiamento
|
|
INNER JOIN sigtap.financiamento
|
|
ON financiamento.id = bpa_exportacao_financiamento.financiamento_id
|
|
WHERE bpa_exportacao_financiamento.exportacao_id = bpa_exportacao.id
|
|
) AS financiamento_nome
|
|
"),
|
|
'bpa_exportacao_status.id AS status_id',
|
|
'bpa_exportacao_status.nome AS status_nome',
|
|
'bpa_exportacao.quantidade_consistencia',
|
|
'bpa_exportacao.quantidade_inconsistencia',
|
|
DB::raw("bpa_exportacao.encaminhado"),
|
|
])
|
|
->join('sigtap.competencia', 'competencia.id', 'bpa_exportacao.competencia_id')
|
|
->join('bpa_exportacao_status', 'bpa_exportacao_status.id', 'bpa_exportacao.status_id')
|
|
->whereNull('bpa_exportacao.deleted_at');
|
|
}
|
|
|
|
public static function download($id)
|
|
{
|
|
$exportacao = Exportacao::findOrFail($id);
|
|
|
|
return [
|
|
'nome' => $exportacao->arquivo,
|
|
'arquivo' => Storage::path(self::BASE_PATH . app('config')->get('database.default') . DIRECTORY_SEPARATOR . $exportacao->arquivo),
|
|
];
|
|
}
|
|
|
|
public static function generate($cliente, $params)
|
|
{
|
|
$file = self::getArquivo($params);
|
|
|
|
$path = self::BASE_PATH . $cliente . DIRECTORY_SEPARATOR;
|
|
|
|
$saved = Storage::put($path . $file['nome'], $file['conteudo']);
|
|
|
|
if ($saved) {
|
|
chmod(Storage::path($path), 0775);
|
|
} else {
|
|
throw new Exception('Erro ao salvar o arquivo.');
|
|
}
|
|
|
|
return $file;
|
|
}
|
|
|
|
private static function getForm()
|
|
{
|
|
return [
|
|
'anos' => self::getAnos(),
|
|
'meses' => [],
|
|
'cnes' => [],
|
|
'unidades' => [],
|
|
'financiamentos' => [],
|
|
];
|
|
}
|
|
|
|
private static function getModel()
|
|
{
|
|
return [
|
|
'ano' => null,
|
|
'competencia_id' => null,
|
|
'cnes' => null,
|
|
'unidade_id' => null,
|
|
'financiamentos' => [],
|
|
];
|
|
}
|
|
|
|
private static function getParams()
|
|
{
|
|
return (object) [
|
|
'ano' => request()->get('ano'),
|
|
'competencia_id' => request()->get('competencia_id'),
|
|
'cnes' => request()->get('cnes'),
|
|
'unidade_id' => request()->get('unidade_id'),
|
|
];
|
|
}
|
|
|
|
private static function validate($request)
|
|
{
|
|
return $request->validate([
|
|
'competencia_id' => [
|
|
'required',
|
|
'integer',
|
|
new CompetenciaIsValid(),
|
|
],
|
|
'cnes' => [
|
|
'nullable',
|
|
'string',
|
|
'exists:cadastro_unidade,cnes',
|
|
],
|
|
'unidade_id' => [
|
|
'nullable',
|
|
'integer',
|
|
'exists:cadastro_unidade,id',
|
|
],
|
|
'financiamentos' => [
|
|
'required',
|
|
'array',
|
|
'distinct',
|
|
new FinanciamentoIsValidForCompetencia($request->competencia_id),
|
|
],
|
|
]);
|
|
}
|
|
|
|
private static function getCompetencias($id = null)
|
|
{
|
|
$competencias = DB::table('sigtap.competencia')
|
|
->select([
|
|
'id',
|
|
'valor',
|
|
])
|
|
->orderByDesc('valor')
|
|
->limit(4);
|
|
|
|
if (is_numeric($id)) {
|
|
$competencias->where('id', '<=', $id);
|
|
}
|
|
|
|
return DB::query()
|
|
->fromSub($competencias, 'competencia')
|
|
->whereExists(function ($query) {
|
|
$query->select(DB::raw(1))
|
|
->from('bpa_procedimento')
|
|
->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
|
|
->whereColumn('bpa_procedimento.competencia_id', 'competencia.id');
|
|
})
|
|
->orderByDesc('valor')
|
|
->get();
|
|
}
|
|
|
|
private static function getAnos()
|
|
{
|
|
$competencias = DB::table('sigtap.competencia')
|
|
->select([
|
|
'id',
|
|
'valor',
|
|
])
|
|
->orderByDesc('valor')
|
|
->limit(4);
|
|
|
|
return DB::query()
|
|
->fromSub($competencias, 'competencia')
|
|
->whereExists(function ($query) {
|
|
$query->select(DB::raw(1))
|
|
->from('bpa_procedimento')
|
|
->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->whereIn('procedimento.competencia_id', self::getCompetencias()->pluck('id'))
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
|
|
->whereColumn('bpa_procedimento.competencia_id', 'competencia.id');
|
|
})
|
|
->orderByDesc('valor')
|
|
->get()
|
|
->map(fn ($competencia) => [
|
|
'value' => Str::substr($competencia->valor, 0, 4),
|
|
'text' => Str::substr($competencia->valor, 0, 4),
|
|
])
|
|
->unique()
|
|
->values();
|
|
}
|
|
|
|
private static function getMeses($params)
|
|
{
|
|
$competencias = DB::table('sigtap.competencia')
|
|
->select([
|
|
'id',
|
|
'valor',
|
|
])
|
|
->whereRaw("SUBSTRING(valor, 1, 4) = " . $params->ano)
|
|
->orderByDesc('valor')
|
|
->limit(4);
|
|
|
|
return DB::query()
|
|
->fromSub($competencias, 'competencia')
|
|
->whereExists(function ($query) {
|
|
$query->select(DB::raw(1))
|
|
->from('bpa_procedimento')
|
|
->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->whereIn('procedimento.competencia_id', self::getCompetencias()->pluck('id'))
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
|
|
->whereColumn('bpa_procedimento.competencia_id', 'competencia.id');
|
|
})
|
|
->orderByDesc('valor')
|
|
->get()
|
|
->map(fn ($competencia) => [
|
|
'id' => $competencia->id,
|
|
'valor' => Str::substr($competencia->valor, 4, 2),
|
|
])
|
|
->values();
|
|
}
|
|
|
|
private static function getCnes($params)
|
|
{
|
|
return DB::table('cadastro_unidade')
|
|
->select([
|
|
'cadastro_unidade.cnes AS text',
|
|
'cadastro_unidade.cnes AS value',
|
|
])
|
|
->whereExists(fn ($q) => $q
|
|
->select(DB::raw(1))
|
|
->from('bpa_procedimento')
|
|
->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->where('bpa_procedimento.competencia_id', $params->competencia_id)
|
|
->whereIn('procedimento.competencia_id', self::getCompetencias($params->competencia_id)->pluck('id'))
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
|
|
->whereColumn('bpa_procedimento.unidade_id', 'cadastro_unidade.id')
|
|
)
|
|
->groupBy('cadastro_unidade.cnes')
|
|
->orderBy('cadastro_unidade.cnes')
|
|
->get();
|
|
}
|
|
|
|
private static function getUnidades($params)
|
|
{
|
|
return DB::table('cadastro_unidade')
|
|
->select([
|
|
'cadastro_unidade.id',
|
|
'cadastro_unidade.nome_fantasia',
|
|
'cadastro_unidade.cnes',
|
|
])
|
|
->whereExists(fn ($q) => $q
|
|
->select(DB::raw(1))
|
|
->from('bpa_procedimento')
|
|
->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->where('bpa_procedimento.competencia_id', $params->competencia_id)
|
|
->whereIn('procedimento.competencia_id', self::getCompetencias($params->competencia_id)->pluck('id'))
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
|
|
->whereColumn('bpa_procedimento.unidade_id', 'cadastro_unidade.id')
|
|
)
|
|
->where('cadastro_unidade.cnes', $params->cnes)
|
|
->orderBy('cadastro_unidade.nome_fantasia')
|
|
->get();
|
|
}
|
|
|
|
private static function getFinanciamentos($params)
|
|
{
|
|
return DB::table('sigtap.financiamento')
|
|
->select([
|
|
'id',
|
|
'nome',
|
|
])
|
|
->where('competencia_id', $params->competencia_id)
|
|
->orderBy('nome')
|
|
->get();
|
|
}
|
|
|
|
private static function hasExportacaoEmAndamento()
|
|
{
|
|
return Exportacao::whereIn('status_id', [
|
|
ExportacaoStatus::AGUARDANDO_PROCESSAMENTO,
|
|
ExportacaoStatus::EM_PROCESSAMENTO,
|
|
])->exists();
|
|
}
|
|
|
|
private static function getArquivo($params)
|
|
{
|
|
$nome = Carbon::now()->format('dmYhis') . '.TXT';
|
|
$conteudo = '';
|
|
$cabecalho = self::getCabecalhoArquivo($params);
|
|
$linhas = [];
|
|
$consistencias = 0;
|
|
$inconsistencias = 0;
|
|
$controle = 0;
|
|
|
|
self::storeLinhasProcedimentosConsolidados($params, $linhas, $consistencias, $inconsistencias);
|
|
self::storeLinhasProcedimentosIndividualizados($params, $linhas, $consistencias, $inconsistencias);
|
|
|
|
$cabecalho['cbc-lin'] = Str::padLeft(sizeof($linhas), 6, '0');
|
|
$cabecalho['cbc-flh'] = Str::padLeft(ceil(sizeof($linhas) / 20), 6, '0');
|
|
|
|
foreach ($linhas as $linha) {
|
|
$controle += (int) $linha['prd-pa'] + (int) $linha['prd-qt'];
|
|
}
|
|
|
|
$cabecalho['cbc-smt-vrf'] = Str::padLeft(($controle % 1111) + 1111, 4, '0');
|
|
|
|
foreach ($cabecalho as $value) {
|
|
$conteudo .= $value;
|
|
}
|
|
|
|
foreach ($linhas as $linha) {
|
|
foreach ($linha as $value) {
|
|
$conteudo .= $value;
|
|
}
|
|
}
|
|
|
|
return [
|
|
'nome' => $nome,
|
|
'conteudo' => $conteudo,
|
|
'consistencias' => $consistencias,
|
|
'inconsistencias' => $inconsistencias,
|
|
];
|
|
}
|
|
|
|
private static function getCabecalhoArquivo($params)
|
|
{
|
|
$competencia = DB::table('sigtap.competencia')
|
|
->select('valor')
|
|
->where('id', $params['competencia_id'])
|
|
->first();
|
|
|
|
return [
|
|
'cbc-hdr' => '01',
|
|
'Cbc-hdr' => '#BPA#',
|
|
'cbc-mvm' => $competencia->valor,
|
|
'cbc-lin' => null,
|
|
'cbc-flh' => null,
|
|
'cbc-smt-vrf' => null,
|
|
'cbc-rsp' => Str::padRight('CONECTASUS', 30, ' '),
|
|
'cbc-sgl' => Str::padRight('CSUS', 6, ' '),
|
|
'cbc-cgccpf' => Str::padLeft('', 14, '0'),
|
|
'cbc-dst' => Str::padRight('', 40, ' '),
|
|
'cbc-dst-in' => 'E',
|
|
'cbc_versao' => Str::padRight('1.0', 10, ' '),
|
|
'cbc-fim' => chr(13).chr(10),
|
|
];
|
|
}
|
|
|
|
private static function getFolhaAndSequencia(&$folha, &$sequencia, $registro)
|
|
{
|
|
|
|
$limite = $registro == Registro::BPA_INDIVIDUALIZADO ? 99 : 20;
|
|
|
|
$sequencia++;
|
|
|
|
if ($sequencia > $limite) {
|
|
$folha++;
|
|
$sequencia = 1;
|
|
}
|
|
}
|
|
|
|
private static function storeLinhasProcedimentosConsolidados($params, &$linhas, &$consistencias, &$inconsistencias)
|
|
{
|
|
$folha = 1;
|
|
$sequencia = 0;
|
|
$competencias = self::getCompetencias($params['competencia_id']);
|
|
|
|
self::getCompetencias($params['competencia_id'])
|
|
->map(function($competencia) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
|
|
self::getProcedimentosConsolidados($params, $competencia)
|
|
->get()
|
|
->map(function($linha) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
|
|
$errors = collect();
|
|
|
|
if (!CnesIsValid::isValid($linha->unidade_cnes)) {
|
|
$errors->push(CnesIsValid::class);
|
|
}
|
|
|
|
if (!CompetenciaIsValid::isValid($linha->competencia_id, $params['competencia_id'])) {
|
|
$errors->push(CompetenciaIsValid::class);
|
|
}
|
|
|
|
if (!ProcedimentoIsValidForCompetencia::isValid($competencias, $linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoIsValidForCompetencia::class);
|
|
}
|
|
|
|
if (!ProcedimentoExists::isValid($linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoExists::class);
|
|
}
|
|
|
|
if (!ProcedimentoIsValidForOcupacao::isValid($linha->ocupacao_id, $linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoIsValidForOcupacao::class);
|
|
}
|
|
|
|
if (!OcupacaoExists::isValid($linha->ocupacao_id)) {
|
|
$errors->push(OcupacaoExists::class);
|
|
}
|
|
|
|
if (!QuantidadeIsValid::isValid($linha->quantidade)) {
|
|
$errors->push(QuantidadeIsValid::class);
|
|
}
|
|
|
|
$procedimentos = DB::table('bpa_procedimento')
|
|
->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
|
|
->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
|
|
->where('registro.codigo', Registro::BPA_CONSOLIDADO)
|
|
->where('bpa_procedimento.competencia_id', $linha->competencia_id)
|
|
->where('cadastro_unidade.cnes', $linha->unidade_cnes)
|
|
->where('bpa_procedimento.procedimento_id', $linha->procedimento_id)
|
|
->where('bpa_procedimento.ocupacao_id', $linha->ocupacao_id)
|
|
->where('bpa_procedimento.origem', $linha->origem);
|
|
|
|
if ($errors->count() === 0) {
|
|
self::getFolhaAndSequencia($folha, $sequencia, Registro::BPA_CONSOLIDADO);
|
|
|
|
$linhas[] = [
|
|
'prd-ident' => '02',
|
|
'prd-cnes' => Str::padLeft(Str::substr($linha->unidade_cnes, 0, 7), 7, '0'),
|
|
'prd-cmp' => Str::padLeft(Str::substr($linha->competencia_valor, 0, 6), 6, '0'),
|
|
'Prd_cbo' => Str::padLeft(Str::substr($linha->ocupacao_codigo, 0, 6), 6, ' '),
|
|
'prd-flh' => Str::padLeft(Str::substr($folha, 0, 3), 3, '0'),
|
|
'prd-seq' => Str::padLeft(Str::substr($sequencia, 0, 2), 2, '0'),
|
|
'prd-pa' => Str::padLeft(Str::substr($linha->procedimento_codigo, 0, 10), 10, '0'),
|
|
'prd-ldade' => Str::padLeft(Str::substr($linha->idade, 0, 3), 3, '0'),
|
|
'prd-qt' => Str::padLeft(Str::substr($linha->quantidade, 0, 6), 6, '0'),
|
|
'prd-org' => 'BPA',
|
|
'prd-fim' => chr(13).chr(10),
|
|
];
|
|
|
|
$consistencias++;
|
|
} else {
|
|
$procedimentos->select('bpa_procedimento.id')->get()->map(function($procedimento) use ($errors) {
|
|
self::storeInconsistencia($procedimento, $errors);
|
|
});
|
|
|
|
$inconsistencias++;
|
|
}
|
|
|
|
$procedimentos->update(['exportacao_id' => $params['exportacao_id']]);
|
|
});
|
|
});
|
|
}
|
|
|
|
private static function storeLinhasProcedimentosIndividualizados($params, &$linhas, &$consistencias, &$inconsistencias)
|
|
{
|
|
$folha = 1;
|
|
$sequencia = 0;
|
|
$competencias = self::getCompetencias($params['competencia_id']);
|
|
|
|
self::getCompetencias($params['competencia_id'])
|
|
->map(function($competencia) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
|
|
self::getProcedimentosIndividualizados($params, $competencia)
|
|
->get()
|
|
->map(function($linha) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
|
|
$errors = collect();
|
|
|
|
if (!CnesIsValid::isValid($linha->unidade_cnes)) {
|
|
$errors->push(CnesIsValid::class);
|
|
}
|
|
|
|
if (!CompetenciaIsValid::isValid($linha->competencia_id, $params['competencia_id'])) {
|
|
$errors->push(CompetenciaIsValid::class);
|
|
}
|
|
|
|
if (!CnsUsuarioIsValid::isValid($linha->usuario_cns)) {
|
|
$errors->push('usuario_cns');
|
|
}
|
|
|
|
if (!OcupacaoExists::isValid($linha->ocupacao_id)) {
|
|
$errors->push(OcupacaoExists::class);
|
|
}
|
|
|
|
if (!PacienteNomeIsRequired::isValid($linha->paciente_nome)) {
|
|
$errors->push('paciente_nome_required');
|
|
}
|
|
|
|
if (!CnsPacienteIsValid::isValid($linha->paciente_cns)) {
|
|
$errors->push('paciente_cns');
|
|
}
|
|
|
|
if (!IdadeIsRequired::isValid($linha->paciente_idade)) {
|
|
$errors->push(IdadeIsRequired::class);
|
|
}
|
|
|
|
if (!EtniaIndigenaIsValid::isValid($linha->paciente_etnia_indigena_codigo_cadsus, $linha->paciente_raca_cor_id)) {
|
|
$errors->push(EtniaIndigenaIsValid::class);
|
|
}
|
|
|
|
if (!LogradouroTipoIsValid::isValid($linha->paciente_logradouro_tipo_codigo)) {
|
|
$errors->push(LogradouroTipoIsValid::class);
|
|
}
|
|
|
|
if (!CepIsValid::isValid($linha->paciente_logradouro_cep)) {
|
|
$errors->push(CepIsValid::class);
|
|
}
|
|
|
|
if (!LogradouroIsRequired::isValid($linha->paciente_logradouro_nome)) {
|
|
$errors->push(LogradouroIsRequired::class);
|
|
}
|
|
|
|
if (!NumeroIsRequired::isValid($linha->paciente_endereco_numero)) {
|
|
$errors->push(NumeroIsRequired::class);
|
|
}
|
|
|
|
if (!BairroIsRequired::isValid($linha->paciente_bairro_nome)) {
|
|
$errors->push(BairroIsRequired::class);
|
|
}
|
|
|
|
if (!ProcedimentoIsValidForCompetencia::isValid($competencias, $linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoIsValidForCompetencia::class);
|
|
}
|
|
|
|
if (!ProcedimentoIsValidForSexo::isValid($linha->paciente_sexo, $linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoIsValidForSexo::class);
|
|
}
|
|
|
|
if (!ProcedimentoExists::isValid($linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoExists::class);
|
|
}
|
|
|
|
if (!ProcedimentoIsValidForOcupacao::isValid($linha->ocupacao_id, $linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoIsValidForOcupacao::class);
|
|
}
|
|
|
|
if (!ProcedimentoIsValidForIdade::isValid($linha->paciente_idade, $linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoIsValidForIdade::class);
|
|
}
|
|
|
|
if ($linha->cid_id && !ProcedimentoIsValidForCid::isValid($linha->cid_id, $linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoIsValidForCid::class);
|
|
}
|
|
|
|
if(is_null($linha->cid_id)){
|
|
|
|
if (!ProcedimentoRequireCid::isValid($linha->procedimento_id)) {
|
|
$errors->push(ProcedimentoRequireCid::class);
|
|
}
|
|
}
|
|
|
|
if (!QuantidadeIsValid::isValid($linha->quantidade)) {
|
|
$errors->push(QuantidadeIsValid::class);
|
|
}
|
|
|
|
if (!QuantidadeIsValidForProcedimento::isValid($linha->procedimento_id, $linha->quantidade)) {
|
|
$errors->push(QuantidadeIsValidForProcedimento::class);
|
|
}
|
|
|
|
if (isset($linha->servico_id) && !is_int($linha->servico_id)) {
|
|
$errors->push('servico_id_integer');
|
|
}
|
|
|
|
if (!isset($linha->classificacao_id) && isset($linha->servico_id)) {
|
|
$errors->push('classificacao_id_required');
|
|
}
|
|
|
|
if (isset($linha->classificacao_id)) {
|
|
if (!is_int($linha->classificacao_id)) {
|
|
$errors->push('classificacao_id_integer');
|
|
} else {
|
|
if (!ClassificacaoIsValidForProcedimento::isValid($linha->procedimento_id, $linha->classificacao_id)) {
|
|
$errors->push(ClassificacaoIsValidForProcedimento::class);
|
|
}
|
|
|
|
if (!ClassificacaoIsValidForServico::isValid($linha->servico_id, $linha->classificacao_id)) {
|
|
$errors->push(ClassificacaoIsValidForServico::class);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isset($linha->cid_id)) {
|
|
if (!CidExists::isValid($linha->cid_id)) {
|
|
$errors->push(CidExists::class);
|
|
}
|
|
|
|
if (!CidIsValidForSexo::isValid($linha->paciente_sexo, $linha->cid_id)) {
|
|
$errors->push(CidIsValidForSexo::class);
|
|
}
|
|
}
|
|
|
|
if (!CaraterAtendimentoExists::isValid($linha->carater_atendimento_id)) {
|
|
$errors->push(CaraterAtendimentoExists::class);
|
|
}
|
|
|
|
$procedimento = DB::table('bpa_procedimento')->where('id', $linha->id);
|
|
|
|
if ($errors->count() === 0) {
|
|
self::getFolhaAndSequencia($folha, $sequencia, Registro::BPA_INDIVIDUALIZADO);
|
|
|
|
$linhas[] = [
|
|
'prd-ident' => '03',
|
|
'prd-cnes' => Str::padLeft(Str::substr($linha->unidade_cnes, 0, 7), 7, '0'),
|
|
'prd-cmp' => Str::padLeft(Str::substr($linha->competencia_valor, 0, 6), 6, ' '),
|
|
'Prd_cnsmed' => Str::padLeft(Str::substr($linha->usuario_cns, 0, 15), 15, '0'),
|
|
'Prd_cbo' => Str::padLeft(Str::substr($linha->ocupacao_codigo, 0, 6), 6, ' '),
|
|
'Prd_dtaten' => Str::padLeft(Str::substr($linha->data_atendimento, 0, 8), 8, ' '),
|
|
'prd-flh' => Str::padLeft(Str::substr($folha, 0, 3), 3, '0'),
|
|
'prd-seq' => Str::padLeft(Str::substr($sequencia, 0, 2), 2, '0'),
|
|
'prd-pa' => Str::padLeft(Str::substr($linha->procedimento_codigo, 0, 10), 10, ' '),
|
|
'Prd-cnspac' => $linha->paciente_cpf ? Str::padLeft('', 15, ' ') : Str::padLeft(Str::substr($linha->paciente_cns, 0, 15), 15, ' '),
|
|
'Prd-sexo' => Str::padLeft(Str::substr($linha->paciente_sexo, 0, 1), 1, ' '),
|
|
'Prd-ibge' => Str::padLeft(Str::substr($linha->paciente_municipio_ibge, 0, 6), 6, ' '),
|
|
'Prd-cid' => Str::padLeft(Str::substr($linha->cid_codigo, 0, 4), 4, ' '),
|
|
'prd-ldade' => Str::padLeft(Str::substr($linha->paciente_idade, 0, 3), 3, '0'),
|
|
'prd-qt' => Str::padLeft(Str::substr($linha->quantidade, 0, 6), 6, '0'),
|
|
'Prd-caten' => Str::padLeft(Str::substr($linha->carater_atendimento_codigo, 0, 2), 2, '0'),
|
|
'Prd-naut' => Str::padLeft(Str::substr('', 0, 13), 13, ' '),
|
|
'prd-org' => 'BPA',
|
|
'prd-nmpac' => Str::padRight(Str::ascii(Str::substr($linha->paciente_nome, 0, 30)), 30, ' '),
|
|
'prd-dtnasc' => Str::padLeft(Str::substr($linha->paciente_data_nascimento, 0, 8), 8, ' '),
|
|
'prd-raca' => Str::padLeft(Str::substr($linha->paciente_raca_cor_codigo, 0, 2), 2, ' '),
|
|
'prd-etnia' => Str::padLeft(Str::substr($linha->paciente_etnia_indigena_codigo_cadsus, 0, 4), 4, ' '),
|
|
'prd-nac' => Str::padLeft(Str::substr($linha->paciente_pais_codigo, 0, 3), 3, ' '),
|
|
'prd_srv' => Str::padLeft(Str::substr($linha->servico_codigo, 0, 3), 3, ' '),
|
|
'prd_clf' => Str::padLeft(Str::substr($linha->classificacao_codigo, 0, 3), 3, ' '),
|
|
'prd_equipe_Seq' => Str::padLeft(Str::substr('', 0, 8), 8, ' '),
|
|
'prd_equipe_Area' => Str::padLeft(Str::substr('', 0, 4), 4, ' '),
|
|
'prd_cnpj' => Str::padLeft(Str::substr('', 0, 14), 14, ' '),
|
|
'prd_cep_pcnte' => Str::padLeft($linha->paciente_logradouro_cep, 8, ' '),
|
|
'prd_lograd_pcnte' => Str::padLeft(Str::substr($linha->paciente_logradouro_tipo_codigo, 0, 3), 3, ' '),
|
|
'prd_end_pcnte' => Str::padRight(Str::ascii(Str::substr($linha->paciente_logradouro_nome, 0, 30)), 30, ' '),
|
|
'prd_compl_pcnte' => Str::padRight(Str::ascii(Str::substr($linha->paciente_endereco_complemento, 0, 10)), 10, ' '),
|
|
'prd_num_pcnte' => Str::padRight(Str::substr($linha->paciente_endereco_numero, 0, 5), 5, ' '),
|
|
'prd_bairro_pcnte' => Str::padRight(Str::ascii(Str::substr($linha->paciente_bairro_nome, 0, 30)), 30, ' '),
|
|
'prd_ddtel_pcnte' => Str::padRight(Str::substr($linha->paciente_telefone, 0, 11), 11, ' '),
|
|
'prd_email_pcnte' => Str::padRight(Str::substr($linha->paciente_email, 0, 40), 40, ' '),
|
|
'prd_ine' => Str::padLeft(Str::substr('', 0, 10), 10, ' '),
|
|
'prd_cpf_pcnte' => $linha->paciente_cpf ? Str::padLeft(Str::substr($linha->paciente_cpf, 0, 11), 11, ' ') : Str::padLeft('', 11, ' '),
|
|
'prd_situacao_rua' => $linha->paciente_situacao_rua,
|
|
'prd-fim' => chr(13).chr(10),
|
|
];
|
|
|
|
$consistencias++;
|
|
} else {
|
|
self::storeInconsistencia($procedimento->select('id')->first(), $errors);
|
|
$inconsistencias++;
|
|
}
|
|
|
|
$procedimento->update(['exportacao_id' => $params['exportacao_id']]);
|
|
});
|
|
});
|
|
}
|
|
|
|
private static function storeInconsistencia($procedimento, $errors)
|
|
{
|
|
foreach ($errors as $error) {
|
|
if ($error === ProcedimentoIsValidForCompetencia::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_CADASTRADO_NA_COMPETENCIA,
|
|
]);
|
|
}
|
|
|
|
if ($error === ProcedimentoIsValidForSexo::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_PERMITIDO_PARA_O_SEXO,
|
|
]);
|
|
}
|
|
|
|
if ($error === ProcedimentoExists::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_INVALIDO,
|
|
]);
|
|
}
|
|
|
|
if ($error === ProcedimentoIsValidForOcupacao::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_PERMITIDO_PARA_O_CBO,
|
|
]);
|
|
}
|
|
|
|
if ($error === ProcedimentoIsValidForIdade::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_PERMITIDO_PARA_A_IDADE,
|
|
]);
|
|
}
|
|
|
|
if ($error === ProcedimentoIsValidForCid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_INCOMPATIVEL_COM_CID,
|
|
]);
|
|
}
|
|
|
|
if ($error === OcupacaoExists::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CBO_INEXISTENTE,
|
|
]);
|
|
}
|
|
|
|
if ($error === CaraterAtendimentoExists::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CARATER_DE_ATENDIMENTO_INVALIDO,
|
|
]);
|
|
}
|
|
|
|
if ($error === IdadeIsRequired::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::IDADE_OBRIGATORIA,
|
|
]);
|
|
}
|
|
|
|
if ($error === EtniaIndigenaIsValid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::ETNIA_INVALIDA,
|
|
]);
|
|
}
|
|
|
|
if ($error === QuantidadeIsValid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::QUANTIDADE_ZERADA,
|
|
]);
|
|
}
|
|
|
|
if ($error === QuantidadeIsValidForProcedimento::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::EXCEDE_QUANTIDADE_MAXIMA_DO_PROCEDIMENTO,
|
|
]);
|
|
}
|
|
|
|
if ($error === CompetenciaIsValid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::COMPETENCIA_INVALIDA,
|
|
]);
|
|
}
|
|
|
|
if ($error === 'usuario_cns') {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CNS_DO_PROFISSIONAL_INVALIDO,
|
|
]);
|
|
}
|
|
|
|
if ($error === 'paciente_cns') {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CNS_INVALIDO,
|
|
]);
|
|
}
|
|
|
|
if ($error === CidExists::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CID_NAO_CADASTRADO,
|
|
]);
|
|
}
|
|
|
|
if ($error === CidIsValidForSexo::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CID_NAO_PERMITIDO_PARA_O_SEXO,
|
|
]);
|
|
}
|
|
|
|
if ($error === ProcedimentoRequireCid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_EXIGE_CID,
|
|
]);
|
|
}
|
|
|
|
if ($error === DataAtendimentoIsValid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::DATA_DE_ATENDIMENTO_INVALIDA,
|
|
]);
|
|
}
|
|
|
|
if ($error === LogradouroTipoIsValid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::TIPO_LOGRADOURO_INVALIDO,
|
|
]);
|
|
}
|
|
|
|
if ($error === CepIsValid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CEP_INVALIDO,
|
|
]);
|
|
}
|
|
|
|
if ($error === LogradouroIsRequired::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::LOGRADOURO_OBRIGATORIO,
|
|
]);
|
|
}
|
|
|
|
if ($error === NumeroIsRequired::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::NUMERO_OBRIGATORIO,
|
|
]);
|
|
}
|
|
|
|
if ($error === BairroIsRequired::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::BAIRRO_OBRIGATORIO,
|
|
]);
|
|
}
|
|
|
|
if ($error === CnesIsValid::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CNES_INVALIDO,
|
|
]);
|
|
}
|
|
|
|
if ($error === ClassificacaoIsValidForProcedimento::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CLASSIFICACAO_INVALIDA_PARA_O_PROCEDIMENTO_INFORMADO,
|
|
]);
|
|
}
|
|
|
|
if ($error === ClassificacaoIsValidForServico::class) {
|
|
DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
|
|
'procedimento_id' => $procedimento->id,
|
|
'inconsistencia_id' => Inconsistencia::CLASSIFICACAO_INVALIDA_PARA_O_SERVICO_INFORMADO,
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static function getProcedimentosConsolidados($params, $competencia)
|
|
{
|
|
$financiamentos = DB::table('sigtap.financiamento')
|
|
->whereIn('competencia_id', self::getCompetencias($competencia->id)->pluck('id'))
|
|
->whereIn('codigo', DB::table('sigtap.financiamento')->whereIn('id', $params['financiamentos'])->pluck('codigo'))
|
|
->select(['id'])
|
|
->pluck('id');
|
|
|
|
return DB::table('bpa_procedimento')
|
|
->select([
|
|
'bpa_procedimento.origem',
|
|
'cadastro_unidade.cnes AS unidade_cnes',
|
|
'competencia.id AS competencia_id',
|
|
'competencia.valor AS competencia_valor',
|
|
'procedimento.id AS procedimento_id',
|
|
'procedimento.codigo AS procedimento_codigo',
|
|
'ocupacao.id AS ocupacao_id',
|
|
'ocupacao.codigo AS ocupacao_codigo',
|
|
'bpa_procedimento.idade',
|
|
DB::raw('SUM(bpa_procedimento.quantidade) AS quantidade'),
|
|
])
|
|
->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.registro', 'registro.id', 'bpa_procedimento.registro_id')
|
|
->leftJoin('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
|
|
->where('registro.codigo', Registro::BPA_CONSOLIDADO)
|
|
->where('bpa_procedimento.competencia_id', $competencia->id)
|
|
->whereIn('cadastro_unidade.id', $params['unidades'])
|
|
->whereIn('procedimento.financiamento_id', $financiamentos)
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
|
|
->groupBy([
|
|
'bpa_procedimento.origem',
|
|
'cadastro_unidade.cnes',
|
|
'competencia.id',
|
|
'procedimento.id',
|
|
'ocupacao.id',
|
|
'bpa_procedimento.idade',
|
|
]);
|
|
}
|
|
|
|
private static function getProcedimentosIndividualizados($params, $competencia)
|
|
{
|
|
$financiamentos = DB::table('sigtap.financiamento')
|
|
->whereIn('competencia_id', self::getCompetencias($competencia->id)->pluck('id'))
|
|
->whereIn('codigo', DB::table('sigtap.financiamento')->whereIn('id', $params['financiamentos'])->pluck('codigo'))
|
|
->select(['id'])
|
|
->pluck('id');
|
|
|
|
return DB::table('bpa_procedimento')
|
|
->select([
|
|
'bpa_procedimento.origem',
|
|
'bpa_procedimento.id',
|
|
'cadastro_unidade.cnes AS unidade_cnes',
|
|
'competencia.id AS competencia_id',
|
|
'competencia.valor AS competencia_valor',
|
|
'cadastro_cidadao_usuario.id AS usuario_id',
|
|
'cadastro_cidadao_usuario.nome AS usuario_nome',
|
|
'cadastro_cidadao_usuario.cns AS usuario_cns',
|
|
'ocupacao.id AS ocupacao_id',
|
|
'ocupacao.codigo AS ocupacao_codigo',
|
|
'cadastro_paciente.id AS paciente_id',
|
|
'cadastro_cidadao_paciente.cpf as paciente_cpf',
|
|
'cadastro_cidadao_paciente.nome AS paciente_nome',
|
|
DB::raw("DATE_FORMAT(cadastro_cidadao_paciente.data_nascimento, '%Y%m%d') AS paciente_data_nascimento"),
|
|
DB::raw('TIMESTAMPDIFF(YEAR, cadastro_cidadao_paciente.data_nascimento, NOW()) AS paciente_idade'),
|
|
'cadastro_cidadao_paciente.cns AS paciente_cns',
|
|
DB::raw("CASE WHEN cadastro_sexo_paciente.id = 1 THEN 'M' WHEN cadastro_sexo_paciente.id = 2 THEN 'F' END AS paciente_sexo"),
|
|
'cadastro_raca_cor_paciente.id AS paciente_raca_cor_id',
|
|
'cadastro_raca_cor_paciente.codigo AS paciente_raca_cor_codigo',
|
|
'cadastro_etnia_indigena_paciente.codigo_cadsus AS paciente_etnia_indigena_codigo_cadsus',
|
|
'cadastro_pais_paciente.codigo AS paciente_pais_codigo',
|
|
'cadastro_logradouro_tipo_paciente.codigo AS paciente_logradouro_tipo_codigo',
|
|
'cadastro_logradouro_paciente.nome AS paciente_logradouro_nome',
|
|
DB::raw("COALESCE(cadastro_endereco_paciente.numero, 0) AS paciente_endereco_numero"),
|
|
'cadastro_endereco_paciente.complemento AS paciente_endereco_complemento',
|
|
'cadastro_bairro_paciente.nome AS paciente_bairro_nome',
|
|
'cadastro_logradouro_paciente.cep AS paciente_logradouro_cep',
|
|
'cadastro_municipio_paciente.nome AS paciente_municipio_nome',
|
|
'cadastro_municipio_paciente.ibge AS paciente_municipio_ibge',
|
|
DB::raw("
|
|
CASE
|
|
WHEN atencao_basica_cadastro_situacao_domicilio.id = ". CadastroDomicilioTipo::SITUACAO_DE_RUA . " then 'S'
|
|
ElSE 'N'
|
|
END as paciente_situacao_rua
|
|
"),
|
|
DB::raw("
|
|
(
|
|
SELECT cadastro_cidadao_telefone.numero
|
|
FROM cadastro_cidadao_telefone
|
|
WHERE cadastro_cidadao_telefone.principal = TRUE
|
|
AND cadastro_cidadao_telefone.cidadao_id = cadastro_cidadao_paciente.id
|
|
AND cadastro_cidadao_telefone.deleted_at IS NULL
|
|
LIMIT 1
|
|
) AS paciente_telefone
|
|
"),
|
|
'cadastro_paciente.email AS paciente_email',
|
|
DB::raw("DATE_FORMAT(bpa_procedimento.data_atendimento, '%Y%m%d') AS data_atendimento"),
|
|
'procedimento.id AS procedimento_id',
|
|
'procedimento.codigo AS procedimento_codigo',
|
|
'bpa_procedimento.quantidade',
|
|
'servico.id AS servico_id',
|
|
'servico.codigo AS servico_codigo',
|
|
'classificacao.id AS classificacao_id',
|
|
'classificacao.codigo AS classificacao_codigo',
|
|
'cid.id AS cid_id',
|
|
'cid.codigo AS cid_codigo',
|
|
'bpa_carater_atendimento.id AS carater_atendimento_id',
|
|
'bpa_carater_atendimento.codigo AS carater_atendimento_codigo',
|
|
])
|
|
->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')
|
|
->leftJoin('cadastro_sexo AS cadastro_sexo_paciente', 'cadastro_sexo_paciente.id', 'cadastro_cidadao_paciente.sexo_id')
|
|
->leftJoin('cadastro_raca_cor AS cadastro_raca_cor_paciente', 'cadastro_raca_cor_paciente.id', 'cadastro_cidadao_paciente.raca_cor_id')
|
|
->leftJoin('intranet.cadastro_pais AS cadastro_pais_paciente', 'cadastro_pais_paciente.id', 'cadastro_cidadao_paciente.pais_nascimento_id')
|
|
->leftJoin('cadastro_domicilio AS cadastro_domicilio_paciente', 'cadastro_domicilio_paciente.id', 'cadastro_cidadao_paciente.domicilio_id')
|
|
->leftJoin('cadastro_domicilio_informacao_residencial','cadastro_domicilio_informacao_residencial.domicilio_id','cadastro_domicilio_paciente.id')
|
|
->leftJoin('atencao_basica_cadastro_situacao_domicilio', 'atencao_basica_cadastro_situacao_domicilio.id','cadastro_domicilio_informacao_residencial.situacao_domicilio_id' )
|
|
->leftJoin('cadastro_endereco AS cadastro_endereco_paciente', 'cadastro_endereco_paciente.id', 'cadastro_domicilio_paciente.endereco_id')
|
|
->leftJoin('cadastro_logradouro AS cadastro_logradouro_paciente', 'cadastro_logradouro_paciente.id', 'cadastro_endereco_paciente.logradouro_id')
|
|
->leftJoin('cadastro_logradouro_tipo AS cadastro_logradouro_tipo_paciente', 'cadastro_logradouro_tipo_paciente.id', 'cadastro_logradouro_paciente.tipo_id')
|
|
->leftJoin('intranet.cadastro_municipio AS cadastro_municipio_paciente', 'cadastro_municipio_paciente.id', 'cadastro_logradouro_paciente.municipio_id')
|
|
->leftJoin('cadastro_bairro AS cadastro_bairro_paciente', 'cadastro_bairro_paciente.id', 'cadastro_logradouro_paciente.bairro_id')
|
|
->leftJoin('cadastro_etnia_indigena AS cadastro_etnia_indigena_paciente', 'cadastro_etnia_indigena_paciente.id', 'cadastro_cidadao_paciente.etnia_indigena_id')
|
|
->leftJoin('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
|
|
->leftJoin('sigtap.servico', 'servico.id', 'bpa_procedimento.servico_id')
|
|
->leftJoin('sigtap.classificacao', 'classificacao.id', 'bpa_procedimento.classificacao_id')
|
|
->leftJoin('sigtap.cid', 'cid.id', 'bpa_procedimento.cid_id')
|
|
->leftJoin('bpa_carater_atendimento', 'bpa_carater_atendimento.id', 'bpa_procedimento.carater_atendimento_id')
|
|
->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
|
|
->where('bpa_procedimento.competencia_id', $competencia->id)
|
|
->whereIn('cadastro_unidade.id', $params['unidades'])
|
|
->whereIn('procedimento.financiamento_id', $financiamentos)
|
|
->whereNull('bpa_procedimento.exportacao_id')
|
|
->whereNull('bpa_procedimento.deleted_at')
|
|
->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id');
|
|
}
|
|
}
|