class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.String, nullable=False)
security_question = db.Column(db.String, nullable=False)
security_answer = db.Column(db.String, nullable=False)
portfolios = db.relationship('PortfolioShell', backref='holder', lazy=True)
def __repr__(self):
return f"User('{self.username}')"
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
text = db.Column(db.Text(200), nullable=False)
chat_id = db.Column(db.Integer, db.ForeignKey('chat.id'), nullable=False)
sender = db.relationship('User', backref='sent_messages', lazy=True)
def __repr__(self):
return "User ({}, {})".format(self.sender_id, self.text)
class Application(db.Model):
id = db.Column(db.Integer, primary_key=True)
app_name = db.Column(db.String(20), nullable=False)
app_manager = db.Column(db.String(20))
support_group = db.Column(db.String(120))
additional_info = db.Column(db.Text)
jvms = db.relationship('Jvm', backref='application', lazy=True)
def __repr__(self):
return f"Application('{self.app_name}', '{self.app_manager}', '{self.additional_info}')"
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(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
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(20), unique=True, nullable=False)
mobile = db.Column(db.Integer, unique=True, nullable=False)
password = db.Column(db.String(20), nullable=False)
cartitems = db.relationship('Cart', backref='user', lazy=True)
def __repr__(self):
return f"User('{self.username}' , '{self.email}', '{self.mobile}')"
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 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 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 User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64),
index=True,
unique=True,
nullable=False)
password_hash = db.Column(db.String, nullable=False)
salt = db.Column(db.String)
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __repr__(self):
return '<username: {}>'.format(self.username)
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 Assignments(db.Model):
__tablename__ = 'assignments'
assignments_id = db.Column(db.INTEGER, primary_key=True)
assignments_title = db.Column(db.String(120))
assignments_description = db.Column(db.String(120))
assignments_course = db.Column(db.INTEGER,
db.ForeignKey('course.course_id'))
sharedfile = db.relationship('SharedFile',
backref='sharedfile_assign',
lazy='dynamic')
class Course(db.Model):
__tablename__ = 'course'
course_id = db.Column(db.INTEGER, primary_key=True)
course_title = db.Column(db.String(120))
course_description = db.Column(db.String(120))
course_date = db.Column(db.String(120))
syllabes = db.relationship('Syllabes',
backref='course_syllabes',
lazy='dynamic')
assignment = db.relationship('Assignments',
backref='course_assignments',
lazy='dynamic')
resources = db.relationship('Resources',
backref='course_resources',
lazy='dynamic')
sharedfile = db.relationship('SharedFile',
backref='course_file',
lazy='dynamic')
news = db.relationship('NewsCourse', backref='course_news', lazy='dynamic')
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
blurb = db.Column(
db.String) #acts as TLDR for the project (not just blurb)
type_project = db.Column(db.String)
url = db.Column(db.String, unique=True)
abs_url = db.Column(db.String, unique=True)
status = db.Column(db.Integer)
posts = db.relationship('Post', backref='Project', lazy='dynamic')
def __repr__(self):
return '<Project: {}>'.format(self.title)
class Article(Document):
"""Blog article."""
category_id = db.Column(db.Integer,
db.ForeignKey('categories.id'),
nullable=False)
title = db.Column(db.String, nullable=False)
lead = db.Column(db.String, nullable=False)
body = db.Column(db.Text, nullable=False)
category = db.relationship('Category', back_populates='articles')
_tags = db.relationship('Tag',
order_by='Tag.uri',
collection_class=TagList,
secondary='article_tags',
back_populates='articles')
@hybrid_property
def tags(self) -> TagList:
"""Return sorted tags."""
return self._tags
@tags.setter
def tags(self, value: Iterable):
"""Sort tags when overwriting them."""
self._tags = TagList(value)
@classmethod
def latest_ones(cls) -> Iterator['Article']:
"""Return articles ordered by publication date, in descending order.
More precisely, articles are sorted by:
- publication date in descending order first,
- primary key in ascending order then.
"""
return cls.query.order_by(cls.publication_date.desc(), cls.id.desc())
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
anonid = db.Column(db.String(12), nullable=False, unique=True)
title = db.Column(db.String(100), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
image = db.Column(db.String(100), unique=True)
content = db.Column(db.Text, nullable=False)
public = db.Column(db.Boolean, default=True, nullable=False)
forSale = db.Column(db.Boolean, default=False, nullable=False)
price = db.Column(db.Float, default=0.0, nullable=False)
discount = db.Column(db.Float, default=0.0, nullable=False)
# relationships
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
replies = db.relationship('Reply', backref='original', lazy=True)
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 SharedFile(db.Model):
__tablename__ = 'sharedfile'
shared_file_id = db.Column(db.INTEGER, primary_key=True)
shared_file_title = db.Column(db.String(120))
shared_file_path = db.Column(db.LargeBinary)
resources = db.relationship('Resources',
backref='sharedfile_res',
lazy='dynamic')
author = db.Column(db.INTEGER, db.ForeignKey('user.user_id'))
course = db.Column(db.INTEGER, db.ForeignKey('course.course_id'))
assignment = db.Column(db.INTEGER,
db.ForeignKey('assignments.assignments_id'))
class Course(db.Model):
id = db.Column(db.Integer, primary_key=True)
posts = db.relationship('Post', backref='course', lazy='dynamic')
slides = db.relationship('Slide', backref='course', lazy='dynamic')
uploadedhomework = db.relationship('UploadedHomework',
backref='course',
lazy='dynamic')
teachers = db.relationship('Professor',
secondary=teachers_courses,
backref='course',
lazy='dynamic')
students = db.relationship('Student',
secondary=students_courses,
backref='course',
lazy='dynamic')
term_id = db.Column(db.Integer, db.ForeignKey('term.id'))
title = db.Column(db.String(120), nullable=True)
minor_title = db.Column(db.String(250), nullable=True)
video_url = db.Column(db.String(120), nullable=True)
about = db.Column(db.Text, nullable=True)
syllabus = db.Column(db.Text, nullable=True)
homework = db.Column(db.Text, nullable=True)
resources = db.Column(db.Text, nullable=True)
degree = db.Column(db.String(120), nullable=True)
def toJSON(self):
return {
'id': self.id,
'title': self.title,
'term': self.term.year,
'video_url': self.video_url,
'about': self.about,
'syllabus': self.syllabus,
'homwork': self.homework,
'resources': self.resources,
'degree': self.degree
}
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 Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(20), nullable=False)
description = db.Column(db.String(1000), nullable=False)
price = db.Column(db.Integer, nullable=False)
size = db.Column(db.String(5), nullable=False)
color = db.Column(db.String(10), nullable=False)
image_link = db.Column(db.String(500), nullable=False)
number = db.Column(db.Integer, nullable=False)
category = db.Column(db.String(20), nullable=False)
sub_category = db.Column(db.String(20), nullable=False)
cartitems = db.relationship('Cart', backref='specificitem', lazy=True)
def __repr__(self):
return f"Item('{self.title}' , '{self.description}', '{self.price}')"
class User(db.Model, UserMixin):
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))
rank = db.Column(db.Integer)
levels = db.relationship('Levels', backref='author', 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 __repr__(self):
return f"User('{self.username}', '{self.email}')"
class Professor(db.Model):
id = db.Column(db.Integer, primary_key=True)
user = db.relationship('User', backref='professor', uselist=False)
field_of_study = db.Column(db.String(100), nullable=True)
degree = db.Column(db.String(30), nullable=True)
level = db.Column(db.String(30), nullable=True)
def toJSON(self):
return {
'id': self.user.id,
'firstname': self.user.first_name,
'lastname': self.user.last_name,
'img_url': self.user.img_url,
'field_of_study': self.field_of_study,
'degree': self.degree,
'level': self.level,
}
class BlogPost(db.Model):
users = db.relationship(User)
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
title = db.Column(db.String(140), nullable=False)
text = db.Column(db.Text, nullable=False)
def __init__(self, title, text, user_id):
self.title = title
self.text = text
self.user_id = user_id
def __repr__(self):
return f"Post ID: {self.id} -- Date: {self.date} --- {self.title}"
class Schema(db.Model):
__tablename__ = 'schema'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
slug = db.Column(db.String(200))
separate = db.Column(db.String(200))
created_at = db.Column(db.DateTime, default=datetime.now())
user = db.Column(db.ForeignKey('user.id'), nullable=False)
order = db.Column(db.Integer)
columns = db.relationship("ColumnSchema")
def __init__(self, *args, **kwargs):
if not 'slug' in kwargs:
kwargs['slug'] = slugify(kwargs.get('name', ''))
super().__init__(*args, **kwargs)
def __repr__(self):
return f'Схема {self.name} создана {self.user}'
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(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800): #30min
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)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.password}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(150), unique=True)
password = db.Column(db.String(150))
first_name = db.Column(db.String(150))
notes = db.relationship('Note')
class Category(db.Model): # type: ignore
__tablename__ = "categories"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(100), index=True, unique=True, nullable=False)
slug = db.Column(db.String(200), unique=True, nullable=False)
description = db.Column(db.String(150), nullable=False)
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())
blogs = db.relationship("Blog",
secondary=association_table,
backref="categories")
def __repr__(self):
return f"<Category {self.title}>"
@classmethod
def new(
cls,
title: str,
slug: str,
description: str,
):
"""
Create a new Category in the database.
Returns a Category.
"""
category = cls(
title=title,
slug=slug,
description=description,
)
db.session.add(category)
db.session.commit()
return category
# Mutators
def update(self, **kwargs):
"""
Update Category.
"""
allowed_attributes = ["title", "description"]
for key, value in kwargs.items():
assert key in allowed_attributes
setattr(self, key, value)
db.session.commit()
def delete(self):
"""
Delete Category.
"""
db.session.delete(self)
db.session.commit()
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 Club(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
country_id = db.Column(db.Integer, db.ForeignKey('country.id'))
country = db.relationship('Country')
