class TaskFilterSet(django_filters.FilterSet):
"""Allows tasks to be filtered by whether they're resolved, and by who resolved them."""
resolved = django_filters.BooleanFilter(label='Show Resolved',
widget=forms.CheckboxInput())
resolved_by = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete'))
assigned = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete'))
deferred = django_filters.BooleanFilter(label='Deferred',
method='filter_deferred',
widget=forms.CheckboxInput())
date_created = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
class Meta:
model = Task
fields = ['resolved', 'resolved_by']
def filter_deferred(self, queryset, name, value):
"""Check if the foia has a tracking number."""
#pylint: disable=unused-argument
if value:
queryset = queryset.get_deferred()
else:
queryset = queryset.get_undeferred()
return queryset
class PortalTaskFilterSet(TaskFilterSet):
"""Allows portal tasks to be filtered by category"""
# pylint: disable=invalid-name
category = django_filters.ChoiceFilter(choices=PORTAL_CATEGORIES)
agency = django_filters.ModelMultipleChoiceFilter(
name='communication__foia__agency',
label='Agency',
queryset=Agency.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('AgencyAutocomplete'))
communication__foia__portal__type = django_filters.ChoiceFilter(
choices=PORTAL_TYPES,
label='Portal Type',
)
resolved = django_filters.BooleanFilter(label='Show Resolved',
widget=forms.CheckboxInput())
resolved_by = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete'))
class Meta:
model = PortalTask
fields = [
'category',
'agency',
'communication__foia__portal__type',
'resolved',
'resolved_by',
]
class ArticleDateRangeFilterSet(django_filters.FilterSet):
"""Allows a list of news items to be filtered by a date range, an author, or many tags."""
projects = django_filters.ModelMultipleChoiceFilter(
name="projects",
queryset=Project.objects.get_public(),
widget=autocomplete_light.MultipleChoiceWidget('ProjectAutocomplete'),
)
authors = django_filters.ModelMultipleChoiceFilter(
queryset=(User.objects.annotate(
article_count=Count('authored_articles')).filter(
article_count__gt=0)),
widget=autocomplete_light.MultipleChoiceWidget(
'UserAuthorAutocomplete'))
pub_date = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
label='Tags',
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
class Meta:
model = Article
fields = ['projects', 'authors', 'pub_date']
class AgencyFOIARequestFilterSet(django_filters.FilterSet):
"""Filters for agency users"""
user = django_filters.ModelMultipleChoiceFilter(
name='composer__user',
label='User',
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserAutocomplete'))
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
label='Tags',
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
date_range = django_filters.DateFromToRangeFilter(
name='communications__datetime',
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
class Meta:
model = FOIARequest
fields = ['user']
class Meta:
model = Project
fields = [
'title',
'summary',
'image',
'tags',
'description',
'contributors',
'requests',
'articles',
]
widgets = {
'description':
forms.Textarea(attrs={'class': 'prose-editor'}),
'contributors':
autocomplete_light.MultipleChoiceWidget('UserAutocomplete'),
'requests':
autocomplete_light.MultipleChoiceWidget('FOIARequestAutocomplete'),
'articles':
autocomplete_light.MultipleChoiceWidget('ArticleAutocomplete'),
}
help_texts = {
'title': 'Changing the title will change the URL of your project.',
}
class MyFOIARequestFilterSet(JurisdictionFilterSet):
"""Allows filtering a request by status, agency, jurisdiction, or tags."""
status = django_filters.ChoiceFilter(choices=BLANK_STATUS)
agency = django_filters.ModelMultipleChoiceFilter(
queryset=Agency.objects.get_approved(),
widget=autocomplete_light.MultipleChoiceWidget('AgencyAutocomplete'))
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
label='Tags',
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
has_embargo = django_filters.BooleanFilter(
name='embargo',
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
has_crowdfund = django_filters.BooleanFilter(
name='crowdfund',
lookup_expr='isnull',
exclude=True,
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
minimum_pages = django_filters.NumberFilter(
name='communications__files__pages',
lookup_expr='gte',
label='Min. Pages',
distinct=True,
widget=forms.NumberInput(),
)
date_range = django_filters.DateFromToRangeFilter(
name='communications__datetime',
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
file_types = django_filters.CharFilter(
label='File Types',
method='filter_file_types',
)
def filter_file_types(self, queryset, name, value):
"""Filter requests with certain types of files"""
#pylint: disable=unused-argument
file_types = value.split(',')
query = Q()
for file_type in file_types:
query |= Q(
communications__files__ffile__endswith=file_type.strip())
return queryset.filter(query)
class Meta:
model = FOIARequest
fields = ['status', 'agency', 'jurisdiction']
class FOIARequestFilterSet(django_filters.FilterSet):
"""Allows filtering a request by status, agency, jurisdiction, user, or tags."""
status = django_filters.ChoiceFilter(choices=BLANK_STATUS)
user = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserAutocomplete')
)
agency = django_filters.ModelMultipleChoiceFilter(
queryset=Agency.objects.get_approved(),
widget=autocomplete_light.MultipleChoiceWidget('AgencyAutocomplete')
)
jurisdiction = django_filters.ModelMultipleChoiceFilter(
queryset=Jurisdiction.objects.filter(hidden=False),
widget=autocomplete_light.MultipleChoiceWidget('JurisdictionAutocomplete')
)
projects = django_filters.ModelMultipleChoiceFilter(
name="projects",
queryset=Project.objects.get_public(),
widget=autocomplete_light.MultipleChoiceWidget('ProjectAutocomplete'),
)
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
has_embargo = django_filters.BooleanFilter(
name='embargo',
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
has_crowdfund = django_filters.BooleanFilter(
name='crowdfund',
lookup_expr='isnull',
exclude=True,
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
minimum_pages = django_filters.NumberFilter(
name='communications__files__pages',
lookup_expr='gte',
label='Min. Pages',
distinct=True,
widget=forms.NumberInput(),
)
date_range = django_filters.DateFromToRangeFilter(
name='communications__date',
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
class Meta:
model = FOIARequest
fields = ['status', 'user', 'agency', 'jurisdiction', 'projects', 'tags']
class ProjectFilterSet(django_filters.FilterSet):
"""Allows a project to be filtered by whether it's featured or by its user."""
contributors = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserAutocomplete'))
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
label='Tags',
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
class Meta:
model = Project
fields = ['contributors']
class AddMembersForm(forms.Form):
"""A form that uses autocomplete to suggest users to add to an organization"""
members = forms.ModelMultipleChoiceField(
required=True,
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserOrganizationAutocomplete')
)
class JurisdictionFilterSet(django_filters.FilterSet):
"""Mix in for including state inclusive jurisdiction filter"""
jurisdiction = django_filters.CharFilter(
widget=autocomplete_light.MultipleChoiceWidget(
'JurisdictionStateInclusiveAutocomplete'),
method='filter_jurisdiction',
label='Jurisdiction',
)
value_format = re.compile(r'\d+-(True|False)')
jurisdiction_field = 'agency__jurisdiction'
def filter_jurisdiction(self, queryset, name, value):
"""Filter jurisdction, allowing for state inclusive searches"""
#pylint: disable=unused-argument
values = self.request.GET.getlist('jurisdiction')
query = Q()
for value in values:
if not self.value_format.match(value):
continue
pk, include_local = value.split('-')
include_local = include_local == 'True'
query |= Q(**{'{}__pk'.format(self.jurisdiction_field): pk})
if include_local:
query |= Q(
**{'{}__parent__pk'.format(self.jurisdiction_field): pk})
return queryset.filter(query)
class QuestionFilterSet(django_filters.FilterSet):
"""Allows question to be filtered by user, date, or if it's unanswered."""
user = django_filters.ModelChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.ChoiceWidget('UserAutocomplete')
)
date = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
unanswered = django_filters.MethodFilter(
action='unanswered_filter',
widget=forms.CheckboxInput()
)
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
def unanswered_filter(self, queryset, value):
"""Filter to show either only unanswered questions or all questions"""
# pylint: disable=no-self-use
if value:
return queryset.filter(answers__isnull=True)
else:
return queryset
class Meta:
model = Question
fields = ['user', 'date']
class ProjectManagerForm(forms.Form):
"""Form for managing a list of projects"""
projects = forms.ModelMultipleChoiceField(
required=False,
queryset=Project.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
'ProjectManagerAutocomplete',
attrs={'placeholder': 'Search for a project'}))
class Meta:
# pylint: disable=too-few-public-methods
model = FOIAMultiRequest
fields = ['title', 'requested_docs', 'agencies']
widgets = {
'title': forms.TextInput(attrs={'placeholder': 'Pick a Title'}),
'agencies': autocomplete_light.MultipleChoiceWidget('AgencyMultiRequestAutocomplete')
}
class FlaggedTaskFilterSet(TaskFilterSet):
"""Allows a flagged task to be filtered by a user."""
user = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserAutocomplete'))
class Meta:
model = FlaggedTask
fields = ['user', 'resolved', 'resolved_by']
class ProxyFilterSet(django_filters.FilterSet):
"""Allows proxies to be filtered by location."""
location = django_filters.ModelMultipleChoiceFilter(
label='State',
queryset=Jurisdiction.objects.filter(level='s', hidden=False),
widget=autocomplete_light.MultipleChoiceWidget('StateAutocomplete'))
class Meta:
model = Profile
fields = ['location']
class ProcessingFOIARequestFilterSet(JurisdictionFilterSet):
"""Allows filtering a request by user, agency, jurisdiction, or tags."""
user = django_filters.ModelMultipleChoiceFilter(
name='composer__user',
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserAutocomplete'))
agency = django_filters.ModelMultipleChoiceFilter(
queryset=Agency.objects.get_approved(),
widget=autocomplete_light.MultipleChoiceWidget('AgencyAutocomplete'))
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
label='Tags',
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
class Meta:
model = FOIARequest
fields = ['user', 'agency', 'jurisdiction']
class StaleAgencyTaskFilterSet(TaskFilterSet):
"""Allows a stale agency task to be filtered by jurisdiction."""
jurisdiction = django_filters.ModelMultipleChoiceFilter(
name='agency__jurisdiction',
queryset=Jurisdiction.objects.filter(hidden=False),
widget=autocomplete_light.MultipleChoiceWidget('JurisdictionAutocomplete')
)
class Meta:
model = StaleAgencyTask
fields = ['jurisdiction', 'resolved', 'resolved_by']
class TaskFilterSet(django_filters.FilterSet):
"""Allows tasks to be filtered by whether they're resolved, and by who resolved them."""
resolved = django_filters.BooleanFilter(widget=forms.CheckboxInput())
resolved_by = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete'))
class Meta:
model = Task
fields = ['resolved', 'resolved_by']
class FailedFaxTaskFilterSet(TaskFilterSet):
"""Allows a failed fax task to be filtered by the agency."""
agency = django_filters.ModelMultipleChoiceFilter(
name='communication__foia__agency',
queryset=Agency.objects.get_approved(),
widget=autocomplete_light.MultipleChoiceWidget('AgencyAutocomplete')
)
class Meta:
model = FailedFaxTask
fields = ['agency', 'resolved', 'resolved_by']
class FOIAAccessForm(forms.Form):
"""Form to add editors or viewers to a request."""
users = forms.ModelMultipleChoiceField(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
'UserRequestSharingAutocomplete'))
access_choices = [
('edit', 'Can Edit'),
('view', 'Can View'),
]
access = forms.ChoiceField(choices=access_choices)
class ProjectManagerForm(forms.Form):
"""Form for managing a list of projects"""
projects = forms.ModelMultipleChoiceField(
required=False,
queryset=Project.objects.none(),
widget=autocomplete_light.MultipleChoiceWidget(
'ProjectManagerAutocomplete',
attrs={'placeholder': 'Search for a project'}))
def __init__(self, *args, **kwargs):
user = kwargs.pop('user')
super(ProjectManagerForm, self).__init__(*args, **kwargs)
self.fields['projects'].queryset = Project.objects.get_manager(user)
class ArticleFilterSet(django_filters.FilterSet):
"""Allows filtering a list of news articles by author or tags"""
projects = django_filters.ModelMultipleChoiceFilter(
name="projects",
queryset=Project.objects.get_public(),
widget=autocomplete_light.MultipleChoiceWidget('ProjectAutocomplete'),
)
authors = django_filters.ModelMultipleChoiceFilter(
queryset=(User.objects.annotate(
article_count=Count('authored_articles')).filter(
article_count__gt=0)),
widget=autocomplete_light.MultipleChoiceWidget(
'UserAuthorAutocomplete'))
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
class Meta:
model = Article
fields = ['projects', 'authors', 'projects', 'tags']
class ReviewAgencyTaskFilterSet(JurisdictionFilterSet, TaskFilterSet):
"""Allows a review agency task to be filtered by jurisdiction."""
jurisdiction_field = 'agency__jurisdiction'
agency = django_filters.ModelMultipleChoiceFilter(
name='agency',
queryset=Agency.objects.exclude(reviewagencytask=None),
widget=autocomplete_light.MultipleChoiceWidget('AgencyAutocomplete'))
class Meta:
model = ReviewAgencyTask
fields = ['jurisdiction', 'agency', 'resolved', 'resolved_by']
class SnailMailTaskFilterSet(TaskFilterSet):
"""Allows snail mail tasks to be filtered by category, as well as the
presence of a tracking number or an agency note."""
category = django_filters.ChoiceFilter(choices=[('', 'All')] +
SNAIL_MAIL_CATEGORIES)
has_tracking_number = django_filters.ChoiceFilter(
method='filter_has_tracking_number',
label='Has tracking number',
choices=BOOLEAN_CHOICES,
)
has_agency_notes = django_filters.ChoiceFilter(
method='filter_has_agency_notes',
label='Has agency notes',
choices=BOOLEAN_CHOICES,
)
resolved = django_filters.BooleanFilter(label='Show Resolved',
widget=forms.CheckboxInput())
resolved_by = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete'))
def blank_choice(self, queryset, name, value):
"""Check if the value is blank"""
# pylint: disable=no-self-use
if value == 'True':
return queryset.exclude(**{name: ''})
elif value == 'False':
return queryset.filter(**{name: ''})
return queryset
def filter_has_tracking_number(self, queryset, name, value):
"""Check if the foia has a tracking number."""
#pylint: disable=unused-argument
return self.blank_choice(queryset, 'communication__foia__tracking_id',
value)
def filter_has_agency_notes(self, queryset, name, value):
"""Check if the agency has notes."""
#pylint: disable=unused-argument
return self.blank_choice(queryset,
'communication__foia__agency__notes', value)
class Meta:
model = SnailMailTask
fields = [
'category',
'has_tracking_number',
'has_agency_notes',
'resolved',
'resolved_by',
]
class FOIAAccessForm(forms.Form):
"""Form to add editors or viewers to a request."""
users = forms.ModelMultipleChoiceField(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
'UserRequestSharingAutocomplete'))
access_choices = [
('edit', 'Can Edit'),
('view', 'Can View'),
]
access = forms.ChoiceField(choices=access_choices)
def __init__(self, *args, **kwargs):
required = kwargs.pop('required', True)
super(FOIAAccessForm, self).__init__(*args, **kwargs)
self.fields['users'].required = required
self.fields['access'].required = required
class ReviewAgencyTaskFilterSet(JurisdictionFilterSet, TaskFilterSet):
"""Allows a review agency task to be filtered by jurisdiction."""
COMPLICATED_LIMIT = 10
jurisdiction_field = 'agency__jurisdiction'
agency = django_filters.ModelMultipleChoiceFilter(
name='agency',
queryset=Agency.objects.exclude(reviewagencytask=None),
widget=autocomplete_light.MultipleChoiceWidget('AgencyAutocomplete'))
federal = django_filters.ChoiceFilter(
method='filter_federal',
label='Federal Agencies',
choices=BOOLEAN_CHOICES,
)
complicated = django_filters.ChoiceFilter(
method='filter_complicated',
label='Complicated Tasks',
choices=BOOLEAN_CHOICES,
)
class Meta:
model = ReviewAgencyTask
fields = ['jurisdiction', 'agency', 'resolved', 'resolved_by']
def filter_federal(self, queryset, name, value):
"""Check if the task is for a federal agency"""
#pylint: disable=unused-argument
if value == 'True':
return queryset.filter(agency__jurisdiction__level='f')
else:
return queryset.exclude(agency__jurisdiction__level='f')
def filter_complicated(self, queryset, name, value):
"""Check if the task is for a federal agency"""
#pylint: disable=unused-argument
queryset = queryset.annotate(c=CountWhen(
agency__foiarequest__status__in=['ack', 'processed', 'appealing']))
if value == 'True':
return queryset.filter(c__gte=self.COMPLICATED_LIMIT)
else:
return queryset.exclude(c__gte=self.COMPLICATED_LIMIT)
class ArticleAuthorFilterSet(django_filters.FilterSet):
"""Allows a list of articles by an author to be filtered by a date range or many tags."""
pub_date = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
class Meta:
model = Article
fields = ['pub_date', 'tags']
class TaskFilterSet(django_filters.FilterSet):
"""Allows tasks to be filtered by whether they're resolved, and by who resolved them."""
resolved = django_filters.BooleanFilter(
label='Show Resolved',
widget=forms.CheckboxInput())
resolved_by = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete')
)
date_created = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
class Meta:
model = Task
fields = ['resolved', 'resolved_by']
class ModuloScriviMessaggioConDestinatariVisibili(
ModuloScriviMessaggioSenzaDestinatari):
destinatari = forms.ModelMultipleChoiceField(
Persona.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
'PersonaAutocompletamento'))
class BaseComposerForm(forms.ModelForm):
"""This form creates and updates FOIA composers"""
title = forms.CharField(
widget=forms.TextInput(attrs={
'placeholder': 'Add a title',
'class': 'submit-required',
}),
max_length=255,
required=False,
help_text='i.e., "John Doe Arrest Report" or "2017 Agency Leadership '
'Calendars". Agencies may see this on emailed requests.',
)
requested_docs = forms.CharField(
widget=forms.Textarea(
attrs={
'placeholder':
'Write a short description of the documents you are '
'looking for. The more specific you can be, the better.',
'class':
'submit-required',
}),
required=False,
)
agencies = ComposerAgencyField(
queryset=Agency.objects.get_approved(),
widget=autocomplete_light.MultipleChoiceWidget(
'AgencyComposerAutocomplete'),
required=False,
help_text='i.e., Police Department, Austin, TX or Office of the '
'Governor, Arkansas')
edited_boilerplate = forms.BooleanField(
required=False,
label='Edit Template Language',
)
embargo = forms.BooleanField(
required=False,
help_text='Embargoing a request keeps it completely private from '
'other users until the embargo date you set. '
'You may change this whenever you want.')
permanent_embargo = forms.BooleanField(required=False)
tags = TaggitField(
widget=TaggitWidget('TagAutocomplete',
attrs={
'placeholder': 'Search tags',
'data-autocomplete-minimum-characters': 1
}),
help_text='Separate tags with commas.',
required=False,
)
parent = forms.ModelChoiceField(
queryset=FOIAComposer.objects.none(),
required=False,
widget=forms.HiddenInput(),
)
action = forms.ChoiceField(
choices=[
('save', 'Save'),
('submit', 'Submit'),
('delete', 'Delete'),
],
widget=forms.HiddenInput(),
)
register_full_name = forms.CharField(
label='Full Name or Handle (Public)',
required=False,
)
register_email = forms.EmailField(label='Email', required=False)
register_newsletter = forms.BooleanField(
initial=True,
required=False,
label='Get MuckRock\'s weekly newsletter with '
'FOIA news, tips, and more',
)
login_username = forms.CharField(label='Username', required=False)
login_password = forms.CharField(label='Password',
widget=forms.PasswordInput(),
required=False)
class Meta:
model = FOIAComposer
fields = [
'title',
'agencies',
'requested_docs',
'edited_boilerplate',
'embargo',
'permanent_embargo',
'tags',
'parent',
'register_full_name',
'register_email',
'register_newsletter',
]
def __init__(self, *args, **kwargs):
if not hasattr(self, '_user'):
self._user = kwargs.pop('user')
self.request = kwargs.pop('request')
super(BaseComposerForm, self).__init__(*args, **kwargs)
if self._user.is_authenticated:
del self.fields['register_full_name']
del self.fields['register_email']
del self.fields['register_newsletter']
del self.fields['login_username']
del self.fields['login_password']
if not self._user.has_perm('foia.embargo_foiarequest'):
del self.fields['embargo']
if not self._user.has_perm('foia.embargo_perm_foiarequest'):
del self.fields['permanent_embargo']
self.fields['parent'].queryset = (FOIAComposer.objects.get_viewable(
self._user).distinct())
self.fields['agencies'].user = self._user
self.fields['agencies'].queryset = (
Agency.objects.get_approved_and_pending(self._user))
def save(self, commit=True, update_owners=True):
"""Update the composer's user and organization"""
# pylint: disable=arguments-differ
if update_owners:
self.instance.user = self.request.user
self.instance.organization = self.request.user.profile.organization
return super(BaseComposerForm, self).save(commit)
def clean_register_email(self):
"""Do a case insensitive uniqueness check"""
email = self.cleaned_data['register_email']
if email and User.objects.filter(email__iexact=email).exists():
raise forms.ValidationError(
'User with this email already exists. Please login first.')
return email
def clean_title(self):
"""Make sure we have a non-blank(ish) title"""
title = self.cleaned_data['title'].strip()
if title:
return title
else:
return 'Untitled'
def clean_agencies(self):
"""Remove exempt agencies"""
return [a for a in self.cleaned_data['agencies'] if not a.exempt]
def clean(self):
"""Check cross field dependencies"""
cleaned_data = super(BaseComposerForm, self).clean()
if cleaned_data.get('action') == 'submit':
for field in ['title', 'requested_docs', 'agencies']:
if not self.cleaned_data.get(field):
self.add_error(
field,
'This field is required when submitting',
)
if cleaned_data.get('permanent_embargo'):
cleaned_data['embargo'] = True
if not self._user.is_authenticated:
register = (cleaned_data.get('register_full_name')
and cleaned_data.get('register_email'))
login = (cleaned_data.get('login_username')
and cleaned_data.get('login_password'))
if not register and not login:
raise forms.ValidationError(
'You must supply either registration information or '
'login information')
if login:
try:
self._user = mini_login(
self.request,
cleaned_data.get('login_username'),
cleaned_data.get('login_password'),
)
except HTTPError:
raise forms.ValidationError(
'Please enter a correct username and password')
return cleaned_data
