Cxense billing views

import logging

from django.contrib.auth.mixins import LoginRequiredMixin
from django.core.exceptions import PermissionDenied
from django.urls import reverse
from django.forms import formset_factory
from django.http import HttpResponseRedirect
from django.http.response import JsonResponse
from django.shortcuts import redirect
from django.views.generic.base import TemplateView, RedirectView, View
from formtools.wizard.views import SessionWizardView
from reports.models import Report
from reports.tasks import create_report_task
from reports.views import ReportListMixin

from billing.models import CustomerAggregatedData
from billing.reports import get_customers_xlsx_report
from billing.utils import parse_date_range, first, LoginAndPermissionRequiredMixin
from dmp_content.models import CxSiteGroup, CxSite
from dmp_content import reports as dmp_reports
from .forms import AddCustomer1Form, AddCustomer2Form, SiteGroupFormSetHelper
from .models import CxenseCustomer
from .reports import CustomersReport


logger = logging.getLogger('billing')


class AddManualCxenseCustomer(SessionWizardView):
    form_list = [AddCustomer1Form, AddCustomer2Form]
    template_name = 'billing/add_customer.html'

    def get_form(self, step=None, data=None, files=None):

        form = super(AddManualCxenseCustomer, self).get_form(step, data, files)

        if step == '1':
            # on SECOND step get data of first step
            step0data = self.storage.get_step_data('0')
            if step0data:
                parent_cx_id = step0data.get('0-parent_cx_id')
                initial_data_set = []
                if parent_cx_id:
                    parent = CxenseCustomer.objects.get(cx_id=parent_cx_id)
                    for sitegroup in parent.site_groups.all():
                        initial_data_set.append({
                            'select': False,
                            'sitegroup_id': sitegroup.group_id,
                            'sitegroup_name': sitegroup.name
                        })

                formset_class = formset_factory(AddCustomer2Form, extra=0)
                formset = formset_class(data=data, initial=initial_data_set)
                return formset

        return form

    def get_context_data(self, form, **kwargs):
        context = super(AddManualCxenseCustomer, self).get_context_data(form=form, **kwargs)
        if self.steps.current == '1':
            context.update({'helper': SiteGroupFormSetHelper})
        return context

    def done(self, form_list, **kwargs):
        forms_data = [form.cleaned_data for form in form_list]
        form_0_data = forms_data[0]
        form_1_data = forms_data[1]

        customer = CxenseCustomer.objects.create(
            name=form_0_data.get('name'),
            sales_force_id=form_0_data.get('sales_force_id'),
            zuora_id=form_0_data.get('zuora_id'),
            manual=True
        )

        parent_cx_id = form_0_data.get('parent_cx_id')
        parent = None

        if parent_cx_id:
            parent = CxenseCustomer.objects.get(cx_id=parent_cx_id)

        if parent:
            customer.parent = parent
            customer.save()

        self.add_sitegroups_and_sites(
            customer=customer,
            sitegroups_ids=[sg['sitegroup_id'] for sg in form_1_data if sg['select']]
        )

        return HttpResponseRedirect(
            reverse('admin:billing_cxensecustomer_change', args=(customer.id,))
        )

    def add_sitegroups_and_sites(self, customer, sitegroups_ids):
        sitegroups = CxSiteGroup.objects.filter(group_id__in=sitegroups_ids)
        CustomerSiteGroup = CxSiteGroup.customer.through
        CustomerSiteGroup.objects.bulk_create(
            CustomerSiteGroup(cxensecustomer=customer, cxsitegroup=sg) for sg in sitegroups
        )

        sites = CxSite.objects.filter(site_group__in=sitegroups).distinct()
        CustomerSite = CxSite.customers.through
        CustomerSite.objects.bulk_create(
            CustomerSite(customer=customer, site=s) for s in sites
        )


class CustomersView(LoginAndPermissionRequiredMixin, ReportListMixin, TemplateView):
    permission_required = 'permissions.view_customers_tab'
    template_name = 'billing/customers.html'
    report_type = ['customers', 'unmapped_sitegroups']

    def post(self, request):
        start_date, end_date = parse_date_range(self.request.POST['daterange'])
        if 'generateCustomersReport' in request.POST:
            filename = f'Customers {start_date:%Y-%m-%d} - {end_date:%Y-%m-%d}.xlsx'
            report = Report.new(report_type='customers', user=request.user, filename=filename)
            create_report_task.delay(
                report_id=report.id,
                func=get_customers_xlsx_report,
                kwargs={
                    'start_date': start_date,
                    'end_date': end_date,
                },
            )
            return JsonResponse(report.as_api())
        elif 'generateUnmappedSiteGroupsReport' in request.POST:
            filename = f'Sitegroups {start_date:%Y-%m-%d} - {end_date:%Y-%m-%d}.xlsx'
            report = Report.new(report_type='unmapped_sitegroups', user=request.user, filename=filename)
            create_report_task.delay(
                report_id=report.id,
                func=dmp_reports.get_unmapped_sitegroups_report,
                kwargs={
                    'start_date': start_date,
                    'end_date': end_date,
                },
            )
            return JsonResponse(report.as_api())
        return redirect('customers')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['product_name'] = 'customers'
        return context


class CustomersJsonView(LoginAndPermissionRequiredMixin, View):
    permission_required = 'permissions.view_customers_tab'

    def get(self, request):
        start_date, end_date = parse_date_range(self.request.GET['daterange'])
        rows = list(CustomerAggregatedData.objects.filter(date__range=(start_date, end_date)).values())
        self.add_account_pages_links(rows)
        return JsonResponse(rows, safe=False)

    def add_account_pages_links(self, rows):
        urls = CustomersReport.get_data_urls(customers=CxenseCustomer.objects.all())
        for row in rows:
            row['account_page_link'] = urls.get(row['zuora_id'])


class UnmappedSitegroupsJsonView(LoginAndPermissionRequiredMixin, View):
    permission_required = 'permissions.view_customers_tab'

    def get(self, request):
        start_date, end_date = parse_date_range(self.request.GET['daterange'])
        rows = dmp_reports.get_unmapped_sitegroups_report_rows(start_date, end_date)
        rows = [dict(zip(dmp_reports.UNMAPPED_SITEGROUPS_REPORT_HEADER, r)) for r in rows]
        return JsonResponse(rows, safe=False)


class MainRedirectView(LoginRequiredMixin, RedirectView):
    pages = (
        {'url_name': 'customers', 'permission': 'view_customers_tab'},
        {'url_name': 'dmp:index', 'permission': 'view_dmp_tab'},
        {'url_name': 'content:index', 'permission': 'view_content_tab'},
        {'url_name': 'display:index', 'permission': 'view_display_tab'},
        {'url_name': 'maxifier:index', 'permission': 'view_maxifier_tab'},
        {'url_name': 'video:index', 'permission': 'view_video_tab'},
    )

    @property
    def pattern_name(self):
        first_allowed_page = first(self.get_allowed_pages())
        if not first_allowed_page:
            raise PermissionDenied()
        return first_allowed_page

    def get_allowed_pages(self):
        yield from (page['url_name'] for page in self.pages
                    if self.request.user.has_perm('permissions.' + page['permission']))