class Skills(db.Model):
__tablename__ = "skills"
__table_args__ = {'extend_existing': True}
skills_id = db.Column(db.Integer, primary_key=True)
skills_name = db.Column(db.String(60))
skills_media_id = db.Column(db.Integer)
skills_description = db.Column(
db.String(1000)) # FIXME: Max Length of Text in PostgreSQL
skills_updated_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
def __init__(self,
skills_id: int = None,
skills_name: str = None,
skills_media_id: int = None,
skills_description: str = None,
skills_updated_date: str = None):
self.skills_id = skills_id
self.skills_name = skills_name
self.skills_media_id = skills_media_id
self.skills_description = skills_description
self.skills_updated_date = skills_updated_date
def __repr__(self):
return f'<Skills {self.skills_id}, {self.skills_name}, {self.skills_media_id}, {self.skills_description}, {self.skills_updated_date}>'
class NotificationType(db.Model):
__tablename__ = "notification_type"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(15), unique=True, nullable=False)
def __init__(self, id: int = None, name: str = None):
self.id = id
self.name = name
def __repr__(self):
return f'<NotificationType {self.name}>'
class Country(db.Model):
__tablename__ = "country"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
def __init__(self, id: int = None, name: str = None):
self.id = id
self.name = name
def __repr__(self):
return f'<Country {self.name}>'
class ZipCode(db.Model):
__tablename__ = "zip_code"
__table_args__ = {'extend_existing': True}
id_zip_code = db.Column(db.Integer, primary_key=True)
zip_code = db.Column(db.String(10))
def __init__(self, id_zip_code: int = None, zip_code: str = None):
self.id_zip_code = id_zip_code
self.zip_code = zip_code
def __repr__(self):
return f'<ZipCode {self.id_zip_code}, {self.zip_code}>'
class Address(db.Model):
__tablename__ = "address"
id = db.Column(db.Integer, primary_key=True)
street = db.Column(db.String(80))
outer_number = db.Column(db.String(10))
inner_number = db.Column(db.String(10))
neighborhood_id = db.Column(db.Integer)
muncipality_id = db.Column(db.Integer)
zip_code = db.Column(db.String(80))
state_id = db.Column(db.Integer)
def __init__(self,
id: int = None,
street: str = None,
outer_number: str = None,
inner_number: str = None,
neighborhood_id: int = None,
muncipality_id: int = None,
zip_code: int = None,
state_id: int = None):
self.id = id
self.street = street
self.outer_number = outer_number
self.inner_number = inner_number
self.neighborhood_id = neighborhood_id
self.muncipality_id = muncipality_id
self.zip_code = zip_code
self.state_id = state_id
def __repr__(self):
return '<Address {id}, {street}, {outer_number}, {inner_number}, {neighborhood_id}, {muncipality_id}, {zip_code}, {state_id}>'.format(
**self)
class Role(db.Model):
__tablename__ = "role"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
status = db.Column(db.Integer, nullable=False)
user = db.relationship("User")
def __init__(self, id: int = None, name: str = None, status: str = None):
self.id = id
self.name = name
self.status = status
def __repr__(self):
return '<Role %r>' % self.name
class Album(db.Model):
__tablename__ = "album"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), unique=True, nullable=False)
description = db.Column(db.String(100), nullable=False)
def __init__(self,
id: int = None,
title: str = None,
description: str = None):
self.id = id
self.title = title
self.description = description
def __repr__(self):
return '<Album %r>' % self.title
class Evidence(db.Model):
__tablename__ = "evidence"
__table_args__ = {'extend_existing': True}
evidence_id = db.Column(db.Integer, primary_key=True)
evidence_profession = db.Column(db.Integer)
evidence_media = db.Column(db.Integer)
def __init__(self,
evidence_id: int = None,
evidence_profession: int = None,
evidence_media: int = None):
self.evidence_id = evidence_id
self.evidence_profession = evidence_profession
self.evidence_media = evidence_media
def __repr__(self):
return f'<Evidence {self.evidence_id}, {self.evidence_profession}, {self.evidence_media}>'
class Municipality(db.Model):
__tablename__ = "municipality"
__table_args__ = {'extend_existing': True}
id_municipality = db.Column(db.Integer, primary_key=True)
municipality_name = db.Column(db.String(100))
id_state_code = db.Column(db.Integer)
def __init__(self,
id_municipality: int = None,
municipality_name: str = None,
id_state_code: int = None):
self.id_municipality = id_municipality
self.municipality_name = municipality_name
self.id_state_code = id_state_code
def __repr__(self):
return f'<Municipality {self.id_municipality}, {self.municipality_name}, {self.id_state_code}>'
class WorkingArea(db.Model):
__tablename__ = "working_area"
__table_args__ = {'extend_existing': True}
working_area_id = db.Column(db.Integer, primary_key=True)
working_area_user = db.Column(db.Integer)
working_area_municipality = db.Column(db.Integer)
def __init__(self,
working_area_id: int = None,
working_area_user: int = None,
working_area_municipality: int = None):
self.working_area_id = working_area_id
self.working_area_user = working_area_user
self.working_area_municipality = working_area_municipality
def __repr__(self):
return f'<WorkingArea {self.working_area_id}, {self.working_area_user}, {self.working_area_municipality}>'
class Profession(db.Model):
__tablename__ = "profession"
__table_args__ = {'extend_existing': True}
profession_id = db.Column(db.Integer, primary_key=True)
profession_user = db.Column(db.Integer)
profession_skill = db.Column(db.Integer)
def __init__(self,
profession_id: int = None,
profession_user: int = None,
profession_skill: int = None):
self.profession_id = profession_id
self.profession_user = profession_user
self.profession_skill = profession_skill
def __repr__(self):
return f'<Profession {self.profession_id}, {self.profession_user}, {self.profession_skill}>'
class Org(db.Model):
__tablename__ = "org"
__table_args__ = {'extend_existing': True}
org_id = db.Column(db.Integer, primary_key=True)
org_name = db.Column(db.String(30))
org_media_id = db.Column(db.Integer)
def __init__(self,
org_id: int = None,
org_name: str = None,
org_media_id: int = None):
self.org_id = org_id
self.org_name = org_name
self.org_media_id = org_media_id
def __repr__(self):
return f'<Org {self.org_id}, {self.org_name}, {self.org_media_id}>'
class State(db.Model):
__tablename__ = "state"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
country_id = db.Column(db.Integer, nullable=False)
def __init__(self,
id: int = None,
name: str = None,
country_id: str = None):
self.id = id
self.name = name
self.country_id = country_id
def __repr__(self):
return f'<State {self.name}>'
class CountryCode(db.Model):
__tablename__ = "country_code"
__table_args__ = {'extend_existing': True}
id_country_code = db.Column(db.Integer, primary_key=True)
country_code = db.Column(db.Integer)
country_name = db.Column(db.String(30))
def __init__(self,
id_country_code: int = None,
country_code: int = None,
country_name: str = None):
self.id_country_code = id_country_code
self.country_code = country_code
self.country_name = country_name
def __repr__(self):
return f'<CountryCode {self.id_country_code}, {self.country_code}, {self.country_name}>'
class UserRole(db.Model):
__tablename__ = "user_role"
__table_args__ = {'extend_existing': True}
user_role_id = db.Column(db.Integer, primary_key=True)
user_role_name = db.Column(db.String(20))
user_role_updated_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
def __init__(self,
user_role_id: int = None,
user_role_name: str = None,
user_role_updated_date: str = None):
self.user_role_id = user_role_id
self.user_role_name = user_role_name
self.user_role_updated_date = user_role_updated_date
def __repr__(self):
return f'<UserRole {self.user_role_id}, {self.user_role_name}, {self.user_role_updated_date}>'
class Status(db.Model):
__tablename__ = "status"
__table_args__ = {'extend_existing': True}
status_id = db.Column(db.Integer, primary_key=True)
status_name = db.Column(db.String(15))
status_updated_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
def __init__(self,
status_id: int = None,
status_name: str = None,
status_updated_date: str = None):
self.status_id = status_id
self.status_name = status_name
self.status_updated_date = status_updated_date
def __repr__(self):
return f'<Status {self.status_id}, {self.status_name}, {self.status_updated_date}>'
class StateCode(db.Model):
__tablename__ = "state_code"
__table_args__ = {'extend_existing': True}
id_state_code = db.Column(db.Integer, primary_key=True)
state_code = db.Column(db.String(3))
state_name = db.Column(db.String(25))
id_country_code = db.Column(db.Integer)
def __init__(self,
id_state_code: int = None,
state_code: str = None,
state_name: str = None,
id_country_code: int = None):
self.id_state_code = id_state_code
self.state_code = state_code
self.state_name = state_name
self.id_country_code = id_country_code
def __repr__(self):
return f'<StateCode {self.id_state_code}, {self.state_code}, {self.state_name}, {self.id_country_code}>'
class Colony(db.Model):
__tablename__ = "colony"
__table_args__ = {'extend_existing': True}
id_colony_code = db.Column(db.Integer, primary_key=True)
colony_name = db.Column(db.String(100))
id_municipality = db.Column(db.Integer)
id_zip_code = db.Column(db.Integer)
def __init__(self,
id_colony_code: int = None,
colony_name: str = None,
id_municipality: int = None,
id_zip_code: int = None):
self.id_colony_code = id_colony_code
self.colony_name = colony_name
self.id_municipality = id_municipality
self.id_zip_code = id_zip_code
def __repr__(self):
return f'<Colony {self.id_colony_code}, {self.colony_name}, {self.id_municipality}, {self.id_zip_code}>'
class Category(db.Model):
__tablename__ = "category"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
description = db.Column(db.String(100), nullable=False)
status = db.Column(db.Integer, nullable=False)
def __init__(self,
id: int = None,
name: str = None,
description: str = None,
status: str = None):
self.id = id
self.name = name
self.description = description
self.status = status
def __repr__(self):
return '<Category %r>' % self.name
class Neighbourhood(db.Model):
__tablename__ = "neighbourhood"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=False, nullable=False)
zip_code = db.Column(db.Integer)
municipality_id = db.Column(db.Integer, nullable=False)
def __init__(self,
id: int = None,
name: str = None,
zip_code: int = None,
municipality_id: int = None):
self.id = id
self.name = name
self.zip_code = zip_code
self.municipality_id = municipality_id
def __repr__(self):
return '<Neighbourhood {id}, {name}, {zip_code}, {municipality_id}>'.format(
**self)
class User(UserMixin, db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
uid = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(250), nullable=False)
password_date = db.Column(db.Date)
email = db.Column(db.String(150), unique=True, nullable=False)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
profile = db.relationship("Profile")
def __init__(self,
id: int = None,
password: str = None,
email: str = None,
image_profile: str = None,
role_id: int = None):
self.id = id
self.uid = str(uuid.uuid4())
self.password = generate_password_hash(password)
self.password_date = date.today()
self.email = email
self.role_id = role_id
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return '<User {uid}, {email}, {role_id}>'.format(**self)
class ServiceProvided(db.Model):
__tablename__ = "service_provided"
id = db.Column(db.Integer, primary_key=True)
catalog_entries_id = db.Column(db.Integer)
client_id = db.Column(db.Integer, nullable=False)
comment_entry = db.Column(db.String, nullable=False)
created = db.Column(db.DateTime, nullable=False)
evaluation_id = db.Column(db.Integer)
last_updated = db.Column(db.DateTime)
provider_id = db.Column(db.Integer, nullable=False)
rating = db.Column(db.Integer)
status = db.Column(db.Integer, nullable=False)
def __init__(self,
id: int = None,
catalog_entries_id: int = None,
client_id: int = None,
comment_entry: int = None,
created: int = None,
evaluation_id: int = None,
last_updated: int = None,
provider_id: int = None,
rating: int = None,
status: int = None):
self.id = id
self.catalog_entries_id = catalog_entries_id
self.client_id = client_id
self.comment_entry = comment_entry
self.created = created
self.evaluation_id = evaluation_id
self.last_updated = last_updated
self.provider_id = provider_id
self.rating = rating
self.status = status
def __repr__(self):
return '<Service {catalog_entries_id}, {client_id}, {comment_entry}, '\
'{created}, {evaluation_id}, {last_updated}, {provider_id}, '\
'{rating}, {status}>'.format(**self)
class Media(db.Model):
__tablename__ = "media"
__table_args__ = {'extend_existing': True}
media_id = db.Column(db.Integer, primary_key=True)
media_status_id = db.Column(db.Integer)
media_data = db.Column(db.LargeBinary)
media_link = db.Column(db.String(200))
media_title = db.Column(db.String(30))
media_description = db.Column(db.String(100))
media_size = db.Column(db.Float)
media_content_upload_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
media_content_updated_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
def __init__(self,
media_id: int = None,
media_status_id: int = None,
media_data: bin = None,
media_link: str = None,
media_title: str = None,
media_description: str = None,
media_size: float = None,
media_content_upload_date: str = None,
media_content_updated_date: str = None):
self.media_id = media_id
self.media_status_id = media_status_id
self.media_data = media_data
self.media_link = media_link
self.media_title = media_title
self.media_description = media_description
self.media_size = media_size
self.media_content_upload_date = media_content_upload_date
self.media_content_updated_date = media_content_updated_date
def __repr__(self):
return f'<Media {self.media_id} ,{self.media_status_id}, {self.media_data}, {self.media_link}, {self.media_title}, {self.media_description}, {self.media_size}, {self.media_content_upload_date}, {self.media_content_updated_date}>'
class Notification(db.Model):
__tablename__ = "notification"
id = db.Column(db.Integer, primary_key=True)
account_id = db.Column(db.Integer, db.ForeignKey('user.id'))
created = db.Column(db.DateTime, default=db.func.current_timestamp())
media_id = db.Column(db.Integer)
message = db.Column(db.String(255))
notification_type_id = db.Column(db.Integer,
db.ForeignKey('notification_type.id'))
status = db.Column(db.Integer)
title = db.Column(db.String(80))
updated = db.Column(db.DateTime)
def __init__(self,
id: int = None,
account_id: int = None,
created: int = None,
media_id: int = None,
message: int = None,
notification_type_id: int = None,
status: int = None,
title: int = None,
updated: int = None):
self.id = id
self.account_id = account_id
self.created = created
self.media_id = media_id
self.message = message
self.notification_type_id = notification_type_id
self.status = status
self.title = title
self.updated = updated
def __repr__(self):
return '<Service {id}, {account_id}, {created}, {media_id}, {message}, '\
'{notification_type_id}, {status}, {title}, {updated}>'.format(**self)
class Message(db.Model):
__tablename__ = "message"
id = db.Column(db.Integer, primary_key=True)
provider_id = db.Column(db.Integer, db.ForeignKey('user.id'))
service_id = db.Column(db.Integer, db.ForeignKey('service.id'))
entry = db.Column(db.String(500), nullable=False)
status = db.Column(db.Integer, nullable=False)
created = db.Column(db.DateTime,
nullable=False,
default=db.func.current_timestamp())
def __init__(self, id, provider_id, service_id, entry, status):
self.id = id
self.provider_id = provider_id
self.service_id = service_id
self.entry = entry
self.status = status
def __repr__(self):
return '<Service {id}, {provider_id}, {service_id}, '\
'{entry}, {status}, {created}>'.format(**self)
class UserAuth(UserMixin, db.Model):
__tablename__ = "user_auth"
__table_args__ = {'extend_existing': True}
user_auth_id = db.Column(db.Integer, primary_key=True)
user_auth_password = db.Column(db.String(500))
user_auth_pass_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
user_model_id = db.Column(db.Integer)
user_auth_updated_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
user_auth_name = db.Column(db.String(30))
def __init__(
self,
user_auth_id: int = None,
user_auth_password: str = None,
user_auth_pass_date: str = None,
user_model_id: int = None,
user_auth_updated_date: str = None,
user_auth_name: str = None,
):
self.user_auth_id = user_auth_id
self.user_auth_name = user_auth_name
self.user_auth_password = generate_password_hash(user_auth_password)
self.user_auth_pass_date = user_auth_pass_date
self.user_model_id = user_model_id
self.user_auth_updated_date = user_auth_updated_date
def set_password(self, user_auth_password):
self.user_auth_password = generate_password_hash(user_auth_password)
def check_password(self, user_auth_password):
return check_password_hash(self.user_auth_password, user_auth_password)
def __repr__(self):
return f'<UserAuth {self.user_auth_id}, {self.user_auth_name}, {self.user_auth_password}, {self.user_auth_pass_date}, {self.user_model_id}, {self.user_auth_updated_date}>'
class UserModel(db.Model):
__tablename__ = "user_model"
__table_args__ = {'extend_existing': True}
user_model_id = db.Column(db.Integer, primary_key=True)
user_status_id = db.Column(db.Integer)
user_role_id = db.Column(db.Integer)
user_model_first_name = db.Column(db.String(100))
user_model_last_name = db.Column(db.String(100))
user_model_surname = db.Column(db.String(100))
user_model_birthday = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
user_model_phone_number = db.Column(db.String(18))
user_model_address_id = db.Column(db.Integer)
user_model_registry_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
user_model_updated_date = db.Column(
db.String(50)) # FIXME: Timestamp to Date in Python
user_model_media_id = db.Column(db.Integer)
user_model_org = db.Column(db.Integer)
user_model_creator_id = db.Column(db.Integer)
def __init__(self,
user_model_id: int = None,
user_status_id: int = None,
user_role_id: int = None,
user_model_first_name: str = None,
user_model_last_name: str = None,
user_model_surname: str = None,
user_model_birthday: str = None,
user_model_phone_number: str = None,
user_model_address_id: int = None,
user_model_registry_date: str = None,
user_model_updated_date: str = None,
user_model_media_id: int = None,
user_model_org: int = None,
user_model_creator_id: int = None):
self.user_model_id = user_model_id
self.user_status_id = user_status_id
self.user_role_id = user_role_id
self.user_model_first_name = user_model_first_name
self.user_model_last_name = user_model_last_name
self.user_model_surname = user_model_surname
self.user_model_birthday = user_model_birthday
self.user_model_phone_number = user_model_phone_number
self.user_model_address_id = user_model_address_id
self.user_model_registry_date = user_model_registry_date
self.user_model_updated_date = user_model_updated_date
self.user_model_media_id = user_model_media_id
self.user_model_org = user_model_org
self.user_model_creator_id = user_model_creator_id
def __repr__(self):
return f'<UserModel {self.user_model_id}, {self.user_status_id}, {self.user_role_id}, {self.user_model_first_name}, {self.user_model_last_name}, {self.user_model_surname}, {self.user_model_birthday}, {self.user_model_phone_number}, {self.user_model_address_id}, {self.user_model_registry_date}, {self.user_model_updated_date}, {self.user_model_media_id}, {self.user_model_org}, {self.user_model_creator_id}>'
class Profile(UserMixin, db.Model):
__tablename__ = "profile"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(150), nullable=False)
second_name = db.Column(db.String(150), nullable=False)
first_surname = db.Column(db.String(150), nullable=False)
second_surname = db.Column(db.String(150), nullable=False)
birthdate = db.Column(db.DateTime, nullable=False)
curp = db.Column(db.String(18), nullable=False)
mobile_number = db.Column(db.String(15), nullable=False)
home_number = db.Column(db.String(15), nullable=True)
office_number = db.Column(db.String(15), nullable=True)
facebook_profile = db.Column(db.String(150), nullable=True)
linkedin_profile = db.Column(db.String(150), nullable=True)
twitter_profile = db.Column(db.String(150), nullable=True)
image_profile = db.Column(db.String(150), nullable=False)
status = db.Column(db.Enum('active', 'suspended'), nullable=False)
created = db.Column(db.DateTime, nullable=False)
updated = db.Column(db.DateTime, nullable=False)
# credentials_id = db.Column(db.String(150), nullable=False)
address = db.Column(db.String(250), nullable=False)
# org_id = db.Column(db.Integer, db.ForeignKey('organization.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __init__(self,
id: int = None,
first_name: str = None,
second_name: str = None,
first_surname: str = None,
second_surname: str = None,
birthdate: str = None,
curp: str = None,
mobile_number: str = None,
home_number: str = None,
office_number: str = None,
facebook_profile: str = None,
linkedin_profile: str = None,
twitter_profile: str = None,
image_profile: str = None,
status: str = None,
credentials_id: str = None,
address: str = None,
org_id: str = None,
user_id: int = None):
self.id = id
self.first_name = first_name
self.second_name = second_name
self.first_surname = first_surname
self.second_surname = second_surname
self.birthdate = birthdate
self.curp = curp
self.mobile_number = mobile_number
self.home_number = home_number
self.office_number = office_number
self.facebook_profile = facebook_profile
self.linkedin_profile = linkedin_profile
self.twitter_profile = twitter_profile
self.image_profile = image_profile
self.status = status
self.credentials_id = credentials_id,
self.created = date.today()
self.updated = date.today()
self.address = address
self.org_id = org_id
self.user_id = user_id
def __repr__(self):
return '<Profile id={id}, first_name={first_name}, first_surname={last_name}, user_id={user_id}>'.format(
**self)
class Service(db.Model):
__tablename__ = "service"
id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, nullable=False)
years_of_experience = db.Column(db.Integer, nullable=False)
price_of_service = db.Column(db.Float, nullable=False)
description = db.Column(db.String(500))
work_zone = db.Column(db.String(100), nullable=False)
services_provided = db.Column(db.Integer)
five_stars = db.Column(db.Integer)
four_starts = db.Column(db.Integer)
three_starts = db.Column(db.Integer)
two_starts = db.Column(db.Integer)
one_start = db.Column(db.Integer)
created = db.Column(db.DateTime,
nullable=False,
default=db.func.current_timestamp())
read_only = db.Column(db.Boolean)
last_updated = db.Column(db.DateTime, nullable=True)
status_id = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __init__(self,
id: int = None,
category_id: int = None,
years_of_experience: float = None,
price_of_service: int = None,
description: str = None,
work_zone: str = None,
services_provided: int = None,
five_stars: int = None,
four_starts: int = None,
three_starts: int = None,
two_starts: int = None,
one_start: int = None,
created: db.DateTime = None,
read_only: db.Boolean = None,
last_updated: db.DateTime = None,
status_id: int = None,
user_id: int = None):
self.id = id
self.category_id = category_id
self.years_of_experience = years_of_experience
self.price_of_service = price_of_service
self.description = description
self.work_zone = work_zone
self.services_provided = services_provided
self.five_stars = five_stars
self.four_starts = four_starts
self.three_starts = three_starts
self.two_starts = two_starts
self.one_start = one_start
self.created = created
self.read_only = read_only
self.last_updated = last_updated
self.status_id = status_id
self.user_id = user_id
def __repr__(self):
return '<Service {id}, {category_id}, {years_of_experience}, {price_of_service},'\
' {description}, {work_zone}, {services_provided}, {five_stars}, {four_starts},'\
' {three_starts}, {two_starts}, {one_starts}, {created}, {read_only},'\
' {last_updated}, {status_id}, {user_id}>'.format(**self)
class Skill(db.Model):
__tablename__ = "skill"
id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
years_of_experience = db.Column(db.Integer, nullable=False)
price_of_service = db.Column(db.Float, nullable=False)
description = db.Column(db.String(500))
work_zone = db.Column(db.String(100), nullable=False)
services_provided = db.Column(db.Integer)
five_stars = db.Column(db.Integer)
four_starts = db.Column(db.Integer)
three_starts = db.Column(db.Integer)
two_starts = db.Column(db.Integer)
one_start = db.Column(db.Integer)
def __init__(self,
id: int = None,
category_id: int = None,
years_of_experience: float = None,
price_of_service: int = None,
description: str = None,
work_zone: str = None,
services_provided: int = None,
five_stars: int = None,
four_starts: int = None,
three_starts: int = None,
two_starts: int = None,
one_start: int = None):
self.id = id
self.category_id = category_id
self.years_of_experience = years_of_experience
self.price_of_service = price_of_service
self.description = description
self.work_zone = work_zone
self.services_provided = services_provided
self.five_stars = five_stars
self.four_starts = four_starts
self.three_starts = three_starts
self.two_starts = two_starts
self.one_start = one_start
def __repr__(self):
return '<Skill {id}, {category_id}, {years_of_experience}, {price_of_service}, {description}, {work_zone}, {services_provided}, {five_stars}, {four_starts}, {three_starts}, {two_starts}, {one_starts}>'.format(
**self)
