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 _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 _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)
if settings.UNIT_TESTING and not web_user.domain_memberships:
web_user.delete(deleted_by=None)
else:
web_user.save()
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 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 handle(self, *args, **options):
users = CommCareUser.by_domain('icds-cas')
web_users = WebUser.by_domain('icds-cas')
users = users + web_users
user_details = self._get_details(users)
usernames_list = list(user_details.keys())
chunk_size = 100
headers = ["username", "last_access_time", "created_on", "role"]
rows = [headers]
usernames_usage = set()
for user_chunk in chunked(usernames_list, chunk_size):
usage_data = ICDSAuditEntryRecord.objects.filter(
username__in=list(user_chunk)).values('username').annotate(
time=Max('time_of_use'))
for usage in usage_data:
row_data = [
usage['username'],
self.convert_to_ist(usage['time']),
self.convert_to_ist(user_details[usage['username']][0]),
user_details[usage['username']][1]
]
usernames_usage.add(usage['username'])
rows.append(row_data)
users_not_logged_in = set(usernames_list) - usernames_usage
for user in users_not_logged_in:
rows.extend([
user, 'N/A',
self.convert_to_ist(user_details[usage['username']][0]),
user_details[usage['username']][1]
])
fout = open('/home/cchq/National_users_usage_data.csv', 'w')
writer = csv.writer(fout)
writer.writerows(rows)
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 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)
global_tz = self.cleaned_data['default_timezone']
domain.default_timezone = global_tz
users = WebUser.by_domain(domain.name)
for user in users:
dm = user.get_domain_membership(domain.name)
if not dm.override_global_tz:
dm.timezone = global_tz
user.save()
domain.save()
return True
except Exception:
return False
def invite_web_user(request, domain, template="users/invite_web_user.html"):
role_choices = UserRole.role_choices(domain)
if request.method == "POST":
current_users = [user.username for user in WebUser.by_domain(domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(domain)]
form = AdminInvitesUserForm(request.POST,
excluded_emails= current_users + pending_invites,
role_choices=role_choices
)
if form.is_valid():
data = form.cleaned_data
# create invitation record
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = domain
invite = DomainInvitation(**data)
invite.save()
invite.send_activation_email()
messages.success(request, "Invitation sent to %s" % invite.email)
return HttpResponseRedirect(reverse("web_users", args=[domain]))
else:
form = AdminInvitesUserForm(role_choices=role_choices)
context = _users_context(request, domain)
context.update(
registration_form=form
)
return render(request, template, context)
def test_migration(self):
bootstrap_domain(ILSGatewayAPI(TEST_DOMAIN, MockEndpoint('http://test-api.com/', 'dummy', 'dummy')))
self.assertEqual(6, len(list(Product.by_domain(TEST_DOMAIN))))
self.assertEqual(5, len(list(Location.by_domain(TEST_DOMAIN))))
self.assertEqual(6, len(list(CommCareUser.by_domain(TEST_DOMAIN))))
self.assertEqual(5, len(list(WebUser.by_domain(TEST_DOMAIN))))
self.assertEqual(ILSMigrationStats.objects.filter(domain=TEST_DOMAIN).count(), 1)
def main_context(self):
try:
facilities = Location.filter_by_type_count(self.domain, 'FACILITY')
except TypeError:
facilities = 0
contacts = CommCareUser.by_domain(self.domain, reduce=True)
web_users = WebUser.by_domain(self.domain, reduce=True)
try:
products = len(Product.by_domain(self.domain))
except ResourceNotFound:
products = 0
main_context = super(GlobalStats, self).main_context
context = {
'supply_points': len(list(Location.by_domain(self.domain))),
'facilities': facilities,
'contacts': contacts[0]['value'] if contacts else 0,
'web_users': web_users[0]['value'] if web_users else 0,
'products': products,
#TODO add next after the enlargement ILS migration
'product_stocks': 0,
'stock_transactions': 0,
'inbound_messages': 0,
'outbound_messages': 0
}
main_context.update(context)
return main_context
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)
global_tz = self.cleaned_data['default_timezone']
domain.default_timezone = global_tz
users = WebUser.by_domain(domain.name)
for user in users:
dm = user.get_domain_membership(domain.name)
if not dm.override_global_tz:
dm.timezone = global_tz
user.save()
domain.save()
return True
except Exception:
return False
def invite_web_user(request, domain, template="users/invite_web_user.html"):
role_choices = UserRole.role_choices(domain)
if request.method == "POST":
current_users = [user.username for user in WebUser.by_domain(domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(domain)]
form = AdminInvitesUserForm(request.POST,
excluded_emails= current_users + pending_invites,
role_choices=role_choices
)
if form.is_valid():
data = form.cleaned_data
# create invitation record
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = domain
invite = DomainInvitation(**data)
invite.save()
invite.send_activation_email()
messages.success(request, "Invitation sent to %s" % invite.email)
return HttpResponseRedirect(reverse("web_users", args=[domain]))
else:
form = AdminInvitesUserForm(role_choices=role_choices)
context = _users_context(request, domain)
context.update(
registration_form=form
)
return render(request, template, context)
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 main_context(self):
try:
facilities = Location.filter_by_type_count(self.domain, 'FACILITY')
except TypeError:
facilities = 0
contacts = CommCareUser.by_domain(self.domain, reduce=True)
web_users = WebUser.by_domain(self.domain, reduce=True)
try:
products = len(Product.by_domain(self.domain))
except ResourceNotFound:
products = 0
main_context = super(GlobalStats, self).main_context
context = {
'supply_points': len(list(Location.by_domain(self.domain))),
'facilities': facilities,
'contacts': contacts[0]['value'] if contacts else 0,
'web_users': web_users[0]['value'] if web_users else 0,
'products': products,
#TODO add next after the enlargement ILS migration
'product_stocks': 0,
'stock_transactions': 0,
'inbound_messages': 0,
'outbound_messages': 0
}
main_context.update(context)
return main_context
def audit_logs(request, domain):
from auditcare.models import NavigationEventAudit
usernames = [user.username for user in WebUser.by_domain(domain)]
data = {}
for username in usernames:
data[username] = []
for doc in (
get_db()
.view(
"auditcare/urlpath_by_user_date",
startkey=[username],
endkey=[username, {}],
include_docs=True,
wrapper=lambda r: r["doc"],
)
.all()
):
try:
(d,) = re.search(r"^/a/([\w\-_\.]+)/", doc["request_path"]).groups()
if d == domain:
data[username].append(doc)
except Exception:
pass
return json_response(data)
def invite_web_user_form(self):
role_choices = _get_editable_role_choices(self.domain,
self.request.couch_user,
allow_admin_role=True)
loc = None
domain_request = DomainRequest.objects.get(
id=self.request_id) if self.request_id else None
initial = {
'email': domain_request.email if domain_request else None,
}
if 'location_id' in self.request.GET:
from corehq.apps.locations.models import SQLLocation
loc = SQLLocation.objects.get(
location_id=self.request.GET.get('location_id'))
if self.request.method == 'POST':
current_users = [
user.username for user in WebUser.by_domain(self.domain)
]
pending_invites = [
di.email for di in SQLInvitation.by_domain(self.domain)
]
return AdminInvitesUserForm(self.request.POST,
excluded_emails=current_users +
pending_invites,
role_choices=role_choices,
domain=self.domain)
return AdminInvitesUserForm(initial=initial,
role_choices=role_choices,
domain=self.domain,
location=loc)
def balance_email_reports(self):
EWSMigrationProblem.objects.filter(domain=self.domain).delete()
reports = set()
reports_count = 0
for web_user in WebUser.by_domain(self.domain):
notifications = ReportNotification.by_domain_and_owner(self.domain, web_user.get_id)
for notification in notifications:
config_id = notification.config_ids[0] if notification.config_ids else None
if not config_id:
continue
config = ReportConfig.get(config_id)
location_id = config.filters.get('location_id')
if not location_id:
# report is not migrated from ews
continue
reports_count += 1
report_slug = config.report_slug
code = SQLLocation.objects.get(location_id=location_id).site_code
report_tuple = (
web_user.username, notification.day, notification.hour,
code, report_slug, notification.interval
)
external_id = '{}-{}-{}-{}-{}-{}'.format(*report_tuple)
if not notification.send_to_owner and not notification.recipient_emails:
migration_problem, _ = EWSMigrationProblem.objects.get_or_create(
domain=self.domain,
object_id=web_user.username,
object_type='email_report_send_to_owner',
external_id=external_id
)
migration_problem.description = 'send_to_owner not set to true'
migration_problem.save()
reports.add(report_tuple)
total_count = 0
for report in self.endpoint.get_daily_reports(limit=1000)[1]:
if self._check_report(report, reports, 1, 'daily'):
total_count += 1
for report in self.endpoint.get_weekly_reports(limit=1000)[1]:
if self._check_report(report, reports, report.day_of_week, 'weekly'):
total_count += 1
for report in self.endpoint.get_monthly_reports(limit=1000)[1]:
if self._check_report(report, reports, report.day_of_month, 'monthly'):
total_count += 1
if total_count != reports_count:
migration_problem, _ = EWSMigrationProblem.objects.get_or_create(
domain=self.domain,
object_id=None,
object_type='email_report',
external_id='email-report-count'
)
migration_problem.description = '{} / {}'.format(reports_count, total_count)
migration_problem.save()
def set_send_to_owner_field_task(domain):
for web_user in WebUser.by_domain(domain):
notifications = ReportNotification.by_domain_and_owner(domain, web_user.get_id)
for notification in notifications:
if not notification.send_to_owner and not notification.recipient_emails:
notification.send_to_owner = True
notification.save()
balance_migration_task.delay(domain)
def test_migration(self):
ils_bootstrap_domain_test_task(
TEST_DOMAIN, MockEndpoint('http://test-api.com/', 'dummy',
'dummy'))
self.assertEqual(6, len(list(Product.by_domain(TEST_DOMAIN))))
self.assertEqual(5, len(list(Location.by_domain(TEST_DOMAIN))))
self.assertEqual(6, len(list(CommCareUser.by_domain(TEST_DOMAIN))))
self.assertEqual(5, len(list(WebUser.by_domain(TEST_DOMAIN))))
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)))
ewsghana_webuser = 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)
location = SQLLocation.objects.get(external_id=1, domain=TEST_DOMAIN)
self.assertEqual(
ewsghana_webuser.get_domain_membership(TEST_DOMAIN).location_id,
location.location_id)
def setUp(self):
self.endpoint = MockEndpoint('http://test-api.com/', 'dummy', 'dummy')
self.api_object = ILSGatewayAPI(TEST_DOMAIN, self.endpoint)
self.datapath = os.path.join(os.path.dirname(__file__), 'data')
initial_bootstrap(TEST_DOMAIN)
for user in WebUser.by_domain(TEST_DOMAIN):
user.delete()
def setUp(self):
self.endpoint = MockEndpoint('http://test-api.com/', 'dummy', 'dummy')
self.api_object = ILSGatewayAPI(TEST_DOMAIN, self.endpoint)
self.datapath = os.path.join(os.path.dirname(__file__), 'data')
initial_bootstrap(TEST_DOMAIN)
for user in WebUser.by_domain(TEST_DOMAIN):
user.delete()
def tearDownClass(cls):
cls.sms_backend_mapping.delete()
cls.sms_backend.delete()
for user in WebUser.by_domain(TEST_DOMAIN):
user.delete()
for vn in VerifiedNumber.by_domain(TEST_DOMAIN):
vn.delete()
def _users_context(request, domain):
couch_user = request.couch_user
web_users = WebUser.by_domain(domain)
for user in [couch_user] + list(web_users):
user.current_domain = domain
return {"web_users": web_users, "domain": domain, "couch_user": couch_user}
def billing_admins_response(self):
all_web_users = WebUser.by_domain(domain=self.request.domain)
admins = filter(lambda x: x.is_domain_admin and x.username != self.request.couch_user.username,
all_web_users)
admins = filter(lambda x: x.username not in self.existing, admins)
if self.search_string:
admins = filter(lambda x: (x.username.lower().startswith(self.search_string.lower())
or self.search_string in x.full_name), admins)
return [(a.username, "%s (%s)" % (a.full_name, a.username)) for a in admins]
def billing_admins_response(self):
all_web_users = WebUser.by_domain(domain=self.request.domain)
admins = filter(lambda x: x.is_domain_admin and x.username != self.request.couch_user.username,
all_web_users)
admins = filter(lambda x: x.username not in self.existing, admins)
if self.search_string:
admins = filter(lambda x: (x.username.lower().startswith(self.search_string.lower())
or self.search_string in x.full_name), admins)
return [(a.username, "%s (%s)" % (a.full_name, a.username)) for a in admins]
def setUp(self):
self.endpoint = MockEndpoint('http://test-api.com/', 'dummy', 'dummy')
self.api_object = EWSApi(TEST_DOMAIN, self.endpoint)
self.datapath = os.path.join(os.path.dirname(__file__), 'data')
initial_bootstrap(TEST_DOMAIN)
self.api_object.prepare_commtrack_config()
self.api_object.create_or_edit_roles()
for user in WebUser.by_domain(TEST_DOMAIN):
user.delete()
def tearDown(self):
delete_all_locations()
for user in WebUser.by_domain(self.TEST_DOMAIN):
user.delete()
delete_domain_phone_numbers(self.TEST_DOMAIN)
super(SMSNotificationTestCase, self).tearDown()
def page_context(self):
return {
'stats': get_object_or_404(ILSMigrationStats, domain=self.domain),
'products_count': SQLProduct.objects.filter(domain=self.domain).count(),
'locations_count': SQLLocation.objects.filter(domain=self.domain).exclude(is_archived=True).count(),
'web_users_count': WebUser.by_domain(self.domain, reduce=True)[0]['value'],
'sms_users_count': CommCareUser.by_domain(self.domain, reduce=True)[0]['value'],
'problems': ILSMigrationProblem.objects.filter(domain=self.domain)
}
def obj_get_list(self, bundle, **kwargs):
domain = kwargs['domain']
username = bundle.request.GET.get('web_username')
if username:
user = WebUser.get_by_username(username)
if not (user and user.is_member_of(domain)):
user = None
return [user] if user else []
return list(WebUser.by_domain(domain))
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)))
ewsghana_webuser = self.api_object.web_user_sync(webuser)
web_users = list(WebUser.by_domain(TEST_DOMAIN))
self.assertEqual(1, len(web_users))
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)
location = SQLLocation.objects.get(external_id=1, domain=TEST_DOMAIN)
self.assertEqual(ewsghana_webuser.get_domain_membership(TEST_DOMAIN).location_id, location.location_id)
extension = EWSExtension.objects.get(user_id=ewsghana_webuser.get_id, domain=TEST_DOMAIN)
self.assertEqual(SQLLocation.objects.get(location_id=extension.location_id).site_code, 'rsp2')
self.assertListEqual(ewsghana_webuser.phone_numbers, ['1233232'])
self.assertEqual(ewsghana_webuser.default_phone_number, '1233232')
def tearDown(self):
for location in Location.by_domain(self.TEST_DOMAIN):
location.delete()
for user in WebUser.by_domain(self.TEST_DOMAIN):
user.delete()
for vn in VerifiedNumber.by_domain(self.TEST_DOMAIN):
vn.delete()
def get_users_to_export(username, domain):
if username:
users = [username]
super_users = []
else:
users = {u.username for u in WebUser.by_domain(domain)}
super_users = {u['username'] for u in User.objects.filter(is_superuser=True).values('username')}
super_users = super_users - users
return users, super_users
def get_admins_emails():
def get_role_or_none(user):
role = user.get_role(DOMAIN, False, False)
if role:
return role.name
return None
return map(lambda user: user.get_email(),
filter(lambda user: get_role_or_none(user) == 'Succeed Admin',
WebUser.by_domain(DOMAIN)))
def test_webusers_migration(self):
checkpoint = MigrationCheckpoint(
domain=TEST_DOMAIN, start_date=datetime.utcnow(), date=datetime.utcnow(), api="product", limit=100, offset=0
)
location_api = ApiSyncObject("webuser", self.endpoint.get_webusers, self.api_object.web_user_sync)
synchronization(location_api, checkpoint, None, 100, 0)
self.assertEqual("webuser", checkpoint.api)
self.assertEqual(100, checkpoint.limit)
self.assertEqual(0, checkpoint.offset)
self.assertEqual(5, len(list(WebUser.by_domain(TEST_DOMAIN))))
def tearDown(self):
for location in Location.by_domain(self.TEST_DOMAIN):
location.delete()
for user in WebUser.by_domain(self.TEST_DOMAIN):
user.delete()
delete_domain_phone_numbers(self.TEST_DOMAIN)
super(SMSNotificationTestCase, self).tearDown()
def get_admins_emails():
def get_role_or_none(user):
role = user.get_role(DOMAIN, False, False)
if role:
return role.name
return None
return map(
lambda user: user.get_email(),
filter(lambda user: get_role_or_none(user) == 'Succeed Admin',
WebUser.by_domain(DOMAIN)))
def web_users(self):
web_users = WebUser.by_domain(self.domain)
teams = Team.get_by_domain(self.domain)
for team in teams:
for user in team.get_members():
if user.get_id not in [web_user.get_id for web_user in web_users]:
user.from_team = True
web_users.append(user)
for user in web_users:
user.current_domain = self.domain
return web_users
def test_create_web_reporter(self):
with open(os.path.join(self.datapath, 'sample_webusers.json')) as f:
webuser = EWSUser(json.loads(f.read())[2])
ewsghana_webuser = 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)))
web_reporter_role = UserRole.by_domain_and_name(TEST_DOMAIN, 'Web Reporter')[0]
dm = web_users[0].get_domain_membership(TEST_DOMAIN)
self.assertEqual(web_reporter_role.get_id, dm.role_id)
location = SQLLocation.objects.get(external_id=620, domain=TEST_DOMAIN)
self.assertEqual(location.location_id, ewsghana_webuser.get_domain_membership(TEST_DOMAIN).location_id)
def tearDown(self):
delete_all_locations()
for user in WebUser.by_domain(self.TEST_DOMAIN):
user.delete()
delete_domain_phone_numbers(self.TEST_DOMAIN)
for product in Product.by_domain(self.TEST_DOMAIN):
product.delete()
super(MissingReportNotificationTestCase, self).tearDown()
def invite_web_user_form(self):
role_choices = UserRole.role_choices(self.domain)
if self.request.method == 'POST':
current_users = [user.username for user in WebUser.by_domain(self.domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(self.domain)]
return AdminInvitesUserForm(
self.request.POST,
excluded_emails=current_users + pending_invites,
role_choices=role_choices,
domain=self.domain
)
return AdminInvitesUserForm(role_choices=role_choices, domain=self.domain)
def web_users(self):
web_users = WebUser.by_domain(self.domain)
teams = Team.get_by_domain(self.domain)
for team in teams:
for user in team.get_members():
if user.get_id not in [web_user.get_id for web_user in web_users]:
user.from_team = True
web_users.append(user)
for user in web_users:
user.current_domain = self.domain
web_users.sort(key=lambda x: (x.role_label(), x.email))
return web_users
def invite_web_user_form(self):
role_choices = UserRole.role_choices(self.domain)
if self.request.method == 'POST':
current_users = [user.username for user in WebUser.by_domain(self.domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(self.domain)]
return AdminInvitesUserForm(
self.request.POST,
excluded_emails=current_users + pending_invites,
role_choices=role_choices,
domain=self.domain
)
return AdminInvitesUserForm(role_choices=role_choices, domain=self.domain)
def _users_context(request, domain):
couch_user = request.couch_user
web_users = WebUser.by_domain(domain)
for user in [couch_user] + list(web_users):
user.current_domain = domain
return {
'web_users': web_users,
'domain': domain,
'couch_user': couch_user,
}
def _users_context(request, domain):
couch_user = request.couch_user
web_users = WebUser.by_domain(domain)
for user in [couch_user] + list(web_users):
user.current_domain = domain
return {
'web_users': web_users,
'domain': domain,
'couch_user': couch_user,
}
def web_users(self):
web_users = WebUser.by_domain(self.domain)
teams = Team.get_by_domain(self.domain)
for team in teams:
for user in team.get_members():
if user.get_id not in [web_user.get_id for web_user in web_users]:
user.from_team = True
web_users.append(user)
for user in web_users:
user.current_domain = self.domain
web_users.sort(key=lambda x: (x.role_label(), x.email))
return web_users
def main_context(self):
contacts = CommCareUser.by_domain(self.domain, reduce=True)
web_users = WebUser.by_domain(self.domain)
web_users_admins = web_users_read_only = 0
facilities = SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='FACILITY')
admin_role_list = UserRole.by_domain_and_name(self.domain, 'Administrator')
if admin_role_list:
admin_role = admin_role_list[0]
else:
admin_role = None
for web_user in web_users:
dm = web_user.get_domain_membership(self.domain)
if admin_role and dm.role_id == admin_role.get_id:
web_users_admins += 1
else:
web_users_read_only += 1
main_context = super(GlobalStats, self).main_context
entities_reported_stock = SQLLocation.objects.filter(
domain=self.domain,
location_type__administrative=False
).count()
context = {
'root_name': self.root_name,
'country': SQLLocation.objects.filter(domain=self.domain,
location_type__name__iexact=self.root_name).count(),
'region': SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='region').count(),
'district': SQLLocation.objects.filter(
domain=self.domain,
location_type__name__iexact='district'
).count(),
'entities_reported_stock': entities_reported_stock,
'facilities': len(facilities),
'contacts': contacts[0]['value'] if contacts else 0,
'web_users': len(web_users),
'web_users_admins': web_users_admins,
'web_users_read_only': web_users_read_only,
'products': SQLProduct.objects.filter(domain=self.domain, is_archived=False).count(),
'product_stocks': StockState.objects.filter(sql_product__domain=self.domain).count(),
'stock_transactions': StockTransaction.objects.filter(report__domain=self.domain).count(),
'inbound_messages': SMS.count_by_domain(self.domain, direction=INCOMING),
'outbound_messages': SMS.count_by_domain(self.domain, direction=OUTGOING),
}
if self.show_supply_point_types:
counts = SQLLocation.objects.values('location_type__name').filter(domain=self.domain).annotate(
Count('location_type')
).order_by('location_type__name')
context['location_types'] = counts
main_context.update(context)
return main_context
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 main_context(self):
contacts = CommCareUser.by_domain(self.domain, reduce=True)
web_users = WebUser.by_domain(self.domain)
web_users_admins = web_users_read_only = 0
facilities = SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='FACILITY')
admin_role_list = UserRole.by_domain_and_name(self.domain, 'Administrator')
if admin_role_list:
admin_role = admin_role_list[0]
else:
admin_role = None
for web_user in web_users:
dm = web_user.get_domain_membership(self.domain)
if admin_role and dm.role_id == admin_role.get_id:
web_users_admins += 1
else:
web_users_read_only += 1
main_context = super(GlobalStats, self).main_context
entities_reported_stock = SQLLocation.objects.filter(
domain=self.domain,
location_type__administrative=False
).count()
context = {
'root_name': self.root_name,
'country': SQLLocation.objects.filter(domain=self.domain,
location_type__name__iexact=self.root_name).count(),
'region': SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='region').count(),
'district': SQLLocation.objects.filter(
domain=self.domain,
location_type__name__iexact='district'
).count(),
'entities_reported_stock': entities_reported_stock,
'facilities': len(facilities),
'contacts': contacts[0]['value'] if contacts else 0,
'web_users': len(web_users),
'web_users_admins': web_users_admins,
'web_users_read_only': web_users_read_only,
'products': SQLProduct.objects.filter(domain=self.domain, is_archived=False).count(),
'product_stocks': StockState.objects.filter(sql_product__domain=self.domain).count(),
'stock_transactions': StockTransaction.objects.filter(report__domain=self.domain).count(),
'inbound_messages': SMSLog.count_incoming_by_domain(self.domain),
'outbound_messages': SMSLog.count_outgoing_by_domain(self.domain)
}
if self.show_supply_point_types:
counts = SQLLocation.objects.values('location_type__name').filter(domain=self.domain).annotate(
Count('location_type')
).order_by('location_type__name')
context['location_types'] = counts
main_context.update(context)
return main_context
def tearDown(self):
for location in Location.by_domain(self.TEST_DOMAIN):
location.delete()
for user in WebUser.by_domain(self.TEST_DOMAIN):
user.delete()
delete_domain_phone_numbers(self.TEST_DOMAIN)
for product in Product.by_domain(self.TEST_DOMAIN):
product.delete()
super(UrgentNonReportingNotificationTestCase, self).tearDown()
def get_users_for_domain(domain):
users = {u.username for u in WebUser.by_domain(domain)}
super_users = {
u['username']
for u in User.objects.filter(is_superuser=True).values('username')
}
users_who_accepted_invitations = set(
Invitation.objects.filter(is_accepted=True,
domain=domain).values_list('email',
flat=True))
removed_users = users_who_accepted_invitations - users
super_users = super_users - users
return users, removed_users, super_users
def web_users(self):
web_users = WebUser.by_domain(self.domain)
teams = Team.get_by_domain(self.domain)
for team in teams:
for user in team.get_members():
if user.get_id not in [
web_user.get_id for web_user in web_users
]:
user.from_team = True
web_users.append(user)
for user in web_users:
user.current_domain = self.domain
return web_users
def apply(self, domain):
if not self.has_migrated_permissions:
logging.info("Applying permissions migration to domain %s" % domain.name)
from corehq.apps.users.models import UserRole, WebUser
UserRole.init_domain_with_presets(domain.name)
for web_user in WebUser.by_domain(domain.name):
try:
web_user.save()
except ResourceConflict:
# web_user has already been saved by another thread in the last few seconds
pass
self.has_migrated_permissions = True
domain.save()
def save(self, request, domain):
try:
global_tz = self.cleaned_data['default_timezone']
domain.default_timezone = global_tz
users = WebUser.by_domain(domain.name)
for user in users:
dm = user.get_domain_membership(domain.name)
if not dm.override_global_tz:
dm.timezone = global_tz
user.save()
domain.save()
return True
except Exception:
return False
def test_webusers_migration(self):
checkpoint = MigrationCheckpoint(domain=TEST_DOMAIN,
start_date=datetime.utcnow(),
date=datetime.utcnow(),
api='product',
limit=100,
offset=0)
location_api = ApiSyncObject('webuser', self.endpoint.get_webusers,
self.api_object.web_user_sync)
synchronization(location_api, checkpoint, None, 100, 0)
self.assertEqual('webuser', checkpoint.api)
self.assertEqual(100, checkpoint.limit)
self.assertEqual(0, checkpoint.offset)
self.assertEqual(5, len(list(WebUser.by_domain(TEST_DOMAIN))))
def _notify_dimagi_users_on_domain(domain):
from corehq.apps.users.models import WebUser
from corehq.apps.hqwebapp.tasks import send_mail_async
recipients = [
user.get_email() for user in WebUser.by_domain(domain)
if user.is_dimagi
]
subject = 'CommCare HQ project migrated to the scale backend.'.format(
domain)
message = """
The CommCare HQ project "{}" has been migrated to the scale backend.
You should not notice anything different but if you do please report a bug.
""".format(domain)
send_mail_async.delay(subject, message, settings.DEFAULT_FROM_EMAIL,
recipients)
def audit_logs(request, domain):
usernames = [user.username for user in WebUser.by_domain(domain)]
data = {}
for username in usernames:
data[username] = []
for doc in get_db().view('auditcare/urlpath_by_user_date',
startkey=[username],
endkey=[username, {}],
include_docs=True,
wrapper=lambda r: r['doc']).all():
try:
(d, ) = re.search(r'^/a/([\w\-_\.]+)/',
doc['request_path']).groups()
if d == domain:
data[username].append(doc)
except Exception:
pass
return json_response(data)
def _users_context(request, domain):
couch_user = request.couch_user
web_users = WebUser.by_domain(domain)
teams = Team.get_by_domain(domain)
for team in teams:
for user in team.get_members():
if user.get_id not in [web_user.get_id for web_user in web_users]:
user.from_team = True
web_users.append(user)
for user in [couch_user] + list(web_users):
user.current_domain = domain
return {
'web_users': web_users,
'domain': domain,
'couch_user': couch_user,
}
