import werkzeug
from openerp import SUPERUSER_ID
-from openerp.addons.web import http
-from openerp.addons.web.http import request
+from openerp import http
+from openerp.http import request
from openerp.tools.translate import _
from openerp.addons.website.models.website import slug
for p in products:
x = min(max(p.website_size_x, 1), PPR)
y = min(max(p.website_size_y, 1), PPR)
- if index>PPG:
+ if index>=PPG:
x = y = 1
pos = minpos
while not self._check_place(pos%PPR, pos/PPR, x, y):
pos += 1
-
- if index>PPG and (pos/PPR)>maxy:
+ # if 21st products (index 20) and the last line is full (PPR products in it), break
+ # (pos + 1.0) / PPR is the line where the product would be inserted
+ # maxy is the number of existing lines
+ # + 1.0 is because pos begins at 0, thus pos 20 is actually the 21st block
+ # and to force python to not round the division operation
+ if index >= PPG and ((pos + 1.0) / PPR) > maxy:
break
if x==1 and y==1: # simple heuristic for CPU optimization
return path
+def get_pricelist():
+ cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
+ sale_order = context.get('sale_order')
+ if sale_order:
+ pricelist = sale_order.pricelist_id
+ else:
+ partner = pool['res.users'].browse(cr, SUPERUSER_ID, uid, context=context).partner_id
+ pricelist = partner.property_product_pricelist
+ return pricelist
+
class website_sale(http.Controller):
def get_pricelist(self):
+ return get_pricelist()
+
+ def get_attribute_value_ids(self, product):
cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
- sale_order = context.get('sale_order')
- if sale_order:
- pricelist = sale_order.pricelist_id
+ currency_obj = pool['res.currency']
+ attribute_value_ids = []
+ if request.website.pricelist_id.id != context['pricelist']:
+ website_currency_id = request.website.currency_id.id
+ currency_id = self.get_pricelist().currency_id.id
+ for p in product.product_variant_ids:
+ price = currency_obj.compute(cr, uid, website_currency_id, currency_id, p.lst_price)
+ 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])
else:
- partner = pool['res.users'].browse(cr, SUPERUSER_ID, uid, context=context).partner_id
- pricelist = partner.property_product_pricelist
- return pricelist
+ 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]
+ for p in product.product_variant_ids]
+
+ return attribute_value_ids
@http.route(['/shop',
'/shop/page/<int:page>',
domain += ['|', '|', '|', ('name', 'ilike', search), ('description', 'ilike', search),
('description_sale', 'ilike', search), ('product_variant_ids.default_code', 'ilike', search)]
if category:
- domain += [('product_variant_ids.public_categ_ids', 'child_of', int(category))]
+ domain += [('public_categ_ids', 'child_of', int(category))]
+
+ attrib_list = request.httprequest.args.getlist('attrib')
+ attrib_values = [map(int,v.split("-")) for v in attrib_list if v]
+ attrib_set = set([v[1] for v in attrib_values])
- attrib_values = [map(int,v.split(",")) for v in request.httprequest.args.getlist('attrib') if v]
if attrib_values:
attrib = None
ids = []
if attrib:
domain += [('attribute_line_ids.value_ids', 'in', ids)]
- attrib_set = set([v[1] for v in attrib_values])
- keep = QueryURL('/shop', category=category and int(category), search=search, attrib=attrib_set)
+ keep = QueryURL('/shop', category=category and int(category), search=search, attrib=attrib_list)
if not context.get('pricelist'):
- context['pricelist'] = int(self.get_pricelist())
- product_obj = pool.get('product.template')
+ pricelist = self.get_pricelist()
+ context['pricelist'] = int(pricelist)
+ else:
+ pricelist = pool.get('product.pricelist').browse(cr, uid, context['pricelist'], context)
url = "/shop"
- product_count = product_obj.search_count(cr, uid, domain, context=context)
if search:
post["search"] = search
if category:
+ category = pool['product.public.category'].browse(cr, uid, int(category), context=context)
url = "/shop/category/%s" % slug(category)
- pager = request.website.pager(url=url, total=product_count, page=page, step=PPG, scope=7, url_args=post)
- product_ids = product_obj.search(cr, uid, domain, limit=PPG+10, offset=pager['offset'], order='website_published desc, website_sequence desc', context=context)
- products = product_obj.browse(cr, uid, product_ids, context=context)
style_obj = pool['product.style']
style_ids = style_obj.search(cr, uid, [], context=context)
categories = category_obj.browse(cr, uid, category_ids, context=context)
categs = filter(lambda x: not x.parent_id, categories)
+ domain += [('public_categ_ids', 'in', category_ids)]
+ product_obj = pool.get('product.template')
+
+ product_count = product_obj.search_count(cr, uid, domain, context=context)
+ pager = request.website.pager(url=url, total=product_count, page=page, step=PPG, scope=7, url_args=post)
+ product_ids = product_obj.search(cr, uid, domain, limit=PPG, offset=pager['offset'], order='website_published desc, website_sequence desc', context=context)
+ products = product_obj.browse(cr, uid, product_ids, context=context)
+
attributes_obj = request.registry['product.attribute']
- attributes_ids = attributes_obj.search(cr, uid, [], context=request.context)
- attributes = attributes_obj.browse(cr, uid, attributes_ids, context=request.context)
+ attributes_ids = attributes_obj.search(cr, uid, [], context=context)
+ attributes = attributes_obj.browse(cr, uid, attributes_ids, context=context)
+
+ from_currency = pool.get('product.price.type')._get_field_currency(cr, uid, 'list_price', context)
+ to_currency = pricelist.currency_id
+ compute_currency = lambda price: pool['res.currency']._compute(cr, uid, from_currency, to_currency, price, context=context)
values = {
'search': search,
'attrib_values': attrib_values,
'attrib_set': attrib_set,
'pager': pager,
- 'pricelist': self.get_pricelist(),
+ 'pricelist': pricelist,
'products': products,
'bins': table_compute().process(products),
'rows': PPR,
'styles': styles,
'categories': categs,
'attributes': attributes,
+ 'compute_currency': compute_currency,
'keep': keep,
'style_in_product': lambda style, product: style.id in [s.id for s in product.website_style_ids],
'attrib_encode': lambda attribs: werkzeug.url_encode([('attrib',i) for i in attribs]),
}
-
return request.website.render("website_sale.products", values)
@http.route(['/shop/product/<model("product.template"):product>'], type='http', auth="public", website=True)
def product(self, product, category='', search='', **kwargs):
cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
category_obj = pool['product.public.category']
+ template_obj = pool['product.template']
context.update(active_id=product.id)
if category:
- category = category_obj.browse(request.cr, request.uid, int(category), context=request.context)
+ category = category_obj.browse(cr, uid, int(category), context=context)
- attrib_values = [map(int,v.split(",")) for v in request.httprequest.args.getlist('attrib') if v]
+ attrib_list = request.httprequest.args.getlist('attrib')
+ attrib_values = [map(int,v.split("-")) for v in attrib_list if v]
attrib_set = set([v[1] for v in attrib_values])
- keep = QueryURL('/shop', category=category and category.id, search=search, attrib=attrib_set)
+ keep = QueryURL('/shop', category=category and category.id, search=search, attrib=attrib_list)
category_ids = category_obj.search(cr, uid, [], context=context)
category_list = category_obj.name_get(cr, uid, category_ids, context=context)
category_list = sorted(category_list, key=lambda category: category[1])
+ pricelist = self.get_pricelist()
+
+ from_currency = pool.get('product.price.type')._get_field_currency(cr, uid, 'list_price', context)
+ to_currency = pricelist.currency_id
+ compute_currency = lambda price: pool['res.currency']._compute(cr, uid, from_currency, to_currency, price, context=context)
+
if not context.get('pricelist'):
context['pricelist'] = int(self.get_pricelist())
- product = request.registry.get('product.template').browse(request.cr, request.uid, int(product), context=context)
-
- variants = [[p.id, map(int, p.attribute_value_ids), p.price] for p in product.product_variant_ids]
+ product = template_obj.browse(cr, uid, int(product), context=context)
values = {
'search': search,
'category': category,
- 'pricelist': self.get_pricelist(),
+ 'pricelist': pricelist,
'attrib_values': attrib_values,
+ 'compute_currency': compute_currency,
'attrib_set': attrib_set,
'keep': keep,
'category_list': category_list,
'main_object': product,
'product': product,
- 'variants': variants,
+ 'get_attribute_value_ids': self.get_attribute_value_ids
}
return request.website.render("website_sale.product", values)
@http.route(['/shop/cart'], type='http', auth="public", website=True)
def cart(self, **post):
+ cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
order = request.website.sale_get_order()
+ if order:
+ from_currency = pool.get('product.price.type')._get_field_currency(cr, uid, 'list_price', context)
+ to_currency = order.pricelist_id.currency_id
+ compute_currency = lambda price: pool['res.currency']._compute(cr, uid, from_currency, to_currency, price, context=context)
+ else:
+ compute_currency = lambda price: price
+
values = {
'order': order,
+ 'compute_currency': compute_currency,
'suggested_products': [],
}
if order:
- if not request.context.get('pricelist'):
- request.context['pricelist'] = order.pricelist_id.id
- values['suggested_products'] = order._cart_accessories(context=request.context)
+ _order = order
+ if not context.get('pricelist'):
+ _order = order.with_context(pricelist=order.pricelist_id.id)
+ values['suggested_products'] = _order._cart_accessories()
+
return request.website.render("website_sale.cart", values)
@http.route(['/shop/cart/update'], type='http', auth="public", methods=['POST'], website=True)
def cart_update(self, product_id, add_qty=1, set_qty=0, **kw):
cr, uid, context = request.cr, request.uid, request.context
- request.website.sale_get_order(force_create=1)._cart_update(product_id=int(product_id), add_qty=add_qty, set_qty=set_qty)
+ 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))
return request.redirect("/shop/cart")
@http.route(['/shop/cart/update_json'], type='json', auth="public", methods=['POST'], website=True)
- def cart_update_json(self, product_id, line_id, add_qty=None, set_qty=None):
+ def cart_update_json(self, product_id, line_id, add_qty=None, set_qty=None, display=True):
order = request.website.sale_get_order(force_create=1)
- quantity = order._cart_update(product_id=product_id, line_id=line_id, add_qty=add_qty, set_qty=set_qty)
- return {
- 'quantity': quantity,
- 'cart_quantity': order.cart_quantity,
- 'website_sale.total': request.website._render("website_sale.total", {
- 'website_sale_order': request.website.sale_get_order()
- })
- }
+ value = order._cart_update(product_id=product_id, line_id=line_id, add_qty=add_qty, set_qty=set_qty)
+ if not display:
+ return None
+ value['cart_quantity'] = order.cart_quantity
+ value['website_sale.total'] = request.website._render("website_sale.total", {
+ 'website_sale_order': request.website.sale_get_order()
+ })
+ return value
#------------------------------------------------------
# Checkout
else:
order = request.website.sale_get_order(force_create=1, context=context)
if order.partner_id:
- domain = [("active", "=", False), ("partner_id", "=", order.partner_id.id)]
- user_ids = request.registry['res.users'].search(cr, SUPERUSER_ID, domain, context=context)
+ domain = [("partner_id", "=", order.partner_id.id)]
+ user_ids = request.registry['res.users'].search(cr, SUPERUSER_ID, domain, context=dict(context or {}, active_test=False))
if not user_ids or request.website.user_id.id not in user_ids:
checkout.update( self.checkout_parse("billing", order.partner_id) )
else:
checkout['shipping_id'] = shipping_id
+ # Default search by user country
+ if not checkout.get('country_id'):
+ country_code = request.session['geoip'].get('country_code')
+ if country_code:
+ country_ids = request.registry.get('res.country').search(cr, uid, [('code', '=', country_code)], context=context)
+ if country_ids:
+ checkout['country_id'] = country_ids[0]
+
values = {
'countries': countries,
'states': states,
'shipping_id': partner.id != shipping_id and shipping_id or 0,
'shippings': shippings,
'error': {},
+ 'has_check_vat': hasattr(registry['res.partner'], 'check_vat')
}
return values
- mandatory_billing_fields = ["name", "phone", "email", "street", "city", "country_id", "zip"]
- optional_billing_fields = ["street2", "state_id", "vat"]
- mandatory_shipping_fields = ["name", "phone", "street", "city", "country_id", "zip"]
- optional_shipping_fields = ["state_id"]
+ mandatory_billing_fields = ["name", "phone", "email", "street2", "city", "country_id"]
+ optional_billing_fields = ["street", "state_id", "vat", "vat_subjected", "zip"]
+ mandatory_shipping_fields = ["name", "phone", "street", "city", "country_id"]
+ optional_shipping_fields = ["state_id", "zip"]
def checkout_parse(self, address_type, data, remove_prefix=False):
""" data is a dict OR a partner browse record
for field_name in all_fields if data.get(prefix + field_name))
else:
query = dict((prefix + field_name, getattr(data, field_name))
- for field_name in all_fields if field_name != "street2" and getattr(data, field_name))
- if data.parent_id:
- query[prefix + 'street2'] = data.parent_id.name
+ for field_name in all_fields if getattr(data, field_name))
+ if address_type == 'billing' and data.parent_id:
+ query[prefix + 'street'] = data.parent_id.name
if query.get(prefix + 'state_id'):
query[prefix + 'state_id'] = int(query[prefix + 'state_id'])
if query.get(prefix + 'country_id'):
query[prefix + 'country_id'] = int(query[prefix + 'country_id'])
+ if query.get(prefix + 'vat'):
+ query[prefix + 'vat_subjected'] = True
+
if not remove_prefix:
return query
if partner_id and request.website.partner_id.id != partner_id:
orm_partner.write(cr, SUPERUSER_ID, [partner_id], billing_info, context=context)
else:
+ # create partner
partner_id = orm_partner.create(cr, SUPERUSER_ID, billing_info, context=context)
# create a new shipping partner
order_info = {
'partner_id': partner_id,
- 'message_follower_ids': [(4, partner_id)],
+ 'message_follower_ids': [(4, partner_id), (3, request.website.partner_id.id)],
'partner_invoice_id': partner_id,
}
- order_info.update(registry.get('sale.order').onchange_partner_id(cr, SUPERUSER_ID, [], partner_id, context=context)['value'])
+ order_info.update(order_obj.onchange_partner_id(cr, SUPERUSER_ID, [], partner_id, context=context)['value'])
+ address_change = order_obj.onchange_delivery_id(cr, SUPERUSER_ID, [], order.company_id.id, partner_id,
+ checkout.get('shipping_id'), None, context=context)['value']
+ order_info.update(address_change)
+ if address_change.get('fiscal_position'):
+ fiscal_update = order_obj.onchange_fiscal_position(cr, SUPERUSER_ID, [], address_change['fiscal_position'],
+ [(4, l.id) for l in order.order_line], context=None)['value']
+ order_info.update(fiscal_update)
+
order_info.pop('user_id')
order_info.update(partner_shipping_id=checkout.get('shipping_id') or partner_id)
@http.route(['/shop/checkout'], type='http', auth="public", website=True)
def checkout(self, **post):
- cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
+ cr, uid, context = request.cr, request.uid, request.context
order = request.website.sale_get_order(force_create=1, context=context)
request.session['sale_last_order_id'] = order.id
+ request.website.sale_get_order(update_pricelist=True, context=context)
+
return request.redirect("/shop/payment")
#------------------------------------------------------
"""
cr, uid, context = request.cr, request.uid, request.context
payment_obj = request.registry.get('payment.acquirer')
+ sale_order_obj = request.registry.get('sale.order')
order = request.website.sale_get_order(context=context)
values = {
'order': request.registry['sale.order'].browse(cr, SUPERUSER_ID, order.id, context=context)
}
- values.update(request.registry.get('sale.order')._get_website_data(cr, uid, order, context))
+ values['errors'] = sale_order_obj._get_errors(cr, uid, order, context=context)
+ values.update(sale_order_obj._get_website_data(cr, uid, order, context))
# fetch all registered payment means
# if tx:
# acquirer_ids = [tx.acquirer_id.id]
# else:
- acquirer_ids = payment_obj.search(cr, SUPERUSER_ID, [('website_published', '=', True)], context=context)
- values['acquirers'] = payment_obj.browse(cr, uid, acquirer_ids, context=context)
- render_ctx = dict(context, submit_class='btn btn-primary', submit_txt='Pay Now')
- for acquirer in values['acquirers']:
- acquirer.button = payment_obj.render(
- cr, SUPERUSER_ID, acquirer.id,
- order.name,
- order.amount_total,
- order.pricelist_id.currency_id.id,
- partner_id=shipping_partner_id,
- tx_values={
- 'return_url': '/shop/payment/validate',
- },
- context=render_ctx)
+ if not values['errors']:
+ acquirer_ids = payment_obj.search(cr, SUPERUSER_ID, [('website_published', '=', True), ('company_id', '=', order.company_id.id)], context=context)
+ values['acquirers'] = list(payment_obj.browse(cr, uid, acquirer_ids, context=context))
+ render_ctx = dict(context, submit_class='btn btn-primary', submit_txt=_('Pay Now'))
+ for acquirer in values['acquirers']:
+ acquirer.button = payment_obj.render(
+ cr, SUPERUSER_ID, acquirer.id,
+ order.name,
+ order.amount_total,
+ order.pricelist_id.currency_id.id,
+ partner_id=shipping_partner_id,
+ tx_values={
+ 'return_url': '/shop/payment/validate',
+ },
+ context=render_ctx)
return request.website.render("website_sale.payment", values)
"""
cr, uid, context = request.cr, request.uid, request.context
transaction_obj = request.registry.get('payment.transaction')
- sale_order_obj = request.registry['sale.order']
order = request.website.sale_get_order(context=context)
if not order or not order.order_line or acquirer_id is None:
'sale_order_id': order.id,
}, context=context)
request.session['sale_transaction_id'] = tx_id
+ tx = transaction_obj.browse(cr, SUPERUSER_ID, tx_id, context=context)
# update quotation
- sale_order_obj.write(
+ request.registry['sale.order'].write(
cr, SUPERUSER_ID, [order.id], {
'payment_acquirer_id': acquirer_id,
'payment_tx_id': request.session['sale_transaction_id']
}, context=context)
+
# confirm the quotation
- sale_order_obj.action_button_confirm(cr, SUPERUSER_ID, [order.id], context=request.context)
+ if tx.acquirer_id.auto_confirm == 'at_pay_now':
+ request.registry['sale.order'].action_button_confirm(cr, SUPERUSER_ID, [order.id], context=request.context)
return tx_id
}
tx_ids = request.registry['payment.transaction'].search(
- cr, uid, [
+ cr, SUPERUSER_ID, [
'|', ('sale_order_id', '=', order.id), ('reference', '=', order.name)
], context=context)
}
else:
state = 'done'
- message = ""
+ message = '<h2>%s</h2>' % _('Your order has been confirmed, thank you for your loyalty.')
validation = None
else:
- tx = request.registry['payment.transaction'].browse(cr, uid, tx_ids[0], context=context)
+ tx = request.registry['payment.transaction'].browse(cr, SUPERUSER_ID, tx_ids[0], context=context)
state = tx.state
+ message = '<h2>%s</h2>' % _('Thank you for your order.')
if state == 'done':
- message = '<p>%s</p>' % _('Your payment has been received.')
+ message += '<p>%s</p>' % _('Your payment has been received.')
elif state == 'cancel':
- message = '<p>%s</p>' % _('The payment seems to have been canceled.')
+ message += '<p>%s</p>' % _('The payment seems to have been canceled.')
elif state == 'pending' and tx.acquirer_id.validation == 'manual':
- message = '<p>%s</p>' % _('Your transaction is waiting confirmation.')
+ message += '<p>%s</p>' % _('Your transaction is waiting confirmation.')
if tx.acquirer_id.post_msg:
message += tx.acquirer_id.post_msg
else:
- message = '<p>%s</p>' % _('Your transaction is waiting confirmation.')
+ message += '<p>%s</p>' % _('Your transaction is waiting confirmation.')
validation = tx.acquirer_id.validation
return {
order = request.registry['sale.order'].browse(cr, SUPERUSER_ID, sale_order_id, context=context)
assert order.id == request.session.get('sale_last_order_id')
- if not tx or not order:
+ if not order or (order.amount_total and not tx):
return request.redirect('/shop')
- if not order.amount_total or tx.state in ['pending', 'done']:
+ if (not order.amount_total and not tx) or tx.state in ['pending', 'done']:
+ if (not order.amount_total and not tx):
+ # Orders are confirmed by payment transactions, but there is none for free orders,
+ # (e.g. free events), so confirm immediately
+ order.action_button_confirm()
# send by email
email_act = sale_order_obj.action_quotation_send(cr, SUPERUSER_ID, [order.id], context=request.context)
- elif tx.state == 'cancel':
+ elif tx and tx.state == 'cancel':
# cancel the quotation
sale_order_obj.action_cancel(cr, SUPERUSER_ID, [order.id], context=request.context)
projects / odoo / odoo.git / blobdiff