feat(fusion_helpdesk): customer follow-up + embedded ticket inbox
Squash-merge of feat/helpdesk-customer-followup. The billing and fusion_login_audit work from that branch is already on main (landed separately); this lands only the helpdesk feature. - Identity keystone: submit() forwards partner_email/partner_name/ x_fc_client_label so the central Helpdesk find-or-creates the customer partner and subscribes them as a follower (enables reply emails + magic link). - Embedded in-app 'My Tickets' inbox: server-side scoped read/reply RPC endpoints, per-user seen tracking (fusion.helpdesk.ticket.seen), systray unread badge. Defense-in-depth scope domain + _norm_email normalisation (wildcard emails cannot widen scope). - fusion_helpdesk_central: x_fc_client_label field + list/search views + branded acknowledgement email template. - Deployed and smoke-tested live: nexa central 19.0.1.1.0, entech client 19.0.1.4.1 (requires Contact Creation on the central service account). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
gsinghpal
@@ -23,6 +23,15 @@ from odoo import _, http
|
||||
from odoo.exceptions import UserError
|
||||
from odoo.http import request
|
||||
|
||||
from odoo.addons.fusion_helpdesk.utils import (
|
||||
build_ticket_vals,
|
||||
build_scope_domain,
|
||||
is_public_message,
|
||||
compute_unread_count,
|
||||
escape_like,
|
||||
_norm_email,
|
||||
)
|
||||
|
||||
_logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@@ -34,7 +43,7 @@ class FusionHelpdeskController(http.Controller):
|
||||
)
|
||||
def submit(self, kind, subject, description,
|
||||
error_code=None, attachments=None,
|
||||
page_url=None, user_agent=None):
|
||||
page_url=None, user_agent=None, reply_email=None):
|
||||
"""Forward a bug report or feature request to the central Odoo
|
||||
Helpdesk and return {ok, ticket_id, ticket_url, error}.
|
||||
|
||||
@@ -60,10 +69,6 @@ class FusionHelpdeskController(http.Controller):
|
||||
}
|
||||
|
||||
# ---- Build the ticket payload ---------------------------------
|
||||
prefix = ('[%s] ' % cfg['client_label']) if cfg['client_label'] else ''
|
||||
kind_label = 'Bug Report' if kind == 'bug' else 'Feature Request'
|
||||
full_subject = '%s%s: %s' % (prefix, kind_label, subject or '(untitled)')
|
||||
|
||||
body_parts = []
|
||||
if description:
|
||||
body_parts.append(
|
||||
@@ -77,12 +82,22 @@ class FusionHelpdeskController(http.Controller):
|
||||
)
|
||||
body_parts.append(self._build_diag_block(page_url, user_agent))
|
||||
|
||||
ticket_vals = {
|
||||
'name': full_subject,
|
||||
'description': '\n'.join(body_parts),
|
||||
}
|
||||
if cfg['team_id']:
|
||||
ticket_vals['team_id'] = cfg['team_id']
|
||||
# Identity keystone: send the reporter's name + email so the central
|
||||
# helpdesk find-or-creates the customer partner and subscribes them as
|
||||
# a follower — which is what enables reply emails, the magic link, and
|
||||
# the scoped "My Tickets" inbox. reply_email is the (editable) value the
|
||||
# user confirmed in the dialog; fall back to their Odoo email/login.
|
||||
user = request.env.user
|
||||
# Normalise the confirmed email (and fall back to the user's own).
|
||||
# Normalising rejects garbage / wildcard-bearing values so the stored
|
||||
# partner_email — which is also the inbox scope key — stays clean.
|
||||
reporter_email = _norm_email(reply_email, user.email, user.login)
|
||||
ticket_vals = build_ticket_vals(
|
||||
kind=kind, subject=subject, body_html='\n'.join(body_parts),
|
||||
team_id=cfg['team_id'], client_label=cfg['client_label'],
|
||||
reporter_name=user.name, reporter_email=reporter_email,
|
||||
company_name=request.env.company.name,
|
||||
)
|
||||
|
||||
# ---- Talk to remote Odoo --------------------------------------
|
||||
try:
|
||||
@@ -133,7 +148,12 @@ class FusionHelpdeskController(http.Controller):
|
||||
return _network_error_response(cfg['url'], e)
|
||||
|
||||
# ---- Push attachments -----------------------------------------
|
||||
# The ticket already exists; an attachment failure must NOT bubble up
|
||||
# as a 500 (the user would think the whole submission failed and file
|
||||
# a duplicate). Catch network errors too, count failures, and report
|
||||
# them back so the dialog can tell the user which files didn't make it.
|
||||
attached = 0
|
||||
failed = 0
|
||||
for att in attachments or []:
|
||||
data_b64 = (att or {}).get('data_b64')
|
||||
name = (att or {}).get('name') or 'attachment.bin'
|
||||
@@ -152,10 +172,12 @@ class FusionHelpdeskController(http.Controller):
|
||||
}],
|
||||
)
|
||||
attached += 1
|
||||
except xmlrpc.client.Fault as e:
|
||||
except (xmlrpc.client.Fault, xmlrpc.client.ProtocolError,
|
||||
socket.timeout, OSError, ssl.SSLError) as e:
|
||||
failed += 1
|
||||
_logger.warning(
|
||||
'fusion_helpdesk: attachment "%s" upload failed: %s',
|
||||
name, e.faultString,
|
||||
name, e,
|
||||
)
|
||||
|
||||
ticket_url = urljoin(
|
||||
@@ -163,9 +185,9 @@ class FusionHelpdeskController(http.Controller):
|
||||
'odoo/helpdesk/%s' % ticket_id,
|
||||
)
|
||||
_logger.info(
|
||||
'fusion_helpdesk: created remote ticket #%s (%s attachments) '
|
||||
'fusion_helpdesk: created remote ticket #%s (%s attached, %s failed) '
|
||||
'on %s for user %s',
|
||||
ticket_id, attached, cfg['url'],
|
||||
ticket_id, attached, failed, cfg['url'],
|
||||
request.env.user.login,
|
||||
)
|
||||
return {
|
||||
@@ -173,6 +195,7 @@ class FusionHelpdeskController(http.Controller):
|
||||
'ticket_id': ticket_id,
|
||||
'ticket_url': ticket_url,
|
||||
'attached': attached,
|
||||
'failed': failed,
|
||||
}
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
@@ -351,6 +374,318 @@ class FusionHelpdeskController(http.Controller):
|
||||
body += '</table>'
|
||||
return body
|
||||
|
||||
# ==================================================================
|
||||
# Embedded ticket inbox — identity, RPC seam, helpers
|
||||
# ==================================================================
|
||||
def _identity(self):
|
||||
"""Resolve the caller's scope from the SERVER-SIDE session only.
|
||||
|
||||
Never trust an email / label / scope sent by the browser — this is
|
||||
the security boundary that stops one deployment reading another's
|
||||
tickets through the shared bot account."""
|
||||
user = request.env.user
|
||||
cfg = self._read_config()
|
||||
return {
|
||||
'cfg': cfg,
|
||||
# Normalised so a self-set wildcard email ('%') can't widen scope.
|
||||
'email': _norm_email(user.email, user.login),
|
||||
'label': cfg['client_label'],
|
||||
'is_admin': user.has_group('fusion_helpdesk.group_reporter_admin'),
|
||||
'name': user.name,
|
||||
}
|
||||
|
||||
def _config_ready(self, cfg):
|
||||
return all([cfg['url'], cfg['db'], cfg['login'], cfg['password']])
|
||||
|
||||
def _rpc(self, cfg, model, method, args, kw=None):
|
||||
"""Authenticate + execute_kw against the central Odoo as the bot.
|
||||
|
||||
A ProtocolError on the execute_kw leg (e.g. a 502/503/429 from the
|
||||
central reverse proxy) is NOT an OSError subclass, so we convert it to
|
||||
a _RemoteError here — otherwise it would escape every endpoint's
|
||||
except-tuple and surface as a raw 500 (mislabelled "Network error")."""
|
||||
uid, proxy = self._authenticate(cfg)
|
||||
try:
|
||||
return proxy.execute_kw(
|
||||
cfg['db'], uid, cfg['password'], model, method, args, kw or {},
|
||||
)
|
||||
except xmlrpc.client.ProtocolError as e:
|
||||
_logger.warning('fusion_helpdesk: HTTP %s on %s.%s: %s',
|
||||
e.errcode, model, method, e.errmsg)
|
||||
raise _RemoteError(
|
||||
'remote_http_error',
|
||||
_('The central Helpdesk returned HTTP %(code)s. Please try '
|
||||
'again in a moment.') % {'code': e.errcode},
|
||||
)
|
||||
|
||||
def _internal_subtype_map(self, cfg, subtype_ids):
|
||||
"""{subtype_id: internal_bool} so internal notes can be hidden."""
|
||||
ids = [s for s in set(subtype_ids) if s]
|
||||
if not ids:
|
||||
return {}
|
||||
rows = self._rpc(cfg, 'mail.message.subtype', 'read',
|
||||
[ids], {'fields': ['internal']})
|
||||
return {r['id']: r.get('internal', False) for r in rows}
|
||||
|
||||
def _ticket_messages(self, cfg, ticket_ids):
|
||||
"""Raw comment/email messages for a set of tickets (one RPC)."""
|
||||
if not ticket_ids:
|
||||
return []
|
||||
return self._rpc(
|
||||
cfg, 'mail.message', 'search_read',
|
||||
[[('model', '=', 'helpdesk.ticket'),
|
||||
('res_id', 'in', list(ticket_ids)),
|
||||
('message_type', 'in', ['comment', 'email'])]],
|
||||
{'fields': ['id', 'res_id', 'author_id', 'subtype_id']},
|
||||
)
|
||||
|
||||
def _last_support_map(self, cfg, tickets, msgs):
|
||||
"""{ticket_id: latest customer-visible SUPPORT message id}.
|
||||
|
||||
A support message is a public comment NOT authored by the ticket's
|
||||
own customer (internal notes and the customer's own posts excluded)."""
|
||||
internal = self._internal_subtype_map(
|
||||
cfg, [m['subtype_id'][0] for m in msgs if m.get('subtype_id')])
|
||||
customer = {
|
||||
t['id']: (t['partner_id'][0] if t['partner_id'] else None)
|
||||
for t in tickets
|
||||
}
|
||||
last = {}
|
||||
for m in msgs:
|
||||
st = m.get('subtype_id')
|
||||
if st and internal.get(st[0]):
|
||||
continue # internal note — never counts / never shown
|
||||
author = m['author_id'][0] if m['author_id'] else None
|
||||
rid = m['res_id']
|
||||
if author and author == customer.get(rid):
|
||||
continue # the customer's own reply isn't an unread "support" msg
|
||||
if m['id'] > last.get(rid, 0):
|
||||
last[rid] = m['id']
|
||||
return last
|
||||
|
||||
def _public_messages(self, cfg, ticket_id):
|
||||
"""Customer-visible thread for one ticket, oldest first."""
|
||||
raw = self._rpc(
|
||||
cfg, 'mail.message', 'search_read',
|
||||
[[('model', '=', 'helpdesk.ticket'),
|
||||
('res_id', '=', ticket_id),
|
||||
('message_type', 'in', ['comment', 'email'])]],
|
||||
{'fields': ['id', 'date', 'body', 'author_id', 'subtype_id',
|
||||
'attachment_ids'],
|
||||
'order': 'id asc'},
|
||||
)
|
||||
internal = self._internal_subtype_map(
|
||||
cfg, [m['subtype_id'][0] for m in raw if m.get('subtype_id')])
|
||||
out = []
|
||||
for m in raw:
|
||||
st = m.get('subtype_id')
|
||||
msg = {
|
||||
'id': m['id'],
|
||||
'date': m['date'],
|
||||
'body': m['body'] or '',
|
||||
'author': (m['author_id'][1] if m['author_id'] else ''),
|
||||
'author_id': (m['author_id'][0] if m['author_id'] else False),
|
||||
'attachment_count': len(m.get('attachment_ids') or []),
|
||||
'subtype_is_internal': internal.get(st[0], False) if st else False,
|
||||
}
|
||||
if is_public_message(msg):
|
||||
out.append(msg)
|
||||
return out
|
||||
|
||||
def _resolve_author(self, cfg, ident, ticket):
|
||||
"""Find-or-create the replier's OWN partner on central so their reply
|
||||
is correctly attributed.
|
||||
|
||||
`ident['email']` is already normalised (no wildcards); we escape it for
|
||||
the =ilike search as belt-and-suspenders. On any failure we log and
|
||||
return False — message_post then attributes the reply to the service
|
||||
account, which is honest. We deliberately do NOT fall back to the
|
||||
ticket's customer: for an admin replying to a colleague's ticket that
|
||||
would silently impersonate the customer."""
|
||||
email = ident['email']
|
||||
if not email:
|
||||
return False
|
||||
try:
|
||||
pids = self._rpc(cfg, 'res.partner', 'search',
|
||||
[[('email', '=ilike', escape_like(email))]], {'limit': 1})
|
||||
if pids:
|
||||
return pids[0]
|
||||
return self._rpc(cfg, 'res.partner', 'create',
|
||||
[{'name': ident['name'], 'email': email}])
|
||||
except (xmlrpc.client.Fault, _RemoteError) as e:
|
||||
_logger.warning(
|
||||
'fusion_helpdesk: could not resolve reply author for %s on '
|
||||
'ticket %s (%s); posting as the service account.',
|
||||
email, ticket.get('id'), e)
|
||||
return False
|
||||
|
||||
def _mark_ticket_seen(self, ticket_id, messages):
|
||||
"""Best-effort read-tracking. Runs AFTER the remote read/post, so it
|
||||
must never raise — otherwise a local DB hiccup here would turn an
|
||||
already-successful reply into a reported failure, and the user would
|
||||
resubmit (posting a duplicate). Bookkeeping only; log and swallow."""
|
||||
if not messages:
|
||||
return
|
||||
try:
|
||||
request.env['fusion.helpdesk.ticket.seen']._mark_seen(
|
||||
ticket_id, max(m['id'] for m in messages))
|
||||
except Exception: # noqa: BLE001 — non-critical bookkeeping
|
||||
_logger.exception(
|
||||
'fusion_helpdesk: mark-seen failed for ticket %s', ticket_id)
|
||||
|
||||
def _remote_failure(self, cfg, err):
|
||||
"""Map a mid-RPC failure to the dialog's response shape."""
|
||||
if isinstance(err, _RemoteError):
|
||||
return err.to_response()
|
||||
if isinstance(err, (socket.timeout, OSError, ssl.SSLError)):
|
||||
return _network_error_response(cfg['url'], err)
|
||||
return {'ok': False, 'error': 'remote_error',
|
||||
'message': _('The central Helpdesk returned an error: %s'
|
||||
) % str(err)}
|
||||
|
||||
# ==================================================================
|
||||
# Embedded ticket inbox — endpoints (auth='user', server-side scoped)
|
||||
# ==================================================================
|
||||
@http.route('/fusion_helpdesk/my_tickets',
|
||||
type='jsonrpc', auth='user', methods=['POST'])
|
||||
def my_tickets(self, scope='mine'):
|
||||
"""List the caller's tickets (scoped). Admins may pass scope='all'
|
||||
to see every ticket from their deployment."""
|
||||
ident = self._identity()
|
||||
cfg = ident['cfg']
|
||||
if not self._config_ready(cfg):
|
||||
return {'ok': False, 'error': 'config_missing',
|
||||
'message': _('Fusion Helpdesk is not configured.')}
|
||||
view_all = ident['is_admin'] and scope == 'all'
|
||||
domain = build_scope_domain(ident['label'], ident['email'], view_all)
|
||||
try:
|
||||
tickets = self._rpc(
|
||||
cfg, 'helpdesk.ticket', 'search_read', [domain],
|
||||
{'fields': ['id', 'name', 'stage_id', 'partner_id',
|
||||
'write_date', 'ticket_ref'],
|
||||
'order': 'write_date desc', 'limit': 100})
|
||||
msgs = self._ticket_messages(cfg, [t['id'] for t in tickets])
|
||||
except (_RemoteError, xmlrpc.client.Fault, OSError, ssl.SSLError) as e:
|
||||
return self._remote_failure(cfg, e)
|
||||
|
||||
last_support = self._last_support_map(cfg, tickets, msgs)
|
||||
ids = [t['id'] for t in tickets]
|
||||
seen = request.env['fusion.helpdesk.ticket.seen']._seen_map(ids)
|
||||
rows = []
|
||||
for t in tickets:
|
||||
rid = t['id']
|
||||
ls = last_support.get(rid, 0)
|
||||
rows.append({
|
||||
'id': rid,
|
||||
'ref': t.get('ticket_ref') or str(rid),
|
||||
'subject': t['name'],
|
||||
'stage': t['stage_id'][1] if t['stage_id'] else '',
|
||||
'last_update': t['write_date'],
|
||||
'last_support_msg_id': ls,
|
||||
'has_unread': ls > (seen.get(rid, 0) or 0),
|
||||
})
|
||||
return {'ok': True, 'tickets': rows, 'is_admin': ident['is_admin'],
|
||||
'unread': compute_unread_count(rows, seen)}
|
||||
|
||||
@http.route('/fusion_helpdesk/ticket/<int:ticket_id>',
|
||||
type='jsonrpc', auth='user', methods=['POST'])
|
||||
def ticket_detail(self, ticket_id, **kw):
|
||||
"""Full thread for one ticket — re-checks scope, hides internal notes,
|
||||
marks the ticket seen for the badge."""
|
||||
ident = self._identity()
|
||||
cfg = ident['cfg']
|
||||
if not self._config_ready(cfg):
|
||||
return {'ok': False, 'error': 'config_missing',
|
||||
'message': _('Fusion Helpdesk is not configured.')}
|
||||
domain = build_scope_domain(
|
||||
ident['label'], ident['email'], ident['is_admin']
|
||||
) + [('id', '=', ticket_id)]
|
||||
try:
|
||||
found = self._rpc(cfg, 'helpdesk.ticket', 'search_read', [domain],
|
||||
{'fields': ['id', 'name', 'stage_id',
|
||||
'access_token'], 'limit': 1})
|
||||
if not found:
|
||||
return {'ok': False, 'error': 'not_found',
|
||||
'message': _('Ticket not found or not accessible.')}
|
||||
messages = self._public_messages(cfg, ticket_id)
|
||||
except (_RemoteError, xmlrpc.client.Fault, OSError, ssl.SSLError) as e:
|
||||
return self._remote_failure(cfg, e)
|
||||
self._mark_ticket_seen(ticket_id, messages)
|
||||
t = found[0]
|
||||
# Magic link: the customer's own access-token URL on central, so they
|
||||
# can open the full ticket (incl. attachments) in the portal if needed.
|
||||
portal_url = ''
|
||||
if t.get('access_token'):
|
||||
portal_url = '%s/my/ticket/%s/%s' % (
|
||||
cfg['url'].rstrip('/'), t['id'], t['access_token'])
|
||||
return {'ok': True, 'ticket': {
|
||||
'id': t['id'], 'subject': t['name'],
|
||||
'stage': t['stage_id'][1] if t['stage_id'] else '',
|
||||
'portal_url': portal_url,
|
||||
'messages': messages}}
|
||||
|
||||
@http.route('/fusion_helpdesk/ticket/<int:ticket_id>/reply',
|
||||
type='jsonrpc', auth='user', methods=['POST'])
|
||||
def ticket_reply(self, ticket_id, body=None, **kw):
|
||||
"""Post a customer reply on a scoped ticket, attributed to the replier."""
|
||||
ident = self._identity()
|
||||
cfg = ident['cfg']
|
||||
text = (body or '').strip()
|
||||
if not text:
|
||||
return {'ok': False, 'error': 'empty',
|
||||
'message': _('Your reply is empty.')}
|
||||
if not self._config_ready(cfg):
|
||||
return {'ok': False, 'error': 'config_missing',
|
||||
'message': _('Fusion Helpdesk is not configured.')}
|
||||
domain = build_scope_domain(
|
||||
ident['label'], ident['email'], ident['is_admin']
|
||||
) + [('id', '=', ticket_id)]
|
||||
try:
|
||||
found = self._rpc(cfg, 'helpdesk.ticket', 'search_read', [domain],
|
||||
{'fields': ['id', 'partner_id'], 'limit': 1})
|
||||
if not found:
|
||||
return {'ok': False, 'error': 'not_found',
|
||||
'message': _('Ticket not found or not accessible.')}
|
||||
author_id = self._resolve_author(cfg, ident, found[0])
|
||||
# We escape the user's text ourselves, then mark it up as paragraphs.
|
||||
# message_post() ESCAPES a plain str body (it expects a Markup for
|
||||
# HTML) — but Markup can't cross XML-RPC, so we pass body_is_html=True
|
||||
# which tells the remote message_post to treat our already-escaped
|
||||
# HTML as Markup. Without this the customer would see literal <p> tags.
|
||||
html = '<p>%s</p>' % _html_escape(text).replace('\n', '<br/>')
|
||||
self._rpc(cfg, 'helpdesk.ticket', 'message_post', [[ticket_id]], {
|
||||
'body': html, 'body_is_html': True, 'message_type': 'comment',
|
||||
'subtype_xmlid': 'mail.mt_comment', 'author_id': author_id,
|
||||
})
|
||||
messages = self._public_messages(cfg, ticket_id)
|
||||
except (_RemoteError, xmlrpc.client.Fault, OSError, ssl.SSLError) as e:
|
||||
return self._remote_failure(cfg, e)
|
||||
self._mark_ticket_seen(ticket_id, messages)
|
||||
return {'ok': True, 'messages': messages}
|
||||
|
||||
@http.route('/fusion_helpdesk/unread_count',
|
||||
type='jsonrpc', auth='user', methods=['POST'])
|
||||
def unread_count(self):
|
||||
"""Badge count: tickets with a support reply newer than last-seen.
|
||||
Always scoped to the caller's OWN tickets (never the admin-all view)."""
|
||||
ident = self._identity()
|
||||
cfg = ident['cfg']
|
||||
if not self._config_ready(cfg):
|
||||
return {'ok': True, 'count': 0}
|
||||
domain = build_scope_domain(ident['label'], ident['email'], False)
|
||||
try:
|
||||
tickets = self._rpc(cfg, 'helpdesk.ticket', 'search_read', [domain],
|
||||
{'fields': ['id', 'partner_id'], 'limit': 100})
|
||||
msgs = self._ticket_messages(cfg, [t['id'] for t in tickets])
|
||||
except (_RemoteError, xmlrpc.client.Fault, OSError, ssl.SSLError):
|
||||
return {'ok': True, 'count': 0} # badge must never break the systray
|
||||
last_support = self._last_support_map(cfg, tickets, msgs)
|
||||
rows = [{'id': k, 'last_support_msg_id': v}
|
||||
for k, v in last_support.items()]
|
||||
seen = request.env['fusion.helpdesk.ticket.seen']._seen_map(
|
||||
list(last_support.keys()))
|
||||
return {'ok': True, 'count': compute_unread_count(rows, seen)}
|
||||
|
||||
|
||||
def _html_escape(s):
|
||||
return (
|
||||
|
||||
Reference in New Issue
Block a user