381 lines
16 KiB
Python
381 lines
16 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import werkzeug.urls
|
|
|
|
from werkzeug.exceptions import NotFound
|
|
|
|
from odoo import fields
|
|
from odoo import http
|
|
from odoo.http import request
|
|
from odoo.addons.portal.controllers.portal import CustomerPortal
|
|
from odoo.addons.website_google_map.controllers.main import GoogleMap
|
|
from odoo.addons.website_partner.controllers.main import WebsitePartnerPage
|
|
|
|
from odoo.tools.translate import _
|
|
|
|
|
|
class WebsiteAccount(CustomerPortal):
|
|
|
|
def get_domain_my_lead(self, user):
|
|
return [
|
|
('partner_assigned_id', 'child_of', user.commercial_partner_id.id),
|
|
('type', '=', 'lead')
|
|
]
|
|
|
|
def get_domain_my_opp(self, user):
|
|
return [
|
|
('partner_assigned_id', 'child_of', user.commercial_partner_id.id),
|
|
('type', '=', 'opportunity')
|
|
]
|
|
|
|
def _prepare_home_portal_values(self, counters):
|
|
values = super()._prepare_home_portal_values(counters)
|
|
CrmLead = request.env['crm.lead']
|
|
if 'lead_count' in counters:
|
|
values['lead_count'] = (
|
|
CrmLead.search_count(self.get_domain_my_lead(request.env.user))
|
|
if CrmLead.has_access('read')
|
|
else 0
|
|
)
|
|
if 'opp_count' in counters:
|
|
values['opp_count'] = (
|
|
CrmLead.search_count(self.get_domain_my_opp(request.env.user))
|
|
if CrmLead.has_access('read')
|
|
else 0
|
|
)
|
|
return values
|
|
|
|
@http.route(['/my/leads', '/my/leads/page/<int:page>'], type='http', auth="user", website=True)
|
|
def portal_my_leads(self, page=1, date_begin=None, date_end=None, sortby=None, **kw):
|
|
values = self._prepare_portal_layout_values()
|
|
CrmLead = request.env['crm.lead']
|
|
domain = self.get_domain_my_lead(request.env.user)
|
|
|
|
searchbar_sortings = {
|
|
'date': {'label': _('Newest'), 'order': 'create_date desc'},
|
|
'name': {'label': _('Name'), 'order': 'name'},
|
|
'contact_name': {'label': _('Contact Name'), 'order': 'contact_name'},
|
|
}
|
|
|
|
# default sort by value
|
|
if not sortby:
|
|
sortby = 'date'
|
|
order = searchbar_sortings[sortby]['order']
|
|
|
|
if date_begin and date_end:
|
|
domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)]
|
|
|
|
# pager
|
|
lead_count = CrmLead.search_count(domain)
|
|
pager = request.website.pager(
|
|
url="/my/leads",
|
|
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby},
|
|
total=lead_count,
|
|
page=page,
|
|
step=self._items_per_page
|
|
)
|
|
# content according to pager and archive selected
|
|
leads = CrmLead.search(domain, order=order, limit=self._items_per_page, offset=pager['offset'])
|
|
|
|
values.update({
|
|
'date': date_begin,
|
|
'leads': leads,
|
|
'page_name': 'lead',
|
|
'default_url': '/my/leads',
|
|
'pager': pager,
|
|
'searchbar_sortings': searchbar_sortings,
|
|
'sortby': sortby,
|
|
})
|
|
return request.render("website_crm_partner_assign.portal_my_leads", values)
|
|
|
|
@http.route(['/my/opportunities', '/my/opportunities/page/<int:page>'], type='http', auth="user", website=True)
|
|
def portal_my_opportunities(self, page=1, date_begin=None, date_end=None, sortby=None, filterby=None, **kw):
|
|
values = self._prepare_portal_layout_values()
|
|
CrmLead = request.env['crm.lead']
|
|
domain = self.get_domain_my_opp(request.env.user)
|
|
|
|
today = fields.Date.today()
|
|
|
|
searchbar_filters = {
|
|
'all': {'label': _('Active'), 'domain': []},
|
|
'no_activities': {
|
|
'label': _('No Activities'),
|
|
'domain': [('activity_ids', 'not any', [('user_id', '=', request.env.user.id)]), ('stage_id.is_won', '=', False)]
|
|
},
|
|
'overdue': {'label': _('Late Activities'), 'domain': [('activity_date_deadline', '<', today)]},
|
|
'today': {'label': _('Today Activities'), 'domain': [('activity_date_deadline', '=', today)]},
|
|
'future': {'label': _('Future Activities'), 'domain': [('activity_date_deadline', '>', today)]},
|
|
'won': {'label': _('Won'), 'domain': [('stage_id.is_won', '=', True)]},
|
|
'lost': {'label': _('Lost'), 'domain': [('active', '=', False), ('probability', '=', 0)]},
|
|
}
|
|
searchbar_sortings = {
|
|
'date': {'label': _('Newest'), 'order': 'create_date desc'},
|
|
'name': {'label': _('Name'), 'order': 'name'},
|
|
'contact_name': {'label': _('Contact Name'), 'order': 'contact_name'},
|
|
'revenue': {'label': _('Expected Revenue'), 'order': 'expected_revenue desc'},
|
|
'probability': {'label': _('Probability'), 'order': 'probability desc'},
|
|
'stage': {'label': _('Stage'), 'order': 'stage_id'},
|
|
}
|
|
|
|
# default sort by value
|
|
if not sortby:
|
|
sortby = 'date'
|
|
order = searchbar_sortings[sortby]['order']
|
|
# default filter by value
|
|
if not filterby:
|
|
filterby = 'all'
|
|
domain += searchbar_filters[filterby]['domain']
|
|
if filterby == 'lost':
|
|
CrmLead = CrmLead.with_context(active_test=False)
|
|
|
|
if date_begin and date_end:
|
|
domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)]
|
|
# pager: bypass activities access rights for search but still apply access rules
|
|
leads_sudo = CrmLead.sudo()._search(domain)
|
|
domain = [('id', 'in', leads_sudo)]
|
|
opp_count = CrmLead.search_count(domain)
|
|
pager = request.website.pager(
|
|
url="/my/opportunities",
|
|
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby, 'filterby': filterby},
|
|
total=opp_count,
|
|
page=page,
|
|
step=self._items_per_page
|
|
)
|
|
# content according to pager
|
|
opportunities = CrmLead.search(domain, order=order, limit=self._items_per_page, offset=pager['offset'])
|
|
|
|
values.update({
|
|
'date': date_begin,
|
|
'opportunities': opportunities,
|
|
'page_name': 'opportunity',
|
|
'default_url': '/my/opportunities',
|
|
'pager': pager,
|
|
'searchbar_sortings': searchbar_sortings,
|
|
'sortby': sortby,
|
|
'searchbar_filters': searchbar_filters,
|
|
'filterby': filterby,
|
|
})
|
|
return request.render("website_crm_partner_assign.portal_my_opportunities", values)
|
|
|
|
@http.route(['''/my/lead/<model('crm.lead', "[('type','=', 'lead')]"):lead>'''], type='http', auth="user", website=True)
|
|
def portal_my_lead(self, lead, **kw):
|
|
if lead.type != 'lead':
|
|
raise NotFound()
|
|
return request.render("website_crm_partner_assign.portal_my_lead", {'lead': lead})
|
|
|
|
@http.route(['''/my/opportunity/<model('crm.lead', "[('type','=', 'opportunity')]"):opp>'''], type='http', auth="user", website=True)
|
|
def portal_my_opportunity(self, opp, **kw):
|
|
if opp.type != 'opportunity':
|
|
raise NotFound()
|
|
|
|
return request.render(
|
|
"website_crm_partner_assign.portal_my_opportunity", {
|
|
'opportunity': opp,
|
|
'user_activity': opp.sudo().activity_ids.filtered(lambda activity: activity.user_id == request.env.user)[:1],
|
|
'stages': request.env['crm.stage'].search([
|
|
('is_won', '!=', True), '|', ('team_id', '=', False), ('team_id', '=', opp.team_id.id)
|
|
], order='sequence desc, name desc, id desc'),
|
|
'activity_types': request.env['mail.activity.type'].sudo().search(['|', ('res_model', '=', opp._name), ('res_model', '=', False)]),
|
|
'states': request.env['res.country.state'].sudo().search([]),
|
|
'countries': request.env['res.country'].sudo().search([]),
|
|
})
|
|
|
|
|
|
class WebsiteCrmPartnerAssign(WebsitePartnerPage, GoogleMap):
|
|
_references_per_page = 40
|
|
|
|
def _get_gmap_domains(self, **kw):
|
|
if kw.get('dom', '') != "website_crm_partner_assign.partners":
|
|
return super()._get_gmap_domains(**kw)
|
|
current_grade = kw.get('current_grade')
|
|
current_country = kw.get('current_country')
|
|
|
|
domain = [('grade_id', '!=', False), ('is_company', '=', True)]
|
|
if not request.env.user.has_group('website.group_website_restricted_editor'):
|
|
domain += [('grade_id.website_published', '=', True)]
|
|
|
|
if current_country:
|
|
domain += [('country_id', '=', int(current_country))]
|
|
|
|
if current_grade:
|
|
domain += [('grade_id', '=', int(current_grade))]
|
|
|
|
return domain
|
|
|
|
def sitemap_partners(env, rule, qs):
|
|
if not qs or qs.lower() in '/partners':
|
|
yield {'loc': '/partners'}
|
|
|
|
slug = env['ir.http']._slug
|
|
base_partner_domain = [
|
|
('is_company', '=', True),
|
|
('grade_id', '!=', False),
|
|
('website_published', '=', True),
|
|
('grade_id.website_published', '=', True),
|
|
('grade_id.active', '=', True),
|
|
]
|
|
grades = env['res.partner'].sudo()._read_group(base_partner_domain, groupby=['grade_id'])
|
|
for [grade] in grades:
|
|
loc = '/partners/grade/%s' % slug(grade)
|
|
if not qs or qs.lower() in loc:
|
|
yield {'loc': loc}
|
|
country_partner_domain = base_partner_domain + [('country_id', '!=', False)]
|
|
countries = env['res.partner'].sudo()._read_group(country_partner_domain, groupby=['country_id'])
|
|
for [country] in countries:
|
|
loc = '/partners/country/%s' % slug(country)
|
|
if not qs or qs.lower() in loc:
|
|
yield {'loc': loc}
|
|
|
|
@http.route([
|
|
'/partners',
|
|
'/partners/page/<int:page>',
|
|
|
|
'/partners/grade/<model("res.partner.grade"):grade>',
|
|
'/partners/grade/<model("res.partner.grade"):grade>/page/<int:page>',
|
|
|
|
'/partners/country/<model("res.country"):country>',
|
|
'/partners/country/<model("res.country"):country>/page/<int:page>',
|
|
|
|
'/partners/grade/<model("res.partner.grade"):grade>/country/<model("res.country"):country>',
|
|
'/partners/grade/<model("res.partner.grade"):grade>/country/<model("res.country"):country>/page/<int:page>',
|
|
], type='http', auth="public", website=True, sitemap=sitemap_partners, readonly=True)
|
|
def partners(self, country=None, grade=None, page=0, **post):
|
|
country_all = post.pop('country_all', False)
|
|
partner_obj = request.env['res.partner']
|
|
country_obj = request.env['res.country']
|
|
search = post.get('search', '')
|
|
|
|
base_partner_domain = [('is_company', '=', True), ('grade_id', '!=', False), ('website_published', '=', True), ('grade_id.active', '=', True)]
|
|
if not request.env.user.has_group('website.group_website_restricted_editor'):
|
|
base_partner_domain += [('grade_id.website_published', '=', True)]
|
|
if search:
|
|
base_partner_domain += ['|', ('name', 'ilike', search), ('website_description', 'ilike', search)]
|
|
|
|
# Infer Country
|
|
if not country and not country_all:
|
|
if request.geoip.country_code:
|
|
country = country_obj.search([('code', '=', request.geoip.country_code)], limit=1)
|
|
|
|
# Group by country
|
|
country_domain = list(base_partner_domain)
|
|
if grade:
|
|
country_domain += [('grade_id', '=', grade.id)]
|
|
countries = partner_obj.sudo().read_group(
|
|
country_domain + [('country_id', '!=', False)],
|
|
["id", "country_id"],
|
|
groupby="country_id", orderby="country_id")
|
|
|
|
# Fallback on all countries if no partners found for the country and
|
|
# there are matching partners for other countries.
|
|
country_ids = [c['country_id'][0] for c in countries]
|
|
fallback_all_countries = country and country.id not in country_ids
|
|
if fallback_all_countries:
|
|
country = None
|
|
|
|
# Group by grade
|
|
grade_domain = list(base_partner_domain)
|
|
if country:
|
|
grade_domain += [('country_id', '=', country.id)]
|
|
grades = partner_obj.sudo().read_group(
|
|
grade_domain, ["id", "grade_id"],
|
|
groupby="grade_id")
|
|
grades_partners = partner_obj.sudo().search_count(grade_domain)
|
|
# flag active grade
|
|
for grade_dict in grades:
|
|
grade_dict['active'] = grade and grade_dict['grade_id'][0] == grade.id
|
|
grades.insert(0, {
|
|
'grade_id_count': grades_partners,
|
|
'grade_id': (0, _("All Categories")),
|
|
'active': bool(grade is None),
|
|
})
|
|
|
|
countries_partners = partner_obj.sudo().search_count(country_domain)
|
|
# flag active country
|
|
for country_dict in countries:
|
|
country_dict['active'] = country and country_dict['country_id'] and country_dict['country_id'][0] == country.id
|
|
countries.insert(0, {
|
|
'country_id_count': countries_partners,
|
|
'country_id': (0, _("All Countries")),
|
|
'active': bool(country is None),
|
|
})
|
|
|
|
# current search
|
|
if grade:
|
|
base_partner_domain += [('grade_id', '=', grade.id)]
|
|
if country:
|
|
base_partner_domain += [('country_id', '=', country.id)]
|
|
|
|
# format pager
|
|
slug = request.env['ir.http']._slug
|
|
if grade and not country:
|
|
url = '/partners/grade/' + slug(grade)
|
|
elif country and not grade:
|
|
url = '/partners/country/' + slug(country)
|
|
elif country and grade:
|
|
url = '/partners/grade/' + slug(grade) + '/country/' + slug(country)
|
|
else:
|
|
url = '/partners'
|
|
url_args = {}
|
|
if search:
|
|
url_args['search'] = search
|
|
if country_all:
|
|
url_args['country_all'] = True
|
|
|
|
partner_count = partner_obj.sudo().search_count(base_partner_domain)
|
|
pager = request.website.pager(
|
|
url=url, total=partner_count, page=page, step=self._references_per_page, scope=7,
|
|
url_args=url_args)
|
|
|
|
# search partners matching current search parameters
|
|
partner_ids = partner_obj.sudo().search(
|
|
base_partner_domain, order="grade_sequence ASC, implemented_partner_count DESC, complete_name ASC, id ASC",
|
|
offset=pager['offset'], limit=self._references_per_page)
|
|
partners = partner_ids.sudo()
|
|
|
|
google_maps_api_key = request.website.google_maps_api_key
|
|
|
|
values = {
|
|
'countries': countries,
|
|
'country_all': country_all,
|
|
'current_country': country,
|
|
'grades': grades,
|
|
'current_grade': grade,
|
|
'partners': partners,
|
|
'pager': pager,
|
|
'searches': post,
|
|
'search_path': "%s" % werkzeug.urls.url_encode(post),
|
|
'google_maps_api_key': google_maps_api_key,
|
|
'fallback_all_countries': fallback_all_countries,
|
|
}
|
|
return request.render("website_crm_partner_assign.index", values, status=partners and 200 or 404)
|
|
|
|
|
|
# Do not use semantic controller due to sudo()
|
|
@http.route()
|
|
def partners_detail(self, partner_id, **post):
|
|
current_slug = partner_id
|
|
_, partner_id = request.env['ir.http']._unslug(partner_id)
|
|
current_grade, current_country = None, None
|
|
grade_id = post.get('grade_id')
|
|
country_id = post.get('country_id')
|
|
if grade_id:
|
|
current_grade = request.env['res.partner.grade'].browse(int(grade_id)).exists()
|
|
if country_id:
|
|
current_country = request.env['res.country'].browse(int(country_id)).exists()
|
|
if partner_id:
|
|
partner = request.env['res.partner'].sudo().browse(partner_id)
|
|
is_website_restricted_editor = request.env.user.has_group('website.group_website_restricted_editor')
|
|
if partner.exists() and (partner.website_published or is_website_restricted_editor):
|
|
partner_slug = request.env['ir.http']._slug(partner)
|
|
if partner_slug != current_slug:
|
|
return request.redirect('/partners/%s' % partner_slug)
|
|
values = {
|
|
'main_object': partner,
|
|
'partner': partner,
|
|
'current_grade': current_grade,
|
|
'current_country': current_country
|
|
}
|
|
return request.render("website_crm_partner_assign.partner", values)
|
|
raise request.not_found()
|