class User_Profile(UserMixin, db.Model):
"""
Table class to store the user profile
"""
__tablename__ = 'user_profile'
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(50), nullable=False)
lastName = db.Column(db.String(50), nullable=False)
regNo = db.Column(db.String(20), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
uploaded_image = db.Column(db.Boolean, nullable=False, default=False)
registered = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
def __init__(self, firstName, lastName, regNo):
self.firstName = firstName
self.lastName = lastName
self.regNo = regNo
def __repr__(self):
return "<regNo {}>".format(self.regNo)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def set_uploaded_image(self):
self.uploaded_image = True
def has_uploaded_image(self):
return self.uploaded_image
class User(database.Model, UserMixin):
__tablename__ = "user"
id = database.Column("id",
database.Integer,
primary_key=True,
autoincrement=True)
username = database.Column("username",
database.String(255),
unique=True,
nullable=False)
password = database.Column("password", database.Text, nullable=False)
email = database.Column("email",
database.String(255),
unique=True,
nullable=False)
posts = database.relationship("Post", backref="poster")
sentMessages = database.relationship("Message",
backref="sender",
lazy="dynamic",
foreign_keys="Message.senderId")
receivedMessages = database.relationship("Message",
backref="receiver",
lazy="dynamic",
foreign_keys="Message.receiverId")
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
class User(UserMixin, database.Model):
"""User account model."""
__tablename__ = 'flasklogin-users'
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(100), nullable=False, unique=False)
email = database.Column(database.String(40), unique=True, nullable=False)
role = database.Column(database.String(40), unique=True, nullable=False)
password = database.Column(database.String(200),
primary_key=False,
unique=False,
nullable=False)
enrolled = database.relationship("EduSchedu",
secondary=student_identifier,
backref=database.backref('enrolled'),
lazy='dynamic')
approlled = database.relationship("ApptSchedu",
secondary=student_appt,
backref=database.backref('approlled'),
lazy='dynamic')
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def set_password(self, password):
self.password = generate_password_hash(password, method='sha256')
def check_password(self, password):
return self.password
def __repr__(self):
return "%s" % (self.name)
class Role(database.Model, RoleMixin):
id = database.Column(database.Integer(), primary_key=True)
name = database.Column(database.String(80), unique=True)
description = database.Column(database.String(255))
def __str__(self):
return self.name
class User(database.Model, UserMixin):
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(255))
last_name = database.Column(database.String(255))
email = database.Column(database.String(255), unique=True)
password_hash = database.Column(database.String(255))
active = database.Column(database.Boolean(), default=False)
roles = database.relationship(
'Role',
secondary=roles_users,
)
seances_and_users = database.relationship(
'Seance',
secondary=seances_and_users,
cascade="all,delete",
backref=database.backref('users_on_seance', passive_deletes=True)
)
def __str__(self):
return "{} {}".format(self.name, self.last_name)
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 push_user_to_database_and_set_role(self):
from app import user_datastore
user_datastore.create_user(name=self.name, last_name=self.last_name,
email=self.email, password_hash=self.password_hash, active=False)
user_datastore.add_role_to_user(self.email, 'user')
class ProcessedImages(database.Model):
__tablename__ = "ProcessedImages"
id = database.Column(database.Integer(), primary_key=True, unique=True)
dateUploaded = database.Column(database.DateTime(),
default=datetime.utcnow)
imageFileName = database.Column(database.String(64), unique=True)
sizeFrom = database.Column(database.String(32))
sizeTo = database.Column(database.String(32))
resizeStatus = database.Column(database.String(8))
def __repr__(self):
return f"<Id: {self.id}, date uploaded: {self.dateUploaded}, " \
f"download link: /static/resizedImages/{self.imageFileName}>"
@property
def serialize(self):
return {
"id": self.id,
"dateUploaded": dump_datetime(self.dateUploaded),
"imageFileName": self.imageFileName,
"sizeFrom": self.sizeFrom,
"sizeTo": self.sizeTo,
"resizeStatus": self.resizeStatus,
"downloadFileURL": f"/static/resizedImages/{self.imageFileName}>"
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index = True, unique=True)
#how we relate this user to all of its many posts
posts = db.relationship('Post', backref='author', lazy='dynamic')
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def __repr__(self):
return '<User %r>' % self.nickname
class Dataset(db.Model):
"""
Represents table holding dataset info
"""
__tablename__ = 'dataset'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(50), nullable=False)
original_data = db.Column(db.String(50), unique=True, nullable=False)
working_copy = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(255), nullable=False)
# View is parent of action, thus this relationship helper class
actions = db.relationship('Action',
backref='dataset',
lazy='dynamic',
passive_deletes=True)
# Dataset is child of project, thus this foreign key
project_id = db.Column(db.Integer,
db.ForeignKey('project.id', ondelete='CASCADE'))
def __init__(self, name, original, working, description, project):
self.name = name
self.original_data = original
self.working_copy = working
self.description = description
self.project_id = project
class User(db.Model):
"""
用户表
"""
id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(64), index = True, unique = True)
password = db.Column(db.String(120), )
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
def __repr__(self):
return f'<User { self.username }>'
class User(db.Model, UserMixin):
"""Represents table holding user data in our database"""
# Table name to be used in database
# If not provided class name is used which is a problem when using
# postgres because user is a reserved keyword
__tablename__ = 'user_data'
# Table columns
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
first_name = db.Column(db.String(25))
last_name = db.Column(db.String(25))
email = db.Column(db.String(50), unique=True, nullable=False)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
admin = db.Column(db.Boolean(), default=0)
disabled = db.Column(db.Boolean(), default=0)
# User is parent of action, thus this relationship helper class
actions = db.relationship('Action', backref='user', lazy='dynamic')
def __init__(self, fname, lname, email, uname, password):
"""Initializes a user instance"""
self.first_name = fname
self.last_name = lname
self.email = email
self.username = uname
self.password = generate_password_hash(password, method='sha256')
class AuthorizationData(database.Model):
id = database.Column(database.String(250), primary_key=True)
login = database.Column(database.String(50), unique=True)
password = database.Column(database.String(500), nullable=True)
def __repr__(self):
return 'User %ds>' % self.__login
class User(database.Model, UserMixin):
id = database.Column(database.Integer, primary_key=True)
email = database.Column(database.String(100), unique=True)
password = database.Column(database.String(255))
active = database.Column(database.Boolean)
roles = database.relationship(
'Role', secondary=user_role_relation_database, backref=database.backref('users'), lazy='dynamic'
)
class Logs(db.Model):
__tablename__ = 'logs'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, nullable=False)
type = db.Column(db.String(32), nullable=True)
realAddress = db.Column(db.String(39), nullable=False)
virtualAddress = db.Column(db.String(39), nullable=False)
sbc_id = db.Column(db.Integer, db.ForeignKey('sbc.id', ondelete='CASCADE'), nullable=False)
class Profile(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(150), nullable=False)
level = db.Column(db.String(150), nullable=False)
username = db.Column(db.String(150), nullable=False)
colour = db.Column(db.String(150), nullable=False)
date_of_birth = db.Column(db.DateTime, nullable=False)
password = db.Column(db.String(150),
nullable=False) #This is stored in plaintext for now
chatroomID = db.Column(db.Integer, nullable=False)
@property
def is_active(self):
return True
@property
def is_authenticated(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return self.session_token
def __repr__(self):
return '<User %r>' % self.email
def addProfile(pemail, plevel, pusername, pcolour, pdate_of_birth,
ppassword, pchatroomID):
profile = Profile(email=pemail,
level=plevel,
username=pusername,
colour=pcolour,
date_of_birth=pdate_of_birth,
password=ppassword,
chatroomID=pchatroomID)
db.session.add(profile)
db.session.commit()
return True
def getUserWithEmail(email):
return Profile.query.filter_by(email=email).first()
def getUserDetails(uid):
return db.session.query(Profile).get(uid)
def deleteUserDetails(uid):
Profile.query.filter_by(id=uid).delete()
print("Deleted Profile with id " + str(uid))
@staticmethod
def auth(uid, key):
first_var = Profile.query.filter_by(id=uid).first()
if ((first_var.id == uid) & (first_var.password == key)):
return True
return False
class Forum(database.Model):
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(64), index=True, unique=True)
short_name = database.Column(database.String(32), index=True, unique=True)
creator_id = database.Column(
database.Integer,
database.ForeignKey('users.id')
)
threads = database.relationship('Thread', backref='forum', lazy='dynamic')
class Consumption(database.Model):
id = database.Column(database.Integer, primary_key=True)
sum = database.Column(database.Integer, unique=False)
category = database.Column(database.String(150), unique=False)
creation_date = database.Column(database.DateTime)
user_id = database.Column(database.String(150), unique=False)
def __repr__(self):
return str(self.sum) + " " + str(self.category)
class Contact(db.Model): # type: ignore
""" Database Table for Contact details """
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(150))
email = db.Column(db.String(150))
message = db.Column(db.Text())
def __repr__(self) -> str:
return f"{self.name} -> {self.email}"
class Address(database.Model):
__tablename__ = 'address'
address = database.Column(database.String(30), primary_key=True)
city = database.Column(database.String(10), nullable=False)
state_province = database.Column(database.String(10), nullable=False)
postal_code = database.Column(database.String(5), nullable=False)
country = database.Column(database.String(15), nullable=False)
def __repr__(self):
return '<Address {}>'.format(self.address)
class Users(database.Model):
id = database.Column(database.Integer, primary_key=True)
username = database.Column(database.String(64), index=True, unique=True)
common_name = database.Column(database.String(64))
email = database.Column(database.String(120))
password_hash = database.Column(database.String(128))
token = database.Column(database.String(32), index=True, unique=True)
token_expiration = database.Column(database.DateTime)
posts = database.relationship('Post', backref='author', lazy='dynamic')
threads = database.relationship(
'Thread',
backref='creator',
lazy='dynamic'
)
forums = database.relationship('Forum', backref='creator', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def from_dict(self, data, new_user=False):
for field in ['username', 'email', 'common_name']:
if field in data:
setattr(self, field, data[field])
if new_user and 'password' in data:
self.set_password(data['password'])
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 get_token(self, expires_in=SECONDS_PER_DAY):
now = datetime.utcnow()
if self.token and self.token_expiration > now + timedelta(seconds=60):
return self.token
self.token = base64.b64encode(os.urandom(24)).decode('utf-8')
self.token_expiration = now + timedelta(seconds=expires_in)
update_token_query = f"""
UPDATE users
SET token='{self.token}', token_expiration='{self.token_expiration}'
WHERE users.id = '{self.id}'
"""
database.session.execute(update_token_query)
return self.token
@staticmethod
def check_token(token):
user = Users.query.filter_by(token=token).first()
print(f'Find a token {token} for user {user}')
if user is None or user.token_expiration < datetime.utcnow():
print(f'Invalid token')
return None
return user
class User(db.Model):
""""
Définition de la classe User qui comprend tous les champs nécessaires pour réserver un
voyage à la MNT.
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
nom = db.Column(db.String(100))
prenom = db.Column(db.String(100))
mail = db.Column(db.String(200), unique=True)
telephone = db.Column(db.String(100))
statut = db.Column(db.String(100))
section_service = db.Column(db.String(100))
lieu_de_travail = db.Column(db.String(50))
date_de_naissance = db.Column(db.String(70))
grand_voyageur = db.Column(db.String(70))
reductions = db.Column(db.String(80))
def __repr__(self):
return '<User %r>' % (self.mail)
def user_dict(self):
"""
Fonction qui permet de lister les informations utilisateurs.
"""
return {
'nom': self.nom,
'prenom': self.prenom,
'mail': self.mail,
'telephone': self.telephone,
'statut': self.statut,
'lieu_de_travail': self.lieu_de_travail,
'section_service': self.section_service,
'date_de_naissance': self.date_de_naissance,
'grand_voyageur': self.grand_voyageur,
'reductions': self.reductions
}
def save_to_bdd(self, infos):
"""
Fonction qui permet d'ajouter un utilisateur dans la table User.
"""
user_to_add = User(nom=infos.get('nom'),
prenom=infos.get('prenom'),
mail=infos.get('mail'),
telephone=infos.get('telephone'),
statut=infos.get('statut'),
section_service=infos.get('section_service'),
lieu_de_travail=infos.get('lieu_de_travail'),
date_de_naissance=infos.get('date_de_naissance'),
grand_voyageur=infos.get('grand_voyageur'),
reductions=infos.get('reductions'))
db.session.add(user_to_add)
db.session.commit()
class Subject(database.Model):
id = database.Column(database.Integer, primary_key=True, autoincrement=False)
level = database.Column(database.Integer, nullable=False)
type = database.Column(database.String(10), nullable=False)
image_url = database.Column(database.String(256)) # Only radicals have images defined.
characters = database.Column(database.String(64), nullable=False)
create_date = database.Column(database.DateTime, server_default=database.func.now())
modify_date = database.Column(database.DateTime, server_onupdate=database.func.now())
def __repr__(self):
return f'<ID: {self.id}, Level {self.level}, Type {self.type}, Characters {self.characters}>'
class Call(database.Model):
__tablename__ = 'call'
call_id = database.Column(database.Integer, primary_key=True, autoincrement=True)
investment_name = database.Column(database.String(120), nullable=False)
date = database.Column(database.String(120), nullable=False)
capital_requirement = database.Column(database.Integer, nullable=False)
def __init__(self, investment_name, date, capital_requirement):
self.investment_name = investment_name
self.date = date
self.capital_requirement = capital_requirement
class EduSchedu(database.Model):
__tablename__ = 'classes'
id = database.Column(database.Integer, primary_key=True)
time = database.Column(TIME(), nullable=False)
dow = database.Column(database.Integer, default='')
classname = database.Column(database.String(100), default='')
zoomlink = database.Column(database.String(500), default='')
students = database.relationship("User",
secondary=student_identifier,
backref=database.backref('students'),
lazy='dynamic')
class UserProfiles(database.Model):
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(150), unique=False)
last_name = database.Column(database.String(150), unique=False)
email = database.Column(database.String(150), unique=False)
creation_date = database.Column(database.DateTime)
user_id = database.Column(database.String(150),
database.ForeignKey('authorization_data.id'))
def __repr__(self):
return str(self.name) + " " + str(self.last_name)
class User(db.Model, UserMixin):
"""
Database Model for Table 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))
todos = db.relationship("Todo", backref="owner")
def set_password(self, password: str):
""" Set the hashed password for the user """
self.password_hash = generate_password_hash(password)
def check_password(self, password: str):
""" Check the users password """
return check_password_hash(self.password_hash, password)
def is_active(self):
""" True, as all users are active. """
return True
def get_id(self):
""" Return the email address to satisfy Flask-Login's requirements. """
return self.id
def is_authenticated(self):
""" Return True if the user is authenticated. """
return self.authenticated
def is_anonymous(self):
""" False, as anonymous users aren't supported. """
return False
def __repr__(self):
return f"{self.username} -> {self.email}"
def remove_todo(self, task: str):
""" Remove Todo from the user """
for i in self.todos:
if i.task == task:
db.session.delete(i)
db.commit()
else:
continue
def add_todo(self, task: str):
""" Add Todo to the user """
td = Todo(task=task,
owner=User.query.filter_by(username=self.username).first())
db.session.add(td)
db.session.commit()
class Article(database.Model):
__searchable__ = ["title", "body"]
id = database.Column(database.Integer, primary_key=True)
title = database.Column(database.String(100), nullable=False, unique=True)
date_posted = database.Column(database.DateTime,
nullable=False,
default=datetime.utcnow)
body = database.Column(database.Text, nullable=False)
user_id = database.Column(database.Unicode(36),
database.ForeignKey("user.id"),
nullable=False)
company_id = database.Column(database.Unicode(36),
database.ForeignKey("company.id"),
nullable=True)
image_file = database.Column(database.String(150),
unique=False,
nullable=True,
default="/static/homepagePics/blackgirls.jpg")
comments = database.relationship("Comment",
cascade="all,delete",
backref="article",
lazy="dynamic")
likes = database.relationship("Like",
cascade="all,delete",
backref="article",
lazy="dynamic")
views = database.Column(database.Integer, default=0)
@staticmethod
def generate_fake():
from random import seed, randint
import forgery_py
seed()
user_count = User.query.count()
company_count = Company.query.count()
for i in range(user_count):
user = User.query.offset(randint(0, user_count - 1)).first()
company = Company.query.offset(randint(0,
company_count - 1)).first()
article = Article(title=forgery_py.lorem_ipsum.words(randint(1,
5)),
body=forgery_py.lorem_ipsum.sentences(
randint(1, 3)),
author=user,
company=company)
database.session.add(article)
database.session.commit()
def __repr__(self):
return "Article('{}', '{}')".format(self.title, self.date_posted)
class User(database.Model):
__tablename__ = 'users'
id = database.Column(database.BigInteger, primary_key=True, autoincrement=True)
username = database.Column(database.String(255), nullable=False)
password = database.Column(database.String(255), nullable=False)
def __init__(self, username, password):
self.username = username
self.password = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password)
class Port(database.Model):
__tablename__ = 'port'
port_type = database.Column(database.String(7), nullable=False)
port_number = database.Column(database.SmallInteger, primary_key=True)
plug_type = database.Column(database.String(10), nullable=False)
station_name = database.Column(database.String(30),
database.ForeignKey('station.station_name'),
primary_key=True,
index=True)
station = database.relationship('Station', backref='ports')
def __repr__(self):
return '<Port {}, {}>'.format(self.port_number, self.station_name)
class Badges(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
badgeName = db.Column(db.String(150), nullable=False)
description = db.Column(db.String(1150), nullable=False)
def addBadges(bbadgeName, bdescription):
badges = Badges(badgeName=bbadgeName, description=bdescription)
db.session.add(badges)
db.session.commit()
return True
def getBadge(bid):
return db.session.query(Badges).get(bid)
class Tag(database.Model):
id = database.Column(database.Integer, primary_key=True)
title = database.Column(database.String(256), unique=True)
slug = database.Column(database.String(256), unique=True)
def __init__(self, *args, **kwargs):
super(Tag, self).__init__(*args, **kwargs)
if self.title:
self.slug = slugify(self.title, 'Tag')
else:
self.slug = slugify(str(int(time())), 'Tag')
def __repr__(self):
return f'<Tag id: {self.id}, title: {self.title}>'
