def infrastructure_odoo(self, instance, key, **post):
(instance_name, instance_id) = unslug(instance)
odoo_instance = request.env['odoo.instance'].sudo().search(
[('id', '=', instance_id), ('key', '=', key)], limit=1)
if not odoo_instance:
return request.not_found('Instance data not found')
method = request.httprequest.method
if method == 'GET':
res = odoo_instance.get_instance_data()
elif method == 'POST':
# Get post vars
docker_image = post.get('docker_image', None)
docker_image_tag = post.get('docker_image_tag', None)
build_status = post.get('build_status', None)
if not all((docker_image, docker_image_tag, build_status)):
return request.not_found('Parameters missing')
docker_image_tag_obj = request.env['docker.image.tag'].sudo()
docker_image_tag_obj.set_docker_image_state(
docker_image, docker_image_tag, build_status)
res = {'result': 'OK'}
else:
return request.not_found('Method not found')
return request.make_response(
json.dumps(res, sort_keys=True, indent=4, separators=(', ', ': ')),
headers=[('Content-Type', 'application/json')],
)
def partners_detail(self, partner_id, partner_name="", **post):
_, partner_id = unslug(partner_id)
current_grade, current_country = None, None
grade_id = post.get("grade_id")
country_id = post.get("country_id")
if grade_id:
grade_ids = request.registry["res.partner.grade"].exists(
request.cr, request.uid, int(grade_id), context=request.context
)
if grade_ids:
current_grade = request.registry["res.partner.grade"].browse(
request.cr, request.uid, grade_ids[0], context=request.context
)
if country_id:
country_ids = request.registry["res.country"].exists(
request.cr, request.uid, int(country_id), context=request.context
)
if country_ids:
current_country = request.registry["res.country"].browse(
request.cr, request.uid, country_ids[0], context=request.context
)
if partner_id:
partner = request.registry["res.partner"].browse(
request.cr, SUPERUSER_ID, partner_id, context=request.context
)
if partner.exists() and partner.website_published:
values = {
"main_object": partner,
"partner": partner,
"current_grade": current_grade,
"current_country": current_country,
}
return request.website.render("website_crm_partner_assign.partner", values)
return self.partners(**post)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
current_grade, current_country = None, None
grade_id = post.get('grade_id')
country_id = post.get('country_id')
if grade_id:
grade_ids = request.registry['res.partner.grade'].exists(request.cr, request.uid, int(grade_id), context=request.context)
if grade_ids:
current_grade = request.registry['res.partner.grade'].browse(request.cr, request.uid, grade_ids[0], context=request.context)
if country_id:
country_ids = request.registry['res.country'].exists(request.cr, request.uid, int(country_id), context=request.context)
if country_ids:
current_country = request.registry['res.country'].browse(request.cr, request.uid, country_ids[0], context=request.context)
if partner_id:
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
is_website_publisher = request.registry['res.users'].has_group(request.cr, request.uid, 'base.group_website_publisher')
if partner.exists() and (partner.website_published or is_website_publisher):
values = {
'main_object': partner,
'partner': partner,
'current_grade': current_grade,
'current_country': current_country
}
return request.website.render("website_crm_partner_assign.partner", values)
return self.partners(**post)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
current_grade, current_country = None, None
grade_id = post.get('grade_id')
country_id = post.get('country_id')
if grade_id:
grade_ids = request.registry['res.partner.grade'].exists(request.cr, request.uid, int(grade_id), context=request.context)
if grade_ids:
current_grade = request.registry['res.partner.grade'].browse(request.cr, request.uid, grade_ids[0], context=request.context)
if country_id:
country_ids = request.registry['res.country'].exists(request.cr, request.uid, int(country_id), context=request.context)
if country_ids:
current_country = request.registry['res.country'].browse(request.cr, request.uid, country_ids[0], context=request.context)
if partner_id:
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
is_website_publisher = request.registry['res.users'].has_group(request.cr, request.uid, 'base.group_website_publisher')
if partner.exists() and (partner.website_published or is_website_publisher):
values = {
'main_object': partner,
'partner': partner,
'current_grade': current_grade,
'current_country': current_country
}
return request.website.render("website_crm_partner_assign.partner", values)
return self.partners(**post)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
if partner_id:
partner = request.env['res.partner'].sudo().browse(partner_id)
if partner.exists() and partner.website_published:
values = {}
values['main_object'] = values['partner'] = partner
return request.render("website_customer.details", values)
return self.customers(**post)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
if partner_id:
partner = request.env['res.partner'].sudo().browse(partner_id)
if partner.exists() and partner.website_published:
values = {}
values['main_object'] = values['partner'] = partner
return request.render("website_customer.details", values)
return self.customers(**post)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
if partner_id:
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
if partner.exists() and partner.website_published:
values = {}
values['main_object'] = values['partner'] = partner
return request.website.render("website_customer.details", values)
return self.customers(**post)
def program_details(self, program_id, redirect=None, **post):
_, program_id = unslug(program_id)
program = request.registry['school.program'].browse(
request.cr, request.uid, program_id, context=request.context)
values = {
'program': program,
'slug_id': program_id,
}
return request.render("website_school_management.program_details",
values)
def referer_to_page(self):
"""Translate HTTP REFERER to cms page if possible."""
ref = request.httprequest.referrer
if not ref:
return None
parsed = urlparse.urlparse(ref)
if '/cms/' in parsed.path:
last_bit = parsed.path.split('/')[-1]
page_id = unslug(last_bit)[-1]
return request.env['cms.page'].browse(page_id)
return None
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
if partner_id:
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
is_website_publisher = request.registry['res.users'].has_group(request.cr, request.uid, 'base.group_website_publisher')
if partner.exists() and (partner.website_published or is_website_publisher):
values = {
'main_object': partner,
'partner': partner,
'edit_page': False
}
return request.website.render("website_partner.partner_page", values)
return request.not_found()
def program_details(self, program_id, redirect=None, **post):
_, program_id = unslug(program_id)
program = request.env['school.program'].sudo().search([('id', '=',
program_id)])
if program:
values = {
'program': program,
'slug_id': program_id,
}
return request.render("website_school_management.program_details",
values)
else:
raise werkzeug.exceptions.HTTPException(
description='Unkown program.')
def course_group(self, course_group_id, redirect=None, **post):
_, course_group_id = unslug(course_group_id)
course_group_id = request.env['school.course_group'].sudo().browse(
[course_group_id])
if course_group_id:
values = {
'docs': course_group_id,
}
return request.render(
"school_course_description.report_course_group_documentation_content",
values)
else:
return request.render(
"school_course_description.report_course_group_documentation_no_content",
[])
def program_domain(self, domain_id, redirect=None, **post):
_, domain_id = unslug(domain_id)
programs = request.env['school.program'].sudo().search(
[('state', '=', 'published'), ('domain_id', '=', domain_id)],
order="domain_id, cycle_id, name ASC")
program_list = []
for program in programs:
program_list.append({
'program': program,
'slug_id': slug(program),
})
values = {
'program_list': program_list,
}
return request.render("website_school_management.program", values)
def course(self, course_id, redirect=None, **post):
_, course_id = unslug(course_id)
course_docs = request.env['school.course_documentation'].sudo().search(
[('state', '=', 'published'), ('course_ids', '=', course_id)],
order="author_id")
if course_docs:
values = {
'docs': course_docs[0],
}
return request.render(
"school_course_description.report_course_documentation_content",
values)
else:
return request.render(
"school_course_description.report_course_documentation_no_content",
[])
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
if partner_id:
partner = request.registry['res.partner'].browse(
request.cr, SUPERUSER_ID, partner_id, context=request.context)
is_website_publisher = request.registry['res.users'].has_group(
request.cr, request.uid, 'base.group_website_publisher')
if partner.exists() and (partner.website_published
or is_website_publisher):
values = {
'main_object': partner,
'partner': partner,
'edit_page': False
}
return request.website.render("website_partner.partner_page",
values)
return request.not_found()
def test_unslug(self):
tests = {
"": (None, None),
"foo": (None, None),
"foo-": (None, None),
"-": (None, None),
"foo-1": ("foo", 1),
"foo-bar-1": ("foo-bar", 1),
"foo--1": ("foo", -1),
"1": (None, 1),
"1-1": ("1", 1),
"--1": (None, None),
"foo---1": (None, None),
"foo1": (None, None),
}
for slug, expected in tests.iteritems():
self.assertEqual(unslug(slug), expected)
def test_unslug(self):
tests = {
'': (None, None),
'foo': (None, None),
'foo-': (None, None),
'-': (None, None),
'foo-1': ('foo', 1),
'foo-bar-1': ('foo-bar', 1),
'foo--1': ('foo', -1),
'1': (None, 1),
'1-1': ('1', 1),
'--1': (None, None),
'foo---1': (None, None),
'foo1': (None, None),
}
for slug, expected in tests.iteritems():
self.assertEqual(unslug(slug), expected)
def test_unslug(self):
tests = {
'': (None, None),
'foo': (None, None),
'foo-': (None, None),
'-': (None, None),
'foo-1': ('foo', 1),
'foo-bar-1': ('foo-bar', 1),
'foo--1': ('foo', -1),
'1': (None, 1),
'1-1': ('1', 1),
'--1': (None, None),
'foo---1': (None, None),
'foo1': (None, None),
}
for slug, expected in tests.iteritems():
self.assertEqual(unslug(slug), expected)
def get_root(self, item=None, upper_level=0):
"""Walk trough page path to find root ancestor.
URL is made of items' slug so we can jump
at any level by looking at path parts.
Use `upper_level` to stop walking at a precise
hierarchy level.
"""
item = item or self
# 1st bit is `/cms`
bits = item.website_url.split('/')[2:]
try:
_slug = bits[upper_level]
except IndexError:
# safely default to real root
_slug = bits[0]
_, page_id = unslug(_slug)
return self.browse(page_id)
def customers(self, country_id=0, page=0, country_name='', tag_id=0, **post):
cr, uid, context = request.cr, request.uid, request.context
country_obj = request.registry['res.country']
tag_obj = request.registry['res.partner.tag']
partner_obj = request.registry['res.partner']
partner_name = post.get('search', '')
domain = [('website_published', '=', True), ('assigned_partner_id', '!=', False)]
if partner_name:
domain += [
'|',
('name', 'ilike', post.get("search")),
('website_description', 'ilike', post.get("search"))
]
if tag_id:
tag_id = unslug(tag_id)[1] or 0
domain += [('tag_ids', 'in', tag_id)]
# group by country, based on customers found with the search(domain)
countries = partner_obj.read_group(
cr, openerp.SUPERUSER_ID, domain, ["id", "country_id"],
groupby="country_id", orderby="country_id", context=request.context)
country_count = partner_obj.search(
cr, openerp.SUPERUSER_ID, domain, count=True, context=request.context)
if country_id:
domain += [('country_id', '=', country_id)]
if not any(x['country_id'][0] == country_id for x in countries):
country = country_obj.read(cr, uid, country_id, ['name'], context)
if country:
countries.append({
'country_id_count': 0,
'country_id': (country_id, country['name'])
})
countries.sort(key=lambda d: d['country_id'][1])
curr_country = country_obj.browse(cr, uid, country_id, context)
countries.insert(0, {
'country_id_count': country_count,
'country_id': (0, _("All Countries"))
})
# search customers to display
partner_count = partner_obj.search_count(cr, openerp.SUPERUSER_ID, domain, context=request.context)
# pager
url = '/customers'
if country_id:
url += '/country/%s' % country_id
pager = request.website.pager(
url=url, total=partner_count, page=page, step=self._references_per_page,
scope=7, url_args=post
)
partner_ids = partner_obj.search(request.cr, openerp.SUPERUSER_ID, domain,
offset=pager['offset'], limit=self._references_per_page,
context=request.context)
google_map_partner_ids = ','.join(map(str, partner_ids))
partners = partner_obj.browse(request.cr, openerp.SUPERUSER_ID, partner_ids, request.context)
tag_obj = request.registry['res.partner.tag']
tag_ids = tag_obj.search(cr, uid, [('website_published', '=', True), ('partner_ids', 'in', partner_ids)],
order='name ASC', context=context)
tags = tag_obj.browse(cr, uid, tag_ids, context=context)
tag = tag_id and tag_obj.browse(cr, uid, tag_id, context=context) or False
values = {
'countries': countries,
'current_country_id': country_id or 0,
'current_country': country_id and curr_country or False,
'partners': partners,
'google_map_partner_ids': google_map_partner_ids,
'pager': pager,
'post': post,
'search_path': "?%s" % werkzeug.url_encode(post),
'tag': tag,
'tags': tags,
}
return request.website.render("website_customer.index", values)
def blog(self, blog=None, tag=None, page=1, **opt):
""" Prepare all values to display the blog.
:return dict values: values for the templates, containing
- 'blog': current blog
- 'blogs': all blogs for navigation
- 'pager': pager of posts
- 'active_tag_ids' : list of active tag ids,
- 'tags_list' : function to built the comma-separated tag list ids (for the url),
- 'tags': all tags, for navigation
- 'nav_list': a dict [year][month] for archives navigation
- 'date': date_begin optional parameter, used in archives navigation
- 'blog_url': help object to create URLs
"""
date_begin, date_end = opt.get('date_begin'), opt.get('date_end')
cr, uid, context = request.cr, request.uid, request.context
blog_post_obj = request.registry['blog.post']
blog_obj = request.registry['blog.blog']
blog_ids = blog_obj.search(cr, uid, [], order="create_date asc", context=context)
blogs = blog_obj.browse(cr, uid, blog_ids, context=context)
# build the domain for blog post to display
domain = []
# retrocompatibility to accept tag as slug
active_tag_ids = tag and map(int, [unslug(t)[1] for t in tag.split(',')]) or []
if active_tag_ids:
domain += [('tag_ids', 'in', active_tag_ids)]
if blog:
domain += [('blog_id', '=', blog.id)]
if date_begin and date_end:
domain += [("create_date", ">=", date_begin), ("create_date", "<=", date_end)]
blog_url = QueryURL('', ['blog', 'tag'], blog=blog, tag=tag, date_begin=date_begin, date_end=date_end)
blog_post_ids = blog_post_obj.search(cr, uid, domain, order="create_date desc", context=context)
blog_posts = blog_post_obj.browse(cr, uid, blog_post_ids, context=context)
pager = request.website.pager(
url=blog_url(),
total=len(blog_posts),
page=page,
step=self._blog_post_per_page,
)
pager_begin = (page - 1) * self._blog_post_per_page
pager_end = page * self._blog_post_per_page
blog_posts = blog_posts[pager_begin:pager_end]
all_tags = blog.all_tags()[blog.id]
# function to create the string list of tag ids, and toggle a given one.
# used in the 'Tags Cloud' template.
def tags_list(tag_ids, current_tag):
tag_ids = list(tag_ids) # required to avoid using the same list
if current_tag in tag_ids:
tag_ids.remove(current_tag)
else:
tag_ids.append(current_tag)
tag_ids = request.registry['blog.tag'].browse(cr, uid, tag_ids, context=context).exists()
return ','.join(map(slug, tag_ids))
values = {
'blog': blog,
'blogs': blogs,
'main_object': blog,
'tags': all_tags,
'active_tag_ids': active_tag_ids,
'tags_list' : tags_list,
'blog_posts': blog_posts,
'pager': pager,
'nav_list': self.nav_list(blog),
'blog_url': blog_url,
'date': date_begin,
}
response = request.website.render("website_blog.blog_post_short", values)
return response
def blog(self, blog=None, tag=None, page=1, **opt):
""" Prepare all values to display the blog.
:return dict values: values for the templates, containing
- 'blog': current blog
- 'blogs': all blogs for navigation
- 'pager': pager of posts
- 'active_tag_ids' : list of active tag ids,
- 'tags_list' : function to built the comma-separated tag list ids
(for the url),
- 'tags': all tags, for navigation
- 'nav_list': a dict [year][month] for archives navigation
- 'date': date_begin optional parameter, used in archives navigation
- 'blog_url': help object to create URLs
"""
date_begin, date_end = opt.get('date_begin'), opt.get('date_end')
blogs = request.env['blog.blog'].search([], order="create_date asc")
# build the domain for blog post to display
domain = []
# retrocompatibility to accept tag as slug
active_tag_ids = tag and map(
int, [unslug(t)[1] for t in tag.split(',')]) or []
if active_tag_ids:
domain += [('tag_ids', 'in', active_tag_ids)]
if blog:
domain += [('blog_id', '=', blog.id)]
if date_begin and date_end:
domain += [
("website_publication_date", ">=", date_begin),
("website_publication_date", "<=", date_end),
]
blog_url = QueryURL('', ['blog', 'tag'],
blog=blog,
tag=tag,
date_begin=date_begin,
date_end=date_end)
blog_posts = request.env['blog.post'].search(domain)
pager = request.website.pager(
url=blog_url(),
total=len(blog_posts),
page=page,
step=self._blog_post_per_page,
)
pager_begin = (page - 1) * self._blog_post_per_page
pager_end = page * self._blog_post_per_page
blog_posts = blog_posts[pager_begin:pager_end]
all_tags = blog.all_tags()[blog.id]
# Function to create the string list of tag ids, and toggle a
# given one. Used in the 'Tags Cloud' template.
def tags_list(tag_ids, current_tag):
tag_ids = list(tag_ids) # required to avoid using the same list
if current_tag in tag_ids:
tag_ids.remove(current_tag)
else:
tag_ids.append(current_tag)
tag_ids = request.env['blog.tag'].browse(tag_ids).exists()
return ','.join(map(slug, tag_ids))
values = {
'blog': blog,
'blogs': blogs,
'main_object': blog,
'tags': all_tags,
'active_tag_ids': active_tag_ids,
'tags_list': tags_list,
'blog_posts': blog_posts,
'pager': pager,
'nav_list': self.nav_list(blog),
'blog_url': blog_url,
'date': date_begin,
}
response = request.website.render("website_blog.blog_post_short",
values)
return response
def blog(self, blog=None, tag=None, page=1, **opt):
""" Prepare all values to display the blog.
:return dict values: values for the templates, containing
- 'blog': current blog
- 'blogs': all blogs for navigation
- 'pager': pager of posts
- 'active_tag_ids' : list of active tag ids,
- 'tags_list' : function to built the comma-separated tag list ids (for the url),
- 'tags': all tags, for navigation
- 'state_info': state of published/unpublished filter
- 'nav_list': a dict [year][month] for archives navigation
- 'date': date_begin optional parameter, used in archives navigation
- 'blog_url': help object to create URLs
"""
date_begin, date_end, state = opt.get('date_begin'), opt.get(
'date_end'), opt.get('state')
published_count, unpublished_count = 0, 0
cr, uid, context = request.cr, request.uid, request.context
blog_post_obj = request.registry['blog.post']
blog_obj = request.registry['blog.blog']
blog_ids = blog_obj.search(cr,
uid, [],
order="create_date asc",
context=context)
blogs = blog_obj.browse(cr, uid, blog_ids, context=context)
# build the domain for blog post to display
domain = []
# retrocompatibility to accept tag as slug
active_tag_ids = tag and map(
int, [unslug(t)[1] for t in tag.split(',')]) or []
if active_tag_ids:
domain += [('tag_ids', 'in', active_tag_ids)]
if blog:
domain += [('blog_id', '=', blog.id)]
if date_begin and date_end:
domain += [("create_date", ">=", date_begin),
("create_date", "<=", date_end)]
if request.env.user.has_group('base.group_website_designer'):
for group in request.env['blog.post'].read_group(
domain, ['website_published'],
groupby=["website_published"]):
if group['website_published']:
published_count = group['website_published_count']
else:
unpublished_count = group['website_published_count']
if state == "published":
domain += [("website_published", "=", True)]
elif state == "unpublished":
domain += [("website_published", "=", False)]
blog_url = QueryURL('', ['blog', 'tag'],
blog=blog,
tag=tag,
date_begin=date_begin,
date_end=date_end)
blog_post_ids = blog_post_obj.search(
cr,
uid,
domain,
order="published_date desc, create_date desc",
context=context)
blog_posts = blog_post_obj.browse(cr,
uid,
blog_post_ids,
context=context)
pager = request.website.pager(
url=blog_url(),
total=len(blog_posts),
page=page,
step=self._blog_post_per_page,
)
pager_begin = (page - 1) * self._blog_post_per_page
pager_end = page * self._blog_post_per_page
blog_posts = blog_posts[pager_begin:pager_end]
all_tags = blog.all_tags()[blog.id]
# function to create the string list of tag ids, and toggle a given one.
# used in the 'Tags Cloud' template.
def tags_list(tag_ids, current_tag):
tag_ids = list(tag_ids) # required to avoid using the same list
if current_tag in tag_ids:
tag_ids.remove(current_tag)
else:
tag_ids.append(current_tag)
tag_ids = request.registry['blog.tag'].browse(
cr, uid, tag_ids, context=context).exists()
return ','.join(map(slug, tag_ids))
values = {
'blog': blog,
'blogs': blogs,
'main_object': blog,
'tags': all_tags,
'state_info': {
"state": state,
"published": published_count,
"unpublished": unpublished_count
},
'active_tag_ids': active_tag_ids,
'tags_list': tags_list,
'blog_posts': blog_posts,
'pager': pager,
'nav_list': self.nav_list(blog),
'blog_url': blog_url,
'date': date_begin,
}
response = request.website.render("website_blog.blog_post_short",
values)
return response
def customers(self,
country_id=0,
page=0,
country_name='',
tag_id=0,
**post):
Country = request.env['res.country']
Tag = request.env['res.partner.tag']
Partner = request.env['res.partner']
partner_name = post.get('search', '')
domain = [('website_published', '=', True),
('assigned_partner_id', '!=', False)]
if partner_name:
domain += [
'|', ('name', 'ilike', post.get("search")),
('website_description', 'ilike', post.get("search"))
]
if tag_id:
tag_id = unslug(tag_id)[1] or 0
domain += [('tag_ids', 'in', tag_id)]
# group by country, based on customers found with the search(domain)
countries = Partner.sudo().read_group(domain, ["id", "country_id"],
groupby="country_id",
orderby="country_id")
country_count = Partner.sudo().search_count(domain)
if country_id:
domain += [('country_id', '=', country_id)]
if not any(x['country_id'][0] == country_id
for x in countries if x['country_id']):
country = Country.browse(country_id).read(['name'])
if country:
countries.append({
'country_id_count':
0,
'country_id': (country_id, country['name'])
})
countries.sort(
key=lambda d: d['country_id'] and d['country_id'][1])
curr_country = Country.browse(country_id)
countries.insert(
0, {
'country_id_count': country_count,
'country_id': (0, _("All Countries"))
})
# search customers to display
partner_count = Partner.sudo().search_count(domain)
# pager
url = '/customers'
if country_id:
url += '/country/%s' % country_id
pager = request.website.pager(url=url,
total=partner_count,
page=page,
step=self._references_per_page,
scope=7,
url_args=post)
partners = Partner.sudo().search(domain,
offset=pager['offset'],
limit=self._references_per_page)
google_map_partner_ids = ','.join(map(str, partners.ids))
tags = Tag.search([('website_published', '=', True),
('partner_ids', 'in', partners.ids)],
order='classname, name ASC')
tag = tag_id and Tag.browse(tag_id) or False
values = {
'countries': countries,
'current_country_id': country_id or 0,
'current_country': curr_country if country_id else False,
'partners': partners,
'google_map_partner_ids': google_map_partner_ids,
'pager': pager,
'post': post,
'search_path': "?%s" % werkzeug.url_encode(post),
'tag': tag,
'tags': tags,
}
return request.website.render("website_customer.index", values)
def customers(self, country_id=0, page=0, country_name='', tag_id=0, **post):
Country = request.env['res.country']
Tag = request.env['res.partner.tag']
Partner = request.env['res.partner']
partner_name = post.get('search', '')
domain = [('website_published', '=', True), ('assigned_partner_id', '!=', False)]
if partner_name:
domain += [
'|',
('name', 'ilike', post.get("search")),
('website_description', 'ilike', post.get("search"))
]
if tag_id:
tag_id = unslug(tag_id)[1] or 0
domain += [('tag_ids', 'in', tag_id)]
# group by country, based on customers found with the search(domain)
countries = Partner.sudo().read_group(domain, ["id", "country_id"], groupby="country_id", orderby="country_id")
country_count = Partner.sudo().search_count(domain)
if country_id:
domain += [('country_id', '=', country_id)]
if not any(x['country_id'][0] == country_id for x in countries if x['country_id']):
country = Country.browse(country_id).read(['name'])
if country:
countries.append({
'country_id_count': 0,
'country_id': (country_id, country['name'])
})
countries.sort(key=lambda d: d['country_id'] and d['country_id'][1])
curr_country = Country.browse(country_id)
countries.insert(0, {
'country_id_count': country_count,
'country_id': (0, _("All Countries"))
})
# search customers to display
partner_count = Partner.sudo().search_count(domain)
# pager
url = '/customers'
if country_id:
url += '/country/%s' % country_id
pager = request.website.pager(
url=url, total=partner_count, page=page, step=self._references_per_page,
scope=7, url_args=post
)
partners = Partner.sudo().search(domain, offset=pager['offset'], limit=self._references_per_page)
google_map_partner_ids = ','.join(map(str, partners.ids))
tags = Tag.search([('website_published', '=', True), ('partner_ids', 'in', partners.ids)], order='classname, name ASC')
tag = tag_id and Tag.browse(tag_id) or False
values = {
'countries': countries,
'current_country_id': country_id or 0,
'current_country': curr_country if country_id else False,
'partners': partners,
'google_map_partner_ids': google_map_partner_ids,
'pager': pager,
'post': post,
'search_path': "?%s" % werkzeug.url_encode(post),
'tag': tag,
'tags': tags,
}
return request.render("website_customer.index", values)
def customers(self, country_id=0, page=0, country_name="", tag_id=0, **post):
cr, uid, context = request.cr, request.uid, request.context
country_obj = request.registry["res.country"]
tag_obj = request.registry["res.partner.tag"]
partner_obj = request.registry["res.partner"]
partner_name = post.get("search", "")
domain = [("website_published", "=", True), ("assigned_partner_id", "!=", False)]
if partner_name:
domain += ["|", ("name", "ilike", post.get("search")), ("website_description", "ilike", post.get("search"))]
if tag_id:
tag_id = unslug(tag_id)[1] or 0
domain += [("tag_ids", "in", tag_id)]
# group by country, based on customers found with the search(domain)
countries = partner_obj.read_group(
cr,
openerp.SUPERUSER_ID,
domain,
["id", "country_id"],
groupby="country_id",
orderby="country_id",
context=request.context,
)
country_count = partner_obj.search(cr, openerp.SUPERUSER_ID, domain, count=True, context=request.context)
if country_id:
domain += [("country_id", "=", country_id)]
if not any(x["country_id"][0] == country_id for x in countries):
country = country_obj.read(cr, uid, country_id, ["name"], context)
if country:
countries.append({"country_id_count": 0, "country_id": (country_id, country["name"])})
countries.sort(key=lambda d: d["country_id"][1])
curr_country = country_obj.browse(cr, uid, country_id, context)
countries.insert(0, {"country_id_count": country_count, "country_id": (0, _("All Countries"))})
# search customers to display
partner_count = partner_obj.search_count(cr, openerp.SUPERUSER_ID, domain, context=request.context)
# pager
url = "/customers"
if country_id:
url += "/country/%s" % country_id
pager = request.website.pager(
url=url, total=partner_count, page=page, step=self._references_per_page, scope=7, url_args=post
)
partner_ids = partner_obj.search(
request.cr,
openerp.SUPERUSER_ID,
domain,
offset=pager["offset"],
limit=self._references_per_page,
context=request.context,
)
google_map_partner_ids = ",".join(map(str, partner_ids))
partners = partner_obj.browse(request.cr, openerp.SUPERUSER_ID, partner_ids, request.context)
tag_obj = request.registry["res.partner.tag"]
tag_ids = tag_obj.search(
cr,
uid,
[("website_published", "=", True), ("partner_ids", "in", partner_ids)],
order="classname, name ASC",
context=context,
)
tags = tag_obj.browse(cr, uid, tag_ids, context=context)
tag = tag_id and tag_obj.browse(cr, uid, tag_id, context=context) or False
values = {
"countries": countries,
"current_country_id": country_id or 0,
"current_country": country_id and curr_country or False,
"partners": partners,
"google_map_partner_ids": google_map_partner_ids,
"pager": pager,
"post": post,
"search_path": "?%s" % werkzeug.url_encode(post),
"tag": tag,
"tags": tags,
}
return request.website.render("website_customer.index", values)
