252 lines
11 KiB
Python
252 lines
11 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import re
|
|
|
|
from werkzeug.exceptions import NotFound
|
|
from werkzeug.utils import redirect
|
|
|
|
from odoo import http, _
|
|
from odoo.fields import Domain
|
|
from odoo.http import request
|
|
|
|
from odoo.addons.website.controllers import form, main
|
|
from odoo.addons.website.models.ir_http import sitemap_qs2dom
|
|
from odoo.addons.base.models.ir_qweb_fields import nl2br, nl2br_enclose
|
|
from odoo.tools import html2plaintext
|
|
from odoo.tools.translate import LazyTranslate
|
|
|
|
_lt = LazyTranslate(__name__)
|
|
|
|
|
|
class WebsiteHelpdesk(http.Controller):
|
|
|
|
def get_helpdesk_team_data(self, team, search=None):
|
|
return {
|
|
'team': team,
|
|
'main_object': team,
|
|
}
|
|
|
|
def sitemap_helpdesk(env, rule, qs):
|
|
HelpdeskTeam = env['helpdesk.team']
|
|
slug = env['ir.http']._slug
|
|
|
|
dom = (
|
|
env['website'].get_current_website().website_domain()
|
|
& Domain('use_website_helpdesk_form', '=', True)
|
|
& Domain('website_published', '=', True)
|
|
)
|
|
dom += sitemap_qs2dom(qs, '/helpdesk', HelpdeskTeam._rec_name)
|
|
|
|
teams = HelpdeskTeam.search(dom)
|
|
for team in teams:
|
|
loc = '/helpdesk/%s' % slug(team)
|
|
if not qs or qs.lower() in loc:
|
|
yield {'loc': loc}
|
|
|
|
if not teams:
|
|
# avoid 404 or blank page in sitemap
|
|
return False
|
|
|
|
if not qs or qs.lower() in '/helpdesk':
|
|
yield {'loc': '/helpdesk'}
|
|
|
|
@http.route(['/helpdesk', '/helpdesk/<model("helpdesk.team"):team>'], type='http', auth="public", website=True, sitemap=sitemap_helpdesk, list_as_website_content=_lt('Helpdesk'))
|
|
def website_helpdesk_teams(self, team=None, **kwargs):
|
|
search = kwargs.get('search')
|
|
|
|
teams_domain = Domain('use_website_helpdesk_form', '=', True) & Domain('website_id', '=', request.website.id)
|
|
if not request.env.user.has_group('helpdesk.group_helpdesk_manager'):
|
|
if team and not team.is_published:
|
|
raise NotFound()
|
|
teams_domain &= Domain('website_published', '=', True)
|
|
|
|
teams = request.env['helpdesk.team'].search(teams_domain, order="id asc")
|
|
if not teams:
|
|
raise NotFound()
|
|
|
|
if not team:
|
|
if len(teams) != 1:
|
|
return request.render("website_helpdesk.helpdesk_all_team", {'teams': teams})
|
|
redirect_url = teams.website_url
|
|
if teams.show_knowledge_base and not kwargs.get('contact_form'):
|
|
redirect_url += '/knowledgebase'
|
|
elif kwargs.get('contact_form'):
|
|
redirect_url += '/?contact_form=1'
|
|
return redirect(redirect_url)
|
|
|
|
if team.show_knowledge_base and not kwargs.get('contact_form'):
|
|
return redirect(team.website_url + '/knowledgebase')
|
|
|
|
result = self.get_helpdesk_team_data(team or teams[0], search=search)
|
|
result['multiple_teams'] = len(teams) > 1
|
|
return request.render("website_helpdesk.team", result)
|
|
|
|
def _get_knowledge_base_values(self, team):
|
|
return {
|
|
'team': team,
|
|
'main_object': team,
|
|
}
|
|
|
|
@http.route(['/helpdesk/<model("helpdesk.team"):team>/knowledgebase'], type='http', auth="public", website=True, sitemap=True)
|
|
def website_helpdesk_knowledge_base(self, team, **kwargs):
|
|
if not team.show_knowledge_base:
|
|
return redirect(team.website_url)
|
|
|
|
search = kwargs.get('search')
|
|
search_kw = ['type', 'date', 'tag']
|
|
if search is not None:
|
|
searches = {
|
|
'search': search,
|
|
**{k: kwargs.get(k) for k in search_kw if request.website.is_view_active('website_helpdesk.navbar_search_%s' % k)}
|
|
}
|
|
|
|
types = team._helpcenter_filter_types()
|
|
options = team._get_search_options(searches)
|
|
search_types = [searches['type']] if searches.get('type') else types.keys()
|
|
results = self._get_search_results(search, search_types, options)
|
|
|
|
tags = sorted(set(team._helpcenter_filter_tags(kwargs.get('type'))))
|
|
dates = {
|
|
'7days': _('Last Week'),
|
|
'30days': _('Last Month'),
|
|
'365days': _('Last Year'),
|
|
}
|
|
return request.render("website_helpdesk.search_results", {
|
|
'team': team,
|
|
'search': search,
|
|
'search_count': len(results),
|
|
'searches': searches,
|
|
'available_types': types,
|
|
'current_type': types[searches['type']] if searches.get('type') else False,
|
|
'available_dates': dates,
|
|
'current_date': dates[searches['date']] if searches.get('date') else False,
|
|
'available_tags': tags,
|
|
'current_tag': searches['tag'] if searches.get('tag') else False,
|
|
'results': results,
|
|
})
|
|
|
|
return request.render("website_helpdesk.knowledge_base", self._get_knowledge_base_values(team))
|
|
|
|
@http.route(['/helpdesk/<model("helpdesk.team"):team>/knowledgebase/autocomplete'], type='jsonrpc', auth="public", website=True, sitemap=True)
|
|
def website_helpdesk_autocomplete(self, team, **kwargs):
|
|
if not team.show_knowledge_base:
|
|
raise NotFound()
|
|
|
|
search = kwargs.get('term')
|
|
if len(search) < 3:
|
|
return {'results': [], 'showMore': False}
|
|
|
|
searches = {'search': search}
|
|
options = team._get_search_options(searches)
|
|
|
|
search_types = team._helpcenter_filter_types().keys()
|
|
results = self._get_search_results(search, search_types, options)
|
|
|
|
return {
|
|
'results': [{
|
|
'name': r['record'].name,
|
|
'icon': r['icon'],
|
|
'url': r['url']} for r in results[:10]],
|
|
'showMore': len(results) > 10,
|
|
}
|
|
|
|
def _get_search_results(self, search, search_types, options):
|
|
search_results = []
|
|
if search:
|
|
for search_type in search_types:
|
|
count, results, dummy = request.website._search_with_fuzzy(search_type, search, limit=10, order='name', options=options)
|
|
if count:
|
|
for all_results in results:
|
|
if all_results.get('results', False):
|
|
search_results += self._format_search_results(search_type, all_results['results'], options)
|
|
return sorted(search_results, key=lambda res: res.get('score', 0), reverse=True)
|
|
|
|
def _format_search_results(self, search_type, records, options):
|
|
return []
|
|
|
|
|
|
class WebsiteForm(form.WebsiteForm):
|
|
|
|
def _handle_website_form(self, model_name, **kwargs):
|
|
email = request.params.get('partner_email')
|
|
if email:
|
|
if request.env.user.email == email:
|
|
partner = request.env.user.partner_id
|
|
else:
|
|
team_company = request.env['helpdesk.team'].sudo().browse(int(request.params.get('team_id'))).company_id.id if request.params.get('team_id') else False
|
|
partner = request.env['mail.thread'].sudo()._mail_find_partner_from_emails(emails=[email], extra_domain=[('company_id', 'in', [team_company, False])])[0]
|
|
if not partner:
|
|
partner = request.env['res.partner'].sudo().create({
|
|
'email': email,
|
|
'name': request.params.get('partner_name', False),
|
|
'phone': request.params.get('partner_phone', False),
|
|
'company_name': request.params.get('partner_company_name', False),
|
|
'lang': request.lang.code,
|
|
})
|
|
kwargs.update({'partner_id': partner.id})
|
|
if not request.env.user._is_internal():
|
|
kwargs.pop('partner_phone', None) # disallow partner's phone modification via _inverse_partner_phone
|
|
|
|
return super()._handle_website_form(model_name, **kwargs)
|
|
|
|
def insert_attachment(self, model_sudo, id_record, files):
|
|
super().insert_attachment(model_sudo, id_record, files)
|
|
# If the helpdesk ticket form is submit with attachments,
|
|
# Give access token to these attachments and make the message
|
|
# accessible to the portal user
|
|
# (which will be able to view and download its own documents).
|
|
model_name = model_sudo.model
|
|
if model_name == "helpdesk.ticket":
|
|
ticket = model_sudo.env[model_name].browse(id_record)
|
|
attachments = request.env['ir.attachment'].sudo().search([
|
|
('res_model', '=', model_name),
|
|
('res_id', '=', ticket.id),
|
|
('access_token', '=', False),
|
|
])
|
|
if not attachments:
|
|
return
|
|
attachments.generate_access_token()
|
|
message = ticket.message_ids.filtered(lambda m: m.attachment_ids == attachments)
|
|
message.is_internal = False
|
|
message.subtype_id = request.env.ref('mail.mt_comment')
|
|
|
|
def insert_record(self, request, model_sudo, values, custom, meta=None):
|
|
res = super().insert_record(request, model_sudo, values, custom, meta=meta)
|
|
if model_sudo.model != 'helpdesk.ticket':
|
|
return res
|
|
ticket = request.env['helpdesk.ticket'].sudo().browse(res)
|
|
custom_label = nl2br_enclose(_("Other Information"), 'h4') # Title for custom fields
|
|
default_field = model_sudo.website_form_default_field_id
|
|
default_field_data = values.get(default_field.name, '')
|
|
if not custom:
|
|
default_field_content = nl2br_enclose(html2plaintext(default_field_data), 'p')
|
|
else:
|
|
default_field_content = nl2br_enclose(default_field.field_description, 'h4') + nl2br_enclose(html2plaintext(default_field_data), 'p')
|
|
custom_content = (default_field_content if default_field_data else '') \
|
|
+ (custom_label + custom if custom else '') \
|
|
+ (self._meta_label + meta if meta else '')
|
|
|
|
if default_field.name:
|
|
if default_field.ttype == 'html':
|
|
custom_content = nl2br(custom_content)
|
|
ticket[default_field.name] = custom_content
|
|
ticket._message_log(
|
|
body=custom_content,
|
|
message_type='comment',
|
|
)
|
|
return res
|
|
|
|
class Website(main.Website):
|
|
|
|
@http.route()
|
|
def get_suggested_link(self, needle, limit=10):
|
|
# filter matching pages where url of format : /helpdesk/<team-slug>
|
|
def _is_helpdesk_team_page(page):
|
|
url = page.get('value', '')
|
|
pattern = r'^/helpdesk/([a-zA-Z]+-)+\d+$'
|
|
return re.match(pattern, url)
|
|
|
|
res = super(Website, self).get_suggested_link(needle, limit)
|
|
res['matching_pages'] = [page for page in res['matching_pages'] if not _is_helpdesk_team_page(page)]
|
|
return res
|