def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['disbursements'] = retrieve_all_pages_for_path(
self.api_session, 'disbursements/', resolution='pending')
context['disbursements'] += retrieve_all_pages_for_path(
self.api_session, 'disbursements/', resolution='preconfirmed')
context['pending_count'] = len(context['disbursements'])
for disbursement in context['disbursements']:
disbursement.update(
**get_disbursement_viability(self.request, disbursement))
return context
def prepare_csv(self, batches):
f = io.StringIO()
f.write(
'Establishment, Date, Prisoner Name, Prisoner Number, TransactionID, Value, Sender, Address\n'
)
total = 0
count = 0
for batch in batches:
csv_batch_date = batch['date'].strftime('%d/%m/%y')
credit_list = retrieve_all_pages_for_path(
self.api_session, 'private-estate-batches/%s/%s/credits/' % (
batch['prison']['nomis_id'],
batch['date'].isoformat(),
))
count += len(credit_list)
prison_name = batch['prison'].get(
'short_name') or batch['prison']['name']
for credit in credit_list:
total += credit['amount']
f.write((
f'{csv_text_value(prison_name)},'
f" {csv_batch_date.replace(',', '')},"
f"{csv_text_value(credit['prisoner_name'])},"
f" {credit['prisoner_number'].replace(',', '')},"
f' {csv_transaction_id(credit)},'
f" {format_amount(credit['amount']).replace(',', '')},"
f"{csv_text_value(credit.get('sender_name') or 'Unknown sender')},"
f' {csv_text_value(format_address(credit))},'
f' \n').replace('"', ''))
f.write(
f", , , ,Total , {format_amount(total).replace(',', '')}, , \n")
return codecs.encode(f.getvalue(), 'cp1252',
errors='ignore'), total, count
def prison_choices(api_session):
choices = cache.get('prison-list')
if not choices:
choices = retrieve_all_pages_for_path(api_session, '/prisons/', exclude_empty_prisons=True)
choices = [[prison['nomis_id'], prison['name']] for prison in choices]
cache.set('prison-list', choices, timeout=60 * 60 * 6)
return choices
def email_export_xlsx(*, object_type, user, session, endpoint_path, filters,
export_description, attachment_name):
if not get_language():
language = getattr(settings, 'LANGUAGE_CODE', 'en')
activate(language)
if object_type == 'credits':
export_message = gettext(
'Attached are the credits you exported from ‘%(service_name)s’.')
elif object_type == 'disbursements':
export_message = (gettext(
'Attached are the bank transfer and cheque disbursements you exported from ‘%(service_name)s’.'
) + ' ' + gettext('You can’t see cash or postal orders here.'))
elif object_type == 'senders':
export_message = gettext(
'Attached is a list of payment sources you exported from ‘%(service_name)s’.'
)
elif object_type == 'prisoners':
export_message = gettext(
'Attached is a list of prisoners you exported from ‘%(service_name)s’.'
)
else:
raise NotImplementedError(f'Cannot export {object_type}')
api_session = get_api_session_with_session(user, session)
generated_at = timezone.now()
object_list = convert_date_fields(
retrieve_all_pages_for_path(api_session, endpoint_path, **filters))
serialiser = ObjectListSerialiser.serialiser_for(object_type)
workbook = serialiser.make_workbook(object_list)
output = save_virtual_workbook(workbook)
attachment_type = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
template_context = prepare_context({
'export_description': export_description,
'generated_at': generated_at,
'export_message': export_message % {
'service_name': gettext('Prisoner money intelligence')
}
})
subject = '%s - %s' % (gettext('Prisoner money intelligence'),
gettext('Exported data'))
text_body = template_loader.get_template(
'security/email/export.txt').render(template_context)
html_body = template_loader.get_template(
'security/email/export.html').render(template_context)
email = AnymailMessage(
subject=subject,
body=text_body.strip('\n'),
from_email=default_from_address(),
to=[user.email],
tags=['export'],
)
email.attach_alternative(html_body, mimetype='text/html')
email.attach(attachment_name, output, mimetype=attachment_type)
email.send()
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['disbursements'] = retrieve_all_pages_for_path(
self.api_session, 'disbursements/', resolution='pending'
)
context['disbursements'] += retrieve_all_pages_for_path(
self.api_session, 'disbursements/', resolution='preconfirmed'
)
context['pending_count'] = len(context['disbursements'])
for disbursement in context['disbursements']:
disbursement.update(
**get_disbursement_viability(self.request, disbursement)
)
return context
def _get_related_credits(api_session, detail_object):
# Get the credits from the same sender that were actioned by FIU
if detail_object['credit']['sender_profile']:
sender_response = retrieve_all_pages_for_path(
api_session,
f'/senders/{detail_object["credit"]["sender_profile"]}/credits/',
**{
'exclude_credit__in': detail_object['credit']['id'],
'security_check__isnull': False,
'only_completed': False,
'security_check__actioned_by__isnull': False,
'include_checks': True
})
else:
sender_response = []
sender_credits = convert_date_fields(sender_response,
include_nested=True)
# Get the credits to the same prisoner that were actioned by FIU
if detail_object['credit']['prisoner_profile']:
prisoner_response = retrieve_all_pages_for_path(
api_session,
f'/prisoners/{detail_object["credit"]["prisoner_profile"]}/credits/',
**{
# Exclude any credits displayed as part of sender credits, to prevent duplication where
# both prisoner and sender same as the credit in question
'exclude_credit__in':
','.join([str(detail_object['credit']['id'])] +
[str(c['id']) for c in sender_credits]),
'security_check__isnull':
False,
'only_completed':
False,
'security_check__actioned_by__isnull':
False,
'include_checks':
True
})
else:
prisoner_response = []
prisoner_credits = convert_date_fields(prisoner_response,
include_nested=True)
return sorted(prisoner_credits + sender_credits,
key=lambda c: c['security_check']['actioned_at'],
reverse=True)
def prison_choices(self):
choices = cache.get('sign-up-prisons')
if not choices:
try:
choices = retrieve_all_pages_for_path(self.api_session, '/prisons/', exclude_empty_prisons=True)
choices = [[prison['nomis_id'], prison['name']] for prison in choices]
cache.set('sign-up-prisons', choices, timeout=60 * 60 * 6)
except (RequestException, OAuth2Error, ValueError):
logger.exception('Could not look up prison list')
return choices
def prison_choices(self):
choices = cache.get('sign-up-prisons')
if not choices:
try:
choices = retrieve_all_pages_for_path(self.api_session, '/prisons/', exclude_empty_prisons=True)
choices = OrderedDict([[prison['nomis_id'], prison['name']] for prison in choices])
cache.set('sign-up-prisons', choices, timeout=60 * 60 * 6)
except (RequestException, OAuth2Error, ValueError):
logger.exception('Could not look up prison list')
return choices
def credits(self):
prisons = [
prison['nomis_id']
for prison in self.request.user.user_data.get('prisons', [])
if prison['pre_approval_required']
]
return retrieve_all_pages_for_path(
self.session,
'/credits/',
valid=True,
reviewed=False,
prison=prisons,
resolution='pending',
received_at__lt=datetime.datetime.combine(
timezone.now().date(),
datetime.time(0, 0, 0, tzinfo=timezone.utc)))
def get_prison_list(cls):
prison_list = cache.get('prison_list')
if not prison_list:
try:
session = get_api_session()
prison_list = retrieve_all_pages_for_path(
session, '/prisons/', exclude_empty_prisons=True)
prison_list = [
prison['name'] for prison in sorted(
prison_list, key=lambda prison: prison['short_name'])
]
if not prison_list:
raise ValueError('Empty prison list')
cache.set('prison_list', prison_list, timeout=60 * 60)
except (RequestException, OAuth2Error, ValueError):
logger.exception('Could not look up prison list')
return prison_list
def credit_choices(self):
filters = {}
fields = set(self.fields.keys())
if self.is_valid():
# valid form
for field in fields:
if field in self.cleaned_data:
filters[field] = self.cleaned_data[field]
elif not self.is_bound:
# no form submission
for field in fields:
if field in self.initial:
filters[field] = self.initial[field]
renames = (
('start', 'received_at__gte'),
('end', 'received_at__lt'),
)
for field_name, api_name in renames:
if field_name in filters:
filters[api_name] = filters[field_name]
del filters[field_name]
page = self.cleaned_data.get('page') or 1
offset = (page - 1) * self.page_size
response = self.session.get('credits/',
params=dict(offset=offset,
limit=self.page_size,
resolution='credited',
**filters)).json()
count = response.get('count', 0)
self.pagination = {
'page': page,
'count': count,
'full_count': count,
'page_count': int(ceil(count / self.page_size)),
}
results = response.get('results', [])
if page == 1:
new_credits = retrieve_all_pages_for_path(self.session,
'credits/',
status='credit_pending',
**filters)
self.pagination['full_count'] += len(new_credits)
results = new_credits + results
return parse_date_fields(results)
def credit_choices(self):
filters = {}
fields = set(self.fields.keys())
if self.is_valid():
# valid form
for field in fields:
if field in self.cleaned_data:
filters[field] = self.cleaned_data[field]
elif not self.is_bound:
# no form submission
for field in fields:
if field in self.initial:
filters[field] = self.initial[field]
renames = (
('start', 'received_at__gte'),
('end', 'received_at__lt'),
)
for field_name, api_name in renames:
if field_name in filters:
filters[api_name] = filters[field_name]
del filters[field_name]
page = self.cleaned_data.get('page') or 1
offset = (page - 1) * self.page_size
response = self.session.get(
'credits/',
params=dict(offset=offset, limit=self.page_size, resolution='credited', **filters)
).json()
count = response.get('count', 0)
self.pagination = {
'page': page,
'count': count,
'full_count': count,
'page_count': int(ceil(count / self.page_size)),
}
results = response.get('results', [])
if page == 1:
new_credits = retrieve_all_pages_for_path(
self.session, 'credits/', status='credit_pending', **filters
)
self.pagination['full_count'] += len(new_credits)
results = new_credits + results
return parse_date_fields(results)
def list_users(request):
page_size = 20
try:
page = int(request.GET['page'])
if page < 1:
raise ValueError
except (KeyError, ValueError):
page = 1
session = api_client.get_api_session(request)
response = session.get(
'users/',
params={
'limit': page_size,
'offset': (page - 1) * page_size,
}
).json()
user_count = response.get('count', 0)
users = response.get('results', [])
try:
account_requests = retrieve_all_pages_for_path(session, 'requests/')
for account_request in account_requests:
account_request['created'] = parse_datetime(account_request['created'])
except HttpClientError:
logger.exception(f'User {request.user.username} cannot access account requests')
account_requests = []
context = {
'breadcrumbs': make_breadcrumbs(),
'can_delete': request.user.has_perm('auth.delete_user'),
'locked_users_exist': any(user['is_locked_out'] for user in users),
'users': users,
'page': page,
'page_count': int(math.ceil(user_count / page_size)),
'user_count': user_count,
'account_requests': account_requests,
}
return render(request, 'mtp_common/user_admin/list.html', context=context)
def get_saved_searches(session):
return retrieve_all_pages_for_path(session, '/searches/')
def get_prisons(self, session):
prisons = cache.get('PrisonList')
if prisons is None:
prisons = retrieve_all_pages_for_path(session, '/prisons/')
cache.set('PrisonList', prisons, timeout=60 * 15)
return prisons
def retrieve_all_transactions(api_session, **kwargs):
return retrieve_all_pages_for_path(
api_session, 'transactions/', **kwargs)
def get_complete_object_list(self):
filters = self.get_api_request_params()
return convert_date_fields(retrieve_all_pages_for_path(
self.session, self.get_object_list_endpoint_path(), **filters)
)
def retrieve_all_valid_credits(api_session, **kwargs):
return retrieve_all_pages_for_path(
api_session, 'credits/', valid=True, **kwargs)
def get_incomplete_payments(self):
older_than = timezone.now() - self.CHECK_INCOMPLETE_PAYMENT_DELAY
return retrieve_all_pages_for_path(self.api_session,
'/payments/',
modified__lt=older_than.isoformat())
def retrieve_prisons(api_session):
prisons = retrieve_all_pages_for_path(api_session, 'prisons/')
return {prison['nomis_id']: prison for prison in prisons}
def retrieve_all_disbursements(api_session, **kwargs):
return retrieve_all_pages_for_path(api_session, 'disbursements/', **kwargs)
def retrieve_credits(self, offset, limit, **filters):
credits = retrieve_all_pages_for_path(
self.session, 'credits/', **dict(self.default_filters, **filters)
)
return len(credits), credits
def _request_all_credits(self):
return retrieve_all_pages_for_path(
self.session, 'credits/', status='credit_pending', resolution='manual',
ordering=self.ordering
)
