class SubscriptionLine(db.Model):
__tablename__ = 'subscription_lines'
__table_args__ = {'extend_existing': True}
subscription_day_id = db.Column(db.Integer,
db.ForeignKey('subscription_days.id'),
primary_key=True)
product_id = db.Column(db.Integer,
db.ForeignKey('products.id'),
primary_key=True)
subscription_day = db.relationship(SubscriptionDay,
backref=db.backref(
"lines",
cascade="all, delete-orphan"))
product = db.relationship(Product,
backref=db.backref("subscription_lines"))
seller_id = db.Column(db.Integer,
db.ForeignKey('sellers.id'),
primary_key=True)
seller = db.relationship(Seller, backref=db.backref("subscription_lines"))
quantity = db.Column(db.Integer, default=0)
price = db.Column(db.Float, default=0.0)
def to_dict(self):
return {
'subscription_day_id': self.subscription_day_id,
'product_id': self.product_id,
'seller_id': self.seller_id,
'quantity': self.quantity,
'price': self.price
}
class Order(db.Model):
__tablename__ = 'orders'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime)
status = db.Column(db.String(20),
nullable=False,
default=OrderStatus_Enum.CREE.value)
seller_id = db.Column(db.Integer,
db.ForeignKey('sellers.id'),
nullable=False)
seller = db.relationship('Seller')
price = db.Column(db.Float)
nb_products = db.Column(db.Integer)
payment_status = db.Column(db.String(20),
nullable=False,
default=PaymentStatus_Enum.NON.value)
products = db.relationship("Product", secondary='lines', viewonly=True)
shipment_id = db.Column(db.Integer,
db.ForeignKey('shipments.id'),
nullable=False)
shipment = db.relationship('Shipment',
backref=db.backref(
"shipments", cascade="all, delete-orphan"))
def add_line(self, line):
self.lines.append(line)
def remove_lines(self):
self.lines.delete()
def get_category(self):
products[0].category
def __repr__(self):
return '<Order {}>'.format(self.id)
def to_dict(self):
return {
'id': self.id,
'title': self.title,
'shipping_dt': self.shipping_dt,
'status': self.status,
'seller_id': self.seller_id,
'shipment_id': self.shipment_id
}
class Product(db.Model):
__tablename__ = 'products'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
short_name = db.Column(db.String(10), nullable=False)
description = db.Column(db.String(250))
price = db.Column(db.Float)
status = db.Column(db.String(20), default='DISPONIBLE')
orders = db.relationship("Order", secondary='lines', viewonly=True)
seller_id = db.Column(db.Integer,
db.ForeignKey('sellers.id'),
nullable=False)
seller = db.relationship('Seller')
category = db.Column(db.String(20), default=Category_Enum.ARTICLE.value)
def __repr__(self):
return "Product('{self.name}',{self.price})"
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'price': self.price,
'seller_id': self.seller_id,
'category': self.category
}
class UserRoles(db.Model):
__tablename__ = 'user_roles'
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'),
primary_key=True)
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'),
primary_key=True)
user = db.relationship(User,
backref=db.backref("users_roles",
cascade="all, delete-orphan"))
role = db.relationship(Role,
backref=db.backref("roles_users",
cascade="all, delete-orphan"))
class Customer(db.Model):
__tablename__ = 'customers'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(50), nullable=False)
lastname = db.Column(db.String(50), nullable=False)
address = db.Column(db.String(200))
cp = db.Column(db.String(20))
city = db.Column(db.String(50))
nb_shipments = db.Column(db.Integer, default=0)
nb_subscriptions = db.Column(db.Integer, default=0)
email = db.Column(db.String(200), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
shipments = db.relationship('Shipment', backref='owner', lazy=True)
subscriptions = db.relationship('Subscription', backref='owner', lazy=True)
def __repr__(self):
return "Customer('{self.firstname}','{self.lastname}','{self.email}')"
class SubscriptionDay(db.Model):
__tablename__ = 'subscription_days'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
subscription_id = db.Column(db.Integer, db.ForeignKey('subscriptions.id'))
subscription = db.relationship('Subscription')
day_of_week = db.Column(db.Integer)
nb_products = db.Column(db.Integer, default=0)
price = db.Column(db.Float, default=0.0)
shipping_price = db.Column(db.Float, default=0.0)
products = db.relationship("Product",
secondary='subscription_lines',
viewonly=True)
def add_products(self, items):
for product_id, qty, price in items:
self.lines.append(
Line(shipment=self,
product_id=product_id,
quantity=qty,
price=price))
def add_line(self, line):
self.lines.append(line)
def to_dict(self):
return {
'subscription_id': self.subscription_id,
'day_of_week': self.day_of_week
}
class Line(db.Model):
__tablename__ = 'lines'
__table_args__ = {'extend_existing': True}
order_id = db.Column(db.Integer,
db.ForeignKey('orders.id'),
primary_key=True)
product_id = db.Column(db.Integer,
db.ForeignKey('products.id'),
primary_key=True)
quantity = db.Column(db.Integer)
price = db.Column(db.Float)
order = db.relationship(Order,
backref=db.backref("lines",
cascade="all, delete-orphan"))
product = db.relationship(Product,
backref=db.backref("lines",
cascade="all, delete-orphan"))
def __repr__(self):
return '<Line {}>'.format(str(self.order.id) + " " + self.product.name)
def __init__(self, order=None, product_id=None, quantity=None, price=None):
self.order = order
self.product_id = product_id
self.quantity = quantity
self.price = price
def to_dict(self):
return {
'order_id': self.order_id,
'product_id': self.product_id,
'quantity': self.quantity,
'price': self.price
}
class User(db.Model, UserMixin):
__tablename__ = 'users'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(100), nullable=False)
joined_at = db.Column(db.DateTime)
active = db.Column(db.Boolean, default=False)
firstname = db.Column(db.String(50))
lastname = db.Column(db.String(50))
account_id = db.Column(db.Integer)
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return 'username :'******', email :'+ self.email + ', password :'******'is_admin : '
def get_id(self):
return self.username
def is_active(self):
return self.active
def set_active(self):
self.active = True
def set_inactive(self):
self.active = False
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def get_main_role(self):
return self.roles[0].name
class Seller(db.Model):
__tablename__ = 'sellers'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
city = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(200), nullable=False)
nb_orders = db.Column(db.Integer, default=0)
nb_subscriptions = db.Column(db.Integer, default=0)
products = db.relationship('Product', backref='owner', lazy=True)
orders = db.relationship('Order', backref='recipient', lazy=True)
def __repr__(self):
return "Seller('{self.name}')"
class ProductStatus(db.Model):
name = db.Column(db.String(50), primary_key=True)
def __repr__(self):
return "ProductStatus('{self.name}')"
class Stat(db.Model):
__tablename__ = 'stats'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
updated_at = db.Column(db.DateTime)
class Subscription(db.Model):
__tablename__ = 'subscriptions'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.Integer,
db.ForeignKey('customers.id'),
nullable=False)
customer = db.relationship('Customer')
start_dt = db.Column(db.Date)
end_dt = db.Column(db.Date)
status = db.Column(db.String(40),
default=SubscriptionStatus_Enum.CREE.value)
payment_status = db.Column(db.String(20), nullable=False)
promotion = db.Column(db.String(200))
price = db.Column(db.Float, default=0.0)
shipping_price = db.Column(db.Float, default=0.0)
nb_products = db.Column(db.Integer, default=0)
nb_orders = db.Column(db.Integer, default=0)
nb_shipments = db.Column(db.Integer, default=0)
category = db.Column(db.String(20), default='INIT')
days = db.relationship('SubscriptionDay',
backref='week',
order_by='asc(SubscriptionDay.day_of_week)',
lazy=True,
cascade="all, delete-orphan")
shipments = db.relationship('Shipment', backref='subref', lazy=True)
def remove_order(self, order):
self.nb_products = self.nb_products - order.nb_products
self.nb_orders = self.nb_orders - 1
def remove_shipment(self, shipment):
self.nb_products = self.nb_products - shipment.nb_products
self.nb_orders = self.nb_orders - shipment.nb_orders
self.nb_shipments = self.nb_shipments - 1
def add_shipment(self, shipment):
self.nb_products = self.nb_products + shipment.nb_products
self.nb_orders = self.nb_orders + shipment.nb_orders
self.nb_shipments = self.nb_shipments + 1
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
class Shipment(db.Model):
__tablename__ = 'shipments'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime)
customer_id = db.Column(db.Integer,
db.ForeignKey('customers.id'),
nullable=False)
customer = db.relationship('Customer')
status = db.Column(db.String(20),
nullable=False,
default=ShipmentStatus_Enum.CREE.value)
price = db.Column(db.Float)
nb_products = db.Column(db.Integer, default=0)
nb_orders = db.Column(db.Integer, default=0)
shipping_price = db.Column(db.Float, default=0.0)
shipping_status = db.Column(db.String(20),
nullable=False,
default=ShippingStatus_Enum.NON.value)
shipping_dt = db.Column(db.DateTime)
shipping_address = db.Column(db.String(200))
shipping_cp = db.Column(db.String(20))
shipping_city = db.Column(db.String(50))
payment_status = db.Column(db.String(20),
nullable=False,
default=PaymentStatus_Enum.NON.value)
shipping_rules = db.Column(db.String(20), nullable=True)
category = db.Column(db.String(20),
nullable=True,
default=Category_Enum.ARTICLE.value)
orders = db.relationship('Order', backref='shipping', lazy=True)
subscription_id = db.Column(db.Integer,
db.ForeignKey('subscriptions.id'),
nullable=True)
subscription = db.relationship('Subscription',
backref=db.backref(
"subscriptions",
cascade="all, delete-orphan"))
def init_stats(self):
self.nb_products = 0
self.nb_orders = 0
self.shipping_price = 0.0
def cancel_order(self, order):
self.nb_products = self.nb_products - order.nb_products
self.nb_orders = self.nb_orders - 1
def active_order(self, order):
self.nb_products = self.nb_products + order.nb_products
self.nb_orders = self.nb_orders + 1
def remove_order(self, order):
#self.cancel_order(order)
self.orders.remove(order)
def add_order(self, order):
self.orders.append(order)
self.active_order(order)
def __repr__(self):
return '<Shipment {}>'.format(self.id)
def to_dict(self):
return {
'id': self.id,
'title': self.title,
'shipping_dt': self.shipping_dt,
'status': self.status,
'customer_id': self.customer_id
}
