Fix/db models

corrige os erros de relação dos DB models

.github/workflows/pipeline_accounts.yaml

+name: Executar Testes com pytest
+
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Clonar o repositório
+        uses: actions/checkout@v4
+
+      - name: Configurar o Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12.4'  # Versão do Projeto
+
+      - name: Instalar dependências & pytest
+        run: |
+          pip install -r requirements.txt
+          pip install pytest
+
+      - name: Executar os testes
+        run: pytest -v

.github/workflows/pipeline_accounts.yaml

+name: Executar Testes com pytest
+
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Clonar o repositório
+        uses: actions/checkout@v4
+
+      - name: Configurar o Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12.4'  # Versão do Projeto
+
+      - name: Instalar dependências & pytest
+        run: |
+          pip install -r requirements.txt
+          pip install pytest
+
+      - name: Executar os testes
+        run: pytest -v

model/account.py

+from sqlalchemy.orm import validates, relationship
 from sqlalchemy import Column, String, Boolean, TIMESTAMP
 from .base import Base
 import uuid
@@ -7,7 +8,16 @@ class Account(Base):
     
     id = Column(String, primary_key=True, default=str(uuid.uuid4()))
     name = Column(String, nullable=False)
-    cnpj = Column(String, unique=True, nullable=False)
+    cnpj = Column(String(14), unique=True, nullable=False)
     is_active = Column(Boolean, default=True)
     created_at = Column(TIMESTAMP, nullable=False)
-    updated_at = Column(TIMESTAMP, nullable=False)
\ No newline at end of file
+    updated_at = Column(TIMESTAMP, nullable=False)
+
+    @validates("cnpj")
+    def validate_cnpj(self, key, cnpj):
+        if not cnpj.isdigit() or len(cnpj) != 14:
+            raise ValueError("CNPJ must be 14 digits long.")
+        return cnpj
+    
+    subscriptions = relationship("Subscription")
+    transactions = relationship("Transaction")
\ No newline at end of file

model/dataset.py

+from sqlalchemy.orm import relationship
 from sqlalchemy import Column, ForeignKey, String, Numeric, Boolean, TIMESTAMP
 from sqlalchemy.dialects.postgresql import UUID as PG_UUID
 import uuid
@@ -13,4 +14,7 @@ class Dataset(Base):
     category = Column(String, nullable=False)
     is_active = Column(Boolean, default=True)
     created_at = Column(TIMESTAMP, nullable=False)
-    updated_at = Column(TIMESTAMP, nullable=False)
\ No newline at end of file
+    updated_at = Column(TIMESTAMP, nullable=False)
+
+
+    subscriptions = relationship("Subscription")
\ No newline at end of file

model/invoice.py

-from sqlalchemy import Column, ForeignKey, Integer, Numeric, DateTime
+from sqlalchemy import Column, ForeignKey, Integer, Numeric, DateTime, String
 from .base import Base
 from sqlalchemy.orm import relationship
 import uuid
@@ -7,7 +7,7 @@ class Invoice(Base):
     __tablename__ = 'invoice'
 
     id = Column(Integer, primary_key=True, index=True)
-    transaction_id = Column(Integer, ForeignKey('transaction.id'))
+    transaction_id = Column(String, ForeignKey('transaction.id'))
     total = Column(Numeric, nullable=False)
     created_at = Column(DateTime, nullable=False)
     updated_at = Column(DateTime, nullable=False)

model/transaction.py

@@ -12,4 +12,6 @@ class Transaction(Base):
     created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
     updated_at = Column(DateTime(timezone=True), onupdate=func.now(), nullable=False)
 
-    account = relationship("Account", back_populates="transactions")
\ No newline at end of file
+    account = relationship("Account", back_populates="transactions")
+    invoices = relationship("Invoice", back_populates="transaction")
+    details = relationship("TransactionDetail")
\ No newline at end of file

repository/account_repository.py

+from sqlalchemy.orm import Session
+from model.account import Account
+
+def get_account_by_name(db: Session, name: str):
+    return db.query(Account).filter(Account.name == name).all()
+
+def get_account_by_cnpj(db: Session, cnpj: str):
+    return db.query(Account).filter(Account.cnpj == cnpj).first()
+
+def get_account_by_is_active(db: Session, is_active: bool):
+    return db.query(Account).filter(Account.is_active == is_active).all()
+
+def create_account(db: Session, name: str, cnpj: str):
+    new_account = Account(name=name, cnpj=cnpj)
+    db.add(new_account)
+    db.commit()
+    db.refresh(new_account)
+    return new_account
+
+def get_all_accounts(db: Session):
+    return db.query(Account).all()
\ No newline at end of file

routers/account_router.py

+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from config.db import SessionLocal
+from service.account_service import get_account, create_new_account, list_accounts
+
+router = APIRouter(prefix="/accounts", tags=["Accounts"])
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@router.get("/{cnpj}")
+def read_account(cnpj: str, db: Session = Depends(get_db)):
+    account = get_account(cnpj, db)
+    if account:
+        return account
+    raise HTTPException(status_code=404, detail="Account not found")
+
+@router.get("/active/{is_active}")
+def get_active_accounts(is_active: bool, db: Session = Depends(get_db)):
+    return list_accounts(db)
+
+@router.post("/")
+def add_account(name: str, cnpj: str, db: Session = Depends(get_db)):
+    try:
+        return create_new_account(name, cnpj, db)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/")
+def get_accounts(db: Session = Depends(get_db)):
+    return list_accounts(db)
+
+

service/account_service.py

+from sqlalchemy.orm import Session
+from repository import account_repository
+
+def get_account(cnpj: str, db: Session):
+    return account_repository.get_account_by_cnpj(db, cnpj)
+
+def create_new_account(name: str, cnpj: str, db: Session):
+    existing_account = account_repository.get_account_by_cnpj(db, cnpj)
+    if existing_account:
+        raise ValueError("Account with this cnpj already exists.")
+    
+    return account_repository.create_account(db, name, cnpj)
+
+def list_accounts(db: Session):
+    return account_repository.get_all_accounts(db)
\ No newline at end of file

tests/test_account_model.py

+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from repository.account_repository import create_account, get_account_by_cnpj, get_all_accounts
+from model.base import Base
+
+# Usando o SQLite em memória -> não persistente
+@pytest.fixture(scope='module')
+def test_db():
+    engine = create_engine('sqlite:///:memory:')
+    Base.metadata.create_all(engine)
+    TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    db = TestingSessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def test_create_account(test_db):
+    account = create_account(test_db, name="Account Test", cnpj="12345678901234")
+
+    assert account.name == "Account Test"
+    assert account.cnpj == "12345678901234"
+    
+    retrieved_account = get_account_by_cnpj(test_db, cnpj="12345678901234")
+    assert retrieved_account is not None
+    assert retrieved_account.name == "Account Test"
+
+def test_get_all_accounts(test_db):
+    accounts = get_all_accounts(test_db)
+    assert len(accounts) > 0
+    assert accounts[0].name == "Account Test"
+    
+    retrieved_accounts = get_all_accounts(test_db)
+    assert len(retrieved_accounts) > 0
+    assert retrieved_accounts[0].name == "Account Test"
\ No newline at end of file