path: root/app/dispatch/views.py

from django.shortcuts import render, redirect
from django.http import HttpResponse
from django.utils.encoding import smart_str
# from django.template import loader
from django.core.urlresolvers import reverse
# import django.contrib.auth as auth
# from django.conf import settings
# Create your views here.
from django.core.exceptions import ObjectDoesNotExist
from django.views.generic import TemplateView,ListView
from django.views.generic.detail import DetailView
from django.views.generic.edit import CreateView, UpdateView, DeleteView
from django.core.urlresolvers import reverse_lazy
from dispatch.models import Customer, Load, Paperwork, Invoice, UserInvoiceNumber, Settings, Identity
from dispatch.forms import AddPaperworkForm
from django.contrib.auth.models import User
from django.contrib.auth.mixins import UserPassesTestMixin
# from django.http import HttpResponseRedirect
from .misc import get_week_dates, split_loads_by_day
import datetime
import re, os

def home(request):
    return redirect(reverse('load_list'))


class LoadDateSort(DetailView):
    def get_context_data(self, **kwargs):
        context = super(DetailView, self).get_context_data(**kwargs)
        week_dates  = get_week_dates(self.request.GET.get('date',None))

        loads = self.get_object().load_set.filter(date__range=(week_dates['start_date'],
            week_dates['end_date'])).prefetch_related('customer')

        context['loads_nosplit'] = loads.order_by('date')

        context['loads'] = split_loads_by_day(loads,week_dates['start_date'],
            week_dates['end_date'])


        context['week_dates'] = week_dates

        return context

class FilteredListView(ListView):
    def get_queryset(self):
        base_qs = super(FilteredListView, self).get_queryset()
        if not self.request.user.is_superuser:
            return base_qs.filter(user=self.request.user)
        return base_qs

class FilteredUpdateView(UpdateView):
    def get_queryset(self):
        base_qs = super(FilteredUpdateView, self).get_queryset()
        if not self.request.user.is_superuser:
            return base_qs.filter(user=self.request.user)
        return base_qs

class FilteredDeleteView(DeleteView):
    def get_queryset(self):
        base_qs = super(FilteredDeleteView, self).get_queryset()
        if not self.request.user.is_superuser:
            return base_qs.filter(user=self.request.user)
        return base_qs


# Driver CRUD

class DriverList(UserPassesTestMixin, ListView):
    template_name = "dispatch/drivers/list.html"
    model = User

    def test_func(self):
        return self.request.user.is_superuser

class DriverDetail(UserPassesTestMixin, DetailView):
    template_name = "dispatch/drivers/detail.html"
    model = User

    def test_func(self):
        # Seems a little hacky at first but it works!
        return self.request.user.is_superuser or \
            self.get_object().pk is self.request.user.id

    def get_context_data(self, **kwargs):
        # Shit gets fucky with super() really fast, but this seems to work
        context = super(DriverDetail, self).get_context_data(**kwargs)

        try:
            context['ident'] = Identity.objects.get(user=self.get_object().pk)
        except:
            context['ident'] = None

        try:
            context['invoice_number'] = \
                UserInvoiceNumber.objects.get(user=self.get_object().pk)
        except ObjectDoesNotExist:
            uinv = UserInvoiceNumber(user=self.get_object())
            uinv.save()
            context['invoice_number'] = uinv

        return context


class DriverSummary(UserPassesTestMixin, LoadDateSort):
    template_name = "dispatch/drivers/summary.html"
    model = User

    def test_func(self):
        # Seems a little hacky at first but it works!
        return self.request.user.is_superuser or \
            self.get_object().pk is self.request.user.id

    def get_context_data(self, **kwargs):
        # Shit gets fucky with super() really fast, but this seems to work
        context = super(DriverSummary, self).get_context_data(**kwargs)

        stats = {};
        stats['count'], stats['average'], stats['sum'] = (0,0,0)
        stats['incomplete_loads'] = 0

        loads_by_date = context['loads']
        for d in loads_by_date:
            # Iterate over the array for the given date
            for l in loads_by_date[d]:
                stats['count']  += 1
                stats['sum']    += l.amount
                if l.amount == 0:
                    stats['incomplete_loads'] += 1

        if stats['sum'] is not 0 and stats['count'] is not 0:
            stats['average'] = stats['sum']/stats['count']


        # Add our stats to the context so we can use it in the template
        context['stats'] = stats

        return context

class DriverUpdate(UserPassesTestMixin, UpdateView):
    template_name = "dispatch/drivers/edit.html"
    model = User
    success_url = reverse_lazy('driver_list')
    # fields = ['username', 'first_name','last_name','email','groups']
    fields = ['username', 'first_name','last_name','email']


    def get(self,request, *args, **kwargs):
        if request.user.is_superuser:
            self.fields.append('is_active')
            self.fields.append('is_superuser')
        return super(DriverUpdate, self).get(request)

    def get_context_data(self, **kwargs):
        # Shit gets fucky with super() really fast, but this seems to work
        context = super(DriverUpdate, self).get_context_data(**kwargs)


        return context

    def test_func(self):
        # Seems a little hacky at first but it works!
        return self.request.user.is_superuser or \
            self.get_object().pk is self.request.user.id

# Customer CRUD

class CustomerList(ListView):
    template_name = "dispatch/companies/list.html"
    model = Customer

class CustomerCreate(UserPassesTestMixin, CreateView):
    template_name = "dispatch/companies/create.html"
    model = Customer
    success_url = reverse_lazy('customer_list')
    fields = ['name', 'address', 'phone_number','email_address']

    def test_func(self):
        return self.request.user.is_superuser

class CustomerDetail(LoadDateSort):
    template_name = "dispatch/companies/detail.html"
    model = Customer

class CustomerUpdate(UserPassesTestMixin, UpdateView):
    template_name = "dispatch/companies/edit.html"
    model = Customer
    success_url = reverse_lazy('customer_list')
    fields = ['name', 'address', 'phone_number','email_address']

    def test_func(self):
        return self.request.user.is_superuser


class CustomerDelete(UserPassesTestMixin, DeleteView):
    template_name = "dispatch/companies/delete.html"
    model = Customer
    success_url = reverse_lazy('customer_list')

    def test_func(self):
        return self.request.user.is_superuser
# Load CRUD

class LoadList(FilteredListView):
    template_name = "dispatch/loads/list.html"
    model = Load


    def get_queryset(self):
        base_qs = super(LoadList, self).get_queryset()
        wd = get_week_dates(self.request.GET.get('date',None))
        return base_qs.filter(date__range=(wd['start_date'], wd['end_date']))

    def get_context_data(self, **kwargs):
        context = super(LoadList, self).get_context_data(**kwargs)
        wd = get_week_dates(self.request.GET.get('date',None))
        context['week_dates'] = wd

        context['loads'] = split_loads_by_day(self.object_list,wd['start_date'],wd['end_date'])
        return context

class LoadCreate(CreateView):
    template_name = "dispatch/loads/create.html"
    model = Load
    fields = ['date', 'customer', 'description', 'delivered_to', 'amount']

    def get(self,request):
        if request.user.is_superuser:
            self.fields.insert(1,'user')
        return super(LoadCreate, self).get(request)

    def form_valid(self, form):
        if not self.request.user.is_superuser:
            load = form.save(commit=False)
            load.user = self.request.user
        return super(LoadCreate, self).form_valid(form)

class LoadDetail(DetailView):
    template_name = "dispatch/loads/detail.html"
    model = Load

    def get_context_data(self, **kwargs):
        context = super(LoadDetail, self).get_context_data(**kwargs)

        context['paperwork_list'] = Paperwork.objects.filter(load=context['object'])

        return context

class LoadUpdate(FilteredUpdateView):
    template_name = "dispatch/loads/edit.html"
    model = Load
    fields = ['date', 'customer', 'description', 'delivered_to', 'amount']

    def get(self,request,pk):
        if request.user.is_superuser:
            self.fields.insert(1,'user')
        return super(LoadUpdate, self).get(request)

    def form_valid(self, form):
        if not self.request.user.is_superuser:
            load = form.save(commit=False)
            load.user = self.request.user
        return super(LoadUpdate, self).form_valid(form)

class LoadDelete(UserPassesTestMixin, FilteredDeleteView):
    template_name = "dispatch/loads/delete.html"
    model = Load
    success_url = reverse_lazy('load_list')

    def test_func(self):
        return self.request.user.is_superuser


# Paperwork Uploads

def PaperworkUpload(request, load_id):
    l = Load.objects.get(pk=load_id)
    if request.method == 'POST':
        form = AddPaperworkForm(request.POST, request.FILES)
        if form.is_valid():
            pw = form.save(commit=False)
            pw.load = l
            pw.save()
            return redirect(reverse('load_detail', kwargs={'pk': load_id}))
    else:
        form = AddPaperworkForm()

    ctx = { 'form': form, 'load': l }
    return render(request, 'dispatch/paperwork/add.html', ctx)

def PaperworkDelete(request, load_id, pk):
    # TODO: Someday we should return the errors deleting the file, if any
    try:
        p = Paperwork.objects.get(pk=pk)
        p.delete()
    except Exception as e:
        print(e)

    return redirect(reverse('load_detail', kwargs={'pk': load_id}))

# Specifically for downloading with the filename set to the description of the
# load
def PaperworkDownload(request, load_id, pk):
    try:
        load = Load.objects.get(pk=load_id)
        paperwork = Paperwork.objects.get(pk=pk)

        if os.path.exists(paperwork.document.path):
            with open(paperwork.document.path, 'rb') as fh:
                try:
                    exp = re.compile('\.[^.]*$', re.IGNORECASE)
                    ext = exp.findall(paperwork.document.path)
                    ext = ext[0]
                except Exception as e:
                    print(e)
                    ext = '.pdf'

                desc = load.description.replace('"', '')

                response = HttpResponse(fh.read(), content_type='application/force-download')
                response['Content-Disposition'] = 'attachment; filename="{}"'.format(smart_str(desc + ext))
                response['X-Sendfile'] = smart_str(paperwork.document.path)
                return response
    except Exception as e:
        print(e)



# User Invoice Numbers

class UserInvoiceNumberUpdate(UserPassesTestMixin, UpdateView):
    template_name = "dispatch/userinvoicenumber/edit.html"
    model = UserInvoiceNumber
    fields = ['number']

    def get(self,request, *args, **kwargs):
        if request.user.is_superuser:
            self.fields.insert(1,'user')
        return super(UserInvoiceNumberUpdate, self).get(request)

    def test_func(self):
        return self.request.user.is_superuser or \
            self.get_object().user.pk is self.request.user.pk


# Identity
class IdentityDetail(DetailView):
    template_name = "dispatch/identity/detail.html"
    model = Identity

def SetDefaultIdentity(request, user_id, pk):
    if request.user.is_superuser:
        print("WORKS")
        ident = Identity.objects.get(pk=pk)
        ident.set_default()
    return redirect(reverse('driver_details', kwargs={'pk': user_id}))

class IdentityCreate(UserPassesTestMixin, CreateView):
    template_name = "dispatch/identity/edit.html"
    model = Identity
    fields = ['name', 'address', 'city', 'state', 'zip_code']

    def get(self, request, *args, **kwargs):
        if request.user.is_superuser:
            self.fields.insert(1,'user')
        return super(IdentityCreate, self).get(request)

    def test_func(self):
        return self.request.user.is_superuser or \
            self.get_object().user.pk is self.request.user.pk

class IdentityUpdate(UserPassesTestMixin, UpdateView):
    template_name = "dispatch/identity/edit.html"
    model = Identity
    fields = ['name', 'address', 'city', 'state', 'zip_code']

    def get(self, request, *args, **kwargs):
        if request.user.is_superuser:
            self.fields.insert(1,'user')
        return super(IdentityUpdate, self).get(request)

    def test_func(self):
        return self.request.user.is_superuser or \
            self.get_object().user.pk is self.request.user.pk


# Invoice
class InvoiceList(FilteredListView):
    template_name = "dispatch/invoice/list.html"
    model = Invoice

class InvoiceDetail(DetailView):
    template_name = "dispatch/invoice/detail.html"
    model = Invoice

def InvoiceGenerateForDates(request, pk):
    driver = User.objects.get(pk=pk)

    # I fucking hate dates and time. What a clusterfuck
    start_date = request.GET.get('date', datetime.datetime.now())
    if isinstance(start_date, str):
        start_date = datetime.datetime.strptime(start_date, '%m/%d/%Y')
    due_date = start_date + datetime.timedelta(days=30)
    wk = get_week_dates(datetime.datetime.strftime(start_date, "%m/%d/%Y"))

    inv = Invoice(user=driver, invoice_date=start_date, due_date=due_date)
    inv.setup()

    inv.save()

    inv.populate_items(start_date=wk['start_date'], end_date=wk['end_date'])

    return redirect(reverse('invoice_list'))

class InvoiceDelete(UserPassesTestMixin, DeleteView):
    template_name = "dispatch/invoice/list.html"
    model = Invoice
    success_url = reverse_lazy('invoice_list')

    def test_func(self):
        return self.request.user.is_superuser or \
            self.get_object().user.pk is self.request.user.pk