def test_move_nonexistent_destination(self): moz, dsa = [uuid.uuid4().hex for i in range(2)] try: Toggle(slug=moz, enabled_users=['claire']).save() move_toggles(moz, dsa) dsa_toggle = Toggle.get(dsa) self.assertEqual(['claire'], dsa_toggle.enabled_users) with self.assertRaises(ResourceNotFound): Toggle.get(moz) finally: MigrationHelperTest._delete_toggles(moz, dsa)
def _migrate_linked_apps_toggle(apps, schema_editor): try: linked_apps_toggle = Toggle.get('linked_apps') except ResourceNotFound: pass else: try: Toggle.get(LINKED_DOMAINS.slug) except ResourceNotFound: linked_domains_toggle = Toggle( slug=LINKED_DOMAINS.slug, enabled_users=linked_apps_toggle.enabled_users) linked_domains_toggle.save()
def _migrate_linked_apps_toggle(apps, schema_editor): try: linked_apps_toggle = Toggle.get('linked_apps') except ResourceNotFound: pass else: try: Toggle.get(LINKED_DOMAINS.slug) except ResourceNotFound: linked_domains_toggle = Toggle( slug=LINKED_DOMAINS.slug, enabled_users=linked_apps_toggle.enabled_users ) linked_domains_toggle.save()
def handle(self, *args, **options): dry_run = options.get('dry_run', False) if dry_run: print("\n-------- DRY RUN --------\n") slug = CALLCENTER.slug try: toggle = Toggle.get(slug) except ResourceNotFound: toggle = Toggle(slug=slug) print("Current domains in toggle: {}".format(toggle.enabled_users)) domains = get_call_center_domains() print("Active call center domains: {}".format(domains)) items = [ namespaced_item(domain, NAMESPACE_DOMAIN) for domain in domains ] missing = set(items) - set(toggle.enabled_users) print("Domains missing from toggle: {}".format(missing)) toggle.enabled_users = items if not dry_run: toggle.save() for item in items: update_toggle_cache(slug, item, True)
def get_toggle(self): if not self.toggle_slug in [t.slug for t in self.all_toggles()]: raise Http404() try: return Toggle.get(self.toggle_slug) except ResourceNotFound: return Toggle(slug=self.toggle_slug)
def get_toggle(self): if not self.static_toggle: raise Http404() try: return Toggle.get(self.toggle_slug) except ResourceNotFound: return Toggle(slug=self.toggle_slug)
def get_toggle(self, slug): if slug not in [f.slug for f, _ in self.features()]: raise Http404() try: return Toggle.get(slug) except ResourceNotFound: return Toggle(slug=slug)
def get_toggle(self): if not self.toggle_slug in [t.slug for t in self.all_toggles()]: raise Http404() try: return Toggle.get(generate_toggle_id(self.toggle_slug)) except ResourceNotFound: return Toggle(slug=self.toggle_slug)
def _get_toggles_to_migrate(self): from corehq.toggles import all_toggles, NAMESPACE_DOMAIN from toggle.models import Toggle from toggle.shortcuts import namespaced_item all_user_ids = self._user_ids_in_domain() toggles_to_migrate = [] domain_item = namespaced_item(self.domain, NAMESPACE_DOMAIN) for toggle in all_toggles() + all_previews(): try: current_toggle = Toggle.get(toggle.slug) except ResourceNotFound: continue enabled_for = set(current_toggle.enabled_users) new_toggle = Toggle(slug=toggle.slug, enabled_users=[]) if domain_item in enabled_for: new_toggle.enabled_users.append(domain_item) enabled_users = enabled_for & all_user_ids new_toggle.enabled_users.extend(list(enabled_users)) if new_toggle.enabled_users: toggles_to_migrate.append(new_toggle.to_json()) return toggles_to_migrate
def page_context(self): toggles = list(all_toggles()) domain_counts = {} user_counts = {} if self.show_usage: for t in toggles: counter = Counter() try: usage = Toggle.get(t.slug) except ResourceNotFound: domain_counts[t.slug] = 0 user_counts[t.slug] = 0 else: for u in usage.enabled_users: namespace = u.split(":", 1)[0] if u.find(":") != -1 else NAMESPACE_USER counter[namespace] += 1 domain_counts[t.slug] = counter.get(NAMESPACE_DOMAIN, 0) user_counts[t.slug] = counter.get(NAMESPACE_USER, 0) return { 'domain_counts': domain_counts, 'page_url': self.page_url, 'show_usage': self.show_usage, 'toggles': toggles, 'tags': ALL_TAGS, 'user_counts': user_counts, }
def test_load_toggles(self): from toggle.models import Toggle mocked_toggles, expected_items = self._get_mocked_toggles() dumped_data = [ json.dumps(Toggle(slug=slug, enabled_users=items).to_json()) for slug, items in expected_items.items() ] existing_toggle_docs = [] for toggle in mocked_toggles.values(): doc_dict = toggle.to_json() expected = expected_items[toggle.slug] # leave only items that aren't in the dump doc_dict['enabled_users'] = [ item for item in doc_dict['enabled_users'] if item not in expected ] existing_toggle_docs.append(doc_dict) with mock_out_couch(docs=existing_toggle_docs): ToggleLoader().load_objects(dumped_data) for mocked_toggle in mocked_toggles.values(): loaded_toggle = Toggle.get(mocked_toggle.slug) self.assertItemsEqual(mocked_toggle.enabled_users, loaded_toggle.enabled_users)
def _get_toggles_to_migrate(domain): from corehq.toggles import all_toggles, NAMESPACE_DOMAIN from toggle.models import Toggle from toggle.shortcuts import namespaced_item domain_item = namespaced_item(domain, NAMESPACE_DOMAIN) usernames = set(get_all_usernames_by_domain(domain)) for toggle in all_toggles() + all_previews(): try: current_toggle = Toggle.get(toggle.slug) except ResourceNotFound: continue enabled_for = set(current_toggle.enabled_users) new_toggle = Toggle(slug=toggle.slug, enabled_users=[]) if domain_item in enabled_for: new_toggle.enabled_users.append(domain_item) enabled_users = enabled_for & usernames new_toggle.enabled_users.extend(list(enabled_users)) if new_toggle.enabled_users: yield new_toggle.to_json()
def handle(self, *args, **options): dry_run = options.get('dry_run', False) if dry_run: print("\n-------- DRY RUN --------\n") slug = CALLCENTER.slug try: toggle = Toggle.get(slug) except ResourceNotFound: toggle = Toggle(slug=slug) print("Current domains in toggle: {}".format(toggle.enabled_users)) domains = get_call_center_domains() print("Active call center domains: {}".format(domains)) items = [namespaced_item(domain, NAMESPACE_DOMAIN) for domain in domains] missing = set(items) - set(toggle.enabled_users) print("Domains missing from toggle: {}".format(missing)) toggle.enabled_users = items if not dry_run: toggle.save() for item in items: update_toggle_cache(slug, item, True)
def load_objects(self, object_strings, force=False, dry_run=False): from toggle.models import Toggle count = 0 for toggle_json in object_strings: if dry_run: count += 1 continue toggle_dict = json.loads(toggle_json) slug = toggle_dict['slug'] try: existing_toggle = Toggle.get(slug) except ResourceNotFound: Toggle.wrap(toggle_dict).save() else: existing_items = set(existing_toggle.enabled_users) items_to_load = set(toggle_dict['enabled_users']) enabled_for = existing_items | items_to_load existing_toggle.enabled_users = list(enabled_for) existing_toggle.save() count += 1 self.stdout.write('Loaded {} Toggles'.format(count)) return Counter({'Toggle': count})
def test_move(self): moz, dsa = [uuid.uuid4().hex for i in range(2)] try: moz_users = ['marco', 'lauren', 'claire'] dsa_users = ['kieran', 'jolani', 'claire'] Toggle(slug=moz, enabled_users=moz_users).save() Toggle(slug=dsa, enabled_users=dsa_users).save() move_toggles(moz, dsa) # ensure original is delted with self.assertRaises(ResourceNotFound): Toggle.get(moz) dsa_toggle = Toggle.get(dsa) expected_users = set(moz_users) | set(dsa_users) self.assertEqual(len(expected_users), len(dsa_toggle.enabled_users)) self.assertEqual(expected_users, set(dsa_toggle.enabled_users)) finally: MigrationHelperTest._delete_toggles(moz, dsa)
def test_move_nonexistent_source(self): dsa = uuid.uuid4().hex try: Toggle(slug=dsa, enabled_users=['kieran']).save() move_toggles('missing-src', dsa) self.assertEqual(['kieran'], Toggle.get(dsa).enabled_users) finally: MigrationHelperTest._delete_toggles(dsa)
def get_enabled_domains(self): try: toggle = Toggle.get(self.slug) except ResourceNotFound: return [] enabled_users = toggle.enabled_users domains = {user.split('domain:')[1] for user in enabled_users if 'domain:' in user} domains |= self.always_enabled domains -= self.always_disabled return list(domains)
def move_toggles(from_toggle_id, to_toggle_id): """ Moves all enabled items from one toggle to another. """ try: from_toggle = Toggle.get(from_toggle_id) except ResourceNotFound: # if no source found this is a noop return try: to_toggle = Toggle.get(to_toggle_id) except ResourceNotFound: to_toggle = Toggle(slug=to_toggle_id, enabled_users=[]) for item in from_toggle.enabled_users: if item not in to_toggle.enabled_users: to_toggle.enabled_users.append(item) update_toggle_cache(to_toggle_id, item, True) to_toggle.save() from_toggle.delete()
def randomness(self): # a bit hacky: leverage couch's dynamic properties to just tack this onto the couch toggle doc try: toggle = Toggle.get(self.slug) except ResourceNotFound: return self.default_randomness dynamic_randomness = getattr(toggle, self.RANDOMNESS_KEY, self.default_randomness) try: dynamic_randomness = float(dynamic_randomness) return dynamic_randomness except ValueError: return self.default_randomness
def update_toggle(self): """ This turns on the special stock handler when EWS is enabled. """ toggle = Toggle.get(STOCK_AND_RECEIPT_SMS_HANDLER.slug) toggle_user_key = namespaced_item(self.domain, NAMESPACE_DOMAIN) if self.enabled and toggle_user_key not in toggle.enabled_users: toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache( STOCK_AND_RECEIPT_SMS_HANDLER.slug, toggle_user_key, True )
def enable_vellum_beta(request): slug = "vellum_beta" try: toggle = Toggle.get(slug) except ResourceNotFound: toggle = Toggle(slug=slug) changed_entries = [] if request.user.username not in toggle.enabled_users: changed_entries.append(request.user.username) toggle.enabled_users.append(request.user.username) toggle.save() _call_save_fn_and_clear_cache(slug, changed_entries, toggle.enabled_users, _find_static_toggle(slug)) return HttpResponse(json.dumps({'success': True}), content_type="application/json")
def all_enabled(cls): """ Yields settings of all domains for which "enabled" is true """ try: toggle = Toggle.get("dhis2_domain") except ResourceNotFound: return for domain in toggle.enabled_users: if domain.startswith("domain:"): # If the "domain" namespace is given, strip it off domain = domain.split(":")[1] settings = cls.for_domain(domain) if settings and settings.is_enabled(): yield settings
def handle(self, *args, **options): domains = Domain.get_all() for domain in domains: if domain.commtrack_enabled: toggle = Toggle.get(LOCATIONS.slug) toggle_user_key = namespaced_item(domain.name, NAMESPACE_DOMAIN) if toggle_user_key not in toggle.enabled_users: toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache(LOCATIONS.slug, toggle_user_key, True) if not domain.locations_enabled: domain.locations_enabled = True domain.save()
def toggle_app_manager_v2(request): slug = "app_manager_v2" on_or_off = request.POST.get('on_or_off', 'on') try: toggle = Toggle.get(slug) except ResourceNotFound: toggle = Toggle(slug=slug) enable = on_or_off == "on" enabled = request.user.username in toggle.enabled_users if enable != enabled: changed_entries = [request.user.username] if enable: toggle.enabled_users.append(request.user.username) else: toggle.enabled_users.remove(request.user.username) toggle.save() _call_save_fn_and_clear_cache(slug, changed_entries, toggle.enabled_users, _find_static_toggle(slug)) return HttpResponse(json.dumps({'success': True}), content_type="application/json")
def toggle_app_manager_v2(request): slug = "app_manager_v2" on_or_off = request.POST.get('on_or_off', 'on') try: toggle = Toggle.get(slug) except ResourceNotFound: toggle = Toggle(slug=slug) enable = on_or_off == "on" enabled = request.user.username in toggle.enabled_users if enable != enabled: changed_entries = [request.user.username] if enable: toggle.enabled_users.append(request.user.username) else: toggle.enabled_users.remove(request.user.username) toggle.save() _call_save_fn_and_clear_cache(slug, changed_entries, toggle.enabled_users, find_static_toggle(slug)) return HttpResponse(json.dumps({'success': True}), content_type="application/json")
def load_objects(self, object_strings, force=False): from toggle.models import Toggle count = 0 for toggle_json in object_strings: toggle_dict = json.loads(toggle_json) slug = toggle_dict['slug'] try: existing_toggle = Toggle.get(slug) except ResourceNotFound: Toggle.wrap(toggle_dict).save() else: existing_items = set(existing_toggle.enabled_users) items_to_load = set(toggle_dict['enabled_users']) enabled_for = existing_items | items_to_load existing_toggle.enabled_users = list(enabled_for) existing_toggle.save() count += 1 self.stdout.write('Loaded {} Toggles'.format(count)) return count, Counter({'Toggle': count})
def page_context(self): toggles = list(all_toggles()) domain_counts = {} active_domain_count = {} user_counts = {} last_used = {} last_modified = {} if self.show_usage: for t in toggles: counter = Counter() try: usage = Toggle.get(t.slug) except ResourceNotFound: domain_counts[t.slug] = 0 user_counts[t.slug] = 0 active_domain_count[t.slug] = 0 else: for u in usage.enabled_users: namespace = u.split( ":", 1)[0] if u.find(":") != -1 else NAMESPACE_USER counter[namespace] += 1 usage_info = _get_usage_info(usage) domain_counts[t.slug] = counter.get(NAMESPACE_DOMAIN, 0) active_domain_count[t.slug] = usage_info["_active_domains"] user_counts[t.slug] = counter.get(NAMESPACE_USER, 0) last_used[t.slug] = usage_info["_latest"] last_modified[t.slug] = usage.last_modified return { 'domain_counts': domain_counts, 'active_domain_count': active_domain_count, 'page_url': self.page_url, 'show_usage': self.show_usage, 'toggles': toggles, 'tags': ALL_TAGS, 'user_counts': user_counts, 'last_used': last_used, 'last_modified': last_modified, }
def handle(self, **options): domains = Toggle.get('mobile_ucr').enabled_users domains = [re.sub(r'^domain:', '', d) for d in domains] for domain in domains: apps = get_apps_in_domain(domain, include_remote=False) for app in apps: dirty = False for module in app.modules: if module.doc_type == 'ReportModule': for config in module.report_configs: if len(config.complete_graph_configs): logger.info( "Already migrated module {} in app {} in domain {}" .format(module.id, app.id, domain)) else: logger.info( "Migrating module {} in app {} in domain {}" .format(module.id, app.id, domain)) config.migrate_graph_configs(domain) dirty = True if dirty: app.save() logger.info('Done with migrate_report_app_configs')
def test_load_toggles(self): from toggle.models import Toggle mocked_toggles, expected_items = self._get_mocked_toggles() dumped_data = [ json.dumps(Toggle(slug=slug, enabled_users=items).to_json()) for slug, items in expected_items.items() ] existing_toggle_docs = [] for toggle in mocked_toggles.values(): doc_dict = toggle.to_json() expected = expected_items[toggle.slug] # leave only items that aren't in the dump doc_dict['enabled_users'] = [item for item in doc_dict['enabled_users'] if item not in expected] existing_toggle_docs.append(doc_dict) with mock_out_couch(docs=existing_toggle_docs): ToggleLoader().load_objects(dumped_data) for mocked_toggle in mocked_toggles.values(): loaded_toggle = Toggle.get(mocked_toggle.slug) self.assertItemsEqual(mocked_toggle.enabled_users, loaded_toggle.enabled_users)
def page_context(self): toggles = list(all_toggles()) domain_counts = {} active_domain_count = {} user_counts = {} last_used = {} last_modified = {} if self.show_usage: for t in toggles: counter = Counter() try: usage = Toggle.get(t.slug) except ResourceNotFound: domain_counts[t.slug] = 0 user_counts[t.slug] = 0 active_domain_count[t.slug] = 0 else: for u in usage.enabled_users: namespace = u.split(":", 1)[0] if u.find(":") != -1 else NAMESPACE_USER counter[namespace] += 1 usage_info = _get_usage_info(usage) domain_counts[t.slug] = counter.get(NAMESPACE_DOMAIN, 0) active_domain_count[t.slug] = usage_info["_active_domains"] user_counts[t.slug] = counter.get(NAMESPACE_USER, 0) last_used[t.slug] = usage_info["_latest"] last_modified[t.slug] = usage.last_modified return { 'domain_counts': domain_counts, 'active_domain_count': active_domain_count, 'page_url': self.page_url, 'show_usage': self.show_usage, 'toggles': toggles, 'tags': ALL_TAGS, 'user_counts': user_counts, 'last_used': last_used, 'last_modified': last_modified, }
def request_new_domain(request, form, org, domain_type=None, new_user=True): now = datetime.utcnow() current_user = CouchUser.from_django_user(request.user) commtrack_enabled = domain_type == 'commtrack' dom_req = RegistrationRequest() if new_user: dom_req.request_time = now dom_req.request_ip = get_ip(request) dom_req.activation_guid = uuid.uuid1().hex new_domain = Domain( name=form.cleaned_data['domain_name'], is_active=False, date_created=datetime.utcnow(), commtrack_enabled=commtrack_enabled, locations_enabled=commtrack_enabled, creating_user=current_user.username, secure_submissions=True, ) if commtrack_enabled: toggle_user_key = namespaced_item(new_domain.name, NAMESPACE_DOMAIN) # enable commtrack toggle toggle = Toggle.get(COMMTRACK.slug) toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache(COMMTRACK.slug, toggle_user_key, True) # enable location toggle toggle = Toggle.get(LOCATIONS.slug) toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache(LOCATIONS.slug, toggle_user_key, True) if form.cleaned_data.get('domain_timezone'): new_domain.default_timezone = form.cleaned_data['domain_timezone'] if org: new_domain.organization = org new_domain.hr_name = request.POST.get('domain_hrname', None) or new_domain.name if not new_user: new_domain.is_active = True # ensure no duplicate domain documents get created on cloudant new_domain.save(**get_safe_write_kwargs()) if not new_domain.name: new_domain.name = new_domain._id new_domain.save() # we need to get the name from the _id create_30_day_trial(new_domain) dom_req.domain = new_domain.name if request.user.is_authenticated(): if not current_user: current_user = WebUser() current_user.sync_from_django_user(request.user) current_user.save() current_user.add_domain_membership(new_domain.name, is_admin=True) current_user.save() dom_req.requesting_user_username = request.user.username dom_req.new_user_username = request.user.username if new_user: dom_req.save() send_domain_registration_email(request.user.email, dom_req.domain, dom_req.activation_guid) else: send_global_domain_registration_email(request.user, new_domain.name) send_new_request_update_email(request.user, get_ip(request), new_domain.name, is_new_user=new_user)
def tearDownClass(cls): Toggle.get(ICDS_UCR_ELASTICSEARCH_DOC_LOADING.slug).delete() super(TestFormsExpressionSpecWithFilterEsVersion, cls).tearDownClass()
def _delete_toggles(self, *toggles): for toggle in toggles: try: Toggle.get(toggle).delete() except ResourceNotFound: pass
def find_domains_with_flat_fixture_enabled(): toggle = Toggle.get(FLAT_LOCATION_FIXTURE.slug) enabled_users = toggle.enabled_users return [user.split('domain:')[1] for user in enabled_users if 'domain:' in user]
def domain(self): # Currently its only possible for one domain to have access to the ICDS dashboard per env return Toggle.get( 'dashboard_icds_reports').enabled_users[0][len('domain:'):]