class User(db.Model, UserMixin):
__tablename__ = 'user'
user_id = db.Column(db.INTEGER, primary_key=True)
user_name = db.Column(db.String(120), nullable=False)
user_qq = db.Column(db.String(120))
user_mail = db.Column(db.String(120))
password = db.Column(db.String(120))
post = db.relationship('Post', backref='author', lazy='dynamic')
roles = db.relationship('Role', secondary='user_roles')
course_auth = db.relationship('Course',
secondary=course_author,
backref=db.backref('course'))
sharedfile = db.relationship('SharedFile',
backref='author_shared',
lazy='dynamic')
# Flask-Login integration
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.user_id
def __unicode__(self):
return self.user_name
class Post(db.Model):
__tablename__ = 'post'
post_id = db.Column(db.INTEGER, primary_key=True)
author_id = db.Column(db.INTEGER, db.ForeignKey('user.user_id'))
post_date = db.Column(db.DateTime)
post_content = db.Column(db.Text)
post_title = db.Column(db.String(120), nullable=False)
category_id = db.Column(db.INTEGER, db.ForeignKey('category.cat_id'))
post_modified_date = db.Column(db.DateTime)
tags = db.relationship('Tags',
secondary=post_tags,
backref=db.backref('tags', lazy='dynamic'))
def __unicode__(self):
return self.user_name
def to_json(self):
return {
'post_id': self.post_id,
'author': self.author.user_name,
'post_date': self.post_date,
'post_content': self.post_content,
'post_title': self.post_title,
'category_id': self.cat.cat_name,
'post_modified_date': self.post_modified_date,
}
class Comment(db.Model):
N = 3
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
content = db.Column(db.String(256))
timestamp = db.Column(db.DateTime(), default=datetime.utcnow, index=True)
path = db.Column(db.Text, index=True)
parent_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
replies = db.relationship('Comment',
backref=db.backref('parent', remote_side=[id]),
lazy='dynamic')
def save(self):
db.session.add(self)
db.session.commit()
prefix = self.parent.path + '.' if self.parent else ''
self.path = prefix + '{:0{}d}'.format(self.id, self._N)
db.session.commit()
def level(self):
return len(self.path) // self._N - 1
def __repr__(self):
return f"Comment('{self.timestamp}')"
class Catalog(db.Model):
id = db.Column(db.Integer, primary_key=True)
catalog_type = db.Column(db.Enum(CatalogTypes), default=CatalogTypes.RULES)
point_value = db.Column(db.Integer, default=1)
sponsor_id = db.Column(db.Integer, db.ForeignKey("sponsor.id"))
sponsor = db.relationship("Sponsor", back_populates="catalog")
categories = db.relationship("Category",
secondary=catalog_category,
lazy="subquery",
backref=db.backref("catalogs", lazy=True))
items = db.relationship("Item",
secondary=catalog_item,
lazy="subquery",
backref=db.backref("catalogs", lazy=True))
rules = db.relationship("Rule",
secondary=catalog_rule,
lazy="subquery",
backref=db.backref("catalogs", lazy=True))
class Brain_mri(db.Model):
id = db.Column(db.Integer, primary_key=True)
pat_id = db.Column(db.Integer,
db.ForeignKey('patient.id', ondelete='CASCADE'),
nullable=False)
pat = db.relationship('Patient', backref=db.backref('allpost', lazy=True))
patient_mri = db.Column(db.String(150), nullable=False)
patient_doc = db.Column(db.String(150), nullable=False)
is_tumor = db.Column(db.Boolean, nullable=True, default=False)
is_done = db.Column(db.Boolean, nullable=False, default=False)
date = db.Column(db.DateTime, nullable=True)
class AdminToUser(db.Model):
id = db.Column(db.Integer, primary_key=True)
admin_id = db.Column(db.Integer,
db.ForeignKey('admin.id', ondelete='CASCADE'),
nullable=False)
admins = db.relationship('Admin',
backref=db.backref('mydb',
lazy=True,
passive_deletes=True))
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
users = db.relationship('User',
backref=db.backref('mydb',
lazy=True,
passive_deletes=True))
subject = db.Column(db.String(6000), nullable=False)
message = db.Column(db.String(6000), nullable=False)
date = db.Column(db.DateTime, nullable=True)
read = db.Column(db.Boolean, nullable=False, default=False)
class Chat(db.Model):
id = db.Column(db.Integer, primary_key=True)
users = db.relationship('User',
secondary=chat_user,
lazy='subquery',
backref=db.backref('chats', lazy=True))
messages = db.relationship('Message', backref='chat', lazy=True)
def __repr__(self):
return "User ({}, {})".format(self.sender_id, self.text)
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, default=datetime.utcnow)
status = db.Column(db.Enum(Status), default=Status.ORDERED)
sponsorship_id = db.Column(db.Integer,
db.ForeignKey("sponsorship.id"),
nullable=False)
address_id = db.Column(db.Integer,
db.ForeignKey('address.id'),
nullable=False)
address = db.relationship("Address",
backref=db.backref("order", uselist=False),
lazy=True)
items = db.relationship("Item",
secondary=order_item,
lazy="subquery",
backref=db.backref("orders", lazy=True))
def __repr__(self):
return f"Order {self.id}"
class AdminToAllUsers(db.Model):
id = db.Column(db.Integer, primary_key=True)
admin_id = db.Column(db.Integer,
db.ForeignKey('admin.id', ondelete='CASCADE'),
nullable=False)
admins = db.relationship('Admin',
backref=db.backref('post',
lazy=True,
passive_deletes=True))
subject = db.Column(db.String(6000), nullable=False)
message = db.Column(db.String(6000), nullable=False)
date = db.Column(db.DateTime, nullable=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_type = db.Column(db.Enum(UserTypes), nullable=False)
first_name = db.Column(db.String(20), nullable=False)
last_name = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
picture = db.Column(db.String(120), default="default_user.jpg")
employer_id = db.Column(db.Integer,
db.ForeignKey("sponsor.id"),
nullable=True)
address_id = db.Column(db.Integer,
db.ForeignKey('address.id'),
nullable=True)
issue_alert = db.Column(db.Boolean, default=True)
order_alert = db.Column(db.Boolean, default=True)
points_alert = db.Column(db.Boolean, default=True)
address = db.relationship("Address",
backref=db.backref("user", uselist=False),
lazy=True)
sponsorships = db.relationship("Sponsorship", backref="driver", lazy=True)
support_tickets = db.relationship("SupportTicket",
backref="user",
lazy=True)
def __repr__(self):
return f"{self.first_name} {self.last_name}"
def active_sponsors(self):
return list(sponsorship.sponsor for sponsorship in self.sponsorships
if sponsorship.active)
def applied_sponsors(self):
return list(sponsorship.sponsor for sponsorship in self.sponsorships
if not sponsorship.active)
def all_sponsors(self):
return list(sponsorship.sponsor for sponsorship in self.sponsorships)
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 User.query.get(user_id)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
marked_problems = db.relationship(
'Problem', secondary=marked,
primaryjoin=(marked.c.user_id==id),
secondaryjoin="marked.c.problem_id==Problem.id",
backref=db.backref('markers', lazy='dynamic'), lazy='dynamic')
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)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{'reset_password': self.id, 'exp': time() + expires_in},
app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')
def is_marked(self, problem):
return self.marked_problems.filter(marked.c.problem_id == problem.id).count() > 0
def mark(self, problem):
if not self.is_marked(problem):
self.marked_problems.append(problem)
def unmark(self, problem):
if self.is_marked(problem):
self.marked_problems.remove(problem)
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token, app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
def __repr__(self):
return '<User {}>'.format(self.username)
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), unique=True, nullable=False)
slug = db.Column(db.String(200), unique=True, nullable=False)
body = db.Column(db.String(6000), nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id', ondelete='CASCADE'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('allpost', lazy=True))
image = db.Column(db.String(150),
nullable=False,
default='blog-list-01.jpg')
user_id = db.Column(db.Integer,
db.ForeignKey('authors.id', ondelete='CASCADE'),
nullable=False)
author = db.relationship('Authors',
backref=db.backref('allpost',
lazy=True,
passive_deletes=True))
date_pub = db.Column(db.DateTime, nullable=True)
draft = db.Column(db.Boolean, nullable=False, default=True)
status = db.Column(db.Integer, nullable=True, default=None)
fair_id = db.Column(db.Integer, nullable=True)
class Blogpost(db.Model):
__searchable__ = ['title', 'body']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), unique=True, nullable=False)
slug = db.Column(db.String(200), unique=True, nullable=False)
body = db.Column(db.String(6000), nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id', ondelete='CASCADE'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('post', lazy=True))
image = db.Column(db.String(150),
nullable=False,
default='blog-list-01.jpg')
user_id = db.Column(db.Integer,
db.ForeignKey('authors.id', ondelete='CASCADE'),
nullable=False)
author = db.relationship('Authors',
backref=db.backref('post',
lazy=True,
passive_deletes=True))
views = db.Column(db.Integer, default=0, nullable=False)
date_pub = db.Column(db.DateTime, nullable=True)
rough_id = db.Column(db.Integer, nullable=True)
class Sponsorship(db.Model):
id = db.Column(db.Integer, primary_key=True)
points = db.Column(db.Integer, default=0)
active = db.Column(db.Boolean, default=False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
sponsor_id = db.Column(db.Integer,
db.ForeignKey("sponsor.id"),
nullable=False)
cart = db.relationship("Item",
secondary=in_cart,
lazy="subquery",
backref=db.backref("carts", lazy=True))
orders = db.relationship("Order", backref="sponsorship", lazy=True)
def __repr__(self):
return f"{self.driver} and {self.sponsor}"
class Comment(db.Model): # type: ignore
__tablename__ = "comments"
id = db.Column(db.Integer(), primary_key=True)
body = db.Column(db.String(200), nullable=False)
path = db.Column(db.Text(), index=True)
created_at = db.Column(
db.DateTime(timezone=True),
server_default=sql.func.current_timestamp(),
nullable=False,
)
updated_at = db.Column(
db.DateTime(timezone=True),
onupdate=sql.func.current_timestamp(),
)
thread_at = db.Column(
db.DateTime(timezone=True),
server_default=sql.func.current_timestamp(),
nullable=False,
)
replies = db.relationship(
"Comment",
cascade="all, delete",
backref=db.backref("parent", remote_side=[id]),
lazy="dynamic",
)
author_id = db.Column(db.Integer(), db.ForeignKey("accounts.id"))
blog_id = db.Column(db.Integer(),
db.ForeignKey("blogs.id"),
nullable=False)
parent_id = db.Column(db.Integer(), db.ForeignKey("comments.id"))
def __repr__(self):
return f"<Comment {self.id} - {self.body}>"
# Factories
@classmethod
def new(
cls,
*,
body: str,
author: Any,
blog: Any,
parent: Optional[Any] = None,
thread_at: Optional[datetime.datetime] = None,
):
# TODO: Make this a transaction
comment = cls(
body=body,
author=author,
blog=blog,
parent=parent,
thread_at=thread_at,
)
db.session.add(comment)
db.session.commit()
comment.updated_at = None
prefix = f"{comment.parent.path}." if comment.parent else ""
comment.path = prefix + "{:0{}d}".format(comment.id, NUMBER_OF_DIGITS)
db.session.commit()
return comment
# Mutators
def update(self, **kwargs):
"""
Update Comment.
"""
allowed_attributes = [
"body",
"author",
]
for key, value in kwargs.items():
assert key in allowed_attributes
setattr(self, key, value)
db.session.commit()
def delete(self):
"""
Delete Comment.
"""
db.session.delete(self)
db.session.commit()
# Properties
@property
def level(self):
return len(self.path) // NUMBER_OF_DIGITS - 1
class Page(db.Model):
id = db.Column(db.Integer, primary_key=True)
tags = db.relationship('Tag',
secondary=tags,
lazy='subquery',
backref=db.backref('pages', lazy=True))
