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 }