def setUpClass(cls):
super(TestFormsExpressionSpecWithFilterEsVersion, cls).setUpClass()
# enable toggle to 100%
db_toggle = Toggle(slug=ICDS_UCR_ELASTICSEARCH_DOC_LOADING.slug)
setattr(db_toggle, DynamicallyPredictablyRandomToggle.RANDOMNESS_KEY, 1)
db_toggle.save()
assert ICDS_UCR_ELASTICSEARCH_DOC_LOADING.enabled(uuid.uuid4().hex, NAMESPACE_OTHER)
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 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 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 _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 _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 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 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_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 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 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 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 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 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):
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 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 _get_mocked_toggles(self):
from toggle.models import generate_toggle_id
from toggle.models import Toggle
from toggle.shortcuts import namespaced_item
mocked_toggles = {
toggle.slug: Toggle(_id=generate_toggle_id(toggle.slug),
slug=toggle.slug)
for toggle in random.sample(all_toggles(), 3)
}
toggles = mocked_toggles.values()
domain_item = namespaced_item(self.domain_name, NAMESPACE_DOMAIN)
toggles[0].enabled_users = [domain_item]
toggles[1].enabled_users = ['user1', 'other-user', 'user2']
toggles[2].enabled_users = [
'user1', domain_item,
namespaced_item('other_domain', NAMESPACE_DOMAIN)
]
expected_items = {
toggles[0].slug: [domain_item],
toggles[1].slug: ['user1', 'user2'],
toggles[2].slug: ['user1', domain_item],
}
return mocked_toggles, expected_items
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 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(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 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 _set_use_livequery(apps, schema_editor):
toggle_id = generate_toggle_id('livequery_sync')
try:
toggle_doc = Toggle.get_db().get(toggle_id)
except ResourceNotFound:
# Flag isn't enabled for anyone on this server
return
for user in toggle_doc.get('enabled_users', []):
domain_obj = Domain.get_by_name(user.split('domain:')[1])
if domain_obj and not domain_obj.use_livequery:
domain_obj.use_livequery = True
domain_obj.save()
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 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 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 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 _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 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 _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 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 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 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:'):]
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 _delete_toggles(self, *toggles):
for toggle in toggles:
try:
Toggle.get(toggle).delete()
except ResourceNotFound:
pass
