class first_crawl(db.Model):
__tablename__ = 'first_crawl'
ID = db.Column(db.Integer, primary_key=True, autoincrement=True)
Title = db.Column(db.String(255), nullable=False)
NewsURL = db.Column(db.String(255), nullable=False)
src = db.Column(db.String(40), nullable=False)
time = db.Column(db.String(20), nullable=False)
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 Role(db.Model):
__tablename__ = 'roles'
role_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
role_name = db.Column(db.String(64), unique=True)
users = db.relationship('Users', backref='role')
def __init__(self, role_name):
self.role_name = role_name
class Artical_class(db.Model):
__tablename__ = 'artical_class'
ac_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ac_class = db.Column(db.String(64), nullable=False)
articals = db.relationship('Artical', backref='artical_class')
def __init__(self, ac_class):
self.ac_class = ac_class
class Item(db.Model):
__tablename__ = 'item'
id = db.Column('id', db.Integer, primary_key=True)
name_item = db.Column('name_item', db.String(200), unique=False)
price_item = db.Column('price_item', db.Integer, unique=False)
cat_id_choose = db.Column('cat_item', db.Integer, unique=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
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 Comment(db.Model):
__tablename__ = 'comments'
comment_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
comment_content = db.Column(db.Text, nullable=False)
artid = db.Column(db.Integer, db.ForeignKey(Artical.artical_id))
user_id = db.Column(db.Integer, db.ForeignKey(Users.user_id))
def __init__(self, comment_content,artid,user_id):
self.comment_content = comment_content
self.artid=artid
self.user_id=user_id
class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
status = db.Column(db.Integer, default=1)
created_time = db.Column(db.Integer, default=time.time())
updated_time = db.Column(db.Integer, default=time.time())
users = db.relationship('User', backref='role', lazy='dynamic')
def __init__(self, name):
self.name = name
class Employee(db.Model):
id = db.Column(db.Integer, primary_key=True)
telegram_id = db.Column(db.Integer, unique=True, nullable=False)
name = db.Column(db.String(80), nullable=False)
added = db.Column(db.DateTime, default=datetime.datetime.now())
logs = db.relationship('Log', backref='employee')
def __init__(self, telegram_id, name):
self.telegram_id = telegram_id
self.name = name
def __repr__(self):
return '<Employee name is {}>'.format(self.name)
class Project(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
description = db.Column(db.String(200))
creation_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
created_on = db.Column(db.DateTime)
tasks = db.relationship('Task', backref='in_project')
users = db.relationship('User',
secondary=user_project,
backref=db.backref('assigned_projects',
lazy='dynamic'))
class Order(db.Model):
__tablename__ = "orders"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String, nullable=False)
sum_price = db.Column(db.Integer, nullable=False)
status = db.Column(db.Integer, nullable=False)
mail = db.Column(db.String, nullable=False)
name = db.Column(db.String, nullable=False)
phone = db.Column(db.String, nullable=False)
address = db.Column(db.String, nullable=False)
user = db.relationship("User")
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
dishes = db.Column(db.JSON)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
mail = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
orders = db.relationship("Order")
password_hash = db.Column(db.String(128), nullable=False)
@property
def password_(self):
raise AttributeError("Вам не нужно знать пароль!")
@password_.setter
def password_(self, password_):
self.password_ = generate_password_hash(password_)
def password_valid(self, password_):
return check_password_hash(self.password_hash, password_)
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
body_html = db.Column(db.Text)
comments = db.relationship('Comment', backref='post', lazy='dynamic')
@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))
class Account(db.Model):
__tablename__ = 'account'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
settings = db.Column(db.Text(), nullable=False)
timetables = db.relationship('TimeTable', backref='account', lazy=True)
running = db.relationship('Running', backref='account', lazy=True)
timestamp = db.Column(db.TIMESTAMP, nullable=False)
started = db.Column(db.Boolean, default=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
credit = db.Column(db.Integer, default=0)
subscription = db.Column(db.String(10), nullable=False, unique=True)
paid = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<Account %r>' % self.username
class second_crawl(db.Model):
__tablename__ = "second_crawl"
ID = db.Column(db.Integer, primary_key=True, autoincrement=True)
Title = db.Column(db.String(255), nullable=False)
content = db.Column(db.Text, nullable=False)
NewsURL = db.Column(db.String(255), nullable=False)
visit_time = db.Column(db.Integer, nullable=False)
src = db.Column(db.String(64), nullable=False)
time = db.Column(db.String(20), nullable=False)
class Log(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date, nullable=False)
start = db.Column(db.DateTime)
end = db.Column(db.DateTime)
out = db.Column(db.DateTime)
late = db.Column(db.Boolean, default=False)
worktime = db.Column(db.Integer)
employee_id = db.Column(db.Integer,
db.ForeignKey('employee.id'),
nullable=False)
def __repr__(self):
return '<Log id = {}>'.format(self.id)
class Task(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(200))
state = db.Column(db.String(100))
priority = db.Column(db.String(100))
in_project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
assigned_to_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class UserModel(db.Model):
__tablename__ = 'utenti'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(50), nullable=False)
ruolo = db.Column(db.String(20), default="studente", nullable=False)
# Salvataggio su db
def salva_sul_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def cerca_su_db(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def tutta_la_lista(cls):
def to_json(x):
return {
'username': x.username,
'password': x.password,
'role': x.ruolo
}
return {
'Utenti': list(map(lambda x: to_json(x), UserModel.query.all()))
}
@classmethod
def svuota_db(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} utenti cancellati'.format(num_rows_deleted)}
except:
return {'message': 'OPS. Qualcosa è andato storto.'}
class Users(UserMixin,db.Model):
__tablename__ = 'users'
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_name = db.Column(db.String(64), unique=True, nullable=False)
password_hash = db.Column(db.String(256), nullable=False)
user_email = db.Column(db.String(64), unique=True, nullable=False)
role_id = db.Column(db.Integer, db.ForeignKey(Role.role_id))
comments = db.relationship('Comment', backref='user')
# def __init__(self, user_name, user_email):
# self.user_name = user_name
# # self.password = password
# self.user_email = user_email
@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)
class Users(UserMixin, db.Model):
__tablename__ = 'user' #对应mysql数据库表
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, index=True)
pwd = db.Column(db.String(64), unique=True, index=True)
def __init__(self, name, pwd):
self.name = name
self.pwd = pwd
def get_id(self):
return self.id
def __repr__(self):
return '<User %r>' % self.name
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
class Dish(db.Model):
__tablename__ = "dishes"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
price = db.Column(db.Integer, nullable=False)
description = db.Column(db.String, nullable=False)
picture = db.Column(db.String, nullable=False)
category_id = db.Column(db.Integer, db.ForeignKey("categories.id"))
category = db.relationship("Category")
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
# personal info
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
re_pass = db.Column(db.String(100))
tasks = db.relationship('Task', backref='assigned_to')
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime())
accounts = db.relationship('Account', backref='user', lazy=True)
parent_id = db.Column(db.Integer, db.ForeignKey('user.id'))
affiliates = db.relationship("User")
def __repr__(self):
return '<User %r>' % self.email
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64))
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
status = db.Column(db.Integer, default=1)
created_time = db.Column(db.Integer, default=time.time())
updated_time = db.Column(db.Integer, default=time.time())
def __repr__(self):
return "<User %r>" % self.username
def __init__(self, username='', role_id=1):
self.username = username
self.role_id = role_id
class User(db.Model, flask_login.UserMixin):
__tablename__ = "User"
id = db.Column(db.Integer, primary_key=True)
account = db.Column(db.String(30), unique=True)
password = db.Column(db.String(30))
real_name = db.Column(db.String(100))
id_number = db.Column(db.String(100))
email = db.Column(db.String(120))
cellphone = db.Column(db.String(120))
def __init__(self, account, password, real_name=None, id_number=None, email=None, cellphone=None):
self.account = str(account)
self.password = str(password)
self.real_name = str(real_name)
self.id_number = str(id_number)
self.email = str(email)
self.cellphone = str(cellphone)
def check_user_account(self):
# 检测user的account是否已经存在
if User.query.filter_by(account=self.account).first() != None:
return False
else:
return True
def new_user(self):
# 创建新user
if self.check_user_account():
db.session.add(self)
db.session.commit()
return True
else:
return False
def check_password(self):
# 检测密码是否正确
user = User.query.filter_by(account=self.account).first()
if user == None:
return False
if self.password != user.password:
return False
else:
return user
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))
class Artical(db.Model):
__tablename__ = 'articals'
artical_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
artical_name = db.Column(db.String(64), nullable=False)
artical_summary = db.Column(db.Text, nullable=False)
artical_time = db.Column(db.DateTime, nullable=False)
artical_content = db.Column(db.Text, nullable=False)
acid = db.Column(db.Integer, db.ForeignKey(Artical_class.ac_id))
artical_comment = db.relationship('Comment', backref='artical')
def __init__(self, artical_name, artical_content, artical_time, artical_summary,acid):
self.artical_name = artical_name
self.artical_content = artical_content
self.artical_time = artical_time
self.artical_summary = artical_summary
self.acid=acid
class Category(db.Model):
__tablename__ = "categories"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
meals = db.relationship("Dish")
class Category(db.Model):
__tablename__ = 'category'
id = db.Column('id', db.Integer, primary_key=True)
name_category = db.Column('name_cat', db.String(50), unique=True)
from flask_login import UserMixin
from start import db
from datetime import datetime
# change --> flask db migrate --> flask db upgrade
user_project = db.Table(
'user_project',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('project_id',
db.Integer,
db.ForeignKey('project.id'),
primary_key=True))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
# personal info
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
re_pass = db.Column(db.String(100))
tasks = db.relationship('Task', backref='assigned_to')
