models.py

from sqlalchemy import ForeignKey, Column, Integer, String, MetaData
from sqlalchemy.orm import relationship, declarative_base, Session
import sqlalchemy as sa
import datetime

convention = {
    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
}
metadata = MetaData(naming_convention=convention)

Base = declarative_base(metadata=metadata)

class Company(Base):
    __tablename__ = 'companies'

    id = Column(Integer(), primary_key=True)
    name = Column(String(), nullable=False)
    founding_year = Column(Integer())

    freebies = relationship("Freebie", back_populates="company", cascade="all, delete-orphan")

    def __repr__(self):
        return f'<Company {self.name}>'

    @property
    def devs(self):
        return list(set([freebie.dev for freebie in self.freebies if freebie.dev]))

    def give_freebie(self, dev, item_name, value):
        if not isinstance(dev, Dev):
            raise TypeError("dev must be an instance of the Dev class.")
        if not isinstance(item_name, str) or not item_name:
            raise ValueError("item_name must be a non-empty string.")
        if not isinstance(value, int) or value <= 0:
            raise ValueError("value must be a positive integer.")

        return Freebie(item_name=item_name, value=value, dev=dev, company=self)

    @classmethod
    def oldest_company(cls, session: Session):
        if not isinstance(session, sa.orm.Session):
            raise TypeError("session must be a SQLAlchemy Session object.")
        return session.query(cls).order_by(cls.founding_year).first()

    def total_freebies_value(self):
        return sum(freebie.value for freebie in self.freebies)


class Dev(Base):
    __tablename__ = 'devs'

    id = Column(Integer(), primary_key=True)
    name = Column(String(), nullable=False, unique=True)

    freebies = relationship("Freebie", back_populates="dev")

    def __repr__(self):
        return f'<Dev {self.name}>'

    @property
    def companies(self):
        return list(set([f.company for f in self.freebies if f.company]))

    def received_one(self, item_name):
        if not isinstance(item_name, str) or not item_name:
            raise ValueError("item_name must be a non-empty string.")
        return any(f.item_name.lower() == item_name.lower() for f in self.freebies)

    def give_away(self, other_dev, freebie):
        if not isinstance(other_dev, Dev):
            raise TypeError("other_dev must be an instance of the Dev class.")
        if not isinstance(freebie, Freebie):
            raise TypeError("freebie must be an instance of the Freebie class.")

        if freebie in self.freebies:
            freebie.dev = other_dev
            return True
        return False

    def total_freebie_value_received(self):
        return sum(f.value for f in self.freebies)


class Freebie(Base):
    __tablename__ = 'freebies'

    id = Column(Integer(), primary_key=True)
    item_name = Column(String(), nullable=False)
    value = Column(Integer(), nullable=False)
    received_at = Column(sa.DateTime, default=datetime.datetime.now)

    dev_id = Column(Integer, ForeignKey('devs.id'), nullable=False)
    company_id = Column(Integer, ForeignKey('companies.id'), nullable=False)

    dev = relationship("Dev", back_populates="freebies")
    company = relationship("Company", back_populates="freebies")

    def __repr__(self):
        company_name = self.company.name if self.company else "Unknown"
        return f'<Freebie {self.item_name} worth {self.value} from {company_name}>'

    def print_details(self):
        dev_name = self.dev.name if self.dev else "N/A"
        company_name = self.company.name if self.company else "N/A"
        return f"{dev_name} owns a {self.item_name} (Value: {self.value}) from {company_name}"

    def update_value(self, new_value):
        if not isinstance(new_value, int) or new_value <= 0:
            raise ValueError("New value must be a positive integer.")
        self.value = new_value