def form_valid(self, form):
self.register_user(form)
return http.HttpResponseRedirect(form.cleaned_data['redirect_url'])
def mash_delete(request, recipe, recipe_id, object_id):
mash = get_object_or_404(MashStep, pk=object_id, recipe=recipe)
mash.delete()
return http.HttpResponseRedirect(recipe.get_absolute_url())
def signout(request):
djlogout(request)
return http.HttpResponseRedirect("/")
def redirect_for_login(request):
# We can't use urlparams here, because it escapes slashes,
# which a large number of tests don't expect
url = '%s?to=%s' % (reverse('users.login'),
urlquote(request.get_full_path()))
return http.HttpResponseRedirect(url)
def post(self, request, *args, **kwargs):
"""On POST, mark this step as done and move to next step."""
first_boot.mark_step_done('firstboot_welcome')
return http.HttpResponseRedirect(reverse(first_boot.next_step()))
def shortcut(request, content_type_id, object_id):
"""
Redirect to an object's page based on a content-type ID and an object ID.
"""
# Look up the object, making sure it's got a get_absolute_url() function.
try:
content_type = ContentType.objects.get(pk=content_type_id)
if not content_type.model_class():
raise http.Http404(
_("Content type %(ct_id)s object has no associated model") %
{'ct_id': content_type_id})
obj = content_type.get_object_for_this_type(pk=object_id)
except (ObjectDoesNotExist, ValueError):
raise http.Http404(
_("Content type %(ct_id)s object %(obj_id)s doesn't exist") % {
'ct_id': content_type_id,
'obj_id': object_id
})
try:
get_absolute_url = obj.get_absolute_url
except AttributeError:
raise http.Http404(
_("%(ct_name)s objects don't have a get_absolute_url() method") %
{'ct_name': content_type.name})
absurl = get_absolute_url()
# Try to figure out the object's domain, so we can do a cross-site redirect
# if necessary.
# If the object actually defines a domain, we're done.
if absurl.startswith(('http://', 'https://', '//')):
return http.HttpResponseRedirect(absurl)
# Otherwise, we need to introspect the object's relationships for a
# relation to the Site object
object_domain = None
if apps.is_installed('django.contrib.sites'):
Site = apps.get_model('sites.Site')
opts = obj._meta
# First, look for an many-to-many relationship to Site.
for field in opts.many_to_many:
if field.remote_field.model is Site:
try:
# Caveat: In the case of multiple related Sites, this just
# selects the *first* one, which is arbitrary.
object_domain = getattr(obj, field.name).all()[0].domain
except IndexError:
pass
if object_domain is not None:
break
# Next, look for a many-to-one relationship to Site.
if object_domain is None:
for field in obj._meta.fields:
if field.remote_field and field.remote_field.model is Site:
try:
object_domain = getattr(obj, field.name).domain
except Site.DoesNotExist:
pass
if object_domain is not None:
break
# Fall back to the current site (if possible).
if object_domain is None:
try:
object_domain = Site.objects.get_current(request).domain
except Site.DoesNotExist:
pass
else:
# Fall back to the current request's site.
object_domain = RequestSite(request).domain
# If all that malarkey found an object domain, use it. Otherwise, fall back
# to whatever get_absolute_url() returned.
if object_domain is not None:
protocol = request.scheme
return http.HttpResponseRedirect('%s://%s%s' %
(protocol, object_domain, absurl))
else:
return http.HttpResponseRedirect(absurl)
def start(request):
if getattr(settings, "REDIRECT_START_PAGE", ""):
return http.HttpResponseRedirect(settings.REDIRECT_START_PAGE)
return render(request, "start.html")
def search(request, tag_name=None):
APP = request.APP
types = (amo.ADDON_EXTENSION, amo.ADDON_THEME, amo.ADDON_DICT,
amo.ADDON_SEARCH, amo.ADDON_LPAPP)
category = request.GET.get('cat')
if category == 'collections':
extra_params = {'sort': {'newest': 'created'}}
else:
extra_params = None
fixed = fix_search_query(request.GET, extra_params=extra_params)
if fixed is not request.GET:
# We generally want a 301, except if it's a "type", because that's only
# here to support the new frontend, so a permanent redirect could mess
# things up when the user is going back and forth between the old and
# new frontend. https://github.com/mozilla/addons-server/issues/6846
status = 302 if 'type' in request.GET else 301
return http.HttpResponseRedirect(urlparams(request.path, **fixed),
status=status)
facets = request.GET.copy()
# In order to differentiate between "all versions" and an undefined value,
# we use "any" instead of "" in the frontend.
if 'appver' in facets and facets['appver'] == 'any':
facets['appver'] = ''
form = ESSearchForm(facets or {})
form.is_valid() # Let the form try to clean data.
form_data = form.cleaned_data
if tag_name:
form_data['tag'] = tag_name
if category == 'themes' or form_data.get('atype') == amo.ADDON_STATICTHEME:
return _personas(request)
sort, extra_sort = split_choices(form.sort_choices, 'created')
if form_data.get('atype') == amo.ADDON_SEARCH:
# Search add-ons should not be searched by ADU, so replace 'Users'
# sort with 'Weekly Downloads'.
sort, extra_sort = list(sort), list(extra_sort)
sort[1] = extra_sort[1]
del extra_sort[1]
# Perform search, using aggregation so that we can build the facets UI.
# Note that we don't need to aggregate on platforms, that facet it built
# from our constants directly, using the current application for this
# request (request.APP).
appversion_field = 'current_version.compatible_apps.%s.max' % APP.id
qs = (Addon.search_public().filter(app=APP.id).aggregate(
tags={'terms': {
'field': 'tags'
}},
appversions={'terms': {
'field': appversion_field
}},
categories={'terms': {
'field': 'category',
'size': 200
}}))
filters = ['atype', 'appver', 'cat', 'sort', 'tag', 'platform']
mapping = {
'users': '-average_daily_users',
'rating': '-bayesian_rating',
'created': '-created',
'name': 'name.raw',
'downloads': '-weekly_downloads',
'updated': '-last_updated',
'hotness': '-hotness'
}
qs = _filter_search(request, qs, form_data, filters, mapping, types=types)
pager = amo.utils.paginate(request, qs)
ctx = {
'is_pjax': request.META.get('HTTP_X_PJAX'),
'pager': pager,
'query': form_data,
'form': form,
'sort_opts': sort,
'extra_sort_opts': extra_sort,
'sorting': sort_sidebar(request, form_data, form),
'sort': form_data.get('sort'),
}
if not ctx['is_pjax']:
aggregations = pager.object_list.aggregations
ctx.update({
'tag':
tag_name,
'categories':
category_sidebar(request, form_data, aggregations),
'platforms':
platform_sidebar(request, form_data),
'versions':
version_sidebar(request, form_data, aggregations),
'tags':
tag_sidebar(request, form_data, aggregations),
})
return render(request, 'search/results.html', ctx)
def form_valid(self, form):
user = form.save(commit=False)
user = create_user(user.email, user.first_name, user.last_name, form.cleaned_data['password1'], form.cleaned_data['newsletter'])
login(self.request, user)
return http.HttpResponseRedirect(self.get_success_url())
def login_begin_view(self, request, next=None):
"""View initiating the authgroupex authentication."""
next = next or request.GET.get('next')
auth_url = self.build_return_url(request, next)
return http.HttpResponseRedirect(auth_url)
def get(self, request, *args, **kwargs):
redirect_to = reverse('saas_user_product_list', args=(request.user, ))
next_url = self.request.GET.get(REDIRECT_FIELD_NAME, None)
if next_url:
redirect_to += '?%s=%s' % (REDIRECT_FIELD_NAME, next_url)
# We will attempt to assign the user to a profile.
# Find an organization with a matching e-mail domain.
if not self.role_model.objects.filter(user=self.request.user).exists():
# XXX copy/pasted from `OrganizationRedirectView`
domain = request.user.email.split('@')[-1].lower()
try:
user, organization = self.get_natural_profile(request)
# Find a RoleDescription we can implicitely grant to the user.
try:
if organization.get_roles().exists():
role_descr = RoleDescription.objects.filter(
Q(organization__isnull=True)
| Q(organization=organization),
implicit_create_on_none=True).get()
else:
# If this profile is not yet claimed by any user,
# then we implicitely grant a manager role.
role_descr = organization.get_role_description(
settings.MANAGER)
# Create a granted role implicitely, but only if the e-mail
# was verified.
next_url = self.get_redirect_url(*args, **kwargs)
if self.check_email_verified(request,
user,
next_url=next_url):
role = organization.add_role_request(
user, role_descr=role_descr)
if role.request_key:
# We have done an implicit grant of a manager role.
role.request_key = None
role.save()
# We create a profile-qualified url after the role
# has been granted otherwise the redirect specified
# in the verification of e-mail will lead to a
# 403 permission denied.
kwargs.update({self.slug_url_kwarg: organization})
next_url = self.get_redirect_url(*args, **kwargs)
return self.get_implicit_grant_response(
next_url, role, *args, **kwargs)
# We are redirecting because the e-mail must be verified
return self.get_implicit_grant_response(
redirect_to, None, *args, **kwargs)
except RoleDescription.DoesNotExist:
LOGGER.debug(
"'%s' does not have a role on any profile but"
" we cannot grant one implicitely because there is"
" no role description that permits it.", user)
except RoleDescription.MultipleObjectsReturned:
LOGGER.debug(
"'%s' does not have a role on any profile but"
" we cannot grant one implicitely because we have"
" multiple role description that permits it. Ambiguous.",
user)
except self.organization_model.DoesNotExist:
LOGGER.debug(
"'%s' does not have a role on any profile but"
" we cannot grant one implicitely because there is"
" no profiles with @%s e-mail domain.", request.user,
domain)
except self.organization_model.MultipleObjectsReturned:
LOGGER.debug(
"'%s' does not have a role on any profile but"
" we cannot grant one implicitely because @%s is"
" ambiguous. Multiple profiles share that email domain.",
request.user, domain)
# XXX This one must return to users/roles/!!!
return http.HttpResponseRedirect(redirect_to)
def redirect(url='./', *args, **kwargs):
if '/' not in url or args or kwargs:
url = urlresolvers.reverse(url, args=args, kwargs=kwargs)
return http.HttpResponseRedirect(url)
def logout(request):
auth.logout(request)
return http.HttpResponseRedirect("/")
def get(self, request, *args, **kwargs):
if request.user.is_authenticated():
return http.HttpResponseRedirect(settings.LOGIN_REDIRECT_URL)
return super(AccountAuthView, self).get(request, *args, **kwargs)
def package_delete(request, pk):
package = shortcuts.get_object_or_404(Package, pk=pk)
package.delete()
messages.info(request, 'Deleted {}'.format(package))
return http.HttpResponseRedirect(reverse('package_list'))
def do_delete(self):
self.object.editoritem.delete()
return http.HttpResponseRedirect(self.get_success_url())
def privacy(request, addon):
if not addon.privacy_policy:
return http.HttpResponseRedirect(addon.get_url_path())
return jingo.render(request, 'addons/privacy.html', {'addon': addon})
def done(self, form_list, **kwargs):
redirect = reverse('horizon:app-catalog:packages:index')
msg = _('Bundle successfully imported.')
LOG.info(msg)
messages.success(self.request, msg)
return http.HttpResponseRedirect(redirect)
def _record(request, addon):
# TODO(andym): simplify this.
logged = request.user.is_authenticated()
premium = addon.is_premium()
allow_anon_install = waffle.switch_is_active('anonymous-free-installs')
# Require login for premium.
if not logged and (premium or not allow_anon_install):
return http.HttpResponseRedirect(reverse('users.login'))
ctx = {'addon': addon.pk}
# Don't generate receipts if we're allowing logged-out install.
if logged or not allow_anon_install:
is_dev = request.check_ownership(addon,
require_owner=False,
ignore_disabled=True)
is_reviewer = acl.check_reviewer(request)
if (not addon.is_webapp()
or not addon.is_public() and not (is_reviewer or is_dev)):
raise http.Http404
if (premium and not addon.has_purchased(request.amo_user)
and not is_reviewer and not is_dev):
return http.HttpResponseForbidden()
# Log the install.
installed, c = Installed.objects.safer_get_or_create(
addon=addon, user=request.amo_user)
# Get download source from GET if it exists, if so get the download
# source object if it exists. Then grab a client data object to hook up
# with the Installed object.
download_source = DownloadSource.objects.filter(
name=request.REQUEST.get('src', None))
download_source = download_source[0] if download_source else None
try:
region = request.REGION.id
except AttributeError:
region = mkt.regions.WORLDWIDE.id
client_data, c = ClientData.objects.get_or_create(
download_source=download_source,
device_type=request.POST.get('device_type', ''),
user_agent=request.META.get('HTTP_USER_AGENT', ''),
is_chromeless=request.POST.get('chromeless', False),
language=request.LANG,
region=region)
installed.update(client_data=client_data)
# Look up to see if its in the receipt cache and log if we have
# to recreate it.
receipt = memoize_get('create-receipt', installed.pk)
error = ''
receipt_cef.log(request, addon, 'request', 'Receipt requested')
if not receipt:
receipt_cef.log(request, addon, 'sign', 'Receipt signing')
try:
receipt = create_receipt(installed.pk)
except SigningError:
error = _('There was a problem installing the app.')
ctx.update(receipt=receipt, error=error)
else:
if not addon.is_public() or not addon.is_webapp():
raise http.Http404
amo.log(amo.LOG.INSTALL_ADDON, addon)
send_request('install', request, {
'app-domain': addon.domain_from_url(addon.origin),
'app-id': addon.pk
})
return ctx
def done(self, form_list, **kwargs):
data = self.get_all_cleaned_data()
app_id = self.storage.get_step_data('upload')['package'].id
# Remove package file from result data
for key in ('package', 'import_type', 'url', 'repo_version',
'repo_name'):
del data[key]
dep_pkgs = self.storage.get_step_data('upload').get('dependencies', [])
installed_images = self.storage.get_step_data('upload').get(
'images', [])
redirect = reverse('horizon:app-catalog:packages:index')
dep_data = {'enabled': data['enabled'], 'is_public': data['is_public']}
murano_client = api.muranoclient(self.request)
for dep_pkg in dep_pkgs:
try:
murano_client.packages.update(dep_pkg.id, dep_data)
LOG.debug('Success update for package {0}.'.format(dep_pkg.id))
except Exception as e:
msg = _("Couldn't update package {0} parameters. Error: {1}")\
.format(dep_pkg.fully_qualified_name, e)
LOG.warning(msg)
messages.warning(self.request, msg)
# Images have been imported as private images during the 'upload' step
# If the package is public, make the required images public
if data['is_public']:
try:
glance_client = glance.glanceclient(self.request, '1')
except Exception:
glance_client = None
if glance_client:
for img in installed_images:
try:
glance_client.images.update(img['id'], is_public=True)
LOG.debug('Success update for image {0}'.format(
img['id']))
except Exception as e:
msg = _("Error {0} occurred while setting image {1}, "
"{2} public").format(e, img['name'], img['id'])
messages.error(self.request, msg)
LOG.exception(msg)
elif len(installed_images):
msg = _("Couldn't initialise glance v1 client, "
"therefore could not make the following images "
"public: {0}").format(' '.join(
[img['name'] for img in installed_images]))
messages.warning(self.request, msg)
LOG.warning(msg)
try:
data['tags'] = [t.strip() for t in data['tags'].split(',')]
murano_client.packages.update(app_id, data)
except exc.HTTPForbidden:
msg = _("You are not allowed to change"
" this properties of the package")
LOG.exception(msg)
exceptions.handle(
self.request,
msg,
redirect=reverse('horizon:app-catalog:packages:index'))
except (exc.HTTPException, Exception):
LOG.exception(_('Modifying package failed'))
exceptions.handle(self.request,
_('Unable to modify package'),
redirect=redirect)
else:
msg = _('Package parameters successfully updated.')
LOG.info(msg)
messages.success(self.request, msg)
return http.HttpResponseRedirect(redirect)
def group_edit(request, url=None):
"""Add or edit a group. (if there is a url we are editing)"""
profile = request.user.userprofile
is_manager = request.user.userprofile.is_manager
invites = None
forms_valid = True
group_forms = {}
form_key = None
show_delete_group_button = False
if not url:
return redirect(reverse('groups:index_groups'))
# Get the group to edit
group = get_object_or_404(Group, url=url)
# Only a group curator or an admin is allowed to edit a group
is_curator = profile in group.curators.all()
is_manager = request.user.userprofile.is_manager
if not (is_curator or is_manager):
messages.error(request, _('You must be a curator or an admin to edit a group'))
return redirect(reverse('groups:show_group', args=[group.url]))
invites = group.invites.filter(groups_invited__accepted=False)
show_delete_group_button = is_curator and group.members.all().count() == 1
# Prepare the forms for rendering
group_forms['basic_form'] = forms.GroupBasicForm
group_forms['curator_form'] = forms.GroupCuratorsForm
group_forms['terms_expiration_form'] = forms.GroupTermsExpirationForm
group_forms['invite_form'] = forms.GroupInviteForm
group_forms['admin_form'] = forms.GroupAdminForm
group_forms['criteria_form'] = forms.GroupCriteriaForm
group_forms['email_form'] = forms.GroupCustomEmailForm
# Do not allow community curators of an access group to modify it
if group.is_access_group and is_curator and not profile.can_create_access_groups:
# reset the form to include only the invitation form
group_forms = {'invite_form': forms.GroupInviteForm,
'email_form': forms.GroupCustomEmailForm}
def _init_group_forms(request, group_forms):
form_args = {
'data': None,
'instance': group,
'request': request
}
key = None
if request.POST:
form_args['data'] = request.POST
key, form = next(((k, v(**form_args)) for k, v in group_forms.items()
if k in request.POST), (None, None))
if key and form:
group_forms[key] = form
# Initialize the rest of the forms with non-POST data
form_args['data'] = None
for k in group_forms.keys():
if k != key:
group_forms[k] = group_forms[k](**form_args)
return key
form_key = _init_group_forms(request, group_forms)
form = group_forms[form_key] if form_key else None
if form and form.is_bound and form.is_valid():
form.save()
next_section = request.GET.get('next')
next_url = urlparams(reverse('groups:group_edit', args=[group.url]), next_section)
return http.HttpResponseRedirect(next_url)
elif request.POST:
forms_valid = False
# check if any of the following forms exist in order to show the access tab
show_access_edit_option = any(form in group_forms for form in ('curator_form',
'criteria_form',
'term_expiration_form'))
context = {
'group': group if url else None,
'invites': invites if group else None,
'forms_valid': forms_valid,
'user_is_curator': is_curator,
'user_is_manager': is_manager,
'user_can_create_access_groups': profile.can_create_access_groups,
'show_access_edit_option': show_access_edit_option,
'show_delete_group_button': show_delete_group_button
}
context.update(group_forms)
return render(request, 'groups/edit_group.html', context)
def from_id(request, event_id):
event = get_object_or_404(models.Event, pk=event_id)
return http.HttpResponseRedirect(
reverse('event', kwargs={'event_hash': event.hash}))
def edit_privacy(request, collection, username, slug):
collection.listed = not collection.listed
collection.save()
log.info(u'%s changed privacy on collection %s' %
(request.amo_user, collection.id))
return http.HttpResponseRedirect(collection.get_url_path())
def redirect_to_profile(request):
return http.HttpResponseRedirect(
reverse('user-recent', args=[request.user.username]))
def form_valid(self, form):
self.save_form(form)
return http.HttpResponseRedirect(self.get_success_url())
def _record(request, addon):
# TODO(andym): we have an API now, replace this with that.
logged = request.user.is_authenticated()
premium = addon.is_premium()
# Require login for premium.
if not logged and premium:
return http.HttpResponseRedirect(reverse('users.login'))
ctx = {'addon': addon.pk}
# Don't generate receipts if we're allowing logged-out install.
if logged:
is_dev = request.check_ownership(addon,
require_owner=False,
ignore_disabled=True,
admin=False)
is_reviewer = acl.check_reviewer(request)
if (not addon.is_webapp()
or not addon.is_public() and not (is_reviewer or is_dev)):
raise http.Http404
if (premium and not addon.has_purchased(request.amo_user)
and not is_reviewer and not is_dev):
raise PermissionDenied
# If you are reviewer, you get a user receipt. Use the reviewer tools
# to get a reviewer receipt. App developers still get their special
# receipt.
install_type = (apps.INSTALL_TYPE_DEVELOPER
if is_dev else apps.INSTALL_TYPE_USER)
# Log the install.
installed, c = Installed.objects.get_or_create(
addon=addon, user=request.amo_user, install_type=install_type)
# Get download source from GET if it exists, if so get the download
# source object if it exists. Then grab a client data object to hook up
# with the Installed object.
download_source = DownloadSource.objects.filter(
name=request.REQUEST.get('src', None))
download_source = download_source[0] if download_source else None
try:
region = request.REGION.id
except AttributeError:
region = mkt.regions.RESTOFWORLD.id
client_data, c = ClientData.objects.get_or_create(
download_source=download_source,
device_type=request.POST.get('device_type', ''),
user_agent=request.META.get('HTTP_USER_AGENT', ''),
is_chromeless=request.POST.get('chromeless', False),
language=request.LANG,
region=region)
installed.update(client_data=client_data)
error = ''
receipt_cef.log(request, addon, 'sign', 'Receipt requested')
try:
receipt = create_receipt(installed)
except SigningError:
error = _('There was a problem installing the app.')
ctx.update(receipt=receipt, error=error)
else:
if not addon.is_public() or not addon.is_webapp():
raise http.Http404
amo.log(amo.LOG.INSTALL_ADDON, addon)
record_action(
'install', request, {
'app-domain': addon.domain_from_url(addon.origin, allow_none=True),
'app-id': addon.pk,
'anonymous': request.user.is_anonymous(),
})
return ctx
def get_success_response(self):
return http.HttpResponseRedirect('{}?reference_id={}'.format(
reverse('checkout:payment-details'), self.reference_id))
def submit(self, user, basket, shipping_address, shipping_method, # noqa (too complex (10))
shipping_charge, billing_address, order_total,
payment_kwargs=None, order_kwargs=None):
"""
Submit a basket for order placement.
The process runs as follows:
* Generate an order number
* Freeze the basket so it cannot be modified any more (important when
redirecting the user to another site for payment as it prevents the
basket being manipulated during the payment process).
* Attempt to take payment for the order
- If payment is successful, place the order
- If a redirect is required (eg PayPal, 3DSecure), redirect
- If payment is unsuccessful, show an appropriate error message
:basket: The basket to submit.
:payment_kwargs: Additional kwargs to pass to the handle_payment
method. It normally makes sense to pass form
instances (rather than model instances) so that the
forms can be re-rendered correctly if payment fails.
:order_kwargs: Additional kwargs to pass to the place_order method
"""
if payment_kwargs is None:
payment_kwargs = {}
if order_kwargs is None:
order_kwargs = {}
# Taxes must be known at this point
assert basket.is_tax_known, (
"Basket tax must be set before a user can place an order")
assert shipping_charge.is_tax_known, (
"Shipping charge tax must be set before a user can place an order")
# We generate the order number first as this will be used
# in payment requests (ie before the order model has been
# created). We also save it in the session for multi-stage
# checkouts (eg where we redirect to a 3rd party site and place
# the order on a different request).
order_number = self.generate_order_number(basket)
self.checkout_session.set_order_number(order_number)
logger.info("Order #%s: beginning submission process for basket #%d",
order_number, basket.id)
# Freeze the basket so it cannot be manipulated while the customer is
# completing payment on a 3rd party site. Also, store a reference to
# the basket in the session so that we know which basket to thaw if we
# get an unsuccessful payment response when redirecting to a 3rd party
# site.
self.freeze_basket(basket)
self.checkout_session.set_submitted_basket(basket)
# We define a general error message for when an unanticipated payment
# error occurs.
error_msg = _("A problem occurred while processing payment for this "
"order - no payment has been taken. Please "
"contact customer services if this problem persists")
signals.pre_payment.send_robust(sender=self, view=self)
try:
self.handle_payment(order_number, order_total, **payment_kwargs)
except RedirectRequired as e:
# Redirect required (eg PayPal, 3DS)
logger.info("Order #%s: redirecting to %s", order_number, e.url)
return http.HttpResponseRedirect(e.url)
except UnableToTakePayment as e:
# Something went wrong with payment but in an anticipated way. Eg
# their bankcard has expired, wrong card number - that kind of
# thing. This type of exception is supposed to set a friendly error
# message that makes sense to the customer.
msg = six.text_type(e)
logger.warning(
"Order #%s: unable to take payment (%s) - restoring basket",
order_number, msg)
self.restore_frozen_basket()
# We assume that the details submitted on the payment details view
# were invalid (eg expired bankcard).
return self.render_payment_details(
self.request, error=msg, **payment_kwargs)
except PaymentError as e:
# A general payment error - Something went wrong which wasn't
# anticipated. Eg, the payment gateway is down (it happens), your
# credentials are wrong - that king of thing.
# It makes sense to configure the checkout logger to
# mail admins on an error as this issue warrants some further
# investigation.
msg = six.text_type(e)
logger.error("Order #%s: payment error (%s)", order_number, msg,
exc_info=True)
self.restore_frozen_basket()
return self.render_preview(
self.request, error=error_msg, **payment_kwargs)
except Exception as e:
# Unhandled exception - hopefully, you will only ever see this in
# development...
logger.error(
"Order #%s: unhandled exception while taking payment (%s)",
order_number, e, exc_info=True)
self.restore_frozen_basket()
return self.render_preview(
self.request, error=error_msg, **payment_kwargs)
signals.post_payment.send_robust(sender=self, view=self)
# If all is ok with payment, try and place order
logger.info("Order #%s: payment successful, placing order",
order_number)
try:
return self.handle_order_placement(
order_number, user, basket, shipping_address, shipping_method,
shipping_charge, billing_address, order_total, **order_kwargs)
except UnableToPlaceOrder as e:
# It's possible that something will go wrong while trying to
# actually place an order. Not a good situation to be in as a
# payment transaction may already have taken place, but needs
# to be handled gracefully.
msg = six.text_type(e)
logger.error("Order #%s: unable to place order - %s",
order_number, msg, exc_info=True)
self.restore_frozen_basket()
return self.render_preview(
self.request, error=msg, **payment_kwargs)
def plugin_check_redirect(request):
return http.HttpResponseRedirect('%s?%s' % (
settings.PFS_URL, iri_to_uri(request.META.get('QUERY_STRING', ''))))
def form_valid(self, form):
self.request.user.delete()
messages.success(
self.request,
_("Your profile has now been deleted. Thanks for using the site."))
return http.HttpResponseRedirect(self.get_success_url())
