class TaskRemarksHistory(db.Model, HistoryMixin):
__tablename__ = 'task_history'
id = db.Column(db.Integer, primary_key=True)
task_id = db.Column(db.Integer, db.ForeignKey('task.id'), nullable=False)
task = db.relationship('Task', backref='remarks')
task_creator = db.relationship('User', backref='tasks_created')
class Category(db.Model):
"""Categories"""
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False)
is_active = db.Column(db.Boolean, nullable=False, server_default="true")
categories_services = db.relationship(
"CategoryService", backref="category", cascade="all, delete, delete-orphan", passive_deletes=True)
services = db.relationship(
"Service", secondary="categories_services", backref="categories")
def __repr__(self):
"""Representation of this class"""
e = self
return f"<Category id={e.id} name={e.name}>"
def serialize(self):
"""Serialize a Category SQLAlchemy obj to dictionary."""
return {
"id": self.id,
"name": self.name,
"is_active": self.is_active
}
class ProjectRemarksHistory(db.Model, HistoryMixin):
__tablename__ = 'project_history'
id = db.Column(db.Integer, primary_key=True)
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
nullable=False)
project = db.relationship('Project', backref='remarks')
user = db.relationship('User', backref='project_remarks')
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256))
email = db.Column(db.String(256))
password = db.Column(db.String(256), nullable=False)
date_created = db.Column(db.DateTime)
admin = db.Column(db.Boolean)
transactions = db.relationship("Transaction", backref="users", lazy=True)
blacklist = db.relationship("Blacklist", backref="users", lazy=True)
def __repr__(self):
return '<User %r>' % self.name
class Task(db.Model):
__tablename__ = 'task'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False, unique=True)
description = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime,
server_default=func.now(),
nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('user.id'))
assigned_by = db.Column(db.Integer, db.ForeignKey('user.id'))
assigned_to = db.Column(db.Integer, db.ForeignKey('user.id'))
reviewed_by = db.Column(db.Integer, db.ForeignKey('user.id'))
created_by_id = db.relationship('User', foreign_keys=[created_by])
assigned_by_id = db.relationship('User', foreign_keys=[assigned_by])
assigned_to_id = db.relationship('User', foreign_keys=[assigned_to])
reviewed_by_id = db.relationship('User', foreign_keys=[reviewed_by])
status_id = db.Column(db.Integer, db.ForeignKey('status.id'))
status = db.relationship('Status', backref='tasks')
criticality_id = db.Column(db.Integer, db.ForeignKey('criticality.id'))
criticality = db.relationship('Criticality', backref='tasks')
expected_completion_date = db.Column(
db.DateTime,
server_default=Computed(sqltext=text('created_at + INTERVAL 3 DAY'),
persisted=True),
nullable=False)
project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
project = db.relationship('Project', backref='tasks')
actual_completion_date = db.Column(db.DateTime,
server_default=null(),
nullable=True)
class Organisation(db.Model):
__tablename__ = 'organisation'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(70), nullable=False, unique=True)
passcode = db.Column(db.Text, nullable=False)
location = db.Column(db.String(30), nullable=False)
registered_at = db.Column(db.DateTime,
server_default=func.now(),
nullable=False)
registered_by = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
organisation_registerer = db.relationship(
'User', backref='organisation_registered', uselist=False)
user_organisation = db.relationship('User',
backref='users',
secondary='user_organisation')
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(256), index=True, unique=True)
price = db.Column(db.Float)
inventory_count = db.Column(db.Integer)
cartitems = db.relationship("CartItem", backref="products", lazy=True)
def __repr__(self):
return '<Product %r>' % self.title
class Admin(db.Model):
__tablename__ = 'admins'
email = db.Column(db.String(256), primary_key=True)
name = db.Column(db.String(256))
date_created = db.Column(db.DateTime)
items = db.relationship("Item", backref="admins", lazy=True)
def __repr__(self):
return '<Admin %r>' % self.name
class Cart(db.Model):
__tablename__ = 'carts'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, unique=True)
created_date = db.Column(db.DateTime)
total = db.Column(db.Float)
carts = db.relationship("CartItem", backref="carts", lazy=True)
def __repr__(self):
return '<Cart %r>' % self.id
class Item(db.Model):
__tablename__ = 'cars'
name = db.Column(db.String(256), primary_key=True, unique=True)
date_in = db.Column(db.DateTime)
date_out = db.Column(db.DateTime)
quantity = db.Column(db.Integer)
transactions = db.relationship("Transaction", backref="cars", lazy=True)
def __repr__(self):
return '<Car %r>' % self.name
class Author(db.Model):
__tablname__ = "author"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(30), nullable=False)
articles = db.relationship("Article", backref="author")
create_time = db.Column(db.DateTime, default=datetime.now, nullable=False)
update_time = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
def __str__(self):
return "%s" % self.name
class Project(db.Model):
__tablename__ = 'project'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.String(255), nullable=False, server_default='')
status_id = db.Column(db.Integer, db.ForeignKey('status.id'))
status = db.relationship('Status', backref='projects')
created_at = db.Column(db.DateTime,
server_default=func.now(),
nullable=False)
organisation_id = db.Column(db.Integer, db.ForeignKey('organisation.id'))
organisation = db.relationship('Organisation', backref='projects')
created_by = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
project_creator = db.relationship('User', backref='projects_created_by')
project_users = db.relationship('User',
backref='user_projects',
secondary='user_project')
class Item(db.Model):
__tablename__ = 'items'
name = db.Column(db.String(256), primary_key=True)
created_by = db.Column(db.String(256), db.ForeignKey('admins.email'))
date_in = db.Column(db.DateTime)
date_out = db.Column(db.DateTime)
quantity = db.Column(db.Integer)
transactions = db.relationship("Transaction", backref="items", lazy=True)
def __repr__(self):
return '<Item %r>' % self.name
class User(db.Model):
"""User Model"""
__tablename__ = 'user'
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(200), nullable=False, unique=True)
password = db.Column(db.Text, nullable=False)
is_verified = db.Column(db.Boolean, server_default=text('0'))
created_at = db.Column(db.DateTime, server_default=func.now())
role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False)
role = db.relationship('Role', backref='users')
class Province(db.Model):
__tablename__ = 'province'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
province_name = db.Column(db.String(10), nullable=False)
city = db.relationship('City', backref='province', lazy='dynamic')
def __init__(self, province_name):
self.province_name = province_name
@staticmethod
def generateDict(province):
province_dict = {}
province_dict['province_id'] = province.id
province_dict['provinceName'] = province.province_name
return province_dict
class FeaturedArticle(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
article_id = db.Column(db.Integer,
db.ForeignKey("article.id"),
nullable=False)
article_title = db.relationship("Article",
backref="featured",
uselist=False)
create_time = db.Column(db.DateTime, default=datetime.now)
update_time = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
def __str__(self):
return "%s" % self.id
class Application(db.Model):
__tablename__ = "applications"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String)
user_id = db.Column(db.String)
is_inhouse_posting = db.Column(db.Boolean)
status = db.Column(db.String(256))
resume = db.Column(db.String(256))
comment = db.Column(db.String(256))
inhouse = db.relationship("Inhouse", backref="applications", lazy=True)
external = db.relationship("External", backref="applications", lazy=True)
interviewquestions = db.relationship("InterviewQuestion",
backref="applications",
lazy=True)
def __repr__(self):
return '<Application %r>' % self.id
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class Tender(db.Model):
__tablename__ = 'tender'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(20), nullable=False)
content = db.Column(db.String(100), nullable=False)
publish_date = db.Column(db.Date)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
city_id = db.Column(db.Integer, db.ForeignKey('city.id'))
users = db.relationship('User', backref=db.backref('tenders'))
def __init__(self, title, content, user_id, city_id, publish_date):
self.title = title
self.content = content
self.user_id = user_id
self.city_id = city_id
self.publish_date = publish_date
class Appointment(db.Model):
"""Appointments"""
__tablename__ = 'appointments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# available after generated google calendar event
event_id = db.Column(db.Text, server_default="")
provider_username = db.Column(db.String(20), db.ForeignKey(
'users.username', ondelete="CASCADE"))
customer_username = db.Column(db.String(20), db.ForeignKey(
'users.username', ondelete="CASCADE"))
start = db.Column(db.TIMESTAMP(timezone=True), nullable=False)
end = db.Column(db.TIMESTAMP(timezone=True), nullable=False)
service_id = db.Column(db.Integer, db.ForeignKey(
'services.id', ondelete="CASCADE"))
note = db.Column(db.Text, nullable=False, server_default="")
updated = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
server_default=sqlalchemy.func.now()
)
created = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
server_default=sqlalchemy.func.now()
)
is_active = db.Column(db.Boolean, nullable=False, server_default="TRUE")
provider = db.relationship("User", foreign_keys=[provider_username], backref=db.backref(
"appointments_as_provider", lazy="dynamic"))
customer = db.relationship("User", foreign_keys=[customer_username], backref=db.backref(
"appointments_as_customer", lazy="dynamic"))
service = db.relationship("Service", foreign_keys=[service_id])
@property
def summary(self):
"""Return the google calendar summary"""
return f"{self.service.name} with {self.customer.full_name}"
@property
def description(self):
"""Return the google calendar description"""
return f"""Service:{self.service.name}
Customer:{self.customer.full_name}
Provider:{self.provider.full_name}
Time:{self.start} to {self.end}
Note:{self.note}"""
def __repr__(self):
"""Representation of this class"""
e = self
return f"<Appointment id={e.id} provider_username={e.provider_username} customer_username={e.customer_username} start={e.start} end={e.end}>"
@staticmethod
def check_available(username, start, end, appointment_id=0):
"""Check if there is a conflict with a schedule"""
count = Appointment.query.filter(
(Appointment.is_active == True) &
(Appointment.provider_username == username) &
(Appointment.id != appointment_id) &
(
(
((Appointment.start <= start) & (Appointment.end > start)) |
((Appointment.start < end)
& (Appointment.end >= end))
) |
(
((Appointment.start >= start) & (Appointment.start < end)) |
((Appointment.end > start)
& (Appointment.end <= end))
)
)).count()
return (count == 0)
@property
def available(self):
"""Check if the time frame is available"""
return Appointment.check_available(self.provider_username, self.start, self.end, self.id)
def serialize(self):
"""Serialize a Appointment SQLAlchemy obj to dictionary."""
return {
"id": self.id,
"event_id": self.event_id,
"provider_username": self.provider_username,
"customer_username": self.customer_username,
"start": self.start.isoformat(),
"end": self.end.isoformat(),
"service_id": self.service_id,
"note": self.note,
"summary": self.summary,
"description": self.description,
"updated": self.updated,
"created": self.created,
"is_active": self.is_active,
"provider": self.provider.full_name,
"customer": self.customer.full_name,
"service": self.service.name
}
class User(db.Model):
"""User"""
__tablename__ = 'users'
# regualar information
username = db.Column(db.String(20), primary_key=True)
password = db.Column(db.Text, nullable=False)
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)
phone = db.Column(db.String(20), server_default='')
description = db.Column(db.Text, server_default='')
image = db.Column(db.Text, server_default='')
# for google calendar use
calendar_id = db.Column(db.Text, server_default='')
calendar_email = db.Column(db.String(50), server_default='')
#provider or customer
is_provider = db.Column(db.Boolean, nullable=False, server_default="FALSE")
updated = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
server_default=sqlalchemy.func.now()
)
created = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
server_default=sqlalchemy.func.now()
)
pwd_token = db.Column(db.Text, nullable=True, server_default='')
is_active = db.Column(db.Boolean, nullable=False, server_default="TRUE")
# Services
services = db.relationship(
"Service", backref="user", cascade="all, delete, delete-orphan", passive_deletes=True)
# Schedules
schedules = db.relationship(
"Schedule", backref="user", cascade="all, delete, delete-orphan", passive_deletes=True)
@property
def full_name(self):
"""Return the full name of the admin"""
if self.first_name == '' and self.last_name == '':
return self.username
return f"{self.first_name} {self.last_name}"
@property
def image_url(self):
"""Return the image url"""
if self.image is None or len(self.image) == 0:
return DEFAULT_IMAGE_USER
return upload_file_url(self.image, USER_UPLOAD_DIRNAME)
def __repr__(self):
"""Representation of this class"""
e = self
return f"<User {e.username} {e.first_name} {e.last_name} {e.email}>"
@classmethod
def register(cls, username, password, email, first_name, last_name, is_provider=False):
"""Register user w/hashed password & return user."""
# return instance of user w/username and hashed pwd
return cls(
username=username,
password=hash_password(password),
email=email,
first_name=first_name,
last_name=last_name,
is_provider=is_provider)
@classmethod
def authenticate(cls, username, password):
"""Validate that admin exists & password is correct.
Return admin if valid; else return False.
"""
u = User.query.filter_by(username=username).first()
if u and u.is_active and check_password_hash(u.password, password):
# return admin instance
return u
else:
return False
@classmethod
def update_password(cls, username, password):
"""Update password"""
u = User.query.filter(User.username == username).first()
if u:
u.password = hash_password(password)
db.session.commit()
return u
else:
return False
@classmethod
def update_password_by_token(cls, token, password):
"""Update password by token"""
u = User.query.filter(User.pwd_token == token, User.is_active==True).first()
if u:
u.password = hash_password(password)
u.pwd_token = ''
db.session.commit()
return u
return False
def serialize(self):
"""Serialize a User SQLAlchemy obj to dictionary."""
return {
"username": self.username,
"full_name": self.full_name,
"first_name": self.first_name,
"last_name": self.last_name,
"email": self.email,
"phone": self.phone,
"description": self.description,
"image": self.image,
"image_url": self.image_url,
"is_provider": self.is_provider,
"updated": self.updated,
"created": self.created,
"is_active": self.is_active
}
class Service(db.Model):
"""Services from the providers"""
__tablename__ = 'services'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(20), db.ForeignKey(
'users.username', ondelete="CASCADE"))
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.Text, nullable=False, server_default='')
image = db.Column(db.Text, server_default='')
updated = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
server_default=sqlalchemy.func.now()
)
created = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
server_default=sqlalchemy.func.now()
)
is_active = db.Column(db.Boolean, nullable=False, server_default="TRUE")
categories_services = db.relationship(
"CategoryService", backref="service", cascade="all, delete, delete-orphan", passive_deletes=True)
@property
def image_url(self):
"""Return the image url"""
if self.image is None or len(self.image) == 0:
return DEFAULT_IMAGE_SERVICE
return upload_file_url(self.image, dirname=SERVICE_UPLOAD_DIRNAME)
def set_categoiry_ids(self, ids=[]):
"""Set categories with category_id list"""
self.categories_services.clear()
for category_id in ids:
self.categories_services.append(CategoryService(
category_id=int(category_id), service_id=self.id))
def get_category_ids(self):
"""Return the list of the category_ids"""
ids = []
for item in self.categories_services:
ids.append(item.category_id)
return ids
def __repr__(self):
"""Representation of this class"""
e = self
return f"<Service name={e.name} username={e.username}>"
def serialize(self):
"""Serialize a Service SQLAlchemy obj to dictionary."""
return {
"id": self.id,
"username": self.username,
"name": self.name,
"description": self.description,
"image": self.image,
"image_url": self.image_url,
"updated": self.updated,
"created": self.created,
"is_active": self.is_active,
"categories": [category.serialize() for category in self.categories],
"category_ids": self.get_category_ids(),
"provider": self.user.full_name
}