pbp_com/apps/storefront/views.py

import json
from django.core.mail import send_mail
import locale
import logging

from django.contrib.auth import login
from django.core.serializers.json import DjangoJSONEncoder
from django.core.urlresolvers import reverse
from django.conf import settings
from django.forms import model_to_dict
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response, get_object_or_404
from django.template import RequestContext

from accounts.forms import (ProfileSecondaryAddressForm, ProfileUpdateForm,
                            ProfileCreateForm)
from accounts.profile import get_profile, get_profile_secondary_address
from accounts import utils as account_utils

from cart.cart import add_to_cart, remove_subscriptions
from catalog import models as catalog_models
from catalog.models import Subscription
from catalog.utils import get_type_by_profile, get_type

from . import constants
from . import forms
from . import utils


LOG = logging.getLogger(__name__)
STOREFRONT_HELP_TO = getattr(settings, 'STOREFRONT_HELP_TO')


def storefront_help(request):
    """ Store Help  """

    form = forms.HelpForm(request.POST or None)
    if request.method == 'POST':
        if form.is_valid():
            message = ''.join(["{0}: {1}\n".format(
                key, value) for key, value in form.cleaned_data.iteritems()])
            LOG.info("Help Form Contents (Sending To: {0}): {1}".format(
                STOREFRONT_HELP_TO, message))
            send_mail(
                'PBP Community Storefront Feedback',
                message,
                'subscriptions@pbp.me',
                [STOREFRONT_HELP_TO],
                fail_silently=True)
            return HttpResponseRedirect(reverse('help_confirm'))

    return render_to_response(
        "storefront/help.html", {"form": form},
        context_instance=RequestContext(request))


def storefront_help_confirm(request):
    """ Store Help Confirmation Page"""
    return render_to_response(
        "storefront/help_confirm.html", context_instance=RequestContext(
            request))


def storefront_privacy(request):
    """ Store Help  """
    return render_to_response(
        "storefront/privacy.html", context_instance=RequestContext(request))


def storefront_index(request):
    """ Store Front Home page """
    return render_to_response(
        "storefront/index.html", context_instance=RequestContext(request))


def category(request, category):
    """ Category page """
    # TODO: security, etc
    # TODO: sorting by price, or title.
    config = {'movie': catalog_models.Movie,
              'book': catalog_models.Book,
              'map': catalog_models.Map}
    sort_type = {'p': 'price', '-p': '-price', 't': 'title', '-t': '-title'}
    sort = request.GET.get('sort', 't')
    sort_by = sort_type.get(sort)
    model = config.get(category)
    # sort by title or price, asc or desc default to title asc
    items = model.objects.active().order_by(sort_by)

    return render_to_response(
        "storefront/category.html", {'items': items, 'category': category,
                                     'sort_by': sort_by},
        context_instance=RequestContext(request))


def item_price(request):
    """ Ajax call to return the item price """

    def _currency(value):
        """ convert value to a nice looking currency """
        try:
            locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
        except Exception:
            locale.setlocale(locale.LC_ALL, '')
        loc = locale.localeconv()
        return locale.currency(value, loc['currency_symbol'], grouping=True)

    response_data = "$N/A"

    if request.method == 'POST':
        try:
            LOG.debug("Post info: {0}".format(request.POST))

            # use the form data to determine the shipping_type
            region1 = request.POST.get('region1', None)
            postal_code1 = request.POST.get('postal_code1', None)
            country_code1 = request.POST.get('country_code1', None)
            region2 = request.POST.get('region2', None)
            postal_code2 = request.POST.get('postal_code2', None)
            country_code2 = request.POST.get('country_code2', None)
            shipping_type = get_type(
                postal_code1, region1, country_code1,
                postal_code2=postal_code2, region2=region2,
                country_code2=country_code2)
            LOG.debug("Found shipping type as: {0}".format(shipping_type))

            # Recast the id values to searchable values
            title = request.POST.get('title', None)
            duration = request.POST.get('duration', None)
            shipping_method = request.POST.get('shipping_method', None)
            title = utils.get_value_by_index(
                utils.unique_titles(shipping_type), title)
            duration = utils.get_value_by_index(
                utils.unique_durations(shipping_type), duration)
            shipping_method = utils.get_value_by_index(
                utils.unique_shipping_methods(), shipping_method)
            LOG.debug("{0}, {1}, {2}, {3}".format(
                title, duration, shipping_method, shipping_type))

            try:
                # Renewals are the same price as regular. This might
                # need to change if that changes
                subscription = Subscription.objects.get(
                    title=title, duration=duration,
                    shipping_type=shipping_type,
                    shipping_method=shipping_method,
                    renewal=False)
                response_data = _currency(subscription.price)
            except Subscription.DoesNotExist:
                pass
        except Exception, e:
            LOG.error(e)
            raise e

    return HttpResponse(
        json.dumps(response_data, cls=DjangoJSONEncoder),
        content_type="application/json")


def item_detail(request, sku):
    item = get_object_or_404(catalog_models.Item, sku=sku).child
    return render_to_response("storefront/item_detail.html", {'item': item},
                              context_instance=RequestContext(request))


def subscription_home(request):
    """ Subscription Home page """
    return render_to_response(
        "storefront/subscriptions_home.html",
        context_instance=RequestContext(request))


def choose_new_subscription(
        request, template="storefront/subscriptions_new.html"):
    """ View used to manage a new subscription """
    def _render(request, form, user_form, second_address_form, shipping_type):
        return render_to_response(
            template, {'form': form, 'userform': user_form,
                       'second_address': second_address_form,
                       'type': shipping_type},
            context_instance=RequestContext(request))

    # set some sane defaults
    user = request.user
    subscription_initial = {'duration': 1}
    primary_initial = {'region': 'ME', 'country': 'US'}
    secondary_initial = {}
    shipping_type = get_type(None, 'ME', 'US')

    if user.is_authenticated():
        profile = get_profile(user)
        secondary_address = get_profile_secondary_address(user)
        shipping_type = get_type_by_profile(profile)
        primary_initial = model_to_dict(user)
        primary_initial.update(model_to_dict(profile))
        secondary_initial = model_to_dict(secondary_address)

        user_form = ProfileUpdateForm(
            user, request.POST or None, initial=primary_initial,
            prefix='form2')
    else:
        user_form = ProfileCreateForm(
            request.POST or None, initial=primary_initial, prefix='form2')

    form = forms.SubscriptionForm(
        request.POST or None, initial=subscription_initial,
        shipping_type=shipping_type, prefix='form1')
    second_address_form = ProfileSecondaryAddressForm(
        request.POST or None, initial=secondary_initial, prefix='form3')

    if request.method == 'POST' and user_form.is_valid() and \
            second_address_form.is_valid():

            # we've called is_valid for both the profile and address forms
            shipping_type = get_type(
                user_form.cleaned_data.get('postal_code', None),
                user_form.cleaned_data.get('region', None),
                user_form.cleaned_data.get('country', None),
                postal_code2=second_address_form.cleaned_data.get(
                    'postal_code', None),
                region2=second_address_form.cleaned_data.get('region', None),
                country_code2=second_address_form.cleaned_data.get('country',
                                                                   None))
            form = forms.SubscriptionForm(
                request.POST or None, shipping_type=shipping_type,
                initial=subscription_initial, prefix='form1')

            if form.is_valid():
                user = user_form.save(request=request)
                second_address_form.save(user=user)
                subscription = form.save()

                remove_subscriptions(request)
                add_to_cart(request, subscription, quantity=1)

                return HttpResponseRedirect(reverse('checkout'))

    return _render(request, form, user_form, second_address_form,
                   shipping_type)


def choose_gift_subscription(
        request, template='storefront/subscriptions_gift_subs.html'):

    def render(subscription_form, gift_from_form, gift_to_form,
               gift_info_form):
        return render_to_response(
            template, {
                'form': subscription_form,
                'gift_from': gift_from_form,
                'gift_to': gift_to_form,
                'gift_info_form': gift_info_form},
            context_instance=RequestContext(request))

    # set some sane defaults
    shipping_type = get_type(None, 'ME', 'US')
    subscription_initial = {'duration': 1}
    gift_from_initial = {'region': 'ME', 'country': 'US'}
    gift_to_initial = {'region': 'ME', 'country': 'US'}
    user = request.user

    LOG.debug("Checking authentication status...")
    if user.is_authenticated():
        LOG.debug("User is authenticated...creating user specific forms.")
        gift_from_initial = model_to_dict(user)
        gift_from_initial.update(model_to_dict(user.get_profile()))
        shipping_type = get_type_by_profile(get_profile(user))
        gift_from_form = ProfileUpdateForm(
            user, request.POST or None, initial=gift_from_initial,
            prefix='form5')
    else:
        LOG.debug("User is not authenticated...creating user creation forms.")
        gift_from_form = ProfileCreateForm(
            request.POST or None, initial=gift_from_initial, prefix='form5')

    subscription_form = forms.SubscriptionForm(
        request.POST or None, shipping_type=shipping_type,
        initial=subscription_initial, prefix='form1')
    gift_to_form = forms.GiftToForm(
        request.POST or None, initial=gift_to_initial, prefix='form2')
    gift_info_form = forms.GiftInformationForm(
        request.POST or None, prefix='form4')

    if request.method == 'POST' and gift_from_form.is_valid():

        LOG.debug("Processing POST data...")
        # we've called is_valid on the gift from form and since we are
        # here..it is. We intentionally have not called saved so that a user
        # isn't created yet as this would cause confusion if the other forms
        # do not validate. We need the data from the cleaned form to pass to
        # the Subscription form which will determine if the subscription type
        # is valid.
        shipping_type = get_type(
            gift_from_form.cleaned_data.get('postal_code', None),
            gift_from_form.cleaned_data.get('region', None),
            gift_from_form.cleaned_data.get('country', None))
        subscription_form = forms.SubscriptionForm(
            request.POST or None, shipping_type=shipping_type,
            initial=subscription_initial, prefix='form1')

        LOG.debug("Checking validity of forms....")
        if gift_to_form.is_valid() and subscription_form.is_valid() and \
                gift_info_form.is_valid() and gift_from_form.is_valid():

                    LOG.debug("Forms are valid...processing.")
                    gift_from_form.save(request=request)
                    subscription = subscription_form.save()
                    gift_to_form.save()
                    gift_detail = gift_to_form.cleaned_data or {}
                    gift_detail.update(gift_info_form.cleaned_data)

                    remove_subscriptions(request)
                    add_to_cart(
                        request, subscription, gift_detail=gift_detail,
                        quantity=1)

                    return HttpResponseRedirect(reverse('checkout'))

        else:
            LOG.debug("Forms are not valid.")
            LOG.debug("subscription_form: {0}".format(subscription_form))
            LOG.debug("gift_from_form: {0}".format(gift_from_form))
            LOG.debug("gift_to_form: {0}".format(gift_to_form))
            LOG.debug("gift_info_form: {0}".format(gift_info_form))

    return render(subscription_form, gift_from_form, gift_to_form,
                  gift_info_form)


def change_of_address(
        request, template='storefront/subscriptions_change_address.html'):
    """ Submits a change of address form.  If the user is not logged in, it
    also creates a new user account.
    """

    # set some sane defaults
    user = request.user
    primary_initial = {'region': 'ME', 'country': 'US'}
    old_address_initial = {'region': 'ME', 'country': 'US'}
    form = forms.ChangeOfAddressForm(
        request.POST or None,
        initial={'date_effective': constants.NEXT_ISSUE})

    if user.is_authenticated():
        profile = get_profile(user)
        old_address_initial = model_to_dict(user)
        old_address_initial.update(model_to_dict(profile))

        old_address = forms.AddressForm(
            request.POST or None, initial=old_address_initial,
            prefix='form5')
        new_address = ProfileUpdateForm(
            user, request.POST or None, initial=primary_initial,
            prefix='form2')
    else:
        old_address = forms.AddressForm(
            request.POST or None, initial=old_address_initial, prefix='form5')
        new_address = ProfileCreateForm(
            request.POST or None, initial=primary_initial, prefix='form2')

    if request.method == 'POST':
        if (form.is_valid() and old_address.is_valid() and
                new_address.is_valid()):

            new_address.save(request=request)

            # recast the title index from the form to the
            #  actual title
            raw_title = form.cleaned_data.get('title', None)
            title = utils.get_value_by_index(
                utils.unique_titles(), raw_title)

            old_address_initial.update(old_address.cleaned_data)
            account_utils.send_change_of_address_email(
                title,
                form.cleaned_data.get('account_number', None),
                form.cleaned_data.get('date_effective', None),
                form.cleaned_data.get('from_date', None),
                form.cleaned_data.get('to_date', None),
                old_address_initial,
                new_address.cleaned_data)

            return HttpResponseRedirect(
                reverse('subscriptions_address_change_complete'))

    return render_to_response(
        template, {
            'form': form,
            'old_address': old_address,
            'new_address': new_address},
        context_instance=RequestContext(request))


def change_of_address_complete(
        request,
        template='storefront/subscriptions_change_address_complete.html'):

    user = request.user
    new_address_initial = model_to_dict(user)
    new_address_initial.update(model_to_dict(user.get_profile()))
    new_address = forms.AddressForm(initial=new_address_initial)

    return render_to_response(
        template, {'new_address': new_address},
        context_instance=RequestContext(request))


def subscriptions_renew(
        request, template='storefront/subscriptions_renewals.html'):

    def _render(request, form, userform, second_address_form, shipping_type):
        return render_to_response(
            template, {
                'form': form, 'userform': userform,
                'second_address': second_address_form, 'type': shipping_type},
            context_instance=RequestContext(request))

    # set some sane defaults
    user = request.user
    subscription_initial = {'duration': 1}
    primary_initial = {'region': 'ME', 'country': 'US'}
    secondary_initial = {}
    shipping_type = get_type(None, 'ME', 'US')

    if user.is_authenticated():
        profile = get_profile(user)
        secondary_address = get_profile_secondary_address(user)
        shipping_type = get_type_by_profile(profile)
        primary_initial = model_to_dict(user)
        primary_initial.update(model_to_dict(profile))
        secondary_initial = model_to_dict(secondary_address)

        userform = ProfileUpdateForm(
            user, request.POST or None, initial=primary_initial,
            prefix='form2')
    else:
        userform = ProfileCreateForm(
            request.POST or None, initial=primary_initial, prefix='form2')

    subscription_form = forms.SubscriptionForm(
        request.POST or None, initial=subscription_initial,
        shipping_type=shipping_type, prefix='form1', use_account_number=True,
        renewal=True)
    second_address_form = ProfileSecondaryAddressForm(
        request.POST or None, initial=secondary_initial, prefix='form3')

    if request.method == 'POST' and userform.is_valid() and \
            second_address_form.is_valid():

            # we've called is_valid for both the profile and address forms
            shipping_type = get_type(
                userform.cleaned_data.get('postal_code', None),
                userform.cleaned_data.get('region', None),
                userform.cleaned_data.get('country', None),
                postal_code2=second_address_form.cleaned_data.get(
                    'postal_code', None),
                region2=second_address_form.cleaned_data.get('region', None),
                country_code2=second_address_form.cleaned_data.get(
                    'country', None))
            subscription_form = forms.SubscriptionForm(
                request.POST or None, shipping_type=shipping_type,
                initial=subscription_initial, prefix='form1',
                use_account_number=True, renewal=True)

            if subscription_form.is_valid():
                user = userform.save(request=request)
                if not user.is_authenticated():
                    login(request, user)
                second_address_form.save(user=user)
                subscription = subscription_form.save()

                account_number = \
                    subscription_form.cleaned_data['account_number']
                remove_subscriptions(request)
                add_to_cart(request, subscription,
                            account_number=account_number, quantity=1)
                return HttpResponseRedirect(reverse('checkout'))

    return _render(request, subscription_form, userform, second_address_form,
                   shipping_type)