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()

    @classmethod

    def virtual_revenue_by_period(cls, period, start=None, end=None):

        r = DBSession.query(cls.amount.label('summable'), event.Event.timestamp)\

                     .join(Transaction)\

                     .join(event.Event)\

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

                     .order_by(event.Event.timestamp)

        if start:

            r = r.filter(event.Event.timestamp>=start.replace(tzinfo=None))

        if end:

            r = r.filter(event.Event.timestamp<end.replace(tzinfo=None))

        return utility.group(r.all(), period)

    @classmethod

    def profit_on_sales(cls, start=None, end=None):

        r = DBSession.query(func.sum(cls.amount-(cls.wholesale*cls.quantity)).label('p'))\

                        .join(Transaction)\

                        .join(event.Event)\

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

        if start:

            r = r.filter(event.Event.timestamp>=start.replace(tzinfo=None))

        if end:

            r = r.filter(event.Event.timestamp<end.replace(tzinfo=None))

        return r.one().p or Decimal(0.0)

    @classmethod

    def item_sale_quantities(cls, item_id):

        return DBSession.query(cls, event.Event)\

                        .join(Transaction)\

                        .join(event.Event)\

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

                        .filter(cls.item_id==int(item_id))\

                        .order_by(event.Event.timestamp).all()

# This is slowww:

# @property

# def __number_sold(self):

#     return object_session(self).query(func.sum(PurchaseLineItem.quantity).label('c'))\

#                                .join(Transaction)\

#                                .join(event.Event)\