def get_subject(self, user=None):
if self.subject_redacted is None:
self.subject_redacted = redact_subject(
self.subject, user=self.request.user
)
self.save()
return self.subject_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_with_request(
plaintext, self.foirequest)
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 make_message(self):
user = self.foirequest.user
address = self.cleaned_data.get('address', '')
if address.strip() and address != user.address:
user.address = address
user.save()
recipient_email = self.cleaned_data["to"]
recipient_info = get_info_for_email(self.foirequest, recipient_email)
recipient_name = recipient_info.name
recipient_pb = recipient_info.publicbody
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)
message = 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(),
)
return message
def save(self):
foirequest = self.foirequest
message = FoiMessage(
request=foirequest,
kind='post',
)
# TODO: Check if timezone support is correct
date = datetime.datetime.combine(self.cleaned_data['date'],
datetime.datetime.now().time())
message.timestamp = timezone.get_current_timezone().localize(date)
message.subject = self.cleaned_data.get('subject', '')
subject_redacted = redact_subject(message.subject,
user=foirequest.user)
message.subject_redacted = subject_redacted
message.plaintext = ''
if self.cleaned_data.get('text'):
message.plaintext = self.cleaned_data.get('text')
message.plaintext_redacted = message.get_content()
message = self.contribute_to_message(message)
message.save()
foirequest.last_message = message.timestamp
foirequest.status = 'awaiting_classification'
foirequest.save()
foirequest.add_postal_reply.send(sender=foirequest)
if self.cleaned_data.get('files'):
self.save_attachments(self.files.getlist('%s-files' % self.prefix),
message)
return message
def save(self):
foirequest = self.foirequest
message = FoiMessage(
request=foirequest,
kind='post',
)
# TODO: Check if timezone support is correct
date = datetime.datetime.combine(self.cleaned_data['date'],
datetime.datetime.now().time())
message.timestamp = timezone.get_current_timezone().localize(date)
message.subject = self.cleaned_data.get('subject', '')
subject_redacted = redact_subject(message.subject, user=foirequest.user)
message.subject_redacted = subject_redacted
message.plaintext = ''
if self.cleaned_data.get('text'):
message.plaintext = self.cleaned_data.get('text')
message.plaintext_redacted = message.get_content()
message = self.contribute_to_message(message)
message.save()
foirequest._messages = None
foirequest.status = 'awaiting_classification'
foirequest.save()
if self.cleaned_data.get('files'):
self.save_attachments(self.files.getlist('%s-files' % self.prefix), message)
if message.is_response:
foirequest.message_received.send(sender=foirequest, message=message)
else:
foirequest.message_sent.send(sender=foirequest, message=message)
return message
def get_subject(self, user=None):
if self.subject_redacted is None:
self.subject_redacted = redact_subject(
self.subject, user=self.request.user
)
self.save()
return self.subject_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 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 set_data_on_message(self, message):
# TODO: Check if timezone support is correct
date = datetime.datetime.combine(self.cleaned_data['date'],
datetime.datetime.now().time())
message.timestamp = timezone.get_current_timezone().localize(date)
message.subject = self.cleaned_data.get('subject', '')
subject_redacted = redact_subject(message.subject,
user=self.foirequest.user)
message.subject_redacted = subject_redacted
message.plaintext = ''
if self.cleaned_data.get('text'):
message.plaintext = self.cleaned_data.get('text')
message.plaintext_redacted = None
message.plaintext_redacted = message.get_content()
return message
def make_message(self):
user = self.foirequest.user
address = self.cleaned_data.get('address', '')
if address.strip() and address != user.address:
user.address = address
user.save()
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 or (
message.sender_public_body and
message.sender_public_body.email
)
recipient_pb = message.sender_public_body
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)
message = 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(),
)
return message
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):
user = self.foirequest.user
address = self.cleaned_data.get('address', '')
if address.strip() and address != user.address:
user.address = address
user.save()
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 or (
message.sender_public_body
and message.sender_public_body.email)
recipient_pb = message.sender_public_body
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)
message = 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(),
)
return message
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 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()
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,
)
is_bounce = email.bounce_info.is_bounce
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
message.content_hidden = self.should_hide_content(
email, foirequest, publicbody)
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_with_request(
message.plaintext,
foirequest,
is_response=True,
)
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 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
