class Make(db.Model, BaseMixin, AuditableMixin):
name = db.Column(db.String(50), unique=True, nullable=False)
country = db.Column(db.String(50))
def __init__(self, **kwargs):
super(Make, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Make %s>" % self.uuid
class Item(db.Model, BaseMixin, AuditableMixin):
"""Inventory model
"""
code = db.Column(db.String(200), nullable=False) # item number
name = db.Column(db.String(200), unique=True, nullable=False)
description = db.Column(db.String(2000))
category_id = db.Column(db.String(50), db.ForeignKey("item_category.uuid"))
model_id = db.Column(db.String(50))
price = db.Column(db.String(50))
item_type = db.Column(db.String(50))
make_id = db.Column(db.String(50))
entity_id = db.Column(db.String(50), db.ForeignKey("entity.uuid"))
entity = db.relationship("Entity")
category = db.relationship("ItemCategory")
def __init__(self, **kwargs):
super(Item, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Item %s>" % self.name
@property
def quantity(self):
"""Get the item balance."""
try:
return query(
" quantity from item_balances where uuid='" + str(self.uuid) + "'"
)[0]["quantity"]
except Exception:
return 0
class VehicleType(db.Model, BaseMixin, AuditableMixin):
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(2000))
def __init__(self, **kwargs):
super(VehicleType, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<VehicleType %s>" % self.uuid
class Role(db.Model, BaseMixin, AuditableMixin):
name = db.Column(db.String(80), unique=True, nullable=False)
category = db.Column(db.String(50))
notes = db.Column(db.String(255))
def __init__(self, **kwargs):
super(Role, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Role %s>" % self.name
class Model(db.Model, BaseMixin, AuditableMixin):
name = db.Column(db.String(50), unique=True, nullable=False)
year = db.Column(db.Integer)
make_id = db.Column(db.Integer, db.ForeignKey("make.id"))
make = db.relationship("Make")
def __init__(self, **kwargs):
super(Make, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Model %s>" % self.uuid
class TransactionType(db.Model, BaseMixin, AuditableMixin):
""""
claim, topup, reversal, charge, adjustment
"""
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(50))
def __init__(self, **kwargs):
super(TransactionType, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<TransactionType %s>" % self.name
class Setting(db.Model, BaseMixin, AuditableMixin):
"""Setting model
"""
name = db.Column(db.String(80), unique=True, nullable=False)
value = db.Column(db.String(4000))
company = db.Column(db.String(50))
def __init__(self, **kwargs):
super(Setting, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Setting %s>" % self.name
class Charge(ChargeBase):
"""A Charge is a part of a tarriff
"""
min_value = db.Column(db.BigInteger)
max_value = db.Column(db.BigInteger)
amount = db.Column(db.String(50))
charge_type = db.Column(db.String(50)) # [flat,percentage]
def __init__(self, **kwargs):
super(Charge, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Charge %s>" % self.code
class CustomerType(db.Model, BaseMixin, AuditableMixin):
""""
in fleet, out fleet
"""
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(50))
entity_id = db.Column(db.String(50))
def __init__(self, **kwargs):
super(CustomerType, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<CustomerType %s>" % self.name
class EmployeeType(db.Model, BaseMixin, AuditableMixin):
""""
mechanic, finance,
"""
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(50))
entity_id = db.Column(db.String(50))
def __init__(self, **kwargs):
super(EmployeeType, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<EmployeeType %s>" % self.name
class Service(db.Model, BaseMixin, AuditableMixin):
"""Service model
"""
name = db.Column(db.String(200), unique=True, nullable=False)
description = db.Column(db.String(4000))
entity_id = db.Column(db.String(50), db.ForeignKey("entity.uuid"))
entity = db.relationship("Entity")
def __init__(self, **kwargs):
super(Service, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Service %s>" % self.name
class ChargeSplit(ChargeBase):
"""Charge split model describes how a charge is shared
"""
account_code = db.Column(db.String(50))
percentage = db.Column(db.Numeric(18, 11))
def __init__(self, **kwargs):
super(ChargeSplit, self).__init__(**kwargs)
def __repr__(self):
return "<ChargeSplit %s>" % self.account_code
self.get_uuid()
def account_name(self):
"""Get the tarriff."""
return Account.get(uuid=self.account_code).name
class AccountType(db.Model, BaseMixin, AuditableMixin):
"""AccountType model
Types are entity, vendor, customer, suspense, commission
"""
name = db.Column(db.String(80), unique=True, nullable=False)
description = db.Column(db.String(4000), nullable=False)
def __init__(self, **kwargs):
super(AccountType, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<AccountType %s>" % self.name
def creator(self):
"""Get the creator."""
return User.query.filter_by(id=self.created_by).first()
class CommissionAccount(db.Model, BaseMixin, AuditableMixin):
"""Any other account created"""
name = db.Column(db.String(50), unique=True)
code = db.Column(db.String(50))
entity_id = db.Column(db.String(50))
def __init__(self, **kwargs):
super(CommissionAccount, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<CommissionAccount %s>" % self.name
def is_valid(self):
if CommissionAccount.get(code=self.code, entity_id=self.entity_id):
return False, {"msg": "The commission account already exists"}, 409
if CommissionAccount.get(name=self.name):
return False, {
"msg": "The commission account name already exists"
}, 409
return True, "OK", 200
def save(self, minimum_balance):
valid, msg, status = self.is_valid()
if valid:
account = Account(
acc_type="commission",
owner_id=self.uuid,
created_by=self.created_by,
group=self.entity_id,
minimum_balance=minimum_balance,
)
db.session.add(self)
db.session.add(account)
db.session.commit()
else:
raise Exception(msg, status)
@property
def account(self):
return Account.get(owner_id=self.uuid)
class Vendor(db.Model, BaseMixin, AuditableMixin):
"""Vendor model
"""
name = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
address = db.Column(db.String(255), nullable=False)
phone = db.Column(db.String(50))
description = db.Column(db.String(4000))
def __init__(self, **kwargs):
super(Vendor, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Vendor %s>" % self.name
@property
def account(self):
return Account.get(owner_id=self.uuid)
class ItemCategory(db.Model, BaseMixin, AuditableMixin):
name = db.Column(db.String(200), unique=True, nullable=False)
description = db.Column(db.String(2000))
parent_id = db.Column(db.String(50))
entity_id = db.Column(db.String(50), db.ForeignKey("entity.uuid"))
entity = db.relationship("Entity")
def __init__(self, **kwargs):
super(ItemCategory, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<ItemCategory %s>" % self.name
@property
def parent(self):
if self.parent_id and self.parent_id != "0":
return ItemCategory.get(uuid=self.parent_id).name
else:
return None
class Tarriff(db.Model, BaseMixin, AuditableMixin):
"""Tarriff model : Contains charges
"""
name = db.Column(db.String(50))
entity_id = db.Column(db.String(50))
tran_type = db.Column(db.String(50))
payment_type = db.Column(db.String(50)) # [flat,percentage,tiered]
charges = db.relationship("Charge",
cascade="all, delete-orphan",
lazy="dynamic")
splits = db.relationship("ChargeSplit",
cascade="all, delete-orphan",
lazy="dynamic")
def __init__(self, **kwargs):
super(Tarriff, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Tarriff %s>" % self.name
class JobItem(db.Model, BaseMixin, AuditableMixin):
job_id = db.Column(db.String(50), db.ForeignKey("job.uuid"))
item_id = db.Column(db.String(50), db.ForeignKey("item.uuid"))
quantity = db.Column(db.String(50))
unit_cost = db.Column(db.String(50))
units = db.Column(db.String(50))
entity_id = db.Column(db.String(50), db.ForeignKey("entity.uuid"))
item = db.relationship("Item")
job = db.relationship("Job")
entity = db.relationship("Entity")
def __init__(self, **kwargs):
super(JobItem, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<JobItem %s>" % self.uuid
@property
def cost(self):
try:
return int(self.quantity) * int(self.unit_cost)
except Exception:
return None
def save(self):
item_log = ItemLog.init_jobitem(self)
db.session.add(self)
item_log.transact()
class WorkItem(db.Model, BaseMixin, AuditableMixin):
request_id = db.Column(db.String(50),
db.ForeignKey("service_request.uuid"))
item = db.Column(db.String(50))
quantity = db.Column(db.String(50))
unit_cost = db.Column(db.String(50))
units = db.Column(db.String(50))
entity_id = db.Column(db.String(50), db.ForeignKey("entity.uuid"))
request = db.relationship("ServiceRequest")
entity = db.relationship("Entity")
def __init__(self, **kwargs):
super(WorkItem, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<WorkItem %s>" % self.uuid
@property
def cost(self):
try:
return int(self.quantity) * int(self.unit_cost)
except Exception:
return None
class Employee(db.Model, BaseMixin, AuditableMixin):
"""Basic Employee model
"""
name = db.Column(db.String(80))
phone = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(50))
address = db.Column(db.String(500))
entity_id = db.Column(db.String(50),
db.ForeignKey("entity.uuid"),
nullable=False)
type_id = db.Column(db.String(50),
db.ForeignKey("employee_type.uuid"),
nullable=False)
entity = db.relationship("Entity")
type = db.relationship("EmployeeType")
jobs = db.relationship("Job", back_populates="employee")
def __init__(self, **kwargs):
super(Employee, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Employee %s>" % self.uuid
@property
def entity(self):
entity = Entity.get(uuid=self.entity_id)
if entity is None:
return None
return entity.name
class Customer(db.Model, BaseMixin, AuditableMixin):
"""Basic Customer model
"""
name = db.Column(db.String(80))
phone = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(50))
address = db.Column(db.String(500))
entity_id = db.Column(db.String(50),
db.ForeignKey("entity.uuid"),
nullable=False)
type_id = db.Column(db.String(50),
db.ForeignKey("customer_type.uuid"),
nullable=False)
vehicles = db.relationship("Vehicle", back_populates="customer")
def __init__(self, **kwargs):
super(Customer, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Customer %s>" % self.uuid
@property
def entity(self):
entity = Entity.get(uuid=self.entity_id)
if entity is None:
return None
return entity.name
@property
def account(self):
return Account.get(owner_id=self.uuid)
class ServiceRequest(db.Model, BaseMixin, AuditableMixin):
""""
Service Request
"""
customer_id = db.Column(db.String(50), db.ForeignKey("customer.uuid"))
service_id = db.Column(db.String(50), db.ForeignKey("service.uuid"))
vehicle_id = db.Column(db.String(50), db.ForeignKey("vehicle.uuid"))
entity_id = db.Column(db.String(50), db.ForeignKey("entity.uuid"))
customer = db.relationship("Customer")
service = db.relationship("Service")
vehicle = db.relationship("Vehicle")
entity = db.relationship("Entity")
job = db.relationship("Job")
def __init__(self, **kwargs):
super(ServiceRequest, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<ServiceRequest %s>" % self.uuid
class PaymentType(db.Model, BaseMixin, AuditableMixin):
"""
Cash, Momo, Bank, e.t.c
"""
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(50))
def __init__(self, **kwargs):
super(PaymentType, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<PaymentType %s>" % self.name
@property
def account(self):
setting = Setting.get(uuid=self.uuid)
return Account.get(uuid=setting.value).id
def save(self):
account = Account(acc_type="commission",
owner_id=self.uuid,
created_by=get_jwt_identity(),
group="system",
minimum_balance=0.0)
setting = Setting(
uuid=self.uuid,
name=self.name,
value=account.uuid,
company="ALL",
created_by=get_jwt_identity(),
)
db.session.add(account)
db.session.add(setting)
db.session.add(self)
db.session.commit()
class Entity(db.Model, BaseMixin, AuditableMixin):
"""Entity model
"""
name = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
address = db.Column(db.String(255), nullable=False)
phone = db.Column(db.String(50))
description = db.Column(db.String(4000))
vendors = db.relationship(
"Vendor",
secondary=entity_vendors,
backref=db.backref("entities", lazy="dynamic"),
lazy="dynamic",
)
customers = db.relationship("Customer", lazy="dynamic")
def __init__(self, **kwargs):
super(Entity, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Entity %s>" % self.name
@property
def account(self):
return Account.get(owner_id=self.uuid)
def add_vendor(self, vendor):
if not self.is_entity_vendor(vendor):
self.vendors.append(vendor)
def remove_vendor(self, vendor):
if self.is_entity_vendor(vendor):
self.vendors.remove(vendor)
def is_entity_vendor(self, vendor):
return self.vendors.filter(
entity_vendors.c.vendor_id == vendor.id).count() > 0
class Group(db.Model, BaseMixin, AuditableMixin):
"""An entity may have groups: these are companies/departments that
subscribe to their plans on behalf of their staff"""
name = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
address = db.Column(db.String(255), nullable=False)
phone = db.Column(db.String(50))
entity_id = db.Column(db.String(50))
def __init__(self, **kwargs):
super(Group, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Group %s>" % self.name
@property
def entity(self):
entity = Entity.get(uuid=self.entity_id)
if entity is None:
return None
return entity.name
class LpoItem(db.Model, BaseMixin, AuditableMixin):
order_id = db.Column(db.String(50),
db.ForeignKey('local_purchase_order.uuid'))
item_id = db.Column(db.String(80),
db.ForeignKey("item.uuid"),
nullable=False)
quantity = db.Column(db.String(50))
unit_price = db.Column(db.String(50))
entity_id = db.Column(db.String(50), db.ForeignKey('entity.uuid'))
item = db.relationship('Item')
order = db.relationship('LocalPurchaseOrder')
entity = db.relationship('Entity')
def __init__(self, **kwargs):
super(LpoItem, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<LpoItem %s>" % self.uuid
@property
def amount(self):
return float(self.quantity) * float(self.unit_price)
class User(db.Model, BaseMixin, AuditableMixin, PersonMixin):
"""Basic user model
"""
__tablename__ = "users"
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(80), nullable=False)
phone = db.Column(db.String(80))
password = db.Column(db.String(255), nullable=False)
role_code = db.Column(db.String(50))
company_id = db.Column(db.String(50))
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.password = pwd_context.hash(self.password)
self.get_uuid()
def __repr__(self):
return "<User %s>" % self.username
@property
def role(self):
"""Get the role."""
role = Role.query.filter_by(uuid=self.role_code).first()
if role is None:
return None
return role.name
@property
def category(self):
"""Get the role category."""
role = Role.query.filter_by(uuid=self.role_code).first()
if role is None:
return None
return role.category
@property
def company(self):
try:
if self.company_id == "system":
return "System"
else:
sql = (""" name
FROM account_holders
where uuid = '""" + self.company_id + """'
""")
data = query(sql)
return data[0]["name"]
except Exception:
return ""
class Vehicle(db.Model, BaseMixin, AuditableMixin):
registration_no = db.Column(db.String(50))
chassis_no = db.Column(db.String(50))
model_id = db.Column(db.String(50), db.ForeignKey("vehicle_model.uuid"))
model_no = db.Column(db.String(50))
engine_no = db.Column(db.String(50))
vehicle_type = db.Column(db.String(50))
customer_id = db.Column(db.String(50), db.ForeignKey("customer.uuid"))
customer = db.relationship("Customer", back_populates="vehicles")
vehicle_model = db.relationship("VehicleModel")
def __init__(self, **kwargs):
super(Vehicle, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<Vehicle %s>" % self.uuid
class VehicleModel(db.Model, BaseMixin, AuditableMixin):
name = db.Column(db.String(50), unique=True, nullable=False)
fuel_type = db.Column(db.String(50))
type_id = db.Column(db.String(50), db.ForeignKey("vehicle_type.uuid"))
transmission = db.Column(db.String(50))
year = db.Column(db.Integer)
make_id = db.Column(db.Integer, db.ForeignKey("make.id"))
make = db.relationship("Make")
type = db.relationship("VehicleType")
def __init__(self, **kwargs):
super(VehicleModel, self).__init__(**kwargs)
self.get_uuid()
def __repr__(self):
return "<VehicleModel %s>" % self.uuid
class TokenBlacklist(db.Model):
"""Blacklist representation
"""
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(36), nullable=False, unique=True)
token_type = db.Column(db.String(10), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
revoked = db.Column(db.Boolean, nullable=False)
expires = db.Column(db.DateTime, nullable=False)
user = db.relationship("User", lazy="joined")
def to_dict(self):
return {
"token_id": self.id,
"jti": self.jti,
"token_type": self.token_type,
"user_identity": self.user_identity,
"revoked": self.revoked,
"expires": self.expires,
}
