monitoring-api/packages/v1/administrativo/controllers/client_controller.py

from actions.dynamic_import.dynamic_import import DynamicImport
# Adaptando os Schemas para a entidade 'Client'
from packages.v1.administrativo.schemas.client_schema import (
    ClientSchema,
    ClientSaveSchema,
    ClientUpdateSchema,
    ClientIdSchema,
    ClientCNSSchema 
)

import json # Necessário para carregar o arquivo app.json
import math

# Carrega as configurações de paginação do app.json
with open('config/app.json', 'r') as f:
    app_config = json.load(f)
    PAGINATION_FIRST = app_config.get('pagination', {}).get('first', 20)
    PAGINATION_SKIP = app_config.get('pagination', {}).get('skip', 0)


class ClientController:
    """
    Controller responsável por orquestrar as operações (CRUD e outras buscas) 
    para a tabela 'client'.
    """

    def __init__(self):
        # Action responsável por carregar as services de acordo com o estado
        self.dynamic_import = DynamicImport()

        # Define o pacote que deve ser carregado
        self.dynamic_import.set_package("administrativo")

        # Define a tabela que o pacote pertence
        self.dynamic_import.set_table("client")
        pass


    # Lista todos os clientes com paginação
    def index(self, first: int = PAGINATION_FIRST, skip: int = PAGINATION_SKIP):
        
        # Importação da classe desejada
        indexService = self.dynamic_import.service("client_index_service", "IndexService")

        # Instânciamento da classe service
        self.indexService = indexService()

        # Lista todos os clientes, recebendo a lista de dados e o total de registros
        data, total_records = self.indexService.execute(first, skip)

        # Cálculo dos metadados de paginação
        total_pages = math.ceil(total_records / first)
        current_page = (skip // first) + 1
        
        next_page = None
        # Verifica se existe uma próxima página
        if current_page < total_pages:
            next_page = current_page + 1

        # Retorna a lista de clientes e os metadados de paginação
        return {
            'message': 'Clientes localizados com sucesso',
            'data': data,
            'pagination': {
                'total_records': total_records,
                'total_pages': total_pages,
                'current_page': current_page,
                'next_page': next_page,
                'first': first, # Total de registros por página
                'skip': skip # Registros pulados
            }
        }
    

    # Busca um cliente específico pelo cns (Adaptado de logClient)
    def getByCns(self, client_schema: ClientCNSSchema):

        #Importação da classe desejada
        client_cns_service = self.dynamic_import.service('client_cns_service', 'ClientCNSService')

        # Instânciamento da classe desejada
        self.client_cns_service = client_cns_service()

        # Busca e retorna o cliente desejado
        return {
            'message': 'Cliente(s) localizados com sucesso pelo CNS',
            'data': self.client_cns_service.execute(client_schema)
        }    

    # Busca um cliente específico pelo ID (client_id)
    def show(self, client_schema: ClientSchema):

        #Importação da classe desejada
        show_service = self.dynamic_import.service('client_show_service', 'ShowService')

        # Instânciamento da classe desejada
        self.show_service = show_service()

        # Busca e retorna o cliente desejado
        return {
            'message': 'Cliente localizado com sucesso',
            'data': self.show_service.execute(client_schema)
        }

    # Cadastra um novo cliente
    def save(self, client_schema: ClientSaveSchema):

        #Importação da classe desejada
        save_service = self.dynamic_import.service('client_save_service', 'ClientSaveService')

        # Instânciamento da classe desejada
        self.save_service = save_service()

        # Busca e retorna o cliente desejado
        return {
            'message': 'Cliente salvo com sucesso',
            'data': self.save_service.execute(client_schema)
        }

    # Atualiza os dados de um cliente
    def update(self, client_id: int, client_schema: ClientUpdateSchema):

        #Importação da classe desejada
        update_service = self.dynamic_import.service('client_update_service', 'ClientUpdateService')

        # Instânciamento da classe desejada
        self.update_service = update_service()

        # Busca e retorna o cliente desejado
        return {
            'message': 'Cliente atualizado com sucesso',
            'data': self.update_service.execute(client_id, client_schema)
        }

    # Exclui um cliente
    def delete(self, client_schema: ClientIdSchema):

        #Importação da classe desejada
        delete_service = self.dynamic_import.service('client_delete_service', 'DeleteService')

        # Instânciamento da classe desejada
        self.delete_service = delete_service()

        # Busca e retorna o cliente desejado
        return {
            'message': 'Cliente removido com sucesso',
            'data': self.delete_service.execute(client_schema)
        }
    

    # Métodos específicos do Log que não se aplicam diretamente a Client foram removidos ou adaptados:
    # getGed, getServer, getDatabase, getBackup, getDisk, getWarning (Estes parecem ser específicos de logs/monitoramento).
    # Mantendo apenas as operações CRUD e buscas por campos relevantes (CNS, State, ID).
    pass