def order_post_save_action(instance, **kwargs):
bonus_rate = settings.DEFAULT_BONUS_RATE
bonus_threshold = settings.DEFAULT_BONUS_RATE_THRESHOLD
# do not proceed offline orders
if not instance.client:
return instance
invites = instance.client.invite_reciever_user_set.filter(
is_expired=False, is_verified=True
).order_by('id') # order by first invite initiated
if instance.status == 'rejected':
bonuses = instance.bonus_order_set.filter(amount__lt=0)
bonuses.delete()
if instance.client:
instance.client.reload_bonus_score(rebuild=True)
if instance.status == 'approved':
mail_code = MailCode()
mail_code.save()
emails = instance.container.owner.get_emails()
phone = instance.container.owner.phone
link = reverse('catalog:service-orders')
async_send_mail(
subject=unicode(_(u"Поступил новый заказ")),
body=render_to_string(settings.NEW_ORDER_MESSAGE_TEMPLATE_NAME,
{'link': link, 'object': instance, 'order_statuses': ORDER_STATUSES,
'site_url': settings. SITE_URL,
'refuse_url': reverse_lazy('catalog:update_order_status',
kwargs=dict(pk=instance.pk, status='rejected')),
'accept_url': reverse_lazy('catalog:update_order_status',
kwargs=dict(pk=instance.pk, status='finished')),
'mail_code': mail_code,
}),
from_email=settings.EMAIL_FROM,
recipient_list=emails,
)
amount = instance.cost
amount_curr = numeral.choose_plural(int(round(float(str(amount)))), (u"рубль", u"рубля", u"рублей"))
sms = SMSLogger.objects.create(
provider='disms',
text=settings.NEW_ORDER_SMS % {
'time': instance.created_on.strftime("%H:%M"),
'amount': "%s %s" % (amount, amount_curr)
},
phone=phone
)
sms.send_message()
sms.save()
amount_bonus = (
instance.cost / Decimal(str(bonus_threshold)) *
Decimal(str(bonus_rate))
)
if instance.client:
user_sms = SMSLogger.objects.create(
provider='disms',
text=settings.USER_ORDER % {
'amount': amount_bonus,
},
phone=instance.client.phone
)
user_sms.send_message()
user_sms.save()
if instance.status == 'processed':
# send votes
for vote in instance.votes.all():
if vote.is_send:
continue
link = settings.SITE_URL + reverse(
'catalog:order-vote', args=(vote.sid,)
)
email = vote.client.email
company = vote.order.container.owner.service_name
message = unicode(settings.VOTE_MESSAGE % {
'link': link,
'company': company
})
async_send_mail(
subject=unicode(_("Please vote for your order")),
# message=unicode(settings.VOTE_MESSAGE % {
# 'link': link,
# 'company': company
# }),
body=message,
from_email=settings.EMAIL_FROM,
recipient_list=[email, ],
fail_silently=True
)
# if not vote.is_send and vote.client.phone and settings.SEND_VOTE_SMS_ACTIVE:
# sms = SMSLogger.objects.create(
# provider='disms', text=unicode(message), phone=vote.client.phone
# )
# sms.send_message()
vote.is_send = True
vote.save()
# create bonuses
# only for authenticated users
# saving bonus transaction
total_price = (instance.cost - instance.discount)
if instance.client:
amount = (
total_price / Decimal(str(bonus_threshold)) *
Decimal(str(bonus_rate))
)
kw = dict(
client=instance.client,
order=instance,
amount=amount,
description="bonus up"
)
bonus_transaction = BonusTransaction.objects.filter(**kw)
if bonus_transaction:
bonus_transaction[0].save()
bonus_transaction[0].client.reload_bonus_score(rebuild=True)
else:
kw.update({
'is_processed': False,
'is_discount': False,
})
bonus_transaction = BonusTransaction.objects.create(**kw)
if instance.client:
# initial
if settings.FIRST_USER_ORDER_BONUS_ENABLE:
kw = {
'client': instance.client,
'amount': Decimal(str(settings.FIRST_ORDER_BONUS)),
'description': 'first %s user bonus' % instance.client.pk
}
transaction = BonusTransaction.objects.filter(**kw)
if not transaction:
transaction = BonusTransaction.objects.create(**kw)
phone = instance.client.phone
bonus_amount = (
total_price / Decimal(str(bonus_threshold)) *
Decimal(str(bonus_rate))
)
sms = SMSLogger.objects.get_or_create(
provider='disms',
text=settings.FIRST_USER_ORDER % {
'amount': settings.FIRST_ORDER_BONUS,
'bonus_amount': bonus_amount
},
phone=phone
)
sms[0].send_message()
sms[0].save()
else:
transaction = transaction[0]
transaction.client.save()
transaction.client.reload_bonus_score(rebuild=True)
if invites:
count = instance.client.orders.count()
if count == 1:
sender = invites[0].sender # use only first sender
# invited
transaction = BonusTransaction.objects.filter(
client=sender,
amount=Decimal(str(settings.BONUS_PER_INVITE_ORDER)),
description='invited %s user' % instance.client.pk
)
if not transaction:
transaction = BonusTransaction.objects.create(
client=sender,
amount=Decimal(str(settings.BONUS_PER_INVITE_ORDER)),
description='invited %s user' % instance.client.pk
)
else:
transaction = transaction[0]
transaction.client.save()
transaction.client.reload_bonus_score(rebuild=True)
#
return instance
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
}
