class Photo(db.Model):
__tablename__ = 'photos'
usrname = db.Column(db.String(100))
photourl = db.Column(db.String(300), primary_key=True)
def __repr__(self):
return '<Image{}:{}>'.format(self.username, self.photourl)
class Response(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
response = db.Column(db.String(20), nullable=False)
class Users(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_profile_pic.png')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Posts', 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 Users.query.get(user_id)
def __repr__(self):
return f"Users('{self.username}', '{self.email}', '{self.image_file}')"
class Newsletter(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
name = db.Column(db.String(20), unique=False, nullable=False)
def __repr__(self):
return f"Newsletter('{self.name}','{self.email}')"
class Document(BaseModel):
"""Base class for all documents (.e.g., blog articles, notes, etc.)."""
__abstract__ = True
publication_date = db.Column(db.Date, default=date.today, nullable=False)
last_update = db.Column(db.Date, onupdate=date.today)
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
# pick random image
# random_robot_file=pick_random_image()
profile_image = db.Column(db.String(64), nullable=False)
# default=random_robot_file)
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
post = db.relationship("BlogPost", backref="author", lazy=True)
def __init__(self, email, username, password, image):
self.email = email
self.username = username
self.password_hash = generate_password_hash(password)
self.profile_image = image
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return f"Username {self.username}"
class Sponsor(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), unique=True, nullable=False)
picture = db.Column(db.String(120), default="default_sponsor.jpg")
managers = db.relationship("User", backref="employer", lazy=True)
sponsorships = db.relationship("Sponsorship", backref="sponsor", lazy=True)
catalog = db.relationship("Catalog",
uselist=False,
back_populates="sponsor")
def __repr__(self):
return f"{self.name}"
def active_drivers(self):
return list(sponsorship.driver for sponsorship in self.sponsorships
if sponsorship.active)
def applied_drivers(self):
return list(sponsorship.driver for sponsorship in self.sponsorships
if not sponsorship.active)
def all_drivers(self):
return list(sponsorship.driver for sponsorship in self.sponsorships)
@classmethod
def sponsor_choices(cls):
sponsors = Sponsor.query.all()
class Fears(db.Model):
__tablename__ = 'fears'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
respondent_id = db.Column(db.Integer)
wspomaganie_innowacji = db.Column(db.Text, nullable=True)
ai_zastapienie_lekarzy = db.Column(db.Text, nullable=True)
operacja_robot_chirurg = db.Column(db.Text, nullable=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return f"Username: {self.username}, Password: {self.password}"
class User(db.Model, UserMixin):
'''
user store
'''
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
password_hash = db.Column(db.String) #store the hash of password instead
#of the plain text as password in plain text is dangerous
@property
def password(self):
raise AttributeError('Password: write-only field')
@password.setter
def password(self, pswd):
self.password_hash = generate_password_hash(pswd)
def check_password(self, pswd):
return check_password_hash(self.password_hash, pswd)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
def __repr__(self):
return '<User %r>' % self.username
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)
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_request_token(token):
return User.query.filter_by(username=token).first()
@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}')"
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)
email = db.Column(db.String(150), unique=True)
password = db.Column(db.String(150))
name = db.Column(db.String(80))
# for relationship database name should be capital
notes = db.relationship("Note")
class Sops(db.Model):
id = db.Column(db.Integer, primary_key=True)
f_name = db.Column(db.String(100))
f_data = db.Column(db.LargeBinary)
def __repr__(self):
return f"Sops('{self.id}', '{self.f_name}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(30), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
# generating a token for resetting the password with an expiration time and passing it the secret
# key that is unique to our app
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 Category(db.Model):
__tablename__ = 'category'
cat_id = db.Column(db.INTEGER, primary_key=True)
cat_name = db.Column(db.String(120))
cat_description = db.Column(db.String(120))
post = db.relationship('Post', backref='cat', lazy='dynamic')
def __unicode__(self):
return self.cat_name
@staticmethod
def list_category():
categories = Category.query.all()
return [c.to_json() for c in categories]
def to_json(self):
return {
'cat_id': self.cat_id,
'cat_name': self.cat_name,
'cat_description': self.cat_description
}
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class Download(db.Model):
__bind_key__ = 'sb_db'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime())
version = db.Column(db.String(64))
build = db.Column(db.String(64))
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.user_id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
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')
roles = db.relationship('Role', secondary='user_roles')
course_auth = db.relationship('Course',
secondary=course_author,
backref=db.backref('course'))
sharedfile = db.relationship('SharedFile',
backref='author_shared',
lazy='dynamic')
# Flask-Login integration
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.user_id
def __unicode__(self):
return self.user_name
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False, unique=True)
password = db.Column(db.String(40), nullable=False)
def __repr__(self):
return f"User('{self.id}', '{self.username}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
fullname = db.Column(db.String(30), nullable=False)
about = db.Column(db.Text, nullable=True)
role = db.Column(db.String(20), nullable=False)
date_joined = db.Column(db.DateTime, nullable=False)
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)
mode = db.Column(db.Boolean, default=False, nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='commenter', 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 Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
function_name = db.Column(db.String(1000), nullable=False)
filepath = db.Column(db.String(1000), nullable=False)
function_docstring = db.Column(db.String(1000), nullable=True)
def __repr__(self):
return f"Function({self.function_name}) \n Filepath:({self.filepath}))"
class Experience(db.Model):
__tablename__ = 'experience'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
respondent_id = db.Column(db.Integer)
udzial_zaawansowane_badanie = db.Column(db.Text, nullable=True)
stosowanie_urzadzen = db.Column(db.Text, nullable=True)
vr = db.Column(db.Text)
class Question(db.Model):
__tablename__ = 'question'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
text = db.Column(db.String(255), nullable=False)
options = db.relationship('Option', backref='question_assigned')
def __repr__(self):
return f"Question('{self.id}', '{self.text}')"
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
datetime = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user_likes = db.relationship('CommentLike', backref='likes', lazy=True)
user = db.relationship('User', backref='author')
class RequestPerMinute(db.Model):
__tablename__ = 'requestperminute'
requestid = db.Column(db.Integer, primary_key=True)
instance_id = db.Column(db.String(50))
timestamp = db.Column(db.DateTime) # A type for datetime.datetime() objects.
def __repr__(self):
return '<RequestPerMinute {}>'.format(self.instance_id)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, nullable=False)
title = db.Column(db.String(255), nullable=False)
image_url = db.Column(db.String(255), nullable=False)
content = db.Column(db.Text, nullable=False)
create_at = Column(DateTime(timezone=True), server_default=func.now())
update_at = Column(DateTime(timezone=True), onupdate=func.now())
class NewsCourse(db.Model):
__tablename__ = 'newscourse'
news_id = db.Column(db.INTEGER, primary_key=True)
news_title = db.Column(db.String(120))
news_description = db.Column(db.String(120))
course = db.Column(db.INTEGER, db.ForeignKey('course.course_id'))
class user_list(db.Model, UserMixin):
username = db.Column(db.String(20), unique=True, nullable=False, primary_key=True)
password = db.Column(db.String(80), nullable=False)
def __repr__(self):
return f"User('{self.username}')"
def get_id(self):
return (self.username)
class Syllabes(db.Model):
__tablename__ = 'syllabes'
syllabes_id = db.Column(db.INTEGER, primary_key=True)
syllabes_title = db.Column(db.String(120))
syllabes_description = db.Column(db.String(120))
course = db.Column(db.INTEGER, db.ForeignKey('course.course_id'))
class User(db.Model):
__tablename__ = 'testtable'
email = db.Column(db.String(100), unique=True)
username = db.Column(db.String(100), primary_key=True, unique=True)
password = db.Column(db.String(300))
def __repr__(self): # how to print User
return '<User:{}>'.format(self.username)
