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(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.image_file}')"
class SmartAction(db.Model):
__tablename__ = "smart_house_action"
id = db.Column('id', db.Integer, primary_key=True)
sensor_id = db.Column(db.Integer, db.ForeignKey('smart_sensor.id'))
time = db.Column('time', db.DateTime)
action = db.Column('action', db.String(50))
outcome = db.Column('outcome', db.String(50))
class Courses(db.Model):
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer)
major = db.Column(db.String(12))
course_name = db.Column(db.String(100))
components = db.relationship("Components", backref="course")
course_sections = db.relationship("Sections", backref="course")
final_schedules = db.relationship("ScheduleFinal",
backref=db.backref("course",
lazy="joined"))
student_planning_data = db.relationship("StudentPlanningData",
backref=db.backref("course",
lazy="joined"))
course_preferences = db.relationship("FacultyCoursePreferences",
backref=db.backref("course",
lazy="joined"))
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'number': self.number,
'major': self.major,
'course_name': self.course_name
#'components': self.components
#'course_sections': self.course_sections,
#'final_schedules': self.final_schedules,
}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True, unique=True,
nullable=False, autoincrement=True)
email = db.Column(db.String(30), nullable=False, unique=True)
username = db.Column(db.String(20), nullable=False, unique=True)
first_name = db.Column(db.String(20), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(60), nullable=False)
admin = db.Column(db.Integer, nullable=False, default=0)
def get_id(self):
return self.id
def get_admin(self):
return self.admin
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)
def __repr__(self):
return f"Profesor:\nid_profesor: {self.id}\nfirst_name: {self.first_name}\nlast_name: {self.last_name}"
class meteor_comments(db.Model):
# comment number is according to article api "commentLength" field
__tablename__ = 'meteor_comments'
id = db.Column(db.Integer, primary_key=True)
art_id = db.Column(db.String())
art_shortid = db.Column(db.String())
comment_author = db.Column(db.String())
author_gender = db.Column(db.Integer())
comment_floor = db.Column(db.Integer())
comment_time = db.Column(db.DateTime())
comment_likes = db.Column(db.Integer())
comment_content = db.Column(db.Text())
comment_response = db.Column(db.Text())
def __init__(self,
id,
shortid,
author,
gender,
floor,
time,
likes,
content,
response=""):
self.art_id = id
self.art_shortid = shortid
self.comment_author = author
self.author_gender = gender
self.comment_floor = floor
self.comment_time = time
self.comment_likes = likes
self.comment_content = content
self.comment_response = response
def __repr__(self):
return str({
'art_id': self.art_id,
'art_shortid': self.art_shortid,
'comment_author': self.comment_author,
'author_gender': self.author_gender,
'comment_floor': self.comment_floor,
'comment_time': self.comment_time,
'comment_likes': self.comment_likes,
'comment_content': self.comment_content,
'comment_response': self.comment_response
})
def serialize(self):
return {
'art_id': self.art_id,
'art_shortid': self.art_shortid,
'comment_author': self.comment_author,
'author_gender': self.author_gender,
'comment_floor': self.comment_floor,
'comment_time': self.comment_time,
'comment_likes': self.comment_likes,
'comment_content': self.comment_content,
'comment_response': self.comment_response
}
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
name = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(255), nullable=False)
def __repr__(self):
return f"User('{self.username}', '{self.name}')"
class File(db.Model):
__tablename__ = 'files'
id = db.Column(db.Integer, primary_key=True)
extension = db.Column(db.String(255), nullable=False)
name_on_server = db.Column(db.String(255), nullable=False)
song_id = db.Column(db.Integer, db.ForeignKey('songs.id'))
def __repr__(self):
return f"File('{self.extension}','{self.name_on_server}')"
class User(db.Model, UserMixin):
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())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users_association_table,
backref=db.backref('users', lazy='dynamic'))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80),
index=True,
unique=True,
nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
def __repr__(self):
return f'<USER {self.username}>'
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(25), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
date_reg = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
mail = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20), nullable=False, default='default.png')
post = db.relationship('Post', backref='author', lazy=True)
todo = db.relationship('Todo', backref='mail', lazy=True)
def __repr__(self):
return f"Users('{self.username}', '{self.mail}')"
class SmartHouse(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
admin_id = db.Column(db.Integer, db.ForeignKey('user.id'))
location = db.Column('location', db.String(50))
url = db.Column('url', db.String(50))
port = db.Column('port', db.Integer)
floors = db.Column('floors', db.Integer)
registered_on = db.Column('registered_on', db.DateTime)
last_connetion = db.Column('last_connetion', db.DateTime)
controllers = db.relationship('SmartController',
backref='house',
lazy='dynamic')
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))
posts = db.relationship('Post', backref='author')
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)
class meteor_articles(db.Model):
__tablename__ = 'meteor_articles'
id = db.Column(db.Integer, primary_key=True)
art_id = db.Column(db.String()) # <= id
art_shortid = db.Column(db.String()) # <= shortId, also url
author_gender = db.Column(
db.Integer()) # <= (authorGender=='female')? 0 : 1
art_author = db.Column(db.String()) # <= authorAlias
art_school = db.Column(db.String()) # <= authorSchoolName
art_time = db.Column(db.DateTime()) # <= createdAt
art_likes = db.Column(db.Integer()) # <= starLength
art_title = db.Column(db.String()) # <= title
art_content = db.Column(db.Text()) # <= content
def __init__(self, id, shortid, gender, author, school, time, likes, title,
content):
self.art_id = id
self.art_shortid = shortid
self.author_gender = gender
self.art_author = author
self.art_school = school
self.art_time = time
self.art_likes = likes
self.art_title = title
self.art_content = content
def __repr__(self):
return str({
'art_id': self.art_id,
'art_shortid': self.art_shortid,
'author_gender': self.author_gender,
'art_author': self.art_author,
'art_school': self.art_school,
'art_time': self.art_time,
'art_likes': self.art_likes,
'art_title': self.art_title,
'art_content': self.art_content
})
def serialize(self):
return {
'art_id': self.art_id,
'art_shortid': self.art_shortid,
'author_gender': self.author_gender,
'art_author': self.art_author,
'art_school': self.art_school,
'art_time': self.art_time,
'art_likes': self.art_likes,
'art_title': self.art_title,
'art_content': self.art_content
}
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))
date_of_reg = db.Column(db.DateTime, default=datetime.utcnow()) # date
isActive = db.Column(db.Boolean)
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)
class ThumbnailImage(db.Model):
__tablename__ = 'thumbnail_image'
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(250), nullable=False)
original_image_id = db.Column(db.Integer, db.ForeignKey('image.id'))
dimensions = db.Column(db.String(25), nullable=True)
original_image = relationship('Image', back_populates='thumbnail_image')
def __init__(self, image_name, original_image):
self.path = image_name
self.original_image = original_image
width, height = PilImage.open(get_full_path(image_name)).size
self.dimensions = '{}x{}'.format(width, height)
class User(db.Model):
# add columns
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=True)
email = db.Column(db.String(120), unique=True, nullable=True)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg'
) # we hash the image files to strings #profile pic
password = db.Column(db.String(60),
nullable=False) # hashing passwords to 60 char length
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class PortoDoorStatus(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
date = db.Column('date', db.DateTime, index=True)
opened = db.Column('door_status', db.String(20))
def to_dict(self, include_email=False):
data = {
'id': self.id,
'date': self.date,
'opened': self.opened,
}
return data
def __init__(self, door_state):
self.opened = door_state
self.date = datetime.utcnow()
def get_opened_status(self):
return self.opened
def get_date_hour(self):
return self.date.strftime("%x %X")
def get_hour(self):
return self.date.strftime("%X")
class Subscribers(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(30), nullable=False)
date_sub = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
def __repr__(self):
return f"Subscribers('{self.email}')"
class RoomTypes(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {'id': self.id, 'name': self.name}
class Components(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
workload_units = db.Column(db.String(5))
hours = db.Column(db.String(5))
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'name': self.name,
'course_id': self.course_id,
'workload_units': self.workload_units,
'hours': self.hours
}
class CohortData(db.Model):
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
major = db.Column(db.String(12))
freshman = db.Column(db.Integer)
sophmores = db.Column(db.Integer)
juniors = db.Column(db.Integer)
seniors = db.Column(db.Integer)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(32))
last_name = db.Column(db.String(32))
username = db.Column(db.String(32))
password_hash = db.Column(db.String(64))
role = db.Column(db.String(12))
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'username': self.username,
'role': self.role
}
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}'"
class User(db.Model, UserMixin): #从 UserMixin 继承
__tablename__ = 't_user'
user_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
user_code = db.Column(db.String(100), unique=True)
user_name = db.Column(db.String(100))
user_password = db.Column(db.String(100))
def __init__(self, user_code, user_name, user_password):
self.user_code = user_code
self.user_name = user_name
self.user_password = user_password
def __repr__(self):
return '<User %r>' % self.user_name
# get_id()方法默认返回的用户的id. 如果用户不存在,应该返回None.
def get_id(self):
return self.user_id
class ScheduleFinal(db.Model):
id = db.Column(db.Integer, primary_key=True)
term_id = db.Column(db.Integer, db.ForeignKey("terms.id"))
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
number_sections = db.Column(db.String(4))
total_enrollment = db.Column(db.String(4))
waitlist = db.Column(db.String(4))
@property
def serialize(self):
return {
'id': self.id,
'course_major': self.course.major,
'course_number': self.course.number,
'number_sections': self.number_sections,
'total_enrollment': self.total_enrollment,
'waitlist': self.waitlist
}
class Artist(db.Model):
__tablename__ = 'artists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
songs = db.relationship('Song', backref='artist', lazy=True)
albums = db.relationship('Album', backref='artist', lazy=True)
def __repr__(self):
return f"Artist('{self.name}', '{self.albums}','{self.songs}')"
class Album(db.Model):
__tablename__ = 'albums'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
artist_id = db.Column(db.Integer, db.ForeignKey('artists.id'))
songs = db.relationship('Song', backref='album', lazy=True)
def __repr__(self):
return f"Album('{self.name}','{self.songs}')"
class Experiments(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False,
unique=True, autoincrement=True)
experiment_name = db.Column(db.String(30), nullable=False, unique=True)
description = db.Column(db.String(300), default="")
data = db.relationship('ExperimentData', backref='experiment_id')
@classmethod
def get_headers(self):
header = ('Experiment Id', 'Experiment Name', 'Data Colected')
return header
@classmethod
def get_data(self, id):
exp = Experiments.query.filter_by(id=id).first()
return exp
def __repr__(self):
return f"id:\n{self.id}\n experiment_name: {self.experiment_name}"
class SmartSensor(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
controller_id = db.Column(db.Integer, db.ForeignKey('smart_controller.id'))
sensor = db.Column('sensor', db.Boolean)
gpio = db.Column('gpio', db.Integer)
description = db.Column('description', db.String(50))
registered_on = db.Column('registered_on', db.DateTime)
last_connetion = db.Column('last_connetion', db.DateTime)
actions = db.relationship('SmartAction', backref='sensor', lazy='dynamic')
class SmartController(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
house_id = db.Column(db.Integer, db.ForeignKey('smart_house.id'))
ctype = db.Column('type', db.String(50))
floor = db.Column('floor', db.Integer)
registered_on = db.Column('registered_on', db.DateTime)
last_connetion = db.Column('last_login_date', db.DateTime)
sensors = db.relationship('SmartSensor',
backref='controller',
lazy='dynamic')
