def __init__(self, *args, **kwargs):
self.list_display = list(self.list_display) + [
u'assigned_to_column',
u'action_column',
]
self.list_filter = list(self.list_filter) + [
simple_list_filter_factory(u'Assigned', u'assigned', [
(u'1', u'Yes', lambda qs: qs.filter(inforequest__isnull=False).distinct()),
(u'0', u'No', lambda qs: qs.filter(inforequest__isnull=True)),
]),
simple_list_filter_factory(u'Action', u'action', [
(u'1', u'Yes', lambda qs: qs.filter(action__isnull=False).distinct()),
(u'0', u'No', lambda qs: qs.filter(action__isnull=True)),
]),
]
self.search_fields = list(self.search_fields) + [
u'=inforequest__pk',
u'=action__pk',
]
self.fieldsets[0][1][u'fields'] = list(self.fieldsets[0][1][u'fields']) + [
u'assigned_to_field',
u'action_field',
]
self.readonly_fields = list(self.readonly_fields) + [
u'assigned_to_field',
u'action_field',
]
super(MessageAdminMixin, self).__init__(*args, **kwargs)
class ObligeeAdmin(SimpleHistoryAdmin):
list_display = [
u'obligee_column',
u'name',
u'emails',
u'status',
u'branch_count_column',
]
list_filter = [
simple_list_filter_factory(u'Branches', u'branches', [
(u'1', u'With', lambda qs: qs.filter(branch__count__gt=0)),
(u'0', u'Without', lambda qs: qs.filter(branch__count=0)),
]),
u'status',
]
search_fields = [
u'=id',
u'name',
u'emails',
]
ordering = [u'name', u'pk']
@decorate(short_description=u'Obligee')
@decorate(admin_order_field=u'pk')
def obligee_column(self, obligee):
return admin_obj_format(obligee, link=False)
@decorate(short_description=u'Branches')
@decorate(admin_order_field=u'branch__count')
def branch_count_column(self, obligee):
return obligee.branch__count
fields = [
u'name',
u'street',
u'city',
u'zip',
u'emails',
u'status',
]
inlines = [
ObligeeAdminBranchInline,
]
def formfield_for_dbfield(self, db_field, **kwargs):
field = super(ObligeeAdmin, self).formfield_for_dbfield(db_field, **kwargs)
# Use textarea for emails
if db_field.name == u'emails':
field.widget = admin.widgets.AdminTextareaWidget()
return field
def has_delete_permission(self, request, obj=None):
if obj is None:
return True
return not obj.branch_set.exists()
def get_queryset(self, request):
queryset = super(ObligeeAdmin, self).get_queryset(request)
queryset = queryset.annotate(Count(u'branch'))
return queryset
class InvitationAdmin(admin.ModelAdmin):
date_hierarchy = u'created'
list_display = [
u'id',
u'email',
u'created',
decorate(
lambda o: u'Accepted' if o.is_accepted else u'Expired'
if o.is_expired else u'Pending' if o.is_pending else u'--',
short_description=u'State',
),
decorate(
lambda o: admin_obj_format(
o.invitor, u'{obj.first_name} {obj.last_name} <{obj.email}>'),
short_description=u'Invitor',
admin_order_field=u'invitor__email',
),
decorate(
lambda o: admin_obj_format(
o.invitee, u'{obj.first_name} {obj.last_name} <{obj.email}>'),
short_description=u'Invitee',
admin_order_field=u'invitee__email',
),
]
list_filter = [
u'created',
simple_list_filter_factory(u'State', u'state', [
(u'1', u'Accepted', lambda qs: qs.accepted()),
(u'2', u'Expired', lambda qs: qs.expired()),
(u'3', u'Pending', lambda qs: qs.pending()),
]),
]
search_fields = [
u'=id',
u'email',
u'invitor__first_name',
u'invitor__last_name',
u'invitor__email',
u'invitee__first_name',
u'invitee__last_name',
u'invitee__email',
]
ordering = [
u'-created',
u'-id',
]
exclude = []
readonly_fields = []
raw_id_fields = [
u'invitor',
u'invitee',
u'message',
]
inlines = []
def get_queryset(self, request):
queryset = super(InvitationAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'invitor')
queryset = queryset.select_related(u'invitee')
return queryset
class MessageAdmin(admin.ModelAdmin):
date_hierarchy = u'created'
list_display = [
u'id',
u'type',
decorate(
lambda o: o.from_formatted,
short_description=u'From',
admin_order_field=u'from_mail',
),
decorate(
lambda o: u'; '.join(u'{}: {}'.format(k, v) for k, v in [
(u'To', o.to_formatted),
(u'Cc', o.cc_formatted),
(u'Bcc', o.bcc_formatted),
] if v),
short_description=u'Recipients',
),
u'created',
u'processed',
]
list_filter = [
u'type',
u'created',
simple_list_filter_factory(u'Processed', u'processed', [
(u'1', u'Yes', lambda qs: qs.processed()),
(u'0', u'No', lambda qs: qs.not_processed()),
]),
]
search_fields = [
u'=id',
u'from_name',
u'from_mail',
u'recipient__name',
u'recipient__mail',
u'received_for',
]
ordering = [
u'-created',
u'-id',
]
exclude = [
]
readonly_fields = [
]
raw_id_fields = [
]
inlines = [
RecipientInline,
]
def get_queryset(self, request):
queryset = super(MessageAdmin, self).get_queryset(request)
queryset = queryset.prefetch_related(Message.prefetch_recipients())
return queryset
class BranchAdmin(admin.ModelAdmin):
date_hierarchy = None
list_display = [
u'id',
decorate(
lambda o: admin_obj_format(o.inforequest),
short_description=u'Inforequest',
admin_order_field=u'inforequest',
),
decorate(
lambda o: admin_obj_format(o.obligee, u'{obj.name}'),
short_description=u'Obligee',
admin_order_field=u'obligee',
),
decorate(
lambda o: admin_obj_format(o.advanced_by),
short_description=u'Advanced by',
admin_order_field=u'advanced_by',
),
]
list_filter = [
simple_list_filter_factory(u'Advanced', u'advanced', [
(u'1', u'Yes', lambda qs: qs.advanced()),
(u'2', u'No', lambda qs: qs.main()),
]),
]
search_fields = [
u'=id',
u'=inforequest__id',
u'obligee__name',
u'=advanced_by__id',
]
ordering = [
u'id',
]
exclude = []
readonly_fields = []
raw_id_fields = [
u'inforequest',
u'obligee',
u'historicalobligee',
u'advanced_by',
]
inlines = []
def get_queryset(self, request):
queryset = super(BranchAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'inforequest')
queryset = queryset.select_related(u'obligee')
queryset = queryset.select_related(u'advanced_by')
return queryset
class ProfileAdmin(admin.ModelAdmin):
date_hierarchy = None
list_display = [
u'id',
decorate(
lambda o: admin_obj_format(
o.user, u'{obj.first_name} {obj.last_name} <{obj.email}>'),
short_description=u'User',
admin_order_field=u'user__email',
),
u'street',
u'city',
u'zip',
decorate(
lambda o: o.undecided_emails_count,
short_description=u'Undecided E-mails',
admin_order_field=u'undecided_emails_count',
),
]
list_filter = [
simple_list_filter_factory(u'Undecided E-mail', u'undecided', [
(u'1', u'With',
lambda qs: qs.filter(undecided_emails_count__gt=0)),
(u'0', u'Without', lambda qs: qs.filter(undecided_emails_count=0)),
]),
]
search_fields = [
u'=id',
u'user__first_name',
u'user__last_name',
u'user__email',
u'street',
u'city',
u'zip',
]
ordering = [
u'id',
]
exclude = []
readonly_fields = []
raw_id_fields = [
u'user',
]
inlines = []
def get_queryset(self, request):
queryset = super(ProfileAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'user')
queryset = queryset.select_undecided_emails_count()
return queryset
def __init__(self, *args, **kwargs):
self.list_display = list(self.list_display) + [
u'inforequest_count_column',
]
self.list_filter = list(self.list_filter) + [
simple_list_filter_factory(u'Inforequests', u'inforequests', [
(u'1', u'With', lambda qs: qs.filter(inforequest__count__gt=0)),
(u'0', u'Without', lambda qs: qs.filter(inforequest__count=0)),
]),
]
self.inlines = list(self.inlines) + [
UserAdminMixinInforequestInline,
UserAdminMixinInforequestDraftInline,
]
super(UserAdminMixin, self).__init__(*args, **kwargs)
class InvitationAdmin(AdminLiveFieldsMixin, admin.ModelAdmin):
list_display = [
u'invitation_column',
u'email',
u'accepted_column',
u'created',
u'invitor_column',
u'invitee_column',
]
list_filter = [
u'created',
simple_list_filter_factory(u'Status', u'status', [
(u'2', u'Expired', lambda qs: qs.expired()),
(u'1', u'Accepted', lambda qs: qs.accepted()),
(u'0', u'Pending', lambda qs: qs.pending()),
]),
]
search_fields = [
u'=id',
u'email',
u'invitor__first_name',
u'invitor__last_name',
u'invitor__email',
u'invitee__first_name',
u'invitee__last_name',
u'invitee__email',
]
ordering = [u'-created', u'-pk']
@decorate(short_description=u'Invitation')
@decorate(admin_order_field=u'pk')
def invitation_column(self, invitation):
return admin_obj_format(invitation, link=False)
@decorate(short_description=u'Accepted')
@decorate(boolean=True)
def accepted_column(self, invitation):
if invitation.is_accepted:
return True
elif invitation.is_expired:
return False
else:
return None
@decorate(short_description=u'Invitor')
@decorate(admin_order_field=u'invitor__email')
def invitor_column(self, invitation):
user = invitation.invitor
return admin_obj_format(user, u'{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'Invitee')
@decorate(admin_order_field=u'invitee__email')
def invitee_column(self, invitation):
user = invitation.invitee
return admin_obj_format(user, u'{obj.first_name} {obj.last_name} <{obj.email}>')
form_add = InvitationAdminAddForm
form_change = forms.ModelForm
fieldsets = [
(None, {
u'classes': [u'wide'],
u'fields': [
u'email',
u'accepted_column',
u'accept_url',
u'invitor',
u'invitor_details_live',
u'invitee',
u'invitee_details_live',
],
}),
(u'Advanced', {
u'classes': [u'wide', u'collapse'],
u'fields': [
u'created',
u'valid_to',
u'accepted',
u'message',
u'message_details_live',
],
}),
]
fieldsets_add = [
(None, {
u'fields': [
u'email',
u'validity',
u'invitor',
u'invitor_details_live',
u'send_email',
],
}),
]
fieldsets_bulk_add = [
(None, {
u'fields': [
u'emails',
u'validity',
u'invitor',
u'invitor_details_live',
u'send_email',
],
}),
]
live_fields = [
u'invitor_details_live',
u'invitee_details_live',
u'message_details_live',
]
readonly_fields = live_fields + [
u'accepted_column',
u'accept_url',
]
raw_id_fields = [
u'invitor',
u'invitee',
u'message',
]
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'invitor')
def invitor_details_live(self, invitor):
user = invitor
return admin_obj_format(user, u'{tag}\n{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'invitee')
def invitee_details_live(self, invitee):
user = invitee
return admin_obj_format(user, u'{tag}\n{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'message')
def message_details_live(self, message):
return admin_obj_format(message)
def get_queryset(self, request):
queryset = super(InvitationAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'invitor', u'invitee')
return queryset
@transaction.atomic
def bulk_add_view(self, request):
invitations = None
if request.method == u'POST':
form = InvitationAdminBulkAddForm(request.POST, user=request.user)
if form.is_valid():
invitations = form.save()
else:
form = InvitationAdminBulkAddForm(user=request.user)
opts = self.model._meta
template = u'admin/%s/%s/bulk_add_form.html' % (opts.app_label, opts.model_name)
adminForm = admin.helpers.AdminForm(form,
fieldsets=self.fieldsets_bulk_add,
prepopulated_fields={},
readonly_fields=self.readonly_fields,
model_admin=self,
)
return render(request, template, {
u'invitations': invitations,
u'object': None,
u'title': 'Bulk add %s' % force_text(opts.verbose_name),
u'opts': opts,
u'adminform': adminForm,
u'media': self.media + adminForm.media,
})
def get_urls(self):
info = self.model._meta.app_label, self.model._meta.model_name
urls = patterns('',
url(r'^bulk-add/$', self.admin_site.admin_view(self.bulk_add_view), name=u'%s_%s_bulk_add' % info),
)
return urls + super(InvitationAdmin, self).get_urls()
def get_fieldsets(self, request, obj=None):
if obj is None:
return self.fieldsets_add
return super(InvitationAdmin, self).get_fieldsets(request, obj)
def get_form(self, request, obj=None, **kwargs):
if obj is None:
self.form = self.form_add
form = super(InvitationAdmin, self).get_form(request, obj, **kwargs)
form = partial(form, user=request.user)
else:
self.form = self.form_change
form = super(InvitationAdmin, self).get_form(request, obj, **kwargs)
return form
def get_formsets(self, request, obj=None):
if obj is None:
return []
return super(InvitationAdmin, self).get_formsets(request, obj)
class MessageAdmin(admin.ModelAdmin):
list_display = [
u'message_column',
u'type',
u'from_formatted_column',
u'recipients_formatted_column',
u'processed',
]
list_filter = [
u'type',
simple_list_filter_factory(u'Processed', u'processed', [
(u'1', u'Yes', lambda qs: qs.processed()),
(u'0', u'No', lambda qs: qs.not_processed()),
]),
u'processed',
]
search_fields = [
u'=id',
u'from_name',
u'from_mail',
u'recipient__name',
u'recipient__mail',
u'received_for',
]
ordering = [u'-processed', u'-pk']
@decorate(short_description=u'Message')
@decorate(admin_order_field=u'pk')
def message_column(self, message):
return admin_obj_format(message, link=False)
@decorate(short_description=u'From')
@decorate(admin_order_field=u'from_mail')
def from_formatted_column(self, message):
return message.from_formatted
@decorate(short_description=u'Recipients')
def recipients_formatted_column(self, message):
res = []
for label, formatted in [
(u'To', message.to_formatted),
(u'Cc', message.cc_formatted),
(u'Bcc', message.bcc_formatted),
]:
if formatted:
res.append(u'%s: %s' % (label, formatted))
return u'; '.join(res)
form_add = MessageAdminAddForm
form_change = forms.ModelForm
fieldsets = (
(None, {
u'fields': [
u'type',
u'processed',
u'from_name',
u'from_mail',
u'received_for',
u'subject',
(u'text', u'html'),
],
}),
(u'Advanced', {
u'classes': [u'collapse'],
u'fields': [
u'headers',
],
}),
)
fieldsets_add = (
(None, {
u'fields': [
u'type',
u'processed',
u'from_formatted',
u'to_formatted',
u'cc_formatted',
u'bcc_formatted',
u'received_for',
u'subject',
(u'text', u'html'),
u'attachments',
],
}),
(u'Advanced', {
u'classes': [u'collapse'],
u'fields': [
u'headers',
],
}),
)
inlines = [
RecipientInline,
AttachmentInline,
]
def render_change_form(self, request, context, **kwargs):
message = kwargs.get(u'obj', None)
# Reply button
if message and message.processed:
query = {}
query[
u'type'] = Message.TYPES.INBOUND if message.type == Message.TYPES.OUTBOUND else Message.TYPES.OUTBOUND
query[u'to_formatted'] = message.from_formatted
query[u'subject'] = u'%s%s' % (u'' if message.subject.startswith(
u'Re:') else u'Re: ', message.subject)
if message.received_for:
query[u'from_formatted'] = message.received_for
elif message.recipients_to:
query[u'from_formatted'] = message.recipients_to[0].formatted
elif message.recipients:
query[u'from_formatted'] = message.recipients[0].formatted
date = formats.date_format(message.processed, u'DATETIME_FORMAT')
name = message.from_name or message.from_mail
quote = u'On {date}, {name} wrote:'.format(date=date, name=name)
query[u'text'] = u'\n\n%s\n%s\n' % (quote, u'\n'.join(
u'> %s' % l for l in message.text.split(u'\n')))
query[u'html'] = u'\n\n%s\n%s\n' % (quote, u'\n'.join(
u'> %s' % l for l in message.html.split(u'\n')))
context[u'reply_url'] = u'%s?%s' % (
reverse(u'admin:mail_message_add'), urlencode(query))
return super(MessageAdmin,
self).render_change_form(request, context, **kwargs)
def get_queryset(self, request):
queryset = super(MessageAdmin, self).get_queryset(request)
queryset = queryset.prefetch_related(Message.prefetch_recipients())
return queryset
def get_fieldsets(self, request, obj=None):
if obj is None:
return self.fieldsets_add
return super(MessageAdmin, self).get_fieldsets(request, obj)
def get_form(self, request, obj=None, **kwargs):
if obj is None:
self.form = self.form_add
form = super(MessageAdmin, self).get_form(request, obj, **kwargs)
session = Session.objects.get(
session_key=request.session.session_key)
form = partial(form, attached_to=session)
else:
self.form = self.form_change
form = super(MessageAdmin, self).get_form(request, obj, **kwargs)
return form
def get_formsets(self, request, obj=None):
if obj is None:
return []
return super(MessageAdmin, self).get_formsets(request, obj)
class InforequestAdmin(admin.ModelAdmin):
date_hierarchy = u'submission_date'
list_display = [
u'id',
decorate(
lambda o: admin_obj_format(
o.applicant, u'{obj.first_name} {obj.last_name} <{obj.email}>'
),
short_description=u'Applicant',
admin_order_field=u'applicant__email',
),
decorate(
lambda o: admin_obj_format(o.main_branch.obligee, u'{obj.name}'),
short_description=u'Obligee',
admin_order_field=u'branch__obligee__name',
),
u'subject',
u'submission_date',
decorate(
lambda o: o.undecided_emails_count,
short_description=u'Undecided E-mails',
admin_order_field=u'undecided_emails_count',
),
u'closed',
]
list_filter = [
u'submission_date',
simple_list_filter_factory(u'Undecided E-mail', u'undecided', [
(u'1', u'With',
lambda qs: qs.filter(undecided_emails_count__gt=0)),
(u'0', u'Without', lambda qs: qs.filter(undecided_emails_count=0)),
]),
u'closed',
]
search_fields = [
u'=id',
u'applicant__first_name',
u'applicant__last_name',
u'applicant__email',
u'branch__obligee__name',
u'unique_email',
u'subject',
]
ordering = [
u'-submission_date',
u'-id',
]
exclude = []
readonly_fields = []
raw_id_fields = [
u'applicant',
]
inlines = []
def get_queryset(self, request):
queryset = super(InforequestAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'applicant')
queryset = queryset.select_undecided_emails_count()
queryset = queryset.prefetch_related(
Inforequest.prefetch_main_branch(
None, Branch.objects.select_related(u'obligee')))
return queryset
class BranchAdmin(AdminLiveFieldsMixin, admin.ModelAdmin):
list_display = [
u'branch_column',
u'inforequest_column',
u'inforequest_closed_column',
u'inforequest_applicant_column',
u'obligee_column',
u'main_branch_column',
]
list_filter = [
simple_list_filter_factory(u'Main Branch', u'mainbranch', [
(u'1', u'Yes', lambda qs: qs.main()),
(u'0', u'No', lambda qs: qs.advanced()),
]),
u'inforequest__closed',
]
search_fields = [
u'=id',
u'=inforequest__pk',
u'inforequest__applicant__first_name',
u'inforequest__applicant__last_name',
u'inforequest__applicant__email',
u'obligee__name',
]
ordering = [u'-pk']
@decorate(short_description=u'Branch')
@decorate(admin_order_field=u'pk')
def branch_column(self, branch):
return admin_obj_format(branch, link=False)
@decorate(short_description=u'Inforequest')
@decorate(admin_order_field=u'inforequest__pk')
def inforequest_column(self, branch):
inforequest = branch.inforequest
return admin_obj_format(inforequest)
@decorate(short_description=u'Closed')
@decorate(admin_order_field=u'inforequest__closed')
@decorate(boolean=True)
def inforequest_closed_column(self, inforequestemail):
return inforequestemail.inforequest.closed
@decorate(short_description=u'Applicant')
@decorate(admin_order_field=u'inforequest__applicant__email')
def inforequest_applicant_column(self, branch):
user = branch.inforequest.applicant
return admin_obj_format(user, u'{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'Obligee')
@decorate(admin_order_field=u'obligee__name')
def obligee_column(self, branch):
obligee = branch.obligee
return admin_obj_format(obligee, u'{obj.name}')
@decorate(short_description=u'Main Branch')
@decorate(admin_order_field=u'advanced_by')
@decorate(boolean=True)
def main_branch_column(self, branch):
return branch.is_main
form_add = BranchAdminAddForm
form_change = BranchAdminChangeForm
fieldsets = [
(None, {
u'classes': [u'wide'],
u'fields': [
u'inforequest',
u'obligee',
u'obligee_details_live',
u'historicalobligee',
u'historicalobligee_details_live',
u'advanced_by',
u'advanced_by_details_live',
u'advanced_by_branch_live',
u'advanced_by_inforequest_live',
u'advanced_by_applicant_live',
u'advanced_by_closed_live',
],
}),
]
fieldsets_add = [
(None, {
u'classes': [u'wide'],
u'fields': [
u'obligee',
u'obligee_details_live',
u'advanced_by',
u'advanced_by_details_live',
u'advanced_by_branch_live',
u'advanced_by_inforequest_live',
u'advanced_by_applicant_live',
u'advanced_by_closed_live',
],
}),
]
raw_id_fields = [
u'inforequest',
u'obligee',
u'historicalobligee',
u'advanced_by',
]
live_fields = [
u'obligee_details_live',
u'historicalobligee_details_live',
u'advanced_by_details_live',
u'advanced_by_branch_live',
u'advanced_by_inforequest_live',
u'advanced_by_applicant_live',
u'advanced_by_closed_live',
]
readonly_fields = live_fields
inlines = [
BranchAdminActionInline,
]
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'obligee')
def obligee_details_live(self, obligee):
return admin_obj_format(obligee, u'{tag}\n{obj.name}')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'historicalobligee')
def historicalobligee_details_live(self, historicalobligee):
return admin_obj_format(historicalobligee, u'{tag}\n{obj.name}')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'advanced_by')
def advanced_by_details_live(self, advanced_by):
action = advanced_by
return admin_obj_format(action, u'{tag} {0}', action.get_type_display()) if action else u'--'
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Branch'))
@live_field(u'advanced_by')
def advanced_by_branch_live(self, advanced_by):
branch = advanced_by.branch if advanced_by else None
return admin_obj_format(branch)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Inforequest'))
@live_field(u'advanced_by')
def advanced_by_inforequest_live(self, advanced_by):
inforequest = advanced_by.branch.inforequest if advanced_by else None
return admin_obj_format(inforequest)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Applicant'))
@live_field(u'advanced_by')
def advanced_by_applicant_live(self, advanced_by):
user = advanced_by.branch.inforequest.applicant if advanced_by else None
return admin_obj_format(user, u'{tag}\n{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Closed'))
@live_field(u'advanced_by')
def advanced_by_closed_live(self, advanced_by):
return _boolean_icon(advanced_by.branch.inforequest.closed) if advanced_by else u'--'
def has_delete_permission(self, request, obj=None):
if not obj:
return True
# Only advanced branches may be deleted. If we want to delete a main branch, we must delete
# its inforequest.
return not obj.is_main
def get_queryset(self, request):
queryset = super(BranchAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'inforequest__applicant')
queryset = queryset.select_related(u'obligee')
return queryset
def get_fieldsets(self, request, obj=None):
if obj is None:
return self.fieldsets_add
return super(BranchAdmin, self).get_fieldsets(request, obj)
def get_form(self, request, obj=None, **kwargs):
if obj is None:
self.form = self.form_add
form = super(BranchAdmin, self).get_form(request, obj, **kwargs)
else:
self.form = self.form_change
form = super(BranchAdmin, self).get_form(request, obj, **kwargs)
return form
def get_formsets(self, request, obj=None):
if obj is None:
return []
return super(BranchAdmin, self).get_formsets(request, obj)
class ActionAdmin(AdminLiveFieldsMixin, admin.ModelAdmin):
list_display = [
u'action_column',
u'branch_column',
u'branch_inforequest_column',
u'branch_closed_column',
u'branch_applicant_column',
u'branch_obligee_column',
u'email_column',
u'type',
u'effective_date',
]
list_filter = [
u'type',
u'effective_date',
simple_list_filter_factory(u'E-mail', u'email', [
(u'1', u'Yes', lambda qs: qs.by_email()),
(u'0', u'No', lambda qs: qs.by_smail()),
]),
u'branch__inforequest__closed',
]
search_fields = [
u'=id',
u'=branch__pk',
u'=branch__inforequest__pk',
u'branch__inforequest__applicant__first_name',
u'branch__inforequest__applicant__last_name',
u'branch__inforequest__applicant__email',
u'branch__obligee__name',
u'=email__pk',
]
ordering = [u'-effective_date', u'-pk']
@decorate(short_description=u'Action')
@decorate(admin_order_field=u'pk')
def action_column(self, action):
return admin_obj_format(action, link=False)
@decorate(short_description=u'Branch')
@decorate(admin_order_field=u'branch__pk')
def branch_column(self, action):
branch = action.branch
return admin_obj_format(branch)
@decorate(short_description=u'Inforequest')
@decorate(admin_order_field=u'branch__inforequest__pk')
def branch_inforequest_column(self, action):
inforequest = action.branch.inforequest
return admin_obj_format(inforequest)
@decorate(short_description=u'Closed')
@decorate(admin_order_field=u'branch__inforequest__closed')
@decorate(boolean=True)
def branch_closed_column(self, action):
return action.branch.inforequest.closed
@decorate(short_description=u'Applicant')
@decorate(admin_order_field=u'branch__inforequest__applicant__email')
def branch_applicant_column(self, action):
user = action.branch.inforequest.applicant
return admin_obj_format(
user, u'{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'Obligee')
@decorate(admin_order_field=u'branch__obligee__name')
def branch_obligee_column(self, action):
obligee = action.branch.obligee
return admin_obj_format(obligee, u'{obj.name}')
@decorate(short_description=u'Email')
@decorate(admin_order_field=u'email__pk')
def email_column(self, action):
email = action.email
return admin_obj_format(email)
form_add = ActionAdminAddForm
form_change = ActionAdminChangeForm
fieldsets = [
(None, {
u'classes': [u'wide'],
u'fields': [
u'inforequest_field',
u'branch',
u'branch_details_live',
u'branch_inforequest_live',
u'branch_applicant_live',
u'branch_obligee_live',
u'branch_closed_live',
u'email',
u'email_details_live',
u'email_assigned_to_live',
u'email_from_live',
u'email_subject_live',
u'type',
u'type_details_live',
u'subject',
u'content',
u'effective_date',
u'deadline',
u'extension',
u'deadline_details_live',
u'disclosure_level',
u'refusal_reason',
],
}),
(u'Advanced', {
u'classes': [u'wide', u'collapse'],
u'fields': [
u'last_deadline_reminder',
],
}),
]
fieldsets_add = [
(None, {
u'classes': [u'wide'],
u'fields': [
u'branch',
u'branch_details_live',
u'branch_inforequest_live',
u'branch_applicant_live',
u'branch_obligee_live',
u'branch_closed_live',
u'type',
u'type_details_live',
u'subject',
u'content',
u'attachments',
u'effective_date',
u'deadline',
u'extension',
u'deadline_details_live',
u'disclosure_level',
u'refusal_reason',
u'obligee_set',
u'obligee_set_details_live',
u'send_email',
],
}),
]
raw_id_fields = [
u'branch',
u'email',
]
live_fields = [
u'branch_details_live',
u'branch_inforequest_live',
u'branch_applicant_live',
u'branch_obligee_live',
u'branch_closed_live',
u'email_details_live',
u'email_assigned_to_live',
u'email_from_live',
u'email_subject_live',
u'type_details_live',
u'deadline_details_live',
u'obligee_set_details_live',
]
readonly_fields = live_fields + [
u'inforequest_field',
]
inlines = [
AttachmentInline,
ActionAdminAdvancedToInline,
]
@decorate(short_description=u'Inforequest')
def inforequest_field(self, action):
inforequest = action.branch.inforequest if action else None
return admin_obj_format(inforequest)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'branch')
def branch_details_live(self, branch):
return admin_obj_format(branch)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Inforequest'))
@live_field(u'branch')
def branch_inforequest_live(self, branch):
inforequest = branch.inforequest if branch else None
return admin_obj_format(inforequest)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Applicant'))
@live_field(u'branch')
def branch_applicant_live(self, branch):
user = branch.inforequest.applicant if branch else None
return admin_obj_format(
user, u'{tag}\n{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Obligee'))
@live_field(u'branch')
def branch_obligee_live(self, branch):
obligee = branch.obligee if branch else None
return admin_obj_format(obligee, u'{tag}\n{obj.name}')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Closed'))
@live_field(u'branch')
def branch_closed_live(self, branch):
return _boolean_icon(branch.inforequest.closed) if branch else u'--'
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'email')
def email_details_live(self, email):
return admin_obj_format(email)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Assigned To'))
@live_field(u'email')
def email_assigned_to_live(self, email):
inforequests = email.inforequest_set.all() if email else []
return admin_obj_format_join(u', ', inforequests)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'From'))
@live_field(u'email')
def email_from_live(self, email):
return email.from_formatted if email else u'--'
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Subject'))
@live_field(u'email')
def email_subject_live(self, email):
return email.subject if email else u'--'
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'type')
def type_details_live(self, type):
return ActionAdmin.type_details_live_aux(type)
@classmethod
def type_details_live_aux(cls, type):
try:
type = int(type)
except (ValueError, TypeError):
return u'--'
if type in Action.APPLICANT_ACTION_TYPES:
return u'Applicant Action'
elif type in Action.OBLIGEE_ACTION_TYPES:
return u'Obligee Action'
elif type in Action.IMPLICIT_ACTION_TYPES:
return u'Implicit Action'
else:
return u'--'
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'effective_date', u'deadline', u'extension')
def deadline_details_live(self, effective_date, deadline, extension):
return ActionAdmin.deadline_details_live_aux(effective_date, deadline,
extension)
@classmethod
def deadline_details_live_aux(cls, effective_date, deadline, extension):
try:
deadline = int(deadline)
extension = int(extension or '0')
except (ValueError, TypeError):
return u'--'
for format in get_format(u'DATE_INPUT_FORMATS'):
try:
effective_date = datetime.datetime.strptime(
effective_date, format).date()
break
except (ValueError, TypeError):
continue
else:
return u'--'
days_passed = workdays.between(effective_date, local_today())
deadline_remaining = deadline + extension - days_passed
deadline_missed = (deadline_remaining < 0)
if deadline_missed:
return u'Deadline was missed {days} working days ago.'.format(
days=-deadline_remaining)
else:
return u'Deadline will be missed in {days} working days.'.format(
days=deadline_remaining)
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'obligee_set')
def obligee_set_details_live(self, obligee_pks):
obligee_pks = obligee_pks.split(u',') if obligee_pks else []
obligees = [
try_except(lambda: Obligee.objects.get(pk=pk), None)
for pk in obligee_pks
]
return admin_obj_format_join(u'\n', obligees, u'{tag} {obj.name}')
def has_delete_permission(self, request, obj=None):
if not obj:
return True
# Branches may not be left empty.
return obj.branch.action_set.count() > 1
def get_queryset(self, request):
queryset = super(ActionAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'branch__inforequest__applicant')
queryset = queryset.select_related(u'branch__obligee')
queryset = queryset.select_related(u'email')
return queryset
def get_fieldsets(self, request, obj=None):
if obj is None:
return self.fieldsets_add
return super(ActionAdmin, self).get_fieldsets(request, obj)
def get_form(self, request, obj=None, **kwargs):
if obj is None:
self.form = self.form_add
form = super(ActionAdmin, self).get_form(request, obj, **kwargs)
session = Session.objects.get(
session_key=request.session.session_key)
form = partial(form, attached_to=session)
else:
self.form = self.form_change
form = super(ActionAdmin, self).get_form(request, obj, **kwargs)
return form
def get_formsets(self, request, obj=None):
if obj is None:
return []
return super(ActionAdmin, self).get_formsets(request, obj)
class InforequestAdmin(AdminLiveFieldsMixin, admin.ModelAdmin):
list_display = [
u'inforequest_column',
u'applicant_column',
u'obligee_column',
u'unique_email',
u'submission_date',
u'closed',
u'undecided_emails_column',
]
list_filter = [
u'submission_date',
simple_list_filter_factory(u'Undecided E-mail', u'undecided', [
(u'1', u'With',
lambda qs: qs.filter(undecided_emails_count__gt=0)),
(u'0', u'Without', lambda qs: qs.filter(undecided_emails_count=0)),
]),
u'closed',
]
search_fields = [
u'=id',
u'applicant__first_name',
u'applicant__last_name',
u'applicant__email',
u'branch__obligee__name',
u'unique_email',
]
ordering = [u'-submission_date', u'-pk']
@decorate(short_description=u'Inforequest')
@decorate(admin_order_field=u'pk')
def inforequest_column(self, inforequest):
return admin_obj_format(inforequest, link=False)
@decorate(short_description=u'Applicant')
@decorate(admin_order_field=u'applicant__email')
def applicant_column(self, inforequest):
user = inforequest.applicant
return admin_obj_format(
user, u'{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'Obligee')
@decorate(admin_order_field=u'branch__obligee__name')
def obligee_column(self, inforequest):
obligee = inforequest.main_branch.obligee
return admin_obj_format(obligee, u'{obj.name}')
@decorate(short_description=u'Undecided E-mails')
@decorate(admin_order_field=u'undecided_emails_count')
def undecided_emails_column(self, inforequest):
return inforequest.undecided_emails_count
form_add = InforequestAdminAddForm
form_change = forms.ModelForm
fieldsets = [
(None, {
u'classes': [u'wide'],
u'fields': [
u'applicant',
u'applicant_details_live',
u'obligee_details_field',
u'applicant_name',
(u'applicant_street', u'applicant_city', u'applicant_zip'),
u'unique_email',
u'submission_date',
u'closed',
u'undecided_emails_field',
],
}),
(u'Advanced', {
u'classes': [u'wide', u'collapse'],
u'fields': [
u'last_undecided_email_reminder',
],
}),
]
fieldsets_add = [
(None, {
u'fields': [
u'applicant',
u'applicant_details_live',
u'obligee',
u'obligee_details_live',
u'subject',
u'content',
u'attachments',
u'send_email',
],
}),
]
live_fields = [
u'applicant_details_live',
u'obligee_details_live',
]
readonly_fields = live_fields + [
u'obligee_details_field',
u'submission_date',
u'undecided_emails_field',
]
raw_id_fields = [
u'applicant',
]
inlines = [
InforequestAdminBranchInline,
InforequestAdminInforequestEmailInline,
]
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'applicant')
def applicant_details_live(self, applicant):
user = applicant
return admin_obj_format(
user, u'{tag}\n{obj.first_name} {obj.last_name} <{obj.email}>')
@decorate(short_description=u'%s%s' % (ADMIN_FIELD_INDENT, u'Details'))
@live_field(u'obligee')
def obligee_details_live(self, obligee_pk):
obligee = try_except(lambda: Obligee.objects.get(pk=obligee_pk), None)
return admin_obj_format(obligee, u'{tag}\n{obj.name}')
@decorate(short_description=u'Obligee')
def obligee_details_field(self, inforequest):
obligee = inforequest.main_branch.obligee
return admin_obj_format(obligee, u'{tag}\n{obj.name}')
@decorate(short_description=u'Undecided E-mails')
def undecided_emails_field(self, inforequest):
return inforequest.undecided_emails_count
def get_queryset(self, request):
queryset = super(InforequestAdmin, self).get_queryset(request)
queryset = queryset.select_related(u'applicant')
queryset = queryset.select_undecided_emails_count()
queryset = queryset.prefetch_related(
Inforequest.prefetch_main_branch(
None, Branch.objects.select_related(u'obligee')))
return queryset
def get_fieldsets(self, request, obj=None):
if obj is None:
return self.fieldsets_add
return super(InforequestAdmin, self).get_fieldsets(request, obj)
def get_form(self, request, obj=None, **kwargs):
if obj is None:
self.form = self.form_add
form = super(InforequestAdmin,
self).get_form(request, obj, **kwargs)
session = Session.objects.get(
session_key=request.session.session_key)
form = partial(form, attached_to=session)
else:
self.form = self.form_change
form = super(InforequestAdmin,
self).get_form(request, obj, **kwargs)
return form
def get_formsets(self, request, obj=None):
if obj is None:
return []
return super(InforequestAdmin, self).get_formsets(request, obj)
