class WorkOrderPackageView(Viewable):
"""A view for |workorderpackages|
This is used to get the most information of a |workorderpackage|
without doing lots of database queries.
"""
_BranchSource = ClassAlias(Branch, "branch_source")
_BranchDestination = ClassAlias(Branch, "branch_destination")
_PersonSource = ClassAlias(Person, "person_source")
_PersonDestination = ClassAlias(Person, "person_destination")
_CompanySource = ClassAlias(Company, "company_source")
_CompanyDestination = ClassAlias(Company, "company_destination")
#: the |workorderpackage| object
package = WorkOrderPackage
# WorkOrderPackage
id = WorkOrderPackage.id
identifier = WorkOrderPackage.identifier
send_date = WorkOrderPackage.send_date
receive_date = WorkOrderPackage.receive_date
# Branch
source_branch_name = Coalesce(NullIf(_CompanySource.fancy_name, u''),
_PersonSource.name)
destination_branch_name = Coalesce(
NullIf(_CompanyDestination.fancy_name, u''), _PersonDestination.name)
# WorkOrder
quantity = Coalesce(Field('_package_items', 'quantity'), 0)
tables = [
WorkOrderPackage,
LeftJoin(_BranchSource,
WorkOrderPackage.source_branch_id == _BranchSource.id),
LeftJoin(_PersonSource, _BranchSource.person_id == _PersonSource.id),
LeftJoin(_CompanySource, _CompanySource.person_id == _PersonSource.id),
LeftJoin(
_BranchDestination,
WorkOrderPackage.destination_branch_id == _BranchDestination.id),
LeftJoin(_PersonDestination,
_BranchDestination.person_id == _PersonDestination.id),
LeftJoin(_CompanyDestination,
_CompanyDestination.person_id == _PersonDestination.id),
LeftJoin(_WorkOrderPackageItemsSummary,
Field('_package_items', 'package_id') == WorkOrderPackage.id),
]
@classmethod
def find_by_destination_branch(cls, store, branch):
return store.find(cls,
WorkOrderPackage.destination_branch_id == branch.id)
class DailyInPaymentView(InPaymentView):
SalesPersonPerson = ClassAlias(Person, 'salesperson_person')
ClientPerson = ClassAlias(Person, 'client_person')
PersonBranch = ClassAlias(Person, 'person_branch')
BranchCompany = ClassAlias(Company, 'branch_company')
salesperson_name = SalesPersonPerson.name
client_name = ClientPerson.name
branch_name = Coalesce(NullIf(BranchCompany.fancy_name, u''),
PersonBranch.name)
sale_subtotal = Field('_sale_items', 'subtotal')
tables = InPaymentView.tables[:]
tables.extend([
Join(PersonBranch, Branch.person_id == PersonBranch.id),
Join(BranchCompany, Branch.person_id == BranchCompany.person_id),
LeftJoin(SalesPerson, Sale.salesperson_id == SalesPerson.id),
LeftJoin(SalesPersonPerson,
SalesPerson.person_id == SalesPersonPerson.id),
LeftJoin(Client, Sale.client_id == Client.id),
LeftJoin(ClientPerson, Client.person_id == ClientPerson.id),
LeftJoin(SaleItemSummary,
Field('_sale_items', 'sale_id') == Sale.id),
])
class BaseTransferView(Viewable):
BranchDest = ClassAlias(Branch, 'branch_dest')
PersonDest = ClassAlias(Person, 'person_dest')
CompanyDest = ClassAlias(Company, 'company_dest')
transfer_order = TransferOrder
identifier = TransferOrder.identifier
identifier_str = Cast(TransferOrder.identifier, 'text')
status = TransferOrder.status
open_date = TransferOrder.open_date
finish_date = Coalesce(TransferOrder.receival_date,
TransferOrder.cancel_date)
source_branch_id = TransferOrder.source_branch_id
destination_branch_id = TransferOrder.destination_branch_id
source_branch_name = Coalesce(NullIf(Company.fancy_name, u''), Person.name)
destination_branch_name = Coalesce(NullIf(CompanyDest.fancy_name, u''),
PersonDest.name)
group_by = [TransferOrder, source_branch_name, destination_branch_name]
tables = [
TransferOrder,
Join(TransferOrderItem,
TransferOrder.id == TransferOrderItem.transfer_order_id),
# Source
LeftJoin(Branch, TransferOrder.source_branch_id == Branch.id),
LeftJoin(Person, Branch.person_id == Person.id),
LeftJoin(Company, Company.person_id == Person.id),
# Destination
LeftJoin(BranchDest,
TransferOrder.destination_branch_id == BranchDest.id),
LeftJoin(PersonDest, BranchDest.person_id == PersonDest.id),
LeftJoin(CompanyDest, CompanyDest.person_id == PersonDest.id),
]
@property
def branch(self):
# We need this property for the acronym to appear in the identifier
return self.store.get(Branch, self.source_branch_id)
class PurchaseOrderView(Viewable):
"""General information about purchase orders
:cvar id: the id of purchase_order table
:cvar status: the purchase order status
:cvar open_date: the date when the order was started
:cvar quote_deadline: the date when the quotation expires
:cvar expected_receival_date: expected date to receive products
:cvar expected_pay_date: expected date to pay the products
:cvar receival_date: the date when the products were received
:cvar confirm_date: the date when the order was confirmed
:cvar salesperson_name: the name of supplier's salesperson
:cvar expected_freight: the expected freight value
:cvar surcharge_value: the surcharge value for the order total
:cvar discount_value: the discount_value for the order total
:cvar supplier_name: the supplier name
:cvar transporter_name: the transporter name
:cvar branch_name: the branch company name
:cvar ordered_quantity: the total quantity ordered
:cvar received_quantity: the total quantity received
:cvar subtotal: the order subtotal (sum of product values)
:cvar total: subtotal - discount_value + surcharge_value
"""
Person_Supplier = ClassAlias(Person, 'person_supplier')
Person_Transporter = ClassAlias(Person, 'person_transporter')
Person_Branch = ClassAlias(Person, 'person_branch')
Person_Responsible = ClassAlias(Person, 'person_responsible')
purchase = PurchaseOrder
branch = Branch
id = PurchaseOrder.id
identifier = PurchaseOrder.identifier
identifier_str = Cast(PurchaseOrder.identifier, 'text')
status = PurchaseOrder.status
open_date = PurchaseOrder.open_date
quote_deadline = PurchaseOrder.quote_deadline
expected_receival_date = PurchaseOrder.expected_receival_date
expected_pay_date = PurchaseOrder.expected_pay_date
confirm_date = PurchaseOrder.confirm_date
salesperson_name = NullIf(PurchaseOrder.salesperson_name, u'')
expected_freight = PurchaseOrder.expected_freight
surcharge_value = PurchaseOrder.surcharge_value
discount_value = PurchaseOrder.discount_value
branch_id = Branch.id
supplier_id = Supplier.id
supplier_name = Person_Supplier.name
transporter_name = Coalesce(Person_Transporter.name, u'')
branch_name = Coalesce(NullIf(Company.fancy_name, u''), Person_Branch.name)
responsible_name = Person_Responsible.name
receival_date = Field('_receiving_order', 'receival_date')
ordered_quantity = Field('_purchase_item', 'ordered_quantity')
received_quantity = Field('_purchase_item', 'received_quantity')
subtotal = Field('_purchase_item', 'subtotal')
total = Field('_purchase_item', 'subtotal') - \
PurchaseOrder.discount_value + PurchaseOrder.surcharge_value
tables = [
PurchaseOrder,
Join(PurchaseItemSummary,
Field('_purchase_item', 'order_id') == PurchaseOrder.id),
LeftJoin(PurchaseReceivingSummary,
Field('_receiving_order', 'purchase_id') == PurchaseOrder.id),
LeftJoin(Supplier, PurchaseOrder.supplier_id == Supplier.id),
LeftJoin(Transporter, PurchaseOrder.transporter_id == Transporter.id),
LeftJoin(Branch, PurchaseOrder.branch_id == Branch.id),
LeftJoin(LoginUser, PurchaseOrder.responsible_id == LoginUser.id),
LeftJoin(Person_Supplier, Supplier.person_id == Person_Supplier.id),
LeftJoin(Person_Transporter, Transporter.person_id == Person_Transporter.id),
LeftJoin(Person_Branch, Branch.person_id == Person_Branch.id),
LeftJoin(Company, Company.person_id == Person_Branch.id),
LeftJoin(Person_Responsible, LoginUser.person_id == Person_Responsible.id),
]
@classmethod
def post_search_callback(cls, sresults):
select = sresults.get_select_expr(Count(1), Sum(cls.total))
return ('count', 'sum'), select
#
# Public API
#
def get_open_date_as_string(self):
return self.open_date.strftime("%x")
@property
def status_str(self):
return PurchaseOrder.translate_status(self.status)
@classmethod
def find_confirmed(cls, store, due_date=None):
query = cls.status == PurchaseOrder.ORDER_CONFIRMED
if due_date:
if isinstance(due_date, tuple):
date_query = And(Date(cls.expected_receival_date) >= due_date[0],
Date(cls.expected_receival_date) <= due_date[1])
else:
date_query = Date(cls.expected_receival_date) == due_date
query = And(query, date_query)
return store.find(cls, query)
class WorkOrderView(Viewable):
"""A view for |workorders|
This is used to get the most information of a |workorder|
without doing lots of database queries.
"""
# TODO: Maybe we should have a cache for branches, to avoid all this
# joins just to get the company name.
_BranchOriginalBranch = ClassAlias(Branch, "branch_original_branch")
_BranchCurrentBranch = ClassAlias(Branch, "branch_current_branch")
_PersonOriginalBranch = ClassAlias(Person, "person_original_branch")
_PersonCurrentBranch = ClassAlias(Person, "person_current_branch")
_CompanyOriginalBranch = ClassAlias(Company, "company_original_branch")
_CompanyCurrentBranch = ClassAlias(Company, "company_current_branch")
_PersonClient = ClassAlias(Person, "person_client")
_PersonSalesPerson = ClassAlias(Person, "person_salesperson")
#: the |workorder| object
work_order = WorkOrder
#: the |workordercategory| object
category = WorkOrderCategory
#: the |client| object
client = Client
# WorkOrder
id = WorkOrder.id
identifier = WorkOrder.identifier
status = WorkOrder.status
equipment = WorkOrder.equipment
open_date = WorkOrder.open_date
approve_date = WorkOrder.approve_date
finish_date = WorkOrder.finish_date
# WorkOrderCategory
category_name = WorkOrderCategory.name
category_color = WorkOrderCategory.color
# Client
client_name = _PersonClient.name
# SalesPerson
salesperson_name = _PersonSalesPerson.name
# Branch
branch_name = Coalesce(NullIf(_CompanyOriginalBranch.fancy_name, u''),
_PersonOriginalBranch.name)
current_branch_name = Coalesce(
NullIf(_CompanyCurrentBranch.fancy_name, u''),
_PersonCurrentBranch.name)
# WorkOrderItem
quantity = Coalesce(Field('_work_order_items', 'quantity'), 0)
total = Coalesce(Field('_work_order_items', 'total'), 0)
tables = [
WorkOrder,
LeftJoin(Client, WorkOrder.client_id == Client.id),
LeftJoin(_PersonClient, Client.person_id == _PersonClient.id),
LeftJoin(Sale, WorkOrder.sale_id == Sale.id),
LeftJoin(SalesPerson, Sale.salesperson_id == SalesPerson.id),
LeftJoin(_PersonSalesPerson,
SalesPerson.person_id == _PersonSalesPerson.id),
LeftJoin(_BranchOriginalBranch,
WorkOrder.branch_id == _BranchOriginalBranch.id),
LeftJoin(_PersonOriginalBranch,
_BranchOriginalBranch.person_id == _PersonOriginalBranch.id),
LeftJoin(_CompanyOriginalBranch,
_CompanyOriginalBranch.person_id == _PersonOriginalBranch.id),
LeftJoin(_BranchCurrentBranch,
WorkOrder.current_branch_id == _BranchCurrentBranch.id),
LeftJoin(_PersonCurrentBranch,
_BranchCurrentBranch.person_id == _PersonCurrentBranch.id),
LeftJoin(_CompanyCurrentBranch,
_CompanyCurrentBranch.person_id == _PersonCurrentBranch.id),
LeftJoin(WorkOrderCategory,
WorkOrder.category_id == WorkOrderCategory.id),
LeftJoin(_WorkOrderItemsSummary,
Field('_work_order_items', 'order_id') == WorkOrder.id),
]
@classmethod
def post_search_callback(cls, sresults):
select = sresults.get_select_expr(Count(1), Sum(cls.total))
return ('count', 'sum'), select
@classmethod
def find_by_current_branch(cls, store, branch):
return store.find(cls, WorkOrder.current_branch_id == branch.id)
