def test_BulkUploadFormAdminView_excluding_duplicates_with_existing_data(self):
username = "******"
email = "*****@*****.**"
password = "******"
client = Client()
csvname = self.get_test_file_name()
Place.objects.all().delete()
User.objects.all().delete()
User.objects.create_superuser(username, email, password)
loggedin = client.login(username=username, password=password)
assert loggedin
# First, insert some data, duplicates and all
with open(csvname) as csvfile:
bulk_add_url = reverse(admin_urlname(Place._meta, "bulk_add"))
res = client.post(bulk_add_url, {"data": csvfile}, follow=True)
# Then, try inserting data, excluding duplicates
with open(csvname) as csvfile:
bulk_add_url = reverse(admin_urlname(Place._meta, "bulk_add"))
res = client.post(bulk_add_url, {"data": csvfile, "exclude_duplicates": "checked"}, follow=True)
assert_equal(Place.objects.count(), 25)
def test_BulkUploadFormAdminView_excluding_duplicates_with_existing_data(
self):
username = '******'
email = '*****@*****.**'
password = '******'
client = Client()
csvname = self.get_test_file_name()
Place.objects.all().delete()
User.objects.all().delete()
User.objects.create_superuser(username, email, password)
loggedin = client.login(username=username, password=password)
assert (loggedin)
# First, insert some data, duplicates and all
with open(csvname) as csvfile:
bulk_add_url = reverse(admin_urlname(Place._meta, 'bulk_add'))
res = client.post(bulk_add_url, {'data': csvfile}, follow=True)
# Then, try inserting data, excluding duplicates
with open(csvname) as csvfile:
bulk_add_url = reverse(admin_urlname(Place._meta, 'bulk_add'))
res = client.post(bulk_add_url, {
'data': csvfile,
'exclude_duplicates': 'checked'
},
follow=True)
assert_equal(Place.objects.count(), 25)
def test_get_context_with_valid_value(self):
"""Tests get_context() when a valid value is supplied."""
book = BookFactory()
widget = RawIdWidget(Book)
change_route_name = admin_urlname(Book._meta, 'change')
change_url = reverse(change_route_name, args=(book.pk, ))
changelist_route_name = admin_urlname(Book._meta, 'changelist')
changelist_url = reverse(changelist_route_name)
assert widget.get_context('test-widget', str(book.pk), {}) == {
'link_label': str(book),
'link_title': 'Look up book',
'link_url': change_url,
'related_url': f'{changelist_url}?_to_field=id',
'widget': {
'attrs': {
'class': 'vUUIDField',
},
'is_hidden': False,
'name': 'test-widget',
'required': False,
'template_name': 'admin/widgets/foreign_key_raw_id.html',
'type': 'text',
'value': str(book.pk),
},
}
def title_display(self, obj):
title = obj.title
meta = Page._meta
url = reverse(admin_urlname(meta, 'add'))
if obj.page:
url = reverse(admin_urlname(meta, 'change'), args=(obj.page.id, ))
return mark_safe('<a href="%s">%s</a>' % (url, title))
def title_display(self, obj):
title = obj.title
meta = Page._meta
url = reverse(admin_urlname(meta, 'add'))
if obj.page:
url = reverse(admin_urlname(meta, 'change'), args=(obj.page.id, ))
return mark_safe('<a href="%s">%s</a>' % (url, title))
def test_valid_input_redirects_to_confirmation(self):
"""
Test that valid POST input responds with a redirect to the confirmation
page.
"""
company_link_route_name = admin_urlname(Company._meta, 'dnb-link-select-ids')
company_link_url = reverse(company_link_route_name)
data = {
'company': CompanyFactory().id,
'duns_number': '123456789',
}
response = self.client.post(company_link_url, data=data)
company_link_confirmation_route_name = admin_urlname(
Company._meta,
'dnb-link-review-changes',
)
company_link_confirmation_url = reverse_with_query_string(
company_link_confirmation_route_name,
data,
)
assert response.status_code == status.HTTP_302_FOUND
assert response['location'] == company_link_confirmation_url
def url(self):
opts = self.context['opts']
if self.details:
base_url = reverse(admin_urlname(opts, self.method),
args=[self.context['original'].pk])
else:
base_url = reverse(admin_urlname(opts, self.method))
return "%s?%s" % (base_url, self.querystring)
def changelist_view(self, request, extra_context=None):
hp = HelpdeskUser(request)
if hp.is_requester():
try:
del request.session['oh_query_string']
del request.session['oh_proxied']
except KeyError:
pass
return super(TicketAdmin,
self).changelist_view(request,
extra_context=extra_context)
filter_clean = False
if 'filter_clean' in request.GET:
request.GET = request.GET.copy()
filter_clean = True
del request.GET['filter_clean']
proxied = request.session.get('oh_proxied', False)
if not proxied:
if hp.is_operator() or hp.is_admin():
session_query_string = request.session.get(
'oh_query_string', '')
if not session_query_string:
try:
subteam = hp.user.oh_teammate.default_subteam
except TeammateSetting.DoesNotExist:
subteam = None
if subteam:
query_string = 'subteam={}'.format(subteam)
request.session['oh_query_string'] = query_string
request.session['oh_proxied'] = True
url = '{}?{}'.format(
reverse(
admin_urlname(self.model._meta, 'changelist')),
query_string)
return redirect(url)
else:
query_string = request.META.get('QUERY_STRING', '')
if query_string:
request.session['oh_query_string'] = query_string
else:
request.session['oh_proxied'] = True
url = '{}?{}'.format(
reverse(
admin_urlname(self.model._meta, 'changelist')),
session_query_string)
return redirect(url)
else:
try:
del request.session['oh_query_string']
except KeyError:
pass
request.session['oh_proxied'] = False
return super(TicketAdmin,
self).changelist_view(request,
extra_context=extra_context)
def changelist_view(self, request, extra_context=None):
hp = HelpdeskUser(request)
if hp.is_requester():
try:
del request.session['oh_query_string']
del request.session['oh_proxied']
except KeyError:
pass
return super(TicketAdmin, self).changelist_view(
request, extra_context=extra_context)
filter_clean = False
if 'filter_clean' in request.GET:
request.GET = request.GET.copy()
filter_clean = True
del request.GET['filter_clean']
proxied = request.session.get('oh_proxied', False)
if not proxied:
if hp.is_operator() or hp.is_admin():
session_query_string = request.session.get(
'oh_query_string', '')
if not session_query_string:
try:
subteam = hp.user.oh_teammate.default_subteam
except TeammateSetting.DoesNotExist:
subteam = None
if subteam:
query_string = 'subteam={}'.format(subteam)
request.session['oh_query_string'] = query_string
request.session['oh_proxied'] = True
url = '{}?{}'.format(
reverse(admin_urlname(self.model._meta,
'changelist')),
query_string)
return redirect(url)
else:
query_string = request.META.get('QUERY_STRING', '')
if query_string:
request.session['oh_query_string'] = query_string
else:
request.session['oh_proxied'] = True
url = '{}?{}'.format(
reverse(admin_urlname(self.model._meta,
'changelist')),
session_query_string)
return redirect(url)
else:
try:
del request.session['oh_query_string']
except KeyError:
pass
request.session['oh_proxied'] = False
return super(TicketAdmin, self).changelist_view(
request, extra_context=extra_context)
def test_load_opt_outs_link_exists(self):
"""
Test that there is a link to load email marketing opt outs on the contact change list page.
"""
change_list_url = reverse(admin_urlname(Contact._meta, 'changelist'))
response = self.client.get(change_list_url)
assert response.status_code == status.HTTP_200_OK
load_opt_outs_url = reverse(
admin_urlname(Contact._meta, 'load-email-marketing-opt-outs'), )
assert load_opt_outs_url in response.rendered_content
def admin_url(obj, action='change'):
if not action in ('add', 'change', 'delete'):
raise ValueError
if action == 'add':
url = reverse(admin_urlname(obj.__class__._meta, action))
elif action in ('change', 'delete'):
url = reverse(admin_urlname(obj.__class__._meta, action),
args=(obj.id, ))
else:
raise ValueError
return url
def _create_company(self, **kwargs):
self.company = CompanyFactory(**kwargs)
change_url = reverse(
admin_urlname(Company._meta, 'change'),
args=(self.company.pk, ),
)
update_url = reverse(
admin_urlname(Company._meta, 'update-from-dnb'),
args=(self.company.pk, ),
)
return (change_url, update_url)
def test_updates_audit_log(self):
"""Test that audit log entries are created for modified contacts."""
creation_time = datetime(2011, 2, 1, 14, 0, 10, tzinfo=utc)
with freeze_time(creation_time):
contact_with_change = ContactFactory(
email='test1@datahub',
accepts_dit_email_marketing=True,
)
contact_without_change = ContactFactory(
email='test2@datahub',
accepts_dit_email_marketing=True,
)
contact_already_opted_out = ContactFactory(
email='test1@datahub',
accepts_dit_email_marketing=False,
)
file = io.BytesIO("""email\r
test1@datahub\r
""".encode())
file.name = 'test.csv'
url = reverse(
admin_urlname(Contact._meta, 'load-email-marketing-opt-outs'),
)
post_time = datetime(2014, 5, 3, 19, 0, 16, tzinfo=utc)
with freeze_time(post_time):
response = self.client.post(
url,
follow=True,
data={
'email_list': file,
},
)
assert response.status_code == status.HTTP_200_OK
assert len(response.redirect_chain) == 1
change_list_url = reverse(admin_urlname(Contact._meta, 'changelist'))
assert response.redirect_chain[0][0] == change_list_url
versions = Version.objects.get_for_object(contact_with_change)
assert versions.count() == 1
assert versions[0].revision.get_comment() == 'Loaded bulk email opt-out list.'
versions = Version.objects.get_for_object(contact_without_change)
assert versions.count() == 0
versions = Version.objects.get_for_object(contact_already_opted_out)
assert versions.count() == 0
def test_link_exists(self):
"""
Test that the link exists for a user with the change company permission.
"""
list_route_name = admin_urlname(Company._meta, 'changelist')
list_url = reverse(list_route_name)
response = self.client.get(list_url)
assert response.status_code == status.HTTP_200_OK
company_link_route_name = admin_urlname(Company._meta, 'dnb-link-select-ids')
company_link_url = reverse(company_link_route_name)
assert company_link_url in response.rendered_content
def dnb_link_review_changes(model_admin, request):
"""
View to allow users to review changes that would be applied to a record before linking it.
POSTs make the link and redirect the user to view the updated record.
"""
if not model_admin.has_change_permission(request):
raise PermissionDenied()
company_list_page = reverse(
admin_urlname(model_admin.model._meta, 'changelist'), )
form = SelectIdsToLinkForm(data=request.GET)
if not form.is_valid():
messages = _build_error_messages(form.errors)
raise AdminError(messages, company_list_page)
dh_company = form.cleaned_data['company']
duns_number = form.cleaned_data['duns_number']
is_post = request.method == 'POST'
if is_post:
_link_company_with_dnb(dh_company.pk, duns_number, request.user,
company_list_page)
django_messages.add_message(
request,
django_messages.SUCCESS,
'Company linked to D&B successfully.',
)
company_change_page = reverse(
admin_urlname(model_admin.model._meta, 'change'),
kwargs={'object_id': dh_company.pk},
)
return HttpResponseRedirect(company_change_page)
dnb_company = _get_company(duns_number, company_list_page, request)
return TemplateResponse(
request,
'admin/company/company/update-from-dnb.html',
{
**model_admin.admin_site.each_context(request),
'media': model_admin.media,
'opts': model_admin.model._meta,
'title': gettext_lazy('Confirm Link Company with D&B'),
'diff': format_company_diff(dh_company, dnb_company),
},
)
def send_email_to_requester(self, request):
template = "openhelpdesk/email/report/info_to_request"
context = {
'report_name': self._meta.verbose_name.lower(),
'operator': request.user.username,
'ticket_id': self.ticket_id
}
subject = subject_template("{}_subject.html".format(template), context)
addr_from = request.user.email
addr_to = [self.ticket.requester.email]
change_ticket_url = '{}#tab_messages'.format(
reverse(admin_urlname(self.ticket._meta, 'change'),
args=(self.ticket_id, )))
context.update({
'report': self,
'request': request,
'change_ticket_url': change_ticket_url
})
send_mail_template(subject,
template,
addr_from,
addr_to,
context=context,
attachments=None)
def send_email_to_operators_on_adding(self, request):
template = "openhelpdesk/email/ticket/ticket_operators_creation"
subject = subject_template(
"{}_subject.html".format(template), {
'ticket_name': self._meta.verbose_name.lower(),
'username': self.requester.username
})
try:
site_conf = SiteConfiguration.objects.get(site=self.site)
addr_from = site_conf.email_addr_from
addr_to = site_conf.email_addrs_to
except SiteConfiguration.DoesNotExist:
addr_from = SiteConfiguration.get_no_site_email_addr_from()
addr_to = SiteConfiguration.get_no_site_email_addrs_to()
change_url = reverse(admin_urlname(self._meta, 'change'),
args=(self.pk, ))
context = {
'ticket_name': self._meta.verbose_name,
'ticket': self,
'request': request,
'change_url': change_url
}
send_mail_template(subject,
template,
addr_from,
addr_to,
context=context,
attachments=None)
def upload(self, request):
opts = self.model._meta
context = dict(
self.admin_site.each_context(request),
opts=opts,
help_text=self.upload_handler.__doc__,
app_label=opts.app_label,
)
if request.method == 'POST':
if 'file' in request.FILES:
try:
f = request.FILES['file']
rows, updated, created = self.upload_handler(f)
msg = "Loaded {}. Parsed:{} " \
"updated:{} created:{}".format(f.name,
rows,
updated,
created)
self.message_user(request, msg, messages.SUCCESS)
return HttpResponseRedirect(reverse(admin_urlname(opts,
'changelist')))
except Exception as e:
self.message_user(request, str(e), messages.ERROR)
return TemplateResponse(request,
self.get_upload_form_template(request),
context)
def test_copy_language_backend(self):
"""
Testing how the copy button works.
It calls the ``get_placeholder_data_view`` function.
"""
self.admin_site.register(PlaceholderFieldTestPage,
PlaceholderFieldTestPageAdmin)
modeladmin = self.admin_site._registry[PlaceholderFieldTestPage]
page = factories.create_page()
placeholder = factories.create_placeholder(page=page)
item1 = factories.create_content_item(RawHtmlTestItem,
placeholder=placeholder,
html='AA')
item2 = factories.create_content_item(RawHtmlTestItem,
placeholder=placeholder,
html='BB')
request = self._get_request(
admin_urlname(page._meta, 'get_placeholder_data'))
data = modeladmin.get_placeholder_data_view(request, page.pk).jsondata
self.assertEqual(len(data['formset_forms']), 2)
self.assertEqual(data['formset_forms'][0]['model'], 'RawHtmlTestItem')
self.assertEqual(data['formset_forms'][0]['contentitem_id'], item1.pk)
self.assertEqual(data['formset_forms'][1]['contentitem_id'], item2.pk)
self.assertTrue('AA' in data['formset_forms'][0]['html'])
def change_view(self, request, object_id, form_url='', extra_context=None):
"""Premept 404s caused by changing the site on the change form page."""
extra_context = extra_context or {}
try:
response = super(TranslatableMixin,
self).change_view(request,
object_id,
form_url=form_url,
extra_context=extra_context)
except Http404 as e:
# See if the object can be found on another site/language
try:
object_id = self.model._meta.pk.to_python(object_id)
found = QuerySet(self.model).get(pk=object_id)
except (self.model.DoesNotExist, ValidationError, ValueError):
raise e
else:
# Find the object with the same slug on this site.
try:
expected = self.get_queryset(request).get(slug=found.slug)
except self.model.DoesNotExist:
raise e
response = redirect(admin_urlname(self.model._meta, 'change'),
expected.pk)
return response
def send_email_to_requester(self, request):
template = "openhelpdesk/email/report/info_to_request"
operator = request.user
operator_name = operator.username
if operator.last_name and operator.first_name:
operator_name = '{} {}'.format(operator.first_name,
operator.last_name)
context = {'report_name': self._meta.verbose_name.lower(),
'operator': operator,
'operator_name': operator_name,
'ticket_id': self.ticket_id,
'email_background_color': (
OrganizationSetting.email_objects.get_color(
self.ticket.requester.email))}
try:
site_conf = SiteConfiguration.objects.get(site=self.ticket.site)
addr_from = site_conf.email_addr_from
except (SiteConfiguration.DoesNotExist, Ticket.DoesNotExist):
addr_from = SiteConfiguration.get_no_site_email_addr_from()
subject = subject_template("{}_subject.html".format(template), context)
addr_to = [self.ticket.requester.email]
change_ticket_url = '{}#tab_messages'.format(
reverse(admin_urlname(self.ticket._meta, 'change'),
args=(self.ticket_id,)))
context.update({'report': self, 'request': request,
'change_ticket_url': change_ticket_url})
send_mail_template(subject, template, addr_from, addr_to,
context=context, attachments=None)
def get_context(self, name, value, attrs):
"""Gets the template context."""
context = super().get_context(name, value, attrs)
if self.model not in self.admin_site._registry:
raise ValueError(
'The specified model is not registered with the specified admin site'
)
changelist_route_name = admin_urlname(self.model._meta, 'changelist')
related_url = reverse(changelist_route_name,
current_app=self.admin_site.name)
params = {
TO_FIELD_VAR: 'id',
}
query_string = urlencode(params)
context['related_url'] = f'{related_url}?{query_string}'
context['widget']['attrs']['class'] = 'vForeignKeyRawIdAdminField'
title_format = gettext('Look up {verbose_name}')
context['link_title'] = title_format.format(
verbose_name=self.model._meta.verbose_name)
if context['widget']['value']:
context['link_label'], context[
'link_url'] = self.label_and_url_for_value(value)
return context
def format_ticket_message(context, message, **kwargs):
if not issubclass(message.__class__, Message):
raise TypeError("{} isn't subclass object of".format(message, Message))
tag_context = {
"css_style": "",
"message": message,
"css_class": "form-row",
"model": message._meta.model_name,
"can_view_report": False,
}
if "helpdesk_user" in context:
hu = HelpdeskUser(context["helpdesk_user"])
if hu.is_operator() or hu.is_admin():
tag_context["can_view_report"] = True
if "css_class" in kwargs:
tag_context.update({"css_class": kwargs["css_class"]})
try:
if message.report:
opts = message.report._meta
tag_context.update(
{
"model": opts.model_name,
"css_style": "text-align: right;",
"view_url": "{}?id={}".format(reverse(admin_urlname(opts, "changelist")), message.report.pk),
}
)
except ObjectDoesNotExist:
pass
return tag_context
def import_table(self, obj):
try:
url = reverse(admin_urlname(obj._meta, 'import_sites'),
args=[obj.pk])
return format_html(f'<a href="{url}">Import</a>')
except NoReverseMatch:
return '-'
def get_staff_url(self):
"""
Return the Admin URL for the current view.
By default, it uses the :func:`get_staff_object` function to base the URL on.
"""
object = self.get_staff_object()
if object is not None:
# View is likely using SingleObjectMixin
return reverse(admin_urlname(object._meta, 'change'), args=(object.pk,))
model = _get_view_model(self)
if model is not None:
# View is likely using MultipleObjectMixin (e.g. ListView)
return reverse(admin_urlname(object._meta, 'changelist'))
return None
def test_error_if_invalid_company_selected(self, company_2, expected_error):
"""Test that an error is displayed if the an invalid company is selected."""
company = CompanyFactory()
select_other_route_name = admin_urlname(Company._meta, 'merge-select-other-company')
select_other_query_args = {
'company_1': company.pk,
}
select_other_url = reverse_with_query_string(
select_other_route_name,
select_other_query_args,
)
value = str(company.pk) if company_2 is self.SAME_COMPANY else company_2
response = self.client.post(
select_other_url,
data={
'company_2': value,
},
)
assert response.status_code == status.HTTP_200_OK
form = response.context['form']
assert 'company_2' in form.errors
assert form.errors['company_2'] == [expected_error]
def test_unarchive_permission_denied(self):
"""
Test the unarchive view when the user does not have sufficient permissions
to unarchive a company.
"""
company = ArchivedCompanyFactory()
unarchive_route_name = admin_urlname(Company._meta,
'unarchive-company')
unarchive_query_args = {
'company': company.pk,
}
unarchive_url = reverse_with_query_string(
unarchive_route_name,
unarchive_query_args,
)
user = create_test_user(
permission_codenames=(CompanyPermission.view_company, ),
is_staff=True,
password=self.PASSWORD,
)
client = self.create_client(user=user)
response = client.get(unarchive_url)
assert response.status_code == status.HTTP_403_FORBIDDEN
company.refresh_from_db()
assert company.archived is True
def test_unarchive_view(
self,
company_callable,
expected_status_code,
expected_archived_value,
):
"""
Test the unarchive view when called on companies in different states.
"""
company = company_callable()
unarchive_route_name = admin_urlname(Company._meta,
'unarchive-company')
unarchive_query_args = {
'company': company.pk,
}
unarchive_url = reverse_with_query_string(
unarchive_route_name,
unarchive_query_args,
)
response = self.client.get(unarchive_url)
assert response.status_code == expected_status_code
company.refresh_from_db()
assert company.archived is expected_archived_value
if expected_archived_value is False:
assert not company.archived_on
assert not company.archived_by
assert not company.archived_reason
def update_from_dnb(model_admin, request, object_id):
"""
Tool to let admin users update company with a valid `duns_number`
by pulling fresh data from D&B.
The company record will be versioned after the update from
D&B is applied.
The `pending_dnb_investigation` field will
be set to False.
"""
if not model_admin.has_change_permission(request):
raise PermissionDenied()
dh_company = model_admin.get_object(request, object_id)
company_change_page = reverse(
admin_urlname(model_admin.model._meta, 'change'),
kwargs={'object_id': dh_company.pk},
)
if dh_company is None or dh_company.duns_number is None:
raise SuspiciousOperation()
try:
dnb_company = get_company(dh_company.duns_number, request)
except DNBServiceInvalidRequestError:
message = 'No matching company found in D&B database.'
raise AdminError([message], company_change_page)
except DNBServiceBaseError:
message = 'Something went wrong in an upstream service.'
raise AdminError([message], company_change_page)
if request.method == 'GET':
return TemplateResponse(
request,
'admin/company/company/update-from-dnb.html',
{
**model_admin.admin_site.each_context(request),
'media':
model_admin.media,
'opts':
model_admin.model._meta,
'object':
dh_company,
'title':
gettext_lazy('Confirm update from D&B'),
'diff':
format_company_diff(dh_company, dnb_company),
},
)
try:
update_company_from_dnb(dh_company, dnb_company, request.user)
return HttpResponseRedirect(company_change_page)
except serializers.ValidationError:
message = 'Data from D&B did not pass the Data Hub validation checks.'
raise AdminError([message], company_change_page)
def _make_confirm_merge_url(source_company, target_company):
confirm_merge_route_name = admin_urlname(Company._meta, 'merge-confirm')
confirm_merge_query_args = {
'source_company': str(source_company.pk),
'target_company': str(target_company.pk),
}
return reverse_with_query_string(confirm_merge_route_name, confirm_merge_query_args)
def get_admin_url(self, object):
"""
Generate the admin URL for an object.
"""
current_app = self.request.resolver_match.namespace
url = reverse(admin_urlname(object._meta, 'change'), args=(object.pk,), current_app=current_app)
return 'http://{0}{1}'.format(self.site.domain, url)
def test_send_email_to_operators_context_set(self, mock_send_email,
initialized_ticket,
request_for_email):
"""
:param initialized_ticket: Ticket already intialized
:type initialized_ticket: openhelpdesk.models.Ticket
"""
site_ops_email = ['*****@*****.**', '*****@*****.**']
self.get_site_config_for_ticket(initialized_ticket)
change_url = reverse(admin_urlname(initialized_ticket._meta, 'change'),
args=(initialized_ticket.pk, ))
context = {
'ticket_name': initialized_ticket._meta.verbose_name,
'ticket': initialized_ticket,
'request': request_for_email,
'change_url': change_url
}
with patch('openhelpdesk.models.SiteConfiguration'
'.email_addrs_to',
return_value=site_ops_email):
initialized_ticket.send_email_to_operators_on_adding(
request_for_email)
mock_send_email.assert_called_once_with(ANY,
ANY,
ANY,
ANY,
context=context,
attachments=ANY)
def format_ticket_message(context, message, **kwargs):
if not issubclass(message.__class__, Message):
raise TypeError("{} isn't subclass object of".format(message, Message))
tag_context = {
'css_style': '',
'message': message,
'css_class': 'form-row',
'model': message._meta.model_name,
'can_view_report': False
}
if 'helpdesk_user' in context:
hu = HelpdeskUser(context['helpdesk_user'])
if hu.is_operator() or hu.is_admin():
tag_context['can_view_report'] = True
if 'css_class' in kwargs:
tag_context.update({'css_class': kwargs['css_class']})
try:
if message.report:
opts = message.report._meta
tag_context.update({
'model':
opts.model_name,
'css_style':
'text-align: right;',
'view_url':
'{}?id={}'.format(reverse(admin_urlname(opts, 'changelist')),
message.report.pk)
})
except ObjectDoesNotExist:
pass
return tag_context
def slottimes_lt(self, obj):
slottimes_count = obj.slottime_set.count()
if slottimes_count >= 1:
url = reverse(admin_urlname(SlotTime._meta, 'changelist'))
return '<a href="{0}?generation={1}">{2}</a>'.format(
url, obj.pk, slottimes_count)
return str(slottimes_count)
def send_email_to_operators_on_adding(self, request):
template = "openhelpdesk/email/ticket/ticket_operators_creation"
requester_name = _('no personal info assigned')
if self.requester.last_name and self.requester.first_name:
requester_name = '{} {}'.format(self.requester.first_name,
self.requester.last_name)
subject = subject_template(
"{}_subject.html".format(template),
{'ticket_name': self._meta.verbose_name.lower(),
'username': self.requester.email or self.requester.username})
try:
site_conf = SiteConfiguration.objects.get(site=self.site)
addr_from = site_conf.email_addr_from
addr_to = site_conf.email_addrs_to
except SiteConfiguration.DoesNotExist:
addr_from = SiteConfiguration.get_no_site_email_addr_from()
addr_to = SiteConfiguration.get_no_site_email_addrs_to()
change_url = reverse(admin_urlname(self._meta, 'change'),
args=(self.pk,))
email_background_color = (
OrganizationSetting.email_objects.get_color(
self.requester.email))
context = {'ticket_name': self._meta.verbose_name, 'ticket': self,
'request': request, 'change_url': change_url,
'requester_username': self.requester.username,
'requester_email': self.requester.email or _(
'no email assigned'),
'requester_name': requester_name,
'email_background_color': email_background_color}
send_mail_template(subject, template, addr_from, addr_to,
context=context, attachments=None)
def format_ticket_message(context, message, **kwargs):
if not issubclass(message.__class__, Message):
raise TypeError("{} isn't subclass object of".format(message, Message))
tag_context = {'css_style': '', 'message': message,
'css_class': 'form-row',
'model': getattr(message._meta, 'model_name',
message._meta.module_name),
'can_view_report': False}
if 'helpdesk_user' in context:
user = context['helpdesk_user']
if user.is_operator() or user.is_admin():
tag_context['can_view_report'] = True
if 'css_class' in kwargs:
tag_context.update({'css_class': kwargs['css_class']})
try:
if message.report:
opts = message.report._meta
tag_context.update({'model': getattr(
opts, 'model_name', opts.module_name),
'css_style': 'text-align: right;',
'view_url': '{}?id={}'.format(
reverse(admin_urlname(opts, 'changelist')),
message.report.pk)})
except ObjectDoesNotExist:
pass
return tag_context
def render_change_form(self,
request,
context,
add=False,
change=False,
form_url='',
obj=None):
if change and obj.site_id != settings.SITE_ID:
# Grab the default language version of the object
try:
default = QuerySet(obj.__class__).filter(
slug=obj.slug, site=settings.SITE_ID)[0]
except IndexError:
context['default_language_url'] = None
else:
with override(settings.LANGUAGE_CODE):
meta = default.__class__._meta
context['default_language_url'] = reverse(
admin_urlname(meta, 'change'), args=(default.id, ))
context['tranlsated_fields'] = self.tranlsated_fields
response = super(TranslatableMixin,
self).render_change_form(request,
context,
add=add,
change=change,
form_url=form_url,
obj=obj)
if change and obj.site_id != settings.SITE_ID:
# Hijack the delayed rendering to replace the change form while
# extending from the original template
if not response.is_rendered:
current_template = select_template(response.template_name).name
response.context_data['base_template'] = current_template
response.template_name = 'translations/admin/change_form.html'
return response
def test_copy_language_backend(self):
"""
Testing how the copy button works.
It calls the ``get_placeholder_data_view`` function.
"""
self.admin_site.register(PlaceholderFieldTestPage,
PlaceholderFieldTestPageAdmin)
modeladmin = self.admin_site._registry[PlaceholderFieldTestPage]
page = factories.create_page()
placeholder = factories.create_placeholder(page=page)
item1 = factories.create_content_item(RawHtmlTestItem,
placeholder=placeholder,
html="AA")
item2 = factories.create_content_item(RawHtmlTestItem,
placeholder=placeholder,
html="BB")
request = self._get_request(
admin_urlname(page._meta, "get_placeholder_data"))
data = modeladmin.get_placeholder_data_view(request, page.pk).jsondata
self.assertEqual(len(data["formset_forms"]), 2)
self.assertEqual(data["formset_forms"][0]["model"], "RawHtmlTestItem")
self.assertEqual(data["formset_forms"][0]["contentitem_id"], item1.pk)
self.assertEqual(data["formset_forms"][1]["contentitem_id"], item2.pk)
self.assertTrue("AA" in data["formset_forms"][0]["html"])
def get_staff_url(self):
"""
Return the Admin URL for the current view.
By default, it uses the :func:`get_staff_object` function to base the URL on.
"""
object = self.get_staff_object()
if object is not None:
# View is likely using SingleObjectMixin
return reverse(admin_urlname(object._meta, "change"), args=(object.pk,))
model = _get_view_model(self)
if model is not None:
# View is likely using MultipleObjectMixin (e.g. ListView)
return reverse(admin_urlname(object._meta, "changelist"))
return None
def confirm_action(modeladmin, request,
action, message,
success_message='',
description='',
pk=None,
extra_context=None,
template='admin_extra_urls/confirm.html',
error_message=None,
**kwargs):
opts = modeladmin.model._meta
context = dict(
modeladmin.admin_site.each_context(request),
opts=opts,
app_label=opts.app_label,
message=message,
description=description,
**kwargs)
if extra_context:
context.update(extra_context)
if request.method == 'POST':
ret = None
try:
ret = action(request)
modeladmin.message_user(request, success_message, messages.SUCCESS)
except Exception as e:
modeladmin.message_user(request, error_message or str(e), messages.ERROR)
return ret or HttpResponseRedirect(reverse(admin_urlname(opts,
'changelist')))
return TemplateResponse(request,
template,
context)
def ld_groups(self, obj):
return '<br>'.join(
['<a href="{}?id={}">{}</a>'.format(
reverse(admin_urlname(group._meta, 'changelist')),
group.pk,
group.name)
for group in obj.groups.order_by('name')])
def booking_type_links(self, obj):
link_tpl = ('<a href="{url}?id={bookinktype.pk}">{bookinktype.title}'
'</a>')
return '<br >'.join([
link_tpl.format(
url=reverse(admin_urlname(bt._meta, 'changelist')),
bookinktype=bt)
for bt in obj.bookingtype_set.order_by('title')])
def admin_disable_on_organizations(self):
return format_html_join(
mark_safe('<br>'),
'<a href="{}?id={}" class="view_tipology">{}</a>',
((reverse(admin_urlname(obj._meta, 'changelist')),
obj.pk,
obj.title)
for obj in self.disable_on_organizations.all()))
def get_redirect_url(self, *args, **kwargs):
ticket_pk = kwargs.get("pk")
url_on_error = reverse(admin_urlname(models.Ticket._meta, "changelist"))
error_msg_prefix = _("An error occurs.")
try:
ticket = models.Ticket.objects.get(pk=ticket_pk)
ticket.opening(self.request.user)
msg = _("Ticket n.%(pk)s is opened and assigned.") % {"pk": ticket_pk}
except models.Ticket.DoesNotExist:
msg = _("Ticket n.%(pk)s does not exist.") % {"pk": ticket_pk}
messages.error(self.request, "{} {}".format(error_msg_prefix, msg))
return url_on_error
except ValueError as ve: # Errors raised by ticket.open
messages.error(self.request, "{} {}".format(error_msg_prefix, str(ve)))
return url_on_error
messages.success(self.request, msg)
return "{}#tab_changestatuslog".format(reverse(admin_urlname(models.Ticket._meta, "change"), args=(ticket_pk,)))
def get_redirect_url(self, *args, **kwargs):
url = reverse(admin_urlname(List._meta, 'changelist'))
if 'next' in self.request.GET:
url = self.request.GET['next']
filters = {key: self.request.GET[key]
for key in self.request.GET
if key in MAILCHIMP_LIST_FILTERS}
List.objects.import_list(request=self.request, filters=filters)
return url
def ld_sessioni_assemblea(self, obj):
"""
:type obj: affarigenerali.models.CommissioneConsigliare
"""
return '<br />'.join(
['{} <a href="{}">presenze'
'</a>'.format(c, reverse(admin_urlname(c._meta, 'change'),
args=(c.pk,)))
for c in obj.sessioni.all()])
def email_new_sociallogin(self, request):
email = self.user.email
context = {'email': email,
'user_url': request.build_absolute_uri(
reverse(admin_urlname(self.user._meta, 'changelist')))
+ '?email={}'.format(email)}
subject = 'Nuovo socialaccount di {}'.format(email)
return self._email_for_sociallogin(
subject, "custom_email_user/email/new_sociallogin.html", context)
def test_check_access_with_request_without_ticket_param(self, mock_messages, report_util):
response_redirect = HttpResponseRedirect("/admin/")
with patch("openhelpdesk.admin.redirect", return_value=response_redirect) as mock_redirect:
# response = ReportAdmin._check_access(report_util.request,
# report_util.model_admin)
response = report_util.model_admin._check_access(report_util.request)
assert response == response_redirect
assert report_util.model_admin.helpdesk_ticket is None
mock_redirect.assert_called_once_with(admin_urlname(Ticket._meta, "changelist"))
mock_messages.error.assert_called_once_with(report_util.request, ANY)
def setUp(self):
self.user = requester()
self.url = reverse(admin_urlname(Ticket._meta, 'add'))
self.content = "Foo"
self.tipologies = get_tipologies(2)
self.add_form_data = AddFormData(self.content, self.tipologies)
response = self.app.get(self.url, user=self.user)
self.form = response.forms['ticket_form']
self.form['content'] = self.add_form_data.content
self.form['priority'] = self.add_form_data.priority
self.form['tipologies'] = self.add_form_data.tipologies
def test_check_access_with_request_with_ticket_not_existing(self, mock_messages, mock_get, report_util):
response_redirect = HttpResponseRedirect("/admin/")
request = report_util.get("/fake/?ticket=999")
with patch("openhelpdesk.admin.redirect", return_value=response_redirect) as mock_redirect:
response = report_util.model_admin._check_access(request)
assert response == response_redirect
assert report_util.model_admin.helpdesk_ticket is None
mock_redirect.assert_called_once_with(admin_urlname(Ticket._meta, "changelist"))
mock_messages.error.assert_called_once_with(request, ANY)
def get_redirect_url(self, *args, **kwargs):
ticket_pk = kwargs.get('pk')
url_on_error = reverse(admin_urlname(Ticket._meta, 'changelist'))
error_msg_prefix = _('An error occurs.')
try:
ticket = Ticket.objects.get(pk=ticket_pk)
ticket.opening(self.request.user)
msg = _('Ticket n.%(pk)s is opened and assigned.') % {
'pk': ticket_pk}
except Ticket.DoesNotExist:
msg = _('Ticket n.%(pk)s does not exist.') % {'pk': ticket_pk}
messages.error(self.request, '{} {}'.format(error_msg_prefix, msg))
return url_on_error
except ValueError as ve: # Errors raised by ticket.open
messages.error(self.request, '{} {}'.format(error_msg_prefix,
str(ve)))
return url_on_error
messages.success(self.request, msg)
return '{}#tab_changestatuslog'.format(
reverse(admin_urlname(Ticket._meta, 'change'), args=(ticket_pk,)))
def test_site_switch_redirect(self):
"""Handle switching the site when viewing the change form page. Redirect
to the corresponding change form for the new site."""
instance = self.create_model()
with self.settings(SITE_ID=self.other.pk):
translated = self.create_model(slug=instance.slug)
# Request translated version PK from the English site
response = self.admin.change_view(self.request, translated.pk)
expected_url_name = admin_urlname(self.model_class._meta, 'change')
expected_url = reverse(expected_url_name, args=(instance.id, ))
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], expected_url)
def setUp(self):
self.user = requester()
self.url = reverse(admin_urlname(Ticket._meta, 'add'))
self.content = "Foo"
self.tipologies = get_tipologies(2)
self.add_form_data = AddFormData(self.content, self.tipologies)
response = self.app.get(self.url, user=self.user)
# support django 1.8 and previus version
form_id = '_form' if '_form' in response.forms else 'ticket_form'
self.form = response.forms[form_id]
self.form['content'] = self.add_form_data.content
self.form['priority'] = self.add_form_data.priority
self.form['tipologies'] = self.add_form_data.tipologies
def _inner(self, request, pk):
try:
ret = func(self, request, pk)
except TypeError:
msg = "'%s()' must accept 3 arguments. " \
"Did you missed 'request' and 'pk' ?" % func.__name__
raise ExtraUrlConfigException(msg)
if not isinstance(ret, HttpResponse):
url = reverse(admin_urlname(self.model._meta, 'change'),
args=[pk])
return HttpResponseRedirect(url)
return ret
def change_view(self, request, object_id, form_url='', extra_context=None):
user = request.user
if user.is_superuser or (
NOWAIT_GROUP_ADMINS in user.groups.values_list('name',
flat=True)):
return super(MixinCheckOperatorAdminView, self).change_view(
request, object_id, form_url=form_url,
extra_context=extra_context)
self.message_user(
request,
_("You do not have permission to modify this object type."),
level=messages.ERROR)
return redirect(admin_urlname(self.model._meta, 'changelist'))
def add_view(self, request, form_url='', extra_context=None):
try:
os = OrganizationSetting.email_objects.get(request.user.email)
extra_context = extra_context or {}
extra_context['organization_setting'] = os
except (ValidationError, OrganizationSetting.DoesNotExist) as e:
msg = _('Sorry! Your email address is invalid. '
'Contact the support service for fix this.')
messages.error(request, _(msg))
# TODO inserire un ticket in maniera automatica
return redirect(admin_urlname(self.model._meta, 'changelist'))
return super(TicketAdmin, self).add_view(request, form_url=form_url,
extra_context=extra_context)
def test_add_report_for_remove_from_from_pending_the_ticket(
browser_o, pending_ticket):
"""
:param browser_o:
:type browser_o: tests.lives.MezzanineLiveBrowser
:param pending_ticket:
:type pending_ticket: helpdesk.models.Ticket
"""
content = 'foo ' * 10
action = 'remove_from_pending'
browser_o.get(reverse(admin_urlname(Report._meta, 'add')) +
'?ticket={}'.format(pending_ticket.pk,))
# insert the content of report
browser_o.driver.find_element_by_id('id_content').send_keys(content)
visible_from_req = browser_o.driver.find_element_by_id(
'id_visible_from_requester')
# select the checkbox for requester's visibility
if not visible_from_req.is_selected():
visible_from_req.click()
# select the action 'remove_from_pending'
browser_o.driver.find_element_by_css_selector(
'input[value="{}"]'.format(action)).click()
# select save button
browser_o.driver.find_element_by_name('_save').click()
browser_o.get(reverse(admin_urlname(Ticket._meta, 'change'),
args=(pending_ticket.id,)))
tab_ticket_data = WebDriverWait(browser_o.driver, 10).until(
ec.visibility_of_element_located((By.ID, 'tab_ticket_data')))
status = tab_ticket_data.find_element_by_css_selector(
".table_ticket_data td.ticket_status")
assert status.text.strip().lower() == 'open'
# select tab of Messages
browser_o.driver.find_element_by_css_selector(
'a[href="#tab_messages"]').click()
report = Report.objects.filter(ticket_id=pending_ticket.id).latest()
message = browser_o.driver.find_element_by_id(
'ticket_message_{}'.format(report.id))
assert content in message.text
def render(self, context):
methodname = template.Variable(self.methodname).resolve(context)
target = template.Variable(self.object).resolve(context)
model_admin = context['adminform'].model_admin
for name, options in chain(model_admin.extra_detail_buttons, model_admin.extra_buttons):
if name == methodname:
opts = options._asdict()
if target:
opts['href'] = reverse(admin_urlname(target._meta, methodname),
args=[target.pk])
context[self.varname] = opts
return ''
raise TemplateSyntaxError("'%s' is not a valid extra url name" % target)
def test_change_view_redirect_to_changelist_view(self, mock_change_view, mock_messages, report_util):
request = report_util.post("/fake", {})
report_id = 5
model_mock = Mock(spec_set=Report)
model_mock.objects.filter.return_value.count.return_value = 0
report_util.model_admin.model = model_mock
http_redirect = HttpResponseRedirect("/admin/report/changelist/")
with patch("openhelpdesk.admin.redirect", return_value=http_redirect) as mock_redirect:
result = report_util.model_admin.change_view(request, report_id)
assert result == http_redirect
mock_redirect.assert_called_once_with(admin_urlname(model_mock._meta, "changelist"))
report_util.model_admin.message_user.assert_called_once_with(request, ANY, level=mock_messages.ERROR)
def change_view(self, request, object_id, *args, **kwargs):
"""
If request.user try to change an Report which sender field is not the
same, request.user is redirect to Report changelist view.
"""
if not self.model.objects.filter(pk=object_id,
sender=request.user).count():
self.message_user(request,
_("You can not change Report with id"
" %(report_id)s") % {'report_id': object_id},
level=messages.ERROR)
return redirect(admin_urlname(self.model._meta, 'changelist'))
return super(ReportAdmin, self).change_view(
request, object_id, *args, **kwargs)
