473 lines
15 KiB
Python
473 lines
15 KiB
Python
import uuid
|
|
|
|
from datetime import datetime
|
|
|
|
from brewman.models.master import Product
|
|
from sqlalchemy import (
|
|
Boolean,
|
|
Column,
|
|
Date,
|
|
DateTime,
|
|
ForeignKey,
|
|
Integer,
|
|
Numeric,
|
|
Unicode,
|
|
UniqueConstraint,
|
|
)
|
|
from sqlalchemy.dialects.postgresql import BYTEA, UUID
|
|
from sqlalchemy.ext.hybrid import hybrid_property
|
|
from sqlalchemy.orm import Session, backref, relationship, synonym
|
|
|
|
from .meta import Base
|
|
|
|
|
|
class VoucherType:
|
|
def __init__(self, id_, name):
|
|
self.id = id_
|
|
self.name = name
|
|
|
|
@classmethod
|
|
def list(cls):
|
|
list_ = [
|
|
VoucherType(1, "Journal"),
|
|
VoucherType(2, "Purchase"),
|
|
VoucherType(3, "Issue"),
|
|
VoucherType(4, "Payment"),
|
|
VoucherType(5, "Receipt"),
|
|
VoucherType(6, "Purchase Return"),
|
|
VoucherType(7, "Opening Accounts"),
|
|
VoucherType(8, "Opening Batches"),
|
|
VoucherType(9, "Verification"),
|
|
VoucherType(10, "Opening Balance"),
|
|
VoucherType(11, "Closing Balance"),
|
|
VoucherType(12, "Employee Benefit"),
|
|
VoucherType(13, "Incentive"),
|
|
]
|
|
return list_
|
|
|
|
@classmethod
|
|
def by_name(cls, name):
|
|
list_ = cls.list()
|
|
for item in list_:
|
|
if item.name == name:
|
|
return item
|
|
|
|
@classmethod
|
|
def by_id(cls, id_):
|
|
list_ = cls.list()
|
|
for item in list_:
|
|
if item.id == id_:
|
|
return item
|
|
|
|
|
|
class Voucher(Base):
|
|
__tablename__ = "vouchers"
|
|
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
date = Column("date", Date, nullable=False, index=True)
|
|
narration = Column("narration", Unicode(1000), nullable=False)
|
|
is_reconciled = Column("is_reconciled", Boolean, nullable=False)
|
|
reconcile_date = Column("reconcile_date", Date, nullable=False)
|
|
is_starred = Column("is_starred", Boolean, nullable=False)
|
|
creation_date = Column("creation_date", DateTime(timezone=True), nullable=False)
|
|
last_edit_date = Column("last_edit_date", DateTime(timezone=True), nullable=False)
|
|
_type = Column("voucher_type", Integer, nullable=False)
|
|
user_id = Column("user_id", UUID(as_uuid=True), ForeignKey("auth_users.id"), nullable=False)
|
|
posted = Column("is_posted", Boolean, nullable=False)
|
|
poster_id = Column("poster_id", UUID(as_uuid=True), ForeignKey("auth_users.id"))
|
|
|
|
user = relationship("User", primaryjoin="User.id==Voucher.user_id", cascade=None)
|
|
poster = relationship("User", primaryjoin="User.id==Voucher.poster_id", cascade=None)
|
|
|
|
journals = relationship(
|
|
"Journal",
|
|
back_populates="voucher",
|
|
cascade="delete, delete-orphan",
|
|
cascade_backrefs=False,
|
|
)
|
|
|
|
inventories = relationship(
|
|
"Inventory",
|
|
back_populates="voucher",
|
|
cascade="delete, delete-orphan",
|
|
cascade_backrefs=False,
|
|
)
|
|
employee_benefits = relationship(
|
|
"EmployeeBenefit",
|
|
backref="voucher",
|
|
cascade="delete, delete-orphan",
|
|
cascade_backrefs=False,
|
|
)
|
|
incentives = relationship(
|
|
"Incentive",
|
|
backref="voucher",
|
|
cascade="delete, delete-orphan",
|
|
cascade_backrefs=False,
|
|
)
|
|
|
|
def _get_type(self):
|
|
return self._type
|
|
# for item in VoucherType.list():
|
|
# if self._type == item.id:
|
|
# return item
|
|
|
|
def _set_type(self, value):
|
|
if type(value) == int:
|
|
self._type = value
|
|
else:
|
|
self._type = value.id
|
|
|
|
type = property(_get_type, _set_type)
|
|
type = synonym("_type", descriptor=type)
|
|
|
|
def __init__(
|
|
self,
|
|
date=None,
|
|
is_reconciled=False,
|
|
reconcile_date=None,
|
|
is_starred=None,
|
|
narration="",
|
|
posted=False,
|
|
creation_date=None,
|
|
last_edit_date=None,
|
|
type_=None,
|
|
user_id=None,
|
|
poster_id=None,
|
|
):
|
|
self.date = date
|
|
self.is_reconciled = is_reconciled
|
|
self.reconcile_date = reconcile_date or date
|
|
self.is_starred = is_starred if is_starred is not None else False
|
|
self.narration = narration
|
|
self.posted = posted
|
|
self.creation_date = creation_date or datetime.utcnow()
|
|
self.last_edit_date = last_edit_date or datetime.utcnow()
|
|
self.type = type_
|
|
self.user_id = user_id
|
|
self.poster_id = poster_id
|
|
|
|
|
|
class Journal(Base):
|
|
__tablename__ = "journals"
|
|
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
debit = Column("debit", Integer, nullable=False)
|
|
amount = Column("amount", Numeric(precision=15, scale=2), nullable=False)
|
|
voucher_id = Column(
|
|
"voucher_id",
|
|
UUID(as_uuid=True),
|
|
ForeignKey("vouchers.id"),
|
|
nullable=False,
|
|
index=True,
|
|
)
|
|
account_id = Column("account_id", UUID(as_uuid=True), ForeignKey("accounts.id"), nullable=False)
|
|
cost_centre_id = Column(
|
|
"cost_centre_id",
|
|
UUID(as_uuid=True),
|
|
ForeignKey("cost_centres.id"),
|
|
nullable=False,
|
|
)
|
|
|
|
voucher = relationship("Voucher", back_populates="journals")
|
|
account = relationship("AccountBase", back_populates="journals")
|
|
|
|
@hybrid_property
|
|
def signed_amount(self):
|
|
return self.debit * self.amount
|
|
|
|
@property
|
|
def __name__(self):
|
|
return self.name
|
|
|
|
def __init__(
|
|
self,
|
|
id_=None,
|
|
debit=None,
|
|
amount=None,
|
|
voucher_id=None,
|
|
account_id=None,
|
|
cost_centre_id=None,
|
|
):
|
|
self.id = id_
|
|
self.debit = debit
|
|
self.amount = amount
|
|
self.voucher_id = voucher_id
|
|
self.account_id = account_id
|
|
self.cost_centre_id = cost_centre_id
|
|
|
|
|
|
class EmployeeBenefit(Base):
|
|
__tablename__ = "employee_benefit"
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
voucher_id = Column("voucher_id", UUID(as_uuid=True), ForeignKey("vouchers.id"), nullable=False)
|
|
journal_id = Column("journal_id", UUID(as_uuid=True), ForeignKey("journals.id"), nullable=False)
|
|
gross_salary = Column("gross_salary", Integer)
|
|
days_worked = Column("days_worked", Integer)
|
|
esi_ee = Column("esi_employee", Integer)
|
|
pf_ee = Column("pf_employee", Integer)
|
|
esi_er = Column("esi_employer", Integer)
|
|
pf_er = Column("pf_employer", Integer)
|
|
|
|
journal = relationship(
|
|
Journal,
|
|
backref=backref("employee_benefit", uselist=False),
|
|
cascade=None,
|
|
cascade_backrefs=False,
|
|
)
|
|
|
|
def __init__(
|
|
self,
|
|
id_=None,
|
|
voucher_id=None,
|
|
journal_id=None,
|
|
journal=None,
|
|
gross_salary=None,
|
|
days_worked=None,
|
|
esi_ee=None,
|
|
pf_ee=None,
|
|
esi_er=None,
|
|
pf_er=None,
|
|
):
|
|
self.id = id_
|
|
self.voucher_id = voucher_id
|
|
self.gross_salary = gross_salary
|
|
self.days_worked = days_worked
|
|
self.esi_ee = esi_ee
|
|
self.pf_ee = pf_ee
|
|
self.esi_er = esi_er
|
|
self.pf_er = pf_er
|
|
if journal is None:
|
|
self.journal_id = journal_id
|
|
else:
|
|
self.journal = journal
|
|
|
|
|
|
class Incentive(Base):
|
|
__tablename__ = "incentives"
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
voucher_id = Column("voucher_id", UUID(as_uuid=True), ForeignKey("vouchers.id"), nullable=False)
|
|
journal_id = Column("journal_id", UUID(as_uuid=True), ForeignKey("journals.id"), nullable=False)
|
|
days_worked = Column("days_worked", Numeric(precision=5, scale=1), nullable=False)
|
|
points = Column("points", Numeric(precision=5, scale=2), nullable=False)
|
|
|
|
journal = relationship(
|
|
Journal,
|
|
backref=backref("incentive", uselist=False),
|
|
cascade=None,
|
|
cascade_backrefs=False,
|
|
)
|
|
|
|
def __init__(
|
|
self,
|
|
id_=None,
|
|
voucher_id=None,
|
|
journal_id=None,
|
|
journal=None,
|
|
days_worked=None,
|
|
points=None,
|
|
):
|
|
self.id = id_
|
|
self.voucher_id = voucher_id
|
|
if journal is None:
|
|
self.journal_id = journal_id
|
|
else:
|
|
self.journal = journal
|
|
self.days_worked = days_worked
|
|
self.points = points
|
|
|
|
|
|
class Inventory(Base):
|
|
__tablename__ = "inventories"
|
|
__table_args__ = (UniqueConstraint("voucher_id", "batch_id"),)
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
voucher_id = Column(
|
|
"voucher_id",
|
|
UUID(as_uuid=True),
|
|
ForeignKey("vouchers.id"),
|
|
nullable=False,
|
|
index=True,
|
|
)
|
|
product_id = Column("product_id", UUID(as_uuid=True), ForeignKey("products.id"), nullable=False)
|
|
batch_id = Column("batch_id", UUID(as_uuid=True), ForeignKey("batches.id"), nullable=False)
|
|
quantity = Column("quantity", Numeric(precision=15, scale=2), nullable=False)
|
|
rate = Column("rate", Numeric(precision=15, scale=2), nullable=False)
|
|
tax = Column("tax", Numeric(precision=15, scale=5), nullable=False)
|
|
discount = Column("discount", Numeric(precision=15, scale=5), nullable=False)
|
|
|
|
voucher = relationship("Voucher", back_populates="inventories")
|
|
|
|
def __init__(
|
|
self,
|
|
id_=None,
|
|
voucher_id=None,
|
|
product_id=None,
|
|
batch_id=None,
|
|
quantity=None,
|
|
rate=None,
|
|
tax=None,
|
|
discount=None,
|
|
batch=None,
|
|
product=None,
|
|
):
|
|
self.id = id_
|
|
self.voucher_id = voucher_id
|
|
if product is None:
|
|
self.product_id = product_id
|
|
else:
|
|
self.product = product
|
|
if batch is None:
|
|
self.batch_id = batch_id
|
|
else:
|
|
self.batch = batch
|
|
self.quantity = quantity
|
|
self.rate = rate
|
|
self.tax = tax
|
|
self.discount = discount
|
|
|
|
@hybrid_property
|
|
def amount(self):
|
|
return self.quantity * self.rate * (1 + self.tax) * (1 - self.discount)
|
|
|
|
|
|
class Batch(Base):
|
|
__tablename__ = "batches"
|
|
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
name = Column("name", Date, nullable=False)
|
|
product_id = Column("product_id", UUID(as_uuid=True), ForeignKey("products.id"), nullable=False)
|
|
quantity_remaining = Column("quantity_remaining", Numeric(precision=15, scale=2), nullable=False)
|
|
rate = Column("rate", Numeric(precision=15, scale=2), nullable=False)
|
|
tax = Column("tax", Numeric(precision=15, scale=5), nullable=False)
|
|
discount = Column("discount", Numeric(precision=15, scale=5), nullable=False)
|
|
|
|
inventories = relationship("Inventory", backref="batch", cascade=None, cascade_backrefs=False)
|
|
|
|
def __init__(
|
|
self,
|
|
name=None,
|
|
product_id=None,
|
|
quantity_remaining=None,
|
|
rate=None,
|
|
tax=None,
|
|
discount=None,
|
|
product=None,
|
|
):
|
|
self.name = name
|
|
self.product_id = product_id
|
|
self.quantity_remaining = quantity_remaining
|
|
self.rate = rate
|
|
self.tax = tax
|
|
self.discount = discount
|
|
if product is None:
|
|
self.product_id = product_id
|
|
else:
|
|
self.product = product
|
|
|
|
def amount(self):
|
|
return self.quantity_remaining * self.rate * (1 + self.tax) * (1 - self.discount)
|
|
|
|
@classmethod
|
|
def list(cls, q, include_nil, date, db: Session):
|
|
query = db.query(cls).join(cls.product)
|
|
if not include_nil:
|
|
query = query.filter(cls.quantity_remaining > 0)
|
|
if date is not None:
|
|
query = query.filter(cls.name <= date)
|
|
if q is not None:
|
|
for item in q.split():
|
|
query = query.filter(Product.name.ilike(f"%{item}%"))
|
|
return query.order_by(Product.name).order_by(cls.name).all()
|
|
|
|
@classmethod
|
|
def suspense(cls):
|
|
return uuid.UUID("a955790e-93cf-493c-a816-c7d92b127383")
|
|
|
|
|
|
class Attendance(Base):
|
|
__tablename__ = "attendances"
|
|
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
employee_id = Column("employee_id", UUID(as_uuid=True), ForeignKey("employees.id"))
|
|
date = Column("date", Date, nullable=False)
|
|
attendance_type = Column("attendance_type", Integer)
|
|
amount = Column("amount", Numeric(precision=5, scale=2))
|
|
creation_date = Column("creation_date", DateTime(timezone=True))
|
|
user_id = Column("user_id", UUID(as_uuid=True), ForeignKey("auth_users.id"))
|
|
is_valid = Column("is_valid", Boolean)
|
|
|
|
user = relationship("User", primaryjoin="User.id==Attendance.user_id")
|
|
|
|
def __init__(
|
|
self,
|
|
id_=None,
|
|
employee_id=None,
|
|
date=None,
|
|
attendance_type=None,
|
|
amount=None,
|
|
creation_date=None,
|
|
user_id=None,
|
|
is_valid=None,
|
|
):
|
|
self.id = id_
|
|
self.employee_id = employee_id
|
|
self.date = date
|
|
self.attendance_type = attendance_type
|
|
self.amount = amount if amount is not None else 0
|
|
self.creation_date = creation_date or datetime.utcnow()
|
|
self.user_id = user_id
|
|
self.is_valid = is_valid if is_valid is not None else True
|
|
|
|
def create(self, db: Session):
|
|
old = (
|
|
db.query(Attendance)
|
|
.filter(Attendance.date == self.date)
|
|
.filter(Attendance.employee_id == self.employee_id)
|
|
.filter(Attendance.is_valid == True) # noqa: E712
|
|
.first()
|
|
)
|
|
if old is None or old.attendance_type != self.attendance_type:
|
|
if old is not None:
|
|
old.is_valid = False
|
|
db.add(self)
|
|
|
|
|
|
class Fingerprint(Base):
|
|
__tablename__ = "fingerprints"
|
|
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
employee_id = Column("employee_id", UUID(as_uuid=True), ForeignKey("employees.id"))
|
|
date = Column("date", DateTime)
|
|
|
|
def __init__(self, id_=None, employee_id=None, date=None):
|
|
self.id = id_
|
|
self.employee_id = employee_id
|
|
self.date = date
|
|
self.fingerprint_type = 0
|
|
|
|
|
|
class DbImage(Base):
|
|
__tablename__ = "images"
|
|
|
|
id = Column("id", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
|
resource_id = Column("resource_id", UUID(as_uuid=True), nullable=False)
|
|
resource_type = Column("resource_type", Unicode(255), nullable=False)
|
|
image = Column("image", BYTEA, nullable=False)
|
|
thumbnail = Column("thumbnail", BYTEA, nullable=False)
|
|
creation_date = Column("creation_date", DateTime(timezone=True), nullable=False)
|
|
|
|
def __init__(
|
|
self,
|
|
resource_id=None,
|
|
resource_type=None,
|
|
image=None,
|
|
thumbnail=None,
|
|
creation_date=None,
|
|
id_=None,
|
|
):
|
|
self.resource_id = resource_id
|
|
self.resource_type = resource_type
|
|
self.image = image
|
|
self.thumbnail = thumbnail
|
|
self.creation_date = creation_date or datetime.utcnow()
|
|
self.id = id_
|