855 lines
36 KiB
Python
855 lines
36 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from datetime import datetime
|
|
from dateutil.relativedelta import relativedelta
|
|
from freezegun import freeze_time
|
|
from markupsafe import Markup
|
|
|
|
from .common import HelpdeskCommon
|
|
from odoo.exceptions import AccessError
|
|
from odoo.tests import Form
|
|
from odoo.tests.common import users
|
|
|
|
|
|
class TestHelpdeskFlow(HelpdeskCommon):
|
|
""" Test used to check that the base functionalities of Helpdesk function as expected.
|
|
- test_access_rights: tests a few access rights constraints
|
|
- test_assign_close_dates: tests the assignation and closing time get computed correctly
|
|
- test_ticket_partners: tests the number of tickets of a partner is computed correctly
|
|
- test_team_assignation_[method]: tests the team assignation method work as expected
|
|
- test_automatic_ticket_closing: tests automatic ticket closing after set number of days
|
|
"""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
res = super().setUpClass()
|
|
ticket_model_id = cls.env['ir.model']._get_id('helpdesk.ticket')
|
|
helpdesk_team_model_id = cls.env['ir.model']._get_id('helpdesk.team')
|
|
|
|
cls.mail_alias = cls.env['mail.alias'].create({
|
|
'alias_name': 'helpdesk_team',
|
|
'alias_model_id': ticket_model_id,
|
|
'alias_parent_model_id': helpdesk_team_model_id,
|
|
'alias_parent_thread_id': cls.test_team.id,
|
|
'alias_defaults': "{'team_id': %s}" % cls.test_team.id,
|
|
})
|
|
|
|
cls.email_to_alias_from = 'client_a@someprovider.com'
|
|
cls.email_to_alias = """MIME-Version: 1.0
|
|
Date: Thu, 27 Dec 2018 16:27:45 +0100
|
|
Message-ID: blablabla1
|
|
Subject: helpdesk team 1 in company 1
|
|
From: Client A <client_a@someprovider.com>
|
|
To: helpdesk_team@test.mycompany.com
|
|
Content-Type: multipart/alternative; boundary="000000000000a47519057e029630"
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/plain; charset="UTF-8"
|
|
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/html; charset="UTF-8"
|
|
Content-Transfer-Encoding: quoted-printable
|
|
|
|
<div>A good message ter</div>
|
|
|
|
--000000000000a47519057e029630--
|
|
"""
|
|
return res
|
|
|
|
def test_access_rights(self):
|
|
# helpdesk user should only be able to:
|
|
# read: teams, stages, SLAs,
|
|
# read, create, write, unlink: tickets, tags
|
|
# helpdesk manager:
|
|
# read, create, write, unlink: everything (from helpdesk)
|
|
# we consider in these tests that if the user can do it, the manager can do it as well (as the group is implied)
|
|
def test_write_and_unlink(record):
|
|
record.write({'name': 'test_write'})
|
|
record.unlink()
|
|
|
|
def test_not_write_and_unlink(self, record):
|
|
with self.assertRaises(AccessError):
|
|
record.write({'name': 'test_write'})
|
|
with self.assertRaises(AccessError):
|
|
record.unlink()
|
|
# self.assertRaises(AccessError, record.write({'name': 'test_write'})) # , "Helpdesk user should not be able to write on %s" % record._name)
|
|
# self.assertRaises(AccessError, record.unlink(), "Helpdesk user could unlink %s" % record._name)
|
|
|
|
# helpdesk.team access rights
|
|
team = self.env['helpdesk.team'].with_user(self.helpdesk_manager).create({'name': 'test'})
|
|
team.with_user(self.helpdesk_user).read()
|
|
test_not_write_and_unlink(self, team.with_user(self.helpdesk_user))
|
|
with self.assertRaises(AccessError):
|
|
team.with_user(self.helpdesk_user).create({'name': 'test create'})
|
|
test_write_and_unlink(team)
|
|
|
|
# helpdesk.ticket access rights
|
|
ticket = self.env['helpdesk.ticket'].with_user(self.helpdesk_user).create({'name': 'test'})
|
|
ticket.read()
|
|
test_write_and_unlink(ticket)
|
|
|
|
# helpdesk.stage access rights
|
|
stage = self.env['helpdesk.stage'].with_user(self.helpdesk_manager).create({
|
|
'name': 'test',
|
|
'team_ids': [(6, 0, [self.test_team.id])],
|
|
})
|
|
stage.with_user(self.helpdesk_user).read()
|
|
test_not_write_and_unlink(self, stage.with_user(self.helpdesk_user))
|
|
with self.assertRaises(AccessError):
|
|
stage.with_user(self.helpdesk_user).create({
|
|
'name': 'test create',
|
|
'team_ids': [(6, 0, [self.test_team.id])],
|
|
})
|
|
test_write_and_unlink(stage)
|
|
|
|
# helpdesk.sla access rights
|
|
sla = self.env['helpdesk.sla'].with_user(self.helpdesk_manager).create({
|
|
'name': 'test',
|
|
'team_id': self.test_team.id,
|
|
'stage_id': self.stage_done.id,
|
|
})
|
|
sla.with_user(self.helpdesk_user).read()
|
|
test_not_write_and_unlink(self, sla.with_user(self.helpdesk_user))
|
|
with self.assertRaises(AccessError):
|
|
sla.with_user(self.helpdesk_user).create({
|
|
'name': 'test create',
|
|
'team_id': self.test_team.id,
|
|
'stage_id': self.stage_done.id,
|
|
})
|
|
test_write_and_unlink(sla)
|
|
|
|
# helpdesk.tag access rights
|
|
tag = self.env['helpdesk.tag'].with_user(self.helpdesk_user).create({'name': 'test with unique name please'})
|
|
tag.read()
|
|
test_write_and_unlink(tag)
|
|
|
|
def test_assign_close_dates(self):
|
|
# helpdesk user create a ticket
|
|
with self._ticket_patch_now('2019-01-08 12:00:00'):
|
|
ticket1 = self.env['helpdesk.ticket'].with_user(self.helpdesk_user).create({
|
|
'name': 'test ticket 1',
|
|
'team_id': self.test_team.id,
|
|
})
|
|
|
|
with self._ticket_patch_now('2019-01-10 13:00:00'):
|
|
# the helpdesk user takes the ticket
|
|
ticket1.user_id = self.helpdesk_user
|
|
# we verify the ticket is correctly assigned
|
|
self.assertEqual(ticket1.user_id.id, ticket1._uid, "Assignation for ticket not correct")
|
|
self.assertEqual(ticket1.assign_hours, 17, "Assignation time for ticket not correct")
|
|
|
|
with self._ticket_patch_now('2019-01-10 15:00:00'):
|
|
# we close the ticket and verify its closing time
|
|
ticket1.write({'stage_id': self.stage_done.id})
|
|
self.assertEqual(ticket1.close_hours, 19, "Close time for ticket not correct")
|
|
|
|
def test_ticket_partners(self):
|
|
# we create a partner
|
|
partner = self.env['res.partner'].create({
|
|
'name': 'Freddy Krueger'
|
|
})
|
|
# helpdesk user creates 2 tickets for the partner
|
|
ticket1 = self.env['helpdesk.ticket'].with_user(self.helpdesk_user).create({
|
|
'name': 'partner ticket 1',
|
|
'team_id': self.test_team.id,
|
|
'partner_id': partner.id,
|
|
})
|
|
self.env['helpdesk.ticket'].with_user(self.helpdesk_user).create({
|
|
'name': 'partner ticket 2',
|
|
'team_id': self.test_team.id,
|
|
'partner_id': partner.id,
|
|
})
|
|
self.assertTrue(ticket1.partner_ticket_count == 1, "Incorrect number of tickets from the same partner.")
|
|
|
|
def test_team_assignation_randomly(self):
|
|
# we put the helpdesk user and manager in the test_team's members
|
|
self.test_team.member_ids = [(6, 0, [self.helpdesk_user.id, self.helpdesk_manager.id])]
|
|
# we set the assignation method to randomly (=uniformly distributed)
|
|
self.test_team.update({'assign_method': 'randomly', 'auto_assignment': True})
|
|
# we create a bunch of tickets
|
|
for i in range(5):
|
|
self.env['helpdesk.ticket'].create({
|
|
'name': 'test ticket ' + str(i),
|
|
'team_id': self.test_team.id,
|
|
})
|
|
# add unassigned ticket to test if the distribution is kept equal.
|
|
self.env['helpdesk.ticket'].create({
|
|
'name': 'ticket unassigned',
|
|
'team_id': self.test_team.id,
|
|
'user_id': False,
|
|
})
|
|
for i in range(5, 10):
|
|
self.env['helpdesk.ticket'].create({
|
|
'name': 'test ticket ' + str(i),
|
|
'team_id': self.test_team.id,
|
|
})
|
|
# ensure both members have the same amount of tickets assigned
|
|
self.assertEqual(self.env['helpdesk.ticket'].search_count([('user_id', '=', self.helpdesk_user.id)]), 5)
|
|
self.assertEqual(self.env['helpdesk.ticket'].search_count([('user_id', '=', self.helpdesk_manager.id)]), 5)
|
|
|
|
def test_team_assignation_balanced(self):
|
|
# we put the helpdesk user and manager in the test_team's members
|
|
self.test_team.member_ids = [(6, 0, [self.helpdesk_user.id, self.helpdesk_manager.id])]
|
|
# we set the assignation method to randomly (=uniformly distributed)
|
|
self.test_team.update({'assign_method': 'balanced', 'auto_assignment': True})
|
|
# we create a bunch of tickets
|
|
for i in range(4):
|
|
self.env['helpdesk.ticket'].create({
|
|
'name': 'test ticket ' + str(i),
|
|
'team_id': self.test_team.id,
|
|
})
|
|
# ensure both members have the same amount of tickets assigned
|
|
self.assertEqual(self.env['helpdesk.ticket'].search_count([('user_id', '=', self.helpdesk_user.id)]), 2)
|
|
self.assertEqual(self.env['helpdesk.ticket'].search_count([('user_id', '=', self.helpdesk_manager.id)]), 2)
|
|
|
|
# helpdesk user finishes his 2 tickets
|
|
self.env['helpdesk.ticket'].search([('user_id', '=', self.helpdesk_user.id)]).write({'stage_id': self.stage_done.id})
|
|
|
|
# we create 4 new tickets
|
|
for i in range(4):
|
|
self.env['helpdesk.ticket'].create({
|
|
'name': 'test ticket ' + str(i),
|
|
'team_id': self.test_team.id,
|
|
})
|
|
|
|
# ensure both members have the same amount of tickets assigned
|
|
self.assertEqual(self.env['helpdesk.ticket'].search_count([('user_id', '=', self.helpdesk_user.id), ('close_date', '=', False)]), 3)
|
|
self.assertEqual(self.env['helpdesk.ticket'].search_count([('user_id', '=', self.helpdesk_manager.id), ('close_date', '=', False)]), 3)
|
|
|
|
def test_create_from_email_multicompany(self):
|
|
company0 = self.env.company
|
|
company1 = self.env['res.company'].create({'name': 'new_company0'})
|
|
Partner = self.env['res.partner']
|
|
|
|
self.env.user.write({
|
|
'company_ids': [(4, company0.id, False), (4, company1.id, False)],
|
|
})
|
|
|
|
helpdesk_team_model = self.env['ir.model'].search([('model', '=', 'helpdesk_team')])
|
|
ticket_model = self.env['ir.model'].search([('model', '=', 'helpdesk.ticket')])
|
|
|
|
helpdesk_team0 = self.env['helpdesk.team'].create({
|
|
'name': 'helpdesk team 0',
|
|
'company_id': company0.id,
|
|
})
|
|
helpdesk_team1 = self.env['helpdesk.team'].create({
|
|
'name': 'helpdesk team 1',
|
|
'company_id': company1.id,
|
|
})
|
|
|
|
mail_alias0 = self.env['mail.alias'].create({
|
|
'alias_name': 'helpdesk_team_0',
|
|
'alias_model_id': ticket_model.id,
|
|
'alias_parent_model_id': helpdesk_team_model.id,
|
|
'alias_parent_thread_id': helpdesk_team0.id,
|
|
'alias_defaults': "{'team_id': %s}" % helpdesk_team0.id,
|
|
})
|
|
mail_alias1 = self.env['mail.alias'].create({
|
|
'alias_name': 'helpdesk_team_1',
|
|
'alias_model_id': ticket_model.id,
|
|
'alias_parent_model_id': helpdesk_team_model.id,
|
|
'alias_parent_thread_id': helpdesk_team1.id,
|
|
'alias_defaults': "{'team_id': %s}" % helpdesk_team1.id,
|
|
})
|
|
self.assertEqual((mail_alias0 + mail_alias1).alias_domain_id, self.mail_alias_domain)
|
|
|
|
new_message0 = f"""MIME-Version: 1.0
|
|
Date: Thu, 27 Dec 2018 16:27:45 +0100
|
|
Message-ID: blablabla0
|
|
Subject: helpdesk team 0 in company 0
|
|
From: A client <client_a@someprovider.com>
|
|
To: {mail_alias0.display_name}
|
|
Content-Type: multipart/alternative; boundary="000000000000a47519057e029630"
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/plain; charset="UTF-8"
|
|
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/html; charset="UTF-8"
|
|
Content-Transfer-Encoding: quoted-printable
|
|
|
|
<div>A good message</div>
|
|
|
|
--000000000000a47519057e029630--
|
|
"""
|
|
|
|
new_message1 = f"""MIME-Version: 1.0
|
|
Date: Thu, 27 Dec 2018 16:27:45 +0100
|
|
Message-ID: blablabla1
|
|
Subject: helpdesk team 1 in company 1
|
|
From: B client <client_b@someprovider.com>
|
|
To: {mail_alias1.display_name}
|
|
Content-Type: multipart/alternative; boundary="000000000000a47519057e029630"
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/plain; charset="UTF-8"
|
|
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/html; charset="UTF-8"
|
|
Content-Transfer-Encoding: quoted-printable
|
|
|
|
<div>A good message bis</div>
|
|
|
|
--000000000000a47519057e029630--
|
|
"""
|
|
partners_exist = Partner.search([('email', 'in', ['client_a@someprovider.com', 'client_b@someprovider.com'])])
|
|
self.assertFalse(partners_exist)
|
|
|
|
helpdesk_ticket0_id = self.env['mail.thread'].message_process(False, new_message0)
|
|
helpdesk_ticket1_id = self.env['mail.thread'].message_process(False, new_message1)
|
|
self.env.cr.flush() # trigger pre-commit
|
|
helpdesk_ticket0 = self.env['helpdesk.ticket'].browse(helpdesk_ticket0_id)
|
|
helpdesk_ticket1 = self.env['helpdesk.ticket'].browse(helpdesk_ticket1_id)
|
|
|
|
self.assertEqual(helpdesk_ticket0.team_id, helpdesk_team0)
|
|
self.assertEqual(helpdesk_ticket1.team_id, helpdesk_team1)
|
|
|
|
self.assertEqual(helpdesk_ticket0.company_id, company0)
|
|
self.assertEqual(helpdesk_ticket1.company_id, company1)
|
|
|
|
partner0 = Partner.search([('email', '=', 'client_a@someprovider.com')])
|
|
partner1 = Partner.search([('email', '=', 'client_b@someprovider.com')])
|
|
self.assertTrue(partner0)
|
|
self.assertTrue(partner1)
|
|
|
|
self.assertEqual(partner0.company_id, company0)
|
|
self.assertEqual(partner1.company_id, company1)
|
|
|
|
self.assertEqual(partner0.name, "A client")
|
|
self.assertEqual(partner1.name, "B client")
|
|
|
|
self.assertEqual(helpdesk_ticket0.partner_id, partner0)
|
|
self.assertEqual(helpdesk_ticket1.partner_id, partner1)
|
|
|
|
self.assertTrue(partner0 in helpdesk_ticket0.message_follower_ids.mapped('partner_id'))
|
|
self.assertTrue(partner1 in helpdesk_ticket1.message_follower_ids.mapped('partner_id'))
|
|
|
|
def test_ticket_sequence_created_from_multi_company(self):
|
|
"""
|
|
In this test we ensure that in a multi-company environment, mail sent to helpdesk team
|
|
create a ticket with the right sequence.
|
|
"""
|
|
company0 = self.env.company
|
|
company1 = self.env['res.company'].create({'name': 'new_company0'})
|
|
|
|
self.env.user.write({
|
|
'company_ids': [(4, company0.id, False), (4, company1.id, False)],
|
|
})
|
|
|
|
helpdesk_team_model = self.env['ir.model'].search([('model', '=', 'helpdesk_team')])
|
|
ticket_model = self.env['ir.model'].search([('model', '=', 'helpdesk.ticket')])
|
|
|
|
helpdesk_team0 = self.env['helpdesk.team'].create({
|
|
'name': 'helpdesk team 0',
|
|
'company_id': company0.id,
|
|
})
|
|
helpdesk_team1 = self.env['helpdesk.team'].create({
|
|
'name': 'helpdesk team 1',
|
|
'company_id': company1.id,
|
|
})
|
|
|
|
_mail_alias_0, mail_alias_1 = self.env['mail.alias'].create([
|
|
{
|
|
'alias_name': 'helpdesk_team_0',
|
|
'alias_model_id': ticket_model.id,
|
|
'alias_parent_model_id': helpdesk_team_model.id,
|
|
'alias_parent_thread_id': helpdesk_team0.id,
|
|
'alias_defaults': "{'team_id': %s}" % helpdesk_team0.id,
|
|
},
|
|
{
|
|
'alias_name': 'helpdesk_team_1',
|
|
'alias_model_id': ticket_model.id,
|
|
'alias_parent_model_id': helpdesk_team_model.id,
|
|
'alias_parent_thread_id': helpdesk_team1.id,
|
|
'alias_defaults': "{'team_id': %s}" % helpdesk_team1.id,
|
|
}
|
|
])
|
|
|
|
new_message1 = f"""MIME-Version: 1.0
|
|
Date: Thu, 27 Dec 2018 16:27:45 +0100
|
|
Message-ID: blablabla1
|
|
Subject: helpdesk team 1 in company 1
|
|
From: B client <client_b@someprovider.com>
|
|
To: {mail_alias_1.display_name}
|
|
Content-Type: multipart/alternative; boundary="000000000000a47519057e029630"
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/plain; charset="UTF-8"
|
|
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/html; charset="UTF-8"
|
|
Content-Transfer-Encoding: quoted-printable
|
|
|
|
<div>A good message bis</div>
|
|
|
|
--000000000000a47519057e029630--
|
|
"""
|
|
self.env['ir.sequence'].create([
|
|
{
|
|
'company_id': company0.id,
|
|
'name': 'test-sequence-00',
|
|
'prefix': 'FirstCompany',
|
|
'code': 'helpdesk.ticket'
|
|
},
|
|
{
|
|
'company_id': company1.id,
|
|
'name': 'test-sequence-01',
|
|
'prefix': 'SecondCompany',
|
|
'code': 'helpdesk.ticket'
|
|
}
|
|
])
|
|
|
|
helpdesk_ticket1_id = self.env['mail.thread'].message_process('helpdesk.ticket', new_message1)
|
|
helpdesk_ticket1 = self.env['helpdesk.ticket'].browse(helpdesk_ticket1_id)
|
|
self.assertTrue(helpdesk_ticket1.ticket_ref.startswith('SecondCompany'))
|
|
|
|
def test_email_non_ascii(self):
|
|
"""
|
|
Ensure that non-ascii characters are correctly handled in partner email addresses
|
|
"""
|
|
new_message = """MIME-Version: 1.0
|
|
Date: Thu, 27 Dec 2018 16:27:45 +0100
|
|
Message-ID: blablabla1
|
|
Subject: helpdesk team 1 in company 1
|
|
From: Client with a §tràÑge name <client_b@someprovaîdère.com>
|
|
To: helpdesk_team@test.mycompany.com
|
|
Content-Type: multipart/alternative; boundary="000000000000a47519057e029630"
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/plain; charset="UTF-8"
|
|
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/html; charset="UTF-8"
|
|
Content-Transfer-Encoding: quoted-printable
|
|
|
|
<div>A good message ter</div>
|
|
|
|
--000000000000a47519057e029630--
|
|
"""
|
|
helpdesk_ticket = self.env['mail.thread'].message_process('helpdesk.ticket', new_message)
|
|
helpdesk_ticket = self.env['helpdesk.ticket'].browse(helpdesk_ticket)
|
|
|
|
self.assertEqual(helpdesk_ticket.partner_id.name, "Client with a §tràÑge name")
|
|
self.assertEqual(helpdesk_ticket.partner_id.email, "client_b@someprovaîdère.com")
|
|
self.assertEqual(helpdesk_ticket.partner_email, "client_b@someprovaîdère.com")
|
|
|
|
def test_email_without_mail_template(self):
|
|
"""
|
|
A mail sent to the alias without mail template on the stage should also create a partner
|
|
"""
|
|
stage = self.test_team._determine_stage()[self.test_team.id]
|
|
stage.template_id = False
|
|
|
|
helpdesk_ticket = self.env['mail.thread'].message_process('helpdesk.ticket', self.email_to_alias)
|
|
helpdesk_ticket = self.env['helpdesk.ticket'].browse(helpdesk_ticket)
|
|
|
|
self.assertEqual(helpdesk_ticket.partner_id.name, "Client A")
|
|
|
|
def test_email_with_mail_template_portal_user(self):
|
|
"""
|
|
Portal users receive an email when they create a ticket
|
|
"""
|
|
self.stage_new.template_id = self.env.ref('helpdesk.new_ticket_request_email_template')
|
|
self.helpdesk_portal.email = self.email_to_alias_from
|
|
|
|
helpdesk_ticket = self.env['mail.thread'].message_process('helpdesk.ticket', self.email_to_alias)
|
|
helpdesk_ticket = self.env['helpdesk.ticket'].browse(helpdesk_ticket)
|
|
self.assertEqual(helpdesk_ticket.partner_id, self.helpdesk_portal.partner_id)
|
|
|
|
self.flush_tracking()
|
|
|
|
# check that when a portal user creates a ticket there is two message on the ticket:
|
|
# - the creation message note
|
|
# - the mail from the stage mail template
|
|
template_msg, creation_log = helpdesk_ticket.message_ids
|
|
self.assertEqual(template_msg.subtype_id, self.env.ref('mail.mt_note'))
|
|
self.assertEqual(creation_log.subtype_id, self.env.ref('helpdesk.mt_ticket_new'))
|
|
|
|
def test_email_with_mail_template_internal_user(self):
|
|
"""
|
|
Internal users receive an email when they create a ticket by email.
|
|
"""
|
|
self.stage_new.template_id = self.env.ref('helpdesk.new_ticket_request_email_template')
|
|
self.helpdesk_user.email = self.email_to_alias_from
|
|
|
|
helpdesk_ticket = self.env['mail.thread'].message_process('helpdesk.ticket', self.email_to_alias)
|
|
helpdesk_ticket = self.env['helpdesk.ticket'].browse(helpdesk_ticket)
|
|
self.assertEqual(helpdesk_ticket.partner_id, self.helpdesk_user.partner_id)
|
|
|
|
self.flush_tracking()
|
|
|
|
# check that when an internal user creates a ticket there is two messages on the ticket:
|
|
# - the creation message note
|
|
# - the mail from the stage mail template
|
|
template_msg, creation_log = helpdesk_ticket.message_ids
|
|
self.assertEqual(template_msg.subtype_id, self.env.ref('mail.mt_note'))
|
|
self.assertEqual(creation_log.subtype_id, self.env.ref('helpdesk.mt_ticket_new'))
|
|
|
|
def test_team_assignation_balanced_sla(self):
|
|
#We create an sla policy with minimum priority set as '2'
|
|
self.test_team.use_sla = True
|
|
sla = self.env['helpdesk.sla'].create({
|
|
'name': 'test sla policy',
|
|
'team_id': self.test_team.id,
|
|
'stage_id': self.stage_progress.id,
|
|
'priority': '2',
|
|
'time': 1,
|
|
})
|
|
|
|
#We create a ticket with priority less than what's on the sla policy
|
|
ticket_1 = self.env['helpdesk.ticket'].create({
|
|
'name': 'test ',
|
|
'team_id': self.test_team.id,
|
|
'priority': '1'
|
|
})
|
|
|
|
#We create a ticket with priority equal to what's on the sla policy
|
|
ticket_2 = self.env['helpdesk.ticket'].create({
|
|
'name': 'test sla ticket',
|
|
'team_id': self.test_team.id,
|
|
'priority': '2'
|
|
})
|
|
|
|
#We create a ticket with priority greater than what's on the sla policy
|
|
ticket_3 = self.env['helpdesk.ticket'].create({
|
|
'name': 'test sla ticket',
|
|
'team_id': self.test_team.id,
|
|
'priority': '3'
|
|
})
|
|
#We confirm that the sla policy has been applied successfully on the ticket.
|
|
#sla policy must not be applied
|
|
self.assertTrue(sla not in ticket_1.sla_status_ids.mapped('sla_id'))
|
|
self.assertTrue(sla not in ticket_3.sla_status_ids.mapped('sla_id'))
|
|
#sla policy must be applied
|
|
self.assertTrue(sla in ticket_2.sla_status_ids.mapped('sla_id'))
|
|
|
|
def test_automatic_ticket_closing(self):
|
|
self.test_team.write({
|
|
'auto_close_ticket': True,
|
|
'auto_close_day': 7,
|
|
'to_stage_id': self.stage_cancel.id,
|
|
})
|
|
|
|
create_ticket = lambda stage_id: self.env['helpdesk.ticket'].create({
|
|
'name': 'Ticket 1',
|
|
'team_id': self.test_team.id,
|
|
'stage_id': stage_id,
|
|
})
|
|
|
|
ticket_1 = create_ticket(self.stage_new.id)
|
|
ticket_2 = create_ticket(self.stage_progress.id)
|
|
ticket_3 = create_ticket(self.stage_done.id)
|
|
|
|
with freeze_time(datetime.now() + relativedelta(days=10)):
|
|
self.test_team._cron_auto_close_tickets()
|
|
|
|
# With no from_stage_ids, all tickets from non closing stages should be moved
|
|
self.assertEqual(ticket_1.stage_id, self.stage_cancel)
|
|
self.assertEqual(ticket_2.stage_id, self.stage_cancel)
|
|
self.assertEqual(ticket_3.stage_id, self.stage_done)
|
|
|
|
self.test_team.from_stage_ids |= self.stage_progress
|
|
ticket_4 = create_ticket(self.stage_new.id)
|
|
ticket_5 = create_ticket(self.stage_progress.id)
|
|
ticket_6 = create_ticket(self.stage_done.id)
|
|
|
|
with freeze_time(datetime.now() + relativedelta(days=10)):
|
|
self.test_team._cron_auto_close_tickets()
|
|
|
|
# Only tasks in the stages in from_stage_ids should be moved
|
|
self.assertEqual(ticket_4.stage_id, self.stage_new)
|
|
self.assertEqual(ticket_5.stage_id, self.stage_cancel)
|
|
self.assertEqual(ticket_6.stage_id, self.stage_done)
|
|
|
|
ticket_7 = create_ticket(self.stage_progress.id)
|
|
|
|
with freeze_time(datetime.now() + relativedelta(days=5)):
|
|
self.test_team._cron_auto_close_tickets()
|
|
|
|
# Tickets under the threshold should not be moved (5 < 7)
|
|
self.assertEqual(ticket_7.stage_id, self.stage_progress)
|
|
|
|
def test_create_from_email(self):
|
|
with freeze_time('2018-12-27 00:00:00'):
|
|
helpdesk_ticket = self.env['helpdesk.ticket'].create({'name': 'Hi! How was your day?'})
|
|
|
|
customer_partner = self.env['res.partner'].create({'name': 'Luc Mélanchetout'})
|
|
helpdesk_partner = self.helpdesk_user.partner_id
|
|
|
|
# hours utc to fit in 08:00 - 17:00 belgian calendar
|
|
hours_and_authors = [
|
|
('08', customer_partner),
|
|
('09', helpdesk_partner), # 2h since creation (= first_response_hours)
|
|
('10', helpdesk_partner),
|
|
('11', customer_partner),
|
|
('12', customer_partner),
|
|
('14', helpdesk_partner), # + 2h since last customer's message (3h - 1h break)
|
|
('15', customer_partner),
|
|
('16', helpdesk_partner), # + 1h since last customer's message
|
|
] # -----
|
|
# = 5h /3responses = 1.67h /response (= avg_response_hours)
|
|
comment_subtype = self.env.ref('mail.mt_comment')
|
|
email_vals = {
|
|
'model': 'helpdesk.ticket',
|
|
'res_id': helpdesk_ticket.id,
|
|
'body': 'Good, you?',
|
|
'subtype_id': comment_subtype.id,
|
|
}
|
|
email_vals_list = []
|
|
for hour, author in hours_and_authors:
|
|
temp_email_vals = email_vals.copy()
|
|
temp_email_vals.update({
|
|
'author_id': author.id,
|
|
'date': '2018-12-27 %s:00:00' % hour,
|
|
})
|
|
email_vals_list.append(temp_email_vals)
|
|
helpdesk_ticket.website_message_ids = self.env['mail.message'].create(email_vals_list)
|
|
self.assertEqual(helpdesk_ticket.first_response_hours, 2.0)
|
|
self.assertEqual(helpdesk_ticket.avg_response_hours, 5 / 3)
|
|
|
|
def test_ticket_count_according_to_partner(self):
|
|
# 1) create a partner
|
|
partner = self.env['res.partner'].create({
|
|
'name': 'Freddy Krueger'
|
|
})
|
|
|
|
# 2) create one open and one closed ticket
|
|
open_ticket, closed_ticket = self.env['helpdesk.ticket'].with_user(self.helpdesk_user).create([{
|
|
'name': 'open ticket',
|
|
'team_id': self.test_team.id,
|
|
'partner_id': partner.id,
|
|
}, {
|
|
'name': 'solved ticket',
|
|
'team_id': self.test_team.id,
|
|
'partner_id': partner.id,
|
|
'stage_id': self.stage_done.id,
|
|
}])
|
|
|
|
# 3) check ticket count according to partner ticket
|
|
self.assertEqual(open_ticket.partner_open_ticket_count, 0, "There should be no other open ticket than this one for this partner")
|
|
self.assertEqual(open_ticket.partner_ticket_count, 1, "There should be one other ticket than this one for this partner")
|
|
self.assertEqual(closed_ticket.partner_open_ticket_count, 1, "There should be one other open ticket than this one for this partner")
|
|
self.assertEqual(closed_ticket.partner_ticket_count, 1, "There should be one other ticket than this one for this partner")
|
|
|
|
def test_create_ticket_in_batch_with_email_cc(self):
|
|
user_a, user_b, user_c = self.env['res.users'].create([{
|
|
'name': 'user A',
|
|
'login': 'loginA',
|
|
'email': 'email@bisous1',
|
|
}, {
|
|
'name': 'user B',
|
|
'login': 'loginB',
|
|
'email': 'email@bisous2',
|
|
}, {
|
|
'name': 'user C',
|
|
'login': 'loginC',
|
|
'email': 'email@bisous3',
|
|
}])
|
|
partner_a, partner_b = self.env['res.partner'].create([{
|
|
'name': 'partner A',
|
|
'email': 'email@bisous4',
|
|
}, {
|
|
'name': 'partner B',
|
|
}])
|
|
ticket_1, ticket_2 = self.env['helpdesk.ticket'].with_context({'mail_create_nolog': True}).create([{
|
|
'name': 'ticket 1',
|
|
'team_id': self.test_team.id,
|
|
'email_cc': 'email@bisous1, email@bisous2, email@bisous4',
|
|
'partner_id': partner_b.id,
|
|
}, {
|
|
'name': 'ticket 2',
|
|
'team_id': self.test_team.id,
|
|
'email_cc': 'email@bisous3, email@bisous2, email@bisous4'
|
|
}])
|
|
self.assertTrue(user_a.partner_id in ticket_1.message_partner_ids)
|
|
self.assertTrue(user_b.partner_id in ticket_1.message_partner_ids)
|
|
self.assertFalse(user_c.partner_id in ticket_1.message_partner_ids)
|
|
self.assertFalse(partner_a in ticket_1.message_partner_ids)
|
|
self.assertTrue(partner_b in ticket_1.message_partner_ids)
|
|
self.assertFalse(user_a.partner_id in ticket_2.message_partner_ids)
|
|
self.assertTrue(user_b.partner_id in ticket_2.message_partner_ids)
|
|
self.assertTrue(user_c.partner_id in ticket_2.message_partner_ids)
|
|
self.assertFalse(partner_a in ticket_2.message_partner_ids)
|
|
self.assertFalse(partner_b in ticket_2.message_partner_ids)
|
|
|
|
@users('hm')
|
|
def test_mail_alias_after_helpdesk_team_creation(self):
|
|
team_1, team_2, team_3 = self.env['helpdesk.team'].with_context({'mail_create_nolog': True}).create([
|
|
{'name': 'Telecom Team', 'use_alias': True},
|
|
{'name': 'telecom', 'use_alias': True},
|
|
{'name': 'Telecom Team', 'use_alias': True},
|
|
])
|
|
for team in (team_1, team_2, team_3):
|
|
self.assertTrue(team.alias_id, 'Alias should be created')
|
|
self.assertTrue(team.use_alias, 'Alias feature should be enabled')
|
|
|
|
self.assertEqual(team_1.alias_id.alias_name, 'telecom-team', 'Alias name should be telecom-team')
|
|
self.assertEqual(team_2.alias_id.alias_name, 'telecom', 'Alias name should be telecom')
|
|
self.assertEqual(team_3.alias_id.alias_name, 'telecom-team-2', 'Alias name should be telecom-team-2')
|
|
|
|
@users('hm')
|
|
def test_helpdesk_team_members_fallback(self):
|
|
helpdesk_form = Form(self.env['helpdesk.team'])
|
|
helpdesk_form.name = 'test team 2'
|
|
helpdesk_form.auto_assignment = True
|
|
helpdesk_form.member_ids.clear()
|
|
helpdesk_form.auto_assignment = False
|
|
helpdesk = helpdesk_form.save()
|
|
|
|
self.assertEqual(helpdesk.member_ids, self.env.user)
|
|
|
|
def test_create_from_email_new_customer_ticket_description(self):
|
|
Partner = self.env['res.partner']
|
|
|
|
new_message = """MIME-Version: 1.0
|
|
Date: Thu, 27 Dec 2018 16:27:45 +0100
|
|
Message-ID: blablabla0
|
|
Subject: new customer
|
|
From: A client <client_a@someprovider.com>
|
|
To: helpdesk_team@aqualung.com
|
|
Content-Type: multipart/alternative; boundary="000000000000a47519057e029630"
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/plain; charset="UTF-8"
|
|
|
|
|
|
--000000000000a47519057e029630
|
|
Content-Type: text/html; charset="UTF-8"
|
|
Content-Transfer-Encoding: quoted-printable
|
|
|
|
should be in the ticket's description
|
|
|
|
--000000000000a47519057e029630--
|
|
"""
|
|
|
|
partner_exist = Partner.search([('email', 'in', ['client_a@someprovider.com'])])
|
|
self.assertFalse(partner_exist, "Partner should not exist")
|
|
|
|
helpdesk_ticket_id = self.env['mail.thread'].message_process('helpdesk.ticket', new_message)
|
|
helpdesk_ticket = self.env['helpdesk.ticket'].browse(helpdesk_ticket_id)
|
|
|
|
partner = Partner.search([('email', '=', 'client_a@someprovider.com')])
|
|
self.assertTrue(partner, "Partner should be created")
|
|
|
|
self.assertEqual(helpdesk_ticket.partner_id, partner)
|
|
|
|
self.assertEqual(helpdesk_ticket.description, Markup("<p>should be in the ticket's description\n</p>"), "the email body should be in the ticket's description")
|
|
|
|
def test_create_ticket_cc(self):
|
|
''' Make sure creating a ticket with an email_cc field creates a follower. '''
|
|
ticket = self.env['helpdesk.ticket'].create({
|
|
'partner_name': 'Test Name',
|
|
'partner_email': 'testmail@test.com',
|
|
'name': 'Ticket Name',
|
|
'email_cc': 'testcc@test.com',
|
|
})
|
|
follow = self.env['mail.followers'].search([
|
|
('res_model', '=', 'helpdesk.ticket'),
|
|
('res_id', '=', ticket.id),
|
|
], limit=1)
|
|
self.assertTrue(follow)
|
|
|
|
def test_create_from_internal_for_internal(self):
|
|
"""
|
|
Test that we can create a ticket from an internal user for an internal user, without raising any access error.
|
|
Also test that empty phone number doesn't overwrite the partner's phone number.
|
|
"""
|
|
user = self.env['res.users'].create({
|
|
'name': 'User',
|
|
'login': 'user',
|
|
'email': 'user@user.com',
|
|
'groups_id': [(6, 0, [self.env.ref('helpdesk.group_helpdesk_manager').id,
|
|
self.env.ref('base.group_partner_manager').id])],
|
|
})
|
|
|
|
self.assertFalse(self.helpdesk_user.partner_id.phone)
|
|
ticket = self.env['helpdesk.ticket'].with_user(user).create({
|
|
'name': 'test ticket 1',
|
|
'team_id': self.test_team.id,
|
|
'partner_id': self.helpdesk_user.partner_id.id,
|
|
'partner_phone': '123'
|
|
})
|
|
self.assertEqual(self.helpdesk_user.partner_id.phone, ticket.partner_phone)
|
|
ticket = self.env['helpdesk.ticket'].with_user(self.helpdesk_user).create({
|
|
'name': 'test ticket 2',
|
|
'team_id': self.test_team.id,
|
|
'partner_id': self.helpdesk_user.partner_id.id,
|
|
'partner_phone': ''
|
|
})
|
|
self.assertEqual(self.helpdesk_user.partner_id.phone, '123')
|
|
|
|
def test_ticket_display_name(self):
|
|
"""
|
|
Test to verify that the display_name should not display the ID of its record when
|
|
it is not yet defined, leading to the display of '#False' in the interface.
|
|
Additionally test the display of partner_name in the display_name when passed in context.
|
|
|
|
The ticket is created in cache with the method `new` to allow the display_name
|
|
to be computed with the ticket_id still being `False`.
|
|
"""
|
|
ticket = self.env['helpdesk.ticket'].new({
|
|
'name': "test ticket",
|
|
'partner_id': self.partner.id
|
|
})
|
|
self.assertEqual(ticket.display_name, "test ticket")
|
|
|
|
# create a record with the values passed from above ticket
|
|
record = self.env['helpdesk.ticket'].create({
|
|
'name': ticket.name,
|
|
'partner_id': ticket.partner_id.id
|
|
})
|
|
# verify that the ticket_ref is now added to the display_name
|
|
self.assertEqual(record.display_name, f"test ticket (#{record.ticket_ref})")
|
|
|
|
# create another record with the partner_name in the context
|
|
record_partner = self.env['helpdesk.ticket'].with_context(with_partner=True).create({
|
|
'name': "test ticket with partner",
|
|
'partner_id': self.partner.id
|
|
})
|
|
# verify that the partner_name is now added to the display_name
|
|
self.assertEqual(record_partner.display_name,
|
|
f"test ticket with partner (#{record_partner.ticket_ref}) - {self.partner.name}")
|
|
|
|
def test_helpdesk_team_with_deleted_user(self):
|
|
user = self.env['res.users'].create({
|
|
'name': 'demo user',
|
|
'login': 'login',
|
|
})
|
|
|
|
helpdesk_team1 = self.env['helpdesk.team'].create({
|
|
'name': 'helpdesk team1',
|
|
'company_id': self.env.company.id,
|
|
'auto_assignment': True,
|
|
'assign_method': 'randomly',
|
|
'member_ids': [(6, 0, [user.id])],
|
|
})
|
|
|
|
helpdesk_team2 = self.env['helpdesk.team'].create({
|
|
'name': 'helpdesk team2',
|
|
'company_id': self.env.company.id,
|
|
'auto_assignment': True,
|
|
'assign_method': 'balanced',
|
|
'member_ids': [(6, 0, [user.id])],
|
|
})
|
|
|
|
user.unlink()
|
|
|
|
ticket1 = self.env['helpdesk.ticket'].create({
|
|
'name': 'test ticket1',
|
|
'team_id': helpdesk_team1.id,
|
|
})
|
|
|
|
ticket2 = self.env['helpdesk.ticket'].create({
|
|
'name': 'test ticket2',
|
|
'team_id': helpdesk_team2.id,
|
|
})
|
|
|
|
self.assertFalse(ticket1.user_id)
|
|
self.assertFalse(ticket2.user_id)
|