class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
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.FOLLOW | Permission.COMMENT
| Permission.WRITE_ARTICLES, True),
'Moderator':
(Permission.FOLLOW | Permission.COMMENT | Permission.WRITE_ARTICLES
| Permission.MODERATE_COMMENTS, False),
'Administrator': (0xff, False)
}
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.default = roles[r][1]
db.session.add(role)
db.session.commit()
def __repr__(self):
return '<Role %r>' % self.name
class Shipment(db.Model):
Shipment_ID = db.Column(db.String(12), primary_key=True, nullable=False)
Shipment_Note = db.Column(db.String(500))
Delivery_ID = db.Column(db.String(8),
db.ForeignKey('delivery.Delivery_ID'),
nullable=False)
delivery = db.relationship('Delivery',
backref=db.backref('delivery', lazy=True))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
fname = db.Column(db.String(80), unique=False, nullable=False)
lname = db.Column(db.String(80), unique=False, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), unique=False, nullable=False)
def __repr__(self):
return '<User %r>' % self.fname
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20))
pwd = db.Column(db.String(20))
blogs = db.relationship('Blog', backref='user')
def __init__(self, username, password):
self.username = username
self.paswword = password
class Follow(db.Model):
__tablename__ = 'follows'
follower_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
class Cart(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
User = db.relationship(User, backref=db.backref('users', lazy=True))
product_id = db.Column(db.Integer,
db.ForeignKey('addproduct.id'),
nullable=False)
Addproduct = db.relationship(Addproduct,
backref=db.backref('products', lazy=True))
quantity = db.Column(db.Integer, nullable=False)
class Blog(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
body = db.Column(db.String(200))
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __init__(self, title, body, owner):
self.title = title
self.body = body
self.owner = owner
class Item(db.Model):
"""Table listing all products that can be sold."""
__tablename__ = 'Items'
id = db.Column('Item_ID', db.Integer, primary_key=True)
item_type = db.Column(db.String(20))
item_description = db.Column(db.String(50))
def __init__(self, item_type, item_description):
self.item_type = item_type
self.item_description = item_description
class Concert(db.Model):
"""This table will list concert dates and venue."""
__tablename__ = 'Concert_List'
id = db.Column('Venue_ID', db.Integer, primary_key=True)
date = db.Column(db.String(20))
venue = db.Column(db.String(50))
def __init__(self, date, venue):
self.date = date
self.venue = venue
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
comments = db.relationship('Comment', backref='post', lazy='dynamic')
@staticmethod
def generate_fake(count=100):
from random import seed, randint
import forgery_py
seed()
user_count = User.query.count()
for i in range(count):
u = User.query.offset(randint(0, user_count - 1)).first()
p = Post(body=forgery_py.lorem_ipsum.sentences(randint(1, 5)),
timestamp=forgery_py.date.date(True),
author=u)
db.session.add(p)
db.session.commit()
# @staticmethod
# def on_changed_body(target, value, oldvalue, initiator):
# allowed_tags = ['a', 'abbr', 'acronym', 'b', 'blockquote', 'code',
# 'em', 'i', 'li', 'ol', 'pre', 'strong', 'ul',
# 'h1', 'h2', 'h3', 'p']
# target.body_html = bleach.linkify(bleach.clean(
# markdown(value, output_format='html'),
# tags=allowed_tags, strip=True))
def to_json(self):
json_post = {
'url':
url_for('api.get_post', id=self.id, _external=True),
'body':
self.body,
'body_html':
self.body_html,
'timestamp':
self.timestamp,
'author':
url_for('api.get_user', id=self.author_id, _external=True),
'comments':
url_for('api.get_post_comments', id=self.id, _external=True),
'comment_count':
self.comments.count()
}
return json_post
class Show(db.Model):
""" This is the table for the specific show, i.e. merch sold, total sales, etc. """
__tablename__ = 'Concert_Totals'
id = db.Column('Sales_Item', db.Integer, primary_key=True)
venue_id = db.Column(db.Integer, ForeignKey('Concert_List.Venue_ID'))
item_id = db.Column(db.Integer, ForeignKey('Items.Item_ID'))
items_sold = db.Column(db.Integer)
def __init__(self, venue_id, item_id, items_sold):
self.venue_id = venue_id
self.item_id = item_id
self.items_sold = items_sold
class Post(db.Model):
__searchable__ = ['title']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120), nullable=False)
content = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}','{self.date_posted}')"
likes = db.relationship('PostLike', backref='post', lazy='dynamic')
dislikes = db.relationship('PostDisLike', backref='post', lazy='dynamic')
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
disabled = db.Column(db.Boolean)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
# @staticmethod
# def on_changed_body(target, value, oldvalue, initiator):
# allowed_tags = ['a', 'abbr', 'acronym', 'b', 'code', 'em', 'i',
# 'strong']
# target.body_html = bleach.linkify(bleach.clean(
# markdown(value, output_format='html'),
# tags=allowed_tags, strip=True))
#
def to_json(self):
json_comment = {
'url': url_for('api.get_comment', id=self.id, _external=True),
'post': url_for('api.get_post', id=self.post_id, _external=True),
'body': self.body,
'body_html': self.body_html,
'timestamp': self.timestamp,
'author': url_for('api.get_user',
id=self.author_id,
_external=True),
}
return json_comment
class Faculty(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
# username = db.Column(db.String(20), unique = True, nullable =False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20), default='photo.jpeg')
password = db.Column(db.String(60), nullable=False)
course = db.Column(db.String(20), nullable=False)
def __repr__(self):
return f"User('{self.id}', '{self.image_file}', '{self.course}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('student.id'),
nullable=False)
author_name = db.Column(db.String(100))
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Good(db.Model):
__tablename__ = "GoodPython"
id = db.Column('id', db.Integer, primary_key=True)
name = db.column('name', db.String(80))
material = db.column('material', db.String(80))
amount = db.column('amount', db.Integer)
price = db.column('price', db.Integer)
def __init__(self, name="unknown", material="unknown", manufacturer="unknown", price=0, amount=0):
self.manufacturer = manufacturer
self.name = name
self.material = material
self.amount = amount
self.price = price
self.type = Types.GOOD.name
def to_string(self):
return "Type:", self.type, " Name:", self.name, " Material:", self.material, " Manufacturer:", self.manufacturer, " Price:", self.price, " Amount:", self.amount
def __repr__(self):
return '<User %r>' % self.name
class Student(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(35), nullable=False)
#username = db.Column(db.String(20), unique = True)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20), default='default.jpeg')
password = db.Column(db.String(60), nullable=False)
year = db.Column(db.String(20), default='x')
# dob = db.Column(db.DateTime, nullable = False, default = datetime.utcnow)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return Student.query.get(user_id)
class Faculty(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
# username = db.Column(db.String(20), unique = True, nullable =False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20), default='photo.jpeg')
password = db.Column(db.String(60), nullable=False)
course = db.Column(db.String(20), nullable=False)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return Faculty.query.get(user_id)
def __repr__(self):
return f"User('{self.id}', '{self.image_file}', '{self.course}')"
class Student(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(35), nullable=False)
#username = db.Column(db.String(20), unique = True)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20), default='default.jpeg')
password = db.Column(db.String(60), nullable=False)
year = db.Column(db.String(20), default='x')
# dob = db.Column(db.DateTime, nullable = False, default = datetime.utcnow)
# def get_reset_token(self, expires_sec = 1800):\
# s = Serializer(app.config['SECRET_KEY'], expires_sec)
# return s.dumps({'id': self.id}).decode('utf-8')
#
# def verify_reset_token(token):
# s = Serializer(app.config['SECRET_KEY'])
# try:
# id = s.load(token)['user_id']
# except:
# return None
# return User.query.ger
def __repr__(self):
return f"User('{self.id}', '{self.name}', '{self.image_file}')"
class PostLike(db.Model):
__tablename__ = 'like_post'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(30), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image_file}')"
def get_reset_token(self, expire_sec=1500):
s = Serializer(current_app.config['SECRET_KEY'], expire_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
liked = db.relationship('PostLike',
foreign_keys='PostLike.user_id',
backref='user',
lazy='dynamic')
disliked = db.relationship('PostDisLike',
foreign_keys='PostDisLike.user_id',
backref='user',
lazy='dynamic')
def like_post(self, post):
if not self.has_liked_post(post) and not self.has_disliked_post(post):
like = PostLike(user_id=self.id, post_id=post.id)
db.session.add(like)
def unlike_post(self, post):
if self.has_liked_post(post):
PostLike.query.filter_by(user_id=self.id, post_id=post.id).delete()
def has_liked_post(self, post):
return PostLike.query.filter(PostLike.user_id == self.id,
PostLike.post_id == post.id).count() > 0
def dislike_post(self, post):
if not self.has_liked_post(post) and not self.has_disliked_post(post):
dislike = PostDisLike(user_id=self.id, post_id=post.id)
db.session.add(dislike)
def has_disliked_post(self, post):
return PostDisLike.query.filter(PostDisLike.user_id == self.id,
PostDisLike.post_id
== post.id).count() > 0
def Undislike_post(self, post):
if self.has_disliked_post(post):
PostDisLike.query.filter_by(user_id=self.id,
post_id=post.id).delete()
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), index=True)
name = db.Column(db.String(64), unique=True, index=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
password_hash = db.Column(db.String(128))
confirmed = db.Column(db.Boolean, default=False)
real_name = db.Column(db.String(64))
location = db.Column(db.String(64))
about_me = db.Column(db.Text())
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
last_seen = db.Column(db.DateTime(), default=datetime.utcnow)
avatar_hash = db.Column(db.String(32))
posts = db.relationship('Post', backref='author', lazy='dynamic')
real_avatar = db.Column(db.String(128), default=None)
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
comments = db.relationship('Comment', backref='author', lazy='dynamic')
@staticmethod
def generate_fake(count=100):
from sqlalchemy.exc import IntegrityError
from random import seed
import forgery_py
seed()
for i in range(count):
u = User(email=forgery_py.internet.email_address(),
username=forgery_py.internet.user_name(True),
password=forgery_py.lorem_ipsum.word(),
confirmed=True,
name=forgery_py.name.full_name(),
location=forgery_py.address.city(),
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
db.session.add(u)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
@staticmethod
def add_self_follows():
for user in User.query.all():
if not user.is_following(user):
user.follow(user)
db.session.add(user)
db.session.commit()
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.role is None:
# if self.email == current_app.config['FLASKY_ADMIN']:
# self.role = Role.query.filter_by(permissions=0xff).first()
# if self.role is None:
self.role = Role.query.filter_by(default=True).first()
# if self.email is not None and self.avatar_hash is None:
# self.avatar_hash = hashlib.md5(
# self.email.encode('utf-8')).hexdigest()
self.followed.append(Follow(followed=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)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'confirm': self.id})
def confirm(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
if data.get('confirm') != self.id:
return False
self.confirmed = True
db.session.add(self)
db.session.commit()
return True
def generate_reset_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'reset': self.id})
def reset_password(self, token, new_password):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
if data.get('reset') != self.id:
return False
self.password = new_password
db.session.add(self)
db.session.commit() #
return True
def generate_email_change_token(self, new_email, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'change_email': self.id, 'new_email': new_email})
def change_email(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
if data.get('change_email') != self.id:
return False
new_email = data.get('new_email')
if new_email is None:
return False
if self.query.filter_by(email=new_email).first() is not None:
return False
self.email = new_email
self.avatar_hash = hashlib.md5(self.email.encode('utf-8')).hexdigest()
db.session.add(self)
db.session.commit() #
return True
def can(self, permissions):
return self.role is not None and \
(self.role.permissions & permissions) == permissions
def is_administrator(self):
return self.can(Permission.ADMINISTER)
def ping(self):
self.last_seen = datetime.utcnow()
db.session.add(self)
db.session.commit() #
def gravatar(self, size=100, default='identicon', rating='g'):
if request.is_secure:
url = 'https://secure.gravatar.com/avatar'
else:
url = 'http://www.gravatar.com/avatar'
hash = self.avatar_hash or hashlib.md5(
self.email.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
def follow(self, user):
if not self.is_following(user):
f = Follow(follower=self, followed=user)
db.session.add(f)
db.session.commit() #
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
db.session.delete(f)
db.session.commit()
def is_following(self, user):
return self.followed.filter_by(followed_id=user.id).first() is not None
def is_followed_by(self, user):
return self.followers.filter_by(
follower_id=user.id).first() is not None
@property
def followed_posts(self):
return Post.query.join(Follow, Follow.followed_id == Post.author_id)\
.filter(Follow.follower_id == self.id)
def to_json(self):
json_user = {
'url':
url_for('api.get_post', id=self.id, _external=True),
'username':
self.username,
'member_since':
self.member_since,
'last_seen':
self.last_seen,
'posts':
url_for('api.get_user_posts', id=self.id, _external=True),
'followed_posts':
url_for('api.get_user_followed_posts', id=self.id, _external=True),
'post_count':
self.posts.count()
}
return json_user
def generate_auth_token(self, expiration):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id}).decode('ascii')
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.query.get(data['id'])
def __repr__(self):
return '<User %r>' % self.username
class Locations(db.Model):
address = db.Column(db.String(150))
id = db.Column(db.Integer, primary_key=True)
class Merchant(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120),
db.ForeignKey('user.email'),
nullable=False)
class Addproduct(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), nullable=False)
price = db.Column(db.Numeric(10, 2), nullable=False)
discount = db.Column(db.Integer, default=0)
stock = db.Column(db.Integer, nullable=False)
desc = db.Column(db.Text, nullable=False)
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('categories', lazy=True))
image1 = db.Column(db.String(150), nullable=False, default='image1.jpg')
image2 = db.Column(db.String(150), nullable=False, default='image2.jpg')
image3 = db.Column(db.String(150), nullable=False, default='image3.jpg')
merchant_id = db.Column(db.Integer,
db.ForeignKey('merchant.id'),
nullable=False)
merchant = db.relationship('Merchant',
backref=db.backref('merchant', lazy=True))
merchant_name = db.Column(db.String(45), nullable=False)
merchant_phone = db.Column(db.String(8), nullable=False)
merchant_address = db.Column(db.Text, nullable=False)
def __repr__(self):
return '<Addproduct %r>' % self.name
class Delivery(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
User_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
product_id = db.Column(db.Integer,
db.ForeignKey('addproduct.id'),
nullable=False)
merchant_id = db.Column(db.Integer,
db.ForeignKey('merchant.id'),
nullable=False)
quantity = db.Column(db.Integer, nullable=False)
Delivery_ID = db.Column(db.String(8), nullable=False)
Delivery_Reg_Time = db.Column(db.Date, auto_now_add=True, nullable=False)
Delivery_Est_Date = db.Column(db.Date, nullable=False)
Delivery_Sender = db.Column(db.String(45),
db.ForeignKey('addproduct.merchant_name'),
nullable=False)
Delivery_Sender_Phone = db.Column(
db.String(8),
db.ForeignKey('addproduct.merchant_phone'),
nullable=False)
From_Address = db.Column(db.String(255),
db.ForeignKey('addproduct.merchant_address'),
nullable=False)
Delivery_Recipient = db.Column(db.String(45), nullable=False)
Delivery_Recipient_Phone = db.Column(db.String(8), nullable=False)
To_Address = db.Column(db.String(255), nullable=False)
Status_Reason = db.Column(db.String(255), nullable=True)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False, unique=True)
