class MRFilterForm(forms.Form):
"""A generic class to filter a list of items"""
user = forms.ModelChoiceField(
required=False,
queryset=User.objects.all(),
widget=autocomplete_light.ChoiceWidget(
'UserAutocomplete',
attrs={'placeholder': 'All Users'}))
agency = forms.ModelChoiceField(
required=False,
queryset=Agency.objects.all(),
widget=autocomplete_light.ChoiceWidget(
'AgencyAutocomplete',
attrs={'placeholder': 'All Agencies'}))
jurisdiction = forms.ModelChoiceField(
required=False,
queryset=Jurisdiction.objects.all(),
widget=autocomplete_light.ChoiceWidget(
'JurisdictionAutocomplete',
attrs={'placeholder': 'All Jurisdictions'}))
tags = TaggitField(widget=TaggitWidget(
'TagAutocomplete',
attrs={
'placeholder': 'All Tags (comma separated)',
'data-autocomplete-minimum-characters': 1}))
class FoiaMachineRequestFilter(django_filters.FilterSet):
"""Allows FOIA Machine Requests to be filtered by their status, jurisdiction, or agency."""
jurisdiction = django_filters.ModelChoiceFilter(
queryset=Jurisdiction.objects.filter(hidden=False),
widget=autocomplete_light.ChoiceWidget('JurisdictionAutocomplete'))
agency = django_filters.ModelChoiceFilter(
queryset=Agency.objects.get_approved(),
widget=autocomplete_light.ChoiceWidget('AgencyAutocomplete'))
class Meta:
model = FoiaMachineRequest
fields = ['status', 'jurisdiction', 'agency']
class ProfileSettingsForm(forms.ModelForm):
"""A form for updating user information"""
first_name = forms.CharField(max_length=30)
last_name = forms.CharField(max_length=30)
location = forms.ModelChoiceField(
required=False,
queryset=Jurisdiction.objects.all(),
widget=autocomplete_light.ChoiceWidget('JurisdictionLocalAutocomplete')
)
class Meta():
model = Profile
fields = ['first_name', 'last_name', 'avatar', 'twitter', 'location']
def clean_twitter(self):
"""Stripe @ from beginning of Twitter name, if it exists."""
twitter = self.cleaned_data['twitter']
return twitter.split('@')[-1]
def save(self, commit=True):
"""Modifies associated User model."""
profile = super(ProfileSettingsForm, self).save(commit)
profile.user.first_name = self.cleaned_data['first_name']
profile.user.last_name = self.cleaned_data['last_name']
profile.user.save()
return profile
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 BulkNewAgencyTaskForm(forms.Form):
"""Form for creating blank new agencies"""
name = forms.CharField(max_length=255)
jurisdiction = forms.ModelChoiceField(
widget=autocomplete_light.ChoiceWidget('JurisdictionAutocomplete'),
queryset=Jurisdiction.objects.all(),
)
class Meta:
model = Organization
fields = [
'name', 'owner', 'monthly_requests', 'monthly_cost', 'max_users'
]
widgets = {
'owner': autocomplete_light.ChoiceWidget('UserAutocomplete')
}
class AgencyFilterSet(django_filters.FilterSet):
"""Allows agencies to be filtered by jurisdiction."""
jurisdiction = django_filters.ModelChoiceFilter(
queryset=Jurisdiction.objects.filter(hidden=False),
widget=autocomplete_light.ChoiceWidget('JurisdictionAutocomplete'))
class Meta:
model = Agency
fields = ['jurisdiction']
class Meta:
model = OnTheFly
fields = ('name', 'other_fly')
widgets = {
'other_fly':
autocomplete_light.ChoiceWidget(
'OnTheFlyAutocomplete',
widget_attrs={'data-widget-bootstrap': 'onthefly-widget'})
}
class GroupObjectPermissionAdminForm(forms.ModelForm):
group = al.ModelChoiceField("GroupAutocomplete")
permission = PermissionModelChoiceField(
queryset=Permission.objects.select_related("content_type").filter(
reduce(operator.or_, PERMISSION_FILTER)
),
label="Permission",
empty_label="Select A Permssion",
)
object_id = forms.CharField(
widget=al.ChoiceWidget("IPAMObjectsAutoComplete"), label="Object"
)
def __init__(self, *args, **kwargs):
super(GroupObjectPermissionAdminForm, self).__init__(*args, **kwargs)
if self.instance.pk:
self.fields["object_id"].initial = "%s-%s" % (
self.instance.content_type.pk,
self.instance.object_pk,
)
def clean(self):
cleaned_data = super(GroupObjectPermissionAdminForm, self).clean()
content_type_id = (
cleaned_data["object_id"].split("-")[0]
if cleaned_data.get("object_id")
else None
)
object_pk = (
cleaned_data["object_id"].split("-")[1]
if cleaned_data.get("object_id")
else None
)
group = cleaned_data["group"] if cleaned_data.get("group") else None
permission = (
cleaned_data["permission"] if cleaned_data.get("permission") else None
)
if content_type_id and object_pk and group and permission:
try:
GroupObjectPermission.objects.get(
group=group,
permission=permission,
content_type_id=content_type_id,
object_pk=object_pk,
)
except GroupObjectPermission.DoesNotExist:
pass
else:
raise ValidationError(
"Group Permission with this Group, Permission, And Object already exist."
)
class Meta:
model = GroupObjectPermission
exclude = ("content_type", "object_pk")
class JurisdictionFilterSet(django_filters.FilterSet):
"""Allows jurisdiction to be filtered by level of government and state."""
level = django_filters.ChoiceFilter(choices=LEVELS)
parent = django_filters.ModelChoiceFilter(
label='State',
queryset=Jurisdiction.objects.filter(level='s', hidden=False),
widget=autocomplete_light.ChoiceWidget('StateAutocomplete'))
class Meta:
model = Jurisdiction
fields = ['level', 'parent']
class TaskFilterForm(MRFilterForm):
"""Extends MRFilterForm with a 'show resolved' filter"""
show_resolved = forms.BooleanField(label='Show resolved', required=False)
resolved_by = forms.ModelChoiceField(
label='Resolved by',
required=False,
queryset=User.objects.all(),
widget=autocomplete_light.ChoiceWidget(
'UserAutocomplete',
attrs={'placeholder': 'Resolved by'}
)
)
class JurisdictionFilterForm(MRFilterForm):
"""Adds a level filter to MRFilterForm"""
levels = (
('f', 'Federal'),
('s', 'State'),
('l', 'Local'),
)
level = forms.ChoiceField(choices=levels, widget=forms.RadioSelect)
parent = forms.ModelChoiceField(required=False,
queryset=Jurisdiction.objects.all(),
widget=autocomplete_light.ChoiceWidget(
'StateAutocomplete',
attrs={'placeholder': 'All States'}))
class ExemptionFilterSet(django_filters.FilterSet):
"""Allows exemptions to be filtered by jurisdiction"""
jurisdiction = django_filters.ModelChoiceFilter(
label='Jurisdiction',
queryset=Jurisdiction.objects.filter(
level__in=('s', 'f'),
hidden=False,
),
widget=autocomplete_light.ChoiceWidget('FederalStateAutocomplete'))
class Meta:
model = Exemption
fields = ['jurisdiction']
class UserObjectPermissionForm(forms.ModelForm):
permission = PermissionModelChoiceField(
queryset=Permission.objects.select_related("content_type").filter(
reduce(operator.or_, PERMISSION_FILTER)
),
label="Permission",
empty_label="Select A Permssion",
)
object_id = forms.CharField(
widget=al.ChoiceWidget("IPAMObjectsAutoComplete"), label="Object"
)
class Meta:
model = UserObjectPermission
exclude = ("content_type", "object_pk", "user")
class ProfileSettingsForm(forms.ModelForm):
"""A form for updating user information"""
location = forms.ModelChoiceField(required=False,
queryset=Jurisdiction.objects.all(),
widget=autocomplete_light.ChoiceWidget(
'JurisdictionLocalAutocomplete'))
class Meta():
model = Profile
fields = ['twitter', 'location']
def clean_twitter(self):
"""Stripe @ from beginning of Twitter name, if it exists."""
twitter = self.cleaned_data['twitter']
return twitter.split('@')[-1]
class CaseGroupPermissionForm(HelperMixin, forms.Form):
action_text = _('Grant')
user = forms.ModelChoiceField(queryset=None,
required=True,
widget=autocomplete_light.ChoiceWidget('UserAutocomplete'),
label=_("User"))
group = forms.ModelChoiceField(queryset=PermissionGroup.objects.all(),
label=_("Permissions group"))
def __init__(self, user, case=None, *args, **kwargs):
self.case = case
self.user = user
super(CaseGroupPermissionForm, self).__init__(*args, **kwargs)
self.fields['user'].queryset = get_user_model().objects.for_user(self.user)
self.helper.form_class = 'form-inline'
self.helper.layout.append(Submit('grant', _('Grant')))
self.helper.form_action = reverse('cases:permission_grant',
kwargs={'pk': str(self.case.pk)})
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.BooleanFilter(name='answers',
lookup_expr='isnull',
widget=forms.CheckboxInput())
class Meta:
model = Question
fields = ['user', 'date']
class CrowdsourceFilterSet(django_filters.FilterSet):
"""Filtering for crowdsources for admins"""
status = django_filters.ChoiceFilter(
choices=(
('draft', 'Draft'),
('open', 'Open'),
('close', 'Closed'),
)
)
is_staff = django_filters.BooleanFilter(
name='user__is_staff',
label='Staff Owned',
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
user = django_filters.ModelChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.ChoiceWidget('UserAutocomplete')
)
class Meta:
model = Crowdsource
fields = ['status', 'user']
class UserObjectPermissionAdminForm(forms.ModelForm):
user = al.ModelChoiceField("UserAutocomplete")
permission = PermissionModelChoiceField(
queryset=Permission.objects.select_related("content_type").filter(
reduce(operator.or_, PERMISSION_FILTER)
),
label="Permission",
empty_label="Select A Permssion",
)
object_id = forms.CharField(
widget=al.ChoiceWidget("IPAMObjectsAutoComplete"), label="Object"
)
def __init__(self, *args, **kwargs):
super(UserObjectPermissionAdminForm, self).__init__(*args, **kwargs)
if self.instance.pk:
self.fields["object_id"].initial = "%s-%s" % (
self.instance.content_type.pk,
self.instance.object_pk,
)
class Meta:
model = UserObjectPermission
exclude = ("content_type", "object_pk")
class NewCaseForm(SingleButtonMixin, PartialMixin, GIODOMixin, autocomplete_light.ModelForm):
attachment_cls = Attachment
attachment_rel_field = 'letter'
attachment_file_field = 'attachment'
action_text = _("Report case")
client = forms.ModelChoiceField(queryset=get_user_model().objects.none(),
label=_("Client"),
required=False,
help_text=CLIEN_FIELD_TEXT,
widget=autocomplete_light.ChoiceWidget('UserAutocomplete'))
email = forms.EmailField(required=False,
label=_("User e-mail"))
email_registration = UserEmailField(required=True,
help_text=EMAIL_TEXT,
label=_("E-mail"))
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user')
super(NewCaseForm, self).__init__(*args, **kwargs)
self.helper.form_tag = False
self.helper.form_method = 'post'
self.fields['name'].help_text = CASE_NAME_TEXT
if self._is_super_staff():
self.fields['client'].initial = self.user
self.fields['client'].queryset = (get_user_model().objects.
for_user(self.user).all())
else:
del self.fields['client']
del self.fields['email']
if not self.user.is_anonymous(): # is registered
del self.fields['email_registration']
if not (self.user.is_anonymous() or self._is_super_staff()):
del self.fields['giodo']
elif self._is_super_staff():
self.fields['giodo'].required = False
def _is_super_staff(self):
return self.user.has_perm('cases.can_select_client')
def clean(self):
if self.user.has_perm('cases.can_select_client') and \
not (self.cleaned_data.get('email') or self.cleaned_data.get('client')):
raise ValidationError(_("Have to enter user email or select a client"))
return super(NewCaseForm, self).clean()
def get_user(self):
if self.user.is_anonymous():
return get_user_model().objects.get_by_email_or_create(
self.cleaned_data['email_registration'])
return self.user
def get_client(self, user):
if self.user.is_anonymous() and self.cleaned_data['email_registration']:
return user
if not self.user.has_perm('cases.can_select_client'):
return self.user
elif self.cleaned_data['client']:
return self.cleaned_data['client']
elif self.cleaned_data['email']:
return get_user_model().objects.get_by_email_or_create(self.cleaned_data['email'])
return self.user
def get_case(self, client, user):
case = Case(name=self.cleaned_data['name'], created_by=user, client=client)
case.save()
return case
