def get_content(self):
if self.plaintext_redacted is None:
self.plaintext_redacted = redact_plaintext(self.plaintext,
self.is_response,
user=self.request.user)
self.save()
return self.plaintext_redacted
def save(self):
foilaw = self.publicbody.default_law
req = self.foirequest
req.public_body = self.publicbody
req.law = foilaw
req.jurisdiction = self.publicbody.jurisdiction
send_now = req.set_status_after_change()
if send_now:
req.due_date = foilaw.calculate_due_date()
req.save()
req.request_to_public_body.send(sender=req)
if req.law:
send_address = not req.law.email_only
if send_now:
messages = req.foimessage_set.all()
message = messages[0]
message.recipient_public_body = self.publicbody
message.sender_user = req.user
message.recipient = self.publicbody.name
message.recipient_email = self.publicbody.email
message.plaintext = construct_initial_message_body(
req,
text=req.description,
foilaw=req.law,
full_text=False,
send_address=send_address)
message.plaintext_redacted = redact_plaintext(message.plaintext,
is_response=False,
user=req.user)
message.save()
message.send()
def make_message(self):
user = self.foirequest.user
subject = self.cleaned_data['subject']
subject = re.sub(r'\s*\[#%s\]\s*$' % self.foirequest.pk, '', subject)
subject = '%s [#%s]' % (subject, self.foirequest.pk)
subject = '%s [#%s]' % (subject, self.foirequest.pk)
subject_redacted = redact_subject(subject, user=user)
plaintext = construct_message_body(self.foirequest,
self.cleaned_data['message'],
send_address=False)
plaintext_redacted = redact_plaintext(plaintext,
is_response=False,
user=self.foirequest.user)
return FoiMessage(request=self.foirequest,
subject=subject,
subject_redacted=subject_redacted,
is_response=False,
is_escalation=True,
sender_user=self.foirequest.user,
sender_name=self.foirequest.user.display_name(),
sender_email=self.foirequest.secret_address,
recipient_email=self.foirequest.law.mediator.email,
recipient_public_body=self.foirequest.law.mediator,
recipient=self.foirequest.law.mediator.name,
timestamp=timezone.now(),
plaintext=plaintext,
plaintext_redacted=plaintext_redacted)
def rerun_message_redaction(foirequests):
for foirequest in foirequests:
user = foirequest.user
for message in foirequest.messages:
message.subject_redacted = redact_subject(message.subject,
user=user)
message.plaintext_redacted = redact_plaintext(
message.plaintext, is_response=message.is_response, user=user)
message.save()
def redact_plaintext_with_request(plaintext, foirequest, is_response=False):
short_url = foirequest.get_absolute_domain_short_url()
secret_urls = {
foirequest.get_auth_link(): short_url,
foirequest.get_upload_link(): short_url
}
return redact_plaintext(plaintext,
is_response=is_response,
user=foirequest.user,
replacements=secret_urls)
def get_content(self):
self.plaintext = self.plaintext or ''
if self.plaintext_redacted is None:
self.plaintext_redacted = redact_plaintext(
self.plaintext,
self.is_response,
user=self.request.user
)
self.save()
return self.plaintext_redacted
def redact_plaintext_with_request(plaintext,
foirequest,
redact_greeting=False,
redact_closing=False):
replacements = get_secret_url_replacements()
return redact_plaintext(plaintext,
redact_greeting=redact_greeting,
redact_closing=redact_closing,
user=foirequest.user,
replacements=replacements)
def process(self, request=None):
foirequest = self.kwargs['foirequest']
publicbody = self.kwargs.get('publicbody', None)
email = self.data
subject = email['subject'] or ''
subject = subject[:250]
message_id = email.get('message_id', '') or ''
if message_id:
message_id = message_id[:512]
message = FoiMessage(request=foirequest,
subject=subject,
email_message_id=message_id,
is_response=True,
sender_name=email['from'][0],
sender_email=email['from'][1],
recipient_email=foirequest.secret_address,
recipient=foirequest.user.display_name(),
plaintext=email['body'],
html=email['html'],
content_hidden=email.get('is_auto_reply', False))
if publicbody is None:
publicbody = get_publicbody_for_email(message.sender_email,
foirequest)
if publicbody is None:
publicbody = foirequest.public_body
message.sender_public_body = publicbody
if foirequest.law and publicbody == foirequest.law.mediator:
message.content_hidden = True
if email['date'] is None:
message.timestamp = timezone.now()
else:
message.timestamp = email['date']
message.subject_redacted = redact_subject(message.subject,
user=foirequest.user)
message.plaintext_redacted = redact_plaintext(message.plaintext,
is_response=True,
user=foirequest.user)
message.save()
foirequest._messages = None
foirequest.status = 'awaiting_classification'
foirequest.last_message = message.timestamp
foirequest.save()
self.add_attachments(foirequest, message, email['attachments'])
foirequest.message_received.send(sender=foirequest, message=message)
def rerun_message_redaction(foirequests):
for foirequest in foirequests:
user = foirequest.user
for message in foirequest.messages:
message.subject_redacted = redact_subject(
message.subject, user=user
)
message.plaintext_redacted = redact_plaintext(
message.plaintext,
is_response=message.is_response,
user=user
)
message.save()
def add_message_body(self,
message,
attachment_names=(),
attachment_missing=()):
message_body = self.cleaned_data['message']
send_address = self.cleaned_data.get('send_address', True)
message.plaintext = construct_message_body(
self.foirequest,
message_body,
send_address=send_address,
attachment_names=attachment_names,
attachment_missing=attachment_missing,
)
message.plaintext_redacted = redact_plaintext(
message.plaintext, is_response=False, user=self.foirequest.user)
def add_message_body(self, message,
attachment_names=(), attachment_missing=()):
message_body = self.cleaned_data['message']
send_address = self.cleaned_data.get('send_address', True)
message.plaintext = construct_message_body(
self.foirequest,
message_body,
send_address=send_address,
attachment_names=attachment_names,
attachment_missing=attachment_missing,
)
message.plaintext_redacted = redact_plaintext(
message.plaintext,
is_response=False,
user=self.foirequest.user
)
def make_message(self):
user = self.foirequest.user
if self.cleaned_data["to"] == 0:
recipient_name = self.foirequest.public_body.name
recipient_email = self.foirequest.public_body.email
recipient_pb = self.foirequest.public_body
else:
message = list(
filter(lambda x: x.id == self.cleaned_data["to"],
list(self.foirequest.messages)))[0]
recipient_name = message.sender_name
recipient_email = message.sender_email
recipient_pb = message.sender_public_body
message_body = self.cleaned_data['message']
subject = re.sub(r'\s*\[#%s\]\s*$' % self.foirequest.pk, '',
self.cleaned_data["subject"])
subject = '%s [#%s]' % (subject, self.foirequest.pk)
subject_redacted = redact_subject(subject, user=user)
send_address = self.cleaned_data.get('send_address', True)
plaintext = construct_message_body(self.foirequest,
message_body,
send_address=send_address)
plaintext_redacted = redact_plaintext(plaintext,
is_response=False,
user=self.foirequest.user)
return FoiMessage(request=self.foirequest,
subject=subject,
kind='email',
subject_redacted=subject_redacted,
is_response=False,
sender_user=user,
sender_name=user.display_name(),
sender_email=self.foirequest.secret_address,
recipient_email=recipient_email.strip(),
recipient_public_body=recipient_pb,
recipient=recipient_name,
timestamp=timezone.now(),
plaintext=plaintext,
plaintext_redacted=plaintext_redacted)
def make_message(self, attachment_names=(), attachment_missing=()):
user = self.foirequest.user
subject = self.cleaned_data['subject']
subject = re.sub(r'\s*\[#%s\]\s*$' % self.foirequest.pk, '', subject)
subject = '%s [#%s]' % (subject, self.foirequest.pk)
subject = '%s [#%s]' % (subject, self.foirequest.pk)
subject_redacted = redact_subject(subject, user=user)
plaintext = construct_message_body(
self.foirequest,
self.cleaned_data['message'],
send_address=False,
attachment_names=attachment_names,
attachment_missing=attachment_missing,
)
plaintext_redacted = redact_plaintext(
plaintext,
is_response=False,
user=self.foirequest.user
)
plaintext_redacted = plaintext_redacted.replace(
self.foirequest.get_auth_link(),
self.foirequest.get_absolute_domain_short_url(),
)
return FoiMessage(
request=self.foirequest,
subject=subject,
subject_redacted=subject_redacted,
is_response=False,
is_escalation=True,
sender_user=self.foirequest.user,
sender_name=self.foirequest.user.display_name(),
sender_email=self.foirequest.secret_address,
recipient_email=self.foirequest.law.mediator.email,
recipient_public_body=self.foirequest.law.mediator,
recipient=self.foirequest.law.mediator.name,
timestamp=timezone.now(),
plaintext=plaintext,
plaintext_redacted=plaintext_redacted
)
def save(self):
foilaw = self.publicbody.default_law
req = self.foirequest
req.public_body = self.publicbody
req.law = foilaw
req.jurisdiction = self.publicbody.jurisdiction
send_now = req.set_status_after_change()
if send_now:
req.due_date = foilaw.calculate_due_date()
req.save()
req.request_to_public_body.send(sender=req)
if req.law:
send_address = not req.law.email_only
if send_now:
messages = req.foimessage_set.all()
message = messages[0]
message.recipient_public_body = self.publicbody
message.sender_user = req.user
message.recipient = self.publicbody.name
message.recipient_email = self.publicbody.email
message.plaintext = construct_initial_message_body(
req,
text=req.description,
foilaw=req.law,
full_text=False,
send_address=send_address
)
message.plaintext_redacted = redact_plaintext(
message.plaintext,
is_response=False,
user=req.user
)
message.save()
message.send()
def process(self, request=None):
foirequest = self.kwargs['foirequest']
publicbody = self.kwargs.get('publicbody', None)
email = self.data
subject = email.subject or ''
subject = subject[:250]
message_id = email.message_id or ''
if message_id:
message_id = message_id[:512]
recipient_name, recipient_email = self.get_recipient_name_email()
is_bounce = email.bounce_info.is_bounce
hide_content = email.is_auto_reply or is_bounce
message = FoiMessage(
request=foirequest,
subject=subject,
email_message_id=message_id,
is_response=True,
sender_name=email.from_[0],
sender_email=email.from_[1],
recipient=recipient_name,
recipient_email=recipient_email,
plaintext=email.body,
html=email.html,
content_hidden=hide_content
)
if not is_bounce:
if publicbody is None:
publicbody = get_publicbody_for_email(
message.sender_email, foirequest
)
if publicbody is None:
publicbody = foirequest.public_body
else:
publicbody = None
message.sender_public_body = publicbody
if (foirequest.law and foirequest.law.mediator and
publicbody == foirequest.law.mediator):
message.content_hidden = True
if email.date is None:
message.timestamp = timezone.now()
else:
message.timestamp = email.date
message.subject_redacted = redact_subject(
message.subject, user=foirequest.user
)
message.plaintext_redacted = redact_plaintext(
message.plaintext, is_response=True,
user=foirequest.user
)
if is_bounce:
self.process_bounce_message(message)
return
message.save()
foirequest._messages = None
foirequest.status = 'awaiting_classification'
foirequest.save()
self.add_attachments(foirequest, message, email.attachments)
foirequest.message_received.send(sender=foirequest, message=message)
def create_request(self, publicbody, sequence=0):
data = self.data
user = data['user']
now = timezone.now()
request = FoiRequest(
title=data['subject'],
public_body=publicbody,
user=data['user'],
description=data['body'],
public=data['public'],
site=Site.objects.get_current(),
reference=data.get('reference', ''),
first_message=now,
last_message=now,
project=data.get('project'),
project_order=data.get('project_order'),
)
send_now = False
if not user.is_active:
request.status = 'awaiting_user_confirmation'
request.visibility = FoiRequest.INVISIBLE
else:
# TODO add draft
request.status = 'awaiting_response'
request.determine_visibility()
send_now = True
request.secret_address = generate_unique_secret_address(user)
foilaw = None
if data.get('law_type'):
law_type = data['law_type']
foilaw = publicbody.get_applicable_law(law_type=law_type)
if foilaw is None:
foilaw = publicbody.default_law
request.law = foilaw
request.jurisdiction = foilaw.jurisdiction
if send_now:
request.due_date = request.law.calculate_due_date()
if data.get('blocked'):
send_now = False
request.is_blocked = True
self.pre_save_request(request)
save_obj_with_slug(request, count=sequence)
if 'tags' in data and data['tags']:
request.tags.add(*data['tags'])
subject = '%s [#%s]' % (request.title, request.pk)
message = FoiMessage(
request=request,
sent=False,
is_response=False,
sender_user=user,
sender_email=request.secret_address,
sender_name=user.display_name(),
timestamp=now,
status='awaiting_response',
subject=subject,
subject_redacted=redact_subject(subject, user=user)
)
send_address = True
if request.law:
send_address = not request.law.email_only
message.plaintext = construct_initial_message_body(
request,
text=data['body'],
foilaw=foilaw,
full_text=data.get('full_text', False),
send_address=send_address)
message.plaintext_redacted = redact_plaintext(
message.plaintext,
is_response=False,
user=user
)
message.recipient_public_body = publicbody
message.recipient = publicbody.name
message.recipient_email = publicbody.email
FoiRequest.request_to_public_body.send(sender=request)
message.save()
FoiRequest.request_created.send(
sender=request,
reference=data.get('reference', '')
)
if send_now:
message.send()
message.save()
return request
def create_request(self, publicbody, sequence=0):
data = self.data
user = data['user']
now = timezone.now()
request = FoiRequest(
title=data['subject'],
public_body=publicbody,
user=data['user'],
description=data['body'],
public=data['public'],
site=Site.objects.get_current(),
reference=data.get('reference', ''),
first_message=now,
last_message=now,
project=data.get('project'),
project_order=data.get('project_order'),
)
send_now = False
if not user.is_active:
request.status = 'awaiting_user_confirmation'
request.visibility = FoiRequest.INVISIBLE
else:
# TODO add draft
request.status = 'awaiting_response'
request.determine_visibility()
send_now = True
request.secret_address = generate_unique_secret_address(user)
foilaw = None
if data.get('law_type'):
law_type = data['law_type']
foilaw = publicbody.get_applicable_law(law_type=law_type)
if foilaw is None:
foilaw = publicbody.default_law
request.law = foilaw
request.jurisdiction = foilaw.jurisdiction
if send_now:
request.due_date = request.law.calculate_due_date()
if data.get('blocked'):
send_now = False
request.is_blocked = True
self.pre_save_request(request)
self.save_obj_with_slug(request, count=sequence)
if 'tags' in data and data['tags']:
request.tags.add(*data['tags'])
subject = '%s [#%s]' % (request.title, request.pk)
message = FoiMessage(request=request,
sent=False,
is_response=False,
sender_user=user,
sender_email=request.secret_address,
sender_name=user.display_name(),
timestamp=now,
status='awaiting_response',
subject=subject,
subject_redacted=redact_subject(subject,
user=user))
send_address = True
if request.law:
send_address = not request.law.email_only
message.plaintext = construct_initial_message_body(
request,
text=data['body'],
foilaw=foilaw,
full_text=data.get('full_text', False),
send_address=send_address)
message.plaintext_redacted = redact_plaintext(message.plaintext,
is_response=False,
user=user)
message.recipient_public_body = publicbody
message.recipient = publicbody.name
message.recipient_email = publicbody.email
FoiRequest.request_to_public_body.send(sender=request)
message.save()
FoiRequest.request_created.send(sender=request,
reference=data.get('reference', ''))
if send_now:
message.send()
message.save()
return request
def get_description(self):
return redact_plaintext(self.description, is_response=False, user=self.user)
def get_description(self):
return redact_plaintext(self.description, user=self.user)
def process(self, request=None):
foirequest = self.kwargs['foirequest']
publicbody = self.kwargs.get('publicbody', None)
email = self.data
subject = email.subject or ''
subject = subject[:250]
message_id = email.message_id or ''
if message_id:
message_id = message_id[:512]
recipient_name, recipient_email = self.get_recipient_name_email()
is_bounce = email.bounce_info.is_bounce
hide_content = email.is_auto_reply or is_bounce
message = FoiMessage(request=foirequest,
subject=subject,
email_message_id=message_id,
is_response=True,
sender_name=email.from_[0],
sender_email=email.from_[1],
recipient=recipient_name,
recipient_email=recipient_email,
plaintext=email.body,
html=email.html,
content_hidden=hide_content)
if not is_bounce:
if publicbody is None:
publicbody = get_publicbody_for_email(message.sender_email,
foirequest)
if publicbody is None:
publicbody = foirequest.public_body
else:
publicbody = None
message.sender_public_body = publicbody
if (foirequest.law and foirequest.law.mediator
and publicbody == foirequest.law.mediator):
message.content_hidden = True
if email.date is None:
message.timestamp = timezone.now()
else:
message.timestamp = email.date
message.subject_redacted = redact_subject(message.subject,
user=foirequest.user)
message.plaintext_redacted = redact_plaintext(message.plaintext,
is_response=True,
user=foirequest.user)
if is_bounce:
self.process_bounce_message(message)
return
message.save()
foirequest._messages = None
foirequest.status = 'awaiting_classification'
foirequest.save()
self.add_attachments(foirequest, message, email.attachments)
foirequest.message_received.send(sender=foirequest, message=message)
def get_description(self):
return redact_plaintext(self.description, is_response=False, user=self.user)
def highlight_request(message, request):
auth_read = is_authenticated_read(message, request)
real_content = unify(message.get_real_content())
redacted_content = unify(message.get_content())
real_description = unify(message.request.description)
redacted_description = redact_plaintext(unify(message.request.description),
is_response=False,
user=message.sender_user)
if auth_read:
content = real_content
description = real_description
else:
content = redacted_content
description = redacted_description
try:
index = content.index(description)
except ValueError:
return markup_redacted_content(real_content,
redacted_content,
authenticated_read=auth_read,
message_id=message.id)
offset = index + len(description)
html = []
if content[:index]:
html.append(
markup_redacted_content(real_content[:index],
redacted_content[:index],
authenticated_read=auth_read)
# format_html('<div>{pre}</div>', pre=content[:index])
)
html_descr = markup_redacted_content(real_description,
redacted_description,
authenticated_read=auth_read)
html_post = markup_redacted_content(real_content[offset:],
redacted_content[offset:],
authenticated_read=auth_read)
html.append(
format_html(
'''<div class="highlight">{description}</div><div class="collapse" id="letter_end">{post}</div>
<div class="d-print-none"><a data-toggle="collapse" href="#letter_end" aria-expanded="false" aria-controls="letter_end" class="muted hideparent">{show_letter}</a>''',
description=html_descr,
post=html_post,
show_letter=_("[... Show complete request text]"),
))
if content[:index]:
html.append(
format_html('''
{regards}
{message_sender}''',
regards=_('Kind Regards,'),
message_sender=message.sender))
html.append(format_html('</div>'))
return mark_safe(''.join(html))
