1 # -*- coding: utf-8 -*-
4 from openerp import SUPERUSER_ID
5 from openerp import http
6 from openerp.http import request
7 from openerp.tools.translate import _
8 from openerp.addons.website.models.website import slug
10 PPG = 20 # Products Per Page
11 PPR = 4 # Products Per Row
13 class table_compute(object):
17 def _check_place(self, posx, posy, sizex, sizey):
19 for y in range(sizey):
20 for x in range(sizex):
24 row = self.table.setdefault(posy+y, {})
25 if row.setdefault(posx+x) is not None:
29 self.table[posy+y].setdefault(x, None)
32 def process(self, products):
33 # Compute products positions on the grid
38 x = min(max(p.website_size_x, 1), PPR)
39 y = min(max(p.website_size_y, 1), PPR)
44 while not self._check_place(pos%PPR, pos/PPR, x, y):
46 # if 21st products (index 20) and the last line is full (PPR products in it), break
47 # (pos + 1.0) / PPR is the line where the product would be inserted
48 # maxy is the number of existing lines
49 # + 1.0 is because pos begins at 0, thus pos 20 is actually the 21st block
50 # and to force python to not round the division operation
51 if index >= PPG and ((pos + 1.0) / PPR) > maxy:
54 if x==1 and y==1: # simple heuristic for CPU optimization
59 self.table[(pos/PPR)+y2][(pos%PPR)+x2] = False
60 self.table[pos/PPR][pos%PPR] = {
61 'product': p, 'x':x, 'y': y,
62 'class': " ".join(map(lambda x: x.html_class or '', p.website_style_ids))
65 maxy=max(maxy,y+(pos/PPR))
68 # Format table according to HTML needs
69 rows = self.table.items()
71 rows = map(lambda x: x[1], rows)
72 for col in range(len(rows)):
73 cols = rows[col].items()
76 rows[col] = [c for c in map(lambda x: x[1], cols) if c != False]
80 # TODO keep with input type hidden
83 class QueryURL(object):
84 def __init__(self, path='', **args):
88 def __call__(self, path=None, **kw):
91 for k,v in self.args.items():
94 for k,v in kw.items():
96 if isinstance(v, list) or isinstance(v, set):
97 l.append(werkzeug.url_encode([(k,i) for i in v]))
99 l.append(werkzeug.url_encode([(k,v)]))
101 path += '?' + '&'.join(l)
106 cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
107 sale_order = context.get('sale_order')
109 pricelist = sale_order.pricelist_id
111 partner = pool['res.users'].browse(cr, SUPERUSER_ID, uid, context=context).partner_id
112 pricelist = partner.property_product_pricelist
115 class website_sale(http.Controller):
117 def get_pricelist(self):
118 return get_pricelist()
120 def get_attribute_value_ids(self, product):
121 cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
122 currency_obj = pool['res.currency']
123 attribute_value_ids = []
124 if request.website.pricelist_id.id != context['pricelist']:
125 website_currency_id = request.website.currency_id.id
126 currency_id = self.get_pricelist().currency_id.id
127 for p in product.product_variant_ids:
128 price = currency_obj.compute(cr, uid, website_currency_id, currency_id, p.lst_price)
129 attribute_value_ids.append([p.id, [v.id for v in p.attribute_value_ids if len(v.attribute_id.value_ids) > 1], p.price, price])
131 attribute_value_ids = [[p.id, [v.id for v in p.attribute_value_ids if len(v.attribute_id.value_ids) > 1], p.price, p.lst_price]
132 for p in product.product_variant_ids]
134 return attribute_value_ids
136 @http.route(['/shop',
137 '/shop/page/<int:page>',
138 '/shop/category/<model("product.public.category"):category>',
139 '/shop/category/<model("product.public.category"):category>/page/<int:page>'
140 ], type='http', auth="public", website=True)
141 def shop(self, page=0, category=None, search='', **post):
142 cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
144 domain = request.website.sale_product_domain()
146 domain += ['|', '|', '|', ('name', 'ilike', search), ('description', 'ilike', search),
147 ('description_sale', 'ilike', search), ('product_variant_ids.default_code', 'ilike', search)]
149 domain += [('public_categ_ids', 'child_of', int(category))]
151 attrib_list = request.httprequest.args.getlist('attrib')
152 attrib_values = [map(int,v.split("-")) for v in attrib_list if v]
153 attrib_set = set([v[1] for v in attrib_values])
158 for value in attrib_values:
162 elif value[0] == attrib:
165 domain += [('attribute_line_ids.value_ids', 'in', ids)]
169 domain += [('attribute_line_ids.value_ids', 'in', ids)]
171 keep = QueryURL('/shop', category=category and int(category), search=search, attrib=attrib_list)
173 if not context.get('pricelist'):
174 pricelist = self.get_pricelist()
175 context['pricelist'] = int(pricelist)
177 pricelist = pool.get('product.pricelist').browse(cr, uid, context['pricelist'], context)
181 post["search"] = search
183 category = pool['product.public.category'].browse(cr, uid, int(category), context=context)
184 url = "/shop/category/%s" % slug(category)
186 style_obj = pool['product.style']
187 style_ids = style_obj.search(cr, uid, [], context=context)
188 styles = style_obj.browse(cr, uid, style_ids, context=context)
190 category_obj = pool['product.public.category']
191 category_ids = category_obj.search(cr, uid, [], context=context)
192 categories = category_obj.browse(cr, uid, category_ids, context=context)
193 categs = filter(lambda x: not x.parent_id, categories)
195 domain += [('public_categ_ids', 'in', category_ids)]
196 product_obj = pool.get('product.template')
198 product_count = product_obj.search_count(cr, uid, domain, context=context)
199 pager = request.website.pager(url=url, total=product_count, page=page, step=PPG, scope=7, url_args=post)
200 product_ids = product_obj.search(cr, uid, domain, limit=PPG, offset=pager['offset'], order='website_published desc, website_sequence desc', context=context)
201 products = product_obj.browse(cr, uid, product_ids, context=context)
203 attributes_obj = request.registry['product.attribute']
204 attributes_ids = attributes_obj.search(cr, uid, [], context=context)
205 attributes = attributes_obj.browse(cr, uid, attributes_ids, context=context)
207 from_currency = pool.get('product.price.type')._get_field_currency(cr, uid, 'list_price', context)
208 to_currency = pricelist.currency_id
209 compute_currency = lambda price: pool['res.currency']._compute(cr, uid, from_currency, to_currency, price, context=context)
213 'category': category,
214 'attrib_values': attrib_values,
215 'attrib_set': attrib_set,
217 'pricelist': pricelist,
218 'products': products,
219 'bins': table_compute().process(products),
222 'categories': categs,
223 'attributes': attributes,
224 'compute_currency': compute_currency,
226 'style_in_product': lambda style, product: style.id in [s.id for s in product.website_style_ids],
227 'attrib_encode': lambda attribs: werkzeug.url_encode([('attrib',i) for i in attribs]),
229 return request.website.render("website_sale.products", values)
231 @http.route(['/shop/product/<model("product.template"):product>'], type='http', auth="public", website=True)
232 def product(self, product, category='', search='', **kwargs):
233 cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
234 category_obj = pool['product.public.category']
235 template_obj = pool['product.template']
237 context.update(active_id=product.id)
240 category = category_obj.browse(cr, uid, int(category), context=context)
242 attrib_list = request.httprequest.args.getlist('attrib')
243 attrib_values = [map(int,v.split("-")) for v in attrib_list if v]
244 attrib_set = set([v[1] for v in attrib_values])
246 keep = QueryURL('/shop', category=category and category.id, search=search, attrib=attrib_list)
248 category_ids = category_obj.search(cr, uid, [], context=context)
249 category_list = category_obj.name_get(cr, uid, category_ids, context=context)
250 category_list = sorted(category_list, key=lambda category: category[1])
252 pricelist = self.get_pricelist()
254 from_currency = pool.get('product.price.type')._get_field_currency(cr, uid, 'list_price', context)
255 to_currency = pricelist.currency_id
256 compute_currency = lambda price: pool['res.currency']._compute(cr, uid, from_currency, to_currency, price, context=context)
258 if not context.get('pricelist'):
259 context['pricelist'] = int(self.get_pricelist())
260 product = template_obj.browse(cr, uid, int(product), context=context)
264 'category': category,
265 'pricelist': pricelist,
266 'attrib_values': attrib_values,
267 'compute_currency': compute_currency,
268 'attrib_set': attrib_set,
270 'category_list': category_list,
271 'main_object': product,
273 'get_attribute_value_ids': self.get_attribute_value_ids
275 return request.website.render("website_sale.product", values)
277 @http.route(['/shop/product/comment/<int:product_template_id>'], type='http', auth="public", methods=['POST'], website=True)
278 def product_comment(self, product_template_id, **post):
279 cr, uid, context = request.cr, request.uid, request.context
280 if post.get('comment'):
281 request.registry['product.template'].message_post(
282 cr, uid, product_template_id,
283 body=post.get('comment'),
285 subtype='mt_comment',
286 context=dict(context, mail_create_nosubcribe=True))
287 return werkzeug.utils.redirect(request.httprequest.referrer + "#comments")
289 @http.route(['/shop/pricelist'], type='http', auth="public", website=True)
290 def pricelist(self, promo, **post):
291 cr, uid, context = request.cr, request.uid, request.context
292 request.website.sale_get_order(code=promo, context=context)
293 return request.redirect("/shop/cart")
295 @http.route(['/shop/cart'], type='http', auth="public", website=True)
296 def cart(self, **post):
297 cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
298 order = request.website.sale_get_order()
300 from_currency = pool.get('product.price.type')._get_field_currency(cr, uid, 'list_price', context)
301 to_currency = order.pricelist_id.currency_id
302 compute_currency = lambda price: pool['res.currency']._compute(cr, uid, from_currency, to_currency, price, context=context)
304 compute_currency = lambda price: price
308 'compute_currency': compute_currency,
309 'suggested_products': [],
313 if not context.get('pricelist'):
314 _order = order.with_context(pricelist=order.pricelist_id.id)
315 values['suggested_products'] = _order._cart_accessories()
317 return request.website.render("website_sale.cart", values)
319 @http.route(['/shop/cart/update'], type='http', auth="public", methods=['POST'], website=True)
320 def cart_update(self, product_id, add_qty=1, set_qty=0, **kw):
321 cr, uid, context = request.cr, request.uid, request.context
322 request.website.sale_get_order(force_create=1)._cart_update(product_id=int(product_id), add_qty=float(add_qty), set_qty=float(set_qty))
323 return request.redirect("/shop/cart")
325 @http.route(['/shop/cart/update_json'], type='json', auth="public", methods=['POST'], website=True)
326 def cart_update_json(self, product_id, line_id, add_qty=None, set_qty=None, display=True):
327 order = request.website.sale_get_order(force_create=1)
328 value = order._cart_update(product_id=product_id, line_id=line_id, add_qty=add_qty, set_qty=set_qty)
331 value['cart_quantity'] = order.cart_quantity
332 value['website_sale.total'] = request.website._render("website_sale.total", {
333 'website_sale_order': request.website.sale_get_order()
337 #------------------------------------------------------
339 #------------------------------------------------------
341 def checkout_redirection(self, order):
342 cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
344 # must have a draft sale order with lines at this point, otherwise reset
345 if not order or order.state != 'draft':
346 request.session['sale_order_id'] = None
347 request.session['sale_transaction_id'] = None
348 return request.redirect('/shop')
350 # if transaction pending / done: redirect to confirmation
351 tx = context.get('website_sale_transaction')
352 if tx and tx.state != 'draft':
353 return request.redirect('/shop/payment/confirmation/%s' % order.id)
355 def checkout_values(self, data=None):
356 cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
357 orm_partner = registry.get('res.partner')
358 orm_user = registry.get('res.users')
359 orm_country = registry.get('res.country')
360 state_orm = registry.get('res.country.state')
362 country_ids = orm_country.search(cr, SUPERUSER_ID, [], context=context)
363 countries = orm_country.browse(cr, SUPERUSER_ID, country_ids, context)
364 states_ids = state_orm.search(cr, SUPERUSER_ID, [], context=context)
365 states = state_orm.browse(cr, SUPERUSER_ID, states_ids, context)
366 partner = orm_user.browse(cr, SUPERUSER_ID, request.uid, context).partner_id
374 if request.uid != request.website.user_id.id:
375 checkout.update( self.checkout_parse("billing", partner) )
376 shipping_ids = orm_partner.search(cr, SUPERUSER_ID, [("parent_id", "=", partner.id), ('type', "=", 'delivery')], context=context)
378 order = request.website.sale_get_order(force_create=1, context=context)
380 domain = [("partner_id", "=", order.partner_id.id)]
381 user_ids = request.registry['res.users'].search(cr, SUPERUSER_ID, domain, context=dict(context or {}, active_test=False))
382 if not user_ids or request.website.user_id.id not in user_ids:
383 checkout.update( self.checkout_parse("billing", order.partner_id) )
385 checkout = self.checkout_parse('billing', data)
387 shipping_id = int(data["shipping_id"])
390 if shipping_id == -1:
391 checkout.update(self.checkout_parse('shipping', data))
393 if shipping_id is None:
395 order = request.website.sale_get_order(context=context)
396 if order and order.partner_shipping_id:
397 shipping_id = order.partner_shipping_id.id
399 shipping_ids = list(set(shipping_ids) - set([partner.id]))
401 if shipping_id == partner.id:
403 elif shipping_id > 0 and shipping_id not in shipping_ids:
404 shipping_ids.append(shipping_id)
405 elif shipping_id is None and shipping_ids:
406 shipping_id = shipping_ids[0]
408 ctx = dict(context, show_address=1)
411 shippings = shipping_ids and orm_partner.browse(cr, SUPERUSER_ID, list(shipping_ids), ctx) or []
413 shipping = orm_partner.browse(cr, SUPERUSER_ID, shipping_id, ctx)
414 checkout.update( self.checkout_parse("shipping", shipping) )
416 checkout['shipping_id'] = shipping_id
418 # Default search by user country
419 if not checkout.get('country_id'):
420 country_code = request.session['geoip'].get('country_code')
422 country_ids = request.registry.get('res.country').search(cr, uid, [('code', '=', country_code)], context=context)
424 checkout['country_id'] = country_ids[0]
427 'countries': countries,
429 'checkout': checkout,
430 'shipping_id': partner.id != shipping_id and shipping_id or 0,
431 'shippings': shippings,
433 'has_check_vat': hasattr(registry['res.partner'], 'check_vat')
438 mandatory_billing_fields = ["name", "phone", "email", "street2", "city", "country_id"]
439 optional_billing_fields = ["street", "state_id", "vat", "vat_subjected", "zip"]
440 mandatory_shipping_fields = ["name", "phone", "street", "city", "country_id"]
441 optional_shipping_fields = ["state_id", "zip"]
443 def checkout_parse(self, address_type, data, remove_prefix=False):
444 """ data is a dict OR a partner browse record
446 # set mandatory and optional fields
447 assert address_type in ('billing', 'shipping')
448 if address_type == 'billing':
449 all_fields = self.mandatory_billing_fields + self.optional_billing_fields
452 all_fields = self.mandatory_shipping_fields + self.optional_shipping_fields
456 if isinstance(data, dict):
457 query = dict((prefix + field_name, data[prefix + field_name])
458 for field_name in all_fields if data.get(prefix + field_name))
460 query = dict((prefix + field_name, getattr(data, field_name))
461 for field_name in all_fields if getattr(data, field_name))
462 if address_type == 'billing' and data.parent_id:
463 query[prefix + 'street'] = data.parent_id.name
465 if query.get(prefix + 'state_id'):
466 query[prefix + 'state_id'] = int(query[prefix + 'state_id'])
467 if query.get(prefix + 'country_id'):
468 query[prefix + 'country_id'] = int(query[prefix + 'country_id'])
470 if query.get(prefix + 'vat'):
471 query[prefix + 'vat_subjected'] = True
473 if not remove_prefix:
476 return dict((field_name, data[prefix + field_name]) for field_name in all_fields if data.get(prefix + field_name))
478 def checkout_form_validate(self, data):
479 cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
483 for field_name in self.mandatory_billing_fields:
484 if not data.get(field_name):
485 error[field_name] = 'missing'
487 if data.get("vat") and hasattr(registry["res.partner"], "check_vat"):
488 if request.website.company_id.vat_check_vies:
489 # force full VIES online check
490 check_func = registry["res.partner"].vies_vat_check
492 # quick and partial off-line checksum validation
493 check_func = registry["res.partner"].simple_vat_check
494 vat_country, vat_number = registry["res.partner"]._split_vat(data.get("vat"))
495 if not check_func(cr, uid, vat_country, vat_number, context=None): # simple_vat_check
496 error["vat"] = 'error'
498 if data.get("shipping_id") == -1:
499 for field_name in self.mandatory_shipping_fields:
500 field_name = 'shipping_' + field_name
501 if not data.get(field_name):
502 error[field_name] = 'missing'
506 def checkout_form_save(self, checkout):
507 cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
509 order = request.website.sale_get_order(force_create=1, context=context)
511 orm_partner = registry.get('res.partner')
512 orm_user = registry.get('res.users')
513 order_obj = request.registry.get('sale.order')
515 billing_info = self.checkout_parse('billing', checkout, True)
519 if request.uid != request.website.user_id.id:
520 partner_id = orm_user.browse(cr, SUPERUSER_ID, uid, context=context).partner_id.id
521 elif order.partner_id:
522 user_ids = request.registry['res.users'].search(cr, SUPERUSER_ID,
523 [("partner_id", "=", order.partner_id.id)], context=dict(context or {}, active_test=False))
524 if not user_ids or request.website.user_id.id not in user_ids:
525 partner_id = order.partner_id.id
527 # save partner informations
528 if partner_id and request.website.partner_id.id != partner_id:
529 orm_partner.write(cr, SUPERUSER_ID, [partner_id], billing_info, context=context)
532 partner_id = orm_partner.create(cr, SUPERUSER_ID, billing_info, context=context)
534 # create a new shipping partner
535 if checkout.get('shipping_id') == -1:
536 shipping_info = self.checkout_parse('shipping', checkout, True)
537 shipping_info['type'] = 'delivery'
538 shipping_info['parent_id'] = partner_id
539 checkout['shipping_id'] = orm_partner.create(cr, SUPERUSER_ID, shipping_info, context)
542 'partner_id': partner_id,
543 'message_follower_ids': [(4, partner_id), (3, request.website.partner_id.id)],
544 'partner_invoice_id': partner_id,
546 order_info.update(order_obj.onchange_partner_id(cr, SUPERUSER_ID, [], partner_id, context=context)['value'])
547 address_change = order_obj.onchange_delivery_id(cr, SUPERUSER_ID, [], order.company_id.id, partner_id,
548 checkout.get('shipping_id'), None, context=context)['value']
549 order_info.update(address_change)
550 if address_change.get('fiscal_position'):
551 fiscal_update = order_obj.onchange_fiscal_position(cr, SUPERUSER_ID, [], address_change['fiscal_position'],
552 [(4, l.id) for l in order.order_line], context=None)['value']
553 order_info.update(fiscal_update)
555 order_info.pop('user_id')
556 order_info.update(partner_shipping_id=checkout.get('shipping_id') or partner_id)
558 order_obj.write(cr, SUPERUSER_ID, [order.id], order_info, context=context)
560 @http.route(['/shop/checkout'], type='http', auth="public", website=True)
561 def checkout(self, **post):
562 cr, uid, context = request.cr, request.uid, request.context
564 order = request.website.sale_get_order(force_create=1, context=context)
566 redirection = self.checkout_redirection(order)
570 values = self.checkout_values()
572 return request.website.render("website_sale.checkout", values)
574 @http.route(['/shop/confirm_order'], type='http', auth="public", website=True)
575 def confirm_order(self, **post):
576 cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
578 order = request.website.sale_get_order(context=context)
580 return request.redirect("/shop")
582 redirection = self.checkout_redirection(order)
586 values = self.checkout_values(post)
588 values["error"] = self.checkout_form_validate(values["checkout"])
590 return request.website.render("website_sale.checkout", values)
592 self.checkout_form_save(values["checkout"])
594 request.session['sale_last_order_id'] = order.id
596 request.website.sale_get_order(update_pricelist=True, context=context)
598 return request.redirect("/shop/payment")
600 #------------------------------------------------------
602 #------------------------------------------------------
604 @http.route(['/shop/payment'], type='http', auth="public", website=True)
605 def payment(self, **post):
606 """ Payment step. This page proposes several payment means based on available
607 payment.acquirer. State at this point :
609 - a draft sale order with lines; otherwise, clean context / session and
611 - no transaction in context / session, or only a draft one, if the customer
612 did go to a payment.acquirer website but closed the tab without
615 cr, uid, context = request.cr, request.uid, request.context
616 payment_obj = request.registry.get('payment.acquirer')
617 sale_order_obj = request.registry.get('sale.order')
619 order = request.website.sale_get_order(context=context)
621 redirection = self.checkout_redirection(order)
625 shipping_partner_id = False
627 if order.partner_shipping_id.id:
628 shipping_partner_id = order.partner_shipping_id.id
630 shipping_partner_id = order.partner_invoice_id.id
633 'order': request.registry['sale.order'].browse(cr, SUPERUSER_ID, order.id, context=context)
635 values['errors'] = sale_order_obj._get_errors(cr, uid, order, context=context)
636 values.update(sale_order_obj._get_website_data(cr, uid, order, context))
638 # fetch all registered payment means
640 # acquirer_ids = [tx.acquirer_id.id]
642 if not values['errors']:
643 acquirer_ids = payment_obj.search(cr, SUPERUSER_ID, [('website_published', '=', True), ('company_id', '=', order.company_id.id)], context=context)
644 values['acquirers'] = list(payment_obj.browse(cr, uid, acquirer_ids, context=context))
645 render_ctx = dict(context, submit_class='btn btn-primary', submit_txt=_('Pay Now'))
646 for acquirer in values['acquirers']:
647 acquirer.button = payment_obj.render(
648 cr, SUPERUSER_ID, acquirer.id,
651 order.pricelist_id.currency_id.id,
652 partner_id=shipping_partner_id,
654 'return_url': '/shop/payment/validate',
658 return request.website.render("website_sale.payment", values)
660 @http.route(['/shop/payment/transaction/<int:acquirer_id>'], type='json', auth="public", website=True)
661 def payment_transaction(self, acquirer_id):
662 """ Json method that creates a payment.transaction, used to create a
663 transaction when the user clicks on 'pay now' button. After having
664 created the transaction, the event continues and the user is redirected
665 to the acquirer website.
667 :param int acquirer_id: id of a payment.acquirer record. If not set the
668 user is redirected to the checkout page
670 cr, uid, context = request.cr, request.uid, request.context
671 transaction_obj = request.registry.get('payment.transaction')
672 order = request.website.sale_get_order(context=context)
674 if not order or not order.order_line or acquirer_id is None:
675 return request.redirect("/shop/checkout")
677 assert order.partner_id.id != request.website.partner_id.id
679 # find an already existing transaction
680 tx = request.website.sale_get_transaction()
682 if tx.state == 'draft': # button cliked but no more info -> rewrite on tx or create a new one ?
684 'acquirer_id': acquirer_id,
688 tx_id = transaction_obj.create(cr, SUPERUSER_ID, {
689 'acquirer_id': acquirer_id,
691 'amount': order.amount_total,
692 'currency_id': order.pricelist_id.currency_id.id,
693 'partner_id': order.partner_id.id,
694 'partner_country_id': order.partner_id.country_id.id,
695 'reference': order.name,
696 'sale_order_id': order.id,
698 request.session['sale_transaction_id'] = tx_id
699 tx = transaction_obj.browse(cr, SUPERUSER_ID, tx_id, context=context)
702 request.registry['sale.order'].write(
703 cr, SUPERUSER_ID, [order.id], {
704 'payment_acquirer_id': acquirer_id,
705 'payment_tx_id': request.session['sale_transaction_id']
708 # confirm the quotation
709 if tx.acquirer_id.auto_confirm == 'at_pay_now':
710 request.registry['sale.order'].action_button_confirm(cr, SUPERUSER_ID, [order.id], context=request.context)
714 @http.route('/shop/payment/get_status/<int:sale_order_id>', type='json', auth="public", website=True)
715 def payment_get_status(self, sale_order_id, **post):
716 cr, uid, context = request.cr, request.uid, request.context
718 order = request.registry['sale.order'].browse(cr, SUPERUSER_ID, sale_order_id, context=context)
719 assert order.id == request.session.get('sale_last_order_id')
724 'message': '<p>%s</p>' % _('There seems to be an error with your request.'),
727 tx_ids = request.registry['payment.transaction'].search(
729 '|', ('sale_order_id', '=', order.id), ('reference', '=', order.name)
733 if order.amount_total:
736 'message': '<p>%s</p>' % _('There seems to be an error with your request.'),
740 message = '<h2>%s</h2>' % _('Your order has been confirmed, thank you for your loyalty.')
743 tx = request.registry['payment.transaction'].browse(cr, SUPERUSER_ID, tx_ids[0], context=context)
745 message = '<h2>%s</h2>' % _('Thank you for your order.')
747 message += '<p>%s</p>' % _('Your payment has been received.')
748 elif state == 'cancel':
749 message += '<p>%s</p>' % _('The payment seems to have been canceled.')
750 elif state == 'pending' and tx.acquirer_id.validation == 'manual':
751 message += '<p>%s</p>' % _('Your transaction is waiting confirmation.')
752 if tx.acquirer_id.post_msg:
753 message += tx.acquirer_id.post_msg
755 message += '<p>%s</p>' % _('Your transaction is waiting confirmation.')
756 validation = tx.acquirer_id.validation
761 'validation': validation
764 @http.route('/shop/payment/validate', type='http', auth="public", website=True)
765 def payment_validate(self, transaction_id=None, sale_order_id=None, **post):
766 """ Method that should be called by the server when receiving an update
767 for a transaction. State at this point :
771 cr, uid, context = request.cr, request.uid, request.context
773 sale_order_obj = request.registry['sale.order']
775 if transaction_id is None:
776 tx = request.website.sale_get_transaction()
778 tx = request.registry['payment.transaction'].browse(cr, uid, transaction_id, context=context)
780 if sale_order_id is None:
781 order = request.website.sale_get_order(context=context)
783 order = request.registry['sale.order'].browse(cr, SUPERUSER_ID, sale_order_id, context=context)
784 assert order.id == request.session.get('sale_last_order_id')
786 if not order or (order.amount_total and not tx):
787 return request.redirect('/shop')
789 if (not order.amount_total and not tx) or tx.state in ['pending', 'done']:
790 if (not order.amount_total and not tx):
791 # Orders are confirmed by payment transactions, but there is none for free orders,
792 # (e.g. free events), so confirm immediately
793 order.action_button_confirm()
795 email_act = sale_order_obj.action_quotation_send(cr, SUPERUSER_ID, [order.id], context=request.context)
796 elif tx and tx.state == 'cancel':
797 # cancel the quotation
798 sale_order_obj.action_cancel(cr, SUPERUSER_ID, [order.id], context=request.context)
801 if email_act and email_act.get('context'):
803 email_ctx = email_act['context']
804 public_id = request.website.user_id.id
806 composer_values['email_from'] = request.website.user_id.company_id.email
807 composer_id = request.registry['mail.compose.message'].create(cr, SUPERUSER_ID, composer_values, context=email_ctx)
808 request.registry['mail.compose.message'].send_mail(cr, SUPERUSER_ID, [composer_id], context=email_ctx)
810 # clean context and session, then redirect to the confirmation page
811 request.website.sale_reset(context=context)
813 return request.redirect('/shop/confirmation')
815 @http.route(['/shop/confirmation'], type='http', auth="public", website=True)
816 def payment_confirmation(self, **post):
817 """ End of checkout process controller. Confirmation is basically seing
818 the status of a sale.order. State at this point :
820 - should not have any context / session info: clean them
821 - take a sale.order id, because we request a sale.order and are not
822 session dependant anymore
824 cr, uid, context = request.cr, request.uid, request.context
826 sale_order_id = request.session.get('sale_last_order_id')
828 order = request.registry['sale.order'].browse(cr, SUPERUSER_ID, sale_order_id, context=context)
830 return request.redirect('/shop')
832 return request.website.render("website_sale.confirmation", {'order': order})
834 #------------------------------------------------------
836 #------------------------------------------------------
838 @http.route(['/shop/add_product'], type='http', auth="user", methods=['POST'], website=True)
839 def add_product(self, name=None, category=0, **post):
840 cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
842 name = _("New Product")
843 product_obj = request.registry.get('product.product')
844 product_id = product_obj.create(cr, uid, { 'name': name, 'public_categ_ids': category }, context=context)
845 product = product_obj.browse(cr, uid, product_id, context=context)
847 return request.redirect("/shop/product/%s?enable_editor=1" % slug(product.product_tmpl_id))
849 @http.route(['/shop/change_styles'], type='json', auth="public")
850 def change_styles(self, id, style_id):
851 product_obj = request.registry.get('product.template')
852 product = product_obj.browse(request.cr, request.uid, id, context=request.context)
856 for style in product.website_style_ids:
857 if style.id == style_id:
858 remove.append(style.id)
862 style = request.registry.get('product.style').browse(request.cr, request.uid, style_id, context=request.context)
865 product.write({'website_style_ids': [(3, rid) for rid in remove]})
867 product.write({'website_style_ids': [(4, style.id)]})
871 @http.route(['/shop/change_sequence'], type='json', auth="public")
872 def change_sequence(self, id, sequence):
873 product_obj = request.registry.get('product.template')
874 if sequence == "top":
875 product_obj.set_sequence_top(request.cr, request.uid, [id], context=request.context)
876 elif sequence == "bottom":
877 product_obj.set_sequence_bottom(request.cr, request.uid, [id], context=request.context)
878 elif sequence == "up":
879 product_obj.set_sequence_up(request.cr, request.uid, [id], context=request.context)
880 elif sequence == "down":
881 product_obj.set_sequence_down(request.cr, request.uid, [id], context=request.context)
883 @http.route(['/shop/change_size'], type='json', auth="public")
884 def change_size(self, id, x, y):
885 product_obj = request.registry.get('product.template')
886 product = product_obj.browse(request.cr, request.uid, id, context=request.context)
887 return product.write({'website_size_x': x, 'website_size_y': y})
889 def order_lines_2_google_api(self, order_lines):
890 """ Transforms a list of order lines into a dict for google analytics """
892 for line in order_lines:
894 'id': line.order_id and line.order_id.id,
895 'name': line.product_id.categ_id and line.product_id.categ_id.name or '-',
896 'sku': line.product_id.id,
897 'quantity': line.product_uom_qty,
898 'price': line.price_unit,
902 @http.route(['/shop/tracking_last_order'], type='json', auth="public")
903 def tracking_cart(self, **post):
904 """ return data about order in JSON needed for google analytics"""
905 cr, uid, context = request.cr, request.uid, request.context
907 sale_order_id = request.session.get('sale_last_order_id')
909 order = request.registry['sale.order'].browse(cr, SUPERUSER_ID, sale_order_id, context=context)
910 ret['transaction'] = {
912 'affiliation': order.company_id.name,
913 'revenue': order.amount_total,
914 'currency': order.currency_id.name
916 ret['lines'] = self.order_lines_2_google_api(order.order_line)
919 # vim:expandtab:tabstop=4:softtabstop=4:shiftwidth=4: