def test_delete(self):
# assign some product to the new program
self.products[0].program_id = self.new_program._id
self.products[0].save()
# make sure start state is okay
self.assertEqual(
2,
len(Program.by_domain(self.domain.name))
)
self.assertEqual(
2,
Product.by_program_id(self.domain.name, self.default_program._id).count()
)
self.assertEqual(
1,
Product.by_program_id(self.domain.name, self.new_program._id).count()
)
self.assertEqual(
self.new_program._id,
self.products[0].program_id
)
self.assertEqual(
self.new_program._id,
SQLProduct.objects.get(product_id=self.products[0]._id).program_id
)
# stash the id before we delete
new_program_id = self.new_program._id
self.new_program.delete()
with self.assertRaises(ResourceNotFound):
Program.get(new_program_id)
self.assertEqual(
1,
len(Program.by_domain(self.domain.name))
)
self.assertEqual(
3,
Product.by_program_id(self.domain.name, self.default_program._id).count()
)
self.assertEqual(
self.default_program._id,
Product.get(self.products[0]._id).program_id
)
self.assertEqual(
self.default_program._id,
SQLProduct.objects.get(product_id=self.products[0]._id).program_id
)
def delete(self):
# you cannot delete the default program
if self.default:
raise Exception(_('You cannot delete the default program'))
default = Program.default_for_domain(self.domain)
products = Product.by_program_id(
self.domain,
self._id,
wrap=False
)
to_save = []
for product in products:
product['program_id'] = default._id
to_save.append(product)
# break up saving in case there are many products
if to_save > 500:
Product.get_db().bulk_save(to_save)
to_save = []
Product.get_db().bulk_save(to_save)
# bulk update sqlproducts
SQLProduct.objects.filter(program_id=self._id).update(program_id=default._id)
return super(Program, self).delete()
def delete(self):
# you cannot delete the default program
if self.default:
raise Exception(_('You cannot delete the default program'))
default = Program.default_for_domain(self.domain)
products = Product.by_program_id(self.domain, self._id, wrap=True)
to_save = []
for product in products:
product['program_id'] = default._id
to_save.append(product)
# break up saving in case there are many products
if len(to_save) > 500:
Product.bulk_save(to_save)
to_save = []
Product.bulk_save(to_save)
# bulk update sqlproducts
SQLProduct.objects.filter(program_id=self._id).update(
program_id=default._id)
return super(Program, self).delete()
def drilldown_map(self):
options = [{"val": ALL_OPTION, "text": "All", "next": []}]
for program in Program.by_domain(self.domain):
products = [{"val": ALL_OPTION, "text": "All", "next": []}]
for product in Product.by_program_id(self.domain, program._id):
products.append({"val": product.get_id, "text": product.name + ' (%s)' % product.code})
options.append({"val": program.get_id, "text": program.name, "next": products})
return options
def drilldown_map(self):
options = []
for program in Program.by_domain(self.domain):
products = []
for product in Product.by_program_id(self.domain, program._id):
products.append({"val": product.get_id, "text": product.name})
options.append({"val": program.get_id, "text": program.name, "next": products})
return options
def get_products(self):
if self.config['program'] and not self.config['product']:
product_ids = [product.get_id for product in Product.by_program_id(self.config['domain'],
self.config['program'])]
elif self.config['program'] and self.config['product']:
product_ids = [self.config['product']]
else:
product_ids = Product.ids_by_domain(self.config['domain'])
return product_ids
def product_data(self):
def _scrub(product_doc):
product_doc['code'] = product_doc.pop('code_')
return product_doc
data = []
products = Product.by_program_id(domain=self.domain, prog_id=self.program_id, skip=self.skip(),
limit=self.limit)
for p in products:
data.append(_scrub(p._doc))
return data
def test_delete(self):
# assign some product to the new program
self.products[0].program_id = self.new_program._id
self.products[0].save()
# make sure start state is okay
self.assertEqual(2, len(Program.by_domain(self.domain.name)))
self.assertEqual(
2,
Product.by_program_id(self.domain.name,
self.default_program._id).count())
self.assertEqual(
1,
Product.by_program_id(self.domain.name,
self.new_program._id).count())
self.assertEqual(self.new_program._id, self.products[0].program_id)
self.assertEqual(
self.new_program._id,
SQLProduct.objects.get(product_id=self.products[0]._id).program_id)
# stash the id before we delete
new_program_id = self.new_program._id
self.new_program.delete()
with self.assertRaises(ResourceNotFound):
Program.get(new_program_id)
self.assertEqual(1, len(Program.by_domain(self.domain.name)))
self.assertEqual(
3,
Product.by_program_id(self.domain.name,
self.default_program._id).count())
self.assertEqual(self.default_program._id,
Product.get(self.products[0]._id).program_id)
self.assertEqual(
self.default_program._id,
SQLProduct.objects.get(product_id=self.products[0]._id).program_id)
def product_ids_filtered_by_program(domain, program):
products = Product.by_program_id(domain, program, False)
return [p['_id'] for p in products]
def get_prod_data(self):
for sublocation in self.sublocations:
sp_ids = get_relevant_supply_point_ids(self.config['domain'], sublocation)
stock_states = StockState.include_archived.filter(
case_id__in=sp_ids,
last_modified_date__lte=self.config['enddate'],
last_modified_date__gte=self.config['startdate'],
section_id=STOCK_SECTION_TYPE
)
stock_states = stock_states.order_by('product_id')
state_grouping = {}
for state in stock_states:
status = state.stock_category
if state.product_id in state_grouping:
state_grouping[state.product_id][status] += 1
else:
state_grouping[state.product_id] = {
'id': state.product_id,
'stockout': 0,
'understock': 0,
'overstock': 0,
'adequate': 0,
'nodata': 0,
'facility_count': 1,
'amc': int(state.get_monthly_consumption() or 0)
}
state_grouping[state.product_id][status] = 1
location_grouping = {
'location': sublocation.name,
'stockout': 0,
'understock': 0,
'adequate': 0,
'overstock': 0,
'total': 0,
'amc': 0
}
product_ids = []
if self.config['program'] != '' and self.config['product'] == '':
product_ids = [product.get_id for product in Product.by_program_id(self.config['domain'],
self.config['program'])]
elif self.config['program'] != '' and self.config['product'] != '':
product_ids = [self.config['product']]
else:
product_ids = Product.ids_by_domain(self.config['domain'])
for product in state_grouping.values():
if product['id'] in product_ids:
location_grouping['stockout'] += product['stockout']
location_grouping['understock'] += product['understock']
location_grouping['adequate'] += product['adequate']
location_grouping['overstock'] += product['overstock']
location_grouping['total'] += sum([product['stockout'], product['understock'],
product['adequate'], product['overstock']])
location_grouping['amc'] += product['amc']
location_grouping['stockout'] = self.percent_fn(location_grouping['total'],
location_grouping['stockout'])
location_grouping['understock'] = self.percent_fn(location_grouping['total'],
location_grouping['understock'])
location_grouping['adequate'] = self.percent_fn(location_grouping['total'],
location_grouping['adequate'])
location_grouping['overstock'] = self.percent_fn(location_grouping['total'],
location_grouping['overstock'])
yield location_grouping
def get_prod_data(self):
def get_months_until_stockout_icon(value):
STOCKOUT = 0.0
LOW = 1
ADEQUATE = 3
if float(value) == STOCKOUT:
return '%s <span class="icon-remove" style="color:red"/>' % value
elif float(value) < LOW:
return '%s <span class="icon-warning-sign" style="color:orange"/>' % value
elif float(value) <= ADEQUATE:
return '%s <span class="icon-ok" style="color:green"/>' % value
elif float(value) > ADEQUATE:
return '%s <span class="icon-arrow-up" style="color:purple"/>' % value
state_grouping = {}
if self.config['program'] and not self.config['product']:
product_ids = [product.get_id for product in Product.by_program_id(self.config['domain'],
self.config['program'])]
elif self.config['program'] and self.config['product']:
product_ids = [self.config['product']]
else:
product_ids = Product.ids_by_domain(self.config['domain'])
stock_states = StockState.objects.filter(
case_id__in=get_relevant_supply_point_ids(self.config['domain'], self.sublocations[0]),
section_id=STOCK_SECTION_TYPE,
product_id__in=product_ids
).order_by('-last_modified_date')
for state in stock_states:
days = (datetime.now() - state.last_modified_date).days
monthly_consumption = int(state.get_monthly_consumption()) if state.get_monthly_consumption() else 0
if state.product_id not in state_grouping:
state_grouping[state.product_id] = {
'commodity': Product.get(state.product_id).name,
'months_until_stockout': "%.2f" % (days / 30.0) if state.stock_on_hand else '',
'months_until_stockout_helper': state.stock_on_hand != 0,
'stockout_duration': timesince(state.last_modified_date) if state.stock_on_hand == 0 else '',
'stockout_duration_helper': state.stock_on_hand == 0,
'current_stock': state.stock_on_hand,
'monthly_consumption': monthly_consumption,
'reorder_level': int(monthly_consumption * REORDER_LEVEL),
'maximum_level': int(monthly_consumption * MAXIMUM_LEVEL),
'date_of_last_report': state.last_modified_date.strftime("%Y-%m-%d")
}
else:
if not state_grouping[state.product_id]['months_until_stockout_helper']:
if state.stock_on_hand:
state_grouping[state.product_id]['months_until_stockout'] = "%.2f" % (days / 30.0)
else:
state_grouping[state.product_id]['stockout_duration_helper'] = False
if state_grouping[state.product_id]['stockout_duration_helper']:
if not state.stock_on_hand:
state_grouping[state.product_id]['stockout_duration'] = timesince(state.last_modified_date)
else:
state_grouping[state.product_id]['stockout_duration_helper'] = False
for values in state_grouping.values():
yield {
'commodity': values['commodity'],
'current_stock': int(values['current_stock']),
'monthly_consumption': values['monthly_consumption'] if values['monthly_consumption'] != 0.00
else 'not enough data',
'months_until_stockout': get_months_until_stockout_icon(values['months_until_stockout']
if values['months_until_stockout']
else 0.0),
'stockout_duration': values['stockout_duration'],
'date_of_last_report': values['date_of_last_report'],
'reorder_level': values['reorder_level'] if values['reorder_level'] != 0.00
else 'unknown',
'maximum_level': values['maximum_level'] if values['maximum_level'] != 0.00
else 'unknown'}
def total(self):
return len(Product.by_program_id(self.domain, self.program_id))
def product_ids_filtered_by_program(domain, program):
products = Product.by_program_id(domain, program, False)
return [p['_id'] for p in products]
