first commit
This commit is contained in:
Claudecio Martins
651
app/Module/Tutor/v0/Models/PetModel.php
Executable file
651
app/Module/Tutor/v0/Models/PetModel.php
Executable file
@@ -0,0 +1,651 @@
|
||||
<?php
|
||||
namespace Zampet\Module\Tutor\v0\Models;
|
||||
|
||||
use Exception;
|
||||
use Zampet\Services\DB;
|
||||
use Zampet\Module\Tutor\v0\DTO\PetDTO;
|
||||
use Zampet\Module\Tutor\v0\DTO\PetRacaDTO;
|
||||
use Zampet\Module\Auth\v0\Models\UsuarioModel;
|
||||
|
||||
class PetModel {
|
||||
protected string $petTable = 'pet';
|
||||
protected string $usuarioPet = 'usuario_pet';
|
||||
protected string $petAuxRacaTable = 'pet_aux_raca';
|
||||
protected string $petAuxEspecieTable = 'pet_aux_especie';
|
||||
|
||||
/**
|
||||
* Lista todos os pets associados a um tutor, buscando o tutor por um identificador flexível.
|
||||
*
|
||||
* Este método busca primeiro o registro do tutor usando um identificador (UUID, ID, e-mail, etc.) e, em seguida, usa o ID interno do tutor para consultar todos os pets a ele associados.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Busca do Tutor:** Utiliza `UsuarioModel::getUsuarioByIdentifier` para buscar os dados do tutor. Se o tutor não for encontrado, lança uma `Exception` com o código 404.
|
||||
* 2. **Consulta dos Pets:** Executa uma consulta `SELECT` que une as tabelas de associação (`up`), pets (`p`), raças (`par`) e espécies (`pae`) para obter uma lista detalhada de todos os pets vinculados ao `usuario_id` do tutor.
|
||||
* 3. **Verificação de Pets:**
|
||||
* * Se a consulta não retornar pets (`empty($petsUsuario)`), retorna um array com `status` 'fail' e uma mensagem informativa.
|
||||
* * Se pets forem encontrados, retorna um array com `status` 'success', código `200 OK` e os dados dos pets na chave `output`.
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` lançada durante o processo (como tutor não encontrado ou erro de consulta) é capturada.
|
||||
* - Retorna um array com `status` 'error', o código de resposta HTTP da exceção e uma mensagem descritiva.
|
||||
*
|
||||
* @param string $identifier A coluna da tabela de usuário a ser usada para identificar o tutor (ex: 'uuid', 'id').
|
||||
* @param mixed $value O valor correspondente ao identificador do tutor.
|
||||
* @return array Um array associativo contendo o status da operação, o código HTTP e os dados dos pets (`output['data']`), ou uma mensagem de erro.
|
||||
*/
|
||||
public function listPetsByTutorIdentifier(string $identifier, mixed $value): array {
|
||||
try {
|
||||
$usuarioData = (new UsuarioModel())->getUsuarioByIdentifier(identifier: $identifier, value: $value);
|
||||
if(!$usuarioData) {
|
||||
throw new Exception(message: 'Tutor not found', code: 404);
|
||||
}
|
||||
$usuarioData = $usuarioData['output']['data'];
|
||||
|
||||
$sql =
|
||||
"SELECT
|
||||
p.id,
|
||||
p.uuid,
|
||||
p.nome,
|
||||
p.especie_id,
|
||||
pae.descricao AS especie,
|
||||
p.raca_id,
|
||||
par.descricao AS raca,
|
||||
p.caminho_foto,
|
||||
p.registro_geral_animal,
|
||||
p.photo_path,
|
||||
p.data_nascimento,
|
||||
p.data_obito,
|
||||
p.sexo,
|
||||
p.created_at,
|
||||
p.updated_at,
|
||||
p.deleted_at
|
||||
FROM {$this->usuarioPet} up
|
||||
LEFT JOIN {$this->petTable} p ON up.pet_id = p.id
|
||||
LEFT JOIN {$this->petAuxRacaTable} par ON p.raca_id = par.id
|
||||
LEFT JOIN {$this->petAuxEspecieTable} pae ON p.especie_id = pae.id
|
||||
WHERE up.usuario_id = :usuario_id";
|
||||
|
||||
$params = [
|
||||
':usuario_id' => $usuarioData['id'],
|
||||
];
|
||||
|
||||
$petsUsuario = DB::fetchAll(sql: $sql, params: $params);
|
||||
if(empty($petsUsuario)) {
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Você não possui pets cadastrados.',
|
||||
'output' => [
|
||||
'data' => []
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Pets encontrados com sucesso.',
|
||||
'output' => [
|
||||
'data' => $petsUsuario
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Lista todas as espécies de pets disponíveis no sistema auxiliar.
|
||||
*
|
||||
* Este método consulta a tabela de espécies (`{$this->petAuxEspecieTable}`) e retorna uma lista de todos os registros (ID e descrição).
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Execução da Consulta:** Executa uma consulta `SELECT` para buscar todos os IDs e descrições da tabela auxiliar de espécies.
|
||||
* 2. **Verificação de Resultados:**
|
||||
* - Se a consulta for bem-sucedida, mas **não retornar nenhuma espécie** (`empty($stmt)`), retorna um array com `status` 'fail' e código `200 OK`.
|
||||
* - Se a consulta for bem-sucedida e **retornar espécies**, retorna um array com `status` 'success', código `200 OK` e os dados encontrados na chave `output`.
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante a consulta retorna um array com `status` 'error', o código de erro da exceção e uma mensagem detalhada de erro.
|
||||
*
|
||||
* @return array Um array associativo contendo o status da operação, o código de resposta HTTP e os dados das espécies (`output['data']`).
|
||||
*/
|
||||
public function getAllEspecies(): array {
|
||||
try {
|
||||
$sql =
|
||||
"SELECT
|
||||
id,
|
||||
uuid,
|
||||
descricao
|
||||
FROM {$this->petAuxEspecieTable}";
|
||||
|
||||
$result = DB::fetchAll(sql: $sql);
|
||||
if(empty($result)) {
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Nenhuma espécie encontrada.',
|
||||
'output' => [
|
||||
'data' => []
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
$preparedResult = [];
|
||||
foreach($result as $key => $especie) {
|
||||
$sql =
|
||||
"SELECT
|
||||
uuid,
|
||||
descricao
|
||||
FROM {$this->petAuxRacaTable}
|
||||
WHERE especie_id = :especie_id";
|
||||
|
||||
$params = [
|
||||
':especie_id' => $especie['id']
|
||||
];
|
||||
|
||||
$result = DB::fetchAll(sql: $sql, params: $params);
|
||||
|
||||
$preparedResult[] = [
|
||||
'uuid' => $especie['uuid'],
|
||||
'descricao' => $especie['descricao'],
|
||||
'racas' => $result
|
||||
];
|
||||
}
|
||||
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Espécies encontradas com sucesso.',
|
||||
'output' => [
|
||||
'data' => $preparedResult
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Busca uma única espécie de pet no banco de dados por um identificador específico.
|
||||
*
|
||||
* Este método recupera os dados de uma espécie da tabela auxiliar `{$this->petAuxEspecieTable}` de forma flexível, permitindo a busca por qualquer coluna (como 'id' ou 'uuid') e o valor correspondente.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Execução da Consulta:** O método monta e executa uma consulta `SELECT` que usa o `$identifier` de forma dinâmica na cláusula `WHERE` e um parâmetro nomeado seguro (`:value`) para o valor. A consulta utiliza `DB::fetchOne`, indicando que apenas um registro é esperado.
|
||||
* 2. **Verificação de Resultados:**
|
||||
* - Se a consulta for bem-sucedida e **nenhuma espécie for encontrada** (`empty($result)`), retorna um array com **`status` 'fail'** e código **200 OK**.
|
||||
* - Se uma espécie for encontrada, retorna um array com **`status` 'success'**, código **200 OK** e os dados do registro na chave `output`.
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante a consulta retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem de erro detalhada.
|
||||
*
|
||||
* @param string $identifier A coluna da tabela a ser usada como critério de busca (ex: 'id', 'uuid', 'descricao').
|
||||
* @param mixed $value O valor correspondente ao identificador que está sendo buscado.
|
||||
* @return array Um array associativo contendo o status da operação, um código de resposta HTTP e os dados da espécie, se encontrada.
|
||||
*/
|
||||
public function getEspecieByIdentifier(string $identifier, mixed $value): array {
|
||||
try {
|
||||
$sql =
|
||||
"SELECT
|
||||
id,
|
||||
uuid,
|
||||
descricao
|
||||
FROM {$this->petAuxEspecieTable}
|
||||
WHERE {$identifier} = :value
|
||||
ORDER BY descricao ASC";
|
||||
|
||||
$params = [
|
||||
':value' => $value
|
||||
];
|
||||
|
||||
$result = DB::fetchOne(sql: $sql, params: $params);
|
||||
if(empty($result)) {
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Espécie não encontrada.',
|
||||
'output' => [
|
||||
'data' => []
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Espécie encontrada com sucesso.',
|
||||
'output' => [
|
||||
'data' => $result
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Busca uma única raça de pet no banco de dados por um identificador específico.
|
||||
*
|
||||
* Este método recupera os dados de uma raça da tabela auxiliar `{$this->petAuxRacaTable}` de forma flexível, permitindo a busca por qualquer coluna como identificador (`$identifier`) e o valor correspondente. A consulta retorna apenas um registro e é ordenada pela descrição.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Execução da Consulta:** O método monta e executa uma consulta `SELECT` que usa o `$identifier` de forma dinâmica na cláusula `WHERE` e um parâmetro nomeado seguro (`:value`) para o valor.
|
||||
* 2. **Verificação de Resultados:**
|
||||
* - Se uma raça for encontrada, retorna um array com **`status` 'success'**, código **200 OK** e os dados da raça na chave `output`.
|
||||
* - Se a consulta for bem-sucedida, mas **nenhuma raça for encontrada** (`empty($result)`), retorna um array com **`status` 'success'** (indicando que a consulta foi bem-sucedida) e uma mensagem de "Raça não encontrada.".
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante a consulta retorna um array com **`status` 'error'**, o código de erro da exceção (ou `500` como fallback) e uma mensagem de erro detalhada.
|
||||
*
|
||||
* @param string $identifier A coluna da tabela a ser usada como critério de busca (ex: 'uuid', 'id', 'descricao').
|
||||
* @param mixed $value O valor correspondente ao identificador que está sendo buscado.
|
||||
* @return array Um array associativo contendo o status da operação, um código de resposta HTTP e os dados da raça, se encontrada.
|
||||
*/
|
||||
public function getRacaByIdentifier(string $identifier, mixed $value): array {
|
||||
try {
|
||||
$sql =
|
||||
"SELECT
|
||||
id,
|
||||
uuid,
|
||||
especie_id,
|
||||
descricao
|
||||
FROM {$this->petAuxRacaTable}
|
||||
WHERE {$identifier} = :value
|
||||
ORDER BY descricao ASC";
|
||||
|
||||
$params = [
|
||||
':value' => $value
|
||||
];
|
||||
|
||||
$result = DB::fetchOne(sql: $sql, params: $params);
|
||||
if(empty($result)) {
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Raça não encontrada.',
|
||||
'output' => [
|
||||
'data' => []
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Raça encontrada com sucesso.',
|
||||
'output' => [
|
||||
'data' => $result
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Busca todas as raças de pets associadas a uma espécie específica.
|
||||
*
|
||||
* Este método primeiro consulta a espécie usando um identificador (UUID, ID, etc.) e, em seguida, usa o ID interno da espécie para listar todas as raças vinculadas a ela na tabela auxiliar `{$this->petAuxRacaTable}`.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Busca da Espécie:** O método chama `getEspecieByIdentifier` para encontrar o ID da espécie. Se a busca falhar, o resultado de erro é retornado imediatamente.
|
||||
* 2. **Consulta das Raças:** Executa uma consulta `SELECT` que busca todas as raças onde `especie_id` corresponde ao ID da espécie encontrado. Os resultados são ordenados alfabeticamente pela descrição.
|
||||
* 3. **Verificação de Resultados:**
|
||||
* - Se a consulta for bem-sucedida, mas **nenhuma raça for encontrada**, retorna um array com **`status` 'fail'** e código **200 OK**.
|
||||
* - Se raças forem encontradas, retorna um array com **`status` 'success'**, código **200 OK** e os dados encontrados na chave `output`.
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante o processo (além daquelas tratadas na busca inicial) retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem de erro detalhada.
|
||||
*
|
||||
* @param string $identifier A coluna da tabela auxiliar de espécies a ser usada para identificar a espécie (ex: 'uuid', 'id').
|
||||
* @param mixed $value O valor correspondente ao identificador da espécie.
|
||||
* @return array Um array associativo contendo o status da operação, o código de resposta HTTP e os dados das raças (`output['data']`).
|
||||
*/
|
||||
public function getRacasByEspecieIdentifier(string $identifier, mixed $value): array {
|
||||
try {
|
||||
$especieData = $this->getEspecieByIdentifier(identifier: $identifier, value: $value);
|
||||
if($especieData['status'] !== 'success') {
|
||||
return $especieData;
|
||||
}
|
||||
$especieData = $especieData['output']['data'];
|
||||
|
||||
$sql =
|
||||
"SELECT
|
||||
id,
|
||||
uuid,
|
||||
descricao
|
||||
FROM {$this->petAuxRacaTable}
|
||||
WHERE especie_id = :especie_id
|
||||
ORDER BY descricao ASC";
|
||||
|
||||
$params = [
|
||||
':especie_id' => $especieData['id']
|
||||
];
|
||||
|
||||
$racas = DB::fetchAll(sql: $sql, params: $params);
|
||||
if(empty($racas)) {
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Nenhuma raça encontrada para a espécie informada.',
|
||||
'output' => [
|
||||
'data' => []
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Raças encontradas com sucesso.',
|
||||
'output' => [
|
||||
'data' => $racas
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Armazena uma nova raça de pet no banco de dados.
|
||||
*
|
||||
* Este método insere os dados de uma nova raça na tabela auxiliar `{$this->petAuxRacaTable}`. A raça é associada a uma espécie existente. A operação utiliza um bloco `try-catch` para garantir o tratamento de erros.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Execução da Query:** Prepara e executa a instrução `INSERT` para inserir o novo registro com o UUID, ID da espécie e a descrição.
|
||||
* 2. **Confirmação e Retorno de Sucesso:** Se a inserção for bem-sucedida, retorna um array com **`status` 'success'**, código **201 Created** e uma mensagem de êxito.
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem detalhada de erro.
|
||||
*
|
||||
* @param PetRacaDTO $petRacaDTO O objeto DTO contendo o UUID, o ID da espécie (`especie_id`) e a descrição da raça a ser criada.
|
||||
* @return array Um array associativo contendo o status da operação, o código de resposta HTTP e uma mensagem.
|
||||
*/
|
||||
public function storeRaca(PetRacaDTO $petRacaDTO): array {
|
||||
try {
|
||||
$sql =
|
||||
"INSERT INTO {$this->petAuxRacaTable} (
|
||||
uuid,
|
||||
especie_id,
|
||||
descricao
|
||||
) VALUES (
|
||||
:uuid,
|
||||
:especie_id,
|
||||
:descricao
|
||||
)";
|
||||
|
||||
$params = [
|
||||
':uuid' => $petRacaDTO->getUuid(),
|
||||
':especie_id' => $petRacaDTO->getEspecieId(),
|
||||
':descricao' => $petRacaDTO->getDescricao()
|
||||
];
|
||||
|
||||
DB::execute(sql: $sql, params: $params);
|
||||
|
||||
return [
|
||||
'response_code' => 201,
|
||||
'status' => 'success',
|
||||
'message' => 'Raça armazenada com sucesso.',
|
||||
'output' => [
|
||||
'data' => [
|
||||
'id' => DB::lastInsertId(),
|
||||
'uuid' => $petRacaDTO->getUuid(),
|
||||
'especie_id' => $petRacaDTO->getEspecieId(),
|
||||
'descricao' => $petRacaDTO->getDescricao()
|
||||
]
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Armazena um novo pet no banco de dados.
|
||||
*
|
||||
* Este método insere os dados de um novo pet na tabela `{$this->petTable}`, utilizando um objeto `PetDTO` que encapsula todas as informações relevantes. A operação é atômica e utiliza um bloco `try-catch` para garantir o tratamento de erros.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Execução da Query:** Prepara e executa a instrução `INSERT` para inserir o novo registro com todos os detalhes do pet (UUID, nome, espécie, raça, dados de saúde, foto, etc.).
|
||||
* 2. **Confirmação e Retorno de Sucesso:** Se a inserção for bem-sucedida, retorna um array com **`status` 'success'**, código **201 Created** e uma mensagem de êxito. Os dados do pet recém-criado, incluindo o ID gerado pelo banco, são retornados na chave `output`.
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem detalhada de erro.
|
||||
*
|
||||
* @param PetDTO $petDTO O objeto DTO contendo os dados do pet a ser criado.
|
||||
* @return array Um array associativo contendo o status da operação, o código de resposta HTTP e os dados do pet, se a operação for bem-sucedida.
|
||||
*/
|
||||
public function storePet(PetDTO $petDTO): array {
|
||||
try {
|
||||
$sql =
|
||||
"INSERT INTO {$this->petTable} (
|
||||
uuid,
|
||||
nome,
|
||||
especie_id,
|
||||
raca_id,
|
||||
caminho_foto,
|
||||
registro_geral_animal,
|
||||
photo_path,
|
||||
data_nascimento,
|
||||
data_obito,
|
||||
sexo,
|
||||
created_at,
|
||||
updated_at,
|
||||
deleted_at
|
||||
) VALUES (
|
||||
:uuid,
|
||||
:nome,
|
||||
:especie_id,
|
||||
:raca_id,
|
||||
:caminho_foto,
|
||||
:registro_geral_animal,
|
||||
:photo_path,
|
||||
:data_nascimento,
|
||||
:data_obito,
|
||||
:sexo,
|
||||
:created_at,
|
||||
:updated_at,
|
||||
:deleted_at
|
||||
)";
|
||||
|
||||
$params = [
|
||||
':uuid' => $petDTO->getUuid(),
|
||||
':nome' => $petDTO->getNome(),
|
||||
':especie_id' => $petDTO->getEspecieId(),
|
||||
':raca_id' => $petDTO->getRacaId(),
|
||||
':caminho_foto' => $petDTO->getCaminhoFoto(),
|
||||
':registro_geral_animal' => $petDTO->getRegistroGeralAnimal(),
|
||||
':photo_path' => $petDTO->getPhotoPath(),
|
||||
':data_nascimento' => $petDTO->getDataNascimento(),
|
||||
':data_obito' => $petDTO->getDataObito(),
|
||||
':sexo' => $petDTO->getSexo(),
|
||||
':created_at' => $petDTO->getCreatedAt(),
|
||||
':updated_at' => $petDTO->getUpdatedAt(),
|
||||
':deleted_at' => $petDTO->getDeletedAt()
|
||||
];
|
||||
|
||||
DB::execute(sql: $sql, params: $params);
|
||||
|
||||
return [
|
||||
'response_code' => 201,
|
||||
'status' => 'success',
|
||||
'message' => 'Pet armazenado com sucesso.',
|
||||
'output' => [
|
||||
'data' => [
|
||||
'id' => DB::lastInsertId(),
|
||||
'uuid' => $petDTO->getUuid(),
|
||||
'nome' => $petDTO->getNome(),
|
||||
'especie_id' => $petDTO->getEspecieId(),
|
||||
'raca_id' => $petDTO->getRacaId(),
|
||||
'caminho_foto' => $petDTO->getCaminhoFoto(),
|
||||
'registro_geral_animal' => $petDTO->getRegistroGeralAnimal(),
|
||||
'photo_path' => $petDTO->getPhotoPath(),
|
||||
'data_nascimento' => $petDTO->getDataNascimento(),
|
||||
'data_obito' => $petDTO->getDataObito(),
|
||||
'sexo' => $petDTO->getSexo(),
|
||||
'created_at' => $petDTO->getCreatedAt(),
|
||||
'updated_at' => $petDTO->getUpdatedAt(),
|
||||
'deleted_at' => $petDTO->getDeletedAt()
|
||||
]
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Associa um pet a um usuário (tutor) no banco de dados.
|
||||
*
|
||||
* Este método insere um novo registro na tabela de associação `{$this->usuarioPet}`, estabelecendo a relação de propriedade entre o usuário e o pet.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Execução da Query:** Prepara e executa a instrução `INSERT` para inserir os IDs do usuário e do pet na tabela de associação.
|
||||
* 2. **Retorno de Sucesso:** Se a inserção for bem-sucedida, retorna um array com **`status` 'success'**, código **201 Created** e uma mensagem de êxito.
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção (ou `500` como fallback) e uma mensagem detalhada de erro.
|
||||
*
|
||||
* @param int $usuario_id O ID do usuário (tutor) a ser associado.
|
||||
* @param int $pet_id O ID do pet a ser associado.
|
||||
* @return array Um array associativo contendo o status da operação, um código de resposta HTTP e uma mensagem.
|
||||
*/
|
||||
public function storeUsuarioPet(int $usuario_id, int $pet_id): array {
|
||||
try {
|
||||
$sql =
|
||||
"INSERT INTO {$this->usuarioPet} (
|
||||
usuario_id,
|
||||
pet_id
|
||||
) VALUES (
|
||||
:usuario_id,
|
||||
:pet_id
|
||||
)";
|
||||
|
||||
$params = [
|
||||
':usuario_id' => $usuario_id,
|
||||
':pet_id' => $pet_id
|
||||
];
|
||||
|
||||
DB::execute(sql: $sql, params: $params);
|
||||
|
||||
return [
|
||||
'response_code' => 201,
|
||||
'status' => 'success',
|
||||
'message' => 'Associação entre usuário e pet criada com sucesso.'
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Busca um único pet no banco de dados por um identificador específico.
|
||||
*
|
||||
* Este método recupera todos os detalhes de um pet da tabela `{$this->petTable}`. A busca é flexível e permite usar qualquer coluna como identificador (`$identifier`) e o valor correspondente.
|
||||
*
|
||||
* #### Fluxo de Operação:
|
||||
* 1. **Execução da Query:** O método monta e executa uma consulta `SELECT` que usa o `$identifier` de forma dinâmica na cláusula `WHERE`. A consulta usa `DB::fetchOne`, indicando que apenas um registro é esperado, e ordena o resultado pelo nome.
|
||||
* 2. **Verificação de Resultados:**
|
||||
* - Se o pet for encontrado, retorna um array com **`status` 'success'**, código **200 OK** e os dados do pet na chave `output`.
|
||||
* - Se o pet **não for encontrado** (`empty($result)`), retorna um array com **`status` 'success'** (indicando que a consulta foi bem-sucedida) e uma mensagem de "Pet não encontrado.".
|
||||
*
|
||||
* #### Tratamento de Erros:
|
||||
* - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção (ou `500` como fallback) e uma mensagem de erro detalhada.
|
||||
*
|
||||
* @param string $identifier A coluna da tabela a ser usada como critério de busca (ex: 'uuid', 'id', 'registro_geral_animal').
|
||||
* @param string $value O valor correspondente ao identificador que está sendo buscado.
|
||||
* @return array Um array associativo contendo o status da operação, um código de resposta HTTP e os dados do pet, se encontrado.
|
||||
*/
|
||||
public function getPetByIdentifier(string $identifier, string $value): array {
|
||||
try {
|
||||
$sql =
|
||||
"SELECT
|
||||
p.id,
|
||||
p.uuid,
|
||||
p.nome,
|
||||
p.especie_id,
|
||||
pae.descricao AS especie,
|
||||
p.raca_id,
|
||||
par.descricao AS raca,
|
||||
p.caminho_foto,
|
||||
p.registro_geral_animal,
|
||||
p.photo_path,
|
||||
p.data_nascimento,
|
||||
p.data_obito,
|
||||
p.sexo,
|
||||
p.created_at,
|
||||
p.updated_at,
|
||||
p.deleted_at
|
||||
FROM {$this->petTable} p
|
||||
LEFT JOIN {$this->petAuxRacaTable} par ON p.raca_id = par.id
|
||||
LEFT JOIN {$this->petAuxEspecieTable} pae ON p.especie_id = pae.id
|
||||
WHERE p.{$identifier} = :value
|
||||
ORDER BY p.nome ASC";
|
||||
|
||||
$params = [
|
||||
':value' => $value
|
||||
];
|
||||
|
||||
$result = DB::fetchOne(sql: $sql, params: $params);
|
||||
if(empty($result)) {
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Pet não encontrado.',
|
||||
'output' => [
|
||||
'data' => []
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
return [
|
||||
'response_code' => 200,
|
||||
'status' => 'success',
|
||||
'message' => 'Pet encontrado com sucesso.',
|
||||
'output' => [
|
||||
'data' => $result
|
||||
]
|
||||
];
|
||||
} catch(Exception $e) {
|
||||
return [
|
||||
'response_code' => $e->getCode() ?? 500,
|
||||
'status' => 'error',
|
||||
'message' => $e->getMessage(),
|
||||
];
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user