Example1

# -*- coding: utf-8 -*-

import json

from django.utils import timezone
from django.shortcuts import redirect, get_object_or_404, render_to_response, \
    RequestContext
from django.core.urlresolvers import reverse, reverse_lazy
from django.db import IntegrityError
from django.http import Http404, HttpResponse, HttpResponseRedirect
from django.views.generic.base import View
from django.views.generic import ListView, DetailView, FormView, TemplateView
from django.utils import translation
from django.contrib import auth, messages
from django.db.models import Q, Count
from django.core.mail import send_mail, EmailMultiAlternatives
from django.template.loader import get_template, render_to_string
from django.utils.translation import ugettext_lazy as _
from django.core.mail import send_mail
from django.conf import settings
from django.core.paginator import Paginator, EmptyPage
from django.forms.models import inlineformset_factory
from django.core.exceptions import ObjectDoesNotExist
from django.contrib.gis.geoip import GeoIP
from django import forms
from django.contrib import auth
from dateutil.relativedelta import relativedelta

from apps.order.forms import OrderForm, OrderListFilterForm, OrderAddressForm, \
    SaveFilterForm, OrderBetForm, ReviewCarrierForm, ReviewCarrierMessageForm
from apps.order.models import Order, OrderCategory, OrderAddress, OrderBet, \
    OrderReportKind, OrderReport, ReviewCarrier
from apps.order.utils import calc_dist
from apps.profile.utils import get_client_ip, UserRating, CarrierRequiredMixin, \
    LoginRequiredMixin, create_payment_data
from apps.profile.tasks import update_rating
from apps.main import notification
from apps.order import tasks as order_tasks


class OrderFormView(FormView):
    model = Order
    template_name = 'order/order_category_form.html'
    form_class = OrderForm
    formset_class = inlineformset_factory(
        Order,
        OrderAddress,
        extra=2,
        can_delete=False,
        form=OrderAddressForm)
    success_url = reverse_lazy('order:order_list')

    def get_formset(self, **kwargs):
        return self.formset_class(
            self.request.POST or None, self.request.FILES or None, **kwargs)

    def send_reg_email(self, obj, form):
        if form.is_create_user:
            notification.reg(
                user=obj.user,
                password=form.random_password,
            )

    def send_add_order_mail(self, obj, form):
        notification.order_create(obj)

    def success_message(self, obj):
        messages.success(
            self.request,
            _(u'Ваша заявка №%(num)s-"%(name)s" создана.') % dict(
                num=obj.pk,
                name=obj.name)
        )

    def get_context_data(self, **kwargs):
        ctx = super(OrderFormView, self).get_context_data(**kwargs)
        ctx['order'] = get_object_or_404(
            OrderCategory, pk=self.kwargs.get('category_pk'))
        ctx['formset'] = self.get_formset()

        g = GeoIP()
        client_ip = get_client_ip(self.request)
        ctx['client_city'] = g.city(client_ip)
        ctx['form_url'] = reverse_lazy('order:order_form', kwargs={'category_pk': self.kwargs.get('category_pk')})
        return ctx

    def get_form_kwargs(self):
        kwargs = super(OrderFormView, self).get_form_kwargs()
        category = get_object_or_404(
            OrderCategory, pk=self.kwargs.get('category_pk'))
        kwargs['category'] = category
        kwargs['user'] = self.request.user
        if self.request.session.get('currency'):
            kwargs['currency'] = self.request.session.get('currency')
        return kwargs

    def form_valid(self, form):
        formset = self.get_formset()
        data = dict()

        if form.is_valid() and formset.is_valid():
            obj = form.save(commit=False)
            category = get_object_or_404(
                OrderCategory, pk=self.kwargs.get('category_pk'))
            obj.category = category
            obj.save()
            formset = self.get_formset(instance=obj)

            #указываем тип для формсета(пункт отправки, назначения и тд.)
            addrss_list = list()
            dist = 0
            for i, row in enumerate(formset):
                try:
                    obj_row = row.save(commit=False)
                    if i == 0:
                        obj_row.type = 1
                    elif i == len(formset)-1:
                        obj_row.type = 3
                    else:
                        obj_row.type = 2
                    obj_row.save()
                    addrss_list.append(obj_row)
                except IntegrityError:
                    pass

            for i in range(0, len(addrss_list)-1):
                dist += calc_dist(addrss_list[i].lat_position,
                    addrss_list[i].long_position,
                    addrss_list[i+1].lat_position,
                    addrss_list[i+1].long_position)

            obj.distance = dist
            obj.refresh_dates_by_timezone()
            obj.save()

            data['valid'] = True
            data['success_url'] = str(reverse_lazy(
                'order:order_detail', kwargs={'pk': obj.pk}))

            # Отправка писем
            self.send_reg_email(obj, form)
            self.send_add_order_mail(obj, form)
            self.success_message(obj)

            if form.is_create_user:
                user = obj.user
                user.backend = 'django.contrib.auth.backends.ModelBackend'
                auth.login(self.request, user)
        else:
            return super(OrderFormView, self).form_invalid(form)

        return HttpResponse(json.dumps(data), content_type="application/json")


class OrderFormUpdateView(LoginRequiredMixin, OrderFormView):
    order = None
    formset_class = inlineformset_factory(
        Order,
        OrderAddress,
        extra=0,
        can_delete=False,
        form=OrderAddressForm)
    success_url = reverse_lazy('order:order_list')

    def dispatch(self, request, *args, **kwargs):
        self.order = get_object_or_404(Order, pk=self.kwargs['pk'])
        self.kwargs['category_pk'] = self.order.category.pk
        if self.order.user != request.user:
            messages.error(request, _(u'Вы не можете редактировать этот заказ'))
            return HttpResponseRedirect(
                reverse_lazy('order:order_detail',
                             kwargs={'pk': self.order.pk}))
        return super(OrderFormUpdateView, self).dispatch(
            request, *args, **kwargs)

    def get_success_url(self):
        self.success_url = reverse_lazy('order:order_detail', kwargs={'pk': self.order.pk})
        return self.success_url

    def get_context_data(self, **kwargs):
        ctx = super(OrderFormUpdateView, self).get_context_data(**kwargs)
        ctx['form_url'] = reverse_lazy('order:order_update_form', kwargs={'pk': self.order.pk})
        return ctx

    def get_form_kwargs(self):
        kwargs = super(OrderFormUpdateView, self).get_form_kwargs()
        kwargs['instance'] = self.order
        kwargs['timezone'] = self.order.timezone
        kwargs['datetime'] = self.order.get_datetime()
        return kwargs

    def get_formset(self, **kwargs):
        kwargs['instance'] = self.order
        return super(OrderFormUpdateView, self).get_formset(**kwargs)

    def send_add_order_mail(self, obj, form):
        pass

    def send_reg_email(self, obj, form):
        pass

    def success_message(self, obj):
        messages.success(
            self.request,
            _(u'Ваша заявка №%(num)s-"%(name)s" изменена.') % dict(
                num=obj.pk,
                name=obj.name)
        )


class OrderFormCopyView(OrderFormView):
    order = None

    def dispatch(self, request, *args, **kwargs):
        self.order = get_object_or_404(Order, pk=self.kwargs['pk'])
        self.kwargs['category_pk'] = self.order.category.pk
        return super(OrderFormCopyView, self).dispatch(
            request, *args, **kwargs)

    def get_form_kwargs(self):
        kwargs = super(OrderFormCopyView, self).get_form_kwargs()
        initial_fields = ['name', 'body', 'photo', 'cargo_weight',
                          'cargo_volume', 'loaders', 'can_be_distilled',
                          'not_on_move', 'buy_and_transportation', 'date',
                          'time', 'price_max', 'price_blitz', 'topicality',
                          'only_pro']
        initial = dict()
        for field in initial_fields:
            initial[field] = self.order.__dict__[field]
        kwargs['initial'] = initial
        kwargs['timezone'] = self.order.timezone
        kwargs['datetime'] = self.order.get_datetime()
        return kwargs

    def get_formset(self, **kwargs):
        initial = []
        for address in self.order.addresses.all().order_by('id'):
            initial.append({
                'city': address.city.name,
                'address': address.address})
        kwargs['initial'] = initial
        return super(OrderFormCopyView, self).get_formset(**kwargs)


class OrderListView(ListView):
    model = Order
    template_name = 'order/order_list.html'
    context_object_name = "orders"
    form_class = OrderListFilterForm

    def get(self, request, *args, **kwargs):
        if request.user.is_authenticated():
            if request.user.is_carrier and request.user.restrict_orders and \
                    not self.request.GET:
                return HttpResponseRedirect('%s?country=%s&region=%s' % (
                    reverse_lazy('order:order_list'),
                    request.user.country.id, request.user.region.id))
        return super(OrderListView, self).get(request, *args, **kwargs)

    def get_queryset(self):
        filters = self.request.GET.copy()
        pagination = filters.get('pangination', 20)

        if not filters:
            self.queryset = self.model.objects.order_by('-created')
        else:
            self.queryset = self.filter(filters)
        # Только заказы, в которых идут торги
        self.queryset = self.queryset.filter(status=0)
        try:
            page = int(self.request.GET.get('page', 1))
            self.queryset = Paginator(self.queryset, pagination).page(page)
        except ValueError:
            self.queryset = Paginator(self.queryset, pagination).page(1)
        except EmptyPage:
            pass

        return self.queryset

    def get_context_data(self, **kwargs):
        ctx = super(OrderListView, self).get_context_data(**kwargs)
        ctx['order_count'] = len(self.queryset)
        ctx['form'] = self.form_class(self.request.GET)
        g = GeoIP()
        client_ip = get_client_ip(self.request)
        ctx['client_city'] = g.city(client_ip)
        return ctx

    def filter(self, filters):
        q = Q()
        func_filters = ['addresses', 'distance', 'weight', 'date', 'category',
                        'global']
        for name in func_filters:
            q = getattr(self, '_filter_%s' % name)(filters, q)
        queryset = self.model.objects
        if filters.get('global') == 'no_bets':
            queryset = queryset.annotate(bet_count=Count('bets'))
        return queryset.filter(q).order_by('-created')

    def _filter_global(self, filters, q):
        if filters.get('global') == "fire":
            return q & Q(end_trading__gte=timezone.now() - timezone.timedelta(
                days=3))
        if filters.get('global') == 'no_bets':
            return q & Q(bet_count=0)
        return q

    def _filter_addresses(self, filters, q):
        _q = Q()
        if filters.get('region'):
            return q & Q(addresses__region__id=filters.get('region'),
                         addresses__type=1)
        if filters.get('region_from'):
            _q = _q & Q(addresses__region__id=filters.get('region_from'),
                        addresses__type=1)
        if filters.get('region_to'):
            _q = _q & Q(addresses__region__id=filters.get('region_to'),
                        addresses__type=3)
        if filters.get('back') and filters.get('region_to'):
            _q = _q | Q(addresses__region__id=filters.get('region_to'),
                        addresses__type=1)
        return _q & q

    def _filter_distance(self, filters, q):
        if filters.get('distance_from'):
            q = q & Q(distance__gte=filters.get('distance_from'))
        if filters.get('distance_to'):
            q = q & Q(distance__lte=filters.get('distance_to'))
        return q

    def _filter_weight(self, filters, q):
        _q = Q()
        if filters.get('weight_from'):
            _q = _q & Q(cargo_weight__gte=filters.get('weight_from'))
        if filters.get('weight_to'):
            _q = _q & Q(cargo_weight__lte=filters.get('weight_to'))
        if filters.get('weight_unknown'):
            _q = _q | Q(cargo_weight__isnull=True)
        return _q & q

    def _filter_date(self, filters, q):
        if filters.get('date_from'):
            date = timezone.datetime.strptime(
                filters.get('date_from'), '%d.%m.%Y')
            q = q & Q(date__gte=date)
        if filters.get('date_to'):
            date = timezone.datetime.strptime(filters.get('date_to'), '%d.%m.%Y')
            q = q & Q(date__lte=date)
        return q

    def _filter_category(self, filters, q):
        if filters.get('category'):
            q = q & Q(category__in=filters.get('category'))
        return q


class OrderDetailView(TemplateView):
    template_name = 'order/order_detail.html'

    def get(self, request, *args, **kwargs):
        order = self.get_order()
        if not order:
            return render_to_response('order/not_found.html', dict(),
                                      context_instance=RequestContext(request))

        view_orders = request.session.get('view_orders') or list()
        if order.pk not in view_orders:
            view_orders.append(order.pk)
            request.session['view_orders'] = view_orders
            order.views += 1
            order.views_today += 1
            order.save()

        if order.status == 0 and order.end_trading <= timezone.now():
            order.status = 4
            order.save()
            notification.order_expiried(order)

        return super(OrderDetailView, self).get(request, *args, **kwargs)

    def get_order(self):
        try:
            return Order.objects.get(pk=self.kwargs.get('pk'))
        except Order.DoesNotExist:
            return None

    def get_context_data(self, **kwargs):
        kwargs['order'] = self.get_order()
        kwargs['now'] = timezone.now()
        bets = kwargs['order'].bets.all()
        kwargs['bets'] = bets.order_by('-user__rating', 'price') \
            if self.request.GET.get('sort', '') == 'rate' \
            else bets.order_by('price')
        return kwargs


class OrderBetAddView(FormView):
    form_class = OrderBetForm
    template_name = 'order/inclusion/order_bet_form.html'

    def get_order(self):
        return get_object_or_404(Order, pk=self.kwargs.get('pk'))

    def get_context_data(self, **kwargs):
        kwargs['order'] = self.get_order()
        kwargs['is_can_bet'], kwargs['bet_error_message'], \
            kwargs['bet_error_type'] = kwargs['order']\
            .is_user_can_bet(self.request.user)
        kwargs['next_time_bet'] = kwargs['order'].get_next_time_bet_by_user(
            self.request.user)
        kwargs['now'] = timezone.now()
        return kwargs

    def get_form_kwargs(self):
        kwargs = super(OrderBetAddView, self).get_form_kwargs()
        kwargs['user'] = self.request.user._setupfunc()
        kwargs['order'] = self.get_order()
        return kwargs

    def form_valid(self, form):
        ctx = self.get_context_data()
        if not ctx['is_can_bet']:
            messages.error(self.request, ctx['bet_error_message'])
        else:
            bet = form.save(commit=False)
            # Все ставки до этого отклоняем(от этого юзера)
            bet.order.bets.filter(user=bet.user, status=0).update(
                status=2, reject_kind=11, status_time=timezone.now())
            bet.save()
            messages.success(self.request, _(u'Ставка сделана'))
            notification.bet_create(bet)
        data = dict()
        data['valid'] = True
        return HttpResponse(json.dumps(data), content_type="application/json")


class SaveFilterView(View):
    form_class = SaveFilterForm

    def post(self, request, *args, **kwargs):
        form = self.form_class(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            if not request.session.has_key('filters'):
                self.request.session['filters'] = []
            self.request.session['filters'].append({
                'name': cd['filter_name'],
                'value': cd['filter']
            })
            request.session.save()
        return HttpResponseRedirect(reverse_lazy('order:order_list'))


class RemoveFilterView(View):

    def post(self, request, *args, **kwargs):
        filter_name = request.POST.get('filter_name')
        filters = request.session.get('filters')
        for filter in  reversed(filters):
            if filter['name'] == filter_name:
                filters.remove(filter)
        request.session['filters'] = filters
        request.session.save()
        return HttpResponse(200)


class OrderReportView(LoginRequiredMixin, View):

    def get(self, request, *args, **kwargs):
        order = get_object_or_404(Order, pk=kwargs['order_pk'])
        report_kind = get_object_or_404(OrderReportKind, pk=kwargs['kind_pk'])
        report, created = OrderReport.objects.get_or_create(
            order=order,
            kind=report_kind,
            user=request.user
        )
        if created:
            messages.success(request,
                             _(u'Жалоба на заказ №%s размещена') % order.pk)
        else:
            messages.error(request, _(u'Вы уже оставляли подобную жалобу на '
                                      u'этот заказ'))
        return HttpResponseRedirect(reverse_lazy(
            'order:order_detail', kwargs={'pk': order.pk}))


class OrderBetSetStatusView(LoginRequiredMixin, View):

    def get(self, request, *args, **kwargs):
        bet = get_object_or_404(OrderBet, pk=kwargs['pk'])
        set_choices = {
            '1': self.take_bet,
            '2': self.reject_bet
        }
        if not bet.is_change_status():
            messages.error(self.request, _(u'Над этой ставкой больше нельзя '
                                           u'предпринимать действия'))
        else:
            if not set_choices[kwargs['status']](bet):
                messages.error(self.request,
                               _(u'У вас нет прав на это действие'))

        return HttpResponseRedirect(reverse_lazy(
            'order:order_detail', kwargs={'pk': bet.order.pk}))

    def take_bet(self, bet):
        if self.request.user != bet.order.user:
            return False
        bet.status = 1
        bet.status_time = timezone.now()
        bet.save()
        # Статус заказа = Подтверждение перевозщиком
        bet.order.status = 5
        bet.order.confirmation_date = timezone.now() + relativedelta(hours=12)
        bet.order.save()
        order_tasks.order_cancel_performer.apply_async(
            eta=bet.order.confirmation_date, args=[bet.order.id])
        notification.bet_accept(bet)
        messages.success(self.request, _(
            u'Ставка принята, ждите подтверждение перевозщика'))
        return True

    def reject_bet(self, bet):
        if self.request.user != bet.user and self.request.user != bet.order.user:
            return False
        # Если юзер владелец заказа
        if self.request.user == bet.order.user:
            reject_id = self.request.GET.get('reject')
            if reject_id and reject_id in \
                    [k for k, v in bet.order.get_bet_reject_customer_choices()]:
                bet.reject_kind = reject_id
            else:
                # Без указания причины
                bet.reject_kind = 0
        # Если юзер владелец ставки
        elif self.request.user == bet.user:
            bet.reject_kind = 12

        bet.status = 2
        bet.status_time = timezone.now()
        bet.save()
        messages.success(self.request, _(u'Ставка отклонена, торги '
                                         u'продолжаються'))
        return True


class OrderBetConfirmationView(LoginRequiredMixin, View):
    order = None

    def dispatch(self, request, *args, **kwargs):
        self.order = get_object_or_404(Order, pk=kwargs['pk'])
        return super(OrderBetConfirmationView, self).dispatch(
            request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        # Когда статус заказа Подтверждение перевозщиком
        result = None
        if self.order.status == 5:
            result = getattr(self, '_%s' % kwargs['action'])()
        return result or HttpResponseRedirect(reverse_lazy(
            'order:order_detail', kwargs={'pk': self.order.pk}))

    def _payment(self):
        """Оплата заказа перевозщиком"""
        if self.request.user != self.order.get_win_bet().user:
            return
        if self.order.get_commission_eur > self.request.user.cash:
            create_payment_data(
                user=self.request.user,
                session=self.request.session,
                price=self.request.user.currency.of_eur(
                    self.order.get_commission_eur),
                quantity=1,
                name=u"Commission payment",
                description=u"Commission payment",
                kind='commission',
                subkind='confirmation',
                kind_id=self.order.id
            )
            return HttpResponseRedirect(reverse_lazy('profile:payment'))
        # оплачиваем комисию
        self.request.user.cash -= self.order.get_commission_eur
        self.request.user.save()
        self.order.performer = self.request.user
        self.order.status = 1
        self.order.is_paid = True
        self.order.confirmation_date = None
        self.order.save()
        notification.order_end_trading(self.order)
        messages.success(self.request, _(u'Ставка подтверждена и '
                                         u'комиссия оплачена'))

    def _pay_later(self):
        """Отложить оплату заказа"""
        if self.request.user != self.order.get_win_bet().user:
            return
        self.order.maturity_date = timezone.now() + relativedelta(days=7)
        self.order.performer = self.request.user
        self.order.status = 1
        self.order.confirmation_date = None
        self.order.save()
        notification.order_end_trading(self.order)
        messages.success(self.request, _(u'Ставка подтверждена. '
                                         u'Не забудьте оплатить комиссию'))

    def _cancel(self):
        """Отклонение ставки при подтверждении перевозчиком или заказчиком,
        пока перевозщик не дал ответ"""
        if self.request.user != self.order.user and \
                self.request.user != self.order.get_win_bet().user:
            return
        # заявка отклонена
        bet = self.order.get_win_bet()
        bet.status = 2
        bet.reject_kind = 0 if self.request.user == self.order.user else 12
        bet.status_time = timezone.now()
        bet.save()
        # торги продолжаються
        self.order.confirmation_date = None
        self.order.status = 0
        self.order.save()
        messages.success(self.request, _(u'Ставка отклонена'))


class OrderCloseView(LoginRequiredMixin, View):

    def get(self, request, *args, **kwargs):
        order = get_object_or_404(Order, pk=kwargs.get('pk'))
        status = kwargs['status']
        close_choices = {
            '2': self.completed,
            '3': self.not_fulfilled,
        }
        if not order.is_can_close():
            messages.error(request, _(u'Этот заказ нельзя закрыть'))
        else:
            if not close_choices[status](order):
                messages.error(request,
                               _(u'У вас нет прав для закрытия заказа'))
            # обновляем рейтинг
            update_rating(order.performer)
        return HttpResponseRedirect(reverse_lazy(
            'order:order_detail', kwargs={'pk': order.pk}))

    def completed(self, order):
        """Заказ выполнен"""
        if self.request.user != order.user and\
                self.request.user != order.get_carrier():
            return False
        order.status = 2
        order.save()
        if self.request.user == order.get_carrier() and not order.is_paid:
            messages.success(self.request, _(u'Заказ выполнен. '
                                             u'Пожалуйста оплатите комиссию.'))
        else:
            messages.success(self.request, _(u'Заказ выполнен'))
        return True

    def not_fulfilled(self, order):
        """Заказ не выполнен"""
        if self.request.user != order.user:
            return False
        order.status = 3
        order.save()
        messages.success(self.request, _(u'Заказ не выполнен'))
        return True


class OrderCancelView(LoginRequiredMixin, View):

    def get(self, request, *args, **kwargs):
        order = get_object_or_404(Order, pk=kwargs.get('pk'))
        if not order.is_can_cancel():
            messages.error(request, _(u'Этот заказ нельзя отменить'))
        elif order.user == request.user:
            # Статус = отменен
            order.status = 4
            order.save()
            messages.success(request,
                             _(u'Заказ отменен'))
        else:
            messages.error(request, _(u'У вас нет прав для отмены заказа'))

        return HttpResponseRedirect(reverse_lazy(
            'order:order_detail', kwargs={'pk': order.pk}))


class AddReviewView(FormView):
    form_class = ReviewCarrierForm
    template_name = 'order/inclusion/review_carrier_form.html'
    success_url = reverse_lazy('order:order_add_review')

    def get_order(self):
        return get_object_or_404(Order, pk=self.request.POST.get('order_pk'))

    def get_form_kwargs(self):
        kwargs = super(AddReviewView, self).get_form_kwargs()
        kwargs['order'] = self.get_order()
        return kwargs

    def get_context_data(self, **kwargs):
        ctx = super(AddReviewView, self).get_context_data(**kwargs)
        ctx['order'] = self.get_order()
        return ctx

    def form_valid(self, form):
        order = self.get_order()
        if self.request.user == order.user:
            obj = form.save()
            if obj.kind == 1:
                # Добавлен положительный отзыв
                obj.carrier.review_pos_count += 1
            elif obj.kind == 2:
                # Отрицательный
                obj.carrier.review_neg_count += 1
            obj.carrier.save()
            notification.new_review(order)
            # обновляем рейтинг
            update_rating(order.performer)
            messages.success(self.request, _(u'Отзыв успешно добавлен'))
        else:
            messages.error(self.request, _(u'Вы не можете оставить отзыв'
                                           u' для этого заказа'))

        data = dict()
        data['valid'] = True
        return HttpResponse(json.dumps(data), content_type="application/json")


class ReviewCarrierMessageView(FormView):
    form_class = ReviewCarrierMessageForm
    template_name = "order/inclusion/review_carrier_answer_form.html"

    def get_review(self):
        return get_object_or_404(ReviewCarrier, pk=self.kwargs.get('pk'))

    def get_context_data(self, **kwargs):
        ctx = super(ReviewCarrierMessageView, self).get_context_data(**kwargs)
        ctx['review'] = self.get_review()
        return ctx

    def get_form_kwargs(self):
        kwargs = super(ReviewCarrierMessageView, self).get_form_kwargs()
        kwargs['instance'] = self.get_review()
        return kwargs

    def form_valid(self, form):
        review = self.get_review()
        if review.carrier == self.request.user:
            form.save()
            messages.success(self.request, _(u'Отзыв успешно добавлен'))
        else:
            messages.error(self.request, _(u'Вы не можете оставить комментарий'
                                           u' для этого отзыва'))

        data = dict()
        data['valid'] = True
        return HttpResponse(json.dumps(data), content_type="application/json")


class ReviewListView(ListView):
    model = ReviewCarrier
    template_name = "order/inclusion/reviews_list.html"
    context_object_name = "reviews"

    def get_queryset(self):
        qargs = list()
        qargs.append(Q(carrier__pk=self.kwargs.get('carrier_pk')))
        f = self.request.GET.get('filter')
        if f:
            qargs.append(Q(kind=f))
        self.queryset = ReviewCarrier.objects.filter(*qargs).order_by("-created")
        return self.queryset


class CommissionPaymentView(CarrierRequiredMixin, View):

    def get_order(self):
        return get_object_or_404(Order, pk=self.kwargs['pk'])

    def get(self, request, *args, **kwargs):
        order = self.get_order()
        # Юзер не являеться перевозщиков в этом заказе
        if order.performer != request.user:
            raise Http404
        # Заказ оплачен или не имеет необходимости в оплате
        if order.is_paid or not order.maturity_date:
            raise Http404
        if request.user.cash < order.get_commission_eur:
            create_payment_data(
                user=self.request.user,
                session=self.request.session,
                price=self.request.user.currency.of_eur(
                    order.get_commission_eur),
                quantity=1,
                name=u"Commission payment",
                description=u"Commission payment",
                kind='commission',
                kind_id=order.id
            )
            return HttpResponseRedirect(reverse_lazy('profile:payment'))
        else:
            request.user.cash -= order.get_commission_eur
            request.user.save()
            order.is_paid = True
            order.maturity_date = None
            order.save()
            messages.success(request, _(u'Комиссия успешно оплачена.'))

        return HttpResponseRedirect(reverse_lazy('profile:user_bill'))