def test_update(self):
self.client.login(username=self.username, password=self.password)
user = WebUser.create(domain=self.domain.name, username="******", password="******")
user_json = {
"email":"*****@*****.**",
"first_name":"Joe",
"is_admin": True,
"last_name":"Admin",
"permissions":{
"edit_apps":True,
"edit_commcare_users":True,
"edit_data":True,
"edit_web_users":True,
"view_reports":True
},
"phone_numbers":[
],
"role":"admin"
}
backend_id = user._id
response = self.client.put(self.single_endpoint(backend_id),
simplejson.dumps(user_json),
content_type='application/json')
self.assertEqual(response.status_code, 204, response.content)
modified = WebUser.get(backend_id)
self.assertEqual(modified.username, "test")
self.assertEqual(modified.first_name, "Joe")
self.assertEqual(modified.last_name, "Admin")
self.assertEqual(modified.email, "*****@*****.**")
modified.delete()
def handle(self, *args, **options):
from corehq.apps.users.models import WebUser
if len(args) != 3:
raise CommandError('Usage: manage.py bootstrap <domain> <email> <password>')
domain_name, username, passwd = args
domain = Domain.get_or_create_with_name(domain_name, is_active=True)
couch_user = WebUser.get_by_username(username)
membership = None
if couch_user:
if not isinstance(couch_user, WebUser):
raise CommandError('Username already in use by a non-web user')
membership = couch_user.get_domain_membership(domain_name)
else:
couch_user = WebUser.create(domain_name, username, passwd)
if not membership:
couch_user.add_domain_membership(domain_name, is_admin=True)
couch_user.is_superuser = True
couch_user.is_staff = True
couch_user.save()
print "user %s created and added to domain %s" % (couch_user.username, domain)
if not getattr(settings, 'BASE_ADDRESS', None):
print ("Warning: You must set BASE_ADDRESS setting "
"in your localsettings.py file in order for commcare-hq "
"to be able to generate absolute urls. "
"This is necessary for a number of features.")
def obj_get_list(self, bundle, **kwargs):
domain = kwargs['domain']
username = bundle.request.GET.get('username')
if username:
user = WebUser.get_by_username(username)
return [user] if user else []
return list(WebUser.by_domain(domain))
def _delete_web_user_membership(domain_name):
from corehq.apps.users.models import WebUser
active_web_users = WebUser.by_domain(domain_name)
inactive_web_users = WebUser.by_domain(domain_name, is_active=False)
for web_user in list(active_web_users) + list(inactive_web_users):
web_user.delete_domain_membership(domain_name)
web_user.save()
def handle(self, username, **options):
from corehq.apps.users.models import WebUser
try:
validate_email(username)
except EmailSyntaxError:
raise CommandError('Your username must be an email address')
couch_user = WebUser.get_by_username(username)
if couch_user:
if not isinstance(couch_user, WebUser):
raise CommandError('Username already in use by a non-web user')
print("✓ User {} exists".format(couch_user.username))
else:
password = self.get_password_from_user()
couch_user = WebUser.create(None, username, password)
print("→ User {} created".format(couch_user.username))
is_superuser_changed = not couch_user.is_superuser
is_staff_changed = not couch_user.is_staff
couch_user.is_superuser = True
couch_user.is_staff = True
if is_superuser_changed or is_staff_changed:
couch_user.save()
if is_superuser_changed:
print("→ User {} is now a superuser".format(couch_user.username))
else:
print("✓ User {} is a superuser".format(couch_user.username))
if is_staff_changed:
print("→ User {} can now access django admin".format(couch_user.username))
else:
print("✓ User {} can access django admin".format(couch_user.username))
def sync_ilsgateway_webuser(domain, ilsgateway_webuser):
user = WebUser.get_by_username(ilsgateway_webuser.email.lower())
user_dict = {
'first_name': ilsgateway_webuser.first_name,
'last_name': ilsgateway_webuser.last_name,
'is_staff': ilsgateway_webuser.is_staff,
'is_active': ilsgateway_webuser.is_active,
'is_superuser': ilsgateway_webuser.is_superuser,
'last_login': force_to_datetime(ilsgateway_webuser.last_login),
'date_joined': force_to_datetime(ilsgateway_webuser.date_joined),
'password_hashed': True,
}
sp = SupplyPointCase.view('hqcase/by_domain_external_id',
key=[domain, str(ilsgateway_webuser.location)],
reduce=False,
include_docs=True,
limit=1).first()
role_id = ilsgateway_webuser.role_id if hasattr(ilsgateway_webuser, 'role_id') else None
location_id = sp.location_id if sp else None
if user is None:
try:
user = WebUser.create(domain=None, username=ilsgateway_webuser.email.lower(),
password=ilsgateway_webuser.password, email=ilsgateway_webuser.email, **user_dict)
user.add_domain_membership(domain, role_id=role_id, location_id=location_id)
user.save()
except Exception as e:
logging.error(e)
else:
if domain not in user.get_domains():
user.add_domain_membership(domain, role_id=role_id, location_id=location_id)
user.save()
return user
def orgs_team_members(request, org, team_id, template="orgs/orgs_team_members.html"):
#organization and teams
organization = Organization.get_by_name(org)
teams = Team.get_by_org(org)
current_domains = Domain.get_by_organization(org)
#check that the team exists
team = Team.get(team_id)
if team is None:
raise Http404("Group %s does not exist" % team_id)
#inspect the members of the team
member_ids = team.get_member_ids()
members = WebUser.view("_all_docs", keys=member_ids, include_docs=True).all()
members.sort(key=lambda user: user.username)
#inspect the domains of the team
domain_names = team.get_domains()
domains = list()
for name in domain_names:
domains.append([Domain.get_by_name(name), team.role_label(domain=name)])
all_org_domains = Domain.get_by_organization(org)
non_domains = [domain for domain in all_org_domains if domain.name not in domain_names]
all_org_member_ids = organization.members
all_org_members = WebUser.view("_all_docs", keys=all_org_member_ids, include_docs=True).all()
non_members = [member for member in all_org_members if member.user_id not in member_ids]
vals = dict(org=organization, team=team, teams=teams, members=members, nonmembers=non_members, domains=current_domains, team_domains=domains, team_nondomains=non_domains)
return render_to_response(request, template, vals)
def setUpClass(cls):
super(GetRestoreUserTest, cls).setUpClass()
cls.project = Domain(name=cls.domain)
cls.project.save()
cls.other_project = Domain(name=cls.other_domain)
cls.other_project.save()
cls.web_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.commcare_user = CommCareUser.create(
username=format_username('jane', cls.domain),
domain=cls.domain,
password='******',
)
cls.other_commcare_user = CommCareUser.create(
username=format_username('john', cls.domain),
domain=cls.domain,
password='******',
)
cls.super_user = WebUser.create(
username='******',
domain=cls.other_domain,
password='******',
)
cls.super_user.is_superuser = True
cls.super_user.save()
def make_web_user(cls, email, domain=None):
domain = domain or cls.domain
domains = [domain]
user = WebUser(username=email, domains=domains)
user.domain_memberships = [DomainMembership(domain=cls.domain)]
UserESFake.save_doc(user._doc)
return user
def web_user_sync(self, ews_webuser):
username = ews_webuser.email.lower()
if not username:
try:
validate_email(ews_webuser.username)
username = ews_webuser.username
except ValidationError:
return None
user = WebUser.get_by_username(username)
user_dict = {
'first_name': ews_webuser.first_name,
'last_name': ews_webuser.last_name,
'is_active': ews_webuser.is_active,
'last_login': force_to_datetime(ews_webuser.last_login),
'date_joined': force_to_datetime(ews_webuser.date_joined),
'password_hashed': True,
}
location_id = None
if ews_webuser.location:
try:
location = SQLLocation.objects.get(domain=self.domain, external_id=ews_webuser.location)
location_id = location.location_id
except SQLLocation.DoesNotExist:
pass
if user is None:
try:
user = WebUser.create(domain=None, username=username,
password=ews_webuser.password, email=ews_webuser.email,
**user_dict)
user.add_domain_membership(self.domain, location_id=location_id)
except Exception as e:
logging.error(e)
else:
if self.domain not in user.get_domains():
user.add_domain_membership(self.domain, location_id=location_id)
ews_webuser_extension(user, ews_webuser)
dm = user.get_domain_membership(self.domain)
if dm.location_id != location_id:
dm.location_id = location_id
if ews_webuser.is_superuser:
dm.role_id = UserRole.by_domain_and_name(self.domain, 'Administrator')[0].get_id
elif ews_webuser.groups and ews_webuser.groups[0].name == 'facility_manager':
dm.role_id = UserRole.by_domain_and_name(self.domain, 'Facility manager')[0].get_id
else:
if ews_webuser.supply_point:
supply_point = get_supply_point_case_by_domain_external_id(self.domain, ews_webuser.supply_point)
if supply_point:
dm.location_id = supply_point.location_id
dm.role_id = UserRole.by_domain_and_name(self.domain, 'Web Reporter')[0].get_id
else:
dm.role_id = UserRole.get_read_only_role_by_domain(self.domain).get_id
else:
dm.role_id = UserRole.get_read_only_role_by_domain(self.domain).get_id
user.save()
return user
def make_web_user(cls, email, domain=None):
domain = domain or cls.domain
domains = [domain]
user = WebUser(username=email, domains=domains)
user.domain_memberships = [DomainMembership(domain=domain)]
doc = user._doc
doc['username.exact'] = doc['username']
doc['base_username'] = email
UserESFake.save_doc(doc)
return user
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,
creating_user=current_user.username,
secure_submissions=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 arbitrary_web_user(save=True, is_dimagi=False):
domain = data_gen.arbitrary_unique_name().lower()[:25]
username = "******" % (data_gen.arbitrary_username(), 'dimagi' if is_dimagi else 'gmail')
try:
web_user = WebUser.create(domain, username, 'test123')
except Exception:
web_user = WebUser.get_by_username(username)
web_user.is_active = True
if save:
web_user.save()
return web_user
def setUpClass(cls):
cls.domain = 'my-test-views'
cls.username = '******'
cls.regular_name = 'ron'
cls.password = '******'
cls.user = WebUser.create(cls.domain, cls.username, cls.password, is_active=True)
cls.user.is_superuser = True
cls.user.save()
cls.mobile_worker = CommCareUser.create('potter', '*****@*****.**', '123')
cls.regular = WebUser.create(cls.domain, cls.regular_name, cls.password, is_active=True)
def test_create_facility_manager(self):
with open(os.path.join(self.datapath, 'sample_webusers.json')) as f:
webuser = EWSUser(json.loads(f.read())[1])
self.assertEqual(0, len(WebUser.by_domain(TEST_DOMAIN)))
self.api_object.web_user_sync(webuser)
web_users = list(WebUser.by_domain(TEST_DOMAIN))
self.assertEqual(1, len(web_users))
self.assertEqual(0, len(CommCareUser.by_domain(TEST_DOMAIN)))
facility_manager_role = UserRole.by_domain_and_name(TEST_DOMAIN, 'Facility manager')[0]
dm = web_users[0].get_domain_membership(TEST_DOMAIN)
self.assertEqual(facility_manager_role.get_id, dm.role_id)
def arbitrary_web_user(save=True, is_dimagi=False):
domain = Domain(name=unique_name()[:25])
domain.save()
username = "******" % (unique_name(), "dimagi" if is_dimagi else "gmail")
try:
web_user = WebUser.create(domain.name, username, "test123")
except Exception:
web_user = WebUser.get_by_username(username)
web_user.is_active = True
if save:
web_user.save()
return web_user
def web_user_sync(self, ilsgateway_webuser):
username = ilsgateway_webuser.email.lower()
if not username:
try:
validate_email(ilsgateway_webuser.username)
username = ilsgateway_webuser.username
except ValidationError:
return None
user = WebUser.get_by_username(username)
user_dict = {
'first_name': ilsgateway_webuser.first_name,
'last_name': ilsgateway_webuser.last_name,
'is_active': ilsgateway_webuser.is_active,
# I don't know why sample_webusers.json has these in a number o
# different formats, w/ and w/o 'T', with timezone offset, etc
# I do not know how timezones are meant to be handled, so I am
# conservatively keeping the behavior the same by explicitly
# stripping the timezone with no conversion
# todo: this is almost certainly not what was intended
'last_login': force_to_datetime(ilsgateway_webuser.last_login).replace(tzinfo=None),
'date_joined': force_to_datetime(ilsgateway_webuser.date_joined).replace(tzinfo=None),
'password_hashed': True,
}
location_id = None
if ilsgateway_webuser.location:
try:
sql_location = SQLLocation.objects.get(domain=self.domain, external_id=ilsgateway_webuser.location)
location_id = sql_location.location_id
except SQLLocation.DoesNotExist:
location_id = None
if user is None:
try:
user = WebUser.create(domain=None, username=username,
password=ilsgateway_webuser.password, email=ilsgateway_webuser.email.lower(),
**user_dict)
user.add_domain_membership(self.domain, location_id=location_id)
user.save()
except Exception as e:
if settings.UNIT_TESTING:
raise
logging.error(e)
else:
if self.domain not in user.get_domains():
user.add_domain_membership(self.domain, location_id=location_id)
user.save()
else:
dm = user.get_domain_membership(self.domain)
if dm.location_id != location_id:
dm.location_id = location_id
user.save()
return user
def web_user_sync(self, ilsgateway_webuser):
email = ilsgateway_webuser.email.lower()
if not email:
try:
validate_email(ilsgateway_webuser.username)
email = ilsgateway_webuser.username
except ValidationError:
return None
user = WebUser.get_by_username(email)
user_dict = {
'first_name': ilsgateway_webuser.first_name,
'last_name': ilsgateway_webuser.last_name,
'is_active': ilsgateway_webuser.is_active,
'password_hashed': True,
}
location_id = None
if ilsgateway_webuser.location:
try:
sql_location = SQLLocation.objects.get(domain=self.domain, external_id=ilsgateway_webuser.location)
location_id = sql_location.location_id
except SQLLocation.DoesNotExist:
location_id = None
if user is None:
try:
ils_sql_web_user = ILSGatewayWebUser.objects.get(external_id=ilsgateway_webuser.id)
except ILSGatewayWebUser.DoesNotExist:
ils_sql_web_user = None
if ils_sql_web_user:
# if user exists in db it means he was already migrated but he changed email in v1
old_email = ils_sql_web_user.email
user = WebUser.get_by_username(old_email)
if user:
user.delete_domain_membership(self.domain)
user.save()
user = self._create_web_user(email, ilsgateway_webuser, location_id, user_dict)
ils_sql_web_user.email = email
ils_sql_web_user.save()
return user
else:
user = self._create_web_user(email, ilsgateway_webuser, location_id, user_dict)
else:
self._edit_web_user(user, location_id)
ilsgateway_webuser, _ = ILSGatewayWebUser.objects.get_or_create(
external_id=ilsgateway_webuser.id,
)
ilsgateway_webuser.email = email
ilsgateway_webuser.save()
return user
def setUpClass(cls):
super(RestorePermissionsTest, cls).setUpClass()
cls.other_project = Domain(name=cls.other_domain)
cls.other_project.save()
cls.web_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.super_user = WebUser.create(
username='******',
domain=cls.other_domain,
password='******',
)
cls.super_user.is_superuser = True
cls.super_user.save()
cls.commcare_user = CommCareUser.create(
username=format_username('super', cls.domain),
domain=cls.domain,
password='******',
)
cls.no_edit_commcare_user = CommCareUser.create(
username=format_username('noedit', cls.domain),
domain=cls.domain,
password='******',
)
cls.location_user = CommCareUser.create(
username=format_username('location', cls.domain),
domain=cls.domain,
password='******',
)
cls.wrong_location_user = CommCareUser.create(
username=format_username('wrong-location', cls.domain),
domain=cls.domain,
password='******',
)
cls.web_location_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.commcare_user.set_location(cls.locations['usa'])
cls.web_location_user.set_location(cls.domain, cls.locations['usa'])
cls.no_edit_commcare_user.set_location(cls.locations['usa'])
cls.location_user.set_location(cls.locations['ma'])
cls.wrong_location_user.set_location(cls.locations['montreal'])
cls.restrict_user_to_assigned_locations(cls.commcare_user)
cls.restrict_user_to_assigned_locations(cls.web_location_user)
def test_basic_workflow(self):
"""
This should execute a basic transferring of domains. user will transfer a
domain to muggle. user should be able to see status of transferred domain
and muggle will accept transfer request.
"""
# Get the transfer request page
resp = self.client.get(reverse(TransferDomainView.urlname, args=[self.domain.name]))
self.assertEqual(resp.status_code, 200)
self.assertEqual(type(resp.context['form']), TransferDomainForm,
"Should get TransferRequestForm")
form = resp.context['form']
form.data['domain'] = self.domain.name
form.data['to_username'] = self.muggle.username
# Post the form data
resp = self.client.post(reverse(TransferDomainView.urlname, args=[self.domain.name]),
form.data, follow=True)
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(mail.outbox), 2,
"Should send an email to both requester and requestee")
transfer = TransferDomainRequest.objects.get(to_username=self.muggle.username,
from_username=self.user.username,
domain=self.domain.name)
self.assertIsNotNone(transfer)
self.assertIsNone(transfer.confirm_time)
self.assertTrue(transfer.active)
# Land on the activate transfer page
self.client.login(username=self.muggle.username, password=self.password)
resp = self.client.get(reverse('activate_transfer_domain', args=[transfer.transfer_guid]), follow=True)
self.assertEqual(resp.status_code, 200)
self.assertIsNotNone(resp.context['transfer'])
# Finally accept the transfer
mail.outbox = [] # Clear outbox
resp = self.client.post(reverse('activate_transfer_domain', args=[transfer.transfer_guid]), follow=True)
self.assertEqual(len(mail.outbox), 1, "Send an email to Dimagi to confirm")
# Reload from DB
user = WebUser.get_by_username(self.user.username)
muggle = WebUser.get_by_username(self.muggle.username)
transfer = TransferDomainRequest.objects.get(to_username=self.muggle.username,
from_username=self.user.username,
domain=self.domain.name)
self.assertFalse(user.is_member_of(self.domain.name))
self.assertTrue(muggle.is_member_of(self.domain.name))
self.assertTrue(muggle.get_domain_membership(self.domain.name).is_admin)
self.assertIsNotNone(transfer.confirm_time)
def save(self, request, domain):
try:
if self.can_use_custom_logo:
logo = self.cleaned_data['logo']
if logo:
input_image = Image.open(io.BytesIO(logo.read()))
input_image.load()
input_image.thumbnail(LOGO_SIZE)
# had issues trying to use a BytesIO instead
tmpfilename = "/tmp/%s_%s" % (uuid.uuid4(), logo.name)
input_image.save(tmpfilename, 'PNG')
with open(tmpfilename) as tmpfile:
domain.put_attachment(tmpfile, name=LOGO_ATTACHMENT)
elif self.cleaned_data['delete_logo']:
domain.delete_attachment(LOGO_ATTACHMENT)
domain.call_center_config.enabled = self.cleaned_data.get('call_center_enabled', False)
if domain.call_center_config.enabled:
domain.internal.using_call_center = True
domain.call_center_config.case_owner_id = self.cleaned_data.get('call_center_case_owner', None)
domain.call_center_config.case_type = self.cleaned_data.get('call_center_case_type', None)
global_tz = self.cleaned_data['default_timezone']
if domain.default_timezone != global_tz:
domain.default_timezone = global_tz
users = WebUser.by_domain(domain.name)
users_to_save = []
for user in users:
dm = user.get_domain_membership(domain.name)
if not dm.override_global_tz and dm.timezone != global_tz:
dm.timezone = global_tz
users_to_save.append(user)
if users_to_save:
WebUser.bulk_save(users_to_save)
secure_submissions = self.cleaned_data.get(
'secure_submissions', False)
apps_to_save = []
if secure_submissions != domain.secure_submissions:
for app in get_apps_in_domain(domain.name):
if app.secure_submissions != secure_submissions:
app.secure_submissions = secure_submissions
apps_to_save.append(app)
domain.secure_submissions = secure_submissions
domain.save()
if apps_to_save:
ApplicationBase.bulk_save(apps_to_save)
return True
except Exception:
return False
def setUpClass(cls):
super(AuthenticateAsIntegrationTest, cls).setUpClass()
cls.domain = Domain(name="my-test-views")
cls.domain.save()
cls.username = "******"
cls.regular_name = "ron"
cls.password = "******"
cls.user = WebUser.create(cls.domain.name, cls.username, cls.password, is_active=True)
cls.user.is_superuser = True
cls.user.save()
cls.mobile_worker = CommCareUser.create("potter", "*****@*****.**", "123")
cls.regular = WebUser.create(cls.domain.name, cls.regular_name, cls.password, is_active=True)
def testDomainMemberships(self):
w_username = "******"
w_email = "*****@*****.**"
w2_username = "******"
w2_email = "*****@*****.**"
cc_username = "******"
password = "******"
domain = "test-domain"
# check that memberships are added on creation
webuser = WebUser.create(domain, w_username, password, w_email)
webuser2 = WebUser.create('nodomain', w2_username, password, w2_email)
ccuser = CommCareUser.create(domain, cc_username, password)
self.assertEquals(webuser.is_member_of('test-domain'), True)
self.assertEquals(ccuser.is_member_of('test-domain'), True)
# getting memberships
self.assertEquals(webuser.get_domain_membership(domain).domain, domain)
self.assertEquals(ccuser.get_domain_membership(domain).domain, domain)
permission_to = 'view_reports'
self.assertEquals(webuser.has_permission(domain, permission_to), False)
self.assertEquals(ccuser.has_permission(domain, permission_to), False)
webuser.set_role(domain, "field-implementer")
ccuser.set_role(domain, "field-implementer")
self.assertEquals( webuser.get_domain_membership(domain).role_id,
ccuser.get_domain_membership(domain).role_id)
self.assertEquals(webuser.role_label(), ccuser.role_label())
self.assertEquals(webuser.has_permission(domain, permission_to), True)
self.assertEquals(ccuser.has_permission(domain, permission_to), True)
self.assertEquals(webuser.is_domain_admin(domain), False)
self.assertEquals(ccuser.is_domain_admin(domain), False)
# deleting memberships
webuser.delete_domain_membership(domain)
with self.assertRaises(NotImplementedError):
ccuser.delete_domain_membership(domain)
self.assertEquals(webuser.is_member_of(domain), False)
self.assertEquals(webuser2.is_member_of(domain), False)
self.assertEquals(ccuser.is_member_of(domain), True)
self.assertEquals(ccuser.get_domain_membership(domain).domain, domain)
webuser.add_domain_membership(domain)
webuser.transfer_domain_membership(domain, webuser2)
self.assertEquals(webuser.is_member_of(domain), False)
self.assertEquals(webuser2.is_member_of(domain), True)
def setUpClass(cls):
super(FormEditRestrictionsMixin, cls).setUpClass()
cls.middlesex_web_user = cls.make_web_user('Middlesex')
cls.massachusetts_web_user = cls.make_web_user('Massachusetts')
cambridge_user = cls.make_mobile_user('Cambridge')
cls.cambridge_form = cls.make_form(cambridge_user)
boston_user = cls.make_mobile_user('Boston')
cls.boston_form = cls.make_form(boston_user)
cls.locationless_web_user = WebUser.create(cls.domain, 'joeshmoe', 'password')
cls.project_admin = WebUser.create(cls.domain, 'kennedy', 'password')
def setUpClass(cls):
super(SchedulingRecipientTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.location_types = setup_location_types(cls.domain, ['country', 'state', 'city'])
cls.country_location = make_loc('usa', domain=cls.domain, type='country')
cls.state_location = make_loc('ma', domain=cls.domain, type='state', parent=cls.country_location)
cls.city_location = make_loc('boston', domain=cls.domain, type='city', parent=cls.state_location)
cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc')
cls.mobile_user.set_location(cls.city_location)
cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc')
cls.mobile_user2.set_location(cls.state_location)
cls.mobile_user3 = CommCareUser.create(cls.domain, 'mobile3', 'abc')
cls.mobile_user3.user_data['role'] = 'pharmacist'
cls.mobile_user3.save()
cls.mobile_user4 = CommCareUser.create(cls.domain, 'mobile4', 'abc')
cls.mobile_user4.user_data['role'] = 'nurse'
cls.mobile_user4.save()
cls.mobile_user5 = CommCareUser.create(cls.domain, 'mobile5', 'abc')
cls.mobile_user5.user_data['role'] = ['nurse', 'pharmacist']
cls.mobile_user5.save()
cls.web_user = WebUser.create(cls.domain, 'web', 'abc')
cls.web_user2 = WebUser.create(cls.domain, 'web2', 'abc')
cls.web_user2.user_data['role'] = 'nurse'
cls.web_user2.save()
cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id])
cls.group.save()
cls.group2 = Group(
domain=cls.domain,
users=[
cls.mobile_user.get_id,
cls.mobile_user3.get_id,
cls.mobile_user4.get_id,
cls.mobile_user5.get_id,
]
)
cls.group2.save()
cls.case_group = CommCareCaseGroup(domain=cls.domain)
cls.case_group.save()
def setUp(self):
self.factory = RequestFactory()
domain = Domain.get_or_create_with_name('champ-cameroon')
domain.is_active = True
domain.save()
self.domain = domain
user = WebUser.all().first()
if not user:
user = WebUser.create(domain.name, 'test', 'passwordtest')
user.is_authenticated = True
user.is_superuser = True
user.is_authenticated = True
user.is_active = True
self.user = user
def setUp(self):
self.factory = RequestFactory()
domain = Domain.get_or_create_with_name('test-pna')
domain.is_active = True
domain.save()
self.domain = domain
user = WebUser.get_by_username('test')
if not user:
user = WebUser.create(domain.name, 'test', 'passwordtest')
user.is_authenticated = True
user.is_superuser = True
user.is_authenticated = True
user.is_active = True
self.user = user
def test_edit_webuser_email(self):
with open(os.path.join(self.datapath, 'sample_webusers.json')) as f:
webuser = ILSUser(json.loads(f.read())[0])
self.assertEqual(len(WebUser.by_domain(TEST_DOMAIN)), 0)
ils_webuser = self.api_object.web_user_sync(webuser)
self.assertEqual(len(WebUser.by_domain(TEST_DOMAIN)), 1)
webuser.email = '*****@*****.**'
ils_webuser2 = self.api_object.web_user_sync(webuser)
ils_webuser = WebUser.get(docid=ils_webuser.get_id)
self.assertEqual(len(WebUser.by_domain(TEST_DOMAIN)), 1)
self.assertIsNone(ils_webuser.get_domain_membership(TEST_DOMAIN))
self.assertEqual(ils_webuser2.username, '*****@*****.**')
def setUpClass(cls):
w_username = "******"
w_email = "*****@*****.**"
w2_username = "******"
w2_email = "*****@*****.**"
cc_username = "******"
password = "******"
cls.domain_obj = create_domain(cls.domain)
cls.nodomain_obj = create_domain('nodomain')
cls.project = Domain(name=cls.domain)
cls.project.save()
cls.webuser = WebUser.create(cls.domain, w_username, password, w_email)
cls.webuser2 = WebUser.create('nodomain', w2_username, password, w2_email)
cls.ccuser = CommCareUser.create(cls.domain, cc_username, password)
def web_user_sync(self, ews_webuser):
if not ews_webuser.is_superuser and ews_webuser.groups:
group = ews_webuser.groups[0]
if group.name == 'facility_manager':
return self.convert_web_user_to_sms_user(ews_webuser)
username = ews_webuser.email.lower()
if not username:
try:
validate_email(ews_webuser.username)
username = ews_webuser.username
except ValidationError:
return None
user = WebUser.get_by_username(username)
user_dict = {
'first_name': ews_webuser.first_name,
'last_name': ews_webuser.last_name,
'is_active': ews_webuser.is_active,
'last_login': force_to_datetime(ews_webuser.last_login),
'date_joined': force_to_datetime(ews_webuser.date_joined),
'password_hashed': True,
}
sp = SupplyPointCase.view('hqcase/by_domain_external_id',
key=[self.domain, str(ews_webuser.location)],
reduce=False,
include_docs=True,
limit=1).first()
location_id = sp.location_id if sp else None
if user is None:
try:
user = WebUser.create(domain=None, username=username,
password=ews_webuser.password, email=ews_webuser.email,
**user_dict)
user.add_domain_membership(self.domain, location_id=location_id)
except Exception as e:
logging.error(e)
else:
if self.domain not in user.get_domains():
user.add_domain_membership(self.domain, location_id=location_id)
ews_webuser_extension(user, ews_webuser)
dm = user.get_domain_membership(self.domain)
if ews_webuser.is_superuser:
dm.is_admin = True
else:
dm.role_id = UserRole.get_read_only_role_by_domain(self.domain).get_id
user.save()
return user
def setUpClass(cls):
super(TestBetsUpdates, cls).setUpClass()
cls.domain_obj = Domain(name=cls.domain, is_active=True)
cls.domain_obj.save()
cls.web_user = WebUser.create(cls.domain, 'blah', 'password')
def test_update_domain_date_web_user(self):
self.assertIsNone(self._last_accessed(self.web_user, self.domain.name))
update_domain_date(self.web_user.user_id, self.domain.name)
self.web_user = WebUser.get_by_username(self.web_user.username)
self.assertEqual(self._last_accessed(self.web_user, self.domain.name),
self.today)
def notify_dimagi_project_admins(domain, message):
users = list(WebUser.get_dimagi_emails_by_domain(domain))
# if there isn't a dimagi email in the project, notify admins
notify_admins = len(users) == 0
_assert = soft_assert(users, notify_admins=notify_admins, send_to_ops=False)
_assert(False, message)
def handle(self, username, **options):
print("Deleting user %s" % username)
WebUser.get_by_username(username).delete()
print("Operation completed")
def request_new_domain(request, form, is_new_user=True):
now = datetime.utcnow()
current_user = CouchUser.from_django_user(request.user)
dom_req = RegistrationRequest()
if is_new_user:
dom_req.request_time = now
dom_req.request_ip = get_ip(request)
dom_req.activation_guid = uuid.uuid1().hex
project_name = form.cleaned_data.get('hr_name') or form.cleaned_data.get('project_name')
name = name_to_url(project_name, "project")
with CriticalSection(['request_domain_name_{}'.format(name)]):
name = Domain.generate_name(name)
new_domain = Domain(
name=name,
hr_name=project_name,
is_active=False,
date_created=datetime.utcnow(),
creating_user=current_user.username,
secure_submissions=True,
use_sql_backend=True,
first_domain_for_user=is_new_user
)
if form.cleaned_data.get('domain_timezone'):
new_domain.default_timezone = form.cleaned_data['domain_timezone']
if not is_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
if is_new_user:
# Only new-user domains are eligible for Advanced trial
# domains with no subscription are equivalent to be on free Community plan
create_30_day_advanced_trial(new_domain, current_user.username)
else:
ensure_explicit_community_subscription(new_domain.name, date.today())
UserRole.init_domain_with_presets(new_domain.name)
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 is_new_user:
dom_req.save()
send_domain_registration_email(request.user.email,
dom_req.domain,
dom_req.activation_guid,
request.user.get_full_name())
send_new_request_update_email(request.user, get_ip(request), new_domain.name, is_new_user=is_new_user)
set_toggle(toggles.USE_FORMPLAYER_FRONTEND.slug, new_domain.name, True, namespace=toggles.NAMESPACE_DOMAIN)
meta = get_meta(request)
track_created_new_project_space_on_hubspot.delay(current_user, request.COOKIES, meta)
return new_domain.name
def orgs_landing(request,
org,
template="orgs/orgs_landing.html",
form=None,
add_form=None,
invite_member_form=None,
add_team_form=None,
update_form=None,
tab=None):
organization = request.organization
class LandingNotification(Notification):
doc_type = 'OrgLandingNotification'
def template(self):
return 'orgs/partials/landing_notification.html'
MainNotification.display_if_needed(messages,
request,
ctxt={"org": organization})
LandingNotification.display_if_needed(messages, request)
reg_form_empty = not form
add_form_empty = not add_form
invite_member_form_empty = not invite_member_form
add_team_form_empty = not add_team_form
reg_form = form or DomainRegistrationForm(
initial={'org': organization.name})
add_form = add_form or AddProjectForm(org)
invite_member_form = invite_member_form or InviteMemberForm(org)
add_team_form = add_team_form or AddTeamForm(org)
ctxt = base_context(request, organization, update_form=update_form)
user_domains = []
req_domains = []
# display a notification for each org request that hasn't previously been seen
if request.couch_user.is_org_admin(org):
requests = OrgRequest.get_requests(org)
for req in requests:
if req.seen or req.domain in [d.name for d in ctxt["domains"]]:
continue
messages.info(
request,
render_to_string(
"orgs/partials/org_request_notification.html", {
"requesting_user": WebUser.get(
req.requested_by).username,
"org_req": req,
"org": organization
}),
extra_tags="html")
def format_domains(dom_list, extra=None):
extra = extra or []
dom_list = list(
set(
filter(lambda d: d not in ctxt["domains"] + extra,
dom_list)))
return [Domain.get_by_name(d) for d in dom_list]
# get the existing domains that an org admin would add to the organization
user_domains = request.couch_user.domains or []
user_domains = filter(
lambda x: domain_has_privilege(x, privileges.CROSS_PROJECT_REPORTS
), user_domains)
req_domains = [req.domain for req in requests]
user_domains = format_domains(user_domains)
req_domains = format_domains(req_domains,
[d.name for d in user_domains if d])
filter(
lambda x: domain_has_privilege(x, privileges.CROSS_PROJECT_REPORTS
), req_domains)
ctxt.update(
dict(reg_form=reg_form,
add_form=add_form,
reg_form_empty=reg_form_empty,
add_form_empty=add_form_empty,
invite_member_form=invite_member_form,
invite_member_form_empty=invite_member_form_empty,
add_team_form=add_team_form,
add_team_form_empty=add_team_form_empty,
tab="projects",
user_domains=user_domains,
req_domains=req_domains))
return render(request, template, ctxt)
def test_load_session_data_for_web_user(self):
user = WebUser(username='******', _id=uuid.uuid4().hex)
data = get_user_contributions_to_touchforms_session(user)
self.assertEqual('*****@*****.**', data['username'])
self.assertEqual(user._id, data['user_id'])
self.assertTrue(isinstance(data['user_data'], dict))
def setUpClass(cls):
delete_all_docs_by_doc_type(WebUser.get_db(),
['CommCareUser', 'WebUser'])
super(TestUserStagingTable, cls).setUpClass()
def setUpClass(cls):
super(DropboxUploadHelperTest, cls).setUpClass()
cls.domain = create_domain('adomain')
cls.user = WebUser.create('adomain', 'ben', '***')
def register_fcm_device_token(request, domain, couch_user_id, device_token):
user = WebUser.get_by_user_id(couch_user_id)
user.fcm_device_token = device_token
user.save()
return HttpResponse()
def editable_user(self):
try:
return WebUser.get(self.editable_user_id)
except (ResourceNotFound, CouchUser.AccountTypeError):
raise Http404()
def confirm_domain(request, guid=None):
# Did we get a guid?
vals = {}
if guid is None:
vals['message_title'] = _('Missing Activation Key')
vals['message_subtitle'] = _('Account Activation Failed')
vals['message_body'] = _(
'An account activation key was not provided. If you think this '
'is an error, please contact the system administrator.')
vals['is_error'] = True
return render(request, 'registration/confirmation_complete.html', vals)
# Does guid exist in the system?
req = RegistrationRequest.get_by_guid(guid)
if not req:
vals['message_title'] = _('Invalid Activation Key')
vals['message_subtitle'] = _('Account Activation Failed')
vals['message_body'] = _(
'The account activation key "%s" provided is invalid. If you '
'think this is an error, please contact the system '
'administrator.') % guid
vals['is_error'] = True
return render(request, 'registration/confirmation_complete.html', vals)
requested_domain = Domain.get_by_name(req.domain)
context = get_domain_context(requested_domain.domain_type)
context['requested_domain'] = req.domain
# Has guid already been confirmed?
if requested_domain.is_active:
assert (req.confirm_time is not None and req.confirm_ip is not None)
context['message_title'] = _('Already Activated')
context['message_body'] = _(
'Your account %s has already been activated. No further '
'validation is required.') % req.new_user_username
context['is_error'] = False
return render(request, 'registration/confirmation_complete.html',
context)
# Set confirm time and IP; activate domain and new user who is in the
req.confirm_time = datetime.utcnow()
req.confirm_ip = get_ip(request)
req.save()
requested_domain.is_active = True
requested_domain.save()
requesting_user = WebUser.get_by_username(req.new_user_username)
send_new_request_update_email(requesting_user,
get_ip(request),
requested_domain.name,
is_confirming=True)
context['message_title'] = _('Account Confirmed')
context['message_subtitle'] = _(
'Thank you for activating your account, %s!'
) % requesting_user.first_name
context['message_body'] = _(
'Your account has been successfully activated. Thank you for taking '
'the time to confirm your email address: %s.'
) % requesting_user.username
context['is_error'] = False
return render(request, 'registration/confirmation_complete.html', context)
def update_subscription_properties_by_user(web_user_id, properties):
web_user = WebUser.get_by_user_id(web_user_id)
identify_v2(web_user.username, properties)
update_hubspot_properties_v2(web_user, properties)
def setUpClass(cls):
super().setUpClass()
cls.domain = 'old_shelf'
cls.domain_obj = create_domain(cls.domain)
cls.role = UserRole.create(domain=cls.domain, name='App Editor')
cls.qualified_role_id = cls.role.get_qualified_id()
cls.user1 = WebUser.create(
cls.domain_obj.name,
'*****@*****.**',
'badpassword',
None,
None,
email='*****@*****.**',
first_name='Edith',
last_name='Wharton',
role_id=cls.role.get_id,
)
cls.user2 = WebUser.create(
cls.domain_obj.name,
'*****@*****.**',
'anotherbadpassword',
None,
None,
email='*****@*****.**',
first_name='George',
last_name='Eliot',
is_admin=True,
)
cls.invited_user = Invitation.objects.create(
email='*****@*****.**',
domain=cls.domain_obj.name,
invited_by='*****@*****.**',
invited_on=datetime.utcnow(),
role=cls.qualified_role_id,
)
cls.other_domain = 'new_shelf'
cls.other_domain_obj = create_domain(cls.other_domain)
cls.other_role = UserRole.create(domain=cls.domain, name='User Admin')
cls.user10 = WebUser.create(
cls.other_domain_obj.name,
'*****@*****.**',
'secret',
None,
None,
email='*****@*****.**',
first_name='Susan',
last_name='Choi',
role_id=cls.other_role.get_id,
)
cls.user11 = WebUser.create(
cls.other_domain_obj.name,
'*****@*****.**',
'secret',
None,
None,
email='*****@*****.**',
first_name='Zadie',
last_name='Smith',
role_id=cls.other_role.get_id,
)
cls.other_invited_user = Invitation.objects.create(
email='*****@*****.**',
domain=cls.other_domain_obj.name,
invited_by='*****@*****.**',
invited_on=datetime.utcnow(),
role=cls.other_role.get_qualified_id())
populate_user_index([cls.user1, cls.user2, cls.user10, cls.user11])
def setUp(self):
super(TestRestrictedUserUpload, self).setUp()
self.user = WebUser.create(self.domain, 'username', 'password')
self.user.set_location(self.domain, self.locations['Middlesex'])
restrict_user_by_location(self.domain, self.user)
def admins(self):
return [
admin.email or admin.username
for admin in WebUser.get_admins_by_domain(self.domain)
]
def _setup_web_user(cls):
cls.web_user = WebUser.create(cls.DOMAIN_NAME, cls.WEB_USER, '*****')
cls.web_user.save()
cls.request.couch_user = cls.web_user
def setUpClass(cls):
super(TestSendToHubspot, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.user = WebUser.create(cls.domain, "*****@*****.**", "*****")
cls.user.save()
def request_new_domain(request, form, is_new_user=True):
now = datetime.utcnow()
current_user = CouchUser.from_django_user(request.user, strict=True)
dom_req = RegistrationRequest()
if is_new_user:
dom_req.request_time = now
dom_req.request_ip = get_ip(request)
dom_req.activation_guid = uuid.uuid1().hex
project_name = form.cleaned_data.get('hr_name') or form.cleaned_data.get(
'project_name')
name = name_to_url(project_name, "project")
with CriticalSection(['request_domain_name_{}'.format(name)]):
name = Domain.generate_name(name)
new_domain = Domain(name=name,
hr_name=project_name,
is_active=False,
date_created=datetime.utcnow(),
creating_user=current_user.username,
secure_submissions=True,
use_sql_backend=True,
first_domain_for_user=is_new_user)
# Avoid projects created by dimagi.com staff members as self started
new_domain.internal.self_started = not current_user.is_dimagi
if form.cleaned_data.get('domain_timezone'):
new_domain.default_timezone = form.cleaned_data['domain_timezone']
if not is_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
dom_req.domain = new_domain.name
if not settings.ENTERPRISE_MODE:
_setup_subscription(new_domain.name, current_user)
UserRole.init_domain_with_presets(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 is_new_user:
dom_req.save()
if settings.IS_SAAS_ENVIRONMENT:
# Load template apps to the user's new domain in parallel
from corehq.apps.app_manager.tasks import load_appcues_template_app
header = [
load_appcues_template_app.si(new_domain.name,
current_user.username, slug)
for slug in APPCUES_APP_SLUGS
]
callback = send_domain_registration_email.si(
request.user.email, dom_req.domain, dom_req.activation_guid,
request.user.get_full_name(), request.user.first_name)
chord(header)(callback)
else:
send_domain_registration_email(request.user.email, dom_req.domain,
dom_req.activation_guid,
request.user.get_full_name(),
request.user.first_name)
send_new_request_update_email(request.user,
get_ip(request),
new_domain.name,
is_new_user=is_new_user)
send_hubspot_form(HUBSPOT_CREATED_NEW_PROJECT_SPACE_FORM_ID, request)
return new_domain.name
def normal_user():
user = WebUser.create(DOMAIN_NAME, USERNAME, PASSWORD, None, None)
try:
yield
finally:
user.delete()
def from_user(self):
from corehq.apps.users.models import WebUser
return WebUser.get_by_username(self.from_username)
def setUpClass(cls):
super().setUpClass()
cls.user = WebUser.create(cls.domain, 'fiona', 'secret', None, None)
def confirm_domain(request, guid=None):
error = None
# Did we get a guid?
if guid is None:
error = _(
'An account activation key was not provided. If you think this '
'is an error, please contact the system administrator.')
# Does guid exist in the system?
else:
req = RegistrationRequest.get_by_guid(guid)
if not req:
error = _(
'The account activation key "%s" provided is invalid. If you '
'think this is an error, please contact the system '
'administrator.') % guid
if error is not None:
context = {
'message_body': error,
'current_page': {
'page_name': 'Account Not Activated'
},
}
return render(request, 'registration/confirmation_error.html', context)
requested_domain = Domain.get_by_name(req.domain)
view_name = "dashboard_default"
if not domain_has_apps(req.domain):
view_name = "default_new_app"
# Has guid already been confirmed?
if requested_domain.is_active:
assert (req.confirm_time is not None and req.confirm_ip is not None)
messages.success(
request, 'Your account %s has already been activated. '
'No further validation is required.' % req.new_user_username)
return HttpResponseRedirect(reverse(view_name,
args=[requested_domain]))
# Set confirm time and IP; activate domain and new user who is in the
req.confirm_time = datetime.utcnow()
req.confirm_ip = get_ip(request)
req.save()
requested_domain.is_active = True
requested_domain.save()
requesting_user = WebUser.get_by_username(req.new_user_username)
send_new_request_update_email(requesting_user,
get_ip(request),
requested_domain.name,
is_confirming=True)
messages.success(
request,
'Your account has been successfully activated. Thank you for taking '
'the time to confirm your email address: %s.' %
(requesting_user.username))
track_workflow(requesting_user.email, "Confirmed new project")
track_confirmed_account_on_hubspot.delay(requesting_user)
request.session['CONFIRM'] = True
return HttpResponseRedirect(reverse(view_name, args=[requested_domain]))
def setUpClass(cls):
super(ReportTestCase, cls).setUpClass()
cls.domain = create_domain('test-domain')
cls.web_user = WebUser.get_by_username('test')
if not cls.web_user:
cls.web_user = WebUser.create('test-domain', 'test', 'test', None,
None)
SQLProduct.objects.create(domain=cls.domain.name,
name='Product 2',
code='p2',
product_id='p2')
SQLProduct.objects.create(domain=cls.domain.name,
name='Product 3',
code='p3',
product_id='p3')
SQLProduct.objects.create(domain=cls.domain.name,
name='Product 1',
code='p1',
product_id='p1')
region_location_type = LocationType.objects.create(
domain=cls.domain.name,
name='Region',
)
SQLLocation.objects.create(domain=cls.domain.name,
name='Region 1',
location_id='r1',
location_type=region_location_type)
district_location_type = LocationType.objects.create(
domain=cls.domain.name,
name='District',
)
SQLLocation.objects.create(domain=cls.domain.name,
name='District 1',
location_id='d1',
location_type=district_location_type)
cls.engine = connection_manager.get_engine(DEFAULT_ENGINE_ID)
cls.intra_table = IntraHealthFluff._table
cls.couverture_table = CouvertureFluff._table
cls.taux_table = TauxDeRuptureFluff._table
cls.taux_de_satisfaction_table = TauxDeSatisfactionFluff._table
cls.livraison_table = LivraisonFluff._table
cls.recouvrement_table = RecouvrementFluff._table
with cls.engine.begin() as connection:
cls.couverture_table.create(connection, checkfirst=True)
cls.intra_table.create(connection, checkfirst=True)
cls.taux_table.create(connection, checkfirst=True)
cls.taux_de_satisfaction_table.create(connection, checkfirst=True)
cls.recouvrement_table.create(connection, checkfirst=True)
cls.livraison_table.create(connection, checkfirst=True)
insert = cls.intra_table.insert().values([
dict(doc_id='1',
date=datetime(2017, 11, 17),
product_name='Product 1',
product_id='p1',
district_id='d1',
district_name='District 1',
location_id='pps1',
region_id='r1',
PPS_name='PPS 1',
actual_consumption_total=10,
billed_consumption_total=5,
stock_total=33,
total_stock_total=70,
quantity_total=13,
cmm_total=16),
dict(doc_id='1',
date=datetime(2017, 11, 17),
product_name='Product 2',
product_id='p2',
district_id='d1',
district_name='District 1',
location_id='pps1',
region_id='r1',
PPS_name='PPS 1',
actual_consumption_total=2,
billed_consumption_total=2,
stock_total=1,
total_stock_total=2,
quantity_total=3,
cmm_total=4),
dict(doc_id='1',
date=datetime(2017, 11, 17),
product_name='Product 3',
product_id='p3',
district_id='d1',
district_name='District 1',
location_id='pps1',
region_id='r1',
PPS_name='PPS 1',
actual_consumption_total=6,
billed_consumption_total=4,
stock_total=14,
total_stock_total=0,
quantity_total=88,
cmm_total=99),
dict(doc_id='2',
date=datetime(2017, 11, 17),
product_name='Product 1',
product_id='p1',
district_id='d1',
district_name='District 1',
location_id='pps2',
region_id='r1',
PPS_name='PPS 2',
actual_consumption_total=13,
billed_consumption_total=11,
stock_total=50,
total_stock_total=100,
quantity_total=1,
cmm_total=8),
dict(doc_id='2',
date=datetime(2017, 11, 17),
product_name='Product 2',
product_id='p2',
district_id='d1',
district_name='District 1',
location_id='pps2',
region_id='r1',
PPS_name='PPS 2',
actual_consumption_total=0,
billed_consumption_total=0,
stock_total=2,
total_stock_total=17,
quantity_total=3,
cmm_total=15),
dict(doc_id='2',
date=datetime(2017, 11, 17),
product_name='Product 3',
product_id='p3',
district_id='d1',
district_name='District 1',
location_id='pps2',
region_id='r1',
PPS_name='PPS 2',
actual_consumption_total=150,
billed_consumption_total=11,
stock_total=4,
total_stock_total=0,
quantity_total=11,
cmm_total=12)
])
connection.execute(insert)
def setUpClass(cls):
super(AllCommCareUsersTest, cls).setUpClass()
delete_all_users()
hard_delete_deleted_users()
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
bootstrap_location_types(cls.ccdomain.name)
initialize_domain_with_default_roles(cls.ccdomain.name)
cls.user_roles = UserRole.objects.get_by_domain(cls.ccdomain.name)
cls.custom_role = UserRole.create(cls.ccdomain.name, "Custom Role")
cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district")
cls.loc2 = make_loc('madagascar',
domain=cls.ccdomain.name,
type="district")
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_1.set_location(cls.loc1)
cls.ccuser_1.save()
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_2.set_role(cls.ccdomain.name,
cls.custom_role.get_qualified_id())
cls.ccuser_2.set_location(cls.loc2)
cls.ccuser_2.save()
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.location_restricted_web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.location_restricted_web_user.add_to_assigned_locations(
domain=cls.ccdomain.name, location=cls.loc2)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.retired_user = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.retired_user.retire(cls.ccdomain.name, deleted_by=None)
cls.ccuser_inactive = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_inactive.is_active = False
cls.ccuser_inactive.save()
cls.ccuser_inactive.set_location(cls.loc2)
def setUp(self):
super(TestBulkManagementWithInitialLocs, self).setUp()
self.user = WebUser.create(self.domain, 'username', 'password')
def setUpClass(cls):
super(AllCommCareUsersTest, cls).setUpClass()
delete_all_users()
hard_delete_deleted_users()
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
bootstrap_location_types(cls.ccdomain.name)
UserRole.init_domain_with_presets(cls.ccdomain.name)
cls.user_roles = UserRole.by_domain(cls.ccdomain.name)
cls.custom_role = UserRole.get_or_create_with_permissions(
cls.ccdomain.name,
Permissions(
edit_apps=True,
edit_web_users=True,
view_web_users=True,
view_roles=True,
), "Custom Role")
cls.custom_role.save()
cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district")
cls.loc2 = make_loc('madagascar',
domain=cls.ccdomain.name,
type="district")
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_1.set_location(cls.loc1)
cls.ccuser_1.save()
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_2.set_role(cls.ccdomain.name,
cls.custom_role.get_qualified_id())
cls.ccuser_2.set_location(cls.loc2)
cls.ccuser_2.save()
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user.retire()
def setUp(self):
super(TestTreeValidator, self).setUp()
self.domain_obj = create_domain(self.domain)
self.user = WebUser.create(self.domain, 'username', 'password')
def setUp(self):
super(WebUserLocationAssignmentTest, self).setUp()
self.user = WebUser.create(domain=self.domain,
username='******',
password='******',
last_login=datetime.now())
def setup_webuser(cls, username, domain, role):
user = WebUser.create(domain.name, username, '{}-password'.format(username))
user.set_role(domain.name, role)
user.save()
return user
