class Users(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255), nullable=True)
last_name = db.Column(db.String(255), nullable=True)
prefix = db.Column(db.String(255), nullable=True)
group = db.Column(db.String(255), nullable=True)
username = db.Column(db.String(255), nullable=True)
password = db.Column(db.String(255), nullable=True)
mobileNumber = db.Column(db.String(255), nullable=True)
mobileNumberExtension = db.Column(db.String(255), nullable=True)
email = db.Column(db.String(255), nullable=True)
citizenId = db.Column(db.String(255), nullable=True)
status = db.Column(db.String(255), nullable=True)
groupName = db.Column(db.String(255), nullable=True)
verified = db.Column(db.Boolean(), nullable=True)
token = db.Column(db.String(255), nullable=True)
lockedOut = db.Column(db.Boolean(), nullable=True)
passwordExpired = db.Column(db.Boolean(), nullable=True)
officeNumber = db.Column(db.String(255), nullable=True)
createdAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
updatedAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
roleId = db.Column(db.Integer, db.ForeignKey('roles.id'), nullable=True)
Reset_Password_logs = db.relationship(
"Resetpasswordlogs", backref=db.backref("User_ResetPasswordLogs"))
Global_Settings = db.relationship(
"Globalsettings", backref=db.backref("User_Globalsettings"))
Login_Histories = db.relationship(
"Loginhistories", backref=db.backref("User_Loginhistories"))
class SuperAdmin(db.Model):
__bind_key__ = 'super-admins'
__tablename__ = 'super-admins'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
name = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
pwdhash = db.Column(db.String(54))
is_active = db.Column(db.Boolean(), default=True)
is_staff = db.Column(db.Boolean(), default=True)
is_admin = db.Column(db.Boolean(), default=True)
is_super_admin = db.Column(db.Boolean(), default=True)
created_on = db.Column(db.DateTime(), default=datetime.datetime.now())
def __init__(self, username, name, email, password):
self.username = username.lower()
self.name = name.lower()
self.email = email.lower()
self.set_password(password)
def set_password(self, password):
self.pwdhash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.pwdhash, password)
class Tarefas(db.Model):
__tablename__ = "tasks3"
id = db.Column(db.Integer, primary_key=True)
classcode = db.Column(db.String(256), nullable=True)
classname = db.Column(db.String(256), nullable=True)
student_name = db.Column(db.String(256), nullable=True)
student_id = db.Column(db.Integer(), nullable=True)
task_name = db.Column(db.String(256), nullable=True)
done = db.Column(db.Boolean(), default=False)
finished = db.Column(db.Boolean(), default=False)
class User(db.Model):
__tablename__ = "user"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), unique=True)
firstName = db.Column(db.String(100))
lastName = db.Column(db.String(100))
isLZAdmin = db.Column(db.Boolean(), default=False)
isMCAdmin = db.Column(db.Boolean(), default=False)
isActive = db.Column(db.Boolean(), default=True)
showWelcome = db.Column(db.Boolean(), default=True)
lastUpdated = db.Column(db.String(20))
def __repr__(self):
return "<User(id={self.id!r}, email={self.email!r})>".format(self=self)
class Student(db.Model):
__bind_key__ = 'student'
__tablename__ = 'student'
id = db.Column(db.Integer, primary_key=True)
unique_id = db.Column(db.String(20), unique=True, nullable=False)
f_name = db.Column(db.String(100), nullable=False)
m_name = db.Column(db.String(100), nullable=True)
l_name = db.Column(db.String(100), nullable=False)
gender = db.Column(db.String(8), nullable=False)
email = db.Column(db.String(70), unique=True, nullable=False)
primary_contact = db.Column(db.String(10), unique=True, nullable=False)
secondary_contact = db.Column(db.String(10), nullable=True)
pwdhash = db.Column(db.String(200))
address = relationship("StudentAddress", backref="student")
personal = relationship("PersonalProfile", backref="student")
academic = relationship("AcademicInfo", backref="student")
# attendances = relationship("StudentAttendance",backref="student")
is_student = db.Column(db.Boolean(), default=True)
is_active = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
def __init__(self, unique_id, f_name, m_name, l_name, gender,
primary_contact, secondary_contact, email, password):
self.unique_id = unique_id
self.f_name = f_name
self.m_name = m_name
self.l_name = l_name
self.gender = gender
self.primary_contact = primary_contact
self.secondary_contact = secondary_contact
self.email = email.lower()
self.set_password(password)
def set_password(self, password):
self.pwdhash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.pwdhash, password)
def __repr__(self):
return {
'f_name': self.first_name,
'm_name': self.middle_name,
'last_name': self.l_name
}
class Activator(db.Model):
__tablename__ = "activator"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer, primary_key=True)
isActive = db.Column(db.Boolean)
lastUpdated = db.Column(db.String(20))
isFavourite = db.Column(db.Boolean)
name = db.Column(db.String(255))
available = db.Column(db.Boolean())
sensitivity = db.Column(db.String(255))
userCapacity = db.Column(db.Integer)
serverCapacity = db.Column(db.Integer)
regions = db.Column(db.String(255))
hosting = db.Column(db.String(255))
apiManagement = db.Column(db.String(255))
sourceControlId = db.Column(db.Integer,
db.ForeignKey("eagle_db.sourcecontrol.id"))
businessUnitId = db.Column(db.Integer)
technologyOwner = db.Column(db.String(255))
technologyOwnerEmail = db.Column(db.String(255))
billing = db.Column(db.String(255))
activator = db.Column(db.String(255))
status = db.Column(db.String(255))
accessRequestedById = db.Column(db.Integer,
db.ForeignKey("eagle_db.user.id"))
source = db.Column(db.String(100))
gitRepoUrl = db.Column(db.String(255))
gitSnapshotJson = db.Column(db.String(2048))
def __repr__(self):
return "<Activator(id={self.id!r}, name={self.name!r})>".format(
self=self)
class Solution(db.Model):
__tablename__ = "solution"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer(), primary_key=True)
isActive = db.Column(db.Boolean)
lastUpdated = db.Column(db.String(20))
isFavourite = db.Column(db.Boolean)
name = db.Column(db.String(30))
description = db.Column(db.String(255))
businessUnitId = db.Column(db.Integer())
costCentre = db.Column(db.String(255))
ciId = db.Column(db.Integer())
cdId = db.Column(db.Integer())
sourceControlId = db.Column(db.Integer())
teamId = db.Column(db.Integer())
deployed = db.Column(db.Boolean())
deploymentState = db.Column(db.String(45))
statusId = db.Column(db.Integer())
statusCode = db.Column(db.String(45))
statusMessage = db.Column(db.String(255))
taskId = db.Column(db.String(100))
deploymentFolderId = db.Column(db.String(50))
isSandbox = db.Column(db.Boolean)
def __repr__(self):
return "<Solution(id={self.id!r}, name={self.name!r})>".format(
self=self)
class Notification(db.Model):
__tablename__ = "notification"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer(), primary_key=True)
isActive = db.Column(db.Boolean())
lastUpdated = db.Column(db.String(20))
toUserId = db.Column(db.Integer(), db.ForeignKey("eagle_db.user.id"))
fromUserId = db.Column(db.Integer, db.ForeignKey("eagle_db.user.id"))
importance = db.Column(db.Integer())
message = db.Column(db.String(255))
isRead = db.Column(db.Boolean())
typeId = db.Column(db.Integer(),
db.ForeignKey("eagle_db.notificationType.id"))
def __repr__(self):
return "<Notification(id={self.id!r})>".format(self=self)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'))
username = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
email_confirmed_at = db.Column(db.DateTime())
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100))
firstName = db.Column(db.String(100))
lastName = db.Column(db.String(100))
isAdmin = db.Column(db.Boolean())
class Activator(db.Model):
__tablename__ = "activator"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
type = db.Column(db.String(255))
available = db.Column(db.Boolean())
sensitivity = db.Column(db.String(255))
category = db.Column(db.String(255))
envs = db.Column(db.String(255))
platforms = db.Column(db.String(255))
lastUpdated = db.Column(db.String(255))
userCapacity = db.Column(db.Integer)
serverCapacity = db.Column(db.Integer)
regions = db.Column(db.String(255))
hosting = db.Column(db.String(255))
apiManagement = db.Column(db.String(255))
ci = db.Column(db.String(255))
cd = db.Column(db.String(255))
sourceControl = db.Column(db.String(255))
businessUnit = db.Column(db.String(255))
technologyOwner = db.Column(db.String(255))
technologyOwnerEmail = db.Column(db.String(255))
billing = db.Column(db.String(255))
activator = db.Column(db.String(255))
status = db.Column(db.String(255))
description = db.Column(db.String(255))
#accessRequestedBy = db.Column(db.Integer, db.ForeignKey('user.id'))
accessRequestedBy = db.Column(db.Integer)
source = db.Column(db.String(100))
activatorLink = db.Column(db.String(255))
class Solution(db.Model):
__tablename__ = "solution"
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255))
description = db.Column(db.String(255))
businessUnit = db.Column(db.String(255))
costCentre = db.Column(db.String(255))
ci = db.Column(db.String(255))
cd = db.Column(db.String(255))
sourceControl = db.Column(db.String(255))
environments = db.Column(db.String(255))
active = db.Column(db.Boolean())
favourite = db.Column(db.Boolean())
teams = db.Column(db.Integer())
lastUpdated = db.Column(db.String(255))
applications = db.relationship('Application')
class SharedServicesAction(db.Model):
__tablename__ = "sharedservicesaction"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
categoryName = db.Column(db.String)
categoryClass = db.Column(db.String)
completionRate = db.Column(db.Integer)
locked = db.Column(db.Boolean())
routerLink = db.Column(db.String)
dependantOn = db.Column(db.Integer)
isOptional = db.Column(db.Boolean())
def __repr__(self):
return "<SharedServicesAction(id={self.id!r}, name={self.title!r})>".format(
self=self
)
class Sample(db.Model):
__tablename__ = "sample"
grain_id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
l_value = db.Column(db.Numeric())
harmful = db.Column(db.Boolean())
photo = db.Column(db.String(32))
class LandingZoneAction(db.Model):
__tablename__ = "landingzoneaction"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
categoryName = db.Column(db.String)
categoryClass= db.Column(db.String)
completionRate = db.Column(db.Integer)
locked = db.Column(db.Boolean())
routerLink = db.Column(db.String)
class LandingZoneProgressItem(db.Model):
__tablename__ = "landingzoneprogressitem"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String)
completed = db.Column(db.Boolean())
def __repr__(self):
return "<LandingZoneProgressItem(id={self.id!r}, name={self.label!r})>".format(
self=self)
class BookList(db.Model):
__tablename__ = 'book_list'
id = db.Column(db.Integer, primary_key=True)
private_list = db.Column(db.Boolean(), default=False);
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
books = db.relationship("Book", secondary=book_list_identifier, backref = db.backref('book_list', lazy = 'dynamic'))
def serialize(self):
return {'id': self.id, 'private_list': self.private_list, 'user_id': self.user_id, 'books': [b.serialize() for b in self.books]}
class BusinessUnit(db.Model):
__tablename__ = "businessunit"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
description = db.Column(db.String(200))
isActive = db.Column(db.Boolean())
def __repr__(self):
return "<BusinessUnit(id={self.id!r}, name={self.name!r})>".format(
self=self)
class Naming(db.Model):
__tablename__ = "resourceDefinition"
index = db.Column(db.Integer)
name = db.Column(db.String(64), primary_key=True,
unique=True, nullable=False)
regex = db.Column(db.String(256))
scope = db.Column(db.String(16))
slug = db.Column(db.String(16))
dashes = db.Column(db.Boolean())
lengthmin = db.Column(db.Integer())
lengthmax = db.Column(db.Integer())
class RegularTask(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), nullable=False)
label = db.Column(db.String(120), nullable=False)
task_desc = db.Column(db.String(400), nullable=False)
time_created = db.Column(db.DateTime(), nullable=False)
end_time = db.Column(db.DateTime())
is_done = db.Column(db.Boolean(), nullable=False)
def save_task(self):
ses = db.session
ses.add(self)
ses.commit()
@classmethod
def get_task_by_user(cls, username):
return list(
map(lambda x: x.serialize,
cls.query.filter_by(username=username).all()))
@classmethod
def get_task_by_user_and_id(cls, username, id):
return cls.query.filter_by(username=username, id=id).first()
@classmethod
def get_task_by_user_and_id_json(cls, username, id):
return list(
map(lambda x: x.serialize,
cls.query.filter_by(username=username, id=id).all()))
def mark_as_done(self):
self.is_done = not self.is_done
db.session.commit()
def delete_task(self):
db.session.delete(self)
db.session.commit()
def update(self):
db.session.commit()
@property
def serialize(self):
return {
'id': self.id,
'label': self.label,
'task_desc': self.task_desc,
'username': self.username,
'is_done': self.is_done,
'time_created': self.time_created.isoformat(),
'end_time': self.end_time.isoformat()
}
class SharedServicesProgressItem(db.Model):
__tablename__ = "sharedservicesprogressitem"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String)
completed = db.Column(db.Boolean())
def __repr__(self):
return (
"<SharedServicesProgressItem(id={self.id!r}, name={self.label!r})>"
.format(self=self))
class Team(db.Model):
__tablename__ = "team"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
description = db.Column(db.String(200))
cloudIdentityGroup = db.Column(db.String(200))
businessUnitId = db.Column(db.Integer)
lastUpdated = db.Column(db.String(20))
isActive = db.Column(db.Boolean())
accessRequestedById = db.Column(db.Integer,
db.ForeignKey("eagle_db.user.id"))
class ActivatorCD(db.Model):
__tablename__ = "activatorCD"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
activatorId = db.Column(db.Integer(),
db.ForeignKey("eagle_db.activator.id"))
cdId = db.Column(db.Integer(), db.ForeignKey("eagle_db.cd.id"))
lastUpdated = db.Column(db.String(20))
isActive = db.Column(db.Boolean())
def __repr__(self):
return "<Activator(id={self.id!r}, activatorId={self.activatorId!r}, activatorId={self.cdId!r})>".format(
self=self)
class SolutionEnvironment(db.Model):
__tablename__ = "solutionenvironment"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
solutionId = db.Column(db.Integer(), db.ForeignKey("eagle_db.solution.id"))
environmentId = db.Column(db.Integer(),
db.ForeignKey("eagle_db.lzenvironment.id"))
lastUpdated = db.Column(db.String(20))
isActive = db.Column(db.Boolean())
def __repr__(self):
return "<Solution(id={self.id!r}, solutionId={self.solutionId!r}, solutionId={self.environmentId!r})>".format(
self=self)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer(), USER_ID_SEQ, primary_key=True, server_default=USER_ID_SEQ.next_value())
login = db.Column(db.String(80), unique=False, nullable=False)
password = db.Column(db.String(120), unique=False, nullable=False)
admin_access = db.Column(db.Boolean(),unique=False, nullable=False, default=False)
def __init__ (self, login, password, admin_access):
self.login = login
self.password = password
self.admin_access = admin_access
def __repr__(self):
return "User(%d, %s, %s, %s)" %(self.id, self.login, self.password, self.admin_access)
class NotificationApplicationDeployment(db.Model):
__tablename__ = "notificationApplicationDeployment"
__table_args__ = {"schema": "eagle_db"}
isActive = db.Column(db.Boolean())
lastUpdated = db.Column(db.String(20))
notificationId = db.Column(db.Integer(),
db.ForeignKey("eagle_db.notification.id"),
primary_key=True)
applicationId = db.Column(db.Integer(),
db.ForeignKey("eagle_db.application.id"),
primary_key=True)
def __repr__(self):
return "<NotificationApplicationDeployment(notificationId={self.notificationId!r}, applicationId={self.applicationId!r})>".format(
self=self)
class ActivatorMetadataVariable(db.Model):
__tablename__ = "activatorMetadataVariables"
__table_args__ = {"schema": "eagle_db"}
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
activatorMetadataId = db.Column(
db.Integer(), db.ForeignKey("eagle_db.activatorMetadata.id"))
name = db.Column(db.String(255))
type = db.Column(db.String(255))
value = db.Column(db.String(255))
defaultValue = db.Column(db.String(255))
isOptional = db.Column(db.Boolean())
def __repr__(self):
return "<ActivatorMetadataVariable(id={self.id!r}, activatorMetadataId={self.activatorMetadataId!r})>".format(
self=self)
class Artist(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
phone = db.Column(db.String(120))
genres = db.Column(db.String(120))
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120))
website = db.Column(db.String(120))
seeking_venue = db.Column(db.Boolean())
seeking_description = db.Column(db.String(500))
shows = db.relationship("Show",
cascade="all,delete",
back_populates="artist")
def __repr__(self):
return f'{self.id}: {self.name}'
class Venue(db.Model):
__tablename__ = 'Venue'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=True)
genres = db.Column(db.ARRAY(db.String(120)), nullable=True, default=[])
address = db.Column(db.String(120), nullable=True)
city = db.Column(db.String(120), nullable=True)
state = db.Column(db.String(120), nullable=True)
phone = db.Column(db.String(120))
website = db.Column(db.String(120))
facebook_link = db.Column(db.String(120))
seeking_talent = db.Column(db.Boolean())
seeking_description = db.Column(db.String(120))
image_link = db.Column(db.String(500))
venue_shows = db.relationship('Show', backref='Venue', lazy=True)
def __repr__(self):
return f'<Venue {self.id} {self.name}>'
class User(UserRepository):
__tablename__ = "users"
#id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
date_of_birth = db.Column(db.DateTime)
email = db.Column(db.String(80), unique=True)
deleted = db.Column(db.Boolean(), default=False)
def __repr__(self):
return '<User(name {}, email: {})>'.format(
self.name, self.email) if not self.deleted else None
@validates('name')
def validate_name(self, key, name):
if not name:
raise AssertionError('No name provided')
if not re.match("[a-zA-Z ]+", name):
raise AssertionError(
'The name should contain only latin alphabet letters')
if len(name) < 3 or len(name) > 20:
raise AssertionError(
'The name must be between 4 and 20 characters')
return name
@validates('email')
def validate_email(self, key, email):
if not email:
raise AssertionError('No email provided')
if db.session.query(User).filter(User.email == email).one_or_none():
raise AssertionError('There is already a user with this email')
if not re.match("[^@]+@[^@]+\.[^@]+", email):
raise AssertionError('Provided email is not an email address')
return email
@validates('date_of_birth')
def validate_dob(self, key, date_of_birth):
if not date_of_birth:
raise AssertionError('No date of birth provided')
return datetime.datetime.strptime(date_of_birth, '%Y-%m-%d')
