class Order(db.Model):
__tablename__ = 'Order'
order_id = db.Column('order_id', db.Integer, primary_key=True)
customer_email = db.Column(db.String(100))
date_placed = db.Column(db.DateTime)
status = db.Column(
db.Enum("pending",
"shipped",
"fulfilled",
"canceled",
name="status_enum"))
order_products = relationship("OrderProduct", backref="order_source")
def __init__(self, customer_email, date_placed, status):
self.customer_email = customer_email
self.date_placed = date_placed
self.status = status
def __repr__(self):
return '<order_id {}>'.format(self.order_id)
def serialize(self):
return {
'order_id': self.order_id,
'customer_email': self.customer_email,
'date_placed': str(self.date_placed),
'status': self.status
}
class InventoryItem(db.Model):
__tablename__ = 'InventoryItem'
item_id = db.Column('item_id', db.Integer, primary_key=True)
name = db.Column(db.String(100))
description = db.Column(db.String(256))
price = db.Column(db.Numeric(precision=9, scale=2))
quantity = db.Column(db.Integer)
def __init__(self, name, description, price, quantity):
if not name:
raise Exception("Name should not be empty")
if price < 0 or quantity < 0:
raise Exception("Can't be negative")
self.name = name
self.description = description
self.price = price
self.quantity = quantity
def __repr__(self):
return '<item_id {}>'.format(self.item_id)
def serialize(self):
return {
'item_id': self.item_id,
'name': self.name,
'description': self.description,
'price': str(self.price),
'quantity': self.quantity
}
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120))
def __init__(self, name):
self.name = name
def __repr__(self):
return "{}".format(self.name)
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
tag_name = db.Column(db.String(100))
tag_slug = db.Column(db.String(100))
def __init__(self, *args, **kwargs):
super(Tag, self).__init__(*args, **kwargs)
self.tag_slug = slugify(self.tag_name)
def __repr__(self):
return f'<Tag id: {self.id}, name: {self.tag_name} >'
class DbUser(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
last_name = db.Column(db.String(100), nullable=False)
first_name = db.Column(db.String(100), nullable=False)
cv_url = db.Column(db.String(255))
skill = relationship('DbUserSkillAssociation',
back_populates='user',
cascade='save-update, merge, delete, delete-orphan')
def __repr__(self):
return f'{self.first_name} {self.last_name}. CV: {self.cv_url}'
class Blog(Bookmark):
__tablename__ = 'blog'
def __init__(self, **kwargs):
super(Blog, self).__init__(**kwargs)
self.type = Bookmark.TYPE_BLOG
id = db.Column(db.Integer, db.ForeignKey('bookmark.id'), primary_key=True)
URL = db.Column(db.String(250))
writer = db.Column(db.String(250))
__mapper_args__ = {
'polymorphic_identity': 'blog',
}
class UserModel(db.Model):
'''class representing users table'''
__tablename__ = 'users'
username = db.Column(db.String(30), primary_key=True)
name = db.Column(db.String(50))
email = db.Column(db.String(70), unique=True)
password = db.Column(db.String(200))
admin = db.Column(db.Boolean)
reset_password = db.Column(db.String(200))
date_registered = db.Column(db.DateTime)
last_login = db.Column(db.DateTime)
last_change_password = db.Column(db.DateTime)
last_reset_password = db.Column(db.DateTime)
user_books = db.relationship("UserBooksModel",
cascade="all, delete-orphan")
def __init__(self, username, name, email, password, admin=False):
self.username = username
self.name = name
self.email = email
self.password = generate_password_hash(password)
self.admin = admin
self.reset_password = False
self.date_registered = datetime.now()
@classmethod
def get_user_by_username(cls, username):
'''query user table using username'''
return cls.query.filter_by(username=username).first()
@classmethod
def get_user_by_email(cls, email):
'''query user table using email'''
return cls.query.filter_by(email=email).first()
def save(self):
'''commit and save data from object'''
db.session.add(self)
db.session.commit()
def delete(self):
'''delete a user account'''
db.session.delete(self)
db.session.commit()
def __repr__(self):
return '<name: %s, username: %s, email: %s>' % (
self.name, self.username, self.email)
class Podcast(Bookmark):
__tablename__ = 'podcast'
def __init__(self, **kwargs):
super(Podcast, self).__init__(**kwargs)
self.type = Bookmark.TYPE_PODCAST
id = db.Column(db.Integer, db.ForeignKey('bookmark.id'), primary_key=True)
name = db.Column(db.String(250))
description = db.Column(db.String(1024))
author = db.Column(db.String(250))
__mapper_args__ = {
'polymorphic_identity': 'podcast',
}
class RevokedTokenModel(db.Model):
'''class representing rovoked tokens table'''
__tablename__ = 'revoked_tokens'
id = db.Column(db.Integer, primary_key=True)
json_token_identifier = db.Column(db.String(120))
def save(self):
'''commit and save data from object'''
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, json_token_identifier):
'''check if token is blacklisted'''
query = cls.query.filter_by(
json_token_identifier=json_token_identifier).first()
return bool(query)
class Video(Bookmark):
__tablename__ = 'video'
def __init__(self, **kwargs):
super(Video, self).__init__(**kwargs)
self.type = Bookmark.TYPE_VIDEO
bookmark_id = db.Column(db.Integer,
db.ForeignKey('bookmark.id', ondelete='CASCADE'),
primary_key=True)
URL = db.Column(db.String(250))
timestamp = db.Column(db.Integer(), default=0)
bookmark = db.relationship('Bookmark',
foreign_keys="Video.bookmark_id",
backref=db.backref('video', lazy='dynamic'))
__mapper_args__ = {
'polymorphic_identity': 'video',
}
class Book(Bookmark):
__tablename__ = 'book'
def __init__(self, **kwargs):
super(Book, self).__init__(**kwargs)
self.type = Bookmark.TYPE_BOOK
bookmark_id = db.Column(db.Integer,
db.ForeignKey('bookmark.id', ondelete='CASCADE'),
primary_key=True)
ISBN = db.Column(db.String(17), unique=True)
writer = db.Column(db.String(250))
bookmark = db.relationship('Bookmark',
foreign_keys="Book.bookmark_id",
backref=db.backref('books', lazy='dynamic'))
image = db.Column(db.String(500))
__mapper_args__ = {
'polymorphic_identity': 'book',
}
class OrderProduct(db.Model):
__tablename__ = 'Order_Product'
order_id = db.Column(db.Integer,
db.ForeignKey('Order.order_id'),
primary_key=True)
item_id = db.Column(db.Integer,
db.ForeignKey('InventoryItem.item_id'),
primary_key=True)
item_qty = db.Column(db.Integer)
def __init__(self, order_id, item_id, qty):
self.order_id = order_id
self.item_id = item_id
self.item_qty = qty
def serialize(self):
return {
'order_id': self.order_id,
'item_id': self.item_id,
'item_qty': self.item_qty
}
class WorkItem(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
description = db.Column(db.String(120))
estimated_time = db.Column(db.Integer, default=0)
is_done = db.Column(db.Boolean, default=0)
created_by = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
shared_with = db.relationship('User', secondary=shared_with, lazy='subquery', backref=db.backref('user', lazy=True))
class Data(db.Model):
id = db.Column(db.Integer, primary_key=True)
costs = db.Column(db.Float)
spending_money_obj = db.Column(db.String(140))
comments = db.Column(db.Text)
created_date = db.Column(db.DateTime, default=datetime.now())
slug = db.Column(db.String(140), unique=True)
def __init__(self, *args, **kwargs):
super(Data, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.spending_money_obj:
self.slug = slugify(self.spending_money_obj)
def __repr__(self):
return f'< Data id: {self.id}, title: {self.spending_money_obj} >'
class Message(db.Model):
__tablename__ = "message"
__table_args__ = {"useexisting": True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
time = db.Column(db.DateTime, default=datetime.now())
content = db.Column(db.String(255))
email = db.Column(db.String(100))
title = db.Column(db.String(255))
def __init__(self, name, content, email, title):
self.name = name
self.content = content
self.email = email
self.title = title
def __repr__(self):
return "<User:%s>" % self.name
class Bookmark(Base):
__tablename__ = 'bookmark'
TYPE_BOOK = 1
TYPE_BLOG = 2
TYPE_PODCAST = 3
TYPE_VIDEO = 4
read_status = db.Column(db.Boolean, default=False)
read_date = db.Column(db.DateTime)
header = db.Column(db.String(50))
comment = db.Column(db.String(1024))
type = db.Column(db.Integer)
polymorphic_type = db.Column(db.String(50))
__mapper_args__ = {
'polymorphic_identity': 'bookmark',
"polymorphic_on": polymorphic_type,
}
class UserBooksModel(db.Model):
'''class representing users table'''
__tablename__ = 'user_books'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30),
db.ForeignKey('users.username'),
nullable=False)
book_id = db.Column(db.Integer, nullable=False)
date_borrowed = db.Column(db.DateTime)
date_returned = db.Column(db.DateTime)
return_status = db.Column(db.Boolean)
def __init__(self, username, book_id):
self.username = username
self.book_id = book_id
@classmethod
def date_format(cls, my_date):
'''method to return date format dd-mm-yyyy'''
return str(my_date.day) + '-' + str(my_date.month) + '-' + str(
my_date.year)
@classmethod
def find_user_book(cls, username, book_id):
'''filter by username and book'''
#book = cls.query.filter_by(username=username, book_id=book_id).first()
book = cls.query.filter_by(username=username,
book_id=book_id,
return_status=False).first()
return book
def borrow_book(self):
'''borrow a book'''
self.return_status = False
self.date_borrowed = date.today()
@classmethod
def user_history(cls, username):
'''return user book history'''
all_user_books = cls.query.filter_by(username=username).all()
history = []
for book in all_user_books:
date_returned = book.date_returned
if date_returned is not None:
date_returned = cls.date_format(date_returned)
if date_returned is None:
date_returned = "None"
date_borrowed = cls.date_format(book.date_borrowed)
details = dict(book_id=book.book_id,
date_borrowed=date_borrowed,
date_returned=date_returned,
returned=book.return_status)
history.append(details)
return history
@classmethod
def books_not_returned(cls, username):
'''return all user books not returned'''
unreturned_books = cls.query.filter_by(username=username).all()
unreturned_list = []
for book in unreturned_books:
if book.return_status is False:
date_borrowed = cls.date_format(book.date_borrowed)
details = dict(book_id=book.book_id,
date_borrowed=date_borrowed,
date_returned="None",
returned=book.return_status)
unreturned_list.append(details)
return {username: unreturned_list}
def save(self):
'''commit and save data from object'''
db.session.add(self)
db.session.commit()
def __repr__(self):
return '<name: %s, username: %s, email: %s>' % (
self.name, self.username, self.email)
class BookModel(db.Model):
'''class representing books table'''
__tablename__ = 'books'
book_id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(70))
title = db.Column(db.String(70), unique=True)
edition = db.Column(db.String(10))
status = db.Column(db.String(20))
copies = db.Column(db.Integer)
date_created = db.Column(db.DateTime)
date_modified = db.Column(db.DateTime)
def __init__(self, author, title, edition, copies, status):
self.author = author
self.title = title
self.edition = edition
self.copies = copies
self.status = status
self.date_created = datetime.now()
def save(self):
'''commit and save data from object'''
db.session.add(self)
db.session.commit()
@classmethod
def get_book_by_id(cls, book_id):
'''retrieve single book by id'''
return cls.query.filter_by(book_id=book_id).first()
@classmethod
def get_book_by_title(cls, title):
'''retrieve single book by title'''
return cls.query.filter_by(title=title).first()
@classmethod
def get_all_books(cls, limit=None):
'''retrieve all books'''
all_books = {}
result = cls.query.all()
if limit is not None:
'''if user sets limit'''
result = cls.query.limit(limit)
for book in result:
all_books[book.book_id] = {
"title": book.title,
"author": book.author,
"edition": book.edition,
"copies": book.copies,
"status": book.status
}
return all_books
def delete(self):
'''delete a book by id'''
db.session.delete(self)
db.session.commit()
def __repr__(self):
return '<title: %s, author: %s, edition: %s, copies: %s, status: %s>' % (
self.title, self.author, self.edition, self.copies, self.status)
from application.app import app, db
from werkzeug.security import generate_password_hash, check_password_hash
import logging
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
# email = db.Column(db.String(80), unique=True, nullable=False)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(120))
shared_with = db.Table('shared_with',
db.Column('work_item_id', db.Integer, db.ForeignKey('work_item.id'), primary_key=True),
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True)
)
class WorkItem(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
description = db.Column(db.String(120))
estimated_time = db.Column(db.Integer, default=0)
is_done = db.Column(db.Boolean, default=0)
created_by = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
shared_with = db.relationship('User', secondary=shared_with, lazy='subquery', backref=db.backref('user', lazy=True))
# user - WorkItem
# 1 1
# 2 1
# 3 2
# 3 1
class SubTask(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
description = db.Column(db.String(120))
work_item_id = db.Column(db.Integer, db.ForeignKey('work_item.id'), nullable=False)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
# email = db.Column(db.String(80), unique=True, nullable=False)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(120))
projects = relationship("Projects",
secondary="user_project",
backref='users')
def __repr__(self):
return (u'<{self.__class__.__name__}: {self.id}>'.format(self=self))
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
user_project = db.Table(
'user_project',
db.Column('project_id',
db.Integer,
db.ForeignKey('projects.id'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True))
class DbSkill(db.Model):
__tablename__ = 'skill'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
user = relationship('DbUserSkillAssociation', back_populates='skill')
