class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(30))
description = db.Column(db.String(200))
complete = db.Column(db.Boolean, nullable=False, default=False)
due = db.Column(db.DateTime, nullable=True)
user = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class Astronaut(db.Model):
""" Define the model of Astronaut user
Args:
Form: Inherits the db.Model library
Returns:
None
Attributes:
id - Primary key, must be an integer
name - Must be string of max length 30
username - Can't be null, can be only one in the database, up to 80 characters
email - Must be unique, can't be null and it's string of max 120 characters
password - Password is a string of max 180 characters, can't be null
admin_id - Integer which is an ID of admin, who created current user
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(180), unique=False, nullable=False)
admin_id = db.Column(db.Integer, db.ForeignKey('admin.id'), nullable=False)
# astronauts need to have the admin ID's that created them
admin = db.relationship('Admin', backref=db.backref('admins'))
#Method returning string as representation of the object
def __repr__(self):
return '<Astronaut %r>' % self.username
class Officials(UserMixin, db.Model):
OfficialUId = db.Column(UUID(as_uuid=True), unique=True, primary_key=True)
FirstName = db.Column(db.String(50), nullable=False)
Surname = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
PwdHash = db.Column(db.String(255), nullable=False)
IsAdmin = db.Column(TINYINT(1), default=0)
@property
def password(self):
raise AttributeError('password is not a readable attribute')
def get_id(self):
try:
return text_type(self.OfficialUId)
except AttributeError:
raise NotImplementedError(
'No `UserUId` attribute - override `get_id`')
def verify_password(self, password):
return self.PwdHash == password
def check_admin_status(self):
if IsAdmin == 1:
return True
else:
return False
@login_manager.user_loader
def load_user(OfficialUId):
return Officials.query.get(str(OfficialUId))
def __repr__(self):
return f"User('{self.FirstName}','{self.Surname}', '{self.Email}', '{self.PwdHash}', '{self.IsAdmin}')"
class OveralStatus(db.Model):
""" Define the model of Sensors for the engineering database
Args:
Form: Inherits the db.Model library
Returns:
None
Attributes:
__bind_key__ - Contains name of the database
id - Primary key, must be an integer
fire - String, up to 30 characters
electrical - String, up to 30 characters
temperature - String, up to 30 characters
oxygen - String, up to 30 characters
"""
__bind_key__ = 'engineering_db'
id = db.Column(db.Integer, primary_key=True)
fire = db.Column(db.String(30))
electrical = db.Column(db.String(30))
temperature = db.Column(db.String(30))
oxygen = db.Column(db.String(30))
#method returning string as representation of the object
def __repr__(self):
return '<Overal_Status %r>' % self.fire
class Admin(db.Model):
""" Define the model of Admin for database
Args:
Form: Inherits the db.Model library
Returns:
None
Attributes:
id - Primary key, must be an integer
name - Must be string of max length 30
username - Can't be null, can be only one in the database, up to 80 characters
email - Must be unique, can't be null and it's string of max 120 characters
password - Password is a string of max 180 characters, can't be null
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(180), unique=False, nullable=False)
#Method returning string as representation of the object
def __repr__(self):
return '<Admin %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)
password = db.Column(db.String(60), nullable=False)
#character/game details not changeable by user
energy = db.Column(db.Integer, nullable=False, default=100)
sanity = db.Column(db.Integer, nullable=False, default=100)
grades = db.Column(db.Integer, nullable=False, default=100)
progress = db.Column(db.String(2), nullable=False, default='a1')
def get_reset_token(self, expires_sec=1800):
s = Serializer(application.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(application.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def is_dead(self):
return self.energy <= 0
def __repr__(self):
return f"User('{self.username}','{self.progress}', '{self.energy}', '{self.sanity}', '{self.grades}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=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,
backref=db.backref('users', lazy='dynamic'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
firstName = db.Column(db.String(60), nullable=False)
address = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return f"User('{self.username}', '{self.email}',)"
class Users(UserMixin, db.Model):
UserUId = db.Column(UUID(as_uuid=True),
unique=True,
primary_key=True,
default=db.text("uuid()"))
EligibleToVote = db.Column(TINYINT(1), default=0)
email = db.Column(db.String(255), unique=True, nullable=False)
PwdHash = db.Column(db.String(255), nullable=False)
HasVoted = db.Column(TINYINT(1), default=0)
def __repr__(self):
return f"User('{self.EligibleToVote}', '{self.Email}')"
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False, unique=True)
content = db.Column(db.String(500), nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __repr__(self):
return "".join([
"User ID: ", self.user_id, "\r\n",
"Title: ", self.title, "\r\n", self.content
])
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(500), nullable=False)
posts = db.relationship("Posts", backref="author", lazy=True)
def __repr__(self):
return "".join(["UserID: ", str(self.id), "\r\n",
"Email: ", self.email, "\r\n",
"Name: ", self.first_name, " ", self.last_name
])
class Client(db.Model):
__tablename__ = "Clients"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
street = db.Column(db.String(256), nullable=False)
street_number = db.Column(db.String(6), nullable=False)
postal_code = db.Column(db.Integer, nullable=False)
city = db.Column(db.String(256), nullable=False)
firm = db.Column(db.Boolean, nullable=True)
vat_number = db.Column(db.String(20), nullable=True)
class FormModel(db.Model):
__tablename__ = 'Example'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False, unique=True)
def __repr__(self):
return '<Example {}>'.format(self.name)
class Official(db.Model, UserMixin):
officialuid = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(50), nullable=False)
surname = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(240), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
def get_id(self):
try:
return str(self.officialuid)
except AttributeError:
raise NotImplementedError('No `UId` attribute - override `get_id`')
def __repr__(self):
return f"User('{self.email}')"
def verify_password(self, password):
return self.password == password
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)
password = db.Column(db.String(60), nullable=False)
games_won = db.Column(db.Integer(), nullable=False, default=0)
friend_list = db.relationship("User",
secondary=friends,
primaryjoin=(friends.c.self_id == id),
secondaryjoin=(friends.c.friend_id == id),
backref=db.backref('friends',
lazy='dynamic'),
lazy='dynamic')
games = db.relationship("Game",
secondary=game_table,
backref=db.backref('games', lazy='dynamic'))
def add_friend(self, user): # allows user to add a friend and updates db
if not self.is_friends(user) and self.id != user.id:
self.friend_list.append(user)
user.friend_list.append(self)
def is_friends(self, user): # checks if users are already friends
return self.friend_list.filter(
friends.c.friend_id == user.id).count() > 0
def get_reset_token(self, expires_sec=1800): # for resetting password
s = Serializer(application.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token): # verifies correct token for reset password
s = Serializer(application.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}'')"
class ChessPuzzle(db.Model):
__tablename__ = 'Puzzles'
puzzle_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
description = db.Column(db.String(200))
fen = db.Column(db.String(250), nullable=False)
solution = db.Column(db.String(250), nullable=False)
type_id = db.Column(db.Integer, db.ForeignKey('PuzzleTypes.type_id'))
def __eq__(self, other):
eq_puzzle_id = self.puzzle_id == other.puzzle_id
eq_description = self.description == other.description
eq_fen = self.fen == other.fen
eq_solution = self.solution == other.solution
eq_type = self.type_id == other.type_id
return eq_puzzle_id and eq_description and eq_fen and eq_solution and eq_type
def __str__(self):
return " id: %s\n descr: %s\n fen: %s\n solution: %s\n type_id: %s\n\n" \
% (self.puzzle_id, self.description, self.fen, self.solution, self.type_id)
class Bill(db.Model):
__tablename__ = "Bills"
id = db.Column(db.Integer, primary_key=True)
client_id = db.Column(db.Integer, db.ForeignKey(Client.id))
subject = db.Column(db.String(256), nullable=False)
date = db.Column(db.Date, nullable=False)
expiration = db.Column(db.Date, nullable=False)
price = db.Column(db.Float(precision=2), nullable=False)
cash = db.Column(db.Boolean, nullable=False)
paid = db.Column(db.Boolean, nullable=False)
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)
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Task', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(application.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(application.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}')"
class User(db.Model):
__tablename__ = "Users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(40), nullable=False, unique=False)
email = db.Column(db.String(40), unique=True, nullable=False)
password = db.Column(db.String(200), unique=False, nullable=False)
created_on = db.Column(db.DateTime,
index=False,
unique=False,
nullable=True)
admin = db.Column(db.Boolean, nullable=False, unique=False)
def set_password(self, password):
"""Create hashed password."""
self.password = generate_password_hash(password, method="sha256")
def check_password(self, password):
"""Check hashed password."""
return check_password_hash(self.password, password)
def __repr__(self):
return "<User {}>".format(self.username)
class PuzzleType(db.Model):
__tablename__ = 'PuzzleTypes'
type_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
description = db.Column(db.String(100), nullable=False)
class PoliticalParty(db.Model):
UId = db.Column(UUID(as_uuid=True), unique=True, primary_key=True)
Name = db.Column(db.String(255), nullable=False)
def __repr__(self):
return f"PoliticalParty('{self.Name}')"
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class Election(db.Model, UserMixin):
title = db.Column(db.String(255), nullable=False, primary_key=True)
election_date = db.Column(db.DATE, nullable=False)
start_time = db.Column(db.TIME, nullable=False)
end_time = db.Column(db.TIME, nullable=False)
class Candidates(db.Model, UserMixin):
title = db.Column(db.String(60), primary_key=True)
