class Grade(db.Model):
__tablename__ = 'grades'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
courses = db.relationship('Course',
backref='grade',
lazy=True,
cascade="all, delete, delete-orphan")
light_courses = db.relationship('LightCourse',
backref='grade',
lazy=True,
cascade="all, delete, delete-orphan")
students = db.relationship('User',
backref='grade',
lazy=True,
cascade="all, delete, delete-orphan")
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return self.name
class Section(db.Model):
__tablename__ = 'sections'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
created_date = db.Column(db.DateTime, default=datetime.now())
course_id = db.Column(db.Integer,
db.ForeignKey('courses.id'),
nullable=False)
quizzes = db.relationship('Quiz',
backref='section',
lazy=True,
cascade="all, delete, delete-orphan")
quiz_histories = db.relationship('QuizHistory',
backref='section',
lazy=True,
cascade="all, delete, delete-orphan")
sub_sections = db.relationship('SubSection',
backref='section',
lazy=True,
cascade="all, delete, delete-orphan")
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class SubCategory(PkModel):
__tablename__ = "subcategories"
name = db.Column(db.String(100), nullable=False)
category_id = db.Column(db.Integer, db.ForeignKey("categories.id"))
products = db.relationship("Product", backref="subcategory", lazy=True)
resources = db.relationship("Resource",
backref="resource_subcategory",
lazy=True)
@classmethod
def category_exists(cls, name):
return db.session.query(
exists().where(cls.name == name.lower())).scalar()
@validates("name")
def convert_lower(self, key, value):
return value.lower()
def get_num_products(self):
return len(self.products)
def get_one_image_url(self):
if len(self.products) > 0:
product = self.products[0]
if len(product.resources) == 0:
if len(self.resources) == 0:
return url_for('static',
filename='default/default_subcategory.jpg')
else:
resource = self.resources[0]
return url_for('static',
filename='uploads/subcategory/{}'.format(
resource.filename))
else:
resource = product.resources[0]
return url_for('static',
filename='uploads/products/{}'.format(
resource.filename))
else:
if len(self.resources) == 0:
return url_for('static',
filename='default/default_subcategory.jpg')
else:
resource = self.resources[0]
return url_for('static',
filename='uploads/subcategory/{}'.format(
resource.filename))
class Quiz(db.Model):
__tablename__ = 'quizes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
question = db.Column(db.String(100))
section_id = db.Column(db.Integer,
db.ForeignKey('sections.id'),
nullable=False)
# https://stackoverflow.com/questions/60805/getting-random-row-through-sqlalchemy
answers = db.relationship('Answer',
backref='quiz',
lazy=True,
cascade="all, delete, delete-orphan",
order_by='func.random()')
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Course(db.Model):
__tablename__ = 'courses'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
created_date = db.Column(db.DateTime, default=datetime.now())
submitted = db.Column(db.Boolean, default=False)
teacher_id = db.Column(db.Integer, nullable=False)
sections = db.relationship('Section',
backref='course',
lazy=True,
cascade="all, delete, delete-orphan")
grade_id = db.Column(db.Integer,
db.ForeignKey('grades.id'),
nullable=False)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Category(db.Model):
__tablename__ = "category"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
products = db.relationship("Product",
backref="categories",
lazy=True,
cascade="all, delete")
def insert(self):
"""Save category to the database"""
db.session.add(self)
db.session.commit()
def update(self):
"""Update category"""
db.session.commit()
def delete(self):
"""delete category"""
db.session.delete(self)
db.session.commit()
@classmethod
def category_exists(cls, name):
return db.session.query(exists().where(cls.name == name)).scalar()
class LightCourse(db.Model):
__tablename__ = 'light_courses'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
created_date = db.Column(db.DateTime, default=datetime.now())
submitted = db.Column(db.Boolean, default=True)
teacher_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
grade_id = db.Column(db.Integer,
db.ForeignKey('grades.id'),
nullable=False)
chapters = db.relationship('LightChapter',
backref='course',
lazy=True,
cascade="all, delete, delete-orphan")
quizzes = db.relationship('LightQuiz',
backref='course',
lazy=True,
cascade="all, delete, delete-orphan")
light_certificate = db.relationship('LightCertificate',
backref='course',
lazy=True,
cascade="all, delete, delete-orphan",
uselist=False)
light_certificate_requests = db.relationship(
'LightCertificateRequest',
backref='course',
lazy=True,
cascade="all, delete, delete-orphan")
light_quiz_histories = db.relationship(
'LightQuizHistory',
backref='course',
lazy=True,
cascade="all, delete, delete-orphan")
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(UserMixin, PkModel):
"""The user of the app"""
__tablename__ = "users"
username = db.Column(db.String(100), unique=True)
_password = db.Column(db.String(128), nullable=False)
first_name = db.Column(db.String(128))
last_name = db.Column(db.String(128))
is_admin = db.Column(db.Boolean, default=False)
email = db.Column(db.String(120), unique=True, nullable=False)
date_registered = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now())
is_email_confirmed = db.Column(db.Boolean(), nullable=False, default=False)
email_confirm_date = db.Column(db.DateTime)
is_customer = db.Column(db.Boolean, default=False)
# A user can have many roles and a role can have many users
roles = db.relationship(
"Role",
secondary=role_user_link,
backref="users",
)
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, plaintext):
self._password = generate_password_hash(plaintext, method="sha256")
def check_hash(self, password):
return check_password_hash(self._password, password)
def generate_confirmation_token(self, email):
serializer = URLSafeTimedSerializer(app.config["SECRET_KEY"])
return serializer.dumps(email, salt=app.config["PASSWORD_SALT"])
@staticmethod
def confirm_mail_token(self, token, expiration=3600):
serializer = URLSafeTimedSerializer(app.config["SECRET_KEY"])
try:
email = serializer.loads(token,
salt=app.config["PASSWORD_SALT"],
max_age=expiration)
except:
return False
return email
def __repr__(self):
return "User: {}".format(self.email)
class SubSection(db.Model):
__tablename__ = 'sub_sections'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
created_date = db.Column(db.DateTime, default=datetime.now())
section_id = db.Column(db.Integer,
db.ForeignKey('sections.id'),
nullable=False)
resources = db.relationship('Resource',
backref='sub_section',
lazy=True,
cascade="all, delete, delete-orphan")
homeworks = db.relationship('Homework',
backref='sub_section',
lazy=True,
cascade="all, delete, delete-orphan")
homework_submissions = db.relationship(
'HomeworkSubmission',
backref='sub_section',
lazy=True,
cascade="all, delete, delete-orphan")
homework_evaluations = db.relationship(
'HomeworkEvaluation',
backref='sub_section',
lazy=True,
cascade="all, delete, delete-orphan")
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100))
password = db.Column(db.String(128))
name = db.Column(db.String(120))
role = db.Column(db.String(120))
pass_changed = db.Column(db.Boolean, default=False)
courses = db.relationship("Course",
secondary=course_subs,
cascade = "all, delete")# !subs- teacher, students
light_courses = db.relationship("LightCourse",
secondary=light_course_subs,
cascade = "all, delete")# !subs- teacher, students
quiz_histories = db.relationship('QuizHistory', backref='person', lazy=True,
cascade="all, delete, delete-orphan")
grade_id = db.Column(db.Integer, db.ForeignKey('grades.id'))
def set_hash(self, password):
self.password = generate_password_hash(password, method="sha256")
def check_hash(self, password):
return check_password_hash(self.password, password)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Category(PkModel):
__tablename__ = "categories"
name = db.Column(db.String(100), unique=True, nullable=False)
subcategories = db.relationship("SubCategory",
backref="category",
lazy=True)
resources = db.relationship(
"Resource",
backref="resource_category",
lazy=True,
)
def __repr__(self):
return f"Category: {self.name}"
@classmethod
def category_exists(cls, name):
return db.session.query(
exists().where(cls.name == name.lower())).scalar()
@validates("name")
def convert_lower(self, key, value):
return value.lower()
def get_one_image_url(self):
if len(self.resources) == 0:
return url_for('static',
filename='default/default_subcategory.jpg')
else:
resource = self.resources[0]
return url_for('static',
filename='uploads/products/{}'.format(
resource.filename))
def get_page_url(self):
return url_for('shop.category', category_name=self.name)
class LearningPath(db.Model):
__tablename__ = 'learning_paths'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
courses = db.relationship("Course",
secondary=learningpath_subs,
cascade="all, delete")
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(UserMixin, db.Model):
""" User model """
__tablename__ = "users"
id = db.Column(db.String(10), primary_key=True)
username = db.Column(db.String(100), unique=True)
password = db.Column(db.String(128))
admin_user = db.Column(db.Boolean, default=False)
roles = db.relationship("Role",
secondary=role_helpers,
cascade="all, delete")
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.id = str(uuid4())
def set_hash(self, password):
self.password = generate_password_hash(password, method="sha256")
def check_hash(self, password):
return check_password_hash(self.password, password)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return f'User({self.username!r})'
class Product(PkModel):
__tablename__ = "product"
barcode = db.Column(db.String(100))
price = db.Column(db.Float)
name = db.Column(db.String(100))
description = db.Column(db.String(300))
date = db.Column(db.String(100))
in_stock = db.Column(db.Integer)
discontinued = db.Column(db.Boolean)
selling_price = db.Column(db.Float)
is_onsale = db.Column(db.Boolean, default=False)
is_featured = db.Column(db.Boolean, default=False)
subcategory_name = db.relationship("SubCategory",
backref=db.backref("subcategory",
uselist=False))
transactions = db.relationship(
"Transaction",
secondary=transaction_helpers,
backref="products",
cascade="all, delete",
)
resources = db.relationship("Resource",
backref="resources",
lazy=True,
cascade="all, delete")
colors = db.relationship('Color',
backref='color_product',
lazy=True,
cascade="all, delete, delete-orphan")
sizes = db.relationship('Size',
backref='size_product',
lazy=True,
cascade="all, delete, delete-orphan")
#
subcategory_id = db.Column(db.Integer,
db.ForeignKey('subcategories.id'),
nullable=False)
def get_color_string(self):
return '\n'.join([c.name for c in self.colors])
def get_size_string(self):
return '\n'.join([s.name for s in self.sizes])
def get_one_image_url(self):
if len(self.resources) == 0:
return url_for('static', filename='default/default_product.jpg')
else:
resource = self.resources[0]
return url_for('static',
filename='uploads/products/{}'.format(
resource.filename))
def get_page_url(self):
return url_for('shop.product', product_barcode=self.barcode)
def add(self):
db.session.add(self)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Order(db.Model):
__tablename__ = "orders"
id = db.Column(db.Integer, primary_key=True)
time = db.Column(db.DateTime, default=datetime.now())
logged_in_customer_email = db.Column(db.String(120), default="")
coupon = db.relationship("Coupon",
backref="coupon_order",
lazy=True,
uselist=False)
order_items = db.relationship(
"OrderItem",
backref="item_order",
lazy=True,
cascade="all, delete, delete-orphan",
)
billing_detail = db.relationship(
"BillingDetail",
uselist=False,
backref="billing_detail_order",
cascade="all, delete, delete-orphan",
)
status = db.Column(
db.String(120),
default="pending") # pending, confirmed, shipped, cancelled, refunded
payment_option_name = db.Column(db.String(120))
payment_option_text = db.Column(db.String(120))
shipment_option = db.relationship(
"DeliveryOption",
backref="shipment_option_order",
lazy=True,
uselist=False,
)
payment_option = db.relationship(
"PaymentOption",
backref="payment_option_order",
lazy=True,
uselist=False,
)
def add(self):
db.session.add(self)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def get_std_formatted_time(self):
return self.time.strftime("%b %d %Y, %H:%M")
def get_ref(self):
return '{}#{}'.format(int(self.id) * 19, self.get_std_formatted_time())
def get_total_amount(self):
prices = []
for item in self.order_items:
product = item.get_product()
price = product.selling_price * item.quantity
prices.append(price)
total_prices = sum(prices)
return total_prices
