def commtrack_settings(self): # this import causes some dependency issues so lives in here from corehq.apps.commtrack.models import SQLCommtrackConfig if self.commtrack_enabled: return SQLCommtrackConfig.for_domain(self.name) else: return None
def setUp(self): super(XMLTest, self).setUp() self.domain = util.bootstrap_domain(util.TEST_DOMAIN) util.bootstrap_location_types(self.domain.name) util.bootstrap_products(self.domain.name) self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id) self.ct_settings = SQLCommtrackConfig.for_domain(self.domain.name) self.ct_settings.sqlconsumptionconfig = SQLConsumptionConfig( min_transactions=0, min_window=0, optimal_window=60, ) self.ct_settings.save() self.ct_settings.sqlconsumptionconfig.commtrack_settings = self.ct_settings self.ct_settings.sqlconsumptionconfig.save() self.domain = Domain.get(self.domain._id) self.loc = make_loc('loc1') self.sp = self.loc.linked_supply_point() self.users = [ util.bootstrap_user(self, **user_def) for user_def in self.user_definitions ] self.user = self.users[0]
def stock_level_config_for_domain(domain, commtrack_enabled): if not commtrack_enabled: return None from corehq.apps.commtrack.models import SQLCommtrackConfig ct_config = SQLCommtrackConfig.for_domain(domain) if ct_config is None or not hasattr(ct_config, 'sqlstocklevelsconfig'): return None else: return ct_config.sqlstocklevelsconfig
def should_exclude_invalid_periods(domain): """ Whether the domain's consumption calculation should exclude invalid periods i.e. periods where the stock went up without a receipt being reported """ from corehq.apps.commtrack.models import SQLCommtrackConfig if domain: config = SQLCommtrackConfig.for_domain(domain) if config and hasattr(config, 'sqlconsumptionconfig'): return config.sqlconsumptionconfig.exclude_invalid_periods return False
def process_change(self, change): ledger = change.get_document() from corehq.apps.commtrack.models import SQLCommtrackConfig commtrack_config = SQLCommtrackConfig.for_domain(ledger['domain']) if commtrack_config and commtrack_config.use_auto_consumption: daily_consumption = _get_daily_consumption_for_ledger(ledger) ledger['daily_consumption'] = daily_consumption if not ledger.get('location_id') and ledger.get('case_id'): ledger['location_id'] = _location_id_for_case(ledger['case_id']) _update_ledger_section_entry_combinations(ledger)
def test_report_with_exclude_disabled(self): commtrack_config = SQLCommtrackConfig(domain=self.domain.name) commtrack_config.sqlconsumptionconfig = SQLConsumptionConfig() commtrack_config.save( sync_to_couch=False) # don't bother syncing in tests commtrack_config.sqlconsumptionconfig.commtrack_config = commtrack_config commtrack_config.sqlconsumptionconfig.save() self.create_transactions(self.domain.name) self.assertEqual(StockTransaction.objects.all().count(), 3) self.assertEqual( StockTransaction.objects.filter(type='receipts').count(), 1) commtrack_config.delete()
def _create_commtrack_config_if_needed(domain): if SQLCommtrackConfig.for_domain(domain): return config = SQLCommtrackConfig(domain=domain) config.save( sync_to_couch=False) # must be saved before submodels can be saved SQLAlertConfig(commtrack_config=config).save() SQLConsumptionConfig(commtrack_config=config).save() SQLStockLevelsConfig(commtrack_config=config).save() SQLStockRestoreConfig(commtrack_config=config).save() config.set_actions([ SQLActionConfig( action='receipts', keyword='r', caption='Received', ), SQLActionConfig( action='consumption', keyword='c', caption='Consumed', ), SQLActionConfig( action='consumption', subaction='loss', keyword='l', caption='Losses', ), SQLActionConfig( action='stockonhand', keyword='soh', caption='Stock on hand', ), SQLActionConfig( action='stockout', keyword='so', caption='Stock-out', ), ]) config.save() # save actions, and sync couch
def all_sms_codes(domain): config = SQLCommtrackConfig.for_domain(domain) actions = {action.keyword: action for action in config.all_actions} products = { p.code: p for p in SQLProduct.active_objects.filter(domain=domain) } ret = {} for action_key, action in actions.items(): ret[action_key] = ('action', action) for product_key, product in products.items(): ret[product_key] = ('product', product) return ret
def send_confirmation(v, data): C = SQLCommtrackConfig.for_domain(v.domain) static_loc = data['location'] location_name = static_loc.name metadata = MessageMetadata(location_id=static_loc.get_id) tx_by_action = map_reduce(lambda tx: [(tx.action_config(C).name,)], data=data['transactions'], include_docs=True) def summarize_action(action, txs): return '%s %s' % (txs[0].action_config(C).keyword.upper(), ' '.join(sorted(tx.fragment() for tx in txs))) msg = 'received stock report for %s(%s) %s' % ( static_loc.site_code, truncate(location_name, 20), ' '.join(sorted(summarize_action(a, txs) for a, txs in tx_by_action.items())) ) send_sms_to_verified_number(v, msg, metadata=metadata)
def setUpClass(cls): super(StockStateTest, cls).setUpClass() cls.domain_obj = util.bootstrap_domain(cls.domain) util.bootstrap_location_types(cls.domain) util.bootstrap_products(cls.domain) cls.ct_settings = SQLCommtrackConfig.for_domain(cls.domain) cls.ct_settings.use_auto_consumption = True cls.ct_settings.sqlconsumptionconfig = SQLConsumptionConfig( min_transactions=0, min_window=0, optimal_window=60, ) cls.ct_settings.save() cls.ct_settings.sqlconsumptionconfig.commtrack_settings = cls.ct_settings cls.ct_settings.sqlconsumptionconfig.save() cls.loc = util.make_loc('loc1', domain=cls.domain) cls.sp = cls.loc.linked_supply_point() cls.products = sorted(Product.by_domain(cls.domain), key=lambda p: p._id) cls.process_ledger_changes = process_pillow_changes( 'LedgerToElasticsearchPillow')
def testOTASettings(self): ct_settings = SQLCommtrackConfig.for_domain(self.domain) ct_settings.sqlconsumptionconfig = SQLConsumptionConfig( min_transactions=10, min_window=20, optimal_window=60, ) ct_settings.sqlstockrestoreconfig = SQLStockRestoreConfig( section_to_consumption_types={'stock': 'consumption'}, ) set_default_monthly_consumption_for_domain(self.domain, 5 * DAYS_IN_MONTH) restore_settings = ct_settings.get_ota_restore_settings() self.assertEqual(1, len(restore_settings.section_to_consumption_types)) self.assertEqual( 'consumption', restore_settings.section_to_consumption_types['stock']) self.assertEqual(10, restore_settings.consumption_config.min_periods) self.assertEqual(20, restore_settings.consumption_config.min_window) self.assertEqual(60, restore_settings.consumption_config.max_window) self.assertEqual( 150, restore_settings.consumption_config. default_monthly_consumption_function('foo', 'bar')) self.assertFalse( restore_settings.force_consumption_case_filter( CommCareCase(type='force-type'))) self.assertEqual(0, len(restore_settings.default_product_list)) ct_settings.sqlstockrestoreconfig.force_consumption_case_types = [ 'force-type' ] ct_settings.sqlstockrestoreconfig.use_dynamic_product_list = True restore_settings = ct_settings.get_ota_restore_settings() self.assertTrue( restore_settings.force_consumption_case_filter( CommCareCase(type='force-type'))) self.assertEqual(3, len(restore_settings.default_product_list))
def _create_unsynced_sql(self): """ Create a SQLCommtrackConfig matching the one created by _create_unsynced_couch """ sqlalertconfig = SQLAlertConfig( stock_out_facilities=True, stock_out_commodities=True, stock_out_rates=True, non_report=True, ) sqlstockrestoreconfig = SQLStockRestoreConfig( section_to_consumption_types={'s1': 'c1'}, force_consumption_case_types=['type1'], use_dynamic_product_list=True, ) sqlconsumptionconfig = SQLConsumptionConfig( min_transactions=1, min_window=2, optimal_window=3, use_supply_point_type_default_consumption=True, exclude_invalid_periods=False, ) sqlstocklevelsconfig = SQLStockLevelsConfig( emergency_level=0.5, understock_threshold=1.5, overstock_threshold=3, ) sql = SQLCommtrackConfig( domain='my_project', use_auto_emergency_levels=False, sync_consumption_fixtures=False, use_auto_consumption=False, individual_consumption_defaults=True, sqlalertconfig=sqlalertconfig, sqlstockrestoreconfig=sqlstockrestoreconfig, sqlconsumptionconfig=sqlconsumptionconfig, sqlstocklevelsconfig=sqlstocklevelsconfig, ) sql.save(sync_to_couch=False) # save so that set_actions works sql.set_actions([ SQLActionConfig( action='receipts', subaction='sub-receipts', _keyword='one', caption='first action', ), SQLActionConfig( action='receipts', subaction='sub-receipts', _keyword='two', caption='second action', ), ]) sql.save(sync_to_couch=False) # save actions # Save submodels sqlstockrestoreconfig.commtrack_config = sql sqlstockrestoreconfig.save() sqlalertconfig.commtrack_config = sql sqlalertconfig.save() sqlconsumptionconfig.commtrack_config = sql sqlconsumptionconfig.save() sqlstocklevelsconfig.commtrack_config = sql sqlstocklevelsconfig.save() return sql
def test_delete_commtrack_config(self): SQLCommtrackConfig.for_domain(self.domain.name) or SQLCommtrackConfig( domain=self.domain.name).save() self.assertIsNotNone(SQLCommtrackConfig.for_domain(self.domain.name)) self.domain.delete() self.assertIsNone(SQLCommtrackConfig.for_domain(self.domain.name))
def test_make_domain_commtrack(self): domain_obj = create_domain("test-make-domain-commtrack") make_domain_commtrack(domain_obj) self.assertTrue(domain_obj.commtrack_enabled) self.assertTrue(domain_obj.locations_enabled) config = SQLCommtrackConfig.for_domain(domain_obj.name) self.assertEqual( config.to_json(), { 'domain': 'test-make-domain-commtrack', 'actions': [{ 'action': 'receipts', 'subaction': None, '_keyword': 'r', 'caption': 'Received', }, { 'action': 'consumption', 'subaction': None, '_keyword': 'c', 'caption': 'Consumed', }, { 'action': 'consumption', 'subaction': 'loss', '_keyword': 'l', 'caption': 'Losses', }, { 'action': 'stockonhand', 'subaction': None, '_keyword': 'soh', 'caption': 'Stock on hand', }, { 'action': 'stockout', 'subaction': None, '_keyword': 'so', 'caption': 'Stock-out', }], 'use_auto_emergency_levels': False, 'sync_consumption_fixtures': False, 'use_auto_consumption': False, 'individual_consumption_defaults': False, 'alert_config': { 'stock_out_facilities': False, 'stock_out_commodities': False, 'stock_out_rates': False, 'non_report': False, }, 'consumption_config': { 'min_transactions': 2, 'min_window': 10, 'optimal_window': None, 'use_supply_point_type_default_consumption': False, 'exclude_invalid_periods': False, }, 'ota_restore_config': { 'section_to_consumption_types': {}, 'force_consumption_case_types': [], 'use_dynamic_product_list': False, }, 'stock_levels_config': { 'emergency_level': 0.5, 'understock_threshold': 1.5, 'overstock_threshold': 3, } }) doc = CommtrackConfig.get_db().get(config.couch_id) self.assertIsNone(Command.get_diff_as_string(doc, config)) config.delete() domain_obj.delete()
def test_delete_commtrack_config(self): # Config will have been created by convert_to_commtrack in setUp self.assertIsNotNone(SQLCommtrackConfig.for_domain(self.domain.name)) self.domain.delete() self.assertIsNone(SQLCommtrackConfig.for_domain(self.domain.name))
def config(self): return SQLCommtrackConfig.for_domain(self.domain)