init commit

api/app/Http/Controllers/Mobile/ConectaCidadao/Agendamento/AgendamentoController.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\Agendamento;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\Agendamento\AgendamentoService;
+use Illuminate\Http\Response;
+
+class AgendamentoController extends Controller
+{
+    public function especialidades()
+    {
+        return response()->json(AgendamentoService::especialidades(), Response::HTTP_OK);
+    }
+
+    public function vagas()
+    {
+        return response()->json(AgendamentoService::vagas(), Response::HTTP_OK);
+    }
+
+    public function store()
+    {
+        return response()->json(AgendamentoService::store(), Response::HTTP_CREATED);
+    }
+
+    public function cancelar($id)
+    {
+        return response()->json(AgendamentoService::cancelar($id), Response::HTTP_OK);
+    }
+
+    public function historico()
+    {
+        return response()->json(AgendamentoService::historico(), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/Autenticacao/AutenticacaoController.php

@@ -0,0 +1,200 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\Autenticacao;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\Autenticacao\AutenticacaoService;
+use App\Services\Mobile\ConectaCidadao\Autenticacao\PrimeiroAcessoService;
+use App\Services\Mobile\ConectaCidadao\Autenticacao\RecuperacaoSenhaService;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+
+class AutenticacaoController extends Controller
+{
+    private AutenticacaoService $autenticacaoService;
+    private PrimeiroAcessoService $primeiroAcessoService;
+    private RecuperacaoSenhaService $recuperacaoSenhaService;
+
+    public function __construct(
+        AutenticacaoService $autenticacaoService,
+        PrimeiroAcessoService $primeiroAcessoService,
+        RecuperacaoSenhaService $recuperacaoSenhaService
+    ) {
+        $this->autenticacaoService = $autenticacaoService;
+        $this->primeiroAcessoService = $primeiroAcessoService;
+        $this->recuperacaoSenhaService = $recuperacaoSenhaService;
+    }
+
+    public function login(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'cpf' => ['required', 'string'],
+            'senha' => ['required', 'string'],
+        ]);
+
+        try {
+            $resultado = $this->autenticacaoService->login($dadosValidados);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNAUTHORIZED);
+        }
+
+        return response()->json($resultado, Response::HTTP_OK);
+    }
+
+    public function refresh(Request $request)
+    {
+        try {
+            $resultado = $this->autenticacaoService->refresh();
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNAUTHORIZED);
+        }
+
+        return response()->json($resultado, Response::HTTP_OK);
+    }
+
+    public function primeiroAcessoIniciar(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'cpf' => ['required', 'string'],
+            'data_nascimento' => ['required', 'date_format:Y-m-d'],
+            'telefone' => ['required', 'string'],
+        ]);
+
+        try {
+            $resultado = $this->primeiroAcessoService->iniciar($dadosValidados);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json($resultado, Response::HTTP_OK);
+    }
+
+    public function primeiroAcessoReenviarCodigo(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'token' => ['required', 'integer'],
+        ]);
+
+        try {
+            $this->primeiroAcessoService->reenviarCodigo($dadosValidados['token']);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json([], Response::HTTP_NO_CONTENT);
+    }
+
+    public function primeiroAcessoValidarCodigo(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'token' => ['required', 'integer'],
+            'codigo' => ['required', 'string'],
+        ]);
+
+        try {
+            $this->primeiroAcessoService->validarCodigo($dadosValidados);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json([], Response::HTTP_NO_CONTENT);
+    }
+
+    public function primeiroAcessoDefinirSenha(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'token' => ['required', 'integer'],
+            'senha' => ['required', 'string', 'min:6'],
+        ]);
+
+        try {
+            $this->primeiroAcessoService->definirSenha($dadosValidados);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json([], Response::HTTP_NO_CONTENT);
+    }
+
+    public function recuperacaoSenhaIniciar(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'cpf' => ['required', 'string'],
+        ]);
+
+        try {
+            $resultado = $this->recuperacaoSenhaService->iniciar($dadosValidados['cpf']);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json($resultado, Response::HTTP_OK);
+    }
+
+    public function recuperacaoSenhaReenviarCodigo(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'token' => ['required', 'integer'],
+        ]);
+
+        try {
+            $this->recuperacaoSenhaService->reenviarCodigo($dadosValidados['token']);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json([], Response::HTTP_NO_CONTENT);
+    }
+
+    public function recuperacaoSenhaValidarCodigo(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'token' => ['required', 'integer'],
+            'codigo' => ['required', 'string'],
+        ]);
+
+        try {
+            $this->recuperacaoSenhaService->validarCodigo($dadosValidados);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json([], Response::HTTP_NO_CONTENT);
+    }
+
+    public function recuperacaoSenhaRedefinirSenha(Request $request)
+    {
+        $dadosValidados = $request->validate([
+            'token' => ['required', 'integer'],
+            'senha' => ['required', 'string', 'min:6'],
+        ]);
+
+        try {
+            $this->recuperacaoSenhaService->redefinirSenha($dadosValidados);
+        } catch (\InvalidArgumentException $exception) {
+            return response()->json([
+                'message' => $exception->getMessage(),
+            ], $exception->getCode() ?: Response::HTTP_UNPROCESSABLE_ENTITY);
+        }
+
+        return response()->json([], Response::HTTP_NO_CONTENT);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/CarteiraVacinacao/CarteiraVacinacaoController.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\CarteiraVacinacao;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\CarteiraVacinacao\CarteiraVacinacaoService;
+use Illuminate\Http\Response;
+
+class CarteiraVacinacaoController extends Controller
+{
+    public function vacinas()
+    {
+        return response()->json(CarteiraVacinacaoService::vacinas(), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/EncaminhamentoRegulado/EncaminhamentoReguladoController.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\EncaminhamentoRegulado;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\EncaminhamentoRegulado\EncaminhamentoReguladoService;
+use Illuminate\Http\Response;
+
+class EncaminhamentoReguladoController extends Controller
+{
+    public function meusEncaminhamentos()
+    {
+        return response()->json(EncaminhamentoReguladoService::meusEncaminhamentos(), Response::HTTP_OK);
+    }
+
+    public function documentos(int $id)
+    {
+        return response()->json(EncaminhamentoReguladoService::documentos($id), Response::HTTP_OK);
+    }
+
+    public function documentoPorTipo(int $id, string $tipo)
+    {
+        return response()->json(EncaminhamentoReguladoService::documentoPorTipo($id, $tipo), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/ExameImagem/AgendamentoImagemController.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\ExameImagem;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\ExameImagem\AgendamentoImagemService;
+use Illuminate\Http\Response;
+
+class AgendamentoImagemController extends Controller
+{
+    public function elegibilidade()
+    {
+        return response()->json(AgendamentoImagemService::elegibilidade(), Response::HTTP_OK);
+    }
+
+    public function prestadores()
+    {
+        return response()->json(AgendamentoImagemService::prestadores(), Response::HTTP_OK);
+    }
+
+    public function exames()
+    {
+        return response()->json(AgendamentoImagemService::exames(), Response::HTTP_OK);
+    }
+
+    public function jornadas()
+    {
+        return response()->json(AgendamentoImagemService::jornadas(), Response::HTTP_OK);
+    }
+
+    public function agendar()
+    {
+        return response()->json(AgendamentoImagemService::agendar(), Response::HTTP_CREATED);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/ExameImagem/LaudoController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\ExameImagem;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\ExameImagem\LaudoService;
+use Illuminate\Http\Response;
+
+class LaudoController extends Controller
+{
+    public function laudos()
+    {
+        return response()->json(LaudoService::laudos(), Response::HTTP_OK);
+    }
+
+    public function download(int $exameId)
+    {
+        $laudo = LaudoService::download($exameId);
+
+        return response()->download($laudo['caminho'], $laudo['nome']);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/ExameLaboratorial/AgendamentoExameController.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\ExameLaboratorial;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\ExameLaboratorial\AgendamentoExameService;
+use Illuminate\Http\Response;
+
+class AgendamentoExameController extends Controller
+{
+    public function elegibilidade()
+    {
+        return response()->json(AgendamentoExameService::elegibilidade(), Response::HTTP_OK);
+    }
+
+    public function unidadesColeta()
+    {
+        return response()->json(AgendamentoExameService::unidadesColeta(), Response::HTTP_OK);
+    }
+
+    public function exames()
+    {
+        return response()->json(AgendamentoExameService::exames(), Response::HTTP_OK);
+    }
+
+    public function jornadas()
+    {
+        return response()->json(AgendamentoExameService::jornadas(), Response::HTTP_OK);
+    }
+
+    public function agendar()
+    {
+        return response()->json(AgendamentoExameService::agendar(), Response::HTTP_CREATED);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/ExameLaboratorial/LaudoController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\ExameLaboratorial;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\ExameLaboratorial\LaudoService;
+use Illuminate\Http\Response;
+
+class LaudoController extends Controller
+{
+    public function laudos()
+    {
+        return response()->json(LaudoService::laudos(), Response::HTTP_OK);
+    }
+
+    public function download(int $laudoId)
+    {
+        $laudo = LaudoService::download($laudoId);
+
+        return response()->download($laudo['caminho'], $laudo['nome']);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/ExclusaoConta/ExclusaoContaController.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\ExclusaoConta;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\ExclusaoConta\ExclusaoContaService;
+use Illuminate\Http\Response;
+
+class ExclusaoContaController extends Controller
+{
+    public function destroy($id)
+    {
+        return response()->json(ExclusaoContaService::excluirConta((int) $id), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/Farmacia/MonitoramentoPosologiaController.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\Farmacia;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\Farmacia\MonitoramentoPosologiaService;
+use Illuminate\Http\Response;
+
+class MonitoramentoPosologiaController extends Controller
+{
+    public function medicamentos()
+    {
+        return response()->json(MonitoramentoPosologiaService::medicamentos(), Response::HTTP_OK);
+    }
+
+    public function iniciar(int $receitaItemId)
+    {
+        return response()->json(MonitoramentoPosologiaService::iniciar($receitaItemId), Response::HTTP_OK);
+    }
+
+    public function index(int $receitaItemId)
+    {
+        return response()->json(MonitoramentoPosologiaService::index($receitaItemId), Response::HTTP_OK);
+    }
+
+    public function store(int $receitaItemId)
+    {
+        return response()->json(MonitoramentoPosologiaService::store($receitaItemId), Response::HTTP_CREATED);
+    }
+
+    public function destroy(int $id)
+    {
+        return response()->json(MonitoramentoPosologiaService::destroy($id), Response::HTTP_OK);
+    }
+
+    public function interromper(int $receitaItemId)
+    {
+        return response()->json(MonitoramentoPosologiaService::interromper($receitaItemId), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/Farmacia/ReceitaController.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\Farmacia;
+
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\Farmacia\ReceitaService;
+use Illuminate\Http\Response;
+
+class ReceitaController extends Controller
+{
+    public function index()
+    {
+        return response()->json(ReceitaService::index(), Response::HTTP_OK);
+    }
+
+    public function show(int $id)
+    {
+        return response()->json(ReceitaService::show($id), Response::HTTP_OK);
+    }
+
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/HistoricoAtendimento/HistoricoAtendimentoController.php

@@ -0,0 +1,161 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\HistoricoAtendimento;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\SujeitoAtencao\Paciente;
+use Illuminate\Database\Eloquent\ModelNotFoundException;
+use App\Services\Mobile\ConectaCidadao\HistoricoAtendimento\HistoricoAtendimentoService;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Exception;
+
+class HistoricoAtendimentoController extends Controller
+{
+    private HistoricoAtendimentoService $historicoAtendimentoService;
+
+    public function __construct(HistoricoAtendimentoService $historicoAtendimentoService)
+    {
+        $this->historicoAtendimentoService = $historicoAtendimentoService;
+    }
+
+    public function index(Request $request)
+    {
+        try {
+
+            $pacienteId = $request->input('paciente_id');
+
+            if (!$pacienteId) {
+
+                return response()->json(
+                    [
+                        'message' => 'O parâmetro paciente_id é obrigatório.'
+                    ], 
+                    Response::HTTP_BAD_REQUEST
+                );
+            }
+
+            $paciente = Paciente::find($pacienteId);
+
+            if (!$paciente) {
+
+                return response()->json(
+                    [
+                        'message' => 'Paciente não encontrado.'
+                    ], 
+                    Response::HTTP_NOT_FOUND
+                );
+            }
+
+            $limit = $request->input('limit', 15);
+            $historico = $this->historicoAtendimentoService->getHistorico($paciente, $limit);
+
+        } catch (Exception $exception) {
+            return response()->json(
+                [
+                    'message' => $exception->getMessage(),
+                ], 
+                Response::HTTP_INTERNAL_SERVER_ERROR
+            );
+        }
+
+        return response()->json($historico, Response::HTTP_OK);
+    }
+
+    public function show($id, Request $request)
+    {
+        try {
+
+            $sourceType = $request->input('source_type');
+
+            if (!$sourceType) {
+
+                return response()->json(
+                    [
+                        'message' => 'O parâmetro source_type é obrigatório.'
+                    ], 
+                Response::HTTP_BAD_REQUEST);
+            }
+
+            $detalhes = $this->historicoAtendimentoService->getDetalhes($id, $sourceType);
+
+            return response()->json($detalhes, Response::HTTP_OK);
+
+        } catch (ModelNotFoundException $e) {
+
+            return response()->json(
+                [
+                    'message' => 'Atendimento não encontrado.'
+                ], 
+                Response::HTTP_NOT_FOUND
+            );
+        } catch (\Exception $exception) {
+            return response()->json(
+                [
+                    'message' => $exception->getMessage(),
+                ],
+                Response::HTTP_INTERNAL_SERVER_ERROR
+            );
+        }
+    }
+
+    public function avaliar($sourceType, $id, Request $request)
+    {
+        try {
+
+            $params = $request->all();
+
+            $this->historicoAtendimentoService->avaliar($sourceType, $id, $params);
+
+            return response()->json(
+                [
+                    'message' => 'Avaliação registrada com sucesso.'
+                ], 
+                Response::HTTP_OK
+            );
+
+        } catch (ModelNotFoundException $e) {
+
+            return response()->json(
+                [
+                    'message' => 'Atendimento não encontrado.'
+                ], 
+                Response::HTTP_NOT_FOUND
+            );
+        } catch (\Exception $exception) {
+            return response()->json(
+                [
+                    'message' => $exception->getMessage(),
+                ],
+                Response::HTTP_INTERNAL_SERVER_ERROR
+            );
+        }
+    }
+
+    public function avaliacao($sourceType, $id, Request $request)
+    {
+        try {
+
+            $params = $request->all();
+
+            $avaliacao = $this->historicoAtendimentoService->avaliacao($sourceType, $id, $params);
+
+            return response()->json($avaliacao, Response::HTTP_OK);
+        } catch (ModelNotFoundException $e) {
+
+            return response()->json(
+                [
+                    'message' => 'Avaliação não encontrada.'
+                ], 
+                Response::HTTP_NOT_FOUND
+            );
+        } catch (\Exception $exception) {
+            return response()->json(
+                [
+                    'message' => $exception->getMessage(),
+                ],
+                Response::HTTP_INTERNAL_SERVER_ERROR
+            );
+        }
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/PerfilCidadao/PerfilCidadaoController.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\PerfilCidadao;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\SujeitoAtencao\Paciente;
+use App\Services\Mobile\ConectaCidadao\PerfilCidadao\PerfilCidadaoService;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Exception;
+
+class PerfilCidadaoController extends Controller
+{
+    private PerfilCidadaoService $perfilCidadaoService;
+
+    public function __construct(PerfilCidadaoService $perfilCidadaoService)
+    {
+        $this->perfilCidadaoService = $perfilCidadaoService;
+    }
+
+    public function index(Request $request)
+    {
+        try {
+
+            $pacienteId = $request->input('paciente_id');
+
+            if (!$pacienteId) {
+
+                return response()->json(
+                    [
+                        'message' => 'O parâmetro paciente_id é obrigatório.'
+                    ],
+                    Response::HTTP_BAD_REQUEST
+                );
+            }
+
+            $paciente = Paciente::find($pacienteId);
+
+            if (!$paciente) {
+
+                return response()->json(
+                    [
+                        'message' => 'Paciente não encontrado.'
+                    ],
+                    Response::HTTP_NOT_FOUND
+                );
+            }
+
+            $dadosCidadao = $this->perfilCidadaoService->getDadosCidadao($paciente);
+        } catch (Exception $exception) {
+            return response()->json(
+                [
+                    'message' => $exception->getMessage(),
+                ],
+                Response::HTTP_INTERNAL_SERVER_ERROR
+            );
+        }
+
+        return response()->json($dadosCidadao, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaCidadao/Termos/TermoController.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaCidadao\Termos;
+
+use App\Enums\Mobile\ConectaCidadao\TermoTipo;
+use App\Http\Controllers\Controller;
+use App\Services\Mobile\ConectaCidadao\Termos\TermoService;
+use Illuminate\Http\Response;
+
+class TermoController extends Controller
+{
+    public function politicaCidadao()
+    {
+        $termo = TermoService::getAtivoByTipo(TermoTipo::TERMO_USO);
+
+        return view('conectasus-cidadao.politica-conectasus-cidadao', compact('termo'));
+    }
+
+    public function ativo()
+    {
+        return response()->json(TermoService::getAtivo(), Response::HTTP_OK);
+    }
+
+    public function show($id)
+    {
+        return response()->json(TermoService::getById($id), Response::HTTP_OK);
+    }
+
+    public function pendentes()
+    {
+        return response()->json(TermoService::getPendentes(), Response::HTTP_OK);
+    }
+
+    public function aceitar($id)
+    {
+        return response()->json(TermoService::aceitar($id), Response::HTTP_CREATED);
+    }
+
+    public function aceitacoes()
+    {
+        return response()->json(TermoService::getAceitacoes(), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Administracao/AutenticacaoController.php

@@ -0,0 +1,202 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Administracao;
+
+use App\Enums\Intranet\Sistema;
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\SujeitoAtencao\Usuario;
+use App\Models\Cadastro\SujeitoAtencao\UsuarioHistoricoAcesso;
+use App\Models\Cadastro\Estabelecimento\CentroCusto;
+use App\Models\Cadastro\SujeitoAtencao\Lotacao;
+use App\Models\Geral\Configuracao;
+use App\Models\Intranet\Cliente;
+use App\Utils\Email;
+use App\Utils\Senha;
+use Illuminate\Http\Response;
+use Illuminate\Support\Facades\Hash;
+
+class AutenticacaoController extends Controller
+{
+    public function login()
+    {
+
+        $cliente = Cliente::where('sistema_id', Sistema::CONECTASUS)
+            ->where('link', request()->header('customer'))
+            ->first();
+
+        if ($cliente->ativo === false) {
+            return response()->json(['message' => 'O cliente está com o status inativo.'], Response::HTTP_UNAUTHORIZED);
+        }
+
+        $credentials = request(['usuario', 'senha']);
+
+        $usuario = Usuario::where('usuario', $credentials['usuario'])
+            ->first();
+
+        if (is_null($usuario)) {
+
+            return response()->json(['message' => 'Usuário e/ou senha incorreto(s).'], Response::HTTP_UNAUTHORIZED);
+        }
+
+        if ($usuario->bloqueado) {
+            return response()->json(['message' => 'Usuário bloqueado e sem acesso ao sistema.'], Response::HTTP_UNAUTHORIZED);
+        }
+
+        if (!Hash::check($credentials['senha'], $usuario->senha)) {
+            $configuracao = Configuracao::first();
+
+            $usuarioHistoricoAcesso = UsuarioHistoricoAcesso::where('usuario_id', $usuario->id)
+                ->where('ativo', true)
+                ->orderBy('created_at', 'desc')
+                ->take($configuracao->maximo_tentativa_login - 1)
+                ->get();
+
+            if (
+                $usuarioHistoricoAcesso->count() === ($configuracao->maximo_tentativa_login - 1)
+                && $usuarioHistoricoAcesso->contains('sucesso', true) === false
+            ) {
+                $usuario->update(['bloqueado' => true]);
+            }
+
+            UsuarioHistoricoAcesso::create(
+                [
+                    'usuario_id' => $usuario->id,
+                    'sucesso' => false
+                ]
+            );
+
+            return response()->json(['message' => 'Usuário e/ou senha incorreto(s).'], Response::HTTP_UNAUTHORIZED);
+        }
+
+        UsuarioHistoricoAcesso::create(
+            [
+                'usuario_id' => $usuario->id,
+                'sucesso' => true,
+                'ativo' => false,
+            ]
+        );
+
+        UsuarioHistoricoAcesso::where('usuario_id', $usuario->id)->update(['ativo' => false]);
+
+        $token = auth()->login($usuario);
+
+        $usuario = auth()->user()->load([
+            'lotacoes' => fn($q) => $q->where('ativo', true),
+            'lotacoes.infraestrutura.centrosCusto.setor',
+            'lotacoes.infraestrutura.unidade',
+            'lotacoes.ocupacao',
+        ]);
+
+        $lotacoes = $usuario->lotacoes->sortBy('infraestrutura.unidade.nome_fantasia')->values()
+            ->map(function ($lotacao) {
+
+                $centrosCusto = $lotacao->infraestrutura->centrosCusto->sortBy('setor.nome')->values();
+
+                return [
+                    'lotacao_id' => $lotacao->id,
+                    'ocupacao_id' => $lotacao->ocupacao_id,
+                    'ocupacao' => $lotacao->ocupacao->toArray(),
+                    'infraestrutura' => $centrosCusto->toArray(),
+                    'unidade_id' => $lotacao->infraestrutura->unidade->id,
+                    'unidade_nome_fantasia' => $lotacao->infraestrutura->unidade->nome_fantasia,
+                    'unidade_cnes' => $lotacao->infraestrutura->unidade->cnes,
+                ];
+            })
+            ->toArray();
+
+        $usuario = $usuario->toArray();
+
+        $response = [
+            'expiration' => time() + 60 * auth()->factory()->getTTL(),
+            'token' => $token,
+            'usuario' => [
+                'id' => $usuario['id'],
+                'usuario' => $usuario['usuario'],
+                'bloqueado' => $usuario['bloqueado'],
+                'lotacoes' => $lotacoes
+            ]
+        ];
+
+        return response()->json($response, Response::HTTP_OK);
+    }
+
+    public function refresh()
+    {
+
+        $usuario = auth()->user();
+
+        if ($usuario->troca_senha) {
+            return response()->json(['error' => 'Você deve alterar sua senha antes de prosseguir.'], Response::HTTP_UNAUTHORIZED);
+        }
+
+        $lotacao = Lotacao::with(['usuario', 'ocupacao', 'papeis.permissoes.funcionalidade.modulo', 'permissoes.funcionalidade.modulo'])
+            ->where('id', request()->lotacao_id)
+            ->where('ativo', true)
+            ->firstOrFail();
+
+        $centroCusto = CentroCusto::with(['setor', 'salas'])
+            ->where('infraestrutura_id', request()->centro_custo_id)
+            ->firstOrFail();
+
+        $token = auth()->claims([
+            'lotacao_id' => $lotacao->id,
+            'centro_custo_id' => $centroCusto->id,
+            'unidade_id' => $centroCusto->infraestrutura->unidade_id,
+            'infraestrutura_id' => $centroCusto->infraestrutura_id,
+        ]);
+
+        $permissoes = collect();
+
+        foreach ($lotacao->papeis as $papel) {
+
+            foreach ($papel->permissoes as $permissao) {
+
+                $permissoes->push($permissao);
+            }
+        }
+
+        return response()->json([
+            'expiration' => time() + 60 * auth()->factory()->getTTL(),
+            'token' => $token->refresh(),
+            'permissoes' => $permissoes->merge($lotacao->permissoes),
+        ]);
+    }
+
+    public function recuperarSenha(RecuperacaoSenhaRequest $request)
+    {
+        $usuario = Usuario::where('email', $request->email)
+            ->whereHas('cidadao', function ($query) use ($request) {
+                $query->where('cpf', $request->cpf);
+            })
+            ->first();
+
+        if (is_null($usuario)) {
+
+            return response()->json([
+                'message' => 'A informação inserida não está correta, tente novamente.'
+            ], Response::HTTP_BAD_REQUEST);
+        }
+
+        if ($usuario) {
+            $senha = Senha::gerar();
+
+            $params = [
+                'senha' => $senha,
+                'troca_senha' => true,
+            ];
+
+            $usuario->update($params);
+
+            $object = new \stdClass();
+            $object->user = $usuario->usuario;
+            $object->password = $senha;
+            $object->cliente = $request->header('customer');
+
+            Email::enviar(strtolower($usuario->email), new UsuarioLogin($object));
+        }
+
+        return response()->json([
+            'message' => 'Usuário e senha enviados para o e-mail ' . $usuario->email
+        ], Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/AtencaoBasica/CadastroDomiciliar/CadastroDomiciliarController.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\AtencaoBasica\CadastroDomiciliar;
+
+use App\Http\Controllers\Controller;
+use App\Models\AtencaoBasica\CadastroDomiciliar\CadastroDomiciliar;
+use Illuminate\Http\Response;
+
+class CadastroDomiciliarController extends Controller
+{
+    protected $modulo = 'atencao-basica';
+    protected $funcionalidade = 'cadastro-domiciliar';
+
+    public function index($idUnidade, $idEquipe, $idMicoarea, $exibirForaArea)
+    {
+
+        $vinculos = [
+            'domicilio',
+            'domicilio.endereco',
+            'equipe' => function ($query) use ($idUnidade) {
+                $query->where('unidade_id', $idUnidade);
+            },
+            'microarea:id,area_id',
+            'lazer:id',
+            'animal:id'
+        ];
+
+        $cadastrosDomiciliares = CadastroDomiciliar::with($vinculos)
+            ->where(function ($query) use ($idEquipe, $exibirForaArea) {
+
+                if ($exibirForaArea == 1) {
+
+                    $query->whereNull('equipe_id');
+                    $query->orWhere('equipe_id', $idEquipe);
+                } else {
+
+                    $query->where('equipe_id', $idEquipe);
+                }
+            })
+            ->where('microarea_id', $idMicoarea)
+            ->get()
+            ->map(function ($cadastroDomiciliar) {
+
+                $domicilioId = $cadastroDomiciliar->domicilio->id ?? null;
+                $domicilioEnderecoId = $cadastroDomiciliar->domicilio->endereco->id ?? null;
+                $domicilioEnderecoNumero = $cadastroDomiciliar->domicilio->endereco->numero ?? null;
+                $domicilioEnderecoComplemento = $cadastroDomiciliar->domicilio->endereco->complemento ?? null;
+                $domicilioEnderecoSemNumero = $cadastroDomiciliar->domicilio->endereco->sem_numero ?? null;
+                $loteamento = $cadastroDomiciliar->domicilio->loteamento->nome ?? null;
+                $loteamentoId = $cadastroDomiciliar->domicilio->loteamento->id ?? null;
+                $logradouroId = $cadastroDomiciliar->domicilio->endereco->logradouro->id ?? null;
+                $logradouroTipoId = $cadastroDomiciliar->domicilio->endereco->logradouro->tipo->id ?? null;
+                $bairroId = $cadastroDomiciliar->domicilio->endereco->logradouro->bairro->id ?? null;
+                $cep = $cadastroDomiciliar->domicilio->endereco->logradouro->cep ?? null;
+                $latitude = $cadastroDomiciliar->domicilio->endereco->latitude ?? null;
+                $longitude = $cadastroDomiciliar->domicilio->endereco->longitude ?? null;
+                $areaId = $cadastroDomiciliar->microarea->area_id ?? null;
+
+                unset($cadastroDomiciliar->microarea);
+                unset($cadastroDomiciliar->domicilio);
+
+                return [
+                    'id' => $cadastroDomiciliar->id,
+                    'area_id' => $areaId,
+                    'microarea_id' => $cadastroDomiciliar->microarea_id,
+                    'fora_area' => $cadastroDomiciliar->fora_area,
+                    'instituicao_nome' => $cadastroDomiciliar->instituicao_nome,
+                    'instituicao_nome_responsavel_tecnico' => $cadastroDomiciliar->instituicao_nome_responsavel_tecnico,
+                    'instituicao_cns_responsavel_tecnico' => $cadastroDomiciliar->instituicao_cns_responsavel_tecnico,
+                    'instituicao_cargo_responsavel_tecnico' => $cadastroDomiciliar->instituicao_cargo_responsavel_tecnico,
+                    'instituicao_telefone_responsavel_tecnico' => $cadastroDomiciliar->instituicao_telefone_responsavel_tecnico,
+                    'imovel_tipo_id' => $cadastroDomiciliar->imovel_tipo_id,
+                    'situacao_domicilio_id' => $cadastroDomiciliar->situacao_domicilio_id,
+                    'domicilio_tipo_id' => $cadastroDomiciliar->domicilio_tipo_id,
+                    'quantidade_comodos' => $cadastroDomiciliar->quantidade_comodos,
+                    'situacao_rural_id' => $cadastroDomiciliar->situacao_rural_id,
+                    'domicilio_zona_id' => $cadastroDomiciliar->domicilio_zona_id,
+                    'domicilio_tipo_acesso_id' => $cadastroDomiciliar->domicilio_tipo_acesso_id,
+                    'material_predominante_id' => $cadastroDomiciliar->material_predominante_id,
+                    'abastecimento_id' => $cadastroDomiciliar->abastecimento_id,
+                    'tratamento_id' => $cadastroDomiciliar->tratamento_id,
+                    'destino_lixo_id' => $cadastroDomiciliar->destino_lixo_id,
+                    'forma_escoamento_id' => $cadastroDomiciliar->forma_escoamento_id,
+                    'possui_animais' => $cadastroDomiciliar->possui_animais,
+                    'energia_eletrica' => $cadastroDomiciliar->energia_eletrica,
+                    'quantidade_animais' => $cadastroDomiciliar->quantidade_animais,
+                    'usuario_id' => $cadastroDomiciliar->usuario_id,
+                    'equipe_id' => $cadastroDomiciliar->equipe_id,
+                    'usuario_ocupacao_id' => $cadastroDomiciliar->usuario_ocupacao_id,
+                    'data_usuario_responsavel' => $cadastroDomiciliar->data_usuario_responsavel,
+                    'escala_coelho_id' => $cadastroDomiciliar->escala_coelho_id,
+                    'higiene_residencial_id' => $cadastroDomiciliar->higiene_residencial_id,
+                    'bolsa_familia' => $cadastroDomiciliar->bolsa_familia,
+                    'vale_gas' => $cadastroDomiciliar->vale_gas,
+                    'bolsa_escola' => $cadastroDomiciliar->bolsa_escola,
+                    'bpc' => $cadastroDomiciliar->bpc,
+                    'recusa_cadastro' => $cadastroDomiciliar->recusa_cadastro,
+                    'domicilio_id' => $domicilioId,
+                    'domicilio_endereco_id' => $domicilioEnderecoId,
+                    'domicilio_endereco_numero' => $domicilioEnderecoNumero,
+                    'domicilio_endereco_complemento' => $domicilioEnderecoComplemento,
+                    'domicilio_endereco_sem_numero' => $domicilioEnderecoSemNumero,
+                    'loteamento' => $loteamento,
+                    'loteamento_id' => $loteamentoId,
+                    'lazer' => $cadastroDomiciliar->lazer->pluck('id'),
+                    'animal' => $cadastroDomiciliar->animal->pluck('id'),
+                    'unidade_id' => $cadastroDomiciliar->equipe->unidade_id,
+                    'infraestrutura_id' => $cadastroDomiciliar->equipe->infraestrutura_id,
+                    'logradouro_id' => $logradouroId,
+                    'logradouro_tipo_id' => $logradouroTipoId,
+                    'bairro_id' => $bairroId,
+                    'cep' => $cep,
+                    'latitude' => $latitude,
+                    'longitude' => $longitude,
+                ];
+            });
+
+        return response()->json($cadastrosDomiciliares, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/AtencaoBasica/CadastroIndividual/CadastroIndividualController.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\AtencaoBasica\CadastroIndividual;
+
+use App\Http\Controllers\Controller;
+use App\Models\AtencaoBasica\CadastroIndividual\CadastroIndividual;
+use Illuminate\Http\Response;
+
+class CadastroIndividualController extends Controller
+{
+    protected $modulo = 'atencao-basica';
+    protected $funcionalidade = 'cadastro-individual';
+
+    public function index($idUnidade, $idEquipe, $exibirForaArea)
+    {
+
+        $vinculos = [
+            'paciente' => function ($query) use ($idUnidade) {
+                $query->where('unidade_id', $idUnidade);
+            },
+            'paciente.cidadao',
+            'paciente.informacaoSocial',
+            'deficiencia',
+            'acompanhamentoInfantil',
+            'doencaCardiaca',
+            'problemasRins',
+            'doencaRespiratoria',
+            'origemAlimentacao',
+            'higienePessoal'
+        ];
+
+        $cadastrosIndividuais = CadastroIndividual::with($vinculos)
+            ->where(function ($query) use ($idEquipe, $exibirForaArea) {
+
+                if ($exibirForaArea == 1) {
+
+                    $query->whereNull('equipe_id');
+                    $query->orWhere('equipe_id', $idEquipe);
+                } else {
+
+                    $query->where('equipe_id', $idEquipe);
+                }
+            })
+            ->get()
+            ->map(function ($cadastroIndividual) {
+
+                return [
+                    'id' => $cadastroIndividual->id,
+                    'paciente_id' => $cadastroIndividual->paciente_id,
+                    'usuario_id' => $cadastroIndividual->usuario_id,
+                    'equipe_id' => $cadastroIndividual->equipe_id,
+                    'usuario_ocupacao_id' => $cadastroIndividual->usuario_ocupacao_id,
+                    'data_usuario_responsavel' => $cadastroIndividual->data_usuario_responsavel,
+                    'responsavel' => $cadastroIndividual->responsavel,
+                    'responsavel_cidadao_id' => $cadastroIndividual->responsavel_cidadao_id,
+                    'renda_mensal' => $cadastroIndividual->renda_mensal,
+                    'ativo' => $cadastroIndividual->ativo,
+                    'parentesco_responsavel_id' => $cadastroIndividual->parentesco_responsavel_id,
+                    'ocupacao_id' => $cadastroIndividual->ocupacao_id,
+                    'curso_id' => $cadastroIndividual->curso_id,
+                    'frequenta_escola_creche' => $cadastroIndividual->frequenta_escola_creche,
+                    'situacao_mercado_trabalho_id' => $cadastroIndividual->situacao_mercado_trabalho_id,
+                    'frequenta_cuidador_tradicional' => $cadastroIndividual->frequenta_cuidador_tradicional,
+                    'participa_grupo_comunitario' => $cadastroIndividual->participa_grupo_comunitario,
+                    'acompanhamento_infantil' => $cadastroIndividual->acompanhamentoInfantil->pluck('id'),
+                    'plano_saude' => $cadastroIndividual->plano_saude,
+                    'comunidade_tradicional' => $cadastroIndividual->comunidade_tradicional,
+                    'comunidade_tradicional_id' => $cadastroIndividual->comunidade_tradicional_id,
+                    'orientacao_sexual' => $cadastroIndividual->orientacao_sexual,
+                    'orientacao_sexual_id' => $cadastroIndividual->orientacao_sexual_id,
+                    'identidade_genero' => $cadastroIndividual->identidade_genero,
+                    'identidade_genero_id' => $cadastroIndividual->paciente ? $cadastroIndividual->paciente->cidadao ? $cadastroIndividual->paciente->cidadao->identidade_genero_id : null : null,
+                    'deficiente' => $cadastroIndividual->deficiente,
+                    'deficiencias' => $cadastroIndividual->deficiencia->pluck('id'),
+                    'saida_cidadao_id' => $cadastroIndividual->saida_cidadao_id,
+                    'motivo_saida_data' => $cadastroIndividual->motivo_saida_data,
+                    'recusa_cadastro' => $cadastroIndividual->recusa_cadastro,
+                    'gestante' => $cadastroIndividual->gestante,
+                    'maternidade_referencia' => $cadastroIndividual->maternidade_referencia,
+                    'peso_id' => $cadastroIndividual->peso_id,
+                    'fumante' => $cadastroIndividual->fumante,
+                    'usa_alcool' => $cadastroIndividual->usa_alcool,
+                    'outras_drogas' => $cadastroIndividual->outras_drogas,
+                    'hipertensao' => $cadastroIndividual->hipertensao,
+                    'diabetes' => $cadastroIndividual->diabetes,
+                    'avc_derrame' => $cadastroIndividual->avc_derrame,
+                    'infarto' => $cadastroIndividual->infarto,
+                    'hanseniase' => $cadastroIndividual->hanseniase,
+                    'tuberculose' => $cadastroIndividual->tuberculose,
+                    'cancer' => $cadastroIndividual->cancer,
+                    'fibromialgia' => $cadastroIndividual->fibromialgia,
+                    'transtorno_espectro_autista' => $cadastroIndividual->transtorno_espectro_autista,
+                    'internacao' => $cadastroIndividual->internacao,
+                    'internacao_motivo' => $cadastroIndividual->internacao_motivo,
+                    'doenca_cardiaca' => $cadastroIndividual->doenca_cardiaca,
+                    'doenca_cardiaca_quais' => $cadastroIndividual->doencaCardiaca->pluck('id'),
+                    'problemas_rins' => $cadastroIndividual->problemas_rins,
+                    'problemas_rins_quais' => $cadastroIndividual->problemasRins->pluck('id'),
+                    'doenca_respiratoria' => $cadastroIndividual->doenca_respiratoria,
+                    'doenca_respiratoria_quais' => $cadastroIndividual->doencaRespiratoria->pluck('id'),
+                    'tratamento_saude_mental' => $cadastroIndividual->tratamento_saude_mental,
+                    'acamado' => $cadastroIndividual->acamado,
+                    'domiciliado' => $cadastroIndividual->domiciliado,
+                    'plantas_medicinais' => $cadastroIndividual->plantas_medicinais,
+                    'plantas_medicinais_quais' => $cadastroIndividual->plantas_medicinais_quais,
+                    'praticas_integrativas' => $cadastroIndividual->praticas_integrativas,
+                    'outras_condicoes_primaria' => $cadastroIndividual->outras_condicoes_primaria,
+                    'outras_condicoes_secundaria' => $cadastroIndividual->outras_condicoes_secundaria,
+                    'outras_condicoes_terciaria' => $cadastroIndividual->outras_condicoes_terciaria,
+                    'situacao_rua_id' => $cadastroIndividual->situacao_rua_id,
+                    'outra_instituicao' => $cadastroIndividual->outra_instituicao,
+                    'outra_instituicao_quais' => $cadastroIndividual->outra_instituicao_quais,
+                    'recebe_beneficio' => $cadastroIndividual->recebe_beneficio,
+                    'referencia_familiar' => $cadastroIndividual->referencia_familiar,
+                    'visita_familiar' => $cadastroIndividual->visita_familiar,
+                    'parentesco' => $cadastroIndividual->parentesco,
+                    'alimentacao_diaria_id' => $cadastroIndividual->alimentacao_diaria_id,
+                    'origem_alimentacao' => $cadastroIndividual->origemAlimentacao->pluck('id'),
+                    'higiene_pessoal' => $cadastroIndividual->higiene_pessoal,
+                    'higiene_pessoal_quais' => $cadastroIndividual->higienePessoal->pluck('id'),
+                    'supervisor_id' => $cadastroIndividual->supervisor_id,
+                    "alimentos_acabaram" => $cadastroIndividual->alimentos_acabaram,
+                    "comeu_alguns_alimentos" => $cadastroIndividual->comeu_alguns_alimentos,
+                ];
+            });
+
+        return response()->json($cadastrosIndividuais, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/AtencaoBasica/CadastroIndividual/ComunidadeTradicionalController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\AtencaoBasica\CadastroIndividual;
+
+use App\Http\Controllers\Controller;
+use App\Models\AtencaoBasica\CadastroIndividual\ComunidadeTradicional;
+use Illuminate\Http\Response;
+
+class ComunidadeTradicionalController extends Controller
+{
+    protected $modulo = 'atencao-basica';
+    protected $funcionalidade = 'cadastro-individual';
+
+    public function index()
+    {
+
+        $comunidadesTradicionais = ComunidadeTradicional::all(['id', 'descricao'])
+            ->toArray();
+
+        return response()->json($comunidadesTradicionais, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/AtencaoBasica/Parametrizacao/ParametrizacaoController.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\AtencaoBasica\Parametrizacao;
+
+use App\Http\Controllers\Controller;
+use App\Models\AtencaoBasica\Parametrizacao\Equipe;
+use App\Models\AtencaoBasica\Parametrizacao\EquipeUsuario;
+use Illuminate\Http\Response;
+
+class ParametrizacaoController extends Controller
+{
+    protected $modulo = 'atencao-basica';
+    protected $funcionalidade = 'parametrizacao';
+
+    public function obterEquipe($idUsuario)
+    {
+
+        $vinculos = [
+            'area',
+            'infraestrutura',
+            'microarea',
+            'unidade',
+            'usuarios',
+        ];
+
+        $equipes = Equipe::with($vinculos)
+            ->whereHas('usuarios', function ($query) use ($idUsuario) {
+
+                $query->where('usuario_id', $idUsuario);
+            })
+            ->get()
+            ->map(function ($equipe) {
+
+                return [
+                    'id' => $equipe->id,
+                    'area_id' => $equipe->area_id,
+                    'descricao_area' => $equipe->area->descricao,
+                    'microarea_id' => $equipe->microarea_id ?? null,
+                    'microarea_descricao' => $equipe->microarea->descricao ?? null,
+                    'numero_ine' => $equipe->area->numero_ine,
+                    'area_tipo' => $equipe->area->tipo_id,
+                    'unidade_id' => $equipe->unidade->id,
+                    'unidade_descricao' => $equipe->unidade->nome_fantasia,
+                    'infraestrutura_id' => $equipe->infraestrutura_id,
+                    'infraestrutura_descricao' => $equipe->infraestrutura->nome
+                ];
+            });
+
+        return response()->json($equipes, Response::HTTP_OK);
+    }
+
+    public function obterEquipeUsuario($idUnidade, $idUsuario)
+    {
+
+        $equipesUsuario = EquipeUsuario::where('usuario_id', $idUsuario)
+            ->whereIn('equipe_id', function ($query) use ($idUnidade) {
+
+                $query->select('id')
+                    ->from('atencao_basica_parametrizacao_equipe')
+                    ->where('unidade_id', $idUnidade);
+            })
+            ->get();
+
+        return response()->json($equipesUsuario, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/AtencaoBasica/Parametrizacao/ParametrizacaoExameController.php

@@ -0,0 +1,21 @@
+<?php
+ 
+namespace App\Http\Controllers\Mobile\ConectaSusAb\AtencaoBasica\Parametrizacao;
+
+use App\Http\Controllers\Controller;
+use App\Models\Parametrizacao\Exame\Exame;
+use Illuminate\Http\Response;
+ 
+class ParametrizacaoExameController extends Controller
+{
+    protected $modulo = 'parametrizacao';
+    protected $funcionalidade = 'exame';
+ 
+    public function index()
+    {
+        $parametrizacaoExames = Exame::all(['id', 'codigo', 'nome'])
+            ->toArray();
+ 
+        return response()->json($parametrizacaoExames, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/AlergiaController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\SujeitoAtencao\Alergia;
+use Illuminate\Http\Response;
+
+class AlergiaController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'alergia';
+
+    public function index()
+    {
+
+        $alergias = Alergia::with(['tipo'])
+            ->orderBy('agente_substancia_especifica')
+            ->get()
+            ->map(function ($alergia) {
+
+                return [
+                    'id' => $alergia->id,
+                    'agente_substancia_especifica'  => $alergia->agente_substancia_especifica,
+                    'tipo_id' => $alergia->tipo->id,
+                    'tipo_descricao' => $alergia->tipo->descricao,
+                ];
+            });
+
+        return response()->json($alergias, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/BairroController.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\Localizacao\Bairro;
+use Illuminate\Http\Response;
+
+class BairroController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'bairro';
+
+    public function index()
+    {
+
+        $bairros = $this->get(Bairro::class)->orderBy('nome')->get();
+
+        return response()->json($bairros, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/CidadaoController.php

@@ -0,0 +1,414 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Enums\AtencaoBasica\CadastroIndividual\SaidaCidadao as EnumSaidaCidadao;
+use App\Http\Controllers\Controller;
+use App\Services\Geral\AgeService;
+use Illuminate\Http\Response;
+use Illuminate\Support\Facades\DB;
+use DateTime;
+
+class CidadaoController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'cidadao';
+
+    public function index($idUnidade, $idEquipe, $exibirForaArea, $pagina = 0)
+    {
+
+        $condicaoForaArea = $exibirForaArea == 1 ? 'or atencao_basica_cadastro_individual.equipe_id is null' : '';
+
+        $listaCidadaos = DB::select(DB::raw("
+            select      atencao_basica_cadastro_individual.equipe_id,
+                        cadastro_cidadao.id as cidadao_id,
+                        cadastro_cidadao.cns,
+                        cadastro_cidadao.cpf,
+                        cadastro_cidadao.nome,
+                        cadastro_cidadao.nome_social,
+                        cadastro_cidadao.data_nascimento,
+                        cadastro_cidadao.conjuge,
+                        cadastro_cidadao.nome_mae,
+                        cadastro_cidadao.nome_pai,
+                        cadastro_cidadao.frequenta_escola,
+                        cadastro_cidadao.municipio_nascimento_id,
+                        cadastro_cidadao.pais_nascimento_id,
+                        cadastro_cidadao.estado_nascimento_id,
+                        cadastro_cidadao.escolaridade_id,
+                        cadastro_cidadao.local_nascimento_id,
+                        cadastro_cidadao.estado_civil_id,
+                        cadastro_cidadao.nacionalidade_id,
+                        cadastro_cidadao.etnia_indigena_id,
+                        cadastro_cidadao.raca_cor_id,
+                        cadastro_cidadao.situacao_familiar_conjugal_id,
+                        cadastro_cidadao.tipo_sanguineo_id,
+                        cadastro_cidadao.domicilio_id,
+                        cadastro_cidadao.data_entrada_domicilio,
+                        cadastro_cidadao.motivo_duplicidade_cpf_id,
+                        cadastro_cidadao.created_lotacao_id,
+                        cadastro_cidadao.created_centro_custo_id,
+                        cadastro_cidadao.updated_lotacao_id,
+                        cadastro_cidadao.updated_centro_custo_id,
+                        cadastro_cidadao.identidade_genero_id,
+                        cadastro_cidadao.fator_risco_outro,
+                        cadastro_cidadao.deficiencia_id,
+                        cadastro_cidadao.deficiencia_outro,
+                        cadastro_cidadao.mobilidade_reduzida_id,
+                        cadastro_cidadao.preferencia_nome_id,
+                        cadastro_cidadao_telefone.id as cidadao_telefone_principal_id,
+                        cadastro_cidadao_telefone.numero as cidadao_telefone_principal_numero,
+                        cadastro_cidadao_telefone.principal as cidadao_telefone_principal_principal,
+                        cadastro_cidadao_telefone.observacao as cidadao_telefone_principal_observacao,
+                        cadastro_cidadao_telefone.deleted_at as cadastro_cidadao_telefone_deleted_at,
+                        cadastro_cidadao_fator_risco.fator_risco_id,
+                        cadastro_unidade.id as unidade_id,
+                        cadastro_paciente.id as paciente_id,
+                        cadastro_paciente.prontuario,
+                        cadastro_paciente.classificacao_id,
+                        cadastro_paciente.subclassificacao_id,
+                        cadastro_paciente.email,
+                        cadastro_paciente.protocolo_cross,
+                        cadastro_paciente.bloqueado,
+                        cadastro_paciente.validade_inicio as cadastro_paciente_validade_inicio,
+                        cadastro_paciente.validade_fim as cadastro_paciente_validade_fim,
+                        cadastro_sexo.id as cidadao_sexo_id,
+                        cadastro_sexo.descricao as cidadao_sexo_descricao,
+                        cadastro_sexo.codigo_esus as cidadao_sexo_identificador,
+                        cadastro_carteira_identidade.id as cidadao_carteira_identidade_id,
+                        cadastro_carteira_identidade.estado_id as cidadao_carteira_identidade_estado_id,
+                        cadastro_carteira_identidade.numero as cidadao_carteira_identidade_numero,
+                        cadastro_carteira_identidade.orgao_emissor as cidadao_carteira_identidade_orgao_emissor,
+                        cadastro_carteira_identidade.data_emissao as cidadao_carteira_identidade_data_emissao,
+                        cadastro_carteira_identidade.deleted_at as cidadao_carteira_identidade_deleted_at,
+                        cadastro_carteira_identidade.created_at as cidadao_carteira_identidade_created_at,
+                        cadastro_carteira_identidade.updated_at as cidadao_carteira_identidade_updated_at,
+                        cadastro_domicilio.id as cidadao_domicilio_id,
+                        cadastro_endereco.id as cidadao_domicilio_endereco_id,
+                        cadastro_endereco.numero as cidadao_domicilio_endereco_numero,
+                        cadastro_endereco.complemento as cidadao_domicilio_endereco_complemento,
+                        cadastro_endereco.latitude as cadastro_endereco_latitude,
+                        cadastro_endereco.longitude as cadastro_endereco_longitude,
+                        cadastro_endereco.referencia as cadastro_endereco_referencia,
+                        cadastro_endereco.loteamento_id as cadastro_endereco_loteamento_id,
+                        cadastro_zona.id as cidadao_domicilio_endereco_zona_id,
+                        cadastro_zona.descricao as cidadao_domicilio_endereco_zona_descricao,
+                        cadastro_logradouro.id as cidadao_domicilio_endereco_logradouro_id,
+                        cadastro_logradouro.nome as cidadao_domicilio_endereco_logradouro_nome,
+                        cadastro_logradouro.cep as cidadao_domicilio_endereco_logradouro_cep,
+                        cadastro_logradouro_tipo.id as cidadao_domicilio_endereco_logradouro_tipo_id,
+                        cadastro_logradouro_tipo.descricao as cidadao_domicilio_endereco_logradouro_tipo_nome,
+                        cadastro_logradouro_tipo.codigo as cidadao_domicilio_endereco_logradouro_tipo_codigo,
+                        cadastro_bairro.id as cidadao_domicilio_endereco_logradouro_bairro_id,
+                        cadastro_bairro.nome as cidadao_domicilio_endereco_logradouro_bairro_nome,
+                        intranet.cadastro_municipio.id as cidadao_domicilio_endereco_logradouro_municipio_id,
+                        intranet.cadastro_municipio.nome as cidadao_domicilio_endereco_logradouro_municipio_nome,
+                        intranet.cadastro_municipio.ibge as cidadao_domicilio_endereco_logradouro_municipio_ibge,
+                        intranet.cadastro_estado.id as cidadao_domicilio_endereco_logradouro_municipio_estado_id,
+                        intranet.cadastro_estado.codigo as cidadao_domicilio_endereco_logradouro_municipio_estado_codigo,
+                        intranet.cadastro_estado.nome as cidadao_domicilio_endereco_logradouro_municipio_estado_nome,
+                        intranet.cadastro_estado.uf as cidadao_domicilio_endereco_logradouro_municipio_estado_uf,
+                        intranet.cadastro_pais.id as cidadao_domicilio_endereco_logradouro_municipio_estado_pais_id,
+                        intranet.cadastro_pais.nome as cidadao_domicilio_endereco_logradouro_municipio_estado_pais_nome,
+                        intranet.cadastro_pais.codigo as cidadao_domicilio_endereco_logradouro_municipio_estado_pais_codigo,
+                        cadastro_titulo_eleitor.id as cadastro_titulo_eleitor_id,
+                        cadastro_titulo_eleitor.numero as cadastro_titulo_eleitor_numero,
+                        cadastro_titulo_eleitor.zona as cadastro_titulo_eleitor_zona,
+                        cadastro_titulo_eleitor.secao as cadastro_titulo_eleitor_secao,
+                        cadastro_certidao.id as cadastro_certidao_id,
+                        cadastro_certidao.tipo_id as cadastro_certidao_tipo_id,
+                        cadastro_certidao.modelo_id as cadastro_certidao_modelo_id,
+                        cadastro_certidao.numero as cadastro_certidao_numero,
+                        cadastro_certidao.cartorio_nome as cadastro_certidao_cartorio_nome,
+                        cadastro_certidao.livro as cadastro_certidao_livro,
+                        cadastro_certidao.folha as cadastro_certidao_folha,
+                        cadastro_certidao.data_emissao as cadastro_certidao_data_emissao,
+                        cadastro_certidao.municipio_id as cadastro_certidao_municipio_id,
+                        cadastro_certidao.cartorio_codigo as cadastro_certidao_cartorio_codigo,
+                        cadastro_carteira_trabalho.ID as cadastro_carteira_trabalho_id,
+                        cadastro_carteira_trabalho.numero as cadastro_carteira_trabalho_numero,
+                        cadastro_carteira_trabalho.serie as cadastro_carteira_trabalho_serie,
+                        cadastro_carteira_trabalho.data_emissao as cadastro_carteira_trabalho_data_emissao,
+                        cadastro_carteira_trabalho.estado_id as cadastro_carteira_trabalho_estado_id,
+                        cadastro_carteira_trabalho.nis_pis_pasep as cadastro_carteira_trabalho_nis_pis_pasep,
+                        cadastro_carteira_habilitacao.id as cadastro_carteira_habilitacao_id,
+                        cadastro_carteira_habilitacao.numero as cadastro_carteira_habilitacao_numero,
+                        cadastro_carteira_habilitacao.data_emissao as cadastro_carteira_habilitacao_data_emissao,
+                        cadastro_carteira_habilitacao.data_validade as cadastro_carteira_habilitacao_data_validade,
+                        cadastro_carteira_habilitacao.estado_id as cadastro_carteira_habilitacao_estado_id,
+                        cadastro_carteira_habilitacao.categoria_id as cadastro_carteira_habilitacao_categoria_id,
+                        cadastro_cidadao_alergia.alergia_id as cadastro_cidadao_alergia_alergia_id,
+                        cadastro_cidadao_alergia.criticidade_id as cadastro_cidadao_alergia_criticidade_id,
+                        cadastro_cidadao_alergia.cid_id as cadastro_cidadao_alergia_cid_id,
+                        cadastro_cidadao_alergia.reacoes_observacoes as cadastro_cidadao_alergia_reacoes_observacoes,
+                        cadastro_cidadao_medicamento_uso_continuo.medicamento_id,
+                        cadastro_cidadao_convenio_medico.convenio_medico_id
+            from        cadastro_cidadao
+            left join   cadastro_sexo
+                    on  cadastro_sexo.id = cadastro_cidadao.sexo_id
+            left join   cadastro_cidadao_telefone
+                    on  cadastro_cidadao_telefone.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_paciente
+                    on  cadastro_paciente.cidadao_id = cadastro_cidadao.id
+            left join	cadastro_paciente_informacao_social
+					on	cadastro_paciente_informacao_social.paciente_id = cadastro_paciente.id 
+            left join   cadastro_cidadao_fator_risco
+                    on  cadastro_cidadao_fator_risco.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_unidade
+                    on  cadastro_unidade.id = cadastro_paciente.unidade_id
+            left join   atencao_basica_cadastro_individual
+                    on  atencao_basica_cadastro_individual.paciente_id = cadastro_paciente.id
+            left join   cadastro_carteira_identidade
+                    on  cadastro_carteira_identidade.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_domicilio
+                    on  cadastro_domicilio.id = cadastro_cidadao.domicilio_id
+            left join   cadastro_endereco
+                    on  cadastro_endereco.id = cadastro_domicilio.endereco_id
+            left join   cadastro_zona
+                    on  cadastro_zona.id = cadastro_endereco.zona_id
+            left join   cadastro_logradouro
+                    on  cadastro_logradouro.id = cadastro_endereco.logradouro_id
+            left join   cadastro_logradouro_tipo
+                    on  cadastro_logradouro_tipo.id = cadastro_logradouro.tipo_id
+            left join	cadastro_bairro
+            		on	cadastro_bairro.id = cadastro_logradouro.bairro_id
+    		left join	intranet.cadastro_municipio
+    				on	intranet.cadastro_municipio.id = cadastro_logradouro.municipio_id
+			left join	intranet.cadastro_estado
+					on	intranet.cadastro_estado.id = intranet.cadastro_municipio.estado_id
+			left join	intranet.cadastro_pais
+					on	intranet.cadastro_pais.id = intranet.cadastro_estado.pais_id
+            left join   cadastro_titulo_eleitor
+                    on  cadastro_titulo_eleitor.cidadao_id = cadastro_cidadao.id
+                    and cadastro_titulo_eleitor.deleted_at is null
+            left join   cadastro_certidao
+                    on  cadastro_certidao.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_carteira_trabalho
+                    on  cadastro_carteira_trabalho.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_carteira_habilitacao
+                    on  cadastro_carteira_habilitacao.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_cidadao_alergia
+                    on  cadastro_cidadao_alergia.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_alergia
+                    on  cadastro_alergia.id = cadastro_cidadao_alergia.alergia_id
+            left join   cadastro_cidadao_medicamento_uso_continuo
+                    on  cadastro_cidadao_medicamento_uso_continuo.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_cidadao_convenio_medico
+                    on  cadastro_cidadao_convenio_medico.cidadao_id = cadastro_cidadao.id
+            left join   cadastro_obito
+                    on  cadastro_obito.cidadao_id = cadastro_cidadao.id
+            where       cadastro_paciente.unidade_id = {$idUnidade}
+            and         cadastro_cidadao_telefone.deleted_at is null
+            and         cadastro_paciente.deleted_at is null
+            and         cadastro_paciente_informacao_social.deleted_at is null
+            and         cadastro_unidade.deleted_at is null
+            and         cadastro_domicilio.deleted_at is null
+            and         cadastro_endereco.deleted_at is null
+            and         cadastro_logradouro.deleted_at is null
+            and         cadastro_bairro.deleted_at is null
+            and         cadastro_carteira_trabalho.deleted_at is null
+            and         cadastro_carteira_habilitacao.deleted_at is null
+            and         cadastro_cidadao.deleted_at is null
+            and         cadastro_obito.obito_em is null
+            and
+            (
+                        cadastro_paciente_informacao_social.saida_cidadao_id <> " . EnumSaidaCidadao::OBITO . "
+                    or
+                        cadastro_paciente_informacao_social.saida_cidadao_id is null
+            )
+            and
+            (
+                        atencao_basica_cadastro_individual.saida_cidadao_id <> " . EnumSaidaCidadao::OBITO . "
+                    or
+                        atencao_basica_cadastro_individual.saida_cidadao_id is null
+            )
+            and
+            (
+                        atencao_basica_cadastro_individual.equipe_id = {$idEquipe}
+                        {$condicaoForaArea}
+            )
+        "));
+
+        $limitePorRequisicao = 300;
+        $skip = $pagina === 0 ? 0 : ($pagina * $limitePorRequisicao) + 1;
+        $limit = $skip + $limitePorRequisicao;
+        $contador = 0;
+
+        $cidadaos = [];
+
+        collect($listaCidadaos)->groupBy('cidadao_id')->each(function ($grupo) use (&$contador, $skip, $limit, &$cidadaos) {
+
+            $cidadao = $grupo->first();
+
+            $contador++;
+
+            if ($contador >= $skip && $contador < $limit) {
+
+                $contatos = [];
+                $alergias = [];
+                $medicamentos = [];
+                $fatoresRisco = [];
+                $conveniosMedicos = [];
+                $carteiraIdentidade = [];
+
+                $grupo->each(function ($dadosPaciente) use (&$contatos, &$alergias, &$medicamentos, &$fatoresRisco, &$conveniosMedicos, &$carteiraIdentidade) {
+
+                    self::adicionaContato($contatos, $dadosPaciente);
+                    self::adicionaAlergia($alergias, $dadosPaciente);
+                    self::adicionaMedicamento($medicamentos, $dadosPaciente);
+                    self::adicionaFatorRisco($fatoresRisco, $dadosPaciente);
+                    self::adicionaConvenioMedico($conveniosMedicos, $dadosPaciente);
+                    self::adicionaCarteiraIdentidade($carteiraIdentidade, $dadosPaciente);
+                });
+
+                $cidadao->contatos = $contatos;
+                $cidadao->alergias = $alergias;
+                $cidadao->medicamentos = $medicamentos;
+                $cidadao->fator_risco = $fatoresRisco;
+                $cidadao->convenios = $conveniosMedicos;
+
+                self::obterUltimaCarteiraIdentidade($carteiraIdentidade, $cidadao);
+
+                unset($contatos);
+                unset($alergias);
+                unset($medicamentos);
+                unset($fatoresRisco);
+                unset($conveniosMedicos);
+                unset($carteiraIdentidade);
+
+                $cidadao->cidadao_desconhece_nome_mae = is_null($cidadao->nome_mae) ? 1 : 0;
+                $cidadao->cidadao_desconhece_nome_pai = is_null($cidadao->nome_pai) ? 1 : 0;
+                $cidadao->cpf_nao_pertence_ao_cidadao = !is_null($cidadao->motivo_duplicidade_cpf_id) ? 1 : 0;
+
+                self::obterIdadeCidadao($cidadao);
+
+                self::removeChavesAgrupadas($cidadao);
+
+                array_push($cidadaos, $cidadao);
+            }
+        })->values();
+
+        return response()->json(['cidadaos' => $cidadaos, 'stop' => sizeof($cidadaos) < $limitePorRequisicao ? 1 : 0], Response::HTTP_OK);
+    }
+
+    private static function adicionaContato(&$contatos, $dadosPaciente)
+    {
+
+        if (is_null($dadosPaciente->cadastro_cidadao_telefone_deleted_at) && !in_array($dadosPaciente->cidadao_telefone_principal_id, array_column($contatos, 'cidadao_telefone_principal_id'))) {
+
+            array_push($contatos, [
+                'cidadao_telefone_principal_id' => $dadosPaciente->cidadao_telefone_principal_id,
+                'cidadao_telefone_principal_numero' => $dadosPaciente->cidadao_telefone_principal_numero,
+                'cidadao_telefone_principal_principal' => $dadosPaciente->cidadao_telefone_principal_principal,
+                'cidadao_telefone_principal_observacao' => $dadosPaciente->cidadao_telefone_principal_observacao,
+            ]);
+        }
+    }
+
+    private static function adicionaAlergia(&$alergias, $dadosPaciente)
+    {
+
+        if (!is_null($dadosPaciente->cadastro_cidadao_alergia_alergia_id) && !in_array($dadosPaciente->cadastro_cidadao_alergia_alergia_id, array_column($alergias, 'cadastro_cidadao_alergia_alergia_id'))) {
+
+            array_push($alergias, [
+                'cadastro_cidadao_alergia_alergia_id' => $dadosPaciente->cadastro_cidadao_alergia_alergia_id,
+                'cadastro_cidadao_alergia_criticidade_id' => $dadosPaciente->cadastro_cidadao_alergia_criticidade_id,
+                'cadastro_cidadao_alergia_cid_id' => $dadosPaciente->cadastro_cidadao_alergia_cid_id,
+                'cadastro_cidadao_alergia_reacoes_observacoes' => $dadosPaciente->cadastro_cidadao_alergia_reacoes_observacoes,
+            ]);
+        }
+    }
+
+    private static function adicionaMedicamento(&$medicamentos, $dadosPaciente)
+    {
+
+        if (!is_null($dadosPaciente->medicamento_id) && !in_array($dadosPaciente->medicamento_id, $medicamentos)) {
+
+            array_push($medicamentos, $dadosPaciente->medicamento_id);
+        }
+    }
+
+    private static function adicionaFatorRisco(&$fatoresRisco, $dadosPaciente)
+    {
+
+        if (!is_null($dadosPaciente->fator_risco_id) && !in_array($dadosPaciente->fator_risco_id, $fatoresRisco)) {
+
+            array_push($fatoresRisco, $dadosPaciente->fator_risco_id);
+        }
+    }
+
+    private static function adicionaConvenioMedico(&$conveniosMedicos, $dadosPaciente)
+    {
+
+        if (!is_null($dadosPaciente->convenio_medico_id) && !in_array($dadosPaciente->convenio_medico_id, $conveniosMedicos)) {
+
+            array_push($conveniosMedicos, $dadosPaciente->convenio_medico_id);
+        }
+    }
+
+    private static function adicionaCarteiraIdentidade(&$carteiraIdentidade, $dadosPaciente)
+    {
+
+        if (is_null($dadosPaciente->cidadao_carteira_identidade_deleted_at) && !is_null($dadosPaciente->cidadao_carteira_identidade_id)) {
+
+            array_push($carteiraIdentidade, [
+                'cidadao_carteira_identidade_id' => $dadosPaciente->cidadao_carteira_identidade_id,
+                'cidadao_carteira_identidade_estado_id' => $dadosPaciente->cidadao_carteira_identidade_estado_id,
+                'cidadao_carteira_identidade_numero' => $dadosPaciente->cidadao_carteira_identidade_numero,
+                'cidadao_carteira_identidade_orgao_emissor' => $dadosPaciente->cidadao_carteira_identidade_orgao_emissor,
+                'cidadao_carteira_identidade_data_emissao' => $dadosPaciente->cidadao_carteira_identidade_data_emissao,
+                'cidadao_carteira_identidade_created_at' => $dadosPaciente->cidadao_carteira_identidade_created_at,
+                'cidadao_carteira_identidade_updated_at' => $dadosPaciente->cidadao_carteira_identidade_updated_at,
+            ]);
+        }
+    }
+
+    private static function obterUltimaCarteiraIdentidade($carteiraIdentidade, &$cidadao)
+    {
+
+        if (sizeof($carteiraIdentidade) > 0) {
+
+            array_multisort(array_column($carteiraIdentidade, 'cidadao_carteira_identidade_updated_at'), SORT_DESC, $carteiraIdentidade);
+
+            $carteiraIdentidade = collect($carteiraIdentidade)->first();
+
+            $cidadao->cidadao_carteira_identidade_id = $carteiraIdentidade['cidadao_carteira_identidade_id'] ?? null;
+            $cidadao->cidadao_carteira_identidade_estado_id = $carteiraIdentidade['cidadao_carteira_identidade_estado_id'] ?? null;
+            $cidadao->cidadao_carteira_identidade_numero = $carteiraIdentidade['cidadao_carteira_identidade_numero'] ?? null;
+            $cidadao->cidadao_carteira_identidade_orgao_emissor = $carteiraIdentidade['cidadao_carteira_identidade_orgao_emissor'] ?? null;
+            $cidadao->cidadao_carteira_identidade_data_emissao = $carteiraIdentidade['cidadao_carteira_identidade_data_emissao'] ?? null;
+            $cidadao->cidadao_carteira_identidade_created_at = $carteiraIdentidade['cidadao_carteira_identidade_created_at'] ?? null;
+            $cidadao->cidadao_carteira_identidade_updated_at = $carteiraIdentidade['cidadao_carteira_identidade_updated_at'] ?? null;
+        }
+    }
+
+    private static function obterIdadeCidadao(&$cidadao)
+    {
+
+        if (!is_null($cidadao->data_nascimento)) {
+
+            $dataNascimento = new DateTime($cidadao->data_nascimento);
+
+            $age = AgeService::getAge($dataNascimento);
+        }
+
+        $cidadao->cidadao_idade_anos = isset($age) ? $age->years : null;
+        $cidadao->cidadao_idade_meses = isset($age) ? $age->months : null;
+        $cidadao->cidadao_idade_dias = isset($age) ? $age->days : null;
+    }
+
+    private static function removeChavesAgrupadas(&$cidadao)
+    {
+
+        unset($cidadao->cidadao_telefone_principal_id);
+        unset($cidadao->cidadao_telefone_principal_numero);
+        unset($cidadao->cidadao_telefone_principal_principal);
+        unset($cidadao->cidadao_telefone_principal_observacao);
+        unset($cidadao->cadastro_cidadao_alergia_alergia_id);
+        unset($cidadao->cadastro_cidadao_alergia_criticidade_id);
+        unset($cidadao->cadastro_cidadao_alergia_cid_id);
+        unset($cidadao->cadastro_cidadao_alergia_reacoes_observacoes);
+        unset($cidadao->medicamento_id);
+        unset($cidadao->fator_risco_id);
+        unset($cidadao->convenio_medico_id);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/ConvenioMedicoController.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\SujeitoAtencao\ConvenioMedico;
+use Illuminate\Http\Response;
+
+class ConvenioMedicoController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'convenio-medico';
+
+    public function index()
+    {
+
+        return response()->json(ConvenioMedico::all(['id', 'nome']), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/EtniaIndigenaController.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Response;
+use App\Models\Cadastro\SujeitoAtencao\EtniaIndigena;
+
+class EtniaIndigenaController extends Controller
+{
+
+    public function index()
+    {
+
+        return response()->json($this->get(EtniaIndigena::class)->get(), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/LogradouroController.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\Localizacao\Logradouro;
+use App\Models\Cadastro\Localizacao\LogradouroTipo;
+use Illuminate\Http\Response;
+
+class LogradouroController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'logradouro';
+
+    public function index()
+    {
+
+        $logradouros = Logradouro::all()->map(function ($logradouro) {
+
+            return [
+                "id" => $logradouro->id,
+                "nome" => $logradouro->nome,
+                "cep" => $logradouro->cep,
+                "tipo_nome" => $logradouro->tipo_nome,
+                "tipo_id" => $logradouro->tipo->id,
+                "tipo_descricao" => $logradouro->tipo->descricao,
+                "tipo_codigo" => $logradouro->tipo->codigo,
+                "bairro_id" => $logradouro->bairro->id,
+                "bairro_nome" => $logradouro->bairro->nome,
+                "municipio_id" => $logradouro->municipio->id,
+                "municipio_nome" => $logradouro->municipio->nome,
+                "municipio_ibge" => $logradouro->municipio->ibge,
+                "municipio_estado_id" => $logradouro->municipio->estado->id,
+                "municipio_estado_codigo" => $logradouro->municipio->estado->codigo,
+                "municipio_estado_nome" => $logradouro->municipio->estado->nome,
+                "municipio_estado_uf" => $logradouro->municipio->estado->uf,
+                "municipio_estado_pais_id" => $logradouro->municipio->estado->pais->id,
+                "municipio_estado_pais_nome" => $logradouro->municipio->estado->pais->nome,
+                "municipio_estado_pais_codigo" => $logradouro->municipio->estado->pais->codigo,
+                "municipio_estado_pais_codigo_esus" => $logradouro->municipio->estado->pais->codigo_esus
+            ];
+        });
+
+        return response()->json($logradouros, Response::HTTP_OK);
+    }
+
+    public function obterTipoLogradouro()
+    {
+
+        $camposTipoLogradouro = ['id', 'descricao'];
+
+        $tiposLogradouros = LogradouroTipo::orderBy('descricao')
+            ->select($camposTipoLogradouro)
+            ->get();
+
+        return response()->json($tiposLogradouros, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/LoteamentoController.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\Localizacao\Loteamento;
+use Illuminate\Http\Response;
+
+class LoteamentoController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'loteamento';
+
+    public function index()
+    {
+
+        $loteamentos = $this->get(Loteamento::class)->orderBy('nome')->get();
+
+        return response()->json($loteamentos, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/MedicamentoController.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\Medicamento\Medicamento;
+use Illuminate\Http\Response;
+
+class MedicamentoController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'medicamento';
+
+    public function index()
+    {
+
+        $medicamentos = $this->get(Medicamento::class)->orderBy('nome')->get();
+
+        return response()->json($medicamentos, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/UnidadeController.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\Estabelecimento\Unidade;
+use Illuminate\Http\Response;
+
+class UnidadeController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'unidade';
+
+    public function index()
+    {
+
+        $where = $this->getWhereFromQueryString([
+            'cnpj',
+            'nome_fantasia',
+            'cnes',
+            'unidade_referencia',
+            ['not_id', '<>']
+        ]);
+
+        $unidades = $this->get(Unidade::class)->where($where)->orderBy('nome_fantasia')->get()->map(function ($unidade) {
+
+            return [
+                'id' => $unidade->id,
+                'nome_fantasia' => $unidade->nome_fantasia,
+                'razao_social' => $unidade->razao_social,
+                'cnpj' => $unidade->cnpj,
+                'email' => $unidade->email,
+                'tipo_id' => $unidade->tipo_id,
+                'cnes' => $unidade->cnes
+            ];
+        });
+
+        return response()->json($unidades, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Cadastro/UsuarioController.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Cadastro;
+
+use App\Http\Controllers\Controller;
+use App\Models\Cadastro\SujeitoAtencao\Usuario;
+use Illuminate\Http\Response;
+
+class UsuarioController extends Controller
+{
+    protected $modulo = 'cadastro';
+    protected $funcionalidade = 'usuario';
+
+    public function index()
+    {
+
+        $usuarios = Usuario::with(['atencaoBasicaEquipes'])
+            ->get()
+            ->map(function($usuario) {
+
+                $usuario = $usuario->toArray();
+
+                return [
+                    'id' => $usuario['id'],
+                    'usuario' => $usuario['usuario'],
+                    'email' => $usuario['email'],
+                    'registro_numero' => $usuario['registro_numero'],
+                    'registro_estado_id' => $usuario['registro_estado_id'],
+                    'bloqueado' => $usuario['bloqueado'],
+                    'usuario_cidadao_nome' => $usuario['cidadao']['nome'],
+                    'usuario_cidadao_cpf' => $usuario['cidadao']['cpf'],
+                    'usuario_cidadao_cns' => $usuario['cidadao']['cns'],
+                    'atencao_basica_equipes' => $usuario['atencao_basica_equipes'],
+                ];
+            });
+
+        return response()->json($usuarios, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Geral/CiapController.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Geral;
+
+use App\Http\Controllers\Controller;
+use App\Services\Geral\CiapService;
+use Illuminate\Http\Response;
+
+class CiapController extends Controller
+{
+
+    public function index()
+    {
+
+        return response()->json(CiapService::index()->toArray(), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Intranet/MunicipioController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Intranet;
+
+use App\Http\Controllers\Controller;
+use App\Models\Intranet\Municipio;
+use Illuminate\Http\Response;
+
+class MunicipioController extends Controller
+{
+    public function index()
+    {
+
+        $municipios = $this->get(Municipio::class)
+            ->orderBy('nome')
+            ->get()
+            ->map(function ($municipo) {
+
+                return [
+                    'id' => $municipo->id,
+                    'nome' => $municipo->nome,
+                    'ibge' => $municipo->ibge,
+                    'estado_id' => $municipo->estado->id,
+                    'estado_codigo' => $municipo->estado->codigo,
+                    'estado_nome' => $municipo->estado->nome,
+                    'estado_uf' => $municipo->estado->uf,
+                ];
+            });
+
+        return response()->json($municipios, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Sigtap/CidController.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Sigtap;
+
+use App\Http\Controllers\Controller;
+use App\Services\Sigtap\CidService;
+use Illuminate\Http\Response;
+
+class CidController extends Controller
+{
+
+    public function index()
+    {
+
+        return response()->json(CidService::index()->toArray(), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Sigtap/OcupacaoController.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Sigtap;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Response;
+use App\Models\Sigtap\Ocupacao;
+
+class OcupacaoController extends Controller
+{
+
+    public function index()
+    {
+
+        return response()->json(Ocupacao::all()->toArray(), Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Sigtap/ProcedimentoController.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Sigtap;
+
+use App\Http\Controllers\Controller;
+use App\Models\Sigtap\Procedimento;
+use App\Models\Sigtap\Competencia;
+use Illuminate\Http\Response;
+
+class ProcedimentoController extends Controller
+{
+    public function index()
+    {
+
+        $listaCamposProcedimentos = [
+            'id',
+            'competencia_id',
+            'codigo',
+            'nome',
+            'complexidade',
+            'sexo',
+            'idade_minima',
+            'idade_maxima'
+        ];
+
+        $ultimaCompetencia = Competencia::orderBy('valor', 'desc')->first(['id']);
+
+        $procedimentos = Procedimento::where('competencia_id', $ultimaCompetencia->id)
+            ->select($listaCamposProcedimentos)
+            ->get()
+            ->toArray();
+
+        return response()->json($procedimentos, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Sigtap/ProcedimentoOcupacaoController.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Sigtap;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Response;
+use Illuminate\Support\Facades\DB;
+
+class ProcedimentoOcupacaoController extends Controller
+{
+    public function index($ocupacaoId)
+    {
+
+        $competencias = DB::table('sigtap.competencia')
+            ->select('id')
+            ->orderByDesc('valor')
+            ->take(4)
+            ->pluck('id')
+            ->toArray();
+
+        $procedimentoOcupacao = DB::table('sigtap.procedimento_ocupacao')
+            ->whereIn('competencia_id', $competencias)
+            ->where('ocupacao_id', $ocupacaoId)
+            ->get()
+            ->pluck('procedimento_id');
+
+        return response()->json($procedimentoOcupacao, Response::HTTP_OK);
+    }
+}

api/app/Http/Controllers/Mobile/ConectaSusAb/Sincronizacao/SincronizacaoController.php

@@ -0,0 +1,281 @@
+<?php
+
+namespace App\Http\Controllers\Mobile\ConectaSusAb\Sincronizacao;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Cadastro\SujeitoAtencao\PacienteController;
+use App\Services\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualService;
+use App\Services\AtencaoBasica\VisitaDomiciliar\VisitaDomiciliarService;
+use App\Services\AtencaoBasica\Avaliacao\AvaliacaoService;
+use App\Services\AtencaoBasica\FichaComplementar\FichaComplementarService;
+use App\Services\AtencaoBasica\Procedimento\ProcedimentoService;
+use App\Services\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentarService;
+use App\Services\AtencaoBasica\AtendimentoDomiciliar\AtendimentoDomiciliarService;
+use Illuminate\Http\Response;
+
+class SincronizacaoController extends Controller
+{
+
+    public function sincronizacao()
+    {
+
+        $response = [
+            'cadastro_paciente' => 0,
+            'atendimento_individual' => 0,
+            'visita_domiciliar' => 0,
+            'avaliacao_elegibilidade' => 0,
+            'ficha_complementar' => 0,
+            'procedimentos' => 0,
+            'marcadores_consumo' => 0,
+            'atendimento_domiciliar' => 0,
+        ];
+
+        $identificacoes = [];
+
+        $fichas = request()->all();
+
+        self::adicionarLogSincronizacao($fichas);
+
+        if (isset($fichas['cadastro_paciente'])) {
+
+            self::sincronizarCadastroPaciente($fichas['cadastro_paciente'], $identificacoes, $response);
+        }
+
+        if (isset($fichas['atendimento_individual'])) {
+
+            self::sincronizarAtendimentoIndividual($fichas['atendimento_individual'], $identificacoes, $response);
+        }
+
+        if (isset($fichas['visita_domiciliar'])) {
+
+            self::sincronizarVisitaDomiciliar($fichas['visita_domiciliar'], $identificacoes, $response);
+        }
+
+        if (isset($fichas['avaliacao_elegibilidade'])) {
+
+            self::sincronizarAvaliacaoElegibilidade($fichas['avaliacao_elegibilidade'], $identificacoes, $response);
+        }
+
+        if (isset($fichas['ficha_complementar'])) {
+
+            self::sincronizarFichaComplementar($fichas['ficha_complementar'], $identificacoes, $response);
+        }
+
+        if (isset($fichas['procedimentos'])) {
+
+            self::sincronizarProcedimentos($fichas['procedimentos'], $identificacoes, $response);
+        }
+
+        if (isset($fichas['marcadores_consumo'])) {
+
+            self::sincronizarMarcadorConsumoAlimentar($fichas['marcadores_consumo'], $identificacoes, $response);
+        }
+
+        if (isset($fichas['atendimento_domiciliar'])) {
+
+            self::sincronizarAtendimentoDomiciliar($fichas['atendimento_domiciliar'], $identificacoes, $response);
+        }
+
+        return response()->json($response, Response::HTTP_OK);
+    }
+
+    private static function sincronizarCadastroPaciente($fichas, &$identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as &$ficha) {
+
+                $paciente = new PacienteController();
+
+                $fichaPaciente = $paciente->getPaciente($ficha['paciente_id'] ?? null);
+
+                if (is_null($fichaPaciente)) {
+
+                    $pacienteIdPorCpf = $paciente->obterFichaPacientePorCpf($ficha['cidadao']['cpf']);
+
+                    $fichaPaciente = $paciente->getPaciente($pacienteIdPorCpf ?? null);
+                }
+
+                $idPaciente = $paciente->saveStore($ficha, $fichaPaciente);
+
+                if (is_numeric($idPaciente) && $idPaciente > 0 && isset($ficha['ID_TMP']) && $ficha['ID_TMP'] > 0 && is_null($ficha['cidadao']['id'])) {
+
+                    $identificacoes['paciente'][$ficha['ID_TMP']] = $idPaciente;
+                }
+
+                $response['cadastro_paciente'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarCadastroDomiciliar($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as &$ficha) {
+
+                CadastroDomiciliarService::saveStore($ficha);
+
+                $response['cadastro_domiciliar'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarCadastroIndividual($fichas, &$identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                CadastroIndividualService::saveStore($ficha);
+
+                $response['cadastro_individual'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarAtendimentoIndividual($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                $ficha['paciente_id'] = self::obterIdentificacaoPaciente($identificacoes, $ficha['paciente_id'], $ficha['PACIENTE_ID_TMP']);
+
+                AtendimentoIndividualService::saveStore($ficha);
+
+                $response['atendimento_individual'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarVisitaDomiciliar($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                $ficha['paciente_id'] = self::obterIdentificacaoPaciente($identificacoes, $ficha['paciente_id'], $ficha['PACIENTE_ID_TMP']);
+
+                VisitaDomiciliarService::saveStore($ficha, true);
+
+                $response['visita_domiciliar'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarAvaliacaoElegibilidade($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                $ficha['paciente_id'] = self::obterIdentificacaoPaciente($identificacoes, $ficha['paciente_id'], $ficha['PACIENTE_ID_TMP']);
+
+                AvaliacaoService::saveStore($ficha);
+
+                $response['avaliacao_elegibilidade'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarFichaComplementar($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                $ficha['paciente'] = self::obterIdentificacaoPaciente($identificacoes, $ficha['paciente'], $ficha['PACIENTE_ID_TMP']);
+
+                FichaComplementarService::saveStore($ficha);
+
+                $response['ficha_complementar'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarProcedimentos($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                foreach ($ficha['atendimentos'] as $atendimento) {
+
+                    $atendimento['paciente_id'] = self::obterIdentificacaoPaciente($identificacoes, $atendimento['paciente_id'], $atendimento['PACIENTE_ID_TMP']);
+                }
+
+                ProcedimentoService::saveStore($ficha);
+
+                $response['procedimentos'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarMarcadorConsumoAlimentar($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                $ficha['paciente_id'] = self::obterIdentificacaoPaciente($identificacoes, $ficha['paciente_id'], $ficha['PACIENTE_ID_TMP']);
+
+                MarcadorConsumoAlimentarService::saveStore($ficha);
+
+                $response['marcadores_consumo'] += 1;
+            }
+        }
+    }
+
+    private static function sincronizarAtendimentoDomiciliar($fichas, $identificacoes, &$response)
+    {
+
+        if (is_array($fichas) && sizeof($fichas) > 0) {
+
+            foreach ($fichas as $ficha) {
+
+                foreach ($ficha['atendimentos'] as $atendimento) {
+
+                    $ficha['paciente_id'] = self::obterIdentificacaoPaciente($identificacoes, $atendimento['paciente_id'], $atendimento['PACIENTE_ID_TMP']);
+                }
+
+                AtendimentoDomiciliarService::saveStore($ficha);
+
+                $response['atendimento_domiciliar'] += 1;
+            }
+        }
+    }
+
+    private static function obterIdentificacaoPaciente($identificacoes, $idPaciente, $identificacaoTemporaria)
+    {
+
+        if ($idPaciente > 0) {
+
+            return $idPaciente;
+        }
+
+        if (isset($identificacoes['paciente'][$identificacaoTemporaria]) && $identificacoes['paciente'][$identificacaoTemporaria] > 0) {
+
+            return $identificacoes['paciente'][$identificacaoTemporaria];
+        }
+    }
+
+    private static function adicionarLogSincronizacao($fichas)
+    {
+
+        $cliente = request()->header('customer');
+        $dataHora = \Carbon\Carbon::now()->format('YmdHi');
+        $caminho = "{$cliente}/{$dataHora}.json";
+
+        \Storage::disk('mobile')->put($caminho, json_encode($fichas));
+    }
+}