def cart(request):
_cart = Cart(request)
items = len(list(_cart.cart.item_set.all()))
item_ct = get_model_content_type(Item)
addon_ct = get_model_content_type(Addon)
products = _cart.cart.item_set.filter(content_type=item_ct)
addons = _cart.cart.item_set.filter(content_type=addon_ct)
total_price = _cart.get_total_price()
bonus_max = round(total_price * Decimal(str(0.1 / settings.DEFAULT_EXCHANGE_RATE)))
service = None
deliver_cost = None
if products:
# item could be deleted so careful
try:
service = products.all()[0].product.container.owner
deliver_cost = service.get_deliver_cost(total_price)
except ObjectDoesNotExist:
_cart.cart.item_set.all().delete()
context = {
"cart": _cart,
"kart": {
"total_price": _cart.get_total_price(),
"products": products,
"cart_items": items or None,
"addons": addons,
"bonus_max": int(bonus_max),
"service": service,
"deliver_cost": int(deliver_cost) if deliver_cost is not None else None,
},
}
return context
def remove_item_from_cart(request, item_pk):
cart = Cart(request)
item = get_object_or_404(Item, pk=item_pk)
item_ct = get_model_content_type(Item)
addon_ct = get_model_content_type(Addon)
try:
cart.remove(item)
items = cart.cart.item_set.filter(content_type=item_ct).count()
if items == 0:
# remove all addons if items drops to zero
cart.cart.item_set.filter(content_type=addon_ct).delete()
except ItemDoesNotExist:
return redirect('catalog:cart')
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def clean(self):
# deliver_date, deliver_time
dd = self.cleaned_data.get('deliver_date', None)
dt = self.cleaned_data.get('deliver_time', None)
cart = Cart(self.request)
total_price = cart.get_total_price()
item_ct = get_model_content_type(Item)
item = cart.cart.item_set.filter(content_type=item_ct)
minimal_cost = item[0].product.container.owner.minimal_cost if len(item) else 0
if total_price < minimal_cost and total_price > 0:
msg = _("Minimal cost for order is '%s' for this service, "
"you should get more items to process") % minimal_cost
self._errors['name'] = ErrorList([msg])
if all((dd, dt)):
now = datetime.now()
offset = now + timedelta(minutes=30)
st = datetime(dd.year, dd.month, dd.day, dt.hour, dt.minute, dt.second)
if st <= offset:
msg = _("You can not order in the past")
self._errors['deliver_date'] = ErrorList([msg])
return self.cleaned_data
def wrapper(request, *args, **kwargs):
cart = Cart(request)
pk = kwargs[field]
if type == 'item':
item = get_object_or_None(Item, pk=pk)
elif type == 'addon':
item = get_object_or_None(Addon, pk=pk)
else:
return func(request, *args, **kwargs)
if not item:
return func(request, *args, **kwargs)
# always proceed if cart is clean
if not cart.cart.item_set.count():
return func(request, *args, **kwargs)
item_ct = get_model_content_type(Item)
addon_ct = get_model_content_type(Addon)
if type == 'item':
source_item = cart.cart.item_set.filter(
content_type=item_ct)[0]
source_owner = source_item.product.container.owner
dst_owner = item.container.owner
elif type == 'addon':
source_item = cart.cart.item_set.filter(
content_type=item_ct)[0]
source_owner = source_item.product.container.owner
dst_owner = item.list.container.owner
else:
source_owner = True
dst_owner = False # some sort of trick
#validate source and dst owners
if source_owner != dst_owner:
messages.info(
request,
_("You can not order stuff with \
another services or providers")
)
return redirect(request.META.get('HTTP_REFERER', '/'))
return func(request, *args, **kwargs)
def clean_deliver_cost(self):
deliver_cost = self.cleaned_data['deliver_cost']
_cart = Cart(self.request)
item_ct = get_model_content_type(Item)
items = _cart.cart.item_set.filter(content_type=item_ct)
if items:
owner = items[0].product.container.owner
dcost = owner.get_deliver_cost(_cart.get_total_price())
if dcost > deliver_cost:
raise forms.ValidationError(
_("Deliver cost should not be lower than"
"'%s' value") % dcost
)
return deliver_cost
def save(self):
addons = self.cleaned_data['addons']
addon_ct = get_model_content_type(Addon)
cart = Cart(self.request)
for addon in addons:
quantity = self.data.get('quantity-%s' % addon.pk, 0)
addon_pk = addon.pk
try:
if int(quantity) > 0:
cart.add(addon, addon.get_cost(), quantity)
except ItemAlreadyExists:
cart_item = cart.cart.item_set.get(
object_id=addon_pk, content_type=addon_ct
)
cart_item.quantity += int(quantity)
cart_item.save()
return
def clean_addons(self):
addons = self.cleaned_data['addons']
cart = Cart(self.request)
item_ct = get_model_content_type(Item)
product = cart.cart.item_set.filter(content_type=item_ct)
if not product:
raise forms.ValidationError(_("You can not order addons without any items"))
owner = product[0].product.container.owner
for addon in addons:
if owner != addon.list.container.owner:
#messages.info(
# self.request,
# _("You can not order stuff with"
# "another services or providers")
#)
raise forms.ValidationError(_("You can not choose addons of the side services"))
return addons
def cart(request):
_cart = Cart(request)
item_ct = get_model_content_type(Item)
products = _cart.cart.item_set.filter(content_type=item_ct)
context = {
'cart': _cart, 'total_price': _cart.get_total_price(),
'products': products,
}
if products:
service = products.all()[0].product.container.owner
return {
'redirect': 'catalog:service-page',
'redirect-args': (service.pk,)
}
else:
context.update({
'_template': 'catalog/cart.html'
})
return context
def add_addon_to_cart(request, addon_pk, quantity=1, checkout=False):
cart = Cart(request)
addon = get_object_or_404(Addon, pk=addon_pk)
# item = get_object_or_404(Item, pk=item_pk)
addon_ct = get_model_content_type(Addon)
# item_ct = get_model_content_type(Item)
try:
# cart.add(addon, addon.cost, quantity, item_ct, item.pk)
cart.add(addon, addon.get_cost(), quantity)
except ItemAlreadyExists:
cart_item = cart.cart.item_set.get(
object_id=addon_pk, content_type=addon_ct
)
if checkout:
cart_item.quantity = quantity
else:
cart_item.quantity += quantity
cart_item.save()
return redirect('catalog:cart')
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def clean(self):
cd = self.cleaned_data
item = self.cleaned_data.get('item') or None
item_instance = get_object_or_None(Item, pk=item)
if item_instance:
cart = Cart(self.request)
item_ct = get_model_content_type(Item)
items = cart.cart.item_set.filter(content_type=item_ct)
if items:
cart_item = items[0].product
if cart_item.container.owner != item_instance.container.owner:
dst = item_instance.container.owner.service_name or "-"
src = cart_item.container.owner.service_name or "-"
msg = _("You can not add multiply service items")
if settings.PARTNER_ORDER_ITEM_MESSAGES_WARNING:
messages.warning(
self.request,
_('You\'re trying to stock items from "%(dst)s" delivery. '
'Do you want to cleanse "%(src)s" items?') % {
'dst': dst,
'src': src
},
extra_tags='cleanse_cart'
)
self._errors['item'] = ErrorList([msg, 400])
if 'item' in cd:
del cd['item']
else:
msg = _("No item was found with such id")
self._errors['item'] = ErrorList([msg])
if 'item' in cd:
del cd['item']
return cd
def service_orders_nc(request):
dt = {}
if not any((request.user.is_operator, request.user.is_partner)):
raise Http404("Because I want")
# if request.user.is_partner:
# return {'redirect': 'catalog:service-orders-confirmed'}
client = request.GET.get('client', '')
items = request.GET.get('item', '')
min_cost = request.GET.get('min_cost', None)
max_cost = request.GET.get('max_cost', None)
date = request.GET.get('date', None)
_format = request.GET.get('format', None)
status = deepcopy(request.GET.getlist('status', []))
statuses = ['finished', 'rejected', 'processed', 'approved']
statuses_not_confirmed = [
'not_confirmed',
'checking'
]
if request.user.is_partner:
statuses.pop(statuses.index('approved'))
statuses_not_confirmed.append('approved')
statuses_not_confirmed.pop(statuses_not_confirmed.index('not_confirmed'))
statuses_not_confirmed.pop(statuses_not_confirmed.index('checking'))
orders = Order.objects.filter(status__in=statuses_not_confirmed).order_by('-id')
offset = datetime.now() - timedelta(**settings.NOT_CONFIRMED_INTERVAL)
orders_nc = Order.objects.filter(
status__in=statuses_not_confirmed,
created_on__lte=offset
).order_by('created_on')
not_confirmed = orders_nc.count()
if request.user.is_partner:
orders = orders.exclude(status__in=['not_confirmed', 'checking'])
not_confirmed = orders.count()
if min_cost:
orders = orders.filter(cost__gte=min_cost)
if max_cost:
orders = orders.filter(cost__lte=max_cost)
if client:
orders = (orders.filter(offline_client__name__icontains=client))
if date:
_date = datetime.strptime(date, '%d.%m.%Y')
_stop_date = _date + timedelta(hours=23, minutes=59, seconds=59)
orders = orders.filter(
created_on__gte=_date, created_on__lte=_stop_date
)
# filtering for partners
if request.user.is_partner and not request.user.is_operator:
orders = orders.filter(container__owner=request.user)
dt.update({'_template': 'catalog/service_partner_orders.html'})
if items:
itemz = Item.objects.filter(title__icontains=items)
addons = Addon.objects.filter(title__icontains=items)
items_ct = get_model_content_type(Item)
addon_ct = get_model_content_type(Addon)
item_containers = OrderContainer.objects.filter(
content_type=items_ct, object_id__in=itemz
)
addon_containers = OrderContainer.objects.filter(
content_type=addon_ct, object_id__in=addons
)
orders = (
orders.filter(order_container_order_set__in=item_containers) |
orders.filter(order_container_order_set__in=addon_containers)
).distinct()
if 'is_paid' in status:
orders = orders.filter(is_paid=True)
status.pop(status.index('is_paid'))
if status:
orders = orders.filter(
Q(status__in=status) # | Q(is_paid=is_paid)
)
total_price = sum([i['cost'] - i.get('discount', 0) for i in
orders.values('cost', 'discount')])
orders = process_filter_orders(request, orders)
if _format == 'csv':
return {
'_template': 'catalog/service_orders.csv',
'_content_type': 'text/csv',
'orders': orders
}
dt.update({
'orders': orders,
'orders_nc': orders_nc,
'total_price': total_price,
'not_confirmed': not_confirmed,
'ORDERS': ORDER_STATUSES,
'G': request.GET,
'status': request.GET.getlist('status', []),
})
# if not request.session.get('city'):
# geoip(request)
return dt
def service_orders(request):
dt = {}
if not any((request.user.is_operator, request.user.is_partner)):
raise Http404("Because I want")
status = deepcopy(request.GET.getlist('status', ''))
client = request.GET.get('client', '')
items = request.GET.get('item', '')
min_cost = request.GET.get('min_cost', None)
max_cost = request.GET.get('max_cost', None)
date = request.GET.get('date', None)
_format = request.GET.get('format', None)
excludes = ['not_confirmed',
'approved',
'checking'
]
statuses = [
'approved',
'finished',
'rejected',
'processed',
]
if request.user.is_partner:
# excludes.pop(excludes.index('approved'))
statuses.pop(statuses.index('approved'))
if settings.HIDE_REJECTED_FROM_PARTNER:
excludes.append('rejected')
if request.user.is_operator:
excludes.pop(excludes.index('approved'))
is_paid = ('is_paid' in status)
if is_paid:
status.pop(status.index('is_paid'))
orders = Order.objects.order_by('-id')
orders = orders.filter(status__in=statuses)
if is_paid:
orders = orders.filter(is_paid=is_paid)
# if request.user.is_partner:
# orders = orders.exclude(status='rejected')
not_confirmed = orders.filter(status='not_confirmed').count()
if min_cost:
orders = orders.filter(cost__gte=min_cost)
if max_cost:
orders = orders.filter(cost__lte=max_cost)
if status:
orders = orders.filter(status__in=status)
if client:
orders = (
orders.filter(offline_client__name__icontains=client)
)
if date:
_date = datetime.strptime(date, '%d.%m.%Y')
_stop_date = _date + timedelta(hours=23, minutes=59, seconds=59)
orders = orders.filter(
created_on__gte=_date, created_on__lte=_stop_date
)
# filtering for partners
if request.user.is_partner and not request.user.is_operator:
orders = orders.filter(container__owner=request.user)
dt.update({'_template': 'catalog/service_partner_orders.html'})
if items:
itemz = Item.objects.filter(title__icontains=items)
addons = Addon.objects.filter(title__icontains=items)
items_ct = get_model_content_type(Item)
addon_ct = get_model_content_type(Addon)
item_containers = OrderContainer.objects.filter(
content_type=items_ct, object_id__in=itemz
)
addon_containers = OrderContainer.objects.filter(
content_type=addon_ct, object_id__in=addons
)
orders = (
orders.filter(order_container_order_set__in=item_containers) |
orders.filter(order_container_order_set__in=addon_containers)
).distinct()
total_price = sum([i['cost'] - i.get('discount', 0) for i in
orders.values('cost', 'discount')])
orders = process_filter_orders(request, orders)
if _format == 'csv':
return {
'_template': 'catalog/service_orders.csv',
'_content_type': 'text/csv',
'orders': orders
}
dt.update({
'orders': orders,
'total_price': total_price,
'not_confirmed': not_confirmed,
'ORDERS': ORDER_STATUSES,
'G': request.GET,
'status': request.GET.getlist('status', []),
'has_status': True
})
return dt
def order(request):
form = OrderForm(request.POST or None, request=request)
if request.method == 'POST':
if form.is_valid():
order = form.save(commit=False)
cart = Cart(request)
item_ct = get_model_content_type(Item)
addon_ct = get_model_content_type(Addon)
for item in cart.cart.item_set.filter(content_type=item_ct):
container = item.product.container
service = container.service
break
order.service = service
order.container = container
order.offline_client = form.save_offline_client()
order.commission = container.owner.commission
order.save()
# generating discount
discount = form.cleaned_data['discount'] or 0
if discount:
discount_transaction = BonusTransaction.objects.create(
client=request.user,
order=order,
amount=str(discount * -1),
is_processed=False,
is_discount=True,
description='discount'
)
if order.client:
order.client.reload_bonus_score(rebuild=True)
order.generate_vote_instance()
# saving items and addons as order relations
# savin items
# for item in cart.cart.item_set.filter(content_type=item_ct):
# order_container = OrderContainer.objects.create(
# content_type=item_ct, object_id=item.product.pk,
# quantity=item.quantity,
# total_price=item.total_price,
# order=order)
#
# savin addons separate inside of items
# for addon in cart.cart.item_set.filter(content_type=addon_ct):
# order_container_item = OrderContainer.objects.get(
# content_type=item_ct,
# object_id=addon.link.pk, order=order)
# order_container = OrderContainer.objects.create(
# parent=order_container_item,
# content_type=addon_ct,
# object_id=addon.product.pk,
# total_price=addon.total_price,
# order=order)
for item in cart:
if isinstance(item.product, Item):
order_container = OrderContainer.objects.create(
content_type=item_ct, object_id=item.product.pk,
quantity=item.quantity,
total_price=item.total_price,
order=order)
# for x in range(item.quantity):
# order.items.add(item.product)
elif isinstance(item.product, Addon):
order_container = OrderContainer.objects.create(
content_type=addon_ct, object_id=item.product.pk,
quantity=item.quantity,
total_price=item.total_price,
order=order)
# for x in range(item.quantity):
# order.addons.add(item.product)
else:
pass
cart.delete_items()
if order.status == 'not_confirmed':
for i in User.objects.filter(is_operator=True):
emails = i.get_emails()
phone = order.container.owner.phone
link = reverse('catalog:service-orders')
async_send_mail(
unicode(_(u"Поступил новый заказ")),
render_to_string(settings.NEW_ORDER_MESSAGE_TEMPLATE_NAME,
{'link': link, 'object': order, 'order_statuses': ORDER_STATUSES,
'site_url': settings.SITE_URL}),
settings.EMAIL_FROM,
emails
)
# message.content_subtype = 'html'
# message.send(fail_silently=True)
if form.cleaned_data['payment_redirect'] == 'online':
order = form.instance
url = order.get_online_payment_url()
return {
'payment_redirect': url,
'order_id': form.instance.pk,
'order_amount': order.cost
}
return {
# 'redirect': 'catalog:order-success',
'order_id': form.instance.pk,
'order_amount': order.cost
}
addon_ct = get_model_content_type(Addon)
item_ct = get_model_content_type(Item)
cart = Cart(request)
products = cart.cart.item_set.filter(content_type=item_ct)
addons = cart.cart.item_set.filter(content_type=addon_ct)
return {
'form': form,
'products': products,
'addons': addons
}