class Job(db.Model):
__tablename__ = "jobs"
id = db.Column(db.String(36), primary_key=True)
name = db.Column(db.String(128), index=True)
description = db.Column(db.String(128))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
complete = db.Column(db.Boolean, default=False)
def to_dict(self):
return {
"id": self.id,
"name": self.name,
"description": self.description,
"created_at": self.created_at.isoformat(),
"progress": self.get_progress(),
"complete": self.complete,
}
def from_dict(self, data):
for field in ["name", "description"]:
if field in data:
setattr(self, field, data[field])
def get_rq_job(self):
try:
rq_job = rq.job.Job.fetch(self.id, connection=current_app.redis)
except (redis.exceptions.RedisError, rq.exceptions.NoSuchJobError):
return None
return rq_job
def get_progress(self):
job = self.get_rq_job()
return job.meta.get("progress", 0) if job is not None else 100
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class User(db.Model,UserMixin):
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
def set_password(self,password):
self.password_hash = generate_password_hash(password)
def validate_password(self,password):
return check_password_hash(self.password_hash,password)
class Wish(db.Model):
__tablename__ = 'wish'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
description = db.Column(db.String(100))
create_date_time = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return 'Wish-{0} created at {1}: {2}.'.format(self.id,
self.create_date_time,
self.description)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True)
name = db.Column(db.String(20))
password = db.Column(db.String(20))
def __init__(self, username, name, password):
self.username = username
self.name = name
self.password = password
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 用户id
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码散列值
# 设置密码
def set_password(self, password):
self.password_hash = generate_password_hash(password)
# 验证密码
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(64), index=True)
sex = db.Column(db.String(10), nullable=False)
birthday = db.Column(db.Date, nullable=False)
wishes = db.relationship('Wish', backref='user', lazy='dynamic')
def add_wish(self, wish):
self.wishes.append(wish)
def __repr__(self):
return 'User {0} [{1}] Birthday {2}'\
.format(self.username, self.sex, self.birthday)
class Record(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 记录条目id
uid = db.Column(db.Integer, db.ForeignKey('user.id')) # 记录属于的用户id
date = db.Column(db.Date) # 日期
habit_id = db.Column(db.Integer, db.ForeignKey('habit.id', ondelete = 'CASCADE')) # 习惯id
habit_name = db.Column(db.String(20)) # 习惯名称
remark = db.Column(db.Text) # 备注
is_complete = db.Column(db.String(1)) # 是否完成
class User(UserMixin, db.Model):
__tablename__ = 'Users'
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))
# Backref must be the same as the Table name?
user_pods = db.relationship('Podcast', backref='Users', 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 '<User {}>'.format(self.username)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def __init__(self, username="", email=""):
self.username = username
self.email = email
def to_json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"active": self.active,
}
class Content(db.Model):
id = db.Column(db.INTEGER, primary_key=True)
user_id = db.Column(db.String(20), unique=False, nullable=True)
page_num = db.Column(db.INTEGER, unique=False, nullable=True)
img_url = db.Column(db.String(100), unique=False, nullable=True)
conf_x = db.Column(db.INTEGER, nullable=True)
conf_a = db.Column(db.INTEGER, nullable=True)
conf_k = db.Column(db.INTEGER, nullable=True)
def __repr__(self):
return f"Content('{self.user_id}','{self.page_num}','{self.img_url}','{self.conf_x}','{self.conf_a}','{self.conf_k}')"
class Team(db.Model):
"""
name: name of team
description: description of team
image: image url
publisher: main publisher for team
characters: characters in team
volumes: volumes that team appeard in
"""
__tablename__ = "Team"
name = db.Column(db.String(50), unique=True, primary_key=True)
description = db.Column(db.String, unique=False)
image = db.Column(db.String) # image url
appear = db.Column(db.String, unique=False)
num_appearances = db.Column(db.String, unique=False)
publisher_name = db.Column(db.String(150), db.ForeignKey('Publisher.name'))
team_publisher = db.relationship("Publisher",
back_populates="publisher_teams")
team_characters = db.relationship("Character",
secondary=characters_teams,
back_populates='character_teams')
team_volumes = db.relationship("Volume",
secondary=volumes_teams,
back_populates='volume_teams')
def __repr__(self):
return 'Team(name={}, description={}, image={}, publisher={}, appear={}, num_appearances={}'.format(
self.name,
self.description,
self.image,
self.team_publisher,
self.appear,
self.num_appearances,
) + ")"
def json_it(self):
c = []
for char in self.team_characters:
c += {'name': char.name, 'image': char.image}
v = []
for volume in self.team_volumes:
v += {'name': volume.name, 'image': volume.image}
ans = {
'appear': self.appear,
'description': self.description,
'image': self.image,
'name': self.name,
'num_appearances': self.num_appearances,
'publisher_name': self.publisher_name,
'image': self.image,
'num_appearances': self.num_appearances,
'team_characters': c,
'team_volumes': v
}
return ans
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):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_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.image_file}')"
class Volume(db.Model):
"""
image: image url
description: info on volume
count_of_issues: num issues in volume
start_year: when volume started
publisher: main publisher
characters: characters in volume
teams: teams in the characters
name: name of volume
"""
__tablename__ = "Volume"
image = db.Column(db.String) # image url
description = db.Column(db.String(200), unique=False)
start_year = db.Column(db.Integer, unique=False)
name = db.Column(db.String, unique=True, primary_key=True)
num_issues = db.Column(db.String)
publisher_name = db.Column(db.String(150), db.ForeignKey('Publisher.name'))
volume_publisher = db.relationship("Publisher",
back_populates="publisher_volumes")
volume_characters = db.relationship("Character",
secondary='characters_volumes',
back_populates="character_volumes")
volume_teams = db.relationship("Team",
secondary=volumes_teams,
back_populates='team_volumes')
def json_it(self):
t = []
for team in self.character_teams:
t += {'name': team.name, 'image': team.image}
c = []
for character in self.character_volumes:
c += {'name': character.name, 'image': character.image}
ans = {
'description': self.description,
'image': self.image,
'name': self.name,
'num_issues': self.num_issues,
'publisher_name': self.publisher_name,
'start_year': self.start_year,
'volume_teams': t,
'volume_characters': c
}
return ans
def __repr__(self):
return 'Volume(image={}, description={}, start_year={}, publisher={}, name={}, num_issues={}'.format(
self.image, self.description, self.start_year, self.publisher_name,
self.name, self.num_issues) + ")"
class Episode(db.Model):
#################################################
# All podcast episodes
#################################################
__tablename__ = 'Episodes_' + str(db.ForeignKey('Podcasts.id'))
id = db.Column(db.Integer, primary_key=True)
#user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
pod_id = db.Column(db.Integer, db.ForeignKey('Podcasts.id'))
epname = db.Column(db.String(128), index=True)
epnum = db.Column(db.String(64), index=True)
epdesc = db.Column(db.String(1024))
audio_path = db.Column(db.String(256))
eplink = db.Column(db.String(256), unique=True) # episode website link
# itunes info
it_sum = db.Column(db.String(1024))
it_subtitle = db.Column(db.String(256))
def __repr__(self):
return '<Episode {}>'.format(self.body)
class Student(db.Model):
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(60))
E_score = db.Column(db.String(100))
P_score = db.Column(db.String(100))
C_score = db.Column(db.String(100))
class Publisher(db.Model):
"""
name: the name of the publisher
address: address of publisher if given
city: city of publisher
state: state of publisher
deck: description
image: image url
characters: character publisher has worked with
volumes: volumes publisher has worked with
teams: teams publisher has worked with
"""
__tablename__ = "Publisher"
name = db.Column(db.String(50), unique=True, primary_key=True)
address = db.Column(db.String(100), unique=False) # maybe this one?
city = db.Column(db.String(20), unique=False)
state = db.Column(db.String(20), unique=False)
deck = db.Column(db.String, unique=False)
image = db.Column(db.String) # image url
publisher_characters = db.relationship(
"Character", back_populates="character_publisher")
publisher_volumes = db.relationship("Volume",
back_populates="volume_publisher")
publisher_teams = db.relationship("Team", back_populates="team_publisher")
# TsVector column used for searching.
tsvector_col = db.Column(TsVector)
# Create an index for the tsvector column
__table_args__ = (db.Index('publishers_tsvector_idx',
'tsvector_col',
postgresql_using='gin'), )
def __repr__(self):
return 'Publisher(name={}, address={}, city={}, state={}, deck={}, image={}, publisher_characters={},publisher_volumes={}, publisher_teams={}'.format(
self.name,
self.address,
self.city,
self.state,
self.deck,
self.image,
self.publisher_characters,
self.publisher_volumes,
self.publisher_teams,
) + ")"
def json_it(self):
list_t = []
for team in self.publisher_teams:
temp = {'name': team.name, 'image': team.image}
list_t.append(temp)
list_vol = []
for volume in self.publisher_volumes:
temp = {'name': volume.name, 'image': volume.image}
list_vol.append(temp)
list_char = []
for character in self.publisher_characters:
temp = {'name': character.name, 'image': character.image}
list_char.append(temp)
ans = {
'name': self.name,
'city': self.city,
'deck': self.deck,
'address': self.address,
'image': self.image,
'state': self.state,
'publisher_characters': list_char,
'publisher_teams': list_t,
'publisher_volumes': list_vol
}
return ans
# from afsiodfajf.database import Base # afsafsf is going to be our database name
from demo import db
characters_volumes = db.Table(
'characters_volumes',
db.Column('character_name', db.String(150),
db.ForeignKey('Character.name')),
db.Column('volume_name', db.String(100), db.ForeignKey('Volume.name')))
characters_teams = db.Table(
'characters_teams',
db.Column('character_name', db.String(200),
db.ForeignKey('Character.name')),
db.Column('team_name', db.String(250), db.ForeignKey('Team.name')))
volumes_teams = db.Table(
'volumes_teams',
db.Column('volume_name', db.String(200), db.ForeignKey('Volume.name')),
db.Column('team_name', db.String(150), db.ForeignKey('Team.name')))
class Character(db.Model):
"""
name: name of characters
birth: when the character was born
image: image url
gender: male or female
creator: creator name
volumes: volumes that character is in
teams: teams that character is in
publisher: publisher character is with
class Habit(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 习惯id
uid = db.Column(db.Integer, db.ForeignKey('user.id')) # 习惯属于的用户
habit_name = db.Column(db.String(20)) # 习惯名称
records = db.relationship('Record', backref='habit', lazy=True, cascade='all, delete-orphan', passive_deletes = True) # 包含的习惯记录
class Publisher(db.Model):
"""
name: the name of the publisher
address: address of publisher if given
city: city of publisher
state: state of publisher
deck: description
image: image url
characters: character publisher has worked with
volumes: volumes publisher has worked with
teams: teams publisher has worked with
"""
__tablename__ = "Publisher"
name = db.Column(db.String(50), unique=True, primary_key=True)
address = db.Column(db.String(100), unique=False) # maybe this one?
city = db.Column(db.String(20), unique=False)
state = db.Column(db.String(20), unique=False)
deck = db.Column(db.String, unique=False)
image = db.Column(db.String) # image url
publisher_characters = db.relationship(
"Character", back_populates="character_publisher")
publisher_volumes = db.relationship("Volume",
back_populates="volume_publisher")
publisher_teams = db.relationship("Team", back_populates="team_publisher")
def __repr__(self):
return 'Publisher(name={}, address={}, city={}, state={}, deck={}, image={}, publisher_characters={},publisher_volumes={}, publisher_teams={}'.format(
self.name,
self.address,
self.city,
self.state,
self.deck,
self.image,
self.publisher_characters,
self.publisher_volumes,
self.publisher_teams,
) + ")"
def json_it(self):
list_t = []
for team in self.publisher_teams:
list_t += {'name': team.name, 'image': team.image}
list_vol = []
for volume in self.publisher_volumes:
list_vol += {'name': volume.name, 'image': volume.image}
list_char = []
for character in self.publisher_characters:
print(character)
list_char += {'name': character.name, 'image': character.image}
ans = {
'name': self.name,
'city': self.city,
'deck': self.deck,
'address': self.address,
'image': self.image,
'state': self.state,
'publisher_characters': list_char,
'publisher_teams': list_t,
'publisher_volumes': list_vol
}
return ans
class Character(db.Model):
"""
name: name of characters
birth: when the character was born
image: image url
gender: male or female
creator: creator name
volumes: volumes that character is in
teams: teams that character is in
publisher: publisher character is with
appear: first appearance
real: real name if it exists
num_apperances: num of appearnces
"""
__tablename__ = "Character"
name = db.Column(db.String(150), unique=True, primary_key=True)
birth = db.Column(db.String(100), unique=False)
image = db.Column(db.String) # image url
gender = db.Column(db.String(10))
creator = db.Column(db.String(50), unique=False)
appear = db.Column(db.String, unique=False)
real = db.Column(db.String, unique=False)
num_appearances = db.Column(db.String, unique=False)
publisher_name = db.Column(db.String(150), db.ForeignKey('Publisher.name'))
character_publisher = db.relationship(
"Publisher", back_populates="publisher_characters")
character_volumes = db.relationship("Volume",
secondary=characters_volumes,
back_populates="volume_characters")
character_teams = db.relationship("Team",
secondary=characters_teams,
back_populates="team_characters")
def __repr__(self):
return 'Character(name={}, image={}, birth={}, gender={}, creator={}, publisher={}, appear={}, real={}, num_appearances={}'.format(
self.name, self.image, self.birth, self.gender, self.creator,
self.publisher_name, self.appear, self.real,
self.num_appearances) + ")"
def json_it(self):
t = []
for team in self.character_teams:
t += {'name': team.name, 'image': team.image}
v = []
for volume in self.character_volumes:
v += {'name': volume.name, 'image': volume.image}
ans = {
'name': self.name,
'appear': self.appear,
'birth': self.birth,
'character_publisher': self.character_publisher,
'creator': self.creator,
'gender': self.gender,
'image': self.image,
'num_appearances': self.num_appearances,
'real': self.real,
'character_teams': t,
'character_volumes': v
}
return ans
class Podcast(db.Model):
#################################################
# podcasts
#################################################
__tablename__ = 'Podcasts'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('Users.id'))
username = db.Column(db.String(64))
# basic info
author = db.Column(db.String(64), index=True)
podname = db.Column(db.String(128), index=True)
podlink = db.Column(db.String(256), unique=True)
image_path = db.Column(db.String(512))
poddesc = db.Column(db.String(1024))
buildtime = db.Column(db.DateTime, index=True, default=datetime.utcnow)
rsslink = db.Column(db.String(256), unique=True)
# itunes info
it_own_name = db.Column(db.String(64))
it_own_email = db.Column(db.String(256))
it_cat = db.Column(db.String(128))
it_subcat = db.Column(db.String(128))
it_sum = db.Column(db.String(1024))
it_subtitle = db.Column(db.String(256))
it_keys = db.Column(db.String(512))
it_explicit = db.Column(db.String(32))
pod_eps = db.relationship('Episode', backref='Podcasts', lazy='dynamic')
def __repr__(self):
return '<Podcast {}>'.format(self.body)
class Question(db.Model):
# questionnaire
id = db.Column(db.INTEGER, primary_key=True)
user_id = db.Column(db.String(20), unique=False, nullable=True)
age = db.Column(db.String(20), nullable=True)
gender = db.Column(db.String(20), nullable=True)
nationality = db.Column(db.String(20), nullable=True)
fam_x = db.Column(db.INTEGER, nullable=True)
fam_a = db.Column(db.INTEGER, nullable=True)
fam_k = db.Column(db.INTEGER, nullable=True)
rpuse = db.Column(db.INTEGER, nullable=True)
rp_ic = db.Column(db.INTEGER, nullable=True)
rp_oc = db.Column(db.INTEGER, nullable=True)
rp_s = db.Column(db.INTEGER, nullable=True)
rp_f = db.Column(db.INTEGER, nullable=True)
rp_r = db.Column(db.INTEGER, nullable=True)
rp_c = db.Column(db.INTEGER, nullable=True)
rp_u = db.Column(db.INTEGER, nullable=True)
def __repr__(self):
return f"Content('{self.user_id}','{self.age}','{self.gender}','{self.nationality}'," \
f"'{self.fam_x}','{self.fam_a}','{self.fam_k}','{self.rpuse}','{self.rp_ic}','{self.rp_oc}'," \
f"'{self.rp_s}','{self.rp_f}','{self.rp_r}','{self.rp_c}','{self.rp_u}')"
class Team(db.Model):
"""
name: name of team
description: description of team
image: image url
publisher: main publisher for team
characters: characters in team
volumes: volumes that team appeard in
"""
__tablename__ = "Team"
name = db.Column(db.String(50), unique=True, primary_key=True)
description = db.Column(db.String, unique=False)
image = db.Column(db.String) # image url
appear = db.Column(db.String, unique=False)
num_appearances = db.Column(db.String, unique=False)
publisher_name = db.Column(db.String(150), db.ForeignKey('Publisher.name'))
team_publisher = db.relationship("Publisher",
back_populates="publisher_teams")
team_characters = db.relationship("Character",
secondary=characters_teams,
back_populates='character_teams')
team_volumes = db.relationship("Volume",
secondary=volumes_teams,
back_populates='volume_teams')
# TsVector column used for searching.
tsvector_col = db.Column(TsVector)
# Create an index for the tsvector column
__table_args__ = (db.Index('team_tsvector_idx',
'tsvector_col',
postgresql_using='gin'), )
def __repr__(self):
return 'Team(name={}, description={}, image={}, publisher={}, appear={}, num_appearances={}'.format(
self.name,
self.description,
self.image,
self.team_publisher,
self.appear,
self.num_appearances,
) + ")"
def json_it(self):
c = []
for char in self.team_characters:
temp = {'name': char.name, 'image': char.image}
c.append(temp)
v = []
for volume in self.team_volumes:
temp = {'name': volume.name, 'image': volume.image}
v.append(temp)
ans = {
'appear': self.appear,
'description': self.description,
'image': self.image,
'name': self.name,
'num_appearances': self.num_appearances,
'publisher_name': self.publisher_name,
'image': self.image,
'num_appearances': self.num_appearances,
'team_characters': c,
'team_volumes': v
}
return ans
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
cellphone = db.Column(db.String(20), index=True, unique=True)
class Volume(db.Model):
"""
image: image url
description: info on volume
count_of_issues: num issues in volume
start_year: when volume started
publisher: main publisher
characters: characters in volume
teams: teams in the characters
name: name of volume
"""
__tablename__ = "Volume"
image = db.Column(db.String) # image url
description = db.Column(db.String(200), unique=False)
start_year = db.Column(db.String(100), unique=False)
name = db.Column(db.String, unique=True, primary_key=True)
num_issues = db.Column(db.String)
publisher_name = db.Column(db.String(150), db.ForeignKey('Publisher.name'))
volume_publisher = db.relationship("Publisher",
back_populates="publisher_volumes")
volume_characters = db.relationship("Character",
secondary='characters_volumes',
back_populates="character_volumes")
volume_teams = db.relationship("Team",
secondary=volumes_teams,
back_populates='team_volumes')
# TsVector column used for searching.
tsvector_col = db.Column(TsVector)
# Create an index for the tsvector column
__table_args__ = (db.Index('volume_tsvector_idx',
'tsvector_col',
postgresql_using='gin'), )
def json_it(self):
t = []
for team in self.volume_teams:
temp = {'name': team.name, 'image': team.image}
t.append(temp)
c = []
for character in self.volume_characters:
temp = {'name': character.name, 'image': character.image}
c.append(temp)
ans = {
'description': self.description,
'image': self.image,
'name': self.name,
'num_issues': self.num_issues,
'publisher_name': self.publisher_name,
'start_year': self.start_year,
'volume_teams': t,
'volume_characters': c
}
return ans
def __repr__(self):
return 'Volume(image={}, description={}, start_year={}, publisher={}, name={}, num_issues={}'.format(
self.image, self.description, self.start_year, self.publisher_name,
self.name, self.num_issues) + ")"
