um-cseg / chez-betty

from . import vendor

from . import box

class BoxVendor(Base):

    __tablename__ = 'box_vendors'

    id          = Column(Integer, primary_key=True, nullable=False)

    vendor_id   = Column(Integer, ForeignKey("vendors.id"), nullable=False)

    box_id      = Column(Integer, ForeignKey("boxes.id"), nullable=False)

    item_number = Column(String(255), nullable=False)

    enabled     = Column(Boolean, default=True, nullable=False)

    vendor      = relationship(

                      vendor.Vendor,

                      primaryjoin="and_(BoxVendor.vendor_id==Vendor.id, BoxVendor.enabled==True)",

                      backref="boxes"

                  )

    box         = relationship(

                      box.Box,

                      primaryjoin="and_(BoxVendor.box_id==Box.id, BoxVendor.enabled==True)",

                      backref="vendors"

                  )

    def __init__(self, vendor, box, item_number, enabled=True):

        self.vendor_id   = vendor.id

        self.box_id      = box.id

        self.item_number = item_number

        self.enabled     = enabled

    @classmethod

    def from_id(cls, id):

        return DBSession.query(cls).filter(cls.id == id).one()

    @classmethod

    def from_number_fuzzy(cls, number):

        return DBSession.query(cls).filter(cls.item_number.like('%{}%'.format(number))).all()

from . import vendor

from . import item

class ItemVendor(Base):

    __tablename__ = 'item_vendors'

    id          = Column(Integer, primary_key=True, nullable=False)

    vendor_id   = Column(Integer, ForeignKey("vendors.id"), nullable=False)

    item_id     = Column(Integer, ForeignKey("items.id"), nullable=False)

    item_number = Column(String(255), nullable=False)

    enabled     = Column(Boolean, default=True, nullable=False)

    vendor      = relationship(

                      vendor.Vendor,

                      primaryjoin="and_(ItemVendor.vendor_id==Vendor.id, ItemVendor.enabled==True)",

                      backref="items"

                  )

    item         = relationship(

                      item.Item,

                      primaryjoin="and_(ItemVendor.item_id==Item.id, ItemVendor.enabled==True)",

                      backref="vendors"

                  )

    def __init__(self, vendor, item, item_number, enabled=True):

        self.vendor_id   = vendor.id

        self.item_id     = item.id

        self.item_number = item_number

        self.enabled     = enabled

    @classmethod

    def from_id(cls, id):

        return DBSession.query(cls).filter(cls.id == id).one()

    @classmethod

    def from_number_fuzzy(cls, number):

        return DBSession.query(cls).filter(cls.item_number.like('%{}%'.format(number))).all()

from sqlalchemy_utils import ArrowType

class RequestPost(Base):

    __tablename__ = 'request_posts'

    id         = Column(Integer, primary_key=True, nullable=False)

    timestamp  = Column(ArrowType, nullable=False, default=datetime.datetime.utcnow)

    request_id = Column(Integer, ForeignKey("requests.id"), nullable=False)

    user_id    = Column(Integer, ForeignKey("users.id"), nullable=False)

    post       = Column(Text)

    # Allow admin users to post as users or admins by tracking the view that the post is posted from

    staff_post = Column(Boolean, default=False, nullable=False)

    deleted    = Column(Boolean, default=False, nullable=False)

    def __init__(self, request, user, post, staff_post=False, deleted=False):

        self.request_id = request.id

        self.user_id = user.id

        self.post = post

        self.staff_post = staff_post

        self.deleted = deleted

    @classmethod

    def from_id(cls, id):

        return DBSession.query(cls).filter(cls.id == id).one()

    @classmethod

    def all(cls):

        return DBSession.query(cls).filter(cls.deleted==False)\

                        .order_by(desc(cls.timestamp))\

                        .all()

# This is for tracking which items were in which boxes when we restocked

class SubSubTransaction(Base):

    __tablename__      = "subsubtransactions"

    id                 = Column(Integer, primary_key=True, nullable=False)

    subtransaction_id  = Column(Integer, ForeignKey("subtransactions.id"), nullable=False)

    type               = Column(Enum("restocklineboxitem",

                                     name="subsubtransaction_type"), nullable=False)

    item_id            = Column(Integer, ForeignKey("items.id"), nullable=True)

    quantity           = Column(Integer, nullable=False)

    subtransaction     = relationship(SubTransaction, backref="subsubtransactions", cascade="all")

    item               = relationship(item.Item, backref="subsubtransactions")

    __mapper_args__    = {'polymorphic_on': type}

    def __init__(self, subtransaction, item_id, quantity):

        self.subtransaction_id = subtransaction.id

        self.item_id = item_id

        self.quantity = quantity

    def __getattr__(self, name):

        if name == 'deleted':

            return self.subtransaction.transaction.event.deleted

        else:

            raise AttributeError

    @classmethod

    @limitable_all

    def all_item(cls, item_id):

        return DBSession.query(cls)\

                        .join(SubTransaction)\

                        .join(Transaction)\

                        .join(event.Event)\

                        .filter(cls.item_id == item_id)\

                        .filter(event.Event.deleted==False)\

                        .order_by(cls.id)

class RestockLineBoxItem(SubSubTransaction):