936 lines
28 KiB
PHP
936 lines
28 KiB
PHP
<?php
|
|
|
|
namespace App\Services\AtencaoBasica\Parametrizacao;
|
|
|
|
use App\Models\AtencaoBasica\Parametrizacao\Area;
|
|
use App\Models\AtencaoBasica\Parametrizacao\AreaTipo;
|
|
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
|
|
use App\Models\AtencaoBasica\Parametrizacao\EquipeUsuario;
|
|
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoAtendimentoDomiciliar;
|
|
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoFuncionalidade;
|
|
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoProcedimento;
|
|
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoProcedimentoGrupo;
|
|
use App\Models\AtencaoBasica\Parametrizacao\Microarea;
|
|
use App\Models\AtencaoBasica\Parametrizacao\Outros;
|
|
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissao;
|
|
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoEsus;
|
|
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoOcupacao;
|
|
use App\Models\AtencaoBasica\Parametrizacao\OutrosSupervisor;
|
|
use App\Models\AtencaoBasica\Parametrizacao\RegistroTipo;
|
|
use App\Models\Cadastro\Estabelecimento\Unidade;
|
|
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
|
|
use App\Models\Cadastro\SujeitoAtencao\Usuario;
|
|
use App\Models\Sigtap\Ocupacao;
|
|
use App\Models\Sigtap\Procedimento;
|
|
use App\Services\Service;
|
|
use Illuminate\Support\Facades\DB;
|
|
|
|
class ParametrizacaoService extends Service
|
|
{
|
|
|
|
public static function index()
|
|
{
|
|
|
|
$model = self::getModelData();
|
|
$form = self::getFormData();
|
|
|
|
return [
|
|
'model' => $model,
|
|
'form' => $form,
|
|
];
|
|
}
|
|
|
|
private static function getFormData()
|
|
{
|
|
|
|
return [
|
|
'area' => [
|
|
'tipos_area' => AreaTipo::all()->map(fn ($area) => [
|
|
'id' => $area->id,
|
|
'descricao' => $area->sigla ? $area->sigla .' - '. $area->descricao : '',
|
|
])->toArray(),
|
|
],
|
|
'unidades' => self::obterUnidades()->toArray(),
|
|
'faturamento' => [
|
|
'atendimento_domiciliar' => [
|
|
'registro_tipo' => RegistroTipo::all()->toArray(),
|
|
],
|
|
],
|
|
'outros' => [
|
|
'permissao' => [
|
|
'ocupacoes' => Ocupacao::all(),
|
|
]
|
|
],
|
|
];
|
|
}
|
|
|
|
private static function obterAreas()
|
|
{
|
|
|
|
return Area::with('microareas')
|
|
->get()
|
|
->map(function($area) {
|
|
|
|
$tipo = AreaTipo::find($area->tipo_id);
|
|
|
|
|
|
if ($tipo) {
|
|
$area->tipo_descricao = $tipo->sigla ? $tipo->sigla . ' - ' . $tipo->descricao : '-';
|
|
} else {
|
|
$area->tipo_descricao = '';
|
|
}
|
|
|
|
return $area;
|
|
});
|
|
}
|
|
|
|
private static function obterUnidades()
|
|
{
|
|
|
|
return Unidade::orderBy('nome_fantasia')
|
|
->get()
|
|
->map(fn ($query) => [
|
|
'id' => $query->id,
|
|
'descricao' => $query->nome_fantasia,
|
|
'infraestruturas' => $query->infraestruturas->sortBy('nome')->map(fn ($infraestrutura) => [
|
|
'id' => $infraestrutura->id,
|
|
'nome' => $infraestrutura->nome,
|
|
'principal' => $infraestrutura->principal,
|
|
])->values()
|
|
]);
|
|
}
|
|
|
|
private static function obterEquipes()
|
|
{
|
|
|
|
$equipes = DB::table("atencao_basica_parametrizacao_equipe as parametrizacao_equipe")
|
|
->select(
|
|
'parametrizacao_equipe.id as equipe_id',
|
|
'parametrizacao_equipe.microarea_id',
|
|
'parametrizacao_area.id as area_id',
|
|
'parametrizacao_area.descricao as area_descricao',
|
|
'parametrizacao_area.numero_ine',
|
|
'parametrizacao_microarea.descricao as microarea_descricao',
|
|
'parametrizacao_area_tipo.sigla as area_tipo_sigla',
|
|
'parametrizacao_area_tipo.descricao as area_tipo_descricao',
|
|
'parametrizacao_unidade.id as unidade_id',
|
|
'parametrizacao_unidade.nome_fantasia as unidade_descricao',
|
|
'parametrizacao_infraestrutura.id as infraestrutura_id',
|
|
DB::raw('COALESCE(parametrizacao_infraestrutura.nome, parametrizacao_infraestrutura_unidade.nome_fantasia) as infraestrutura_descricao'),
|
|
'parametrizacao_usuario.id as usuario_id',
|
|
'parametrizacao_cidadao.nome as usuario_nome',
|
|
'parametrizacao_equipe_usuario.ativo as usuario_ativo',
|
|
'sigtap_ocupacao.codigo as lotacao_codigo',
|
|
'sigtap_ocupacao.nome as lotacao_nome',
|
|
)
|
|
->join('atencao_basica_parametrizacao_area as parametrizacao_area', 'parametrizacao_area.id', 'parametrizacao_equipe.area_id')
|
|
->leftJoin('atencao_basica_parametrizacao_equipe_usuario as parametrizacao_equipe_usuario', 'parametrizacao_equipe_usuario.equipe_id', 'parametrizacao_equipe.id')
|
|
->leftJoin('cadastro_usuario as parametrizacao_usuario', 'parametrizacao_usuario.id', 'parametrizacao_equipe_usuario.usuario_id')
|
|
->leftJoin('cadastro_lotacao as parametrizacao_lotacao', 'parametrizacao_lotacao.usuario_id', 'parametrizacao_usuario.id')
|
|
->leftJoin('sigtap.ocupacao as sigtap_ocupacao', 'sigtap_ocupacao.id', 'parametrizacao_lotacao.ocupacao_id')
|
|
->leftJoin('cadastro_cidadao as parametrizacao_cidadao', 'parametrizacao_cidadao.id', 'parametrizacao_usuario.cidadao_id')
|
|
->leftJoin('cadastro_unidade as parametrizacao_unidade', 'parametrizacao_unidade.id', 'parametrizacao_equipe.unidade_id')
|
|
->leftJoin('atencao_basica_parametrizacao_microarea as parametrizacao_microarea', 'parametrizacao_microarea.id', 'parametrizacao_equipe.microarea_id')
|
|
->leftJoin('atencao_basica_parametrizacao_area_tipo as parametrizacao_area_tipo', 'parametrizacao_area_tipo.id', 'parametrizacao_area.tipo_id')
|
|
->leftJoin('cadastro_infraestrutura as parametrizacao_infraestrutura', 'parametrizacao_infraestrutura.id', 'parametrizacao_equipe.infraestrutura_id')
|
|
->leftJoin('cadastro_unidade as parametrizacao_infraestrutura_unidade', 'parametrizacao_infraestrutura_unidade.id', 'parametrizacao_infraestrutura.unidade_id')
|
|
->get()
|
|
->groupBy('equipe_id')
|
|
->map(function ($grupo) {
|
|
$primeiro = collect($grupo)->first();
|
|
return [
|
|
'id' => $primeiro->equipe_id,
|
|
'area_id' => $primeiro->area_id,
|
|
'area_descricao' => $primeiro->area_descricao,
|
|
'numero_ine' => $primeiro->numero_ine,
|
|
'microarea_id' => $primeiro->microarea_id,
|
|
'microarea_descricao' => $primeiro->microarea_descricao ?? 'Não informada',
|
|
'area_tipo' => $primeiro->area_tipo_sigla && $primeiro->area_tipo_descricao
|
|
? $primeiro->area_tipo_sigla . ' - ' . $primeiro->area_tipo_descricao : '',
|
|
'unidade_id' => $primeiro->unidade_id,
|
|
'unidade_descricao' => $primeiro->unidade_descricao,
|
|
'infraestrutura_id' => $primeiro->infraestrutura_id ?? null,
|
|
'infraestrutura_descricao' => $primeiro->infraestrutura_descricao ?? null,
|
|
'usuarios' => $grupo
|
|
->filter(fn($item) => !is_null($item->usuario_id))
|
|
->groupBy('usuario_id')
|
|
->map(function ($usuarios) {
|
|
$usuario = $usuarios->first();
|
|
$lotacoes = $usuarios->map(function ($item) {
|
|
return "{$item->lotacao_codigo} - {$item->lotacao_nome}";
|
|
})->unique()->implode('<br>');
|
|
|
|
return [
|
|
'id' => $usuario->usuario_id,
|
|
'nome' => $usuario->usuario_nome,
|
|
'ativo' => $usuario->usuario_ativo,
|
|
'lotacoes' => $lotacoes,
|
|
];
|
|
})->values()
|
|
];
|
|
})
|
|
->values();
|
|
|
|
return $equipes;
|
|
|
|
}
|
|
|
|
public static function getOcupacoes()
|
|
{
|
|
return Lotacao::where('usuario_id', request()->usuario_id)
|
|
->whereHas('infraestrutura', function ($query) {
|
|
$query->where('infraestrutura_id', request()->infraestrutura_id);
|
|
})
|
|
->get()
|
|
->map(fn ($lotacao) => $lotacao->ocupacao->codigo_nome)
|
|
->join('<br>');
|
|
}
|
|
|
|
private static function obterFaturamentoAtendimentoDomiciliar()
|
|
{
|
|
|
|
$faturamentoAtendimentoDomiciliar = FaturamentoAtendimentoDomiciliar::select('registro_tipo_id')
|
|
->first()
|
|
->toArray();
|
|
|
|
return $faturamentoAtendimentoDomiciliar;
|
|
}
|
|
|
|
private static function obterOutrosSalarioMinimo()
|
|
{
|
|
|
|
$outrosSalarioMinimo = Outros::first()
|
|
->select('salario_minimo')
|
|
->get()
|
|
->toArray();
|
|
|
|
return $outrosSalarioMinimo[0];
|
|
}
|
|
|
|
private static function obterSupervisores()
|
|
{
|
|
|
|
return OutrosSupervisor::with('usuarios')
|
|
->get()
|
|
->map(function ($supervisor) {
|
|
|
|
$dadosUsuario = $supervisor->usuarios->map(fn ($usuario) => [
|
|
'id' => $usuario->id,
|
|
'nome' => $usuario->cidadao->nome
|
|
]);
|
|
|
|
return [
|
|
'id' => $supervisor->id,
|
|
'usuario_id' => $dadosUsuario[0]['id'],
|
|
'usuario_nome' => $dadosUsuario[0]['nome'],
|
|
];
|
|
});
|
|
}
|
|
|
|
private static function getModelData()
|
|
{
|
|
|
|
return [
|
|
'area' => [
|
|
'areas' => self::obterAreas()->toArray(),
|
|
],
|
|
'equipe' => [
|
|
'equipes' => self::obterEquipes()->toArray(),
|
|
],
|
|
'faturamento' => [
|
|
'atendimento_domiciliar' => self::obterFaturamentoAtendimentoDomiciliar(),
|
|
'funcionalidades' => FaturamentoFuncionalidade::all()
|
|
->map(fn ($faturamentoFuncionalidade) => [
|
|
'id' => $faturamentoFuncionalidade->id,
|
|
'descricao' => $faturamentoFuncionalidade->descricao,
|
|
'faturar' => $faturamentoFuncionalidade->faturar,
|
|
]),
|
|
'grupo_procedimentos' => FaturamentoProcedimentoGrupo::with('procedimentos')
|
|
->get()
|
|
->sortBy(['nome', 'competencia'])
|
|
->map(function($grupo) {
|
|
|
|
$procedimentos = $grupo->procedimentos->map(function($procedimento) {
|
|
|
|
$procedimentoSigtap = Procedimento::where('codigo', $procedimento->codigo)
|
|
->first('nome');
|
|
|
|
return [
|
|
'id' => $procedimento->id,
|
|
'codigo' => $procedimento->codigo,
|
|
'descricao' => $procedimentoSigtap->nome,
|
|
'faturar' => $procedimento->faturar
|
|
];
|
|
});
|
|
|
|
return [
|
|
'id' => $grupo->id,
|
|
'descricao' => $grupo->descricao,
|
|
'procedimentos' => $procedimentos,
|
|
];
|
|
}),
|
|
],
|
|
'outros' => [
|
|
'salario_minimo' => self::obterOutrosSalarioMinimo(),
|
|
'supervisores' => self::obterSupervisores(),
|
|
'permissao' => self::obterPermissoes(),
|
|
],
|
|
];
|
|
}
|
|
|
|
private static function obterNomeOcupacao($codigo)
|
|
{
|
|
|
|
$nome = Ocupacao::where('codigo', $codigo)
|
|
->get()
|
|
->map(fn ($ocupacao) => $ocupacao->nome);
|
|
|
|
return $nome[0];
|
|
}
|
|
|
|
private static function obterDescricaoOcupacao($codigo)
|
|
{
|
|
|
|
$descricao = Ocupacao::where('codigo', $codigo)
|
|
->get()
|
|
->map(fn ($ocupacao) => $ocupacao->getCodigoNomeAttribute());
|
|
|
|
return $descricao[0];
|
|
}
|
|
|
|
private static function obterPermissoes()
|
|
{
|
|
|
|
$permissoes = OutrosPermissao::with('ocupacoes')
|
|
->get()
|
|
->map(function ($permissao) {
|
|
|
|
$ocupacoes = $permissao->ocupacoes
|
|
->map(fn($permissaoOcupacao) => [
|
|
'codigo' => $permissaoOcupacao->ocupacao,
|
|
'descricao' => self::obterDescricaoOcupacao($permissaoOcupacao->ocupacao),
|
|
'id' => $permissaoOcupacao->id,
|
|
'nome' => self::obterNomeOcupacao($permissaoOcupacao->ocupacao),
|
|
]);
|
|
|
|
return [
|
|
'id' => $permissao->id,
|
|
'descricao' => $permissao->descricao,
|
|
'ocupacoes' => $ocupacoes
|
|
];
|
|
});
|
|
|
|
return $permissoes;
|
|
}
|
|
|
|
private static function incluirArea($dados)
|
|
{
|
|
|
|
unset($dados['microareas']);
|
|
|
|
$area = new Area;
|
|
|
|
$area->descricao = $dados['descricao'];
|
|
$area->numero_ine = $dados['numero_ine'];
|
|
$area->tipo_id = $dados['tipo_id'];
|
|
|
|
$area->save();
|
|
|
|
return $area->id;
|
|
}
|
|
|
|
private static function alterarArea($area)
|
|
{
|
|
|
|
unset($area['microareas']);
|
|
|
|
$areaAntiga = Area::find($area['id']);
|
|
|
|
if (
|
|
$areaAntiga->descricao != $area['descricao'] ||
|
|
$areaAntiga->numero_ine != $area['numero_ine'] ||
|
|
$areaAntiga->tipo_id != $area['tipo_id']
|
|
) {
|
|
|
|
Area::where('id', $area['id'])
|
|
->update($area);
|
|
}
|
|
}
|
|
|
|
private static function excluirArea($ids = null)
|
|
{
|
|
|
|
if (!is_null($ids)) {
|
|
|
|
self::excluirTodasMicroareasDaArea($ids);
|
|
|
|
Area::whereIn('id', $ids)->delete();
|
|
|
|
} else {
|
|
|
|
self::excluirTodasMicroareas();
|
|
|
|
Area::whereNotNull('id')
|
|
->delete();
|
|
}
|
|
}
|
|
|
|
private static function incluirMicroarea($areaId, $descricao)
|
|
{
|
|
|
|
$microarea = new Microarea;
|
|
|
|
$microarea->descricao = (int) $descricao;
|
|
$microarea->area_id = $areaId;
|
|
|
|
$microarea->save();
|
|
|
|
return $microarea->id;
|
|
}
|
|
|
|
private static function excluirTodasMicroareas()
|
|
{
|
|
|
|
Microarea::whereNotNull('id')
|
|
->delete();
|
|
}
|
|
|
|
private static function excluirTodasMicroareasDaArea($areaIds)
|
|
{
|
|
|
|
if (is_array($areaIds)) {
|
|
|
|
Microarea::whereIn('area_id', $areaIds)
|
|
->delete();
|
|
} else {
|
|
|
|
Microarea::where('area_id', $areaIds)
|
|
->delete();
|
|
}
|
|
}
|
|
|
|
private static function excluirMicroareasEspecificas($areaId, $microareaIds)
|
|
{
|
|
|
|
Microarea::where('area_id', $areaId)
|
|
->where('id', $microareaIds)
|
|
->delete();
|
|
}
|
|
|
|
private static function obterMicroareasParaExcluir($areaId, $microareaIds)
|
|
{
|
|
|
|
return Microarea::where('area_id', $areaId)
|
|
->whereNotIn('id', $microareaIds)
|
|
->select('id')
|
|
->get()
|
|
->toArray();
|
|
}
|
|
|
|
private static function salvarMicroarea($areaId = null, $microareas = [])
|
|
{
|
|
|
|
if (!is_null($areaId) && sizeof($microareas) > 0) {
|
|
|
|
$ids = [];
|
|
|
|
foreach ($microareas as $microarea) {
|
|
|
|
if (is_null($microarea['id'])) {
|
|
|
|
$id = self::incluirMicroarea($areaId, $microarea['descricao']);
|
|
|
|
array_push($ids, $id);
|
|
} else {
|
|
|
|
array_push($ids, $microarea['id']);
|
|
}
|
|
}
|
|
|
|
$idsParaExcluir = self::obterMicroareasParaExcluir($areaId, $ids);
|
|
|
|
if (sizeof($idsParaExcluir) > 0) {
|
|
|
|
self::excluirMicroareasEspecificas($areaId, $idsParaExcluir);
|
|
}
|
|
} elseif (!is_null($areaId)) {
|
|
|
|
self::excluirTodasMicroareasDaArea($areaId);
|
|
} else {
|
|
|
|
self::excluirTodasMicroareas();
|
|
}
|
|
}
|
|
|
|
private static function obterAreasParaExcluir($areaIds)
|
|
{
|
|
|
|
return Area::whereNotIn('id', $areaIds)
|
|
->select('id')
|
|
->get()
|
|
->map(fn ($area) => $area->id)
|
|
->toArray();
|
|
}
|
|
|
|
private static function salvarArea($areas)
|
|
{
|
|
|
|
if (sizeof($areas) > 0) {
|
|
|
|
$ids = [];
|
|
|
|
foreach ($areas as $area) {
|
|
|
|
$id = null;
|
|
|
|
if (!is_null($area['id'])) {
|
|
|
|
self::alterarArea($area);
|
|
|
|
$id = $area['id'];
|
|
} else {
|
|
|
|
$id = self::incluirArea($area);
|
|
}
|
|
|
|
self::salvarMicroarea($id, $area['microareas']);
|
|
|
|
array_push($ids, $id);
|
|
}
|
|
|
|
$idsParaExcluir = self::obterAreasParaExcluir($ids);
|
|
|
|
if (sizeof($idsParaExcluir) > 0) {
|
|
|
|
self::excluirArea($idsParaExcluir);
|
|
}
|
|
} else {
|
|
|
|
self::excluirArea();
|
|
}
|
|
}
|
|
|
|
private static function incluirEquipe($dados)
|
|
{
|
|
|
|
unset($dados['profissionais']);
|
|
|
|
$equipe = new Equipe;
|
|
|
|
$equipe->area_id = $dados['area_id'];
|
|
$equipe->microarea_id = $dados['microarea_id'];
|
|
$equipe->unidade_id = $dados['unidade_id'];
|
|
$equipe->infraestrutura_id = $dados['infraestrutura_id'];
|
|
|
|
$equipe->save();
|
|
|
|
return $equipe->id;
|
|
}
|
|
|
|
private static function excluirEquipe($ids = null)
|
|
{
|
|
|
|
if (is_null($ids)) {
|
|
|
|
self::excluirTodosUsuariosEquipes();
|
|
|
|
Equipe::whereNotNull('id')
|
|
->delete();
|
|
} else {
|
|
|
|
self::excluirTodosUsuariosEquipesDaEquipe($ids);
|
|
|
|
Equipe::whereIn('id', $ids)
|
|
->delete();
|
|
}
|
|
}
|
|
|
|
private static function incluirEquipeUsuario($equipeId, $usuario)
|
|
{
|
|
|
|
if (!self::verificaSeProfissionalExisteEquipe($equipeId, $usuario['id'])) {
|
|
|
|
$equipeUsuario = new EquipeUsuario;
|
|
|
|
$equipeUsuario->equipe_id = $equipeId;
|
|
$equipeUsuario->usuario_id = $usuario['id'];
|
|
$equipeUsuario->ativo = $usuario['ativo'];
|
|
|
|
$equipeUsuario->save();
|
|
}
|
|
}
|
|
|
|
private static function excluirTodosUsuariosEquipes()
|
|
{
|
|
|
|
EquipeUsuario::whereNotNull('equipe_id')
|
|
->delete();
|
|
}
|
|
|
|
private static function excluirTodosUsuariosEquipesDaEquipe($equipeId)
|
|
{
|
|
|
|
if (is_array($equipeId)) {
|
|
|
|
EquipeUsuario::whereIn('equipe_id', $equipeId)
|
|
->delete();
|
|
} else {
|
|
|
|
EquipeUsuario::where('equipe_id', $equipeId)
|
|
->delete();
|
|
}
|
|
}
|
|
|
|
private static function excluirUsuariosEquipesEspecificos($equipeId, $usuarioIds)
|
|
{
|
|
|
|
EquipeUsuario::where('equipe_id', $equipeId)
|
|
->whereIn('usuario_id', $usuarioIds)
|
|
->delete();
|
|
}
|
|
|
|
private static function obterEquipesUsuariosParaExcluir($equipeId, $usuarioIds)
|
|
{
|
|
|
|
return EquipeUsuario::where('equipe_id', $equipeId)
|
|
->whereNotIn('usuario_id', $usuarioIds)
|
|
->select(['equipe_id', 'usuario_id'])
|
|
->get()
|
|
->toArray();
|
|
}
|
|
|
|
private static function verificaSeProfissionalExisteEquipe($equipeId, $usuarioId)
|
|
{
|
|
|
|
$profissional = EquipeUsuario::where('equipe_id', $equipeId)
|
|
->where('usuario_id', $usuarioId)
|
|
->select('usuario_id')
|
|
->get()
|
|
->toArray();
|
|
|
|
if (is_array($profissional) && sizeof($profissional) > 0) {
|
|
|
|
return $profissional[0]['usuario_id'] === $usuarioId;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static function salvarEquipeUsuario($equipeId = null, $profissionais = [])
|
|
{
|
|
|
|
if (!is_null($equipeId) && sizeof($profissionais) > 0) {
|
|
|
|
$ids = [];
|
|
|
|
foreach ($profissionais as $profissional) {
|
|
|
|
$estadoAtual = self::obterEstadoProfissional($profissional['id'], $equipeId);
|
|
|
|
if ($estadoAtual !== null && isset($estadoAtual['ativo'])) {
|
|
|
|
self::atualizarEstadoProfissional($profissional['id'], $profissional['ativo'], $equipeId);
|
|
} else {
|
|
|
|
self::incluirEquipeUsuario($equipeId, $profissional);
|
|
}
|
|
|
|
array_push($ids, $profissional['id']);
|
|
}
|
|
|
|
$idsParaExcluir = self::obterEquipesUsuariosParaExcluir($equipeId, $ids);
|
|
|
|
if (sizeof($idsParaExcluir) > 0) {
|
|
foreach ($idsParaExcluir as $key => $id) {
|
|
unset($idsParaExcluir[$key]['equipe_id']);
|
|
};
|
|
|
|
self::excluirUsuariosEquipesEspecificos($equipeId, $idsParaExcluir);
|
|
}
|
|
} else if (!is_null($equipeId)) {
|
|
|
|
self::excluirTodosUsuariosEquipesDaEquipe($equipeId);
|
|
} else {
|
|
|
|
self::excluirTodosUsuariosEquipes();
|
|
}
|
|
}
|
|
|
|
private static function obterEstadoProfissional($profissionalId, $equipeId)
|
|
{
|
|
|
|
$profissional = EquipeUsuario::where('usuario_id', $profissionalId)
|
|
->where('equipe_id', $equipeId)
|
|
->select('usuario_id', 'ativo', 'equipe_id')
|
|
->first();
|
|
|
|
return $profissional ? $profissional->toArray() : null;
|
|
}
|
|
|
|
private static function atualizarEstadoProfissional($profissionalId, $novoEstado, $equipeId)
|
|
{
|
|
|
|
$alteraAtivo = EquipeUsuario::where('usuario_id', $profissionalId)
|
|
->where('equipe_id', $equipeId)
|
|
->update(['ativo' => $novoEstado]);
|
|
|
|
return $alteraAtivo;
|
|
}
|
|
|
|
private static function obterEquipesParaExcluir($equipeIds)
|
|
{
|
|
|
|
return Equipe::whereNotIn('id', $equipeIds)
|
|
->select(['id'])
|
|
->get()
|
|
->map(fn ($equipe) => $equipe->id)
|
|
->toArray();
|
|
}
|
|
|
|
private static function salvarEquipe($equipes)
|
|
{
|
|
|
|
if (sizeof($equipes) > 0) {
|
|
|
|
$ids = [];
|
|
|
|
foreach ($equipes as $equipe) {
|
|
|
|
if (is_null($equipe['id'])) {
|
|
|
|
$id = self::incluirEquipe($equipe);
|
|
} else {
|
|
|
|
$id = $equipe['id'];
|
|
}
|
|
|
|
self::salvarEquipeUsuario($id, $equipe['profissionais']);
|
|
|
|
array_push($ids, $id);
|
|
}
|
|
|
|
$idsParaExcluir = self::obterEquipesParaExcluir($ids);
|
|
|
|
if (sizeof($idsParaExcluir) > 0) {
|
|
|
|
self::excluirEquipe($idsParaExcluir);
|
|
}
|
|
|
|
} else {
|
|
|
|
self::excluirEquipe();
|
|
}
|
|
}
|
|
|
|
private static function obterOcupacoesPermitidasFuncionalidade($permissaoFuncionalidadeId)
|
|
{
|
|
|
|
return OutrosPermissaoEsus::where('permissao_id', $permissaoFuncionalidadeId)
|
|
->select('codigo')
|
|
->get()
|
|
->map(fn ($permissao) => $permissao->codigo);
|
|
}
|
|
|
|
public static function autocomplete()
|
|
{
|
|
$ocupacoesPermitidasFuncionalidade = self::obterOcupacoesPermitidasFuncionalidade(request()->funcionalidade_id);
|
|
|
|
$ocupacao = DB::table("sigtap.ocupacao")
|
|
->select(
|
|
"sigtap.ocupacao.codigo",
|
|
"sigtap.ocupacao.nome",
|
|
DB::raw("CONCAT(sigtap.ocupacao.codigo, ' - ', sigtap.ocupacao.nome) AS descricao"),
|
|
)
|
|
->whereIn("codigo", $ocupacoesPermitidasFuncionalidade);
|
|
|
|
return $ocupacao;
|
|
}
|
|
|
|
private static function salvarFaturamentoAtendimentoDomiciliar($dadosAtendimentoDomiciliar)
|
|
{
|
|
|
|
FaturamentoAtendimentoDomiciliar::where('id', 1)
|
|
->update($dadosAtendimentoDomiciliar);
|
|
}
|
|
|
|
private static function salvarFaturamentoFuncionalidades($dadosFuncionalidades)
|
|
{
|
|
|
|
foreach ($dadosFuncionalidades as $funcionalidade) {
|
|
|
|
FaturamentoFuncionalidade::where('id', $funcionalidade['id'])
|
|
->update($funcionalidade);
|
|
}
|
|
}
|
|
|
|
private static function salvarFaturamentoProcedimentos($dadosProcedimentos)
|
|
{
|
|
|
|
foreach ($dadosProcedimentos as $procedimento) {
|
|
|
|
FaturamentoProcedimento::where('id', $procedimento['id'])
|
|
->update($procedimento);
|
|
}
|
|
}
|
|
|
|
private static function salvarFaturamento($dadosFaturamento)
|
|
{
|
|
|
|
if (sizeof($dadosFaturamento) > 0) {
|
|
|
|
self::salvarFaturamentoAtendimentoDomiciliar($dadosFaturamento['atendimento_domiciliar']);
|
|
self::salvarFaturamentoFuncionalidades($dadosFaturamento['funcionalidades']);
|
|
self::salvarFaturamentoProcedimentos($dadosFaturamento['procedimentos']);
|
|
}
|
|
}
|
|
|
|
private static function salvarOutrosSalarioMinimo($dadosSalarioMinimo)
|
|
{
|
|
|
|
Outros::where('id', 1)
|
|
->update($dadosSalarioMinimo);
|
|
}
|
|
|
|
private static function obterSupervisoresParaExcluir($ids)
|
|
{
|
|
|
|
return OutrosSupervisor::whereNotIn('id', $ids)
|
|
->select(['id'])
|
|
->get()
|
|
->toArray();
|
|
}
|
|
|
|
private static function incluirSupervisor($dadosSupervisor)
|
|
{
|
|
|
|
$supervisor = new OutrosSupervisor;
|
|
|
|
$supervisor->usuario_id = $dadosSupervisor['usuario_id'];
|
|
|
|
$supervisor->save();
|
|
|
|
return $supervisor->id;
|
|
}
|
|
|
|
private static function excluirSupervisores($ids)
|
|
{
|
|
|
|
if (sizeof($ids) > 0) {
|
|
|
|
OutrosSupervisor::whereIn('id', $ids)
|
|
->delete();
|
|
}
|
|
}
|
|
|
|
private static function salvarOutrosSupervisores($dadosSupervisores)
|
|
{
|
|
|
|
$ids = [];
|
|
|
|
foreach ($dadosSupervisores as $supervisor) {
|
|
|
|
if (is_null($supervisor['id'])) {
|
|
|
|
$id = self::incluirSupervisor($supervisor);
|
|
} else {
|
|
|
|
$id = $supervisor['id'];
|
|
}
|
|
|
|
array_push($ids, $id);
|
|
}
|
|
|
|
$idsParaExcluir = self::obterSupervisoresParaExcluir($ids);
|
|
|
|
self::excluirSupervisores($idsParaExcluir);
|
|
}
|
|
|
|
private static function incluirPermissaoOcupacao($permissaoId, $codigo)
|
|
{
|
|
|
|
$ocupacao = new OutrosPermissaoOcupacao;
|
|
|
|
$ocupacao->permissao_id = $permissaoId;
|
|
$ocupacao->ocupacao = $codigo;
|
|
|
|
$ocupacao->save();
|
|
|
|
return $ocupacao->id;
|
|
}
|
|
|
|
private static function excluirPermissaoOcupacao($permissaoId, $ocupacaoIds)
|
|
{
|
|
|
|
OutrosPermissaoOcupacao::where('permissao_id', $permissaoId)
|
|
->whereIn('id', $ocupacaoIds)
|
|
->delete();
|
|
}
|
|
|
|
private static function obterIdentificacaoPermissaoOcupacao($permissaoId, $ocupacao)
|
|
{
|
|
|
|
$identificacao = OutrosPermissaoOcupacao::where('permissao_id', $permissaoId)
|
|
->where('ocupacao', $ocupacao)
|
|
->select('id')
|
|
->first();
|
|
|
|
return $identificacao->id ?? null;
|
|
}
|
|
|
|
private static function obterOcupacaoPermissaoParaExcluir($ids)
|
|
{
|
|
|
|
return OutrosPermissaoOcupacao::whereNotIn('id', $ids)
|
|
->select(['id'])
|
|
->get()
|
|
->toArray();
|
|
}
|
|
|
|
private static function salvarOutrosPermissao($dadosPermissao)
|
|
{
|
|
|
|
foreach ($dadosPermissao as $permissao) {
|
|
|
|
$ids = [];
|
|
|
|
foreach ($permissao['ocupacoes'] as $ocupacao) {
|
|
|
|
$permissaoOcupacaoId = self::obterIdentificacaoPermissaoOcupacao($permissao['id'], $ocupacao['ocupacao']);
|
|
|
|
if (is_null($permissaoOcupacaoId)) {
|
|
|
|
$id = self::incluirPermissaoOcupacao($permissao['id'], $ocupacao['ocupacao']);
|
|
} else {
|
|
|
|
$id = $permissaoOcupacaoId;
|
|
}
|
|
|
|
array_push($ids, $id);
|
|
}
|
|
|
|
$idsParaExcluir = self::obterOcupacaoPermissaoParaExcluir($ids);
|
|
|
|
self::excluirPermissaoOcupacao($permissao['id'], $idsParaExcluir);
|
|
}
|
|
}
|
|
|
|
private static function salvarOutros($dadosOutros)
|
|
{
|
|
|
|
if (sizeof($dadosOutros) > 0) {
|
|
|
|
self::salvarOutrosSalarioMinimo($dadosOutros['salario_minimo']);
|
|
self::salvarOutrosSupervisores($dadosOutros['supervisores']);
|
|
self::salvarOutrosPermissao($dadosOutros['permissao']);
|
|
}
|
|
}
|
|
|
|
public static function store($request)
|
|
{
|
|
self::salvarArea($request->areas);
|
|
self::salvarEquipe($request->equipes);
|
|
self::salvarFaturamento($request->faturamento);
|
|
self::salvarOutros($request->outros);
|
|
}
|
|
}
|