class UserOrgRole(db.Model):
__tablename__ = "user_org_role"
user_id = db.Column(db.ForeignKey('user.user_id'),
nullable=False,
primary_key=True,
index=True)
org_id = db.Column(db.ForeignKey('organization.org_id'),
nullable=True,
primary_key=True,
index=True)
role_id = db.Column(db.ForeignKey('role.role_id'),
nullable=False,
primary_key=True,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
def __init__(self, user_id, org_id, role_id, owner_id):
self.user_id = user_id
self.org_id = org_id
self.role_id = role_id
self.owner_id = owner_id
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Appointment(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
room = db.Column(db.Integer,
db.ForeignKey('room.roomNumber'),
nullable=False)
clinic_id = db.Column(db.Integer,
db.ForeignKey('clinic.id'),
nullable=False)
doctor_permit_number = db.Column(db.String(7),
db.ForeignKey('doctor.permit_number'),
nullable=False)
patient_hcnumber = db.Column(db.String(12),
db.ForeignKey('patient.hcnumber'),
nullable=False)
length = db.Column(db.Integer, nullable=False)
time = db.Column(db.String(), nullable=False)
date = db.Column(db.Date(), nullable=False)
def __iter__(self):
yield 'id', self.id
yield 'room', self.room
yield 'clinic_id', self.clinic_id
yield 'doctor_permit_number', self.doctor_permit_number
yield 'patient_hcnumber', self.patient_hcnumber
yield 'length', self.length
yield 'time', self.time
yield 'date', self.date.strftime("%Y-%m-%d")
class TestCase(db.Model):
__tablename__ = "test_case"
test_case_id = db.Column(db.Integer, primary_key=True)
test_suite_id = db.Column(db.ForeignKey(TestSuite.test_suite_id))
test_id = db.Column(db.String(80), nullable=True)
test_status = db.Column(db.Integer, nullable=True)
test_case_detail = db.Column(LONGTEXT, nullable=True)
test_name = db.Column(db.String(80), nullable=True)
src_db_id = db.Column(db.ForeignKey('dbdetail.db_id'))
target_db_id = db.Column(db.ForeignKey('dbdetail.db_id'))
created = db.Column(db.DateTime, default=datetime.datetime.now)
test_suite = db.relationship(TestSuite,
back_populates='test_case',
lazy=True)
test_case_log = db.relationship("TestCaseLog",
back_populates='test_cases',
lazy=True)
src_db = db.relationship("DbDetail", foreign_keys=[src_db_id])
target_db = db.relationship("DbDetail", foreign_keys=[target_db_id])
def save_to_db(self):
db.session.add(self)
db.session.commit()
def __init__(self, test_suite_id, test_id, test_status, test_case_detail,
test_name, src_db_id, target_db_id):
self.test_suite_id = test_suite_id
self.test_id = test_id
self.test_status = test_status
self.test_name = test_name
self.test_case_detail = test_case_detail
self.src_db_id = src_db_id
self.target_db_id = target_db_id
class DbConnection(db.Model):
__tablename__ = "db_connection"
db_connection_id = db.Column(
db.Integer,
primary_key=True,
)
project_id = db.Column(db.ForeignKey('project.project_id'),
nullable=False,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
db_connection_name = db.Column(db.Text)
db_type = db.Column(db.SMALLINT, nullable=False)
db_name = db.Column(db.String(80), nullable=False)
db_hostname = db.Column(db.String(255), nullable=False)
db_username = db.Column(db.String(80), nullable=False)
db_encrypted_password = db.Column(db.Text, nullable=False)
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
def __init__(self, project_id, owner_id, db_connection_name, db_type,
db_name, db_hostname, db_username, db_encrypted_password):
self.project_id = project_id
self.owner_id = owner_id
self.db_connection_name = db_connection_name
self.db_type = db_type
self.db_name = db_name
self.db_hostname = db_hostname
self.db_username = db_username
self.db_encrypted_password = db_encrypted_password
def save_to_db(self):
db.session.add(self)
db.session.commit()
class TestSuite(db.Model):
__tablename__ = "test_suite"
test_suite_id = db.Column(db.Integer, primary_key=True)
project_id = db.Column(db.ForeignKey('project.project_id'),
nullable=False,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
excel_name = db.Column(db.Text)
test_suite_name = db.Column(db.Text, nullable=False)
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
test_case = db.relationship("TestCase",
back_populates='test_suite',
lazy=True,
order_by='TestCase.created_at')
def __init__(self, project_id, owner_id, excel_name, test_suite_name):
self.project_id = project_id
self.owner_id = owner_id
self.excel_name = excel_name
self.test_suite_name = test_suite_name
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Person(db.Model):
id = db.Column(db.Integer(), primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(120), unique=True, nullable=False)
phone_number = db.Column(db.String(50))
password = db.Column(db.String(255), nullable=False)
address_id = db.Column(db.Integer(), db.ForeignKey('address.id'))
job_id = db.Column(db.Integer(), db.ForeignKey('job.id'))
stage_id = db.Column(db.Integer(), db.ForeignKey('stage.id'))
def __init__(self, first_name, last_name, email, phone_number, password,
address_id, job_id, stage_id):
self.first_name = first_name
self.last_name = last_name
self.email = email
self.phone_number = phone_number
self.active = True
self.password = Person.hashed_password(password)
self.address_id = address_id
self.job_id = job_id
self.stage_id = stage_id
@staticmethod
def hashed_password(password):
return bcrypt.generate_password_hash(password).decode("utf-8")
@staticmethod
def get_person_with_email_and_password(email, password):
person = Person.query.filter_by(email=email).first()
if person and bcrypt.check_password_hash(person.password, password):
return person
else:
return None
class Job(db.Model):
__tablename__ = "job"
job_id = db.Column(db.Integer, primary_key=True)
test_suite_id = db.Column(db.ForeignKey('test_suite.test_suite_id'),
nullable=False,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
is_external_trigger = db.Column(db.Boolean, nullable=False)
execution_status = db.Column(db.SMALLINT, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
def __init__(
self,
test_suite_id,
owner_id,
is_external_trigger=False,
execution_status=ExecutionStatus().get_execution_status_id_by_name(
"new")):
self.test_suite_id = test_suite_id
self.owner_id = owner_id
self.is_external_trigger = is_external_trigger
self.execution_status = execution_status
def save_to_db(self):
db.session.add(self)
db.session.commit()
class TestCase(db.Model):
__tablename__ = "test_case"
test_case_id = db.Column(db.Integer, primary_key=True)
test_suite_id = db.Column(db.ForeignKey('test_suite.test_suite_id'),
nullable=False,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
test_case_class = db.Column(db.SMALLINT, nullable=False)
latest_execution_status = db.Column(
db.SMALLINT,
nullable=False,
default=ExecutionStatus().get_execution_status_id_by_name('new'))
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
test_case_detail = db.Column(JSON, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
test_suite = db.relationship(TestSuite,
back_populates='test_case',
lazy=True)
test_case_log = db.relationship("TestCaseLog",
back_populates='test_cases',
lazy=True,
order_by='TestCaseLog.created_at')
def __init__(self, test_suite_id, owner_id, test_case_class,
test_case_detail):
self.test_suite_id = test_suite_id
self.owner_id = owner_id
self.test_case_class = test_case_class
self.test_case_detail = test_case_detail
def save_to_db(self):
db.session.add(self)
db.session.commit()
class TestCaseLog(db.Model):
__tablename__ = "test_case_log"
test_case_log_id = db.Column(db.Integer, primary_key=True)
test_case_id = db.Column(db.ForeignKey('test_case.test_case_id'),
index=True)
job_id = db.Column(db.ForeignKey('job.job_id'), index=True)
execution_status = db.Column(db.SMALLINT, nullable=False)
dqi_percentage = db.Column(db.Float(precision=2), nullable=True)
execution_log = db.Column(JSON, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now, index=True)
test_cases = db.relationship(TestCase,
back_populates='test_case_log',
lazy=True)
def __init__(
self,
test_case_id,
job_id,
execution_status=ExecutionStatus().get_execution_status_id_by_name(
"new")):
self.test_case_id = test_case_id
self.job_id = job_id
self.execution_status = execution_status
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Menu(db.Model):
__tablename__ = 'menu'
menu_id = db.Column(db.Integer, primary_key=True)
menu_name = db.Column(db.String(60), nullable=False)
menu_order = db.Column(db.Integer, nullable=False)
is_active = db.Column(db.Boolean, nullable=False, default=True)
permission_id = db.Column(db.ForeignKey('permission.permission_id'),
nullable=False)
parameters = db.Column(JSON, nullable=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def __init__(self,
menu_name,
menu_order,
permission_id,
owner_id,
is_active=True):
self.menu_name = menu_name
self.menu_order = menu_order
self.permission_id = permission_id
self.owner_id = owner_id
self.is_active = is_active
class Query(db.Model):
__tablename__ = 'query'
query_id = db.Column(db.Integer, primary_key=True)
query_string = db.Column(db.Text, nullable=False)
project_id = db.Column(db.ForeignKey('project.project_id'),
nullable=False,
index=True)
execution_status = db.Column(db.SMALLINT, nullable=False)
db_connection_id = db.Column(
db.ForeignKey('db_connection.db_connection_id'),
nullable=False,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
query_result = db.Column(JSON, nullable=True)
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def __init__(self, project_id, db_connection_id, query_string,
execution_status, owner_id):
self.project_id = project_id
self.db_connection_id = db_connection_id
self.query_string = query_string
self.execution_status = execution_status
self.owner_id = owner_id
class UsersRoles(db.Model):
__tablename__ = 'users_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class Role(db.Model):
__tablename__ = "role"
role_id = db.Column(db.Integer, primary_key=True, index=True)
org_id = db.Column(db.ForeignKey('organization.org_id'),
nullable=False,
index=True)
role_name = db.Column(db.String(50), nullable=False)
description = db.Column(db.Text, nullable=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
def __init__(self, role_name, org_id, owner_id, description):
self.role_name = role_name
self.org_id = org_id
self.owner_id = owner_id
self.description = description
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Like(db.Model):
__tablename__ = 'Like'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('User.id'))
photo_id = db.Column(db.Integer, db.ForeignKey('Photo.id'))
date_created = db.Column(db.DateTime, default=datetime.utcnow)
date_updated = db.Column(db.DateTime, default=datetime.utcnow)
class UserRequestedCommunity(db.Model):
__tablename__ = 'user_requested_community'
userID = db.Column(db.String(128),
db.ForeignKey('users.username'),
primary_key=True)
communityID = db.Column(db.Integer,
db.ForeignKey('community.ID'),
primary_key=True)
class UserModerator(db.Model):
__tablename__ = 'user_moderator'
communityID = db.Column(db.Integer,
db.ForeignKey('community.ID'),
primary_key=True)
moderator = db.Column(db.String(128),
db.ForeignKey('users.username'),
primary_key=True)
class TagToPost(db.Model):
id = db.Column(db.Integer(), primary_key=True)
tag = db.Column(db.Integer, db.ForeignKey("tag.id"), nullable=False)
post = db.Column(db.Integer, db.ForeignKey("post.id"), nullable=False)
def __init__(self, name, color):
self.active = True
self.name = name
self.color = color
class UserSession(db.Model):
__tablename__ = "user_session"
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
date = db.Column(db.Date())
sets = db.relationship("UserSet")
note = db.Column(db.Text())
grip = db.Column(db.String(255))
program = db.Column(db.Integer(), db.ForeignKey("program_template.id"))
class Request(db.Model):
id = db.Column(db.Integer(), primary_key=True)
person_id = db.Column(db.Integer(),
db.ForeignKey('person.id'),
nullable=False)
product_id = db.Column(db.Integer(),
db.ForeignKey('product.id'),
nullable=False)
request_justfication = db.Column(db.Text())
request_date = db.Column(db.DateTime())
class Edge(db.Model):
__tablename__ = 'edge'
id = db.Column(db.Integer(), primary_key=True)
source = db.Column(db.Integer(), db.ForeignKey('node.id'), nullable=False)
target = db.Column(db.Integer(), db.ForeignKey('node.id'), nullable=False)
crawlerId = db.Column(db.Integer(),
db.ForeignKey('crawler.id'),
nullable=False)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
author = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
location = db.Column(db.Integer,
db.ForeignKey("location.id"),
nullable=False)
title = db.Column(db.String(255), unique=True)
body = db.Column(db.String(255))
def __init__(self, title, body, author_id, location):
self.active = True
self.title = title
self.body = body
self.author = author_id
self.location = location
class City(db.Model):
__bind_key__ = 'wehomeproperty'
id = db.Column(db.Integer(), index=True, primary_key=True)
geoid = db.Column(db.String(255), index=True, unique=True)
area_geoid = db.Column(db.String(255), db.ForeignKey('area.geoid'), index=True)
state_geoid = db.Column(db.String(255), db.ForeignKey('state.geoid'),index=True)
zipcodes = db.relationship('Zipcode', backref='city')
neighbors = db.relationship('Neighbor', backref='city_')
name = db.Column(db.String(255), index=True)
lat = db.Column(db.Float())
lng = db.Column(db.Float())
properties = db.Column(JSON)
created_at = db.Column(db.DateTime(), default=datetime.datetime.now)
updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
resume = db.Column(db.String(140), nullable=False)
titre = db.Column(db.String(140), nullable=False)
content = db.Column(db.String(140), nullable=False)
date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
class Cardhist(db.Model):
__tablename__ = 'cardhist'
id = db.Column(db.Integer, primary_key=True)
playerId = db.Column(db.Integer, db.ForeignKey('player.id'))
cardId = db.Column(db.Integer, db.ForeignKey('card.id'))
card_name = db.Column(db.String(30), default='')
card_colour = db.Column(db.String(30), default='')
discarded = db.Column(db.Boolean, default=False)
for_wonder = db.Column(db.Boolean, default=False)
def serialise(self):
return {
'playerId': self.playerId,
'card_name': self.card_name,
'card_colour': self.card_colour
}
class Offer(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
asal = db.Column(db.String(255))
tujuan = db.Column(db.String(255))
fee = db.Column(db.Integer())
time = db.Column(db.DateTime())
passenger = db.Column(db.Integer)
color = db.Column(db.Integer)
@staticmethod
def get_all_offers():
offers = Offer.query.all()
offers = {
x.id: {
'user_id': x.user_id,
'asal': x.asal,
'tujuan': x.tujuan,
'fee': x.fee,
'time': x.time,
'passenger': x.passenger,
'passengers': [y.id for y in x.passenger_list],
'color': x.color
}
for x in offers
}
return offers
class Object(db.Model):
id = db.Column(db.Integer, primary_key=True)
object_name = db.Column(db.String(120), nullable=False)
object_parent_id = db.Column(db.Integer, nullable=True)
object_server_id = db.Column(db.Integer,
db.ForeignKey('server.id',
ondelete='CASCADE'),
nullable=False)
object_variables = db.relationship("Variable",
backref="object",
cascade="all, delete-orphan",
lazy='dynamic')
def has_child(self):
return True if Object.query.filter_by(
object_parent_id=self.id) else False
def is_parent(self):
return True if self.object_parent_id is None else False
def get_parent(self):
return Object.query.get(self.object_parent_id)
def get_child_objects(self):
return self.query.filter_by(
object_parent_id=self.id) if Object.query.filter_by(
object_parent_id=self.id) else False
def __repr__(self):
return "Object: {}".format(self.object_name)
class ChallengeFollower(db.Model):
id = db.Column(db.Integer(), primary_key=True)
challenge_instance_id = db.Column(db.Integer(),
db.ForeignKey("challenge_instance.id"),
nullable=False)
challenge_instance = db.relationship('ChallengeInstance')
follower_id = db.Column(db.Integer(),
db.ForeignKey("user.id"),
nullable=False)
follower = db.relationship('User')
date_joined = db.Column(db.DateTime(), nullable=False)
def __init__(self, challenge, follower):
self.challenge_instance = challenge
self.follower = follower
self.date_joined = datetime.datetime.now()
class Community(db.Model):
__tablename__ = 'community'
ID = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), index=True, unique=True)
description = db.Column(db.String(256), index=True)
address = db.Column(db.String(128), index=True, unique=False)
city = db.Column(db.String(15), index=True, unique=False)
zip_code = db.Column(db.Integer, index=True, unique=False)
creation_date = db.Column(db.DateTime,
index=True,
unique=False,
default=False)
created_by = db.Column(db.String(128), db.ForeignKey('users.username'))
status = db.Column(db.String(60), index=True, default="requested")
def gravatar_hash(self):
return hashlib.md5(self.name.lower().encode('utf-8')).hexdigest()
def gravatar(self, size=100, default='identicon', rating='g'):
if request.is_secure:
url = 'https://secure.gravatar.com/avatar'
else:
url = 'http://www.gravatar.com/avatar'
hash = self.gravatar_hash()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
class Image(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False)
data = db.Column(db.LargeBinary())
categories = db.Column(db.String(255))
public = db.Column(db.Integer())
file_name = db.Column(db.String(255))
def __init__(self, user_id, file_name, data, categories=None, public=0):
self.data = data
self.categories = categories
self.public = public
self.user_id = User.query.get(user_id).id
self.file_name = file_name
@staticmethod
def get_all_public_images():
images = Image.query.filter(Image.public == 1)
return images
@staticmethod
def get_allowed_images_from_user(queried_user, querying_user):
if queried_user == querying_user:
return Image.query.filter(Image.user_id == querying_user)
else:
return Image.query.filter((Image.user_id == queried_user)
& Image.public)
class Article(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(120), nullable=False)
link = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return "Article('{self.title}')"
