Source code for shuup.front.apps.customer_information.views

# -*- coding: utf-8 -*-
# This file is part of Shuup.
#
# Copyright (c) 2012-2017, Shoop Commerce Ltd. All rights reserved.
#
# This source code is licensed under the OSL-3.0 license found in the
# LICENSE file in the root directory of this source tree.
import six
from django.contrib import messages
from django.contrib.auth.forms import PasswordChangeForm
from django.contrib.auth.views import password_change
from django.http import HttpResponseNotFound
from django.shortcuts import redirect
from django.utils.translation import ugettext_lazy as _
from django.views.generic import FormView, TemplateView
from registration.signals import user_registered

from shuup import configuration
from shuup.core.models import (
    get_company_contact, get_person_contact, MutableAddress, SavedAddress
)
from shuup.front.views.dashboard import DashboardViewMixin
from shuup.utils.form_group import FormGroup
from shuup.utils.importing import cached_load

from .forms import CompanyContactForm, PersonContactForm, SavedAddressForm
from .notify_events import CompanyAccountCreated


[docs]class PasswordChangeView(DashboardViewMixin, TemplateView):
    template_name = "shuup/customer_information/change_password.jinja"

[docs]    def post(self, *args, **kwargs):
        response = password_change(
            self.request,
            post_change_redirect="shuup:customer_edit",
            template_name=self.template_name
        )
        if response.status_code == 302:
            messages.success(self.request, _("Password successfully changed."))
        return response

[docs]    def get_context_data(self, **kwargs):
        context = super(PasswordChangeView, self).get_context_data(**kwargs)
        context["form"] = PasswordChangeForm(user=self.request.user)
        return context


[docs]class CustomerEditView(DashboardViewMixin, FormView):
    template_name = "shuup/customer_information/edit_customer.jinja"

    def get_form(self, form_class):
        contact = get_person_contact(self.request.user)
        form_group = FormGroup(**self.get_form_kwargs())
        address_form_class = cached_load("SHUUP_ADDRESS_MODEL_FORM")
        form_group.add_form_def("billing", address_form_class, kwargs={"instance": contact.default_billing_address})
        form_group.add_form_def("shipping", address_form_class, kwargs={"instance": contact.default_shipping_address})
        form_group.add_form_def("contact", PersonContactForm, kwargs={"instance": contact})
        return form_group

[docs]    def form_valid(self, form):
        contact = form["contact"].save()
        user = contact.user
        billing_address = form["billing"].save()
        shipping_address = form["shipping"].save()
        if billing_address.pk != contact.default_billing_address_id:  # Identity changed due to immutability
            contact.default_billing_address = billing_address
        if shipping_address.pk != contact.default_shipping_address_id:  # Identity changed due to immutability
            contact.default_shipping_address = shipping_address

        if not bool(get_company_contact(self.request.user)):  # Only update user details for non-company members
            user.email = contact.email
            user.first_name = contact.first_name
            user.last_name = contact.last_name
            user.save()

        contact.save()
        messages.success(self.request, _("Account information saved successfully."))
        return redirect("shuup:customer_edit")


[docs]class CompanyEditView(DashboardViewMixin, FormView):
    template_name = "shuup/customer_information/edit_company.jinja"

[docs]    def dispatch(self, request, *args, **kwargs):
        if not configuration.get(None, "allow_company_registration"):
            return HttpResponseNotFound()
        return super(CompanyEditView, self).dispatch(request, *args, **kwargs)

    def get_form(self, form_class):
        user = self.request.user
        company = get_company_contact(user)
        person = get_person_contact(user)
        form_group = FormGroup(**self.get_form_kwargs())
        address_form_class = cached_load("SHUUP_ADDRESS_MODEL_FORM")
        form_group.add_form_def(
            "billing",
            address_form_class,
            kwargs={
                "instance": _get_default_address_for_contact(company, "default_billing_address", person)
            }
        )
        form_group.add_form_def(
            "shipping",
            address_form_class,
            kwargs={
                "instance": _get_default_address_for_contact(company, "default_shipping_address", person)
            }
        )
        form_group.add_form_def("contact", CompanyContactForm, kwargs={"instance": company})
        return form_group

[docs]    def form_valid(self, form):
        company = form["contact"].save(commit=False)
        is_new = not bool(company.pk)
        company.save()
        user = self.request.user
        person = get_person_contact(user)
        company.members.add(person)
        billing_address = form["billing"].save()
        shipping_address = form["shipping"].save()
        if billing_address.pk != company.default_billing_address_id:  # Identity changed due to immutability
            company.default_billing_address = billing_address
        if shipping_address.pk != company.default_shipping_address_id:  # Identity changed due to immutability
            company.default_shipping_address = shipping_address

        user.email = company.email
        user.first_name = company.name
        user.last_name = ""
        user.save()

        message = _("Company information saved successfully.")
        # If company registration requires activation,
        # company will be created as inactive.
        if is_new and configuration.get(None, "company_registration_requires_approval"):
            company.is_active = False
            message = _("Company information saved successfully. "
                        "Please follow the instructions sent to your email address.")

        company.save()
        if is_new:
            user_registered.send(sender=self.__class__,
                                 user=self.request.user,
                                 request=self.request)
            CompanyAccountCreated(contact=company, customer_email=company.email).run()

        messages.success(self.request, message)
        return redirect("shuup:company_edit")


[docs]class AddressBookView(DashboardViewMixin, TemplateView):
    template_name = "shuup/customer_information/addressbook/index.jinja"

[docs]    def get_context_data(self, **kwargs):
        context = super(AddressBookView, self).get_context_data(**kwargs)
        context["addresses"] = SavedAddress.objects.filter(owner=self.request.customer)
        context["customer"] = self.request.customer
        return context


[docs]class AddressBookEditView(DashboardViewMixin, FormView):
    template_name = "shuup/customer_information/addressbook/edit.jinja"
    form_class = SavedAddressForm
    instance = None

[docs]    def dispatch(self, request, *args, **kwargs):
        try:
            self.instance = SavedAddress.objects.get(pk=kwargs.get("pk", 0), owner=self.request.customer)
        except:
            self.instance = None
        return super(AddressBookEditView, self).dispatch(request, *args, **kwargs)

    def get_form(self, form_class):
        form_group = FormGroup(**self.get_form_kwargs())
        address_kwargs = {}
        saved_address_kwargs = {}
        if self.instance:
            address_kwargs["instance"] = self.instance.address
            saved_address_kwargs["initial"] = {
                "role": self.instance.role,
                "status": self.instance.status,
                "title": self.instance.title,
            }

        form_group.add_form_def("address", cached_load("SHUUP_ADDRESS_MODEL_FORM"), kwargs=address_kwargs)
        form_group.add_form_def(
            "saved_address",
            SavedAddressForm,
            kwargs=saved_address_kwargs
        )
        return form_group

[docs]    def form_valid(self, form):
        address_form = form["address"]
        if self.instance:
            # expect old
            address = MutableAddress.objects.get(pk=self.instance.address.pk)
            for k, v in six.iteritems(address_form.cleaned_data):
                setattr(address, k, v)
            address.save()
        else:
            address = address_form.save()
        owner = self.request.customer
        saf = form["saved_address"]
        saved_address, updated = SavedAddress.objects.update_or_create(
            owner=owner,
            address=address,
            defaults={
                "title": saf.cleaned_data.get("title"),
                "role": saf.cleaned_data.get("role"),
                "status": saf.cleaned_data.get("status")
            }
        )
        messages.success(self.request, _("Address information saved successfully."))
        return redirect("shuup:address_book_edit", pk=saved_address.pk)


[docs]def delete_address(request, pk):
    try:
        SavedAddress.objects.get(pk=pk, owner=request.customer).delete()
    except SavedAddress.DoesNotExist:
        messages.error(request, _("Cannot remove address"))
    return redirect("shuup:address_book")


def _get_default_address_for_contact(contact, address_attr, fallback_contact):
    if contact and getattr(contact, address_attr, None):
        return getattr(contact, address_attr)
    if fallback_contact and getattr(fallback_contact, address_attr, None):
        return getattr(fallback_contact, address_attr)
    return None