class MSettings(db.Model):
__tablename__ = 'marketplace_settings'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
display_name = db.Column(db.String())
value = db.Column(db.String(), default=None)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
@staticmethod
def insert_stripe():
settings = [['stripe_public', 'Stripe Public Key'],
['stripe_secret', 'Stripe Secret Key'],
['paystack_public', 'Paystack Public Key'],
['paystack_secret', 'Paystack Secret Key']]
for s in settings:
setting = MSettings.query.filter_by(name=s[0]).first()
print(setting)
if setting is None:
setting = MSettings(name=s[0], display_name=s[1])
db.session.add(setting)
db.session.commit()
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
index = db.Column(db.String(64))
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
@staticmethod
def insert_roles():
roles = {
'User': (Permission.GENERAL, 'main', True),
'Administrator': (
Permission.ADMINISTER,
'admin',
False # grants all permissions
)
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.permissions = roles[r][0]
role.index = roles[r][1]
role.default = roles[r][2]
db.session.add(role)
db.session.commit()
def __repr__(self):
return '<Role \'%s\'>' % self.name
class MProduct(db.Model):
__tablename__ = 'marketplace_products'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
images = db.Column(db.Text)
description = db.Column(db.String())
availability = db.Column(db.Boolean, default=True)
min_order_quantity = db.Column(db.Integer, default=1)
length = db.Column(db.Float)
weight = db.Column(db.Float)
height = db.Column(db.Float)
price = db.Column(db.Float)
price_currency_id = db.Column(
db.Integer, db.ForeignKey('marketplace_currency.id',
ondelete="CASCADE"))
seller_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
brand_id = db.Column(
db.Integer, db.ForeignKey('marketplace_brands.id', ondelete="CASCADE"))
is_featured = db.Column(db.Boolean, default=False)
condition = db.Column(db.String())
lead_time = db.Column(db.String())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
# categories = db.relationship("MCategory", secondary='marketplace_product_categories',
# backref=backref("products"),
# primaryjoin=(MProductCategory.product_id == id),
# secondaryjoin=(MProductCategory.category_id == MCategory.id))
categories = db.relationship("MCategory",
secondary='marketplace_product_categories',
backref=db.backref('products'))
# variants = db.relationship("MVariant", secondary='marketplace_product_variants',
# backref=backref("products"),
# primaryjoin=(MProductVariant.product_id == id),
# secondaryjoin=(MProductVariant.variant_id == MVariant.id))
variants = db.relationship("MVariant",
secondary='marketplace_product_variants',
backref=db.backref('products'))
brand = db.relationship("MBrand", backref="products")
price_currency = db.relationship("MCurrency")
seller = db.relationship("User", backref="products")
score = query_expression()
@property
def rating(self):
return db.session.query(db.func.avg(
MReview.score)).filter(MReview.product_id == self.id).scalar()
@property
def image_items(self):
return [
url_for('_uploads.uploaded_file',
setname='images',
filename=image,
_external=True) for image in json.loads(self.images)
]
class BlogPost(db.Model):
__tablename__ = 'blog_posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String())
image = db.Column(db.String(), default=None, nullable=False)
text = db.Column(db.Text(), default=None)
comments = db.relationship('BlogComment',
backref=backref('post'),
lazy='dynamic',
cascade="all, delete-orphan")
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
creator = db.relationship('User')
categories = db.relationship(
"BlogCategory",
secondary='blog_post_categories',
backref=backref("posts"),
primaryjoin=(BlogPostCategory.post_id == id),
secondaryjoin=(BlogPostCategory.category_id == BlogCategory.id))
tags = db.relationship("BlogTag",
secondary='blog_post_tags',
backref=backref("posts"),
primaryjoin=(BlogPostTag.post_id == id),
secondaryjoin=(BlogPostTag.tag_id == BlogTag.id))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MProduct(db.Model):
__tablename__ = 'marketplace_products'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
images = db.Column(db.Text)
description = db.Column(db.String())
availability = db.Column(db.Boolean, default=True)
min_order_quantity = db.Column(db.Integer, default=1)
length = db.Column(db.Float)
weight = db.Column(db.Float)
height = db.Column(db.Float)
price = db.Column(db.Float)
price_currency_id = db.Column(db.Integer, db.ForeignKey('marketplace_currency.id', ondelete="CASCADE"))
seller_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"))
is_featured = db.Column(db.Boolean, default=False)
lead_time = db.Column(db.String())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
categories = db.relationship("MCategory", secondary='marketplace_product_categories',
backref=backref("products"),
primaryjoin=(MProductCategory.product_id == id),
secondaryjoin=(MProductCategory.category_id == MCategory.id))
price_currency = db.relationship("MCurrency")
seller = db.relationship("User", backref="products")
@property
def image_items(self):
return [url_for('_uploads.uploaded_file', setname='images',
filename=image, _external=True) for image in json.loads(self.images)]
class MVariant(db.Model):
__tablename__ = 'marketplace_variants'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
symbol = db.Column(db.String())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class MCurrency(db.Model):
__tablename__ = 'marketplace_currency'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
symbol = db.Column(db.String())
default = db.Column(db.Boolean())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class Recipient(db.Model, SaveMixin):
id_email_received_model = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(256), nullable=False)
subject = db.Column(db.String(256), nullable=False)
body = db.Column(db.Text, nullable=False)
create_ts = db.Column(db.DateTime, nullable=False, default=datetime.now())
def __repr__(self):
return "<EmailReceiverModel: {} {}>".format(self.email, self.subject)
class MOrder(db.Model):
__tablename__ = 'marketplace_orders'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
order_number = db.Column(db.String())
charge_id = db.Column(db.String(), default=None, nullable=True)
order_status = db.Column(db.Integer, default=0)
products_total = db.Column(db.Float, default=0)
shipping_cost = db.Column(db.Float, default=0)
order_total = db.Column(db.Float, default=0)
order_discount = db.Column(db.Float, default=0)
order_pay_amount = db.Column(db.Float, default=0)
buyer_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"))
price_currency_id = db.Column(db.Integer, db.ForeignKey('marketplace_currency.id', ondelete="CASCADE"))
first_name = db.Column(db.String(64), index=True)
last_name = db.Column(db.String(64), index=True)
email = db.Column(db.String(64), index=True)
mobile_phone = db.Column(db.BigInteger, index=True)
zip = db.Column(db.String(10), index=True)
city = db.Column(db.String(64), index=True)
state = db.Column(db.String(64), index=True)
country = db.Column(db.String(64), index=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
buyer = db.relationship("User", backref="orders")
price_currency = db.relationship("MCurrency")
@property
def order_status_explained(self):
if self.order_status == 0:
return 'Pending'
return self.order_status
@hybrid_property
def full_name(self):
if self.buyer:
return self.buyer.full_name
first = ''
last = ''
if self.first_name:
first = self.first_name
if self.last_name:
last = self.last_name
return first + " " + last
@property
def sellers(self):
sellers = []
for seller_order in self.order_seller_orders:
if seller_order.seller not in sellers:
sellers.append(seller_order.seller)
return sellers
def order_items_grouped(self):
orders = []
for seller_order in self.order_seller_orders:
items = MOrderItem.query.filter_by(seller_order=seller_order).filter_by(order=self).all()
orders.append({'seller': seller_order.seller, 'items': items, 'shipping': seller_order.shipping_method})
return orders
class ContactMessage(db.Model):
__tablename__ = 'contact_messages'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"),
nullable=True)
name = db.Column(db.String(), default=None, nullable=True)
email = db.Column(db.String(64), default=None, nullable=True)
text = db.Column(db.Text)
user = db.relationship("User")
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MCategory(db.Model):
__tablename__ = 'marketplace_categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
parent_id = db.Column(db.Integer, db.ForeignKey('marketplace_categories.id', ondelete="CASCADE"), nullable=True,
default=None)
name = db.Column(db.String(), default=None, nullable=False)
image = db.Column(db.String(), default=None, nullable=False)
order = db.Column(db.Integer, default=0)
is_featured = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
parent = db.relationship("MCategory", remote_side=[id])
children = db.relationship("MCategory")
class MCategory(db.Model):
__tablename__ = 'marketplace_categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
parent_id = db.Column(db.Integer,
db.ForeignKey('marketplace_categories.id',
ondelete="CASCADE"),
nullable=True,
default=None)
name = db.Column(db.String(), default=None, nullable=False)
image = db.Column(db.String(), default=None, nullable=True)
order = db.Column(db.Integer, default=0)
is_featured = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
parent = db.relationship("MCategory", remote_side=[id])
children = db.relationship("MCategory")
# products = db.relationship(
# 'MProduct',
# secondary=subscribers,
# backref=db.backref('user', passive_deletes=True, lazy='dynamic')
# )
# products = db.relationship("MProduct", backref="categories")
@staticmethod
def insert_data():
names = ('Animals & Pet Supplies', 'Apparel & Accessories',
'Arts & Entertainment', 'Baby & Toddler',
'Business & Industrial', 'Cameras & Optics', 'Electronics',
'Food, Beverages & Tobacco', 'Furniture', 'Hardware',
'Health & Beauty', 'Home & Garden', 'Luggage & Bags',
'Mature', 'Media', 'Office Supplies',
'Religious & Ceremonial', 'Software & Information Technology',
'Sporting Goods', 'Toys & Games', 'Vehicles & Parts',
'Housing', 'Hobbies', 'Classifieds')
for name in names:
name = MCategory(name=name)
db.session.add(name)
db.session.commit()
print('Added Marketplace Categories')
@property
def image_url(self):
return url_for('_uploads.uploaded_file',
setname='images',
filename=self.image,
external=True)
class BlogNewsLetter(db.Model):
__tablename__ = 'blog_news_letters'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), default=None, nullable=True, unique=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class BlogTag(db.Model):
__tablename__ = 'blog_tags'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MBrand(db.Model):
__tablename__ = 'marketplace_brands'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
image = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class MCartDetails(db.Model):
__tablename__ = 'marketplace_cart_details'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cart_id = db.Column(db.Integer,
db.ForeignKey('marketplace_carts.id',
ondelete="CASCADE"),
nullable=True,
default=None)
first_name = db.Column(db.String(64), index=True)
last_name = db.Column(db.String(64), index=True)
email = db.Column(db.String(64), unique=True, index=True)
mobile_phone = db.Column(db.BigInteger, unique=True, index=True)
zip = db.Column(db.String(10), index=True)
city = db.Column(db.String(64), index=True)
state = db.Column(db.String(64), index=True)
country = db.Column(db.String(64), index=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
cart = db.relationship("MCart",
uselist=False,
back_populates="cart_details")
class BlogCategory(db.Model):
__tablename__ = 'blog_categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
order = db.Column(db.Integer, default=0)
is_featured = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MBanner(db.Model):
__tablename__ = 'marketplace_banner'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
main_image = db.Column(db.Text, nullable=True)
feature_header_one = db.Column(db.String(), nullable=True)
feature_icon_one = db.Column(db.Text, nullable=True)
feature_description_one = db.Column(db.String(), nullable=True)
feature_header_two = db.Column(db.String(), nullable=True)
feature_icon_two = db.Column(db.Text, nullable=True)
feature_description_two = db.Column(db.String(), nullable=True)
feature_header_three = db.Column(db.String(), nullable=True)
feature_icon_three = db.Column(db.Text, nullable=True)
feature_description_three = db.Column(db.String(), nullable=True)
@property
def image_url(self):
return url_for('_uploads.uploaded_file', setname='images', filename=self.main_image, external=True)
@property
def image_path(self):
from flask import current_app
return os.path.join(current_app.config['UPLOADED_IMAGES_DEST'], self.main_image)
def __repr__(self):
return u'<{self.__class__.__name__}: {self.id}>'.format(self=self)
class MShippingMethod(db.Model):
__tablename__ = 'marketplace_shipping_methods'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
seller_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"), default=None, nullable=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
seller = db.relationship("User", backref="shipping_methods")
def get_price(self, currency, seller):
price = None
shipping_method_price = MShippingMethodPrice.query.filter_by(shipping_method=self).filter_by(price_currency=currency).filter_by(seller=seller).first()
if shipping_method_price:
price = shipping_method_price.price
return price
class Logo(db.Model):
__tablename__ = 'logos'
id = db.Column(db.Integer, primary_key=True)
image_filename = db.Column(db.String, default=None, nullable=True)
image_url = db.Column(db.String, default=None, nullable=True)
organisation_id = db.Column(db.Integer,
db.ForeignKey('organisations.id',
ondelete="CASCADE"),
nullable=False)
owner_organisation = db.Column(db.String(128))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
def __repr__(self):
return u'<{self.__class__.__name__}: {self.id}>'.format(self=self)
class Notification(db.Model):
__tablename__ = 'notifications'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), index=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
related_id = db.Column(db.Integer, default=0)
timestamp = db.Column(db.Float, index=True, default=time)
payload_json = db.Column(db.Text)
read = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
def get_data(self):
return json.loads(str(self.payload_json))
def parsed(self):
user = User.query.filter_by(id=self.related_id).first()
if 'unread_message' in self.name:
msg = Message.query.filter_by(
id=json.loads(self.payload_json)['message']).first()
if user and msg:
return {
"type":
self.name,
"link":
url_for('main.read_notification', notification_id=self.id),
"text":
"<p><b>{}</b> sent you a message <u>{} ...</u></strong></p>"
.format(user.full_name, msg.body[:40].replace("\n", " ")),
"timestamp":
datetime.fromtimestamp(self.timestamp).ctime(),
"time":
self.timestamp,
"user":
user,
"read":
self.read
}
else:
self.read = True
db.session.add(self)
db.session.commit()
class BlogComment(db.Model, BaseNestedSets):
__tablename__ = 'blog_post_comments'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(), default=None)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
post_id = db.Column(db.Integer,
db.ForeignKey('blog_posts.id', ondelete="CASCADE"))
author = db.relationship('User')
depth = db.Column(db.Integer, default=1)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
def __init__(self, post_id, user_id, text, parent_id=None):
self.post_id = post_id
self.user_id = user_id
self.text = text
self.parent_id = parent_id
class EditableHTML(db.Model):
id = db.Column(db.Integer, primary_key=True)
editor_name = db.Column(db.String(100), unique=True)
value = db.Column(db.Text)
@staticmethod
def get_editable_html(editor_name):
editable_html_obj = EditableHTML.query.filter_by(
editor_name=editor_name).first()
if editable_html_obj is None:
editable_html_obj = EditableHTML(editor_name=editor_name, value='')
return editable_html_obj
@property
def serialize(self):
return {
'id': self.id,
'editor_name': self.editor_name,
'value': self.value
}
class Organisation(db.Model):
__tablename__ = 'organisations'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"),
nullable=False)
image_filename = db.Column(db.String, default=None, nullable=True)
image_url = db.Column(db.String, default=None, nullable=True)
org_name = db.Column(db.String(255))
org_city = db.Column(db.String(255))
org_state = db.Column(db.String(255))
org_country = db.Column(db.String(255))
org_website = db.Column(db.String(255))
org_industry = db.Column(db.String(255))
org_description = db.Column(db.Text)
logos = db.relationship('Logo', backref='organisation', lazy='dynamic')
user = db.relationship('User',
backref='organisations',
cascade='all, delete')
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
def __repr__(self):
return u'<{self.__class__.__name__}: {self.id}>'.format(self=self)
def get_staff(self):
ids = [user.user_id for user in self.staff]
return User.query.filter(User.id.in_(ids)).all()
def get_photo(self):
if self.image_filename:
return url_for('_uploads.uploaded_file',
setname='images',
filename=self.image_filename,
_external=True)
else:
return url_for('static', filename="images/medium_logo_default.png")
class Person(db.Model, SaveMixin):
id_person = db.Column(db.Integer, primary_key=True, doc='ID de la donnée')
email_declarator = db.Column(db.String(256),
nullable=False,
doc='Email du déclarant')
name = db.Column(db.String(80), nullable=False, doc='Nom')
surname = db.Column(db.String(80), nullable=False, doc='Prénom')
email = db.Column(db.String(256), nullable=False, doc='Email')
arrival_date = db.Column(db.Date, nullable=False, doc="Date d'arrivée")
departure_date = db.Column(db.Date, nullable=True, doc="Date de départ")
territory_unit = db.Column(db.String(256),
db.ForeignKey('territory_unit.name'),
nullable=False,
doc="Délégation territoriale")
email_referent = db.Column(db.String(256),
nullable=False,
doc="Email du responsable")
service = db.Column(db.String(256),
nullable=True,
doc="Service de rattachement")
workplace_address = db.Column(db.String(1000),
nullable=True,
doc="Adresse du lieu de travail")
workplace_city = db.Column(db.String(256),
nullable=True,
doc="Ville du lieu de travail")
phone_number = db.Column(db.String(256),
nullable=False,
doc="Numéro de téléphone")
contract_type = db.Column(db.String(256),
db.ForeignKey('contract_type.name'),
nullable=False,
doc="Type de contrat")
position_type = db.Column(db.String(256),
db.ForeignKey('position_type.name'),
nullable=False,
doc="Type de poste")
job_title = db.Column(db.String(256),
nullable=True,
doc="Intitulé du poste")
teams_list = db.Column(db.String(1000), nullable=True, doc="Listes TEAMS")
comment = db.Column(db.String(), nullable=True, doc="Commentaire")
create_ts = db.Column(db.DateTime,
nullable=False,
default=datetime.now(),
doc="Date/heure de création de la donnée")
def __repr__(self):
return "<PersonModel: {} {}>".format(self.name, self.surname)
def fullname(self):
return "{} {}".format(self.name, self.username)
class MCart(db.Model):
__tablename__ = 'marketplace_carts'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
session_id = db.Column(db.String())
user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"), nullable=True, default=None)
step = db.Column(db.Integer, default=1)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
user = db.relationship("User", backref="cart")
cart_details = db.relationship("MCartDetails", uselist=False, back_populates="cart")
@property
def products_count(self):
return len(self.products())
@property
def currency(self):
if len(self.cart_items) > 0:
first_product = self.cart_items[0].product
return first_product.price_currency
return None
def product_count(self, product_id):
product = MProduct.query.get(product_id)
if product:
cart_item = MCartItem.query.filter_by(cart=self).filter_by(product=product).first()
if cart_item:
return cart_item.count
return 0
def products(self):
prods = []
for cart_item in self.cart_items:
prods.append({'product_id': cart_item.product_id, 'count': cart_item.count, 'object': cart_item.product, 'variant': cart_item.variant})
return prods
def sellers(self):
sellers = []
for cart_item in self.cart_items:
if cart_item.seller not in sellers:
sellers.append(cart_item.seller)
return sellers
def orders(self):
orders = []
for seller in self.sellers():
items = MCartItem.query.filter_by(seller=seller).filter_by(cart=self).all()
prods = []
for cart_item in items:
prods.append(
{'product_id': cart_item.product_id, 'count': cart_item.count, 'object': cart_item.product, 'variant': cart_item.variant})
seller_cart = MSellerCart.query.filter_by(cart=self).filter_by(seller=seller).first()
shipping = None
if seller_cart:
shipping = seller_cart.shipping_method
orders.append({'seller': seller, 'items': prods, 'shipping': shipping})
return orders
@property
def products_total(self):
sum = 0
for order in self.orders():
for prod in order['items']:
sum += prod['object'].price * prod['count']
return sum
def price_paid(self):
sum = 0
for order in self.orders():
for prod in order['items']:
sum += prod['object'].price * prod['count']
if order['shipping']:
sum += order['shipping'].get_price(self.currency, order['seller'])
return sum
def price_shipping(self):
sum = 0
for order in self.orders():
if order['shipping']:
sum += order['shipping'].get_price(self.currency, order['seller'])
return sum
def generate_order_number(self):
if self.user_id is not None:
user_part = str(self.user_id)
else:
user_part = self.session_id[:4]
return random_char(4) + user_part + hex(int(time.time()))
class PositionType(db.Model, SaveMixin):
id_position_type = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256), nullable=False, unique=True)
class ContractType(db.Model, SaveMixin):
id_contract_type = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256), nullable=False, unique=True)
class TeamsList(db.Model, SaveMixin):
id_teams_list = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256), nullable=False, unique=True)
class TerritoryUnit(db.Model, SaveMixin):
id_territory_unit = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256), nullable=False, unique=True)
