libretificacaotjcore 0.1.59__py3-none-any.whl

libretificacaotjcore/database/__init__.py

@@ -0,0 +1 @@
+

libretificacaotjcore/database/arquivo_repository.py

@@ -0,0 +1,61 @@
+
+import uuid
+from pymongo.errors import BulkWriteError
+
+class ArquivoRepository:
+    def __init__(self, db):
+        self.__db = db
+
+    async def inserir_arquivo(self, arquivo: dict) -> bool:
+        
+        try:
+            arquivo_no_db = await self.__db.arquivos.find_one(
+                {"solicitacaoId": arquivo["solicitacaoId"], "cpf": arquivo["cpf"]}
+            )
+
+            arquivo['id'] = str(uuid.uuid4())
+
+            if arquivo_no_db is None:
+                await self.__db.arquivos.insert_one(arquivo)
+                return True
+
+            await self.__db.arquivos.delete_one(
+                {"solicitacaoId": arquivo["solicitacaoId"], "cpf": arquivo["cpf"]}
+            )
+            await self.__db.arquivos.insert_one(arquivo)
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao inserir o arquivo: {e}")
+            return False
+        
+    async def inserir_arquivos_em_lote(self, arquivos: list[dict]) -> bool:
+        try:
+            if not arquivos:
+                return False
+
+            filtros = [{"solicitacaoId": a["solicitacaoId"], "cpf": a["cpf"], "id": str(uuid.uuid4())} for a in arquivos]
+            await self.__db.arquivos.delete_many({"$or": filtros})
+
+            await self.__db.arquivos.insert_many(arquivos)
+            return True
+        except BulkWriteError as bwe:
+            print(f"❌ Erro de escrita em lote: {bwe.details}")
+            return False
+        except Exception as e:
+            print(f"❌ Erro ao inserir arquivos em lote: {e}")
+            return False
+
+    async def remover_arquivo(self, solicitacaoId: int) -> bool:
+        try:
+            await self.__db.arquivos.delete_many({"solicitacaoId": solicitacaoId})
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao remover o arquivo: {e}")
+            return False
+
+    async def buscar_por_solicitacao_id(self, solicitacaoId: int) -> list[dict]:
+        try:
+            return await self.__db.arquivos.find({"solicitacaoId": solicitacaoId}).to_list(length=None)
+        except Exception as e:
+            print(f"❌ Erro ao buscar por solicitacaoId: {e}")
+            return []

libretificacaotjcore/database/certificado_repository.py

@@ -0,0 +1,39 @@
+from pymongo.errors import BulkWriteError
+
+class CertificadoRepository:
+    def __init__(self, db):
+        self.__db = db
+
+    async def inserir_certificado(self, certificado: dict) -> bool:
+        try:
+            certificado_no_db = await self.__db.certificado.find_one(
+                {"cnpj": certificado["cnpj"]}
+            )
+
+            if certificado_no_db is None:
+                await self.__db.certificado.insert_one(certificado)
+                return True
+
+            await self.__db.certificado.delete_one(
+                {"cnpj": certificado["cnpj"]}
+            )
+            await self.__db.certificado.insert_one(certificado)
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao inserir o arquivo: {e}")
+            return False
+
+    async def remover_certificado(self, cnpj: str) -> bool:
+        try:
+            await self.__db.certificado.delete_many({"cnpj": cnpj})
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao remover o certificado: {e}")
+            return False
+
+    async def buscar_certificado_por_cnpj(self, cnpj: str) -> list[dict]:
+        try:
+            return await self.__db.certificado.find({"cnpj": cnpj}).to_list(length=None)
+        except Exception as e:
+            print(f"❌ Erro ao buscar certificado: {e}")
+            return []

libretificacaotjcore/database/config_db.py

@@ -0,0 +1,62 @@
+import motor.motor_asyncio
+
+class ConfigDb:
+    def __init__(self, host: str, user: str, password: str, port: int, db_name: str):
+        self.host = host
+        self.user = user
+        self.password = password
+        self.port = port
+        self.db_name = db_name
+        
+        self.client = motor.motor_asyncio.AsyncIOMotorClient(
+            f"mongodb://{self.host}:{self.port}"
+        )
+        self.__db = self.client[self.db_name]
+        self.db_initialized = False
+        
+        
+    async def criar_schema(self):
+        global _db_initialized
+        if not self.db_initialized:
+            if "arquivos" not in (await self.__db.list_collection_names()):
+                await self.__db.create_collection("arquivos")
+            
+            await self.__db.arquivos.create_index([("cnpj", 1)])
+            await self.__db.arquivos.create_index([("solicitacaoId", 1)])
+            await self.__db.arquivos.create_index([("id", 1)], unique=True)
+            await self.__db.arquivos.create_index([("solicitacaoId", 1), ("cpf", 1)], unique=True)
+            self.db_initialized = True
+            
+            if "protocolos" not in (await self.__db.list_collection_names()):
+                await self.__db.create_collection("protocolos")
+            
+            await self.__db.protocolos.create_index([("cnpj", 1)])
+            await self.__db.protocolos.create_index([("solicitacaoId", 1)])
+            await self.__db.protocolos.create_index([("id", 1)], unique=True)
+            await self.__db.protocolos.create_index([("solicitacaoId", 1), ("evento", 1)], unique=True)
+            self.db_initialized = True
+
+            if "rubricas" not in (await self.__db.list_collection_names()):
+                await self.__db.create_collection("rubricas")
+                
+            await self.__db.rubricas.create_index([("cnpj", 1)])
+            await self.__db.rubricas.create_index([("solicitacaoId", 1)], unique=True)
+            await self.__db.rubricas.create_index([("id", 1)], unique=True)
+            self.db_initialized = True
+
+            if "tempo_processos" not in (await self.__db.list_collection_names()):
+                await self.__db.create_collection("tempo_processos")
+                
+            await self.__db.tempo_processos.create_index([("SolicitacaoId", 1)])
+            await self.__db.tempo_processos.create_index([("id", 1)], unique=True)
+            self.db_initialized = True
+            
+            if "solicitacao_xmls" not in (await self.__db.list_collection_names()):
+                await self.__db.create_collection("solicitacao_xmls")
+
+            await self.__db.solicitacao_xmls.create_index([("SolicitacaoId", 1)], unique=True)
+            self.db_initialized = True
+            
+    async def get_db(self):
+        await self.criar_schema()
+        return self.__db

libretificacaotjcore/database/protocolo_repository.py

@@ -0,0 +1,97 @@
+import uuid
+from pymongo.errors import BulkWriteError
+
+class ProtocoloRepository:
+    def __init__(self, db):
+        self.__db = db
+
+    async def inserir_protocolo(self, protocolo: dict) -> bool:
+        
+        try:
+            protocolo_no_db = await self.__db.protocolos.find_one(
+                {"solicitacaoId": protocolo["solicitacaoId"], "evento": protocolo["evento"]}
+            )
+
+            protocolo['id'] = str(uuid.uuid4())
+            if protocolo_no_db is None:
+                await self.__db.protocolos.insert_one(protocolo)
+                return True
+
+            await self.__db.protocolos.delete_one(
+                   {"solicitacaoId": protocolo["solicitacaoId"], "evento": protocolo["evento"]}
+            )
+            await self.__db.protocolos.insert_one(protocolo)
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao inserir o protocolo: {e}")
+            return False
+        
+    async def inserir_protocolos_em_lote(self, protocolos: list[dict]) -> bool:
+        try:
+            if not protocolos:
+                return False
+
+            filtros = [{"solicitacaoId": a["solicitacaoId"], "evento": a["evento"], a['id']: str(uuid.uuid4())} for a in protocolos]
+            await self.__db.protocolos.delete_many({"$or": filtros})
+
+            await self.__db.protocolos.insert_many(protocolos)
+            return True
+        except BulkWriteError as bwe:
+            print(f"❌ Erro de escrita em lote: {bwe.details}")
+            return False
+        except Exception as e:
+            print(f"❌ Erro ao inserir protocolos em lote: {e}")
+            return False
+
+    async def remover_protocolo(self, solicitacaoId: int) -> bool:
+        try:
+            await self.__db.protocolos.delete_many({"solicitacaoId": solicitacaoId})
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao remover o protocolo: {e}")
+            return False
+
+    async def atualizar_protocolo(
+        self, solicitacaoId: int, per_apur: str, protocolo: str, codigo_retorno: str, descricao_retorno: str
+    ) -> bool:
+        """
+        Atualiza os campos codigo_retorno e descricao_retorno
+        dentro do array 'protocolo' filtrando pelo solicitacaoId, per_apur e protocolo.
+        """
+        try:
+            resultado = await self.__db.protocolos.update_one(
+                {
+                    "solicitacaoId": solicitacaoId,
+                    "protocolo.per_apur": per_apur,
+                    "protocolo.protocolo": protocolo
+                },
+                {
+                    "$set": {
+                        "protocolo.$.codigo_retorno": codigo_retorno,
+                        "protocolo.$.descricao_retorno": descricao_retorno
+                    }
+                }
+            )
+
+            if resultado.matched_count == 0:
+                print("⚠️ Nenhum protocolo encontrado para atualizar.")
+                return False
+
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao atualizar protocolo: {e}")
+            return False
+
+    async def buscar_por_solicitacao_id(self, solicitacaoId: int) -> list[dict]:
+        try:
+            return await self.__db.protocolos.find({"solicitacaoId": solicitacaoId}).to_list(length=None)
+        except Exception as e:
+            print(f"❌ Erro ao buscar protocolo por solicitacaoId: {e}")
+            return []
+    
+    async def buscar_por_solicitacao_id_e_evento(self, solicitacaoId: int, evento: str) -> dict | None:
+        try:
+            return await self.__db.protocolos.find_one({"solicitacaoId": solicitacaoId, "evento": evento})
+        except Exception as e:
+            print(f"❌ Erro ao buscar protocolo por solicitacaoId e evento: {e}")
+            return None

libretificacaotjcore/database/rubrica_repository.py

@@ -0,0 +1,35 @@
+import uuid
+from pymongo.errors import BulkWriteError
+
+class RubricaRepository:
+    def __init__(self, db):
+        self.__db = db
+
+    async def inserir_rubrica(self, rubrica: dict) -> bool:
+        
+        try:
+            rubricas_no_db = await self.__db.rubricas.find_one(
+                {"solicitacaoId": rubrica["solicitacaoId"]}
+            )
+
+            rubrica['id'] = str(uuid.uuid4())
+
+            if rubricas_no_db is None:
+                await self.__db.rubricas.insert_one(rubrica)
+                return True
+
+            await self.__db.rubricas.delete_one(
+                   {"solicitacaoId": rubrica["solicitacaoId"]}
+            )
+            await self.__db.rubricas.insert_one(rubrica)
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao inserir o rubrica: {e}")
+            return False
+        
+    async def buscar_por_solicitacao_id(self, solicitacaoId: int) -> dict:
+        try:
+            return await self.__db.rubricas.find_one({"solicitacaoId": solicitacaoId})
+        except Exception as e:
+            print(f"❌ Erro ao buscar rubricas por solicitacaoId: {e}")
+            return {}

libretificacaotjcore/database/solicitacao_xml_repository.py

@@ -0,0 +1,40 @@
+import uuid
+
+class SolicitacaoXmlsRepository:
+    def __init__(self, db):
+        self.__db = db
+
+    async def inserir_solicitacao_xml(self, solicitacao_xml: dict) -> bool:
+        
+        try:
+            solicitacao_xml_no_db = await self.__db.solicitacao_xmls.find_one(
+                {"solicitacaoId": solicitacao_xml["solicitacaoId"]}
+            )
+
+            if solicitacao_xml_no_db is None:
+                await self.__db.solicitacao_xmls.insert_one(solicitacao_xml)
+                return True
+
+            await self.__db.solicitacao_xmls.delete_one(
+                   {"solicitacaoId": solicitacao_xml["solicitacaoId"]}
+            )
+            await self.__db.solicitacao_xmls.insert_one(solicitacao_xml)
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao inserir o solicitacao xml: {e}")
+            return False
+        
+    async def buscar_por_solicitacao_id(self, solicitacaoId: int) -> dict:
+        try:
+            return await self.__db.solicitacao_xmls.find_one({"solicitacaoId": solicitacaoId})
+        except Exception as e:
+            print(f"❌ Erro ao buscar solicitacao xml por solicitacaoId: {e}")
+            return {}
+        
+    async def remover_por_solicitacao_id(self, solicitacaoId: int) -> bool:
+        try:
+            await self.__db.solicitacao_xmls.delete_one({"solicitacaoId": solicitacaoId})
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao remover solicitacao xml por solicitacaoId: {e}")
+            return False

libretificacaotjcore/database/tempo_processo_repository.py

@@ -0,0 +1,119 @@
+from datetime import datetime
+import uuid
+from pymongo.errors import BulkWriteError
+
+from libretificacaotjcore.dtos.processo_dto import ProcessoDto
+from libretificacaotjcore.enums.e_fase_retificacao import EFaseRetificacao
+
+class TempoProcessoRepository:
+    def __init__(self, db):
+        self.__db = db
+
+    async def inserir_processo(self, *, processo: ProcessoDto) -> bool:
+        try:
+            processo_dict = processo.model_dump(exclude_none=True)
+            processo_dict["DataInicio"] = processo.DataInicio.strftime("%Y-%m-%d")
+            processo_dict["DataFim"] = processo.DataFim.strftime("%Y-%m-%d")
+            processo_dict["FaseDescricao"] = EFaseRetificacao(processo.Fase).name
+
+            processo_no_db = await self.__db.tempo_processos.find_one(
+                {
+                    "SolicitacaoId": processo.SolicitacaoId,
+                    "Fase": processo.Fase,
+                    "DataInicio": processo_dict["DataInicio"],
+                    "DataFim": processo_dict["DataFim"],
+                }
+            )
+            
+            processo_dict["id"] = str(uuid.uuid4())
+
+            if processo_no_db is None:
+                processo_dict["InicioProcesso"] = datetime.now()
+                await self.__db.tempo_processos.insert_one(processo_dict)
+                return True
+
+            await self.__db.tempo_processos.delete_one(
+                {
+                    "SolicitacaoId": processo.SolicitacaoId,
+                    "Fase": processo.Fase,
+                    "DataInicio": processo_dict["DataInicio"],
+                    "DataFim": processo_dict["DataFim"],
+                }
+            )
+
+            processo_dict["InicioProcesso"] = datetime.now()
+            await self.__db.tempo_processos.insert_one(processo_dict)
+            return True
+        
+        except Exception as e:
+            print(f"❌ Erro ao inserir o processo: {e}")
+            return False
+        
+    async def atualizar_processo(self, *, processo: ProcessoDto) -> bool:
+        try:
+            processo_dict = processo.model_dump()
+            processo_dict["DataInicio"] = processo.DataInicio.strftime("%Y-%m-%d")
+            processo_dict["DataFim"] = processo.DataFim.strftime("%Y-%m-%d")
+             
+            processo_no_db = await self.__db.tempo_processos.find_one(
+                {
+                    "SolicitacaoId": processo.SolicitacaoId,
+                    "Fase": processo.Fase,
+                    "DataInicio": processo_dict["DataInicio"],
+                    "DataFim": processo_dict["DataFim"],
+                }
+            )
+
+            if processo_no_db is None:
+                return False
+            
+            processo_no_db['FimProcesso'] = datetime.now()
+            tempo_de_processo = self._tempo_de_processo(processo_no_db['InicioProcesso'], processo_no_db['FimProcesso'])
+            processo_no_db['TempoDeProcesso'] = tempo_de_processo
+
+            await self.__db.tempo_processos.update_one(
+                {
+                    "SolicitacaoId": processo.SolicitacaoId,
+                    "Fase": processo.Fase,
+                    "DataInicio": processo_dict["DataInicio"],
+                    "DataFim": processo_dict["DataFim"],
+                },
+                {"$set": processo_no_db
+            })
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao atualizar o processo: {e}")
+            return False
+
+    async def buscar_por_solicitacao_id(self, solicitacao_id: int) -> list[ProcessoDto]:
+        try:
+            processos = await self.__db.tempo_processos.find(
+                {
+                    "SolicitacaoId": solicitacao_id
+                }
+            ).to_list(length=None)
+            processos_dto = []
+
+            for processo in processos:
+                processo_dto = ProcessoDto(**processo)
+                processos_dto.append(processo_dto)
+
+            return processos_dto
+        except Exception as e:
+            print(f"❌ Erro ao buscar os processos por solicitação: {e}")
+            return []
+        
+    def _tempo_de_processo(self, tempo_inicio: datetime, tempo_fim: datetime) -> str | None:
+        if tempo_inicio and tempo_fim:
+            delta = tempo_fim - tempo_inicio
+            total_segundos = int(delta.total_seconds())
+
+            horas = total_segundos // 3600
+            minutos = (total_segundos % 3600) // 60
+            segundos = total_segundos % 60
+
+            tempo_formatado = f"{horas:02d}:{minutos:02d}:{segundos:02d}"
+            tempo_formatado = "00:00:01" if tempo_formatado == "00:00:00" else tempo_formatado
+            return tempo_formatado
+
+        return None

libretificacaotjcore/dtos/arquivo_dto.py

@@ -0,0 +1,20 @@
+from ast import Dict
+
+from pydantic import BaseModel, Field
+
+
+class ArquivoDTO(BaseModel):
+    SolicitacaoId: int = Field(..., description="ID da solicitação")
+    Cpf: str = Field(..., description="CPF do contribuinte")
+    S1200: list[Dict] | None = Field(None, description="Lista de arquivos S-1200")
+    S1210: list[Dict] | None = Field(None, description="Lista de arquivos S-1210")
+    S2200: list[Dict] | None = Field(None, description="Lista de arquivos S-2200")
+    S2299: list[Dict] | None = Field(None, description="Lista de arquivos S-2299")
+    IdeEmpregador: Dict = Field(..., description="Identificação do empregador")
+    Cnpj: str = Field(..., description="CNPJ do empregador")
+    DataInicio: str = Field(..., description="Data de início no formato YYYY-MM-DD")
+    DataFim: str = Field(..., description="Data de fim no formato YYYY-MM-DD")
+    CertificadoId: int = Field(..., description="ID do certificado")
+    DataProcessamento: str = Field(
+        ..., description="Data de processamento no formato YYYY-MM-DD"
+    )

libretificacaotjcore/dtos/processo_dto.py

@@ -0,0 +1,79 @@
+from datetime import date, datetime, timedelta
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from libretificacaotjcore.enums.e_fase_retificacao import EFaseRetificacao
+
+
+class ProcessoDto(BaseModel):
+    model_config = ConfigDict(frozen=False)
+    SolicitacaoId: int = Field(..., description="ID da solicitação")
+    DataInicio: date = Field(..., description="Data de início no formato YYYY-MM-DD")
+    DataFim: date = Field(..., description="Data de fim no formato YYYY-MM-DD")
+    Fase: int | None = Field(None, description="Fase de retificação")
+    InicioProcesso: datetime | None = Field(None, description="Data e hora de início do processo")
+    FimProcesso: datetime | None = Field(None, description="Data e hora de fim do processo")
+    TempoDeProcesso: str | None = Field(None, description="Tempo de processamento")
+    Observacoes: str | None = Field(None, description="Observações adicionais")
+
+    # --- Validadores ---
+
+    @field_validator("SolicitacaoId")
+    @classmethod
+    def validar_solicitacao_id(cls, v: int) -> int:
+        if v <= 0:
+            raise ValueError("O solicitacaoId deve ser um inteiro positivo.")
+        return v
+
+    @field_validator("DataInicio", mode="before")
+    @classmethod
+    def formatar_data_inicio(cls, value) -> date:
+        """
+        Aceita date, datetime ou string.
+        """
+        if isinstance(value, date):
+            return value
+        if isinstance(value, datetime):
+            return value.date()
+        if isinstance(value, str):
+            try:
+                return datetime.strptime(value, "%Y-%m-%d").date()
+            except ValueError as ve:
+                raise ValueError("A DataInicio deve estar no formato YYYY-MM-DD.") from ve
+        raise TypeError("Tipo inválido para DataInicio.")
+
+    @field_validator("DataFim", mode="before")
+    @classmethod
+    def ajustar_data_fim(cls, value) -> date:
+        """
+        Aceita date, datetime ou string.
+        Retorna o último dia do mês da data fornecida.
+        """
+        if isinstance(value, datetime):
+            value = value.date()
+        if isinstance(value, date):
+            ano, mes = value.year, value.month
+        elif isinstance(value, str):
+            try:
+                ano, mes = map(int, value.split("-")[:2])
+            except Exception:
+                raise ValueError("A DataFim deve estar no formato YYYY-MM-DD.")
+        else:
+            raise TypeError("Tipo inválido para DataFim.")
+
+        if mes < 1 or mes > 12:
+            raise ValueError("A DataFim deve conter um mês válido (1–12).")
+
+        # calcula o último dia do mês
+        if mes == 12:
+            proximo_mes = datetime(ano + 1, 1, 1)
+        else:
+            proximo_mes = datetime(ano, mes + 1, 1)
+        return (proximo_mes - timedelta(days=1)).date()
+
+    @field_validator("Fase")
+    @classmethod
+    def validar_fase(cls, v):
+        if v is None:
+            return v
+        if v not in EFaseRetificacao:
+            raise ValueError(f"Fase '{v}' não é válida.")
+        return v

libretificacaotjcore/dtos/solicitacao_dto.py

@@ -0,0 +1,69 @@
+import re
+from datetime import date, datetime, timedelta
+
+from pydantic import BaseModel, Field, field_validator
+from libretificacaotjcore.enums.e_fase_retificacao import EFaseRetificacao
+
+
+class SolicitacaoDTO(BaseModel):
+    SolicitacaoId: int = Field(..., description="ID da solicitação")
+    Cnpj: str = Field(..., description="CNPJ da empresa")
+    DataInicio: date = Field(..., description="Data de início no formato YYYY-MM-DD")
+    DataFim: date = Field(..., description="Data de fim no formato YYYY-MM-DD")
+    CertificadoId: int = Field(..., description="ID do certificado")
+    Fase: int | None = Field(None, description="Fase de retificação")
+    FaseUnica: bool = Field(False, description="Fase única")
+
+    @field_validator("SolicitacaoId")
+    @classmethod
+    def validar_solicitacao_id(cls, v: int) -> int:
+        if v <= 0:
+            raise ValueError("O solicitacaoId deve ser um inteiro positivo.")
+        return v
+
+    @field_validator("CertificadoId")
+    @classmethod
+    def validar_certificado_id(cls, v: int) -> int:
+        if v <= 0:
+            raise ValueError("O certificadoId deve ser um inteiro positivo.")
+        return v
+
+    @field_validator("Cnpj")
+    @classmethod
+    def validar_cnpj(cls, v: str) -> str:
+        cnpj_limpo = re.sub(r"\D", "", v)
+        if len(cnpj_limpo) != 14 or not cnpj_limpo.isdigit():
+            raise ValueError("O CNPJ deve conter 14 dígitos numéricos.")
+        return cnpj_limpo
+
+    @field_validator("DataInicio", mode="before")
+    @classmethod
+    def formatar_data_inicio(cls, value: str) -> date:
+        try:
+            return datetime.strptime(value, "%Y-%m-%d").date()
+        except ValueError as ve:
+            raise ValueError("A dataInicio deve estar no formato YYYY-MM-DD.") from ve
+
+    @field_validator("DataFim", mode="before")
+    @classmethod
+    def ajustar_data_fim(cls, value: str) -> date:
+        ano, mes = map(int, value.split("-")[:2])
+        if mes < 1 or mes > 12:
+            raise ValueError(
+                "A dataFim deve estar no formato YYYY-MM-DD e conter um mês válido."
+            )
+        if mes == 12:
+            proximo_mes = datetime(ano + 1, 1, 1)
+        else:
+            proximo_mes = datetime(ano, mes + 1, 1)
+        return (proximo_mes - timedelta(days=1)).date()
+    
+    @field_validator("Fase")
+    @classmethod
+    def validar_fase(cls, v: str) -> str | None:
+        if v is None:
+            return v
+        
+        if v not in EFaseRetificacao:
+            raise ValueError(f"Fase '{v}' não é válido.")
+        return v

libretificacaotjcore/enums/e_eventos.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class EEventos(str, Enum):
+    S1010 = "S-1010"
+    S1200 = "S-1200"
+    S1210 = "S-1210"
+    S1298 = "S-1298"
+    S1299 = "S-1299"
+    S2299 = "S-2299"
+    S3000 = "S-3000"

libretificacaotjcore/enums/e_fase_retificacao.py

@@ -0,0 +1,38 @@
+from enum import Enum
+
+
+class EFaseRetificacao(Enum):
+    NaoIniciado = 0
+    SolicitacaoXml = 1
+    AguardandoXml = 2
+    DownloadXml = 3
+    ExtraindoDadosDoXml = 4
+    #? Abertura de Competencia
+    EstruturandoXmlAberturaCompetencia = 5
+    AberturaDeCompetencia = 6
+    ConsultandoESocialAberturaCompetencia = 7
+    #? Rubricas
+    EstruturandoXmlInclusaoRubricas = 8
+    InclusaoDasRubricas = 9
+    ConsultandoESocialInclusaoRubricas = 10
+    #? Exclusao de Pagamentos
+    EstruturandoXmlExclusaoPagamentos = 11
+    ExclusaoDePagamentos = 12
+    ConsultandoESocialExclusaoPagamentos = 13
+    #? Retificacao
+    EstruturandoXmlRetificacaoRemuneracao = 14
+    RetificacaoDaRemuneracao = 15
+    ConsultandoESocialRetificacaoRemuneracao = 16
+    #? Desligamento
+    EstruturandoXmlDesligamento = 17
+    Desligamento = 18
+    ConsultandoESocialDesligamento = 19
+    #? Inclusao de Pagamentos
+    EstruturandoXmlInclusaoPagamentos = 20
+    InclusaoDosPagamentos = 21
+    ConsultandoESocialInclusaoPagamentos = 22
+    #? Fechamento de Competencia
+    EstruturandoXmlFechamentoCompetencia = 23
+    FechamentoDeCompetencia = 24
+    ConsultandoESocialFechamentoCompetencia = 25
+    Finalizado = 26

libretificacaotjcore/services/crypto_pass_service.py

@@ -0,0 +1,18 @@
+from cryptography.fernet import Fernet
+
+class CryptoPassService:
+    def __init__(self, key: bytes | None = None):
+        # Se a chave não for passada, gera uma nova
+        self.key = key or Fernet.generate_key()
+        self.cipher = Fernet(self.key)
+
+    def encrypt_password(self, password: str) -> bytes:
+        # Recebe a senha em texto e retorna a senha criptografada em bytes
+        password_bytes = password.encode()
+        encrypted = self.cipher.encrypt(password_bytes)
+        return encrypted
+
+    def decrypt_password(self, token: bytes) -> str:
+        # Recebe o token criptografado e retorna a senha em texto
+        decrypted_bytes = self.cipher.decrypt(token)
+        return decrypted_bytes.decode()

libretificacaotjcore/services/file_service.py

@@ -0,0 +1,53 @@
+import asyncio
+from io import BytesIO
+import os
+import shutil
+from pathlib import Path
+import zipfile
+import aiofiles
+import aiofiles.os
+
+class FileService:
+    async def zip_folder(self, folder_path: str, output_path: str):
+        buffer = BytesIO()
+        
+        with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+            for root, _, files in os.walk(folder_path):
+                for file in files:
+                    full_path = os.path.join(root, file)
+                    arcname = os.path.relpath(full_path, folder_path)
+
+                    async with aiofiles.open(full_path, "rb") as f:
+                        content = await f.read()
+                        zip_file.writestr(arcname, content)
+        
+        async with aiofiles.open(output_path, "wb") as f:
+            await f.write(buffer.getvalue())
+            
+    async def extract_zip(self, folder_path_zip: str, output_path: str):
+            if not await aiofiles.os.path.exists(folder_path_zip):
+                raise FileNotFoundError(
+                    f"Arquivo ZIP não encontrado: {folder_path_zip}"
+                )
+
+            if not await aiofiles.os.path.exists(output_path):
+                await aiofiles.os.makedirs(output_path, exist_ok=True)
+
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None, self._extrair_zip, folder_path_zip, output_path
+            )
+
+    async def remove_file(self, file_path: str):
+        if await aiofiles.os.path.exists(file_path):
+            await aiofiles.os.remove(file_path)
+            
+    async def remove_folder(self, folder_path: str):
+        if await aiofiles.os.path.exists(folder_path):
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, shutil.rmtree, folder_path)
+            
+    def _extrair_zip(self, folder_path_zip: str, output_path: str):
+        with zipfile.ZipFile(folder_path_zip, "r") as zip_ref:
+            zip_ref.extractall(output_path)
+            

libretificacaotjcore/services/rabbitmq_consumer.py

@@ -0,0 +1,59 @@
+import asyncio
+import aio_pika
+import json
+
+class RabbitMQConsumer:
+    def __init__(
+        self,
+        *,
+        host: str,
+        queue: str,
+        username: str,
+        password: str,
+        vhost: str = "/",
+    ):
+        self.host = host
+        self.queue = queue
+        self.username = username
+        self.password = password
+        self.vhost = vhost
+        self.connection = None
+        self.channel = None
+
+    async def connect(self):
+        self.connection = await aio_pika.connect_robust(
+            host=self.host,
+            login=self.username,
+            password=self.password,
+            virtualhost=self.vhost,
+            heartbeat=600,
+        )
+        self.channel = await self.connection.channel()
+        await self.channel.set_qos(prefetch_count=1)
+        await self.channel.declare_queue(self.queue, durable=True)
+
+    async def start_consuming(self, callback):
+        if not self.channel:
+            raise RuntimeError("❌ Canal RabbitMQ não conectado. Chame connect() antes.")
+
+        queue = await self.channel.get_queue(self.queue)
+
+        async def on_message(message):
+            async with message.process():
+                try:
+                    mensagem = json.loads(message.body.decode())
+                    await callback(mensagem)  # aqui sim passa o DTO
+                except Exception as e:
+                    print(f"❌ Erro ao processar mensagem: {e}")
+
+        await queue.consume(on_message)  # registra callback
+
+        print(f'[*] Aguardando mensagens na fila "{self.queue}". Para sair pressione CTRL+C')
+
+        # Mantém o consumer rodando
+        await asyncio.Future()
+
+
+    async def close(self):
+        if self.connection:
+            await self.connection.close()

libretificacaotjcore/services/rabbitmq_publisher.py

@@ -0,0 +1,56 @@
+import aio_pika
+import json
+from aio_pika.abc import AbstractRobustConnection, AbstractChannel, AbstractQueue
+
+class RabbitMQPublisher:
+    def __init__(
+        self,
+        host: str,
+        queue: str,
+        username: str,
+        password: str,
+        vhost: str = "/",
+    ):
+        self.host = host
+        self.queue = queue
+        self.username = username
+        self.password = password
+        self.vhost = vhost
+
+        self.connection: AbstractRobustConnection | None = None
+        self.channel: AbstractChannel | None = None
+        self.queue_obj: AbstractQueue | None = None
+
+    async def connect(self):
+        self.connection = await aio_pika.connect_robust(
+            host=self.host,
+            login=self.username,
+            password=self.password,
+            virtualhost=self.vhost,
+            heartbeat=60,
+        )
+
+        
+        self.channel = await self.connection.channel()
+        # garante que mensagens não são perdidas
+        self.queue_obj = await self.channel.declare_queue(
+            self.queue, durable=True
+        )
+
+    async def publish(self, message: dict):
+        if not self.channel:
+            raise RuntimeError("❌ Canal RabbitMQ não conectado. Chame connect() antes.")
+
+        body = json.dumps(message).encode("utf-8")
+        await self.channel.default_exchange.publish(
+            aio_pika.Message(
+                body=body,
+                delivery_mode=aio_pika.DeliveryMode.PERSISTENT,  # torna a msg persistente
+            ),
+            routing_key=self.queue,
+        )
+        print(f"✅ Mensagem publicada na fila '{self.queue}': {message}")
+
+    async def close(self):
+        if self.connection:
+            await self.connection.close()

libretificacaotjcore/services/request_servico_api.py

@@ -0,0 +1,20 @@
+import httpx
+
+
+class RequestServicoApi:
+    def __init__(self, url, token):
+        self.url = url
+        self.token = token
+        self.client = httpx.AsyncClient(timeout=120, verify=False)
+
+    async def handler(self, *, mensagem_atualizacao: dict):
+        print(self.token)
+        response = await self.client.post(self.url, json=mensagem_atualizacao)
+
+        if response.status_code != 200:
+            raise Exception(f"Erro ao fazer request ao servico de API: {response.status_code}")
+        
+        await self.close()
+
+    async def close(self):
+        await self.client.aclose()

libretificacaotjcore/services/s3_service.py

@@ -0,0 +1,83 @@
+import asyncio
+from functools import partial
+import os
+import boto3
+from botocore.exceptions import ClientError
+
+class S3Service:
+    def __init__(self, aws_access_key_id, aws_secret_access_key, region_name, bucket_name, bucket_path):
+        self.s3 = boto3.client(
+            "s3",
+            aws_access_key_id=aws_access_key_id,
+            aws_secret_access_key=aws_secret_access_key,
+            region_name=region_name,
+        )
+        
+        self.bucket_name = bucket_name
+        self.bucket_path = bucket_path
+
+        self.loop = asyncio.get_running_loop()
+
+    async def save_on_s3(self, file_path, file_name):
+        try:
+            await self.loop.run_in_executor(
+                None,
+                self.s3.upload_file,
+                file_path,
+                self.bucket_name,
+                self.bucket_path + file_name,
+            )
+        except Exception as e:
+            print(f"❌ Erro ao salvar o arquivo no S3: {e}")
+
+    async def save_many_paths_on_s3(self, file_paths):
+        """
+        Salva vários arquivos no S3 informando apenas os caminhos locais.
+        O nome do arquivo no S3 será o mesmo do arquivo local.
+        """
+        tasks = [
+            self.save_on_s3(
+                file_path["caminho_arquivo_local"], file_path["nome_arquivo"]
+            )
+            for file_path in file_paths
+        ]
+        await asyncio.gather(*tasks)
+
+    async def file_on_s3(self, file_name):
+        try:
+            head_object_func = partial(
+                self.s3.head_object,
+                Bucket=self.bucket_name,
+                Key=self.bucket_path + file_name,
+            )
+
+            await self.loop.run_in_executor(None, head_object_func)
+            return True
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "404":
+                return False
+
+            raise
+        except Exception as e:
+            print(f"❌ Erro ao obter o arquivo do S3: {e}")
+            return False
+
+    async def get_file_from_s3(self, file_name, destination_path):
+        try:
+            os.makedirs(os.path.dirname(destination_path), exist_ok=True)
+
+            key = self.bucket_path + file_name
+            print(f"🔍 Verificando chave: {key}")
+            download_func = partial(
+                self.s3.download_file, self.bucket_name, key, destination_path
+            )
+
+            await self.loop.run_in_executor(None, download_func)
+            print(f"📖✅ Arquivo '{file_name}' baixado com sucesso.")
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "404":
+                print(f"⚠️ Arquivo '{file_name}' não encontrado no S3.")
+            else:
+                print(f"❌ Erro ao baixar o arquivo do S3: {e}")
+        except Exception as e:
+            print(f"❌ Erro inesperado ao baixar o arquivo do S3: {e}")

libretificacaotjcore-0.1.59.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: libretificacaotjcore
+Version: 0.1.59
+Summary: Biblioteca para centralizar conexao com filas no rabbit e banco de dados no mongodb para os servicos de retificacao da TJ
+Author-email: Jhonatan Azevedo <dev.azevedo@outlook.com>
+Project-URL: Homepage, https://github.com/seu-usuario/libretificacaotjcore
+Project-URL: Issues, https://github.com/seu-usuario/libretificacaotjcore/issues
+Project-URL: Repository, https://github.com/seu-usuario/libretificacaotjcore
+Keywords: tj,tributo justo,retificação,automação,pydantic,rabbitmq,boto3,motor
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aio-pika>=9.5.7
+Requires-Dist: aiofiles>=24.1.0
+Requires-Dist: boto3>=1.39.16
+Requires-Dist: cryptography>=45.0.6
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: motor>=3.7.1
+Requires-Dist: pika>=1.3.2
+Requires-Dist: py7zr>=1.0.0
+Requires-Dist: pydantic>=2.11.7
+
+# 🛠️ LIBRETIFICACAOTJCORE
+
+## 📝 Descrição
+
+O Objetivo desse serviço é:
+- Centralizar conexão com filas no rabbit e consumo de mensagens
+- Centralizar conexão banco de dados no mongodb para os serviços de retificação da TJ
+- Centralizar todas as operações de criação, leitura e atualização de arquivos
+- Centralizar todas as operações de criação, leitura e atualização de protocolos
+- Disponibilizar metodos para tratativas de arquivos
+- Disponibilizar Dtos e Enums comuns em todos os serviços de retificações
+
+## ⚙️ Configuração
+nessesário ter o [uv astral](https://docs.astral.sh/uv/getting-started/installation/) instalado
+
+Com o UV instalado, execute o comando abaixo para criar o arquivo de configuração:
+
+```bash
+    uv sync
+```
+
+## 📺 Como publicar?
+
+Para publicar o serviço, execute o comando abaixo:
+
+```bash
+    uv build
+```
+e depois
+
+```bash
+    twine upload dist/*
+```
+
+Obs: É necessário informa o token do pypi para que o comando funcione

libretificacaotjcore-0.1.59.dist-info/RECORD

@@ -0,0 +1,27 @@
+libretificacaotjcore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libretificacaotjcore/database/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+libretificacaotjcore/database/arquivo_repository.py,sha256=uVJVzuTg3t5XDM6CfHKMZo_G4dIm1YbqYIYUAlF9NOs,2243
+libretificacaotjcore/database/certificado_repository.py,sha256=LF3rV1rQmRGZVB4wPh_vmDj81Gf_env_5hqtTbxXNFM,1396
+libretificacaotjcore/database/config_db.py,sha256=Hgy_b9z-LI0Xs7WWENniT9QAQEIXtL5ym6cXs17NpSM,2894
+libretificacaotjcore/database/protocolo_repository.py,sha256=B2d-b_zx0PMdSrEoQyC9F3EsW52OsbzwFgx-biZO05s,3878
+libretificacaotjcore/database/rubrica_repository.py,sha256=GtUgoRfuYHYNyBfllMWZPg69noVsfwCJoaXgDTmvmuw,1192
+libretificacaotjcore/database/solicitacao_xml_repository.py,sha256=FWSPSV_tDjKQAnqaffejfX5lpndI3ZLiXa20fYn1BjM,1582
+libretificacaotjcore/database/tempo_processo_repository.py,sha256=WisJ1ZGZp7wUV77PybCajNxM08lUnjzJ0LNJpcwkW_Q,4790
+libretificacaotjcore/dtos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libretificacaotjcore/dtos/arquivo_dto.py,sha256=D4LLJZf-Z0XhJmOvu7nAcBq0j70m9TFtbgxI9ikHXQ0,1045
+libretificacaotjcore/dtos/processo_dto.py,sha256=vk2wyEsKLebqNVbxaEw5t-huPDoPR63fsy4092uORBw,3153
+libretificacaotjcore/dtos/solicitacao_dto.py,sha256=UJ-JpB_85yNHLyea5UGdDv1D6XW9-Ig4P3NyNe2ddAs,2639
+libretificacaotjcore/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libretificacaotjcore/enums/e_eventos.py,sha256=4NICIKFpxEvxMbHu_kcKqNXqylDETcr6qY1tK2bKmi4,207
+libretificacaotjcore/enums/e_fase_retificacao.py,sha256=nbe0viCplUYBBUpoBLVJ8qUz-z1rfviW8_YoNuSNSL0,1232
+libretificacaotjcore/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libretificacaotjcore/services/crypto_pass_service.py,sha256=9D0vyjan6f_8AfNxGkLpGdvyMpojsJq_AAySpv_zKMc,740
+libretificacaotjcore/services/file_service.py,sha256=14CJokBbrsryQGmL0_unH2QKZpnteEAfxf5CPFdv6cE,2075
+libretificacaotjcore/services/rabbitmq_consumer.py,sha256=yRS3sAkaMIIn8Y06icwkO1bpddlLC7BmNSHJVhUalzY,1818
+libretificacaotjcore/services/rabbitmq_publisher.py,sha256=xsb9LmIuZizzq5lxnEEZKMK3U952KSQ2oqlTBZi2Lt8,1787
+libretificacaotjcore/services/request_servico_api.py,sha256=G7vnmvOfwrCGL-Jy_5tCKG-l5E00OCkJfkuoa5Y6sHo,613
+libretificacaotjcore/services/s3_service.py,sha256=HKR_jt2H3XdV1PCzo5R5bnhmoQ3I46Yn5IqAvVPhsjs,2946
+libretificacaotjcore-0.1.59.dist-info/METADATA,sha256=fACouGH6Jc1LPvEjuwUYmN5q8PqKxSMApdVKTlgQgWg,2564
+libretificacaotjcore-0.1.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+libretificacaotjcore-0.1.59.dist-info/top_level.txt,sha256=J9vnz_X9OUnxC-eXHiAzlc9xIrWBwZ5bgnIDQIIFY4c,21
+libretificacaotjcore-0.1.59.dist-info/RECORD,,

libretificacaotjcore-0.1.59.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

libretificacaotjcore-0.1.59.dist-info/top_level.txt

@@ -0,0 +1 @@
+libretificacaotjcore