Use "shipped" instead of "ordered" for truck dump child row "claims"

i.e. if 1 CS is received, that should count against the *shipped* quantity and
not the "ordered" quantity.  if shipped is not explicitly stated on the
invoice, its value should be copied from the ordered quantity
This commit is contained in:
Lance Edgar 2019-04-01 13:18:40 -05:00
parent 850c197834
commit 1d05f73bfe

View file

@ -361,24 +361,24 @@ class PurchaseBatchHandler(BatchHandler):
# for each child row we also calculate all "present", and "claimed"
# vs. "pending" product quantities
# cases_ordered
cases_ordered = child_row.cases_ordered or 0
cases_ordered_claimed = sum([(claim.cases_received or 0)
# cases_shipped
cases_shipped = child_row.cases_shipped or 0
cases_shipped_claimed = sum([(claim.cases_received or 0)
+ (claim.cases_damaged or 0)
+ (claim.cases_expired or 0)
for claim in child_row.truck_dump_claims])
cases_ordered_pending = cases_ordered - cases_ordered_claimed
cases_shipped_pending = cases_shipped - cases_shipped_claimed
# units_ordered
units_ordered = child_row.units_ordered or 0
units_ordered_claimed = sum([(claim.units_received or 0)
# units_shipped
units_shipped = child_row.units_shipped or 0
units_shipped_claimed = sum([(claim.units_received or 0)
+ (claim.units_damaged or 0)
+ (claim.units_expired or 0)
for claim in child_row.truck_dump_claims])
units_ordered_pending = units_ordered - units_ordered_claimed
units_shipped_pending = units_shipped - units_shipped_claimed
# skip this child row if everything in it is accounted for
if not (cases_ordered_pending or units_ordered_pending):
if not (cases_shipped_pending or units_shipped_pending):
continue
# there should only be one claim for this parent/child combo
@ -388,84 +388,84 @@ class PurchaseBatchHandler(BatchHandler):
case_quantity = child_row.case_quantity
# make case claims
if cases_ordered_pending and cases_received_pending:
if cases_shipped_pending and cases_received_pending:
claim = claim or make_claim(child_row)
if cases_received_pending >= cases_ordered_pending:
claim.cases_received = (claim.cases_received or 0) + cases_ordered_pending
child_row.cases_received = (child_row.cases_received or 0) + cases_ordered_pending
cases_received_pending -= cases_ordered_pending
cases_ordered_pending = 0
else: # ordered > received
if cases_received_pending >= cases_shipped_pending:
claim.cases_received = (claim.cases_received or 0) + cases_shipped_pending
child_row.cases_received = (child_row.cases_received or 0) + cases_shipped_pending
cases_received_pending -= cases_shipped_pending
cases_shipped_pending = 0
else: # shipped > received
claim.cases_received = (claim.cases_received or 0) + cases_received_pending
child_row.cases_received = (child_row.cases_received or 0) + cases_received_pending
cases_ordered_pending -= cases_received_pending
cases_shipped_pending -= cases_received_pending
cases_received_pending = 0
self.refresh_row(child_row)
if cases_ordered_pending and cases_damaged_pending:
if cases_shipped_pending and cases_damaged_pending:
claim = claim or make_claim(child_row)
if cases_damaged_pending >= cases_ordered_pending:
claim.cases_damaged = (claim.cases_damaged or 0) + cases_ordered_pending
child_row.cases_damaged = (child_row.cases_damaged or 0) + cases_ordered_pending
cases_damaged_pending -= cases_ordered_pending
cases_ordered_pending = 0
else: # ordered > damaged
if cases_damaged_pending >= cases_shipped_pending:
claim.cases_damaged = (claim.cases_damaged or 0) + cases_shipped_pending
child_row.cases_damaged = (child_row.cases_damaged or 0) + cases_shipped_pending
cases_damaged_pending -= cases_shipped_pending
cases_shipped_pending = 0
else: # shipped > damaged
claim.cases_damaged = (claim.cases_damaged or 0) + cases_damaged_pending
child_row.cases_damaged = (child_row.cases_damaged or 0) + cases_damaged_pending
cases_ordered_pending -= cases_damaged_pending
cases_shipped_pending -= cases_damaged_pending
cases_damaged_pending = 0
self.refresh_row(child_row)
if cases_ordered_pending and cases_expired_pending:
if cases_shipped_pending and cases_expired_pending:
claim = claim or make_claim(child_row)
if cases_expired_pending >= cases_ordered_pending:
claim.cases_expired = (claim.cases_expired or 0) + cases_ordered_pending
child_row.cases_expired = (child_row.cases_expired or 0) + cases_ordered_pending
cases_expired_pending -= cases_ordered_pending
cases_ordered_pending = 0
else: # ordered > expired
if cases_expired_pending >= cases_shipped_pending:
claim.cases_expired = (claim.cases_expired or 0) + cases_shipped_pending
child_row.cases_expired = (child_row.cases_expired or 0) + cases_shipped_pending
cases_expired_pending -= cases_shipped_pending
cases_shipped_pending = 0
else: # shipped > expired
claim.cases_expired = (claim.cases_expired or 0) + cases_expired_pending
child_row.cases_expired = (child_row.cases_expired or 0) + cases_expired_pending
cases_ordered_pending -= cases_expired_pending
cases_shipped_pending -= cases_expired_pending
cases_expired_pending = 0
self.refresh_row(child_row)
# make unit claims
if units_ordered_pending and units_received_pending:
if units_shipped_pending and units_received_pending:
claim = claim or make_claim(child_row)
if units_received_pending >= units_ordered_pending:
claim.units_received = (claim.units_received or 0) + units_ordered_pending
child_row.units_received = (child_row.units_received or 0) + units_ordered_pending
units_received_pending -= units_ordered_pending
units_ordered_pending = 0
else: # ordered > received
if units_received_pending >= units_shipped_pending:
claim.units_received = (claim.units_received or 0) + units_shipped_pending
child_row.units_received = (child_row.units_received or 0) + units_shipped_pending
units_received_pending -= units_shipped_pending
units_shipped_pending = 0
else: # shipped > received
claim.units_received = (claim.units_received or 0) + units_received_pending
child_row.units_received = (child_row.units_received or 0) + units_received_pending
units_ordered_pending -= units_received_pending
units_shipped_pending -= units_received_pending
units_received_pending = 0
self.refresh_row(child_row)
if units_ordered_pending and units_damaged_pending:
if units_shipped_pending and units_damaged_pending:
claim = claim or make_claim(child_row)
if units_damaged_pending >= units_ordered_pending:
claim.units_damaged = (claim.units_damaged or 0) + units_ordered_pending
child_row.units_damaged = (child_row.units_damaged or 0) + units_ordered_pending
units_damaged_pending -= units_ordered_pending
units_ordered_pending = 0
else: # ordered > damaged
if units_damaged_pending >= units_shipped_pending:
claim.units_damaged = (claim.units_damaged or 0) + units_shipped_pending
child_row.units_damaged = (child_row.units_damaged or 0) + units_shipped_pending
units_damaged_pending -= units_shipped_pending
units_shipped_pending = 0
else: # shipped > damaged
claim.units_damaged = (claim.units_damaged or 0) + units_damaged_pending
child_row.units_damaged = (child_row.units_damaged or 0) + units_damaged_pending
units_ordered_pending -= units_damaged_pending
units_shipped_pending -= units_damaged_pending
units_damaged_pending = 0
self.refresh_row(child_row)
if units_ordered_pending and units_expired_pending:
if units_shipped_pending and units_expired_pending:
claim = claim or make_claim(child_row)
if units_expired_pending >= units_ordered_pending:
claim.units_expired = (claim.units_expired or 0) + units_ordered_pending
child_row.units_expired = (child_row.units_expired or 0) + units_ordered_pending
units_expired_pending -= units_ordered_pending
units_ordered_pending = 0
else: # ordered > expired
if units_expired_pending >= units_shipped_pending:
claim.units_expired = (claim.units_expired or 0) + units_shipped_pending
child_row.units_expired = (child_row.units_expired or 0) + units_shipped_pending
units_expired_pending -= units_shipped_pending
units_shipped_pending = 0
else: # shipped > expired
claim.units_expired = (claim.units_expired or 0) + units_expired_pending
child_row.units_expired = (child_row.units_expired or 0) + units_expired_pending
units_ordered_pending -= units_expired_pending
units_shipped_pending -= units_expired_pending
units_expired_pending = 0
self.refresh_row(child_row)
@ -473,49 +473,49 @@ class PurchaseBatchHandler(BatchHandler):
# crosses the case/unit boundary, but is considered "safe" because
# we assume the child row has correct case quantity even if parent
# row has a different one.
if cases_ordered_pending and units_received_pending:
if cases_shipped_pending and units_received_pending:
received = units_received_pending // case_quantity
if received:
claim = claim or make_claim(child_row)
if received >= cases_ordered_pending:
claim.cases_received = (claim.cases_received or 0) + cases_ordered_pending
child_row.cases_received = (child_row.units_received or 0) + cases_ordered_pending
units_received_pending -= (cases_ordered_pending * case_quantity)
cases_ordered_pending = 0
else: # ordered > received
if received >= cases_shipped_pending:
claim.cases_received = (claim.cases_received or 0) + cases_shipped_pending
child_row.cases_received = (child_row.units_received or 0) + cases_shipped_pending
units_received_pending -= (cases_shipped_pending * case_quantity)
cases_shipped_pending = 0
else: # shipped > received
claim.cases_received = (claim.cases_received or 0) + received
child_row.cases_received = (child_row.units_received or 0) + received
cases_ordered_pending -= received
cases_shipped_pending -= received
units_received_pending -= (received * case_quantity)
self.refresh_row(child_row)
if cases_ordered_pending and units_damaged_pending:
if cases_shipped_pending and units_damaged_pending:
damaged = units_damaged_pending // case_quantity
if damaged:
claim = claim or make_claim(child_row)
if damaged >= cases_ordered_pending:
claim.cases_damaged = (claim.cases_damaged or 0) + cases_ordered_pending
child_row.cases_damaged = (child_row.units_damaged or 0) + cases_ordered_pending
units_damaged_pending -= (cases_ordered_pending * case_quantity)
cases_ordered_pending = 0
else: # ordered > damaged
if damaged >= cases_shipped_pending:
claim.cases_damaged = (claim.cases_damaged or 0) + cases_shipped_pending
child_row.cases_damaged = (child_row.units_damaged or 0) + cases_shipped_pending
units_damaged_pending -= (cases_shipped_pending * case_quantity)
cases_shipped_pending = 0
else: # shipped > damaged
claim.cases_damaged = (claim.cases_damaged or 0) + damaged
child_row.cases_damaged = (child_row.units_damaged or 0) + damaged
cases_ordered_pending -= damaged
cases_shipped_pending -= damaged
units_damaged_pending -= (damaged * case_quantity)
self.refresh_row(child_row)
if cases_ordered_pending and units_expired_pending:
if cases_shipped_pending and units_expired_pending:
expired = units_expired_pending // case_quantity
if expired:
claim = claim or make_claim(child_row)
if expired >= cases_ordered_pending:
claim.cases_expired = (claim.cases_expired or 0) + cases_ordered_pending
child_row.cases_expired = (child_row.units_expired or 0) + cases_ordered_pending
units_expired_pending -= (cases_ordered_pending * case_quantity)
cases_ordered_pending = 0
else: # ordered > expired
if expired >= cases_shipped_pending:
claim.cases_expired = (claim.cases_expired or 0) + cases_shipped_pending
child_row.cases_expired = (child_row.units_expired or 0) + cases_shipped_pending
units_expired_pending -= (cases_shipped_pending * case_quantity)
cases_shipped_pending = 0
else: # shipped > expired
claim.cases_expired = (claim.cases_expired or 0) + expired
child_row.cases_expired = (child_row.units_expired or 0) + expired
cases_ordered_pending -= expired
cases_shipped_pending -= expired
units_expired_pending -= (expired * case_quantity)
self.refresh_row(child_row)
@ -524,61 +524,61 @@ class PurchaseBatchHandler(BatchHandler):
# only if the case quantity matches between child and parent rows.
# (otherwise who knows what could go wrong.)
if case_quantity == truck_dump_row.case_quantity:
if units_ordered_pending and cases_received_pending:
if units_shipped_pending and cases_received_pending:
received = cases_received_pending * case_quantity
claim = claim or make_claim(child_row)
if received >= units_ordered_pending:
claim.units_received = (claim.units_received or 0) + units_ordered_pending
child_row.units_received = (child_row.units_received or 0) + units_ordered_pending
leftover = received % units_ordered_pending
if received >= units_shipped_pending:
claim.units_received = (claim.units_received or 0) + units_shipped_pending
child_row.units_received = (child_row.units_received or 0) + units_shipped_pending
leftover = received % units_shipped_pending
if leftover == 0:
cases_received_pending -= (received // units_ordered_pending)
cases_received_pending -= (received // units_shipped_pending)
else:
cases_received_pending -= (received // units_ordered_pending) - 1
cases_received_pending -= (received // units_shipped_pending) - 1
units_received_pending += leftover
units_ordered_pending = 0
else: # ordered > received
units_shipped_pending = 0
else: # shipped > received
claim.units_received = (claim.units_received or 0) + received
child_row.units_received = (child_row.units_received or 0) + received
units_ordered_pending -= received
units_shipped_pending -= received
cases_received_pending = 0
self.refresh_row(child_row)
if units_ordered_pending and cases_damaged_pending:
if units_shipped_pending and cases_damaged_pending:
damaged = cases_damaged_pending * case_quantity
claim = claim or make_claim(child_row)
if damaged >= units_ordered_pending:
claim.units_damaged = (claim.units_damaged or 0) + units_ordered_pending
child_row.units_damaged = (child_row.units_damaged or 0) + units_ordered_pending
leftover = damaged % units_ordered_pending
if damaged >= units_shipped_pending:
claim.units_damaged = (claim.units_damaged or 0) + units_shipped_pending
child_row.units_damaged = (child_row.units_damaged or 0) + units_shipped_pending
leftover = damaged % units_shipped_pending
if leftover == 0:
cases_damaged_pending -= (damaged // units_ordered_pending)
cases_damaged_pending -= (damaged // units_shipped_pending)
else:
cases_damaged_pending -= (damaged // units_ordered_pending) - 1
cases_damaged_pending -= (damaged // units_shipped_pending) - 1
units_damaged_pending += leftover
units_ordered_pending = 0
else: # ordered > damaged
units_shipped_pending = 0
else: # shipped > damaged
claim.units_damaged = (claim.units_damaged or 0) + damaged
child_row.units_damaged = (child_row.units_damaged or 0) + damaged
units_ordered_pending -= damaged
units_shipped_pending -= damaged
cases_damaged_pending = 0
self.refresh_row(child_row)
if units_ordered_pending and cases_expired_pending:
if units_shipped_pending and cases_expired_pending:
expired = cases_expired_pending * case_quantity
claim = claim or make_claim(child_row)
if expired >= units_ordered_pending:
claim.units_expired = (claim.units_expired or 0) + units_ordered_pending
child_row.units_expired = (child_row.units_expired or 0) + units_ordered_pending
leftover = expired % units_ordered_pending
if expired >= units_shipped_pending:
claim.units_expired = (claim.units_expired or 0) + units_shipped_pending
child_row.units_expired = (child_row.units_expired or 0) + units_shipped_pending
leftover = expired % units_shipped_pending
if leftover == 0:
cases_expired_pending -= (expired // units_ordered_pending)
cases_expired_pending -= (expired // units_shipped_pending)
else:
cases_expired_pending -= (expired // units_ordered_pending) - 1
cases_expired_pending -= (expired // units_shipped_pending) - 1
units_expired_pending += leftover
units_ordered_pending = 0
else: # ordered > expired
units_shipped_pending = 0
else: # shipped > expired
claim.units_expired = (claim.units_expired or 0) + expired
child_row.units_expired = (child_row.units_expired or 0) + expired
units_ordered_pending -= expired
units_shipped_pending -= expired
cases_expired_pending = 0
self.refresh_row(child_row)
@ -1392,11 +1392,11 @@ class PurchaseBatchHandler(BatchHandler):
# update child row
self.receiving_update_row_attrs(child_row, mode, cases, units)
if cases:
child_row.cases_ordered_claimed += cases
child_row.cases_ordered_pending -= cases
child_row.cases_shipped_claimed += cases
child_row.cases_shipped_pending -= cases
if units:
child_row.units_ordered_claimed += units
child_row.units_ordered_pending -= units
child_row.units_shipped_claimed += units
child_row.units_shipped_pending -= units
# update child credit, if applicable
self.receiving_update_row_credits(child_row, mode, cases, units, **kwargs)
@ -1418,28 +1418,28 @@ class PurchaseBatchHandler(BatchHandler):
# first we try to accommodate the full "as-is" amounts, if possible
if positive:
if cases and units:
if child_row.cases_ordered_pending >= cases and child_row.units_ordered_pending >= units:
if child_row.cases_shipped_pending >= cases and child_row.units_shipped_pending >= units:
update(cases, units)
return 0, 0
elif cases:
if child_row.cases_ordered_pending >= cases:
if child_row.cases_shipped_pending >= cases:
update(cases, 0)
return 0, 0
else: # units
if child_row.units_ordered_pending >= units:
if child_row.units_shipped_pending >= units:
update(0, units)
return 0, 0
else: # negative
if cases and units:
if child_row.cases_ordered_claimed >= -cases and child_row.units_ordered_claimed >= -units:
if child_row.cases_shipped_claimed >= -cases and child_row.units_shipped_claimed >= -units:
update(cases, units)
return 0, 0
elif cases:
if child_row.cases_ordered_claimed >= -cases:
if child_row.cases_shipped_claimed >= -cases:
update(cases, 0)
return 0, 0
else: # units
if child_row.units_ordered_claimed >= -units:
if child_row.units_shipped_claimed >= -units:
update(0, units)
return 0, 0
@ -1447,49 +1447,49 @@ class PurchaseBatchHandler(BatchHandler):
# much as possible, as simply as possible"
if cases and units:
if positive:
if child_row.cases_ordered_pending >= cases:
if child_row.cases_shipped_pending >= cases:
update(cases, 0)
return 0, units
if child_row.units_ordered_pending >= units:
if child_row.units_shipped_pending >= units:
update(0, units)
return cases, 0
else: # negative
if child_row.cases_ordered_claimed >= -cases:
if child_row.cases_shipped_claimed >= -cases:
update(cases, 0)
return 0, units
if child_row.units_ordered_claimed >= -units:
if child_row.units_shipped_claimed >= -units:
update(0, units)
return cases, 0
# okay then, try to (simply) use up any "child" quantities
if positive:
if cases and units and (child_row.cases_ordered_pending
and child_row.units_ordered_pending):
pending = (child_row.cases_ordered_pending,
child_row.units_ordered_pending)
if cases and units and (child_row.cases_shipped_pending
and child_row.units_shipped_pending):
pending = (child_row.cases_shipped_pending,
child_row.units_shipped_pending)
update(pending[0], pending[1])
return cases - pending[0], units - pending[1]
if cases and child_row.cases_ordered_pending:
pending = child_row.cases_ordered_pending
if cases and child_row.cases_shipped_pending:
pending = child_row.cases_shipped_pending
update(pending, 0)
return cases - pending, 0
if units and child_row.units_ordered_pending:
pending = child_row.units_ordered_pending
if units and child_row.units_shipped_pending:
pending = child_row.units_shipped_pending
update(0, pending)
return 0, units - pending
else: # negative
if cases and units and (child_row.cases_ordered_claimed
and child_row.units_ordered_claimed):
claimed = (child_row.cases_ordered_claimed,
child_row.units_ordered_claimed)
if cases and units and (child_row.cases_shipped_claimed
and child_row.units_shipped_claimed):
claimed = (child_row.cases_shipped_claimed,
child_row.units_shipped_claimed)
update(-claimed[0], -claimed[1])
return cases + claimed[0], units + claimed[1]
if cases and child_row.cases_ordered_claimed:
claimed = child_row.cases_ordered_claimed
if cases and child_row.cases_shipped_claimed:
claimed = child_row.cases_shipped_claimed
update(-claimed, 0)
return cases + claimed, 0
if units and child_row.units_ordered_claimed:
claimed = child_row.units_ordered_claimed
if units and child_row.units_shipped_claimed:
claimed = child_row.units_shipped_claimed
update(0, -claimed)
return 0, units + claimed
@ -1497,9 +1497,9 @@ class PurchaseBatchHandler(BatchHandler):
if parent_row.case_quantity != child_row.case_quantity:
raise NotImplementedError("cannot split case when parent/child disagree about size")
if positive:
if cases and child_row.units_ordered_pending:
if child_row.units_ordered_pending >= parent_row.case_quantity:
unit_cases = child_row.units_ordered_pending // parent_row.case_quantity
if cases and child_row.units_shipped_pending:
if child_row.units_shipped_pending >= parent_row.case_quantity:
unit_cases = child_row.units_shipped_pending // parent_row.case_quantity
if unit_cases >= cases:
update(0, cases * parent_row.case_quantity)
return 0, units
@ -1507,27 +1507,27 @@ class PurchaseBatchHandler(BatchHandler):
update(0, unit_cases * parent_row.case_quantity)
return cases - unit_cases, units
else: # units_pending < case_size
pending = child_row.units_ordered_pending
pending = child_row.units_shipped_pending
update(0, pending)
return (cases - 1,
(units or 0) + parent_row.case_quantity - pending)
if units and child_row.cases_ordered_pending:
if units and child_row.cases_shipped_pending:
if units >= parent_row.case_quantity:
unit_cases = units // parent_row.case_quantity
if unit_cases <= child_row.cases_ordered_pending:
if unit_cases <= child_row.cases_shipped_pending:
update(unit_cases, 0)
return 0, units - (unit_cases * parent_row.case_quantity)
else: # unit_cases > cases_pending
pending = child_row.cases_ordered_pending
pending = child_row.cases_shipped_pending
update(pending, 0)
return 0, units - (pending * parent_row.case_quantity)
else: # units < case_size
update(0, units)
return 0, 0
else: # negative
if cases and child_row.units_ordered_claimed:
if child_row.units_ordered_claimed >= parent_row.case_quantity:
unit_cases = child_row.units_ordered_claimed // parent_row.case_quantity
if cases and child_row.units_shipped_claimed:
if child_row.units_shipped_claimed >= parent_row.case_quantity:
unit_cases = child_row.units_shipped_claimed // parent_row.case_quantity
if unit_cases >= -cases:
update(0, cases * parent_row.case_quantity)
return 0, units
@ -1535,18 +1535,18 @@ class PurchaseBatchHandler(BatchHandler):
update(0, -unit_cases * parent_row.case_quantity)
return cases + unit_cases, units
else: # units_claimed < case_size
claimed = child_row.units_ordered_claimed
claimed = child_row.units_shipped_claimed
update(0, -claimed)
return (cases + 1,
(units or 0) - parent_row.case_quantity + claimed)
if units and child_row.cases_ordered_claimed:
if units and child_row.cases_shipped_claimed:
if -units >= parent_row.case_quantity:
unit_cases = -units // parent_row.case_quantity
if unit_cases <= child_row.cases_ordered_claimed:
if unit_cases <= child_row.cases_shipped_claimed:
update(-unit_cases, 0)
return 0, units + (unit_cases * parent_row.case_quantity)
else: # unit_cases > cases_claimed
claimed = child_row.cases_ordered_claimed
claimed = child_row.cases_shipped_claimed
update(-claimed, 0)
return 0, units + (claimed * parent_row.case_quantity)
else: # -units < case_size
@ -1604,39 +1604,39 @@ class PurchaseBatchHandler(BatchHandler):
# for each child row we also calculate "claimed" vs. "pending" amounts
# cases_ordered
child_row.cases_ordered_claimed = sum([(claim.cases_received or 0)
child_row.cases_shipped_claimed = sum([(claim.cases_received or 0)
+ (claim.cases_damaged or 0)
+ (claim.cases_expired or 0)
for claim in child_row.truck_dump_claims])
child_row.cases_ordered_pending = (child_row.cases_ordered or 0) - child_row.cases_ordered_claimed
child_row.cases_shipped_pending = (child_row.cases_ordered or 0) - child_row.cases_shipped_claimed
# units_ordered
child_row.units_ordered_claimed = sum([(claim.units_received or 0)
child_row.units_shipped_claimed = sum([(claim.units_received or 0)
+ (claim.units_damaged or 0)
+ (claim.units_expired or 0)
for claim in child_row.truck_dump_claims])
child_row.units_ordered_pending = (child_row.units_ordered or 0) - child_row.units_ordered_claimed
child_row.units_shipped_pending = (child_row.units_ordered or 0) - child_row.units_shipped_claimed
# maybe account for split cases
if child_row.units_ordered_pending < 0:
split_cases = -child_row.units_ordered_pending // child_row.case_quantity
if -child_row.units_ordered_pending % child_row.case_quantity:
if child_row.units_shipped_pending < 0:
split_cases = -child_row.units_shipped_pending // child_row.case_quantity
if -child_row.units_shipped_pending % child_row.case_quantity:
split_cases += 1
if split_cases > child_row.cases_ordered_pending:
if split_cases > child_row.cases_shipped_pending:
raise ValueError("too many cases have been split?")
child_row.cases_ordered_pending -= split_cases
child_row.units_ordered_pending += split_cases * child_row.case_quantity
child_row.cases_shipped_pending -= split_cases
child_row.units_shipped_pending += split_cases * child_row.case_quantity
all_child_rows.append(child_row)
def sortkey(row):
if positive:
return self.get_units(row.cases_ordered_pending,
row.units_ordered_pending,
return self.get_units(row.cases_shipped_pending,
row.units_shipped_pending,
row.case_quantity)
else: # negative
return self.get_units(row.cases_ordered_claimed,
row.units_ordered_claimed,
return self.get_units(row.cases_shipped_claimed,
row.units_shipped_claimed,
row.case_quantity)
# sort child rows such that smallest (relevant) quantities come first;
@ -1647,24 +1647,24 @@ class PurchaseBatchHandler(BatchHandler):
for child_row in all_child_rows:
if cases and units:
if positive:
if child_row.cases_ordered_pending == cases and child_row.units_ordered_pending == units:
if child_row.cases_shipped_pending == cases and child_row.units_shipped_pending == units:
return child_row
else: # negative
if child_row.cases_ordered_claimed == cases and child_row.units_ordered_claimed == units:
if child_row.cases_shipped_claimed == cases and child_row.units_shipped_claimed == units:
return child_row
elif cases:
if positive:
if child_row.cases_ordered_pending == cases:
if child_row.cases_shipped_pending == cases:
return child_row
else: # negative
if child_row.cases_ordered_claimed == cases:
if child_row.cases_shipped_claimed == cases:
return child_row
else: # units
if positive:
if child_row.units_ordered_pending == units:
if child_row.units_shipped_pending == units:
return child_row
else: # negative
if child_row.units_ordered_claimed == units:
if child_row.units_shipped_claimed == units:
return child_row
# next we try to find the "first" (smallest) match which satisfies, but
@ -1672,24 +1672,24 @@ class PurchaseBatchHandler(BatchHandler):
for child_row in all_child_rows:
if cases and units:
if positive:
if child_row.cases_ordered_pending >= cases and child_row.units_ordered_pending >= units:
if child_row.cases_shipped_pending >= cases and child_row.units_shipped_pending >= units:
return child_row
else: # negative
if child_row.cases_ordered_claimed >= -cases and child_row.units_ordered_claimed >= -units:
if child_row.cases_shipped_claimed >= -cases and child_row.units_shipped_claimed >= -units:
return child_row
elif cases:
if positive:
if child_row.cases_ordered_pending >= cases:
if child_row.cases_shipped_pending >= cases:
return child_row
else: # negative
if child_row.cases_ordered_claimed >= -cases:
if child_row.cases_shipped_claimed >= -cases:
return child_row
else: # units
if positive:
if child_row.units_ordered_pending >= units:
if child_row.units_shipped_pending >= units:
return child_row
else: # negative
if child_row.units_ordered_claimed >= -units:
if child_row.units_shipped_claimed >= -units:
return child_row
# okay, we're getting desperate now; let's start splitting cases and
@ -1697,14 +1697,14 @@ class PurchaseBatchHandler(BatchHandler):
incoming_units = self.get_units(cases, units, parent_row.case_quantity)
for child_row in all_child_rows:
if positive:
pending_units = self.get_units(child_row.cases_ordered_pending,
child_row.units_ordered_pending,
pending_units = self.get_units(child_row.cases_shipped_pending,
child_row.units_shipped_pending,
child_row.case_quantity)
if pending_units >= incoming_units:
return child_row
else: # negative
claimed_units = self.get_units(child_row.cases_ordered_claimed,
child_row.units_ordered_claimed,
claimed_units = self.get_units(child_row.cases_shipped_claimed,
child_row.units_shipped_claimed,
child_row.case_quantity)
if claimed_units >= -incoming_units:
return child_row
@ -1716,10 +1716,10 @@ class PurchaseBatchHandler(BatchHandler):
# list *backwards* here, hoping for the "biggest" match
for child_row in reversed(all_child_rows):
if positive:
if child_row.cases_ordered_pending or child_row.units_ordered_pending:
if child_row.cases_shipped_pending or child_row.units_shipped_pending:
return child_row
else: # negative
if child_row.cases_ordered_claimed or child_row.units_ordered_claimed:
if child_row.cases_shipped_claimed or child_row.units_shipped_claimed:
return child_row
def remove_row(self, row):