233 lines
8 KiB
Python
233 lines
8 KiB
Python
# -*- coding: utf-8 -*-
|
|
################################################################################
|
|
#
|
|
# Rattail -- Retail Software Framework
|
|
# Copyright © 2010-2016 Lance Edgar
|
|
#
|
|
# This file is part of Rattail.
|
|
#
|
|
# Rattail is free software: you can redistribute it and/or modify it under the
|
|
# terms of the GNU Affero General Public License as published by the Free
|
|
# Software Foundation, either version 3 of the License, or (at your option)
|
|
# any later version.
|
|
#
|
|
# Rattail is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for
|
|
# more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with Rattail. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
################################################################################
|
|
"""
|
|
Views for purchase order batches
|
|
"""
|
|
|
|
from __future__ import unicode_literals, absolute_import
|
|
|
|
from rattail.db import model, api
|
|
from rattail.gpc import GPC
|
|
from rattail.db.batch.purchase.handler import PurchaseBatchHandler
|
|
from rattail.time import localtime
|
|
|
|
import formalchemy as fa
|
|
|
|
from tailbone import forms
|
|
from tailbone.db import Session
|
|
from tailbone.views.batch import BatchMasterView
|
|
|
|
|
|
class PurchaseBatchView(BatchMasterView):
|
|
"""
|
|
Master view for purchase order batches.
|
|
"""
|
|
model_class = model.PurchaseBatch
|
|
model_title_plural = "Purchase Batches"
|
|
model_row_class = model.PurchaseBatchRow
|
|
batch_handler_class = PurchaseBatchHandler
|
|
route_prefix = 'purchases.batch'
|
|
url_prefix = '/purchases/batches'
|
|
rows_creatable = True
|
|
rows_editable = True
|
|
|
|
def _preconfigure_grid(self, g):
|
|
super(PurchaseBatchView, self)._preconfigure_grid(g)
|
|
|
|
g.joiners['vendor'] = lambda q: q.join(model.Vendor)
|
|
g.filters['vendor'] = g.make_filter('vendor', model.Vendor.name,
|
|
default_active=True, default_verb='contains')
|
|
g.sorters['vendor'] = g.make_sorter(model.Vendor.name)
|
|
|
|
g.joiners['buyer'] = lambda q: q.join(model.Employee).join(model.Person)
|
|
g.filters['buyer'] = g.make_filter('buyer', model.Person.display_name,
|
|
default_active=True, default_verb='contains')
|
|
g.sorters['buyer'] = g.make_sorter(model.Person.display_name)
|
|
|
|
g.date_ordered.set(label="Ordered")
|
|
|
|
def configure_grid(self, g):
|
|
g.configure(
|
|
include=[
|
|
g.id,
|
|
g.vendor,
|
|
g.buyer,
|
|
g.date_ordered,
|
|
g.created,
|
|
g.created_by,
|
|
g.executed,
|
|
],
|
|
readonly=True)
|
|
|
|
def _preconfigure_fieldset(self, fs):
|
|
super(PurchaseBatchView, self)._preconfigure_fieldset(fs)
|
|
fs.po_number.set(label="PO Number")
|
|
fs.po_total.set(label="PO Total")
|
|
|
|
def configure_fieldset(self, fs):
|
|
fs.configure(
|
|
include=[
|
|
fs.store,
|
|
fs.vendor.with_renderer(forms.renderers.VendorFieldRenderer),
|
|
fs.buyer.with_renderer(forms.renderers.EmployeeFieldRenderer),
|
|
fs.date_ordered,
|
|
fs.po_number,
|
|
fs.po_total,
|
|
fs.created,
|
|
fs.created_by,
|
|
fs.executed,
|
|
fs.executed_by,
|
|
])
|
|
|
|
if self.creating:
|
|
del fs.po_total
|
|
|
|
# default store may be configured
|
|
store = self.rattail_config.get('rattail', 'store')
|
|
if store:
|
|
store = api.get_store(Session(), store)
|
|
if store:
|
|
fs.model.store = store
|
|
|
|
# default buyer is current user
|
|
if self.request.method != 'POST':
|
|
buyer = self.request.user.employee
|
|
if buyer:
|
|
fs.model.buyer = buyer
|
|
|
|
# default order date is today
|
|
fs.model.date_ordered = localtime(self.rattail_config).date()
|
|
|
|
def _preconfigure_row_grid(self, g):
|
|
super(PurchaseBatchView, self)._preconfigure_row_grid(g)
|
|
|
|
g.filters['upc'].label = "UPC"
|
|
g.filters['brand_name'].label = "Brand"
|
|
|
|
g.upc.set(label="UPC")
|
|
g.brand_name.set(label="Brand")
|
|
g.cases_ordered.set(label="Cases")
|
|
g.units_ordered.set(label="Units")
|
|
g.po_total.set(label="Total")
|
|
|
|
def configure_row_grid(self, g):
|
|
g.configure(
|
|
include=[
|
|
g.sequence,
|
|
g.upc,
|
|
g.brand_name,
|
|
g.description,
|
|
g.size,
|
|
g.cases_ordered,
|
|
g.units_ordered,
|
|
g.po_total,
|
|
g.status_code,
|
|
],
|
|
readonly=True)
|
|
|
|
def make_row_grid_tools(self, batch):
|
|
return self.make_default_row_grid_tools(batch)
|
|
|
|
# def row_grid_row_attrs(self, row, i):
|
|
# attrs = {}
|
|
# if row.status_code in (row.STATUS_NOT_IN_PURCHASE,
|
|
# row.STATUS_NOT_IN_INVOICE,
|
|
# row.STATUS_DIFFERS_FROM_PURCHASE):
|
|
# attrs['class_'] = 'notice'
|
|
# if row.status_code in (row.STATUS_NOT_IN_DB,
|
|
# row.STATUS_COST_NOT_IN_DB,
|
|
# row.STATUS_NO_CASE_QUANTITY):
|
|
# attrs['class_'] = 'warning'
|
|
# return attrs
|
|
|
|
def _preconfigure_row_fieldset(self, fs):
|
|
super(PurchaseBatchView, self)._preconfigure_row_fieldset(fs)
|
|
fs.upc.set(label="UPC")
|
|
fs.brand_name.set(label="Brand")
|
|
fs.po_unit_cost.set(label="PO Unit Cost")
|
|
fs.po_total.set(label="PO Total")
|
|
fs.append(fa.Field('item_lookup', label="Item Lookup Code", required=True,
|
|
validate=self.item_lookup))
|
|
|
|
def item_lookup(self, value, field=None):
|
|
"""
|
|
Try to locate a single product using ``value`` as a lookup code.
|
|
"""
|
|
batch = self.get_instance()
|
|
product = api.get_product_by_vendor_code(Session(), value, vendor=batch.vendor)
|
|
if product:
|
|
return product.uuid
|
|
if value.isdigit():
|
|
product = api.get_product_by_upc(Session(), GPC(value))
|
|
if not product:
|
|
product = api.get_product_by_upc(Session(), GPC(value, calc_check_digit='upc'))
|
|
if product:
|
|
if not product.cost_for_vendor(batch.vendor):
|
|
raise fa.ValidationError("Product {} exists but has no cost for vendor {}".format(
|
|
product.upc.pretty(), batch.vendor))
|
|
return product.uuid
|
|
raise fa.ValidationError("Product not found")
|
|
|
|
def configure_row_fieldset(self, fs):
|
|
|
|
if self.creating:
|
|
fs.configure(
|
|
include=[
|
|
fs.item_lookup,
|
|
fs.cases_ordered,
|
|
fs.units_ordered,
|
|
])
|
|
|
|
elif self.editing:
|
|
fs.configure(
|
|
include=[
|
|
fs.upc.readonly(),
|
|
fs.product.readonly(),
|
|
fs.cases_ordered,
|
|
fs.units_ordered,
|
|
])
|
|
|
|
def before_create_row(self, form):
|
|
row = form.fieldset.model
|
|
batch = self.get_instance()
|
|
row.sequence = max([0] + [r.sequence for r in batch.data_rows]) + 1
|
|
row.batch = batch
|
|
# TODO: this seems heavy-handed but works..
|
|
row.product_uuid = self.item_lookup(form.fieldset.item_lookup.value)
|
|
|
|
def after_create_row(self, row):
|
|
self.handler.refresh_row(row)
|
|
|
|
def redirect_after_create_row(self, row):
|
|
self.request.session.flash("Added item: {} {}".format(row.upc.pretty(), row.product))
|
|
return self.redirect(self.request.current_route_url())
|
|
|
|
# TODO: redirect to new purchase...
|
|
# def get_execute_success_url(self, batch, result, **kwargs):
|
|
# # return self.get_action_url('view', batch)
|
|
# return
|
|
|
|
|
|
def includeme(config):
|
|
PurchaseBatchView.defaults(config)
|