Sith/stock/views.py

from collections import OrderedDict
from datetime import datetime, timedelta

from django.utils import timezone
from django.shortcuts import render, get_object_or_404
from django.views.generic import ListView, DetailView, RedirectView, TemplateView
from django.views.generic.edit import UpdateView, CreateView, DeleteView, ProcessFormView, FormMixin, BaseFormView
from django.utils.translation import ugettext_lazy as _
from django import forms
from django.http import HttpResponseRedirect, HttpResponse
from django.forms.models import modelform_factory
from django.core.urlresolvers import reverse_lazy, reverse
from django.db import transaction, DataError

from core.views import CanViewMixin, CanEditMixin, CanEditPropMixin, CanCreateMixin, TabedViewMixin
from counter.views import CounterAdminTabsMixin, CounterTabsMixin
from counter.models import Counter, ProductType
from stock.models import Stock, StockItem, ShoppingList, ShoppingListItem


class StockItemList(CounterAdminTabsMixin, CanCreateMixin, ListView):
	"""
	The stockitems list view for the counter owner
	"""
	model = Stock
	template_name = 'stock/stock_item_list.jinja'
	pk_url_kwarg = "stock_id"
	current_tab = "stocks"

	def get_context_data(self):
		ret = super(StockItemList, self).get_context_data()
		if 'stock_id' in self.kwargs.keys():
			ret['stock'] = Stock.objects.filter(id=self.kwargs['stock_id']).first();
		return ret
	
class StockListView(CounterAdminTabsMixin, CanViewMixin, ListView):
	"""
	A list view for the admins
	"""
	model = Stock
	template_name = 'stock/stock_list.jinja'
	current_tab = "stocks"

	def can_be_viewed_by(self, user):
		return user.is_in_group(settings.SITH_GROUP_COUNTER_ADMIN_ID)


class StockEditForm(forms.ModelForm):
	"""
	A form to change stock's characteristics
	"""
	class Meta:
		model = Stock
		fields = ['name', 'counter']
			
	def __init__(self, *args, **kwargs):
		super(StockEditForm, self).__init__(*args, **kwargs)

	def save(self, *args, **kwargs):
		return super(StockEditForm, self).save(*args, **kwargs)
		

class StockEditView(CounterAdminTabsMixin, CanEditPropMixin, UpdateView):
	"""
	An edit view for the stock
	"""
	model = Stock
	form_class = StockEditForm
	pk_url_kwarg = "stock_id"
	current_tab = "stocks"

	def get_context_data(self, **kwargs):
		context = super(StockItemList, self).get_context_data(**kwargs)
		if 'stock' in self.request.GET.keys():
			context['stock'] = Stock.objects.filter(id=self.request.GET['stock']).first()
		return context
		

class StockItemEditView(CounterAdminTabsMixin, CanEditPropMixin, UpdateView):
	"""
	An edit view for a stock item
	"""
	model = StockItem
	form_class = modelform_factory(StockItem, fields=['name', 'unit_quantity', 'effective_quantity', 'minimal_quantity', 'type', 'stock_owner'])
	pk_url_kwarg = "item_id"
	template_name = 'core/edit.jinja'
	current_tab = "stocks"


class StockCreateView(CounterAdminTabsMixin, CanCreateMixin, CreateView):
	"""
	A create view for a new Stock
	"""
	model = Stock
	form_class = modelform_factory(Stock, fields=['name', 'counter'])
	template_name = 'core/create.jinja'
	pk_url_kwarg = "counter_id"
	current_tab = "stocks"
	success_url = reverse_lazy('stock:list')

	def get_initial(self):
		ret = super(StockCreateView, self).get_initial()
		if 'counter_id' in self.kwargs.keys():
			ret['counter'] = self.kwargs['counter_id']
		return ret
		
class StockItemCreateView(CounterAdminTabsMixin, CanCreateMixin, CreateView):
	"""
	A create view for a new StockItem
	"""	
	model = StockItem
	form_class = modelform_factory(StockItem, fields=['name', 'unit_quantity', 'effective_quantity', 'minimal_quantity', 'type', 'stock_owner'])
	template_name = 'core/create.jinja'
	pk_url_kwarg = "stock_id"
	current_tab = "stocks"

	def get_initial(self):
		ret = super(StockItemCreateView, self).get_initial()
		if 'stock_id' in self.kwargs.keys():
			ret['stock_owner'] = self.kwargs['stock_id']
		return ret

	def get_success_url(self):
		return reverse_lazy('stock:items_list', kwargs={'stock_id':self.object.stock_owner.id})


class StockShoppingListView(CounterAdminTabsMixin, CanViewMixin, ListView):
	"""
	A list view for the people to know the item to buy
	"""
	model = Stock
	template_name = "stock/stock_shopping_list.jinja"
	pk_url_kwarg = "stock_id"
	current_tab = "stocks"

	def get_context_data(self):
		ret = super(StockShoppingListView, self).get_context_data()
		if 'stock_id' in self.kwargs.keys():
			ret['stock'] = Stock.objects.filter(id=self.kwargs['stock_id']).first();
		return ret


class StockItemQuantityForm(forms.BaseForm):
	def clean(self):
		with transaction.atomic():
			self.stock = Stock.objects.filter(id=self.stock_id).first()
			shopping_list = ShoppingList(name="Courses "+self.stock.counter.name, date=timezone.now(), todo=True)
			shopping_list.save()
			shopping_list.stock_owner = self.stock
			shopping_list.save()
			for k,t in self.cleaned_data.items():
				if k == 'name':
					shopping_list.name = t
					shopping_list.save()
				elif k == "comment":
					shopping_list.comment = t
					shopping_list.save()
				else:
					if t > 0 :
						item_id = int(k[5:])
						item = StockItem.objects.filter(id=item_id).first()
						shoppinglist_item = ShoppingListItem(stockitem_owner=item, name=item.name, type=item.type, tobuy_quantity=t)
						shoppinglist_item.save()
						shoppinglist_item.shopping_lists.add(shopping_list)
						shoppinglist_item.save()
						
		return self.cleaned_data

class StockItemQuantityBaseFormView(CounterAdminTabsMixin, CanEditMixin, DetailView, BaseFormView):
	"""
	docstring for StockItemOutList
	"""
	model = StockItem
	template_name = "stock/shopping_list_quantity.jinja"
	pk_url_kwarg = "stock_id"
	current_tab = "stocks"

	def get_form_class(self):
		fields = OrderedDict()
		kwargs = {}
		fields['name'] = forms.CharField(max_length=30, required=True, label='Shopping list name')
		for t in ProductType.objects.order_by('name').all():
			for i in self.stock.items.filter(type=t).order_by('name').all():
				if i.effective_quantity <= i.minimal_quantity:	            
					field_name = "item-%s" % (str(i.id))
					fields[field_name] = forms.IntegerField(required=True, label=str(i),
								help_text=str(i.effective_quantity)+" left")
		fields['comment'] = forms.CharField(widget=forms.Textarea(), required=False,
				initial="Add here, items to buy that are not reference as a product (example : sponge, knife, mugs ...)")				
		kwargs['stock_id'] = self.stock.id
		kwargs['base_fields'] = fields
		return type('StockItemQuantityForm', (StockItemQuantityForm,), kwargs)

	def get(self, request, *args, **kwargs):
		"""
		Simple get view
		"""
		self.stock = Stock.objects.filter(id=self.kwargs['stock_id']).first()
		return super(StockItemQuantityBaseFormView, self).get(request, *args, **kwargs)
	
	def post(self, request, *args, **kwargs):
		"""
		Handle the many possibilities of the post request
		"""
		self.object = self.get_object()
		self.stock = Stock.objects.filter(id=self.kwargs['stock_id']).first()
		return super(StockItemQuantityBaseFormView, self).post(request, *args, **kwargs)

	def form_valid(self, form):
		return super(StockItemQuantityBaseFormView, self).form_valid(form)

	def get_context_data(self, **kwargs):
		kwargs = super(StockItemQuantityBaseFormView, self).get_context_data(**kwargs)
		if 'form' not in kwargs.keys():
			kwargs['form'] = self.get_form()
		kwargs['stock'] = self.stock
		return kwargs

	def get_success_url(self):
		return reverse_lazy('stock:shoppinglist_list', args=self.args, kwargs=self.kwargs)


class StockShoppingListItemListView(CounterAdminTabsMixin, CanViewMixin, ListView):
	"""docstring for StockShoppingListItemListView"""
	model = ShoppingList
	template_name = "stock/shopping_list_items.jinja"
	pk_url_kwarg = "shoppinglist_id"
	current_tab = "stocks"

	def get_context_data(self):
		ret = super(StockShoppingListItemListView, self).get_context_data()
		if 'shoppinglist_id' in self.kwargs.keys():
			ret['shoppinglist'] = ShoppingList.objects.filter(id=self.kwargs['shoppinglist_id']).first();
		return ret

class StockShoppingListDeleteView(CounterAdminTabsMixin, CanEditMixin, DeleteView):
    """
    Delete a ShoppingList (for the resonsible account)
    """
    model = ShoppingList
    pk_url_kwarg = "shoppinglist_id"
    template_name = 'core/delete_confirm.jinja'
    current_tab = "stocks"

    def get_success_url(self):
    	return reverse_lazy('stock:shoppinglist_list', kwargs={'stock_id':self.object.stock_owner.id})


class StockShopppingListSetDone(CanEditMixin, DetailView):
    """
    Set a ShoppingList as done
    """
    model = ShoppingList
    pk_url_kwarg = "shoppinglist_id"

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        self.object.todo = False
        self.object.save()
        return HttpResponseRedirect(reverse('stock:shoppinglist_list', args=self.args, kwargs={'stock_id':self.object.stock_owner.id}))

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()
        return HttpResponseRedirect(reverse('stock:shoppinglist_list', args=self.args, kwargs={'stock_id':self.object.stock_owner.id}))


class StockShopppingListSetTodo(CanEditMixin, DetailView):
    """
    Set a ShoppingList as done
    """
    model = ShoppingList
    pk_url_kwarg = "shoppinglist_id"

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        self.object.todo = True
        self.object.save()
        return HttpResponseRedirect(reverse('stock:shoppinglist_list', args=self.args, kwargs={'stock_id':self.object.stock_owner.id}))

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()
        return HttpResponseRedirect(reverse('stock:shoppinglist_list', args=self.args, kwargs={'stock_id':self.object.stock_owner.id}))


class StockUpdateAfterShopppingForm(forms.BaseForm):
	def clean(self):
		with transaction.atomic():
			self.shoppinglist = ShoppingList.objects.filter(id=self.shoppinglist_id).first()
			for k,t in self.cleaned_data.items():
				shoppinglist_item_id = int(k[5:])
				#item_id = int(k[5:])
				if int(t) > 0 :
					shoppinglist_item = ShoppingListItem.objects.filter(id=shoppinglist_item_id).first()
					shoppinglist_item.bought_quantity = int(t)
					shoppinglist_item.save()
					shoppinglist_item.stockitem_owner.effective_quantity += int(t)
					shoppinglist_item.stockitem_owner.save()
					#item = StockItem.objects.filter(id=item_id).first()
					#item.bought_quantity = int(t)
					#item.effective_quantity += int(t)
					#item.save()
			self.shoppinglist.todo = False
			self.shoppinglist.save()
		return self.cleaned_data

class StockUpdateAfterShopppingBaseFormView(CounterAdminTabsMixin, CanEditMixin, DetailView, BaseFormView):
	"""
	docstring for StockUpdateAfterShopppingBaseFormView
	"""
	model = ShoppingList
	template_name = "stock/update_after_shopping.jinja"
	pk_url_kwarg = "shoppinglist_id"
	current_tab = "stocks"

	def get_form_class(self):
		fields = OrderedDict()
		kwargs = {}
		for t in ProductType.objects.order_by('name').all():
			for i in self.shoppinglist.shopping_items_to_buy.filter(type=t).order_by('name').all():
				field_name = "item-%s" % (str(i.id))
				fields[field_name] = forms.CharField(max_length=30, required=True, label=str(i),
						help_text=str(i.tobuy_quantity) + " asked")
		kwargs['shoppinglist_id'] = self.shoppinglist.id
		kwargs['base_fields'] = fields
		return type('StockUpdateAfterShopppingForm', (StockUpdateAfterShopppingForm,), kwargs)

	def get(self, request, *args, **kwargs):
		self.shoppinglist = ShoppingList.objects.filter(id=self.kwargs['shoppinglist_id']).first()
		return super(StockUpdateAfterShopppingBaseFormView, self).get(request, *args, **kwargs)
	
	def post(self, request, *args, **kwargs):
		"""
		Handle the many possibilities of the post request
		"""
		self.object = self.get_object()
		self.shoppinglist = ShoppingList.objects.filter(id=self.kwargs['shoppinglist_id']).first()
		return super(StockUpdateAfterShopppingBaseFormView, self).post(request, *args, **kwargs)

	def form_valid(self, form):
		"""
		We handle here the redirection
		"""
		return super(StockUpdateAfterShopppingBaseFormView, self).form_valid(form)

	def get_context_data(self, **kwargs):
		kwargs = super(StockUpdateAfterShopppingBaseFormView, self).get_context_data(**kwargs)
		if 'form' not in kwargs.keys():
			kwargs['form'] = self.get_form()
		kwargs['shoppinglist'] = self.shoppinglist
		kwargs['stock'] = self.shoppinglist.stock_owner
		return kwargs

	def get_success_url(self):
		self.kwargs.pop('shoppinglist_id', None)
		return reverse_lazy('stock:shoppinglist_list', args=self.args, kwargs=self.kwargs)


class StockTakeItemsForm(forms.BaseForm):
	"""
	docstring for StockTakeItemsFormView
	"""
	def clean(self):
		with transaction.atomic():
			for k,t in self.cleaned_data.items():
				item_id = int(k[5:])
				if t > 0 :
					item = StockItem.objects.filter(id=item_id).first()
					item.effective_quantity -= t
					item.save()
		return self.cleaned_data			


class StockTakeItemsBaseFormView(CounterTabsMixin, CanEditMixin, DetailView, BaseFormView):
	"""
	docstring for StockTakeItemsBaseFormView
	"""
	model = StockItem
	template_name = "stock/stock_take_items.jinja"
	pk_url_kwarg = "stock_id"
	current_tab = "take_items_from_stock"

	def get_form_class(self):
		fields = OrderedDict()
		kwargs = {}
		for t in ProductType.objects.order_by('name').all():
			for i in self.stock.items.filter(type=t).order_by('name').all():
				field_name = "item-%s" % (str(i.id))
				fields[field_name] = forms.IntegerField(required=False, label=str(i), help_text="("+ str(i.effective_quantity) + " left)")
				kwargs[field_name] = i.effective_quantity
		kwargs['stock_id'] = self.stock.id
		kwargs['counter_id'] = self.stock.counter.id
		kwargs['base_fields'] = fields
		return type('StockTakeItemsForm', (StockTakeItemsForm,), kwargs)

	def get(self, request, *args, **kwargs):
		"""
		Simple get view
		"""
		self.stock = Stock.objects.filter(id=self.kwargs['stock_id']).first()
		return super(StockTakeItemsBaseFormView, self).get(request, *args, **kwargs)
	
	def post(self, request, *args, **kwargs):
		"""
		Handle the many possibilities of the post request
		"""
		self.object = self.get_object()
		self.stock = Stock.objects.filter(id=self.kwargs['stock_id']).first()
		if self.stock.counter.type == "BAR" and not ('counter_token' in self.request.session.keys() and
				self.request.session['counter_token'] == self.stock.counter.token): # Also check the token to avoid the bar to be stolen
			return HttpResponseRedirect(reverse_lazy('counter:details', args=self.args,
				kwargs={'counter_id': self.stock.counter.id})+'?bad_location')
		return super(StockTakeItemsBaseFormView, self).post(request, *args, **kwargs)

	def form_valid(self, form):
		return super(StockTakeItemsBaseFormView, self).form_valid(form)

	def get_context_data(self, **kwargs):
		kwargs = super(StockTakeItemsBaseFormView, self).get_context_data(**kwargs)
		if 'form' not in kwargs.keys():
			kwargs['form'] = self.get_form()
		kwargs['stock'] = self.stock
		kwargs['counter'] = self.stock.counter
		return kwargs

	def get_success_url(self):
		stock = Stock.objects.filter(id=self.kwargs['stock_id']).first()
		self.kwargs['counter_id'] = stock.counter.id
		self.kwargs.pop('stock_id', None)
		return reverse_lazy('counter:details', args=self.args, kwargs=self.kwargs)