class Review(database.Model):
__searchable__ = ["title", "body"]
id = database.Column(database.Integer, primary_key=True)
title = database.Column(database.String(100), nullable=False)
rating = database.Column(database.Integer, nullable=False)
date_posted = database.Column(database.DateTime,
nullable=False,
default=datetime.utcnow)
body = database.Column(database.Text, nullable=False)
user_id = database.Column(database.Unicode(36),
database.ForeignKey("user.id"),
nullable=False)
product_id = database.Column(database.Integer,
database.ForeignKey("product.id"),
nullable=False)
@staticmethod
def generate_fake():
from random import seed, randint
import forgery_py
seed()
user_count = User.query.count()
product_count = Product.query.count()
for i in range(product_count):
user = User.query.offset(randint(0, user_count - 1)).first()
product = Product.query.offset(randint(0,
product_count - 1)).first()
review = Review(title=forgery_py.lorem_ipsum.words(randint(1, 5)),
body=forgery_py.lorem_ipsum.sentences(randint(
1, 3)),
author=user,
product=product)
database.session.add(review)
database.session.commit()
def __repr__(self):
return "Review('{}', '{}')".format(self.title, self.date_posted)
class Thread(database.Model):
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(64))
short_name = database.Column(database.String(32))
creator_id = database.Column(
database.Integer,
database.ForeignKey('users.id')
)
creation_timestamp = database.Column(
database.DateTime,
index=True,
default=datetime.utcnow
)
text = database.Column(database.String(1000))
posts = database.relationship('Post', backref='thread', lazy='dynamic')
forum_id = database.Column(
database.Integer,
database.ForeignKey('forum.id')
)
deleted = database.Column(database.Boolean, default=False)
def __repr__(self):
return '<Thread {}>'.format(self.name)
class Port(database.Model):
__tablename__ = 'port'
port_type = database.Column(database.String(7), nullable=False)
port_number = database.Column(database.SmallInteger, primary_key=True)
plug_type = database.Column(database.String(10), nullable=False)
station_name = database.Column(database.String(30),
database.ForeignKey('station.station_name'),
primary_key=True,
index=True)
station = database.relationship('Station', backref='ports')
def __repr__(self):
return '<Port {}, {}>'.format(self.port_number, self.station_name)
class User(UserMixin, database.Model):
def __init__(self, name, pwd, email_):
self.username = name
self.password = pwd
self.email = email_
__tablename__ = 'users'
id = database.Column(database.Integer, primary_key=True)
username = database.Column(database.String(64), unique=True, index=True)
password = database.Column(database.String(40), nullable=False)
fullname = database.Column(database.String(64), nullable=False)
avatar_src = database.Column(database.String(100))
birth = database.Column(database.Date)
experience_id = database.Column(database.Integer,
database.ForeignKey('experiences.id'))
experience = database.relationship('Experience',
backref=database.backref(
'users', lazy='dynamic'))
account_type_id = database.Column(database.Integer,
database.ForeignKey('roles.id'))
account_type = database.relationship('Role',
backref=database.backref(
'users', lazy='dynamic'))
email = database.Column(database.String(100), nullable=False)
phone = database.Column(database.String(11))
allowance = database.Column(database.Integer)
numoftours = database.Column(database.Integer)
status = database.Column(database.Integer)
def __repr__(self):
return '<User \'{}\'>'.format(self.username)
class Station(database.Model):
__tablename__ = 'station'
station_name = database.Column(database.String(30), primary_key=True)
mac_address = database.Column(database.String(19), nullable=False)
org_name = database.Column(database.String(20), nullable=False)
latitude = database.Column(database.Float, nullable=False)
longitude = database.Column(database.Float, nullable=False)
address_name = database.Column(database.String(30),
database.ForeignKey('address.address'),
nullable=False)
address = database.relationship('Address', backref='stations')
def __repr__(self):
return '<Station {}>'.format(self.station_name)
class Product(database.Model):
__searchable__ = ["name", "price"]
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(50), unique=True, nullable=False)
price = database.Column(database.Integer, nullable=False, default=0.00)
rating = database.Column(database.Integer, nullable=True, default=5)
description = database.Column(database.Text, nullable=False)
image_file = database.Column(
database.String(150),
unique=False,
nullable=True,
default="/static/profilePics/default_" +
str(random.randint(1,
len(os.listdir("app/static/profilePics")) + 1)) +
".jpg")
date_posted = database.Column(database.DateTime,
nullable=False,
default=datetime.utcnow)
company_id = database.Column(database.Unicode(36),
database.ForeignKey("company.id"),
nullable=True)
reviews = database.relationship("Review",
cascade="all,delete",
backref="product",
lazy="dynamic")
wishlist = database.relationship("User",
secondary=items,
backref=database.backref("wishlist",
lazy="dynamic"))
@staticmethod
def generate_fake():
from random import seed
import forgery_py
seed()
company_count = Company.query.count()
for i in range(company_count):
company = Company.query.offset(randint(0,
company_count - 1)).first()
product = Review(name=forgery_py.lorem_ipsum.words(randint(1, 3)),
price=forgery_py.monetary.money(),
description=forgery_py.lorem_ipsum.sentences(
randint(1, 3)),
company=company)
database.session.add(product)
database.session.commit()
class Citizen(database.Model):
import_id = database.Column(database.Integer,
database.ForeignKey('import.import_id'),
primary_key=True,
nullable=False)
citizen_id = database.Column(database.Integer,
primary_key=True,
nullable=False)
town = database.Column(database.String)
street = database.Column(database.String)
building = database.Column(database.String)
apartment = database.Column(database.Integer)
name = database.Column(database.String)
birth_date = database.Column(database.String)
gender = database.Column(database.String)
relatives = database.Column(database.String)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(50), nullable=False, unique=True)
is_admin = db.Column(db.Boolean, nullable=False, default=False)
password_hash = db.Column(db.String(100), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow)
redirect_to = db.Column(db.Integer, db.ForeignKey('forwarding.id'), nullable=True)
forwarding = db.relationship("Forwarding")
def __repr__(self):
return "<{}:{}>".format(self.id, self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class PatientService(database.Model):
__tablename__ = 'patient_services'
id = database.Column(database.Integer,
autoincrement=True,
primary_key=True,
info={'label': 'ID'})
provided_service = database.Column(database.String(255),
nullable=False,
info={'label': 'Service Provided'})
service_date = database.Column(database.Date,
nullable=False,
info={'label': 'Date'})
service_name = database.Column(database.String(100),
nullable=False,
info={'label': 'Name of Lab Test'})
service_type = database.Column(database.Enum('Hematology', 'Microbiology',
'Chemical Pathology',
'Histopathology',
'Immunology'),
nullable=False,
info={'label': 'Service Type'})
provider_name = database.Column(database.String(100),
nullable=False,
info={'label': 'Doctor Name'})
provider_source = database.Column(database.String(150),
nullable=False,
info={'label': 'Name of Hospital'})
cost = database.Column(database.DECIMAL,
nullable=False,
info={'label': 'Cost of Services'})
patient_id = database.Column(database.Integer,
database.ForeignKey('patient.id'),
nullable=False,
info={'label': 'Patient ID'})
patient = database.relationship(Patient,
backref=database.backref("services"),
lazy=True)
class Post(database.Model):
__tablename__ = "post"
id = database.Column("id",
database.Integer,
primary_key=True,
autoincrement=True)
posterId = database.Column("posterId", database.Integer,
database.ForeignKey("user.id"))
title = database.Column("title", database.Text, nullable=True)
content = database.Column("content", database.Text, nullable=True)
dateCreated = database.Column("dateCreated",
database.DateTime,
nullable=False,
default=datetime.datetime.utcnow())
dateUpdated = database.Column("dateUpdated",
database.DateTime,
nullable=False,
default=datetime.datetime.utcnow(),
onupdate=datetime.datetime.utcnow())
def __init__(self, posterId, title, content):
self.posterId = posterId
self.title = title
self.content = content
class UserPicture(database.Model):
__tablename__ = 'userPictures'
userId = database.Column(database.Integer, database.ForeignKey('userData.id'))
pictureId = database.Column(database.Integer, primary_key=True)
picturePath = database.Column(database.String(100), index=False, unique=True, nullable=False)
encoded = database.Column(database.Integer, index=False, unique=False, nullable=False)
from flask_security import UserMixin, RoleMixin
from time import time
from datetime import datetime
from app import database
from utils import slugify
# Post-Tag relationship table
post_tag_relation_database = database.Table(
'post_tag',
database.Column('post_id', database.Integer, database.ForeignKey('post.id')),
database.Column('tag_id', database.Integer, database.ForeignKey('tag.id')),
)
# Simplest post model
class Post(database.Model):
id = database.Column(database.Integer, primary_key=True)
title = database.Column(database.String(256))
slug = database.Column(database.String(256), unique=True)
body = database.Column(database.Text)
creation_date = database.Column(database.DateTime, default=datetime.now())
tags = database.relationship(
'Tag', secondary=post_tag_relation_database, backref=database.backref('posts'), lazy='dynamic'
)
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
if self.title:
self.slug = slugify(self.title, 'Post')
from datetime import datetime
from app import database
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from sqlalchemy.dialects.mysql import TIME
from hashlib import md5
student_identifier = database.Table(
'student_identifier',
database.Column('class_id', database.Integer,
database.ForeignKey('classes.id')),
database.Column('user_id', database.Integer,
database.ForeignKey('flasklogin-users.id')))
student_appt = database.Table(
'student_appt',
database.Column('appt_id', database.Integer,
database.ForeignKey('appts.id')),
database.Column('user_id', database.Integer,
database.ForeignKey('flasklogin-users.id')))
class Instance(database.Model):
id = database.Column(database.Integer, primary_key=True)
chat_enabled = database.Column(database.Boolean,
nullable=False,
default=True)
class Company(database.Model, UserMixin):
__searchable__ = ["name"]
id = database.Column(database.Unicode(36),
primary_key=True,
autoincrement=False)
name = database.Column(database.String(50), unique=True, nullable=False)
address = database.Column(database.String(100),
unique=True,
nullable=False)
city = database.Column(database.String(50), unique=False, nullable=False)
zip_code = database.Column(database.String(20),
unique=False,
nullable=False)
state = database.Column(database.String(25), unique=False, nullable=True)
country = database.Column(database.String(50),
unique=False,
nullable=False)
phone_number = database.Column(database.String(20),
unique=True,
nullable=False)
email = database.Column(database.String(80), unique=True, nullable=False)
image_file = database.Column(
database.String(150),
unique=False,
nullable=True,
default="/static/profilePics/default_" +
str(random.randint(1,
len(os.listdir("app/static/profilePics")) + 1)) +
".jpg")
website = database.Column(database.String(100), unique=True, nullable=True)
password = database.Column(database.String(100), nullable=False)
role_id = database.Column(database.Integer, database.ForeignKey("role.id"))
products = database.relationship("Product",
cascade="all,delete",
backref="company",
lazy="dynamic")
articles = database.relationship("Article",
cascade="all,delete",
backref="company",
lazy="dynamic")
def __init__(self, **kwargs):
super(Company, self).__init__(**kwargs)
self.role = Role.query.filter_by(name="Company").first()
def can(self, permissions):
return self.role is not None and (self.role.permissions
and permissions) == permissions
@staticmethod
def generate_fake():
from random import seed, randint
import forgery_py
seed()
for i in range(3):
company = Company(
name=forgery_py.name.company_name(),
address=forgery_py.address.street_address(),
city=forgery_py.address.city(),
zip_code=forgery_py.address.zip_code(),
state=forgery_py.address.state(),
country=forgery_py.address.country(),
phone_number=''.join(
["%s" % randint(0, 9) for num in range(0, 10)]),
email=forgery_py.email.address(),
website=forgery_py.forgery.internet.domain_name(),
password=forgery_py.basic.password())
database.session.add(company)
database.session.commit()
@property
def is_company(self):
return True
def set_role(self, role):
self.role = Role.query.filter_by(name=role).first()
class User(database.Model, UserMixin):
__searchable__ = ["firstname", "lastname", "username"]
id = database.Column(database.Unicode(36),
primary_key=True,
autoincrement=False)
firstname = database.Column(database.String(32),
unique=False,
nullable=False)
lastname = database.Column(database.String(32),
unique=False,
nullable=False)
username = database.Column(database.String(20),
unique=True,
nullable=False)
email = database.Column(database.String(80), unique=True, nullable=False)
image_file = database.Column(
database.String(150),
unique=False,
nullable=True,
default="/static/profilePics/default_" +
str(random.randint(1,
len(os.listdir("app/static/profilePics")) + 1)) +
".jpg")
occupation = database.Column(database.String(50),
unique=False,
nullable=True)
phone_number = database.Column(database.String(10),
unique=True,
nullable=True)
hometown = database.Column(database.String(50),
unique=False,
nullable=True)
bio = database.Column(database.Text, nullable=True)
password = database.Column(database.String(100), nullable=False)
role_id = database.Column(database.Integer, database.ForeignKey("role.id"))
articles = database.relationship("Article",
cascade="all,delete",
backref="author",
lazy="dynamic")
comments = database.relationship("Comment",
cascade="all,delete",
backref="commenter",
lazy="dynamic")
likes = database.relationship("Like",
cascade="all,delete",
backref="liker",
lazy="dynamic")
reviews = database.relationship("Review",
cascade="all,delete",
backref="reviewer",
lazy="dynamic")
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.role = Role.query.filter_by(name="User").first()
def can(self, permissions):
return self.role is not None and (self.role.permissions
and permissions) == permissions
@staticmethod
def generate_fake():
from random import seed
import forgery_py
seed()
for i in range(3):
user = User(firstname=forgery_py.name.first_name(),
lastname=forgery_py.name.last_name(),
username=forgery_py.internet.user_name(True),
email=forgery_py.email.address(),
password=forgery_py.basic.password())
database.session.add(user)
database.session.commit()
def get_reset_token(self, expires_sec=300):
secret_key = Serializer(current_app.config["SECRET_KEY"], expires_sec)
return secret_key.dumps({"user_id": self.id})
@property
def is_company(self):
return False
def set_role(self, role):
self.role = Role.query.filter_by(name=role).first()
@staticmethod
def verify_reset_token(token):
secret_key = Serializer(current_app.config["SECRET_KEY"])
try:
user_id = secret_key.loads(token)["user_id"]
except:
return None
return User.query.get(user_id)
def __repr__(self):
return "User('{}', '{}', '{}')".format(self.username, self.email,
self.image_file)
article_id = database.Column(database.Integer,
database.ForeignKey("article.id"),
nullable=False)
user_id = database.Column(database.Unicode(36),
database.ForeignKey("user.id"),
nullable=False)
def __repr__(self):
return "Like('{}', '{}', {}')".format(self.id, self.article_id,
self.user_id)
items = database.Table(
"items",
database.Column("user_id", database.Unicode(36),
database.ForeignKey("user.id")),
database.Column("product_id", database.Integer,
database.ForeignKey("product.id")))
class Permission:
WRITE_ARTICLES = 2
COMMENT = 4
MODERATE_COMMENTS = 8
MANAGE_PRODUCTS = 16
class Product(database.Model):
__searchable__ = ["name", "price"]
id = database.Column(database.Integer, primary_key=True)
