def registrations(request):
context = {}
hubApi = HubApiClient(
api_url=request.session["user_tokens"]["HUB"]["url"], # noqa
auth_token=request.session["user_tokens"]["HUB"]["token"] # noqa
)
if 'mother_id' in request.GET:
form = RegistrationFilterForm(request.GET)
if form.is_valid():
reg_filter = {
settings.STAGE_FIELD: form.cleaned_data['stage'],
"validated": form.cleaned_data['validated'],
settings.IDENTITY_FIELD: form.cleaned_data['mother_id']
}
registrations = hubApi.get_registrations(
params=reg_filter)['results']
else:
registrations = []
else:
form = RegistrationFilterForm()
registrations = hubApi.get_registrations()['results']
context['form'] = form
context['registrations'] = utils.get_page_of_iterator(
registrations, settings.REGISTRATION_LIST_PAGE_SIZE,
request.GET.get('page'))
return render(request, 'ci/registrations.html', context)
def handle(self, *args, **options):
hub_url = options['hub_url']
hub_token = options['hub_token']
id_url = options['identity_url']
id_token = options['identity_token']
hub_id_field = options['hub_identity_field']
if not hub_url or not hub_token:
self.warning("hub-url and hub-token is required.")
return
hubApi = HubApiClient(hub_token, hub_url)
idApi = IdentityStoreApiClient(id_token, id_url)
subscriptions = Subscription.objects.filter(process_status=5)
reg_count = 0
id_count = 0
for subscription in subscriptions.iterator():
identity = subscription.identity
# find and update linked registrations
registrations = hubApi.get_registrations({hub_id_field: identity})
for registration in registrations['results']:
if not registration['data'].get('exclude_report', False):
registration['data']['exclude_report'] = True
try:
hubApi.update_registration(
registration['id'], {'data': registration['data']})
reg_count += 1
except exceptions.ConnectionError as exc:
self.warning(
'Connection error to Hub API: {}'.format(exc))
except HTTPServiceError as exc:
self.warning('Invalid Hub API response({}): {}'.format(
exc.response.status_code, exc.response.url))
# find and update linked identities
identity = idApi.get_identity(identity)
if not identity['details'].get('exclude_report', False):
identity['details']['exclude_report'] = True
try:
idApi.update_identity(identity['id'],
{'details': identity['details']})
id_count += 1
except exceptions.ConnectionError as exc:
self.warning(
'Connection error to Identity API: {}'.format(exc))
except HTTPServiceError as exc:
self.warning(
'Invalid Identity Store API response({}): {}'.format(
exc.response.status_code, exc.response.url))
self.success('Updated %s identities and %s registrations.' %
(id_count, reg_count))
def identity(request, identity):
idApi = IdentityStoreApiClient(
api_url=request.session["user_tokens"]["SEED_IDENTITY_SERVICE"]
["url"], # noqa
auth_token=request.session["user_tokens"]["SEED_IDENTITY_SERVICE"][
"token"] # noqa
)
hubApi = HubApiClient(
api_url=request.session["user_tokens"]["HUB"]["url"], # noqa
auth_token=request.session["user_tokens"]["HUB"]["token"] # noqa
)
sbmApi = StageBasedMessagingApiClient(
api_url=request.session["user_tokens"]["SEED_STAGE_BASED_MESSAGING"]
["url"], # noqa
auth_token=request.session["user_tokens"]["SEED_STAGE_BASED_MESSAGING"]
["token"] # noqa
)
msApi = MessageSenderApiClient(
api_url=request.session["user_tokens"]["SEED_MESSAGE_SENDER"]
["url"], # noqa
auth_token=request.session["user_tokens"]["SEED_MESSAGE_SENDER"][
"token"] # noqa
)
messagesets_results = sbmApi.get_messagesets()
messagesets = {}
schedules = {}
choices = []
for messageset in messagesets_results["results"]:
messagesets[messageset["id"]] = messageset["short_name"]
schedules[messageset["id"]] = messageset["default_schedule"]
choices.append((messageset["id"], messageset["short_name"]))
results = idApi.get_identity(identity)
sbm_filter = {"identity": identity}
subscriptions = sbmApi.get_subscriptions(params=sbm_filter)
if request.method == "POST":
if 'add_subscription' in request.POST:
form = AddSubscriptionForm(request.POST)
language = results['details'].get(settings.LANGUAGE_FIELD)
if language:
if form.is_valid():
subscription = {
"active": True,
"identity": identity,
"completed": False,
"lang": language,
"messageset": form.cleaned_data['messageset'],
"next_sequence_number": 1,
"schedule": schedules[form.cleaned_data['messageset']],
"process_status": 0,
}
sbmApi.create_subscription(subscription)
messages.add_message(
request,
messages.INFO,
'Successfully created a subscription.',
extra_tags='success')
else:
messages.add_message(
request,
messages.ERROR,
'No language value in {} on the identity.'.format(
settings.LANGUAGE_FIELD),
extra_tags='danger')
elif 'deactivate_subscription' in request.POST:
form = DeactivateSubscriptionForm(request.POST)
if form.is_valid():
data = {"active": False}
sbmApi.update_subscription(
form.cleaned_data['subscription_id'], data)
messages.add_message(
request,
messages.INFO,
'Successfully deactivated the subscription.',
extra_tags='success')
elif 'optout_identity' in request.POST:
try:
details = results.get('details', {})
addresses = details.get('addresses', {})
for address_type, addresses in addresses.items():
for address, info in addresses.items():
idApi.create_optout({
"identity": identity,
"optout_type": "stop",
"address_type": address_type,
"address": address,
"request_source": "ci"
})
hubApi.create_optout_admin({settings.IDENTITY_FIELD: identity})
messages.add_message(request,
messages.INFO,
'Successfully opted out.',
extra_tags='success')
except:
messages.add_message(request,
messages.ERROR,
'Optout failed.',
extra_tags='danger')
hub_filter = {settings.IDENTITY_FIELD: identity}
registrations = hubApi.get_registrations(params=hub_filter)
changes = hubApi.get_changes(params=hub_filter)
if results is None:
return redirect('not_found')
outbound_message_params = {
'to_identity': identity,
'ordering': '-created_at',
}
outbound_messages = msApi.get_outbounds(params=outbound_message_params)
outbound_page = request.GET.get('outbound_page')
outbound_paginator = Paginator(list(outbound_messages['results']),
settings.IDENTITY_MESSAGES_PAGE_SIZE)
try:
outbound_messages = outbound_paginator.page(outbound_page)
except PageNotAnInteger:
outbound_messages = outbound_paginator.page(1)
except EmptyPage:
outbound_messages = outbound_paginator.page(
outbound_paginator.num_pages)
inbound_message_params = {
'from_identity': identity,
'ordering': '-created_at',
}
inbound_messages = msApi.get_inbounds(inbound_message_params)
inbound_page = request.GET.get('inbound_page')
inbound_paginator = Paginator(list(inbound_messages['results']),
settings.IDENTITY_MESSAGES_PAGE_SIZE)
try:
inbound_messages = inbound_paginator.page(inbound_page)
except PageNotAnInteger:
inbound_messages = inbound_paginator.page(1)
except EmptyPage:
inbound_messages = inbound_paginator.page(inbound_paginator.num_pages)
deactivate_subscription_form = DeactivateSubscriptionForm()
add_subscription_form = AddSubscriptionForm()
add_subscription_form.fields['messageset'] = forms.ChoiceField(
choices=choices)
optout_visible = False
details = results.get('details', {})
addresses = details.get('addresses', {})
msisdns = addresses.get('msisdn', {})
optout_visible = any((not d.get('optedout') for _, d in msisdns.items()))
context = {
"identity": results,
"registrations": registrations,
"changes": changes,
"messagesets": messagesets,
"subscriptions": subscriptions,
"outbound_messages": outbound_messages,
"add_subscription_form": add_subscription_form,
"deactivate_subscription_form": deactivate_subscription_form,
"inbound_messages": inbound_messages,
"optout_visible": optout_visible
}
context.update(csrf(request))
return render(request, 'ci/identities_detail.html', context)
def handle(self, *options, **kwargs):
self.identity_cache = {}
hub_token = kwargs['hub_token']
hub_url = kwargs['hub_url']
id_store_token = kwargs['identity_store_token']
id_store_url = kwargs['identity_store_url']
group = kwargs['group']
headers = ['risk', 'count']
if group == 'msisdn':
if not id_store_token or not id_store_url:
raise CommandError(
'Please make sure the --identity-store-url and '
'--identity-store-token is set.')
ids_client = IdentityStoreApiClient(id_store_token, id_store_url)
headers = ['msisdn', 'risk']
output = self.stdout
if kwargs['output']:
output = open(kwargs['output'], 'w')
results = defaultdict(int)
def add_to_result(risk, reg):
if group == "msisdn":
identity = self.get_identity(ids_client, reg)
if identity:
details = identity.get('details', {})
default_addr_type = details.get('default_addr_type')
if default_addr_type:
addresses = details.get('addresses', {})
msisdns = addresses.get(default_addr_type, {}).keys()
else:
msisdns = []
results[', '.join(msisdns)] = 1 if risk == "high" else 0
else:
results[risk] += 1
if hub_token and hub_url:
hub_client = HubApiClient(hub_token, hub_url)
for source in (1, 3):
registrations = hub_client.get_registrations({
"source": source,
"validated": True
})['results']
for registration in registrations:
mom_dob = registration["data"].get("mom_dob")
if not mom_dob:
identity = self.get_identity(
ids_client, registration["registrant_id"])
if not identity:
continue
mom_dob = identity["details"].get("mom_dob")
risk = get_risk_status(registration["reg_type"], mom_dob,
registration["data"].get("edd"))
add_to_result(risk, registration['registrant_id'])
else:
registrations = Registration.objects.filter(
Q(reg_type='pmtct_postbirth') | Q(reg_type='pmtct_prebirth')
| Q(reg_type='whatsapp_pmtct_postbirth')
| Q(reg_type='whatsapp_pmtct_prebirth'),
validated=True)
for registration in registrations.iterator():
add_personally_identifiable_fields(registration)
risk = get_risk_status(registration.reg_type,
registration.data["mom_dob"],
registration.data.get("edd"))
add_to_result(risk, registration.registrant_id)
writer = csv.DictWriter(output, headers)
writer.writeheader()
for risk, count in results.items():
writer.writerow({headers[0]: risk, headers[1]: count})