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 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 Blog(db.Model):
from datetime import datetime
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(20),
db.ForeignKey('buser.username'),
default=None)
title = db.Column(db.String(200), default='Untitled', nullable=False)
text = db.Column(db.String(100000), default=None)
created = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
edited = db.Column(db.DateTime, default=None)
custom_url = db.Column(db.String(200), default=None)
# public, private, unpublished
visibility = db.Column(db.String(20), default='public', nullable=False)
def __repr__(self):
return '<Blog %r>' % self.id
def markdown_text(self):
return markdown(self.text)
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 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 Blog(db.Model): # type: ignore
__tablename__ = "blogs"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(100), index=True, nullable=False)
slug = db.Column(db.String(200), unique=True, nullable=False)
description = db.Column(db.String(150))
body = db.Column(db.Text(), nullable=False)
published = db.Column(db.Boolean(), nullable=False, default=False)
comment = db.Column(db.Boolean(), nullable=False, default=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())
author_id = db.Column(db.Integer(),
db.ForeignKey("accounts.id"),
nullable=True)
comments = db.relationship("Comment",
cascade="all, delete",
backref="blog",
lazy=True)
def __repr__(self):
return f"<Blog {self.title}>"
# TODO: We need to prevent blank values.
# @orm.validates("title")
# def validate(self, key, value):
# assert value
# return value
# Factories
@classmethod
def new(
cls,
title: str,
slug: str,
body: str,
author: Any,
description: Optional[str] = None,
categories: Optional[List[Any]] = None,
published: bool = False,
comment: bool = False,
):
"""
Create a new Blog in the database.
Returns a Blog.
"""
blog = cls(
title=title,
slug=slug,
description=description,
body=body,
author=author,
published=published,
comment=comment,
)
if categories:
blog.categories = categories
db.session.add(blog)
db.session.commit()
return blog
# Mutators
def update(self, **kwargs):
"""
Update Blog.
"""
allowed_attributes = [
"title",
"description",
"body",
"author",
"categories",
"published",
"comment",
]
for key, value in kwargs.items():
assert key in allowed_attributes
setattr(self, key, value)
db.session.commit()
def delete(self):
"""
Delete Blog.
"""
db.session.delete(self)
db.session.commit()
# Properties
@property
def is_published(self) -> bool:
return self.published
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from sqlalchemy import sql
from website import db
association_table = db.Table(
"category_blog_association",
db.Column("blogs_id", db.Integer(), db.ForeignKey("blogs.id")),
db.Column("categories_id", db.Integer(), db.ForeignKey("categories.id")),
)
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(),
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
data = db.Column(db.String(10000))
date = db.Column(db.DateTime(timezone=True), default=func.now())
# here database name should be in lowercase
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
from website import db
from flask_login import UserMixin
from werkzeug.security import check_password_hash, generate_password_hash
authorities_users = db.Table('authorities-users',
db.Column('authority_id', db.Integer, db.ForeignKey(
'authority.id'), primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('user.id'), primary_key=True))
class Authority(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
authorities = db.relationship('Authority',
secondary=authorities_users, backref='user', lazy='dynamic')
first_name = db.Column(db.String(120), nullable=False)
last_name = db.Column(db.String(120), nullable=False)
username = db.Column(db.String(120), nullable=False)
password_hash = db.Column(db.String(120), nullable=False)
img_url = db.Column(db.String(120), nullable=True)
student_id = db.Column(db.Integer, db.ForeignKey('student.id'))
professor_id = db.Column(db.Integer, db.ForeignKey('professor.id'))
posts = db.relationship('Post', backref='user', lazy='dynamic')
verify = db.Column(db.Boolean,nullable=False)
def isAdmin(self):
for auth in self.authorities:
if auth.name == "Admin":
class UserRoles(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE'))
class Address(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), nullable=False)
person_id = db.Column(db.Integer,
db.ForeignKey('person.id'),
nullable=False)
class CommentLike(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
comment_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
class Course(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(40), unique=True)
CId = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
from website import db
from website.mod_student.models import Student
from website.mod_professor.models import Professor
teachers_courses = db.Table(
'teachers-courses',
db.Column('teacher_id',
db.Integer,
db.ForeignKey('professor.id'),
primary_key=True),
db.Column('course_id',
db.Integer,
db.ForeignKey('course.id'),
primary_key=True))
students_courses = db.Table(
'students-courses',
db.Column('student_id',
db.Integer,
db.ForeignKey('student.id'),
primary_key=True),
db.Column('course_id',
db.Integer,
db.ForeignKey('course.id'),
primary_key=True))
class Slide(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(120), nullable=False)
name = db.Column(db.String(120), nullable=False)
class UploadedHomework(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(120), nullable=False)
course_id = db.Column(db.Integer, db.ForeignKey('course.id'))
student_id = db.Column(db.Integer, db.ForeignKey('student.id'))
class Sale(db.Model):
id = db.Column(db.Integer, primary_key=True)
seller = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
buyer = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
class Profile(db.Model):
__tablename__ = 'profile'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
schemas = db.Column(db.String(50))
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)
chat_user = db.Table(
'tags',
db.Column('chat_id',
db.Integer,
db.ForeignKey('chat.id'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True))
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)
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')
class Goal(db.Model):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.Text, nullable=False)
completed = db.Column(db.Boolean, nullable=False, default=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
from datetime import datetime
from hashlib import md5
from time import time
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
import jwt
from website import app, db, login
marked = db.Table(
'marked', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('problem_id', db.Integer, db.ForeignKey('problem.id')))
class Problem(db.Model):
id = db.Column(db.Integer, primary_key=True)
problem_name = db.Column(db.String(64), index=True)
problem_link = db.Column(db.String(64), index=True, unique=True)
keywords = db.Column(db.String(140), index=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",
class Whitelist(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
movie_id = db.Column(db.String(20), nullable=False)
poster = db.Column(db.String(200))
from flask_user import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from website import db, app
post_tags = db.Table(
'post_tags', db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')),
db.Column('post_id', db.Integer, db.ForeignKey('post.post_id')))
class Tags(db.Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True)
tagname = db.Column(db.String(100))
course_author = db.Table(
'course_author',
db.Column('course_id', db.Integer, db.ForeignKey('course.course_id')),
db.Column('author_id', db.Integer, db.ForeignKey('user.user_id')))
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')
from datetime import datetime
from enum import Enum, unique
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from math import ceil
from website import db, login_manager, app
from flask_login import UserMixin
catalog_category = db.Table(
"catalog_category",
db.Column("catalog_id",
db.Integer,
db.ForeignKey("catalog.id"),
primary_key=True),
db.Column("category_id",
db.Integer,
db.ForeignKey("category.id"),
primary_key=True))
catalog_item = db.Table(
"catalog_item",
db.Column("catalog_id",
db.Integer,
db.ForeignKey("catalog.id"),
primary_key=True),
db.Column("item_id",
db.Integer,
db.ForeignKey("item.id"),
primary_key=True))
catalog_rule = db.Table(
"catalog_rule",
class PostLike(db.Model):
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 UserClassRelationship(db.Model):
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), primary_key=True)
class_id = db.Column(db.Integer,
db.ForeignKey("class.id"),
primary_key=True)
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
from website import db
tags_posts = db.Table(
'tags-posts',
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'), primary_key=True),
db.Column('post_id',
db.Integer,
db.ForeignKey('post.id'),
primary_key=True))
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
posts = db.relationship('Post', backref='category', lazy='dynamic')
class Slider(db.Model):
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
data = db.Column(db.String(10000))
date = db.Column(db.DateTime(timezone=True), default=func.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class Slider(db.Model):
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
