def get_stock_state_for_transaction(transaction):
from corehq.apps.commtrack.models import StockState
from corehq.apps.locations.models import SQLLocation
from corehq.apps.products.models import SQLProduct
# todo: in the worst case, this function makes
# - three calls to couch (for the case, domain, and commtrack config)
# - four postgres queries (transacitons, product, location, and state)
# - one postgres write (to save the state)
# and that doesn't even include the consumption calc, which can do a whole
# bunch more work and hit the database.
sql_product = SQLProduct.objects.get(product_id=transaction.product_id)
try:
domain_name = transaction.__domain
except AttributeError:
domain_name = sql_product.domain
try:
sql_location = SQLLocation.objects.get(supply_point_id=transaction.case_id)
except SQLLocation.DoesNotExist:
sql_location = None
try:
state = StockState.include_archived.get(
section_id=transaction.section_id,
case_id=transaction.case_id,
product_id=transaction.product_id,
)
except StockState.DoesNotExist:
state = StockState(
section_id=transaction.section_id,
case_id=transaction.case_id,
product_id=transaction.product_id,
sql_product=sql_product,
sql_location=sql_location,
)
# we may not be saving the latest transaction so make sure we use that
# todo: this should change to server date
latest_transaction = StockTransaction.latest(
case_id=transaction.case_id,
section_id=transaction.section_id,
product_id=transaction.product_id
)
if latest_transaction != transaction:
logging.warning(
'Just fired signal for a stale stock transaction. Domain: {}, instance: {},latest was {}'.format(
domain_name, transaction, latest_transaction
)
)
transaction = latest_transaction
state.last_modified_date = transaction.report.server_date
state.last_modified_form_id = transaction.report.form_id
state.stock_on_hand = transaction.stock_on_hand
# so you don't have to look it up again in the signal receivers
if domain_name:
state.__domain = domain_name
return state
def new_stock_state(self, ref, transaction):
return StockState(
case_id=ref.case_id,
section_id=ref.section_id,
product_id=ref.entry_id,
sql_location=self.get_location(ref.case_id),
last_modified_date=transaction.report.server_date,
last_modified_form_id=transaction.report.form_id,
stock_on_hand=transaction.stock_on_hand,
)
def test_domain_mapping(self):
# make sure there's a fake case setup for this
with self.assertRaises(DocDomainMapping.DoesNotExist):
DocDomainMapping.objects.get(doc_id=self.sp._id)
StockState(
section_id='stock',
case_id=self.sp._id,
product_id=self.products[0]._id,
last_modified_date=datetime.now(),
).save()
self.assertEqual(
self.domain.name,
DocDomainMapping.objects.get(doc_id=self.sp._id).domain_name)
def stock_data():
from corehq.apps.commtrack.models import StockState
from corehq.apps.commtrack.tests.util import make_product
from corehq.apps.products.models import SQLProduct
from casexml.apps.case.mock import CaseFactory
product = make_product('domain', 'Sample Product 1', 'pp', None)
case = CaseFactory('domain').create_case()
stock_state = [
StockState(
section_id=str(i),
case_id=case.case_id,
product_id=product._id,
last_modified_date=datetime.utcnow(),
sql_product=SQLProduct.objects.get(product_id=product._id),
) for i in range(3)
]
def get_stock_state_json(sql_ledger):
"""Build stock state JSON from latest transaction
Returns empty dict if stock transactions do not exist.
"""
# similar to StockTransaction.latest(), but more efficient
transactions = list(StockTransaction.get_ordered_transactions_for_stock(
sql_ledger.case_id,
sql_ledger.section_id,
sql_ledger.product_id,
).select_related("report")[:1])
if not transactions:
return {}
transaction = transactions[0]
return StockState(
case_id=sql_ledger.case_id,
section_id=sql_ledger.section_id,
product_id=sql_ledger.product_id,
sql_location=SQLLocation.objects.get_or_None(supply_point_id=sql_ledger.case_id),
last_modified_date=transaction.report.server_date,
last_modified_form_id=transaction.report.form_id,
stock_on_hand=transaction.stock_on_hand,
).to_json()
