Example #1
0
def order(request):
    if request.method == 'POST':
        user = request.user
        form = OrderForm(user, request.POST)
        if form.is_valid():
            user.profile.full_name = form.cleaned_data['full_name']
            user.profile.phone = form.cleaned_data['phone']
            user.profile.postcode = form.cleaned_data['postcode']
            user.profile.region = form.cleaned_data['region']
            user.profile.locality = form.cleaned_data['locality']
            user.profile.street = form.cleaned_data['street']
            user.profile.house_nmb = form.cleaned_data['house_nmb']
            user.profile.apartment_nmb = form.cleaned_data['apartment_nmb']
            user.save()
    else:
        return redirect('cart')

    dandp = DandP(request)
    delivery_id = int(dandp.dandp['delivery']) + 1
    payment_id = int(dandp.dandp['payment']) + 1

    delivery = Delivery.objects.get(id=delivery_id)
    payment = Payment.objects.get(id=payment_id)

    context = {
        'delivery': delivery,
        'payment': payment,
    }

    return render(request, 'orders/order.html', context)
Example #2
0
File: views.py Project: eof4tt/sfx
    def post(self, request, *args, **kwargs):
        self.form = OrderForm(request.POST, request.FILES)
        if request.method == "POST":
            if self.form.is_valid():
                new_order = self.form.save()
                self.formset2desc = OrderDescriptionFormset(request.POST,
                                                            instance=new_order)
                self.formset2files = OrderDocsFormset(request.POST,
                                                      request.FILES,
                                                      instance=new_order)
                messages.add_message(request, messages.SUCCESS,
                                     "Заказ успешно добавлен. ")
                if self.formset2desc.is_valid():
                    self.formset2desc.save()
                    messages.add_message(request, messages.SUCCESS,
                                         "Описание успешно добавлено. ")
                    if self.formset2files.is_valid():
                        self.formset2files.save()
                        messages.add_message(
                            request, messages.SUCCESS,
                            "Документ(ы) к заказу успешно добавлен(ы). ")
                        return redirect("/orders/index/", *args, **kwargs)
                    else:
                        messages.add_message(
                            request, messages.SUCCESS,
                            "Проверьте корректность добавление нового документа или подтвердите текущие изменения. "
                        )

        self.formset2desc = OrderDescriptionFormset(request.POST)
        self.formset2files = OrderDocsFormset(request.POST, request.FILES)
        messages.add_message(
            request, messages.SUCCESS,
            "ВНИМАНИЕ: Необходимо заполнить все обязательные параметры! ")
        return super(OrderCreate, self).get(request, *args, **kwargs)
Example #3
0
class PrepareOrder(TemplateView):
    form = None
    template_name = "checkout/prepare_order.html"

    def get(self, request, *args, **kwargs):
        self.form = OrderForm()
        return super(PrepareOrder, self).get(self, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(PrepareOrder, self).get_context_data(**kwargs)
        context['form'] = self.form
        context['brands'] = Brand.objects.order_by("name")
        context['categorys'] = Category.objects.order_by("name")
        return context

    def post(self, request, *args, **kwargs):
        self.form = OrderForm(request.POST)
        if self.form.is_valid():
            order = self.form.save()
            for filter_in_cart in request.session['cart']:
                filter = Filter.objects.get(pk=filter_in_cart['filter_id'])
                total_price = "{0:.2f}".format(
                    float(filter_in_cart["filter_price"].replace(",", ".")) *
                    int(filter_in_cart["numb"])
                ).replace(".", ",")
                product_in_order = ProductInOrder.objects.create(order=order, product=filter,
                                                                 numb=filter_in_cart['numb'],
                                                                 price_item=filter_in_cart["filter_price"],
                                                                 total_price=total_price)
            request.session['cart'].clear()
            request.session.modified = True
            return render(request, "checkout/thanks.html", locals())
        else:
            return super(PrepareOrder, self).get(request, *args, **kwargs)
Example #4
0
def charge(request):
	cart = Cart(request)
	if request.method == 'POST':
		form = OrderForm(request.POST)
		order = form.save()
		context = {
			'key': settings.STRIPE_PUBLISHABLE_KEY,
			'order': order,
		}
		for object in cart:
			OrderItem.objects.create(
				order=order,
				item=object['item'],
				price=object['price'],
				quantity=object['quantity']
			)
		cart.clear()
		#charge_amount = request.POST['amount']
		charge = stripe.Charge.create(
			amount=500,						#OrderItem.objects.filter(price__icontains(object['price'])),
			currency='usd', 				# will need to modify for different currency types (low priority)
			description='A New Django Order',
			source=request.POST['stripeToken']
		)
		return render(request, 'order_confirmation.html', context)
	else:
		response = HttpResponse("<center><h2>FATAL ERROR: Not a POST request.</h2></center>")
		return response
Example #5
0
def HomeView(request, pk, *args, **kwargs):
    """
    Shows the user their order has been placed and gives them the option of
    continuing with payment. Once payment is complete this same view will show
    them all the details concerned with their order.
    
    request -- holds the logged in user
    pk -- the id number of the scheduled course being ordered
    *args -- used for extensibility (if order should support GET args)
    **kwargs -- used for extensibility (if order should support POST args)
    """
    scheduled_course = CourseSchedule.objects.get(id=pk)
    if request.method == 'POST': # If the form has been submitted...
        form = OrderForm(request.POST, user=request.user, scheduled_course=scheduled_course) # A form bound to the POST data
        if form.is_valid(): # All validation rules pass
            # Process the data in form.cleaned_data
            # ...
            form.save()
            order = Order.objects.filter(user=request.user).order_by('-date')[0]
            return HttpResponseRedirect(unicode(order.id)) # Redirect after POST
    else:
        form = OrderForm(request.POST, user=request.user, scheduled_course=scheduled_course) # An unbound form
    return render(request, 'orders/home.html', {
        'form': form,
        'scheduled_course': scheduled_course,
    })
Example #6
0
def car_detail(request, car_id):
    car = get_object_or_404(Car, id=car_id)

    form = OrderForm(request.POST or None, initial={"car": car})

    if request.method == "POST":
        if form.is_valid():
            form = OrderForm(request.POST)
            name = request.POST.get('name', '')
            carid = request.POST.get('car', '')
            telephone = request.POST.get('phone', '')
            autos = int(carid)
            idauto = Car.objects.all()[autos].idauto
            model = Car.objects.all()[autos].modelcar
            complectation = Car.objects.all()[autos].complectation
            engine = Car.objects.all()[autos].engine
            power = Car.objects.all()[autos].power
            kpp = Car.objects.all()[autos].kpp
            color = Car.objects.all()[autos].color
            oldprice = Car.objects.all()[autos].oldprice
            newprice = Car.objects.all()[autos].newprice

            subject = 'Заявка с сайта "Лайфхак SKODA"'
            from_email = settings.EMAIL_HOST_USER

            message = ''' 
На сайте "SKODA Лайфхак" появилась новая заявка на автомобиль! 
_____________________________________________________________ 

АВТОМОБИЛЬ: 

ID автомобиля: {0} 
ŠKODA {1} {2} | {3}, {4} | {5} | {6}

Цена без скидки: {7} руб.
Цена со скидкой: {8} руб.
_____________________________________________________________

КЛИЕНТ:

Имя клиента: {9} 
Телефон клиента: {10}'''.format(idauto, model, complectation, engine, power,
                                kpp, color, oldprice, newprice, name,
                                telephone)

            recipient_list = Mail.objects.all()

            messages = [(subject, message, from_email, [recipient])
                        for recipient in recipient_list]

            send_mass_mail(messages)

            return HttpResponseRedirect("{}?sended=True".format(
                reverse("car", kwargs={"car_id": car.id})))

    return render(request, "cars/car_detail.html", {
        "car": car,
        "form": form,
        "sended": request.GET.get("sended", False)
    })
Example #7
0
    def test_avoid_duplicates(self):
        """Test to avoid duplicates."""
        order = Order.objects.create(
            user=User.objects.all()[0],
            customer=Customer.objects.all()[0],
            ref_name='Duplicate test',
            delivery=date(2018, 1, 1),
            priority='2',
            waist=10,
            chest=20,
            hip=30,
            lenght=40,
            others='Duplicate order',
            budget=100,
            prepaid=100,
        )
        self.assertTrue(Order.objects.get(ref_name='Duplicate test'))
        duplicated_order = OrderForm({
            'customer': order.customer.pk,
            'ref_name': order.ref_name,
            'delivery': order.delivery,
            'waist': order.waist,
            'chest': order.chest,
            'hip': order.hip,
            'priority': order.priority,
            'lenght': order.lenght,
            'others': order.others,
            'budget': order.budget,
            'prepaid': order.prepaid,
        })

        self.assertFalse(duplicated_order.is_valid())
        self.assertEqual(duplicated_order.errors['__all__'][0],
                         'The order already exists in the db')
Example #8
0
def create_order(request):
    billing_profile = BillingProfile.objects.filter(user=request.user).first()
    cart = Cart.objects.filter(user=request.user, active=True).first()

    if request.method == 'POST':
        if not request.user.is_authenticated or Order.objects.filter(
                billing_profile=billing_profile, active=True).first() is None or cart is None:
            return HttpResponseBadRequest('Error occurred while placing the order!')

        model_instance = Order.objects.get_active_order(
            billing_profile=billing_profile, cart=cart)
        form = OrderForm(request.POST, instance=model_instance)
        if form.is_valid():
            model_instance.shipping_address = form.cleaned_data.get('shipping_address')
            model_instance.payment_method = form.cleaned_data.get('payment_method')
            # change order status to placed
            model_instance.status = 'placed'
            # make order and cart inactive for placing next order
            model_instance.active = False
            model_instance.save()
            form.save()
            context = {
                'order_id': model_instance.order_id,
            }
            return render(request, "carts/order_success.html", context)
    return redirect('home')
Example #9
0
def place_order(request):
    if request.method == 'GET':
        total_amount = round(
            sum([
                product.price
                for product in Product.objects.filter(cart__user=request.user)
            ]), 2)
        order = Order()
        order.amount = total_amount
        context = {
            'form': OrderForm(instance=order),
        }
        return render(request, 'orders/order_details.html', context)
    else:
        form = OrderForm(request.POST)

        if form.is_valid():
            order = form.save(commit=False)
            order.buyer = request.user
            order.order_date = datetime.datetime.now()
            order.save()

            set_sold_products_unavailable(request.user, order)

            update_raised_money(order.amount)

            empty_user_cart(request.user)

            return redirect('successful donation', order.id)

        context = {
            'form': form,
        }
        return render(request, 'orders/order_details.html', context)
Example #10
0
File: web.py Project: Whitie/ozone
def order(req, article_id=0):
    if req.user.has_perm('orders.can_order'):
        choice_filter = {'day__gte': date.today() - timedelta(days=1)}
    else:
        choice_filter = {'day__gt': date.today()}
    if req.method == 'POST':
        form = OrderForm(req.POST)
        form.fields['oday'].choices = h.get_oday_choices(choice_filter)
        if form.is_valid():
            cleaned = form.cleaned_data
            company = Company.objects.get(id=cleaned['art_supplier_id'])
            costs = h.get_costs(req.POST)
            art, created = h.search_article(
                cleaned['art_id'].strip(),
                cleaned['art_name'], cleaned['art_q'], company
            )
            art.tax = int(req.POST.get('tax', '19'))
            if created:
                art.tox_control = cleaned['tox']
                art.save()
            _price = h.get_price(cleaned['art_price'])
            if _price and art.price != _price:
                art.price = _price
                art.save()
            order = Order.objects.create(
                count=cleaned['count'], article=art,
                order_day=OrderDay.objects.get(id=int(cleaned['oday']))
            )
            order.save()
            for cost, percent in costs:
                co = CostOrder.objects.create(percent=percent, order=order,
                                              cost=cost)
                co.save()
            order.memo = cleaned['memo']
            order.for_test = cleaned['exam']
            order.for_repair = cleaned['repair']
            order.users.add(req.user)
            order.save()
            # Add orderer to rating_users
            if req.user.id not in [x.id for x in company.rating_users.all()]:
                company.rating_users.add(req.user)
                company.save()
                messages.success(req, u'Sie wurden als Bewerter für %s '
                                      u'hinzugefügt.' % company.name)
            messages.success(req, u'Ihre Bestellung %s wurde gespeichert.'
                             % order)
            return redirect('orders-detail', order_id=order.order_day.id)
        messages.error(req, u'Bitte füllen Sie die benötigten Felder aus.')
    else:
        form = OrderForm()
        form.fields['oday'].choices = h.get_oday_choices(choice_filter)
    costs = Cost.objects.all().order_by('ident')
    ctx = dict(
        page_title=_(u'New Order'), form=form, menus=menus, costs=costs,
        article_id=article_id, costs_msg=_(u'Sum of costs must be 100!'),
        cur_msg=u'Preis in %s.' % settings.CURRENCY[0], extra=False,
        need_ajax=True
    )
    return render(req, 'orders/order.html', ctx, app=u'orders')
Example #11
0
def update_cart(request):
    """Updates the user's shopping cart."""
    order = Order.get_or_create(request)
    order_form = OrderForm(request.REQUEST, prefix='btb', instance=order)
    if order_form.is_valid():
        order = order_form.save()
        return order.get_as_cart()
    return False
Example #12
0
def cvety_list(request):
    cvetys = Cvety.objects.all()
    form = OrderForm(request.POST or None)
    if request.method == "POST":
        if form.is_valid():
            form.save()
            return HttpResponseRedirect("?sended=True")
    return render(request, "cvety/cvety_list.html", {'cvetys': cvetys, 'form': form, "sended": request.GET.get("sended", False)})
Example #13
0
def update(request, id):
    order = Order.objects.get(id=id)
    form = OrderForm(request.POST, instance=order)
    if form.is_valid():
        form.save()
        messages.success(request, "Order modified successfully")
        return redirect("/list")
    return render(request, 'edit.html', {'order': order})
Example #14
0
    def post(self, request, *args, **kwargs):
        form = OrderForm(request.POST)
        if not form.is_valid():
            errors = {key: invalid_msg.format(value[0]) for key, value in form.errors.items()}
            return render(request, self.template_name, {'error': errors, 'form': form})
        # 保存
        form.save(request.user.id)

        return redirect('order:index')
Example #15
0
File: views.py Project: eof4tt/sfx
class OrderCreate(TemplateView):
    model = Orders
    template_name = "order_add.html"
    form = None
    formset2files = None
    formset2desc = None
    success_url = "/orders/index/"

    def get(self, request, *args, **kwargs):
        dataform = {'project_name': self.kwargs["contract"]}
        self.form = OrderForm(initial=dataform)
        self.formset2desc = OrderDescriptionFormset()
        self.formset2files = OrderDocsFormset()
        return super(OrderCreate, self).get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(OrderCreate, self).get_context_data(**kwargs)
        context['form'] = self.form
        context['formset2desc'] = self.formset2desc
        context['formset2files'] = self.formset2files
        return context

    def post(self, request, *args, **kwargs):
        self.form = OrderForm(request.POST, request.FILES)
        if request.method == "POST":
            if self.form.is_valid():
                new_order = self.form.save()
                self.formset2desc = OrderDescriptionFormset(request.POST,
                                                            instance=new_order)
                self.formset2files = OrderDocsFormset(request.POST,
                                                      request.FILES,
                                                      instance=new_order)
                messages.add_message(request, messages.SUCCESS,
                                     "Заказ успешно добавлен. ")
                if self.formset2desc.is_valid():
                    self.formset2desc.save()
                    messages.add_message(request, messages.SUCCESS,
                                         "Описание успешно добавлено. ")
                    if self.formset2files.is_valid():
                        self.formset2files.save()
                        messages.add_message(
                            request, messages.SUCCESS,
                            "Документ(ы) к заказу успешно добавлен(ы). ")
                        return redirect("/orders/index/", *args, **kwargs)
                    else:
                        messages.add_message(
                            request, messages.SUCCESS,
                            "Проверьте корректность добавление нового документа или подтвердите текущие изменения. "
                        )

        self.formset2desc = OrderDescriptionFormset(request.POST)
        self.formset2files = OrderDocsFormset(request.POST, request.FILES)
        messages.add_message(
            request, messages.SUCCESS,
            "ВНИМАНИЕ: Необходимо заполнить все обязательные параметры! ")
        return super(OrderCreate, self).get(request, *args, **kwargs)
Example #16
0
 def test_non_team_members_can_not_set_team(self):
     form_data = {
         "amount": 1,
         "product": self.product.id,
         "team": self.team.id,
         "state": "REQ",
         "unit_price": 10.00,
     }
     form = OrderForm(data=form_data, teams=Team.objects.none())
     self.assertFalse(form.is_valid())
Example #17
0
 def test_valid_permission_can_set_team(self):
     form_data = {
         "amount": 1,
         "product": self.product.id,
         "team": self.team.id,
         "state": "REQ",
         "unit_price": 10.00,
     }
     form = OrderForm(data=form_data, teams=Team.objects.all())
     self.assertTrue(form.is_valid())
Example #18
0
 def test_order_edit_view_with_permission_using_form(self):
     order = Order.objects.all()[0]
     self.client.login(email='*****@*****.**', password='******')
     self.user.user_permissions.add(self.special_permission)
     response = self.client.get(reverse('order-edit', kwargs={'pk' : order.pk}))
     form = OrderForm(data={'order_state': "Done", 'final_price': order.final_price})
     self.assertTrue(form.is_valid())
     self.assertTemplateUsed(response, 'orders/order_edit.html')
     self.assertContains(response, 'Order')
     self.assertNotContains(response, 'Pippopooppo')
Example #19
0
    def post(self, request, *args, **kwargs):
        order_id = request.POST.get('id')
        order = get_object_or_404(Order, id=order_id)
        form = OrderForm(request.POST, instance=order)
        if not form.is_valid():
            errors = {key: invalid_msg.format(value[0]) for key, value in form.errors.items()}
            return render(request, self.template_name, {'error': errors, 'form': form})
        # 保存
        form.save(request.user.id)

        return redirect('order:index')
Example #20
0
def artifical_post(request):
    """ функция ведет на обработку формы """

    order_f = OrderForm(request.POST)
    id_status = request.POST['payment_method']
    id_status = int(id_status)
    s = Status.objects.get(id=id_status)
    new_status = order_f.save(commit=False)
    new_status.current_status = s
    new_status.save()
    return redirect('orders_page')
Example #21
0
def cvety_ditail(request, cvety_id):
    cvety = get_object_or_404(Cvety, id=cvety_id)
    form = OrderForm(request.POST or None, initial={"cvety": cvety })
    if request.method == "POST":
        if form.is_valid():
            form.save()
            return HttpResponseRedirect("{}?sended=True".format(reverse("cvety", kwargs={"cvety_id": cvety_id})))
    return  render(request, "cvety/cvety_ditail.html", {
        "cvety": cvety,
        "form": form,
        "sended": request.GET.get("sended", False)
        })
Example #22
0
def book_order(request, category_slug, slug):
    from orders.models import OrderItem
    form = OrderForm(request.POST or None)
    try:
        category = Category.objects.get(slug=category_slug)
        product = Product.objects.active().filter(slug=slug, category=category)[0]
    except (Category.DoesNotExist, Product.DoesNotExist):
        raise Http404
    if request.method == "POST" and form.is_valid():
        order = form.save()
        order_item = OrderItem.objects.create(order=order, product=product)
        subject = u"[%s] Новый заказ - %s" % (order.id, product.name)
        message = u"""
            Имя: %s
            Телефон: %s
            E-Mail: %s
            Книга: %s, %s - %s грн
        """ % (
            order.full_name,
            order.phone, order.email,
            product.author,
            product.name,
            product.price
        )
        send_mail(subject, message, settings.DEFAULT_FROM,
            settings.ORDER_MANAGERS, fail_silently=False)

        # send email to customer
        subject, _from, _to = CUSTOMER_SUBJECT, settings.DEFAULT_FROM, order.email
        text_content = CUSTOMER_MESSAGE_PLAIN % (
            product.author,
            product.name,
            product.price
        )
        html_content = CUSTOMER_MESSAGE_HTML % (
            product.author,
            product.name,
            product.price
        )
        msg = EmailMultiAlternatives(subject, text_content, _from, [_to])
        msg.attach_alternative(html_content, "text/html")
        msg.send()

        return HttpResponse(json.dumps({'message': ORDER_POPUP_MESSAGE}),
            mimetype="application/json")

    data = {
        'form': form,
        'product': product,
        'category': category
    }
    return render(request, 'book-order.html', data)
Example #23
0
def order_create(request, template_name='orders/create.html'):

    form = OrderForm(request.POST or None)
    if request.method == 'POST':
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('orders:create_success'))

    context = {
        'form': form,
    }

    return TemplateResponse(request, template_name, context)
Example #24
0
def add_order(request):

    form = OrderForm(request.POST or None)
    orders = Order.objects.all()

    if form.is_valid():
        order = form.save(commit=False)
        order.save()

        messages.success(request, "Order placed")
        return render(request, 'orders/index.html', {'orders': orders})

    return render(request, 'orders/add_order.html', {'form': form})
Example #25
0
def house_detail(request, house_id):
    house = get_object_or_404(House, id=house_id)
    form = OrderForm(request.POST or None, initial={'house': house})

    if request.method == 'POST':
        if form.is_valid():
            form.save()
            return HttpResponseRedirect('{}?sended=True'.format(reverse('house', kwargs={'house_id': house.id})))

    return render(request, 'houses/house_detail.html', {
        'house': house,
        'form': form,
        'sended': request.GET.get('sended', False)
    })
Example #26
0
def house_detail(request, house_id):
    house = get_object_or_404(House, id=house_id)
    form = OrderForm(request.POST or None, initial={"house": house})

    if request.method == "POST":
        if form.is_valid():
            form.save()
            return HttpResponseRedirect("{}?sended=True".format(
                reverse("house", kwargs={"house_id": house.id})))

    return render(request, "houses/house_detail.html", {
        "house": house,
        "form": form,
        "sended": request.GET.get("sended", False)
    })
Example #27
0
def order_page(request):
    form = OrderForm(request.POST)
    if form.is_valid():
        order = form.save(commit=False)
        order.id = request.id
        order.author = request.author
        order.number = request.number
        order.order_price = request.order_price
        order.order_comments = request.order_comments
        order.date_and_time_of_order = timezone.now()
        order.order_status = request.order_status
        order.products_list = request.products_list
        order.client = request.client
        order.save()
    return render(request, "order.html", {'form': form})
Example #28
0
    def get(self, request):
        index = Index.objects.first()
        first_slide = index.slides.first()

        products = Product.objects.filter(is_active=True)[:3]

        order_form = OrderForm()
        feedback_form = FeedBackForm()

        news = News.objects.filter(is_active=True)[:4]

        addresses = Address.objects.all()
        phones = Phone.objects.all()
        emails = Email.objects.all()
        map_code = MapCode.objects.first()

        context = {
            'index': index,
            'first_slide': first_slide,
            'products': products,
            'order_form': order_form,
            'feedback_form': feedback_form,
            'news': news,
            'addresses': addresses,
            'phones': phones,
            'emails': emails,
            'map_code': map_code,
        }

        return render(request, 'core/index.html', context)
Example #29
0
    def get(self, request):
        cart = Cart(request)

        # if not cart.delivery['price']:
        #     messages.error(request, 'Неверный почтовый индекс')

        user = request.user

        initial = cart.delivery
        if user.is_authenticated:
            initial = {
                'method': cart.delivery['method'],
                'price': cart.delivery['price'],
                # 'postcode': cart.delivery['postcode'] or user.postcode,
                'country': cart.delivery['country'] or user.country,
                'region': cart.delivery['region'] or user.region,
                'city': cart.delivery['city'] or user.city,
                'micro_district': cart.delivery['micro_district']
                or user.micro_district,
                'street': cart.delivery['street'] or user.street,
                'house_nmb': cart.delivery['house_nmb'] or user.house_nmb,
                'building_nmb': cart.delivery['building_nmb']
                or user.building_nmb,
                'room_nmb': cart.delivery['room_nmb'] or user.room_nmb,
                'phone': cart.delivery['phone'] or user.phone,
                'full_name': cart.delivery['full_name'] or user.full_name,
                'email': cart.delivery['email'] or user.email,
            }

        order_form = OrderForm(initial=initial)

        context = {
            'order_form': order_form,
        }
        return render(request, 'orders/cart.html', context)
Example #30
0
def contact_info(request):
    cart = Cart(request)
    if len(cart) != 0:
        if request.method == 'POST':
            dandp = DandP(request)
            delivery = request.POST.get('delivery')
            payment = request.POST.get('payment')

            if delivery == 0:
                dandp.dandp['delivery'] = 0
            if delivery == 1:
                dandp.dandp['delivery'] = 1
            if payment == 0:
                dandp.dandp['payment'] = 0
            if payment == 1:
                dandp.dandp['payment'] = 1

            dandp.update(delivery, payment)
    else:
        return redirect('cart')

    form = OrderForm(request.user)

    context = {
        'form': form,
    }

    return render(request, 'orders/contact_info.html', context)
Example #31
0
 def test_customer_excludes_providers(self):
     """Providers should be excluded from dropdown."""
     form = OrderForm()
     Customer.objects.create(name='Provider', phone=5, cp=1, provider=True)
     self.assertEqual(len(form.fields['customer'].choices), 2)
     for customer in form.fields['customer'].choices:
         self.assertNotEqual(customer[1], 'express')
Example #32
0
def meal_details(request, id, slug):
    meal = get_object_or_404(Meal, id=id, slug=slug)
    form = OrderForm()
    context = {
                'meal': meal,
                'form': form,
              }
    return render(request, 'meals/details.html', context)
Example #33
0
def to_order(request, product_id):
	thing = StoreThing.objects.get(id=product_id)

	if request.method == 'POST':
		form = OrderForm(request.POST)
		if form.is_valid():
			cd = form.cleaned_data
			order = Orders(
				name = cd['name'],
				s_name = cd['s_name'],
				p_name = cd['p_name'],
				address = cd['address'],
				phone = cd['phone'],
				email = cd['email'],
				product = thing,
				quantity = cd['quantity'],
				)

			order.save()

			send_mail(
				u'Поступил новый заказ',
				get_template('mail/store_thing_add.txt').render(
					Context({
						's_name': cd['s_name'],
						'name': cd['name'],
						'p_name': cd['p_name'],
						'address': cd['address'],
						'phone': cd['phone'],
						'email': cd['email'],
						'product': thing,
						'quantity': cd['quantity']
						})
					),
					'*****@*****.**',
					['*****@*****.**'])

			return HttpResponseRedirect('/thx/')

	else:
		form = OrderForm()

	return render(request, 'catalog/storething_detail.html', {
		'order_form': form,
		'thing': thing,
	})
Example #34
0
    def post(self, request, pk=None, action=None):
        form = OrderForm(request.POST)
        if form.is_valid():
            order = form.save()
            item = render_to_string('orders/row_item.html', {'order': order})

            response = {
                'valid': 'success',
                'message': 'order created successfully.',
                'item': item
            }
        else:
            response = {
                'valid': 'error',
                'message': form_validation_error(form)
            }
        return JsonResponse(response)
Example #35
0
def orderproduct(request):
    current_user = request.user
    form = OrderForm(request.POST or None)
    shopcart = ShopCart.objects.filter(user_id=current_user.id)
    total = 0
    numItems = 0
    subtotal = []
    for item in shopcart:
        numItems += 1
        total += item.quantity * item.product.price
    for item in shopcart:
        subtotal.append(item.quantity * item.product.price)
    if request.method == 'POST':
        if form.is_valid():
            data = Order()
            data.first_name = form.cleaned_data['first_name']
            data.last_name = form.cleaned_data['last_name']
            data.address = form.cleaned_data['address']
            data.city = form.cleaned_data['city']
            data.email = form.cleaned_data['email']
            data.phone = form.cleaned_data['phone']
            data.user_id = current_user.id
            data.total = total
            data.save()

            for item in shopcart:
                detail = OrderDetail()
                detail.order_id = data.id
                detail.user_id = current_user.id
                detail.product_id = item.product_id
                detail.quantity = item.quantity
                detail.price = item.product.price
                detail.total = item.amount
                detail.save()
            ShopCart.objects.filter(user_id=current_user.id).delete()
            messages.success(request, "Thanks for purchases")
            return HttpResponseRedirect(reverse("orderproduct", args=None))
    context = {
        'total': total,
        'numItems': numItems,
        'shopcart': shopcart,
        'subtotal': subtotal,
        'form': form,
    }
    template = "orders/orderproduct.html"
    return render(request, template, context)
Example #36
0
def update_order(request, pk_order):
    """
    A order update page for the admin to change the status
    and download/upload the artwork for the customer.
    """
    order = Order.objects.get(id=pk_order)
    form = OrderForm(instance=order)
    tax = order.get_total() * Decimal(21 / 100)
    total = order.get_total() + tax

    if order.id_code:
        if request.method == 'POST':
            form = OrderForm(request.POST, request.FILES, instance=order)
            if form.is_valid():
                form.save()
                messages.info(request, 'Order updated successfully')
                return redirect('accounts:adminpage')
        else:
            context = {
                'order': order,
                'tax': tax,
                'total': total,
                'form': form
            }
            return render(request, 'accounts/update_order.html', context)
    else:
        messages.error(request, 'Order still in progress')
        return redirect('accounts:adminpage')
Example #37
0
def new_order(request):
    c = get_client_context(request)
    
    c['map_center'] = '55.76, 37.64'
    c['map_zoom'] = '11'
    
    if request.method == 'GET':
        order_form = OrderForm()
    elif request.method == 'POST':
        order_form = OrderForm(request.POST)
        if order_form.is_valid():
            o = order_form.save(commit=False)
            o.set_created(c['client'])
            messages.success(request, u'Ваш заказ успешно добавлен и ожидает оплаты.')
            return HttpResponseRedirect('/cabinet/history')

    c['order_form'] = order_form
    
    return render_to_response('client/new.html', c, context_instance=RequestContext(request))
Example #38
0
def change(request, order_id=''):
    """
    Display a single order
    """
    if order_id is not '':
        order = get_object_or_404(Order, pk=order_id)
    else:
        order = None

    if request.method == 'POST':
        if order is None:
            order_form = OrderForm(request.POST)
        else:
            order_form = OrderForm(request.POST, instance=order)
        if order_form.is_valid():
            order = order_form.save()
            print(order)
            return HttpResponseRedirect('/orders/list/')
    else:
        if order is None:
            order_form = OrderForm()
        else:
            order_form = OrderForm(instance=order)

    context = {
        'title': 'Change order',
        'order_id': order_id,
        'order_form': order_form,
    }
    return render(request, 'orders/change.html', context)
Example #39
0
def index(req):

	if req.method == 'POST':
		orderform = OrderForm(req.POST)
		if orderform.is_valid():
			try:
				o = orderform.save()
			except IntegrityError as e:
				messages.error(req, e)
				return HttpResponseRedirect(reverse('orders:index'))

			return HttpResponseRedirect(reverse('orders:detail', args=(o.id,)))
	else:
		orderform = OrderForm()

	return render(req,
		'orders/index.html', {
			'title': 'Coffee Ordering',
			'allorders': Order.objects.all(),
			'orderform': orderform
		}
	)
Example #40
0
def index(request):
    if request.method == 'POST':
        form = OrderForm(request.POST)
        if form.is_valid():
            order = form.save()
            item_ids = request.POST.getlist('items[]')
            for item_id in item_ids:
                item = Item.objects.get(pk=item_id)
                ItemOrder.objects.create(item=item, order=order)
            messages.success(request, "Bestelling succesvol doorgegeven!")
            return HttpResponseRedirect(reverse('index'))
    else:
        form = OrderForm()
    categories = Category.objects.all().prefetch_related('items__discounts')
    total = Item.objects.count()
    n = 0
    cols = [[], []]
    for category in categories:
        cols[0 if n < total/2 else 1].append(category)
        n += category.items.count()
    context = {'cols': cols, 'form': form}
    return render(request, 'orders/index.html', context)
Example #41
0
def customer_submits_valet_request(request, format=None):

	customer = request.user

	request.session['customer_id'] = customer.id

	if request.method == "POST":

		form = OrderForm(request.POST)

		if form.is_valid():


			print request.POST

			# users current position
			location = Location()
			location.lat = request.POST['lat']
			location.lng = request.POST['lng']
			location.full_address = request.POST['address']
			location.save()

			if request.POST['is_repark']:

				# create Repark instancee
				repark = Repark()
				repark.requested_by = customer
				repark.pickup_location = location
				repark.requested_at = local_time_now
				repark.save()
				request.session["repark_id"] = repark.id

				serializer = ReparkSerializer(repark)

			if request.POST['is_dropoff']:

				# retrieve latest request
				last_request = customer.orders_repark_customer_related.latest('completed_at')
				
				# create Dropoff instance
				dropoff = Dropoff()
				dropoff.requested_by = customer

				# vehicle pickup location is the last request's dropoff location
				dropoff.pickup_location = last_request.dropoff_location
				# vehicle dropoff location is location of user's current position
				dropoff.dropoff_location = location
				dropoff.requested_at = local_time_now
				dropoff.save()
				request.session["dropoff_id"] = dropoff.id

				serializer = DropoffSerializer(dropoff)
			
			if request.POST['is_scheduled_repark']:

				scheduled_repark = ScheduledRepark()
				scheduled_repark.requested_by = customer
				scheduled_repark.pickup_location = location
				scheduled_repark.scheduled_start_date = request.POST['scheduled_start_date']
				scheduled_repark.scheduled_end_date = request.POST['scheduled_end_date']
				scheduled_repark.time_limit = request.POST['time_limit']
				scheduled_repark.requested_at = local_time_now

				"""
				Calculate the expiration time based on when user requested repark
				"""

				parking_exp_time = local_time_now + datetime.timedelta(hours=int(scheduled_repark.time_limit))
				scheduled_repark.parking_exp_time = parking_exp_time


				scheduled_repark.save()

				request.session["scheduled_repark_id"] = scheduled_repark.id

				serializer = ScheduledReparkSerializer(scheduled_repark)


				# send repark to celery task queue
				# eta should be 30 to 45 mins before parking_exp_time

				# tasks.query_valets.apply_async((scheduled_repark.id,), link=tasks.match_valet_with_repark.s(scheduled_repark.id))
				tasks.match_valet_with_repark.apply_async(scheduled_repark.id, countdown=60)

			data = serializer.data
			print(data)

			return Response(data, template_name='maps/user/index.html')