def redact_subject(self):
content = self.subject
if self.request.user:
account_service = AccountService(self.request.user)
content = account_service.apply_message_redaction(content)
content = redact_content(content)
return content[:255]
def add_attachments(self, foirequest, message, attachments):
account_service = AccountService(foirequest.user)
names = set()
for i, attachment in enumerate(attachments):
att = FoiAttachment(
belongs_to=message,
name=attachment.name,
size=attachment.size,
filetype=attachment.content_type
)
if not att.name:
att.name = _("attached_file_%d") % i
# Translators: replacement for person name in filename
repl = str(_('NAME'))
att.name = account_service.apply_name_redaction(att.name, repl)
att.name = re.sub(r'[^A-Za-z0-9_\.\-]', '', att.name)
att.name = att.name[:250]
# Assure name is unique
if att.name in names:
att.name = add_number_to_filename(att.name, i)
names.add(att.name)
if foirequest.not_publishable:
att.can_approve = False
attachment._committed = False
att.file = File(attachment)
att.save()
if att.can_convert_to_pdf():
self.trigger_convert_pdf(att.id)
def add_attachments(self, foirequest, message, attachments):
account_service = AccountService(foirequest.user)
names = set()
for i, attachment in enumerate(attachments):
att = FoiAttachment(belongs_to=message,
name=attachment.name,
size=attachment.size,
filetype=attachment.content_type)
if not att.name:
att.name = _("attached_file_%d") % i
# Translators: replacement for person name in filename
repl = str(_('NAME'))
att.name = account_service.apply_name_redaction(att.name, repl)
att.name = re.sub(r'[^A-Za-z0-9_\.\-]', '', att.name)
att.name = att.name[:250]
# Assure name is unique
if att.name in names:
att.name = add_number_to_filename(att.name, i)
names.add(att.name)
attachment._committed = False
att.file = File(attachment)
att.save()
def process(self, request=None):
data = self.data
user = data['user']
user_created = False
if not user.is_authenticated:
user_created = True
user, password = AccountService.create_user(**self.data)
self.data['user'] = user
if request is not None:
extra = registry.run_hook('pre_request_creation',
request,
user=user,
data=data)
if extra is not None:
data.update(extra)
if len(self.data['publicbodies']) > 1:
foi_object = self.create_project()
else:
foi_object = self.create_request(self.data['publicbodies'][0])
if user_created:
AccountService(user).send_confirmation_mail(
request_id=foi_object.pk,
password=password,
reference=foi_object.reference,
redirect_url=self.data.get('redirect_url'))
self.post_creation(foi_object)
return foi_object
class PublicBodyUploader:
def __init__(self, foirequest, token):
self.foirequest = foirequest
self.token = token
self.account_service = AccountService(foirequest.user)
def create_upload_message(self, upload_list):
message = FoiMessage.objects.create(
request=self.foirequest,
timestamp=timezone.now(),
is_response=True,
plaintext='',
plaintext_redacted='',
html='',
kind='upload',
sender_public_body=self.foirequest.public_body
)
self.foirequest.message_received.send(
sender=self.foirequest, message=message
)
self.names = set()
att_count = 0
for upload_url in upload_list:
att = self.create_attachment(message, upload_url)
if att:
att_count += 1
return att_count
def create_attachment(self, message, upload_url):
upload = Upload.objects.get_by_url(
upload_url, token=self.token
)
if upload is None:
return
name = self.account_service.apply_name_redaction(
upload.filename, str(_('NAME'))
)
name = make_name_unique(name, self.names)
self.names.add(name)
att = FoiAttachment.objects.create(
belongs_to=message,
name=name,
size=upload.size,
filetype=upload.content_type,
can_approve=True,
approved=False,
pending=True,
)
upload.ensure_saving()
upload.save()
transaction.on_commit(
lambda: move_upload_to_attachment.delay(
att.id, upload.id
)
)
return att
def redact_plaintext(self):
content = self.plaintext
content = redact_content(content)
greeting_replacement = str(_("<< Greeting >>"))
if not settings.FROIDE_CONFIG.get('public_body_officials_public'):
if self.is_response:
if settings.FROIDE_CONFIG.get('closings'):
content = remove_closing(
settings.FROIDE_CONFIG['closings'], content)
else:
if settings.FROIDE_CONFIG.get('greetings'):
content = replace_custom(
settings.FROIDE_CONFIG['greetings'],
greeting_replacement, content)
if self.request.user:
account_service = AccountService(self.request.user)
content = account_service.apply_message_redaction(content)
return content
def process(self, request=None):
data = self.data
user = data['user']
user_created = False
user_auth = user.is_authenticated
if not user_auth:
user, user_created = AccountService.create_user(
**self.data
)
self.data['user'] = user
if not user_created and not user_auth:
return self.create_token_draft(user)
if request is not None:
extra = registry.run_hook('pre_request_creation',
request,
user=user,
data=data
)
if extra is not None:
data.update(extra)
if len(self.data['publicbodies']) > 1:
foi_object = self.create_project()
else:
foi_object = self.create_request(self.data['publicbodies'][0])
if user_created:
AccountService(user).send_confirmation_mail(
request_id=foi_object.pk,
reference=foi_object.reference,
redirect_url=self.data.get('redirect_url')
)
self.post_creation(foi_object)
return foi_object
def create_token_draft(self, user):
'''
User is not authenticated, but has given valid email.
Create a draft object with a token, send token to email.
'''
from .views import MakeRequestView
data = self.data
additional_kwargs = dict(
subject=data.get('subject', ''),
body=data.get('body', ''),
full_text=data.get('full_text', False),
public=data['public'],
reference=data.get('reference', ''),
law_type=data.get('law_type', ''),
)
flag_keys = set(MakeRequestView.FORM_CONFIG_PARAMS) | {'redirect_url'}
flags = {k: v for k, v in data.items() if k in flag_keys}
additional_kwargs['flags'] = flags
draft = RequestDraft.objects.create(user=None,
token=uuid.uuid4(),
**additional_kwargs)
draft.publicbodies.set(data['publicbodies'])
claim_url = reverse('foirequest-claim_draft',
kwargs={'token': draft.token})
AccountService(user).send_confirm_action_mail(
claim_url,
draft.subject,
reference=draft.reference,
redirect_url=self.data.get('redirect_url'))
return draft
def add_message_from_email(self, email, publicbody=None):
from .message import FoiMessage
from .attachment import FoiAttachment
message = FoiMessage(request=self)
message.subject = email['subject'] or ''
message.subject = message.subject[:250]
message_id = email.get('message_id', '')
if message_id:
message.email_message_id = message_id[:512]
message.is_response = True
message.sender_name = email['from'][0]
message.sender_email = email['from'][1]
if publicbody is None:
publicbody = get_publicbody_for_email(message.sender_email, self)
if publicbody is None:
publicbody = self.public_body
message.sender_public_body = publicbody
if message.sender_public_body == self.law.mediator:
message.content_hidden = True
if email['date'] is None:
message.timestamp = timezone.now()
else:
message.timestamp = email['date']
message.recipient_email = self.secret_address
message.recipient = self.user.display_name()
message.plaintext = email['body']
message.html = email['html']
if not message.plaintext and message.html:
message.plaintext = strip_tags(email['html'])
message.subject_redacted = message.redact_subject()[:250]
message.plaintext_redacted = message.redact_plaintext()
message.save()
self._messages = None
self.status = 'awaiting_classification'
self.last_message = message.timestamp
self.save()
has_pdf = False
account_service = AccountService(self.user)
for i, attachment in enumerate(email['attachments']):
att = FoiAttachment(belongs_to=message,
name=attachment.name,
size=attachment.size,
filetype=attachment.content_type)
if not att.name:
att.name = _("attached_file_%d") % i
# Translators: replacement for person name in filename
repl = str(_('NAME'))
att.name = account_service.apply_name_redaction(att.name, repl)
att.name = re.sub(r'[^A-Za-z0-9_\.\-]', '', att.name)
att.name = att.name[:255]
if att.name.endswith('pdf') or 'pdf' in att.filetype:
has_pdf = True
attachment._committed = False
att.file = File(attachment)
att.save()
if (has_pdf and settings.FROIDE_CONFIG.get(
"mail_managers_on_pdf_attachment", False)):
mail_managers(_('Message contains PDF'),
self.get_absolute_domain_url())
self.message_received.send(sender=self, message=message)
def __init__(self, foirequest, token):
self.foirequest = foirequest
self.token = token
self.account_service = AccountService(foirequest.user)
def confirm_donor_email(donor, request=None):
if request and request.user.is_staff:
# Don't trigger things as staff
return
is_auth = request and request.user.is_authenticated
donor.email_confirmed = timezone.now()
donor.save()
logger.info('Donor confirmed %s', donor.id)
# Try finding existing user via email
new_user = False
user = None
if not donor.user:
users = User.objects.filter(
email__iexact=donor.email,
is_active=True
)
if len(users) > 1:
user = users[0]
new_user = True
else:
user = None
if user is not None:
donor = assign_and_merge_donors(donor, user)
if request and is_auth:
auth.login(request, user)
elif donor.become_user and not is_auth:
# Create user
new_user = True
user, created = AccountService.create_user(
user_email=donor.email,
first_name=donor.first_name,
last_name=donor.last_name,
address=donor.get_full_address(),
private=True
)
AccountService(user)._confirm_account()
donor.user = user
donor.save()
logger.info('Donor user created %s for donor %s', user.id, donor.id)
# Login new user
if request:
auth.login(request, user)
else:
user = donor.user
if 'newsletter' in request.GET:
donor.contact_allowed = True
donor.save()
if donor.contact_allowed:
# Subscribe to normal and donor newsletter
# TODO: subscribe email address / if different from user?
subscribe_to_default_newsletter(
donor.email, user=user,
name=donor.get_full_name(),
email_confirmed=True
)
subscribe_donor_newsletter(donor, email_confirmed=True)
if new_user:
connect_payments_to_user(donor)
