Debian Codegraph @

addons/sale_project/tests/test_sale_project.py

raw
1 # Part of Odoo. See LICENSE file for full copyright and licensing details.
2
3 from odoo import Command
4 from odoo.fields import Datetime
5 from odoo.tests import Form, new_test_user, tagged
6 from odoo.exceptions import UserError
7
8 from .common import TestSaleProjectCommon
9
10
11 @tagged('post_install', '-at_install')
12 class TestSaleProject(TestSaleProjectCommon):
13
14 @classmethod
15 def setUpClass(cls):
16 super().setUpClass()
17
18 cls.project_plan, _other_plans = cls.env['account.analytic.plan']._get_all_plans()
19 cls.analytic_plan = cls.env['account.analytic.plan'].create({
20 'name': 'Plan Test',
21 })
22 cls.analytic_account_sale = cls.env['account.analytic.account'].create({
23 'name': 'Project for selling timesheet - AA',
24 'plan_id': cls.analytic_plan.id,
25 'code': 'AA-2030'
26 })
27 cls.analytic_account = cls.env['account.analytic.account'].create({
28 'name': 'Main AA of Project',
29 'plan_id': cls.project_plan.id,
30 })
31
32 # Create projects
33 cls.project_global = cls.env['project.project'].create({
34 'name': 'Global Project',
35 'account_id': cls.analytic_account.id,
36 cls.analytic_plan._column_name(): cls.analytic_account_sale.id,
37 'allow_billable': True,
38 })
39 cls.project_template = cls.env['project.project'].create({
40 'name': 'Project TEMPLATE for services',
41 })
42 cls.project_template_state = cls.env['project.task.type'].create({
43 'name': 'Only stage in project template',
44 'sequence': 1,
45 'project_ids': [(4, cls.project_template.id)]
46 })
47 cls.task_template = cls.env['project.task'].create({
48 'name': 'test task template',
49 'project_id': cls.project_template.id,
50 'is_template': True,
51 })
52
53 # Create service products
54 uom_hour = cls.env.ref('uom.product_uom_hour')
55
56 cls.product_order_service1 = cls.env['product.product'].create({
57 'name': "Service Ordered, create no task",
58 'standard_price': 11,
59 'list_price': 13,
60 'type': 'service',
61 'invoice_policy': 'order',
62 'uom_id': uom_hour.id,
63 'default_code': 'SERV-ORDERED1',
64 'service_tracking': 'no',
65 'project_id': False,
66 })
67 cls.product_order_service2 = cls.env['product.product'].create({
68 'name': "Service Ordered, create task in global project",
69 'standard_price': 30,
70 'list_price': 90,
71 'type': 'service',
72 'invoice_policy': 'order',
73 'uom_id': uom_hour.id,
74 'default_code': 'SERV-ORDERED2',
75 'service_tracking': 'task_global_project',
76 'project_id': cls.project_global.id,
77 })
78 cls.product_order_service3 = cls.env['product.product'].create({
79 'name': "Service Ordered, create task in new project",
80 'standard_price': 10,
81 'list_price': 20,
82 'type': 'service',
83 'invoice_policy': 'order',
84 'uom_id': uom_hour.id,
85 'default_code': 'SERV-ORDERED3',
86 'service_tracking': 'task_in_project',
87 'project_id': False, # will create a project
88 })
89 cls.product_order_service4 = cls.env['product.product'].create({
90 'name': "Service Ordered, create project only",
91 'standard_price': 15,
92 'list_price': 30,
93 'type': 'service',
94 'invoice_policy': 'order',
95 'uom_id': uom_hour.id,
96 'default_code': 'SERV-ORDERED4',
97 'service_tracking': 'project_only',
98 'project_id': False,
99 })
100
101 # Create partner
102 cls.partner = cls.env['res.partner'].create({'name': "Mur en béton"})
103
104 # Create additional analytic plans at setup to avoid adding fields in project.project between tests
105 cls.analytic_plan_1 = cls.env['account.analytic.plan'].create({'name': 'Sale Project Plan 1'})
106 cls.analytic_plan_2 = cls.env['account.analytic.plan'].create({'name': 'Sale Project Plan 2'})
107
108 def test_sale_order_with_project_task(self):
109 SaleOrder = self.env['sale.order'].with_context(tracking_disable=True)
110 SaleOrderLine = self.env['sale.order.line'].with_context(tracking_disable=True)
111
112 sale_order = SaleOrder.create({
113 'partner_id': self.partner.id,
114 'partner_invoice_id': self.partner.id,
115 'partner_shipping_id': self.partner.id,
116 })
117 so_line_order_no_task = SaleOrderLine.create({
118 'product_id': self.product_order_service1.id,
119 'product_uom_qty': 10,
120 'order_id': sale_order.id,
121 })
122
123 so_line_order_task_in_global = SaleOrderLine.create({
124 'name': f"{self.product_order_service2.display_name}\nDescription for global task.",
125 'product_id': self.product_order_service2.id,
126 'product_uom_qty': 10,
127 'order_id': sale_order.id,
128 })
129
130 self.product_order_service3.description_sale = "Task in New Project"
131 so_line_order_new_task_new_project = SaleOrderLine.create({
132 'name': f"{self.product_order_service3.display_name}\nDescription for new project task.",
133 'product_id': self.product_order_service3.id,
134 'product_uom_qty': 10,
135 'order_id': sale_order.id,
136 })
137 so_line_order_new_task_new_project2 = SaleOrderLine.create({
138 'product_id': self.product_order_service3.id,
139 'product_uom_qty': 10,
140 'order_id': sale_order.id,
141 })
142
143 so_line_order_only_project = SaleOrderLine.create({
144 'product_id': self.product_order_service4.id,
145 'product_uom_qty': 10,
146 'order_id': sale_order.id,
147 })
148 sale_order.action_confirm()
149
150 # service_tracking 'no'
151 self.assertFalse(so_line_order_no_task.project_id, "The project should not be linked to no task product")
152 self.assertFalse(so_line_order_no_task.task_id, "The task should not be linked to no task product")
153 # service_tracking 'task_global_project'
154 self.assertFalse(so_line_order_task_in_global.project_id, "Only task should be created, project should not be linked")
155 self.assertEqual(self.project_global.tasks.sale_line_id, so_line_order_task_in_global, "Global project's task should be linked to so line")
156 self.assertEqual(
157 so_line_order_task_in_global.task_id.name,
158 f"{sale_order.name} - Description for global task.",
159 "Task name in global project should include SO name and the single-line SOL description.",
160 )
161 self.assertFalse(
162 so_line_order_task_in_global.task_id.description,
163 "Task description should be empty for single-line SOL descriptions."
164 )
165 # service_tracking 'task_in_project'
166 self.assertTrue(so_line_order_new_task_new_project.project_id, "Sales order line should be linked to newly created project")
167 self.assertTrue(so_line_order_new_task_new_project.task_id, "Sales order line should be linked to newly created task")
168 self.assertEqual(
169 so_line_order_new_task_new_project.task_id.name,
170 "Description for new project task.",
171 "Task name should be the single-line SOL description.",
172 )
173 self.assertFalse(
174 so_line_order_new_task_new_project.task_id.description,
175 "Task description should be empty for single-line SOL descriptions."
176 )
177 self.assertEqual(
178 so_line_order_new_task_new_project2.task_id.name,
179 self.product_order_service3.description_sale,
180 "Task name should be the product's default sales description."
181 )
182 # service_tracking 'project_only'
183 self.assertFalse(so_line_order_only_project.task_id, "Task should not be created")
184 self.assertTrue(so_line_order_only_project.project_id, "Sales order line should be linked to newly created project")
185
186 self.assertEqual(self.env['sale.order'].search([('tasks_ids', 'in', so_line_order_new_task_new_project.task_id.ids)]), sale_order)
187 self.assertEqual(self.env['sale.order'].search([('tasks_ids', '=', so_line_order_new_task_new_project.task_id.id)]), sale_order)
188 self.assertEqual(self.env['sale.order'].search([('tasks_ids.project_id', '=', so_line_order_new_task_new_project.project_id.id)]), sale_order)
189
190 self.assertEqual(self.project_global._get_sale_order_items(), self.project_global.sale_line_id | self.project_global.tasks.sale_line_id, 'The _get_sale_order_items should returns all the SOLs linked to the project and its active tasks.')
191
192 sale_order_2 = SaleOrder.create({
193 'partner_id': self.partner.id,
194 'partner_invoice_id': self.partner.id,
195 'partner_shipping_id': self.partner.id,
196 })
197 sale_line_1_order_2 = SaleOrderLine.create({
198 'product_id': self.product_order_service1.id,
199 'product_uom_qty': 10,
200 'price_unit': self.product_order_service1.list_price,
201 'order_id': sale_order_2.id,
202 })
203 section_sale_line_order_2 = SaleOrderLine.create({
204 'display_type': 'line_section',
205 'name': 'Test Section',
206 'order_id': sale_order_2.id,
207 })
208 note_sale_line_order_2 = SaleOrderLine.create({
209 'display_type': 'line_note',
210 'name': 'Test Note',
211 'order_id': sale_order_2.id,
212 })
213 sale_order_2.action_confirm()
214 task = self.env['project.task'].create({
215 'name': 'Task',
216 'sale_line_id': sale_line_1_order_2.id,
217 'project_id': self.project_global.id,
218 })
219 self.assertEqual(task.sale_line_id, sale_line_1_order_2)
220 self.assertIn(task.sale_line_id, self.project_global._get_sale_order_items())
221 self.assertEqual(self.project_global._get_sale_orders(), sale_order | sale_order_2)
222
223 sale_order_lines = sale_order.order_line + sale_line_1_order_2 # exclude the Section and Note Sales Order Items
224 sale_items_data = self.project_global.get_sale_items_data(limit=5, with_action=False, section_id='billable_fixed')
225
226 expected_sale_line_dict = {
227 sol_read['id']: sol_read
228 for sol_read in sale_order_lines._read_format(
229 ['display_name', 'product_uom_qty', 'qty_delivered', 'qty_invoiced', 'product_uom_id', 'product_id'])
230 }
231 actual_sol_ids = []
232 for line in sale_items_data['sol_items']:
233 sol_id = line['id']
234 actual_sol_ids.append(sol_id)
235 self.assertIn(sol_id, expected_sale_line_dict)
236 self.assertDictEqual(line, expected_sale_line_dict[sol_id])
237 self.assertNotIn(section_sale_line_order_2.id, actual_sol_ids, 'The section Sales Order Item should not be takken into account in the Sales section of project.')
238 self.assertNotIn(note_sale_line_order_2.id, actual_sol_ids, 'The note Sales Order Item should not be takken into account in the Sales section of project.')
239
240 def test_sol_product_type_update(self):
241 sale_order = self.env['sale.order'].with_context(tracking_disable=True).create({
242 'partner_id': self.partner.id,
243 'partner_invoice_id': self.partner.id,
244 'partner_shipping_id': self.partner.id,
245 })
246 self.product_order_service3.type = 'consu'
247 sale_order_line = self.env['sale.order.line'].create({
248 'order_id': sale_order.id,
249 'name': self.product_order_service3.name,
250 'product_id': self.product_order_service3.id,
251 'product_uom_qty': 5,
252 'price_unit': self.product_order_service3.list_price
253 })
254 self.assertFalse(sale_order_line.is_service, "As the product is consumable, the SOL should not be a service")
255
256 self.product_order_service3.type = 'service'
257 self.assertTrue(sale_order_line.is_service, "As the product is a service, the SOL should be a service")
258
259 def test_cancel_so_linked_to_project(self):
260 """ Test that cancelling a SO linked to a project will not raise an error """
261 # Ensure user don't have edit right access to the project
262 group_sale_manager = self.env.ref('sales_team.group_sale_manager')
263 group_project_user = self.env.ref('project.group_project_user')
264 self.env.user.write({'group_ids': [(6, 0, [group_sale_manager.id, group_project_user.id])]})
265 sale_order = self.env['sale.order'].with_context(tracking_disable=True).create({
266 'partner_id': self.partner.id,
267 'partner_invoice_id': self.partner.id,
268 'partner_shipping_id': self.partner.id,
269 })
270 sale_order_line = self.env['sale.order.line'].create({
271 'name': self.product_order_service2.name,
272 'product_id': self.product_order_service2.id,
273 'order_id': sale_order.id,
274 })
275 self.assertFalse(self.project_global.tasks.sale_line_id, "The project tasks should not be linked to the SOL")
276
277 sale_order.action_confirm()
278 self.assertEqual(self.project_global.tasks.sale_line_id.id, sale_order_line.id, "The project tasks should be linked to the SOL from the SO")
279 #use of sudo() since the env.user does not have the access right to edit projects.
280 self.project_global.sudo().sale_line_id = sale_order_line
281 sale_order.action_cancel()
282
283 def test_links_with_sale_order_line(self):
284 """
285 Check that the subtasks are linked to the correct sale order line.
286 """
287 product_A, product_B, product_C = self.env['product.product'].create([
288 {
289 'name': 'product_A',
290 'lst_price': 100.0,
291 'type': 'service',
292 'service_tracking': 'task_in_project',
293 },
294 {
295 'name': 'product_B',
296 'lst_price': 100.0,
297 'type': 'service',
298 'service_tracking': 'task_in_project',
299 },
300 {
301 'name': 'product_C',
302 'lst_price': 100.0,
303 'type': 'service',
304 'service_tracking': 'task_in_project',
305 },
306 ])
307 sale_order_first, sale_order_second = self.env['sale.order'].create([
308 {
309 'partner_id': self.partner.id,
310 'order_line': [
311 Command.create({'product_id': product_A.id}),
312 Command.create({'product_id': product_B.id}),
313 ]
314 },
315 {
316 'partner_id': self.partner.id,
317 'order_line': [
318 Command.create({'product_id': product_C.id}),
319 ]
320 }
321 ])
322 (sale_order_first + sale_order_second).action_confirm()
323
324 sale_order_line_A = sale_order_first.order_line.filtered(lambda sol: sol.product_id == product_A)
325 sale_order_line_B = sale_order_first.order_line - sale_order_line_A
326 sale_order_line_C = sale_order_second.order_line
327
328 project_first = sale_order_first.project_ids
329 project_second = sale_order_second.project_ids
330
331 task_A = sale_order_first.tasks_ids.filtered(lambda task: task.sale_line_id == sale_order_line_A)
332 task_B = sale_order_first.tasks_ids - task_A
333 task_C = sale_order_second.tasks_ids
334
335 # [CASE 1] Parent in the same project --> use parent's sale order line
336 task_A.write({
337 'child_ids': [
338 Command.create({'name': 'Sub A in first project', 'project_id': project_first.id}),
339 ]
340 })
341 task_B.write({
342 'child_ids': [
343 Command.create({'name': 'Sub B in first project', 'project_id': project_first.id}),
344 ]
345 })
346 task_C.write({
347 'child_ids': [
348 Command.create({'name': 'Sub C in second project', 'project_id': project_second.id}),
349 ]
350 })
351 self.assertEqual(task_A.child_ids.sale_line_id, sale_order_line_A)
352 self.assertEqual(task_B.child_ids.sale_line_id, sale_order_line_B)
353 self.assertEqual(task_C.child_ids.sale_line_id, sale_order_line_C)
354
355 # [CASE 2] Parent in an other project --> use parent's sale_order line
356 task_B.write({
357 'child_ids': [
358 Command.create({'name': 'Sub B in second project', 'project_id': project_second.id}),
359 ]
360 })
361 sub_B_second = task_B.child_ids.filtered(lambda sub: sub.name == 'Sub B in second project')
362 self.assertEqual(sub_B_second.sale_line_id, sale_order_line_B)
363
364 # [CASE 3] Without parent --> use sale order line of the project
365 task_D = self.env['project.task'].create({
366 'name': 'Task D',
367 'project_id': project_first.id,
368 })
369 self.assertEqual(task_D.sale_line_id, project_first.sale_line_id)
370
371 def test_compute_project_and_task_button(self):
372 """
373 Ensures that when a sale order has at least one sol with a service product whose service-policy is either delivered on milestone or ordered prepaid, then the
374 show_create_project_button is set to True. If the sale order also has one project linked to it, then the show_project_and_task_button should be True, and the show_create_button
375 should be updated to False
376 """
377 sale_order_1 = self.env['sale.order'].with_context(tracking_disable=True).create({
378 'partner_id': self.partner.id,
379 'partner_invoice_id': self.partner.id,
380 'partner_shipping_id': self.partner.id,
381 })
382 sale_order_2 = sale_order_1.copy()
383 sale_order_3 = sale_order_1.copy()
384 (sale_order_1 | sale_order_2 | sale_order_3).action_confirm()
385 # consumable product, manual service product
386 self.env['sale.order.line'].create([{
387 'product_id': self.product_consumable.id,
388 'order_id': sale_order_1.id,
389 }])
390 self.assertFalse(sale_order_1.show_project_button, "There is no project on the sale order, the button should be hidden")
391 # add a milestone product
392 line_delivered_milestone = self.env['sale.order.line'].create({
393 'product_id': self.product_service_delivered_milestone.id,
394 'order_id': sale_order_1.id,
395 })
396 # the user does not have project creation right
397 user_wrong_group = new_test_user(self.env, groups='sales_team.group_sale_manager,project.group_project_user', login='wendy', name='wendy')
398 sale_order_1.with_user(user_wrong_group)._compute_show_project_and_task_button()
399 self.assertFalse(sale_order_1.show_create_project_button, "The user does not have the right to create a new project, the button should be hidden")
400 self.assertFalse(sale_order_1.show_project_button, "There is no project on the sale order, the button should be hidden")
401 # the user has project creation right
402 sale_order_1._compute_show_project_and_task_button()
403 self.assertTrue(sale_order_1.show_create_project_button, "There is a product service with the service_policy set on 'delivered on milestone' on the sale order, the button should be displayed")
404 self.assertFalse(sale_order_1.show_project_button, "There is no project on the sale order, the button should be hidden")
405 # add a project to the SO
406 line_delivered_milestone.project_id = self.project_global
407 sale_order_1._compute_show_project_and_task_button()
408 self.assertFalse(sale_order_1.show_create_project_button, "There is a product service with the service_policy set on 'delivered on milestone' and a project on the sale order, the button should be hidden")
409 self.assertTrue(sale_order_1.show_project_button, "There is a product service with the service_policy set on 'delivered on milestone' and a project on the sale order, the button should be displayed")
410
411 # add an ordered_prepaid service product
412 line_prepaid = self.env['sale.order.line'].create({
413 'product_id': self.product_service_ordered_prepaid.id,
414 'order_id': sale_order_2.id,
415 })
416 sale_order_2._compute_show_project_and_task_button()
417 self.assertTrue(sale_order_2.show_create_project_button, "There is a product service with the service_policy set on 'ordered_prepaid' on the sale order, the button should be displayed")
418 self.assertFalse(sale_order_2.show_project_button, "There is no project on the sale order, the button should be hidden")
419 # create a new task, whose sale order item is a sol of the SO
420 task = self.env['project.task'].create({
421 'name': 'Test Task',
422 'project_id': self.project_global.id,
423 'sale_line_id': line_prepaid.id,
424 })
425 sale_order_2._compute_tasks_ids()
426 sale_order_2._compute_show_project_and_task_button()
427 self.assertTrue(sale_order_2.show_create_project_button, "There is a product service with the service_policy set on 'ordered_prepaid' on the sale order, the button should be displayed")
428 self.assertFalse(sale_order_2.show_project_button, "There is no project on the sale order, the button should be hidden")
429 self.assertEqual(sale_order_2.tasks_ids, task)
430 task.action_convert_to_template()
431 sale_order_2._compute_tasks_ids()
432 sale_order_2._compute_show_project_and_task_button()
433 self.assertFalse(sale_order_2.show_project_button, 'The button should no longer be visible since no tasks are linked to the SO.')
434 self.assertFalse(sale_order_2.tasks_ids, 'No tasks should be linked to the SO since the task has been converted into a template.')
435
436 # add a manual service product
437 self.env['sale.order.line'].create({
438 'product_id': self.product_service_delivered_manual.id,
439 'order_id': sale_order_3.id,
440 })
441 sale_order_3._compute_show_project_and_task_button()
442 self.assertTrue(sale_order_3.show_create_project_button, "There is a product service with the service_policy set on 'manual' on the sale order, the button should be displayed")
443 self.assertFalse(sale_order_3.show_project_button, "There is no project on the sale order, the button should be hidden")
444
445 def test_create_task_from_template_line(self):
446 """
447 When we add an SOL from a template that is a service that has a service_policy that will generate a task,
448 even if default_task_id is present in the context, a new task should be created when confirming the SO.
449 """
450 default_task = self.env['project.task'].with_context(tracking_disable=True).create({
451 'name': 'Task',
452 'project_id': self.project_global.id
453 })
454 sale_order = self.env['sale.order'].with_context(tracking_disable=True, default_task_id=default_task.id).create({
455 'partner_id': self.partner.id,
456 })
457 quotation_template = self.env['sale.order.template'].create({
458 'name': 'Test quotation',
459 })
460 quotation_template.write({
461 'sale_order_template_line_ids': [
462 Command.set(
463 self.env['sale.order.template.line'].create([{
464 'name': self.product_order_service2.display_name,
465 'sale_order_template_id': quotation_template.id,
466 'product_id': self.product_order_service2.id,
467 }, {
468 'name': self.product_order_service3.display_name,
469 'sale_order_template_id': quotation_template.id,
470 'product_id': self.product_order_service3.id,
471 }]).ids
472 )
473 ]
474 })
475 sale_order.with_context(default_task_id=default_task.id).write({
476 'sale_order_template_id': quotation_template.id,
477 })
478 sale_order.with_context(default_task_id=default_task.id)._onchange_sale_order_template_id()
479 self.assertFalse(sale_order.order_line.mapped('task_id'),
480 "SOL should have no related tasks, because they are from services that generates a task")
481 sale_order.action_confirm()
482 self.assertEqual(sale_order.tasks_count, 2, "SO should have 2 related tasks")
483 self.assertNotIn(default_task, sale_order.tasks_ids, "SO should link to the default task from the context")
484
485 def test_project_creation_on_so_confirm_with_account(self):
486 # Ensures that the company of the account of the SO is propagated to the project.
487 sale_order = self.env['sale.order'].with_context(tracking_disable=True).create({
488 'partner_id': self.partner.id,
489 'partner_invoice_id': self.partner.id,
490 'partner_shipping_id': self.partner.id,
491 })
492 analytic_account_company = self.env['account.analytic.account'].create({
493 'name': 'Account with company',
494 'plan_id': self.analytic_plan.id,
495 'company_id': self.env.company.id,
496 })
497 analytic_plan_name = self.analytic_plan._column_name()
498 project = self.env['project.project'].create({
499 'name': 'SO Project',
500 analytic_plan_name: analytic_account_company.id,
501 })
502 sale_order.project_id = project
503 self.env['sale.order.line'].create({
504 'name': self.product_order_service2.name,
505 'product_id': self.product_order_service3.id,
506 'order_id': sale_order.id,
507 })
508 self.assertTrue(sale_order.project_id[analytic_plan_name], "The SO should have an analytic account before it is confirmed.")
509 sale_order.action_confirm()
510 self.assertEqual(self.env.company, sale_order.project_id[analytic_plan_name].company_id, "The company of the account should be the company of the SO.")
511 self.assertEqual(sale_order.project_id[analytic_plan_name], sale_order.project_ids[analytic_plan_name], "The project created for the SO and the project of the SO should have the same account.")
512 self.assertEqual(self.env.company, sale_order.project_ids.company_id, "The project created for the SO should have the same company as its account.")
513
514 def test_project_creation_on_so_with_manual_analytic(self):
515 """ Tests that the manually added analytic account (of a plan other than projects) and the project account
516 created when SO is confirmed are both still in the line after confirmation.
517 """
518 analytic_distribution_manual = {str(self.analytic_account_sale.id): 100}
519 sale_order = self.env['sale.order'].create({
520 'partner_id': self.partner.id,
521 'partner_invoice_id': self.partner.id,
522 'partner_shipping_id': self.partner.id,
523 'order_line': [
524 Command.create({
525 'product_id': self.product_order_service3.id,
526 'analytic_distribution': analytic_distribution_manual,
527 }),
528 ],
529 })
530 self.assertEqual(sale_order.order_line.analytic_distribution, analytic_distribution_manual)
531 sale_order.action_confirm()
532 expected_analytic_distribution = {f"{self.analytic_account_sale.id},{sale_order.order_line.project_id.account_id.id}": 100}
533 self.assertEqual(sale_order.order_line.analytic_distribution, expected_analytic_distribution)
534
535 def test_project_on_sol_with_analytic_distribution_model(self):
536 """ If a line has a distribution coming from an analytic distribution model, and the sale order has a project,
537 both the project account and the accounts from the ADM should still be in the line after confirmation.
538 The Project account should appear on all lines if there are several Analytic Distribution Models applying.
539 """
540 # We create one distribution model with two accounts in one line, based on product
541 # and a second model with a different plan, based on partner
542 analytic_account_1 = self.env['account.analytic.account'].create({
543 'name': 'Analytic Account - Plan 1',
544 'plan_id': self.analytic_plan_1.id,
545 })
546 analytic_account_2 = self.env['account.analytic.account'].create({
547 'name': 'Analytic Account - Plan 2',
548 'plan_id': self.analytic_plan_2.id,
549 })
550 distribution_model_product = self.env['account.analytic.distribution.model'].create({
551 'product_id': self.product_a.id,
552 'analytic_distribution': {','.join([str(analytic_account_1.id), str(analytic_account_2.id)]): 100},
553 'company_id': self.company.id,
554 })
555 distribution_model_partner = self.env['account.analytic.distribution.model'].create({
556 'partner_id': self.partner.id,
557 'analytic_distribution': {self.analytic_account_sale.id: 100},
558 'company_id': self.company.id,
559 })
560
561 project = self.env['project.project'].create({
562 'name': 'Project Test',
563 'account_id': self.analytic_account.id,
564 'allow_billable': True,
565 })
566 sale_order = self.env['sale.order'].create({
567 'partner_id': self.partner.id,
568 'partner_invoice_id': self.partner.id,
569 'partner_shipping_id': self.partner.id,
570 'project_id': project.id,
571 'order_line': [
572 Command.create({'product_id': self.product_a.id}),
573 ],
574 })
575
576 expected_analytic_distribution = {
577 f"{analytic_account_1.id},{analytic_account_2.id},{project.account_id.id}": 100,
578 f"{self.analytic_account_sale.id},{project.account_id.id}": 100,
579 }
580 self.assertEqual(sale_order.order_line.analytic_distribution, expected_analytic_distribution)
581
582 # If the project is removed from the SO, only the product's analytic distribution is still in the line
583 sale_order.project_id = None
584 self.assertEqual(
585 sale_order.order_line.analytic_distribution,
586 distribution_model_product.analytic_distribution | distribution_model_partner.analytic_distribution
587 )
588
589 # If project is added and the SO is confirmed, both analytic distributions are in the line
590 sale_order.project_id = project
591 sale_order.action_confirm()
592 self.assertEqual(sale_order.order_line.analytic_distribution, expected_analytic_distribution)
593
594 def test_exclude_archived_projects_in_stat_btn_related_view(self):
595 """Checks if the project stat-button action includes both archived and active projects."""
596 # Setup
597 project_A = self.env['project.project'].create({'name': 'Project_A'})
598 project_B = self.env['project.project'].create({'name': 'Project_B'})
599
600 product_A = self.env['product.product'].create({
601 'name': 'product A',
602 'list_price': 1.0,
603 'type': 'service',
604 'service_tracking': 'task_global_project',
605 'project_id':project_A.id,
606 })
607 product_B = self.env['product.product'].create({
608 'name': 'product B',
609 'list_price': 2.0,
610 'type': 'service',
611 'service_tracking': 'task_global_project',
612 'project_id':project_B.id,
613 })
614
615 sale_order = self.env['sale.order'].with_context(tracking_disable=True).create({
616 'partner_id': self.partner.id,
617 'partner_invoice_id': self.partner.id,
618 'partner_shipping_id': self.partner.id,
619 })
620
621 SaleOrderLine = self.env['sale.order.line'].with_context(tracking_disable=True)
622 SaleOrderLine.create({
623 'name': product_A.name,
624 'product_id': product_A.id,
625 'product_uom_qty': 10,
626 'price_unit': product_A.list_price,
627 'order_id': sale_order.id,
628 })
629 SaleOrderLine.create({
630 'name': product_B.name,
631 'product_id': product_B.id,
632 'product_uom_qty': 10,
633 'price_unit': product_B.list_price,
634 'order_id': sale_order.id,
635 })
636 sale_order._action_confirm()
637
638 def get_project_ids_from_action_domain(action):
639 for el in action['domain']:
640 if len(el) == 3 and el[0] == 'id' and el[1] == 'in':
641 domain_proj_ids = el[2]
642 break
643 else:
644 raise Exception(f"Couldn't find projects ids in the following action domain: {action['domain']}")
645 return domain_proj_ids
646
647 # Check if button action includes both projects BEFORE archivization
648 action = sale_order.action_view_project_ids()
649 self.assertEqual(len(get_project_ids_from_action_domain(action)), 2, "Domain should contain 2 projects.")
650 self.assertEqual(sale_order.project_count, 2, "Expected 2 projects linked to the sale order.")
651
652 # Check if button action includes both projects AFTER archivization
653 project_B.write({'active': False})
654 sale_order._compute_project_ids()
655 self.assertEqual(sale_order.project_count, 1, "Expected 1 project linked to the sale order.")
656
657 action = sale_order.action_view_project_ids()
658 self.assertEqual(
659 action['xml_id'],
660 'project.act_project_project_2_project_task_all',
661 "xml_id mismatch: expected 'project.act_project_project_2_project_task_all', got %s" % action['xml_id']
662 )
663 self.assertEqual(
664 action['type'],
665 'ir.actions.act_window',
666 "type mismatch: expected 'ir.actions.act_window', got %s" % action['type']
667 )
668 self.assertEqual(
669 action['res_model'],
670 'project.task',
671 "res_model mismatch: expected 'project.task', got %s" % action['res_model']
672 )
673
674 def test_sale_order_line_view_form_editable(self):
675 """ Check the behavior of the form view editable of `sale.order.line` introduced in that module
676
677 Test Case:
678 =========
679 1. create SO to use it as default_order_id when the SOL will be created by the editable form
680 2. open form view of `sale.order.line` to create and edit a SOL
681 3. create on the fly a product and check default values of that product
682 3.1. type should be "service"
683 3.2. service_policy should be "ordered_prepaid" (Prepaid/Fixed Price)
684 4. check if the qty_delivered is editable
685 4.1. if sale_timesheet is installed then the field should be readonly otherwise editable
686 5. change the product set on the SOL form view to service product with invoice policy to 'delivered_milestones'
687 6. check if the qty_delivered field is readonly
688 7. change the product set on the SOL form view to service product with invoice policy to 'ordered_prepaid'
689 8. check if the qty_delivered is editable
690 8.1. if sale_timesheet is installed then the field should be readonly otherwise editable
691 9. change the product set on the SOL form view to service product with invoice policy to 'delivered_manual'
692 10. check if the qty_delivered is editable
693 """
694 so = self.env['sale.order'].create({
695 'partner_id': self.partner.id,
696 })
697 so.action_confirm()
698 SaleOrderLine = self.env['sale.order.line'].with_context(default_order_id=so.id)
699 self.assertEqual(self.product_service_ordered_prepaid.service_policy, 'ordered_prepaid')
700 self.assertEqual(self.product_service_delivered_milestone.service_policy, 'delivered_milestones')
701 self.assertEqual(self.product_service_delivered_manual.service_policy, 'delivered_manual')
702 with Form(SaleOrderLine, 'sale_project.sale_order_line_view_form_editable') as sol_form:
703 product_context = sol_form._get_context('product_id')
704 product = sol_form.product_id.with_context(product_context).new({
705 'name': 'Test product',
706 })
707 self.assertEqual(product.type, 'service')
708 self.assertEqual(product.type, 'service')
709 self.assertEqual(product.service_policy, 'ordered_prepaid')
710 sol_form.product_id = product
711 is_readonly = product.service_type != 'manual'
712 self.assertEqual(sol_form._get_modifier('qty_delivered', 'readonly'), is_readonly)
713 if is_readonly:
714 self.assertEqual(sol_form.qty_delivered_method, 'timesheet')
715 self.assertEqual(sol_form.qty_delivered, 0, 'quantity delivered is readonly')
716 else:
717 sol_form.qty_delivered = 1
718 self.assertEqual(sol_form.qty_delivered_method, 'manual')
719 self.assertEqual(sol_form.qty_delivered, 1, 'quantity delivered is editable')
720 sol_form.qty_delivered = 0 # reset for the next test case
721
722 sol_form.product_id = self.product_service_delivered_milestone
723 self.assertTrue(sol_form._get_modifier('qty_delivered', 'readonly'))
724 self.assertEqual(sol_form.qty_delivered_method, 'milestones')
725
726 sol_form.product_id = self.product_service_ordered_prepaid
727 is_readonly = self.product_service_ordered_prepaid.service_type != 'manual'
728 self.assertEqual(sol_form._get_modifier('qty_delivered', 'readonly'), is_readonly)
729 if is_readonly: # then sale_timesheet module installed
730 self.assertEqual(sol_form.qty_delivered_method, 'timesheet')
731 self.assertEqual(sol_form.qty_delivered, 0, 'quantity delivered is readonly')
732 else:
733 sol_form.qty_delivered = 1
734 self.assertEqual(sol_form.qty_delivered_method, 'manual')
735 self.assertEqual(sol_form.qty_delivered, 1, 'quantity delivered is editable')
736 sol_form.qty_delivered = 0 # reset for the next test case
737
738 sol_form.product_id = self.product_service_delivered_manual
739 self.assertFalse(sol_form._get_modifier('qty_delivered', 'readonly'))
740 sol_form.qty_delivered = 1
741 self.assertEqual(sol_form.qty_delivered_method, 'manual')
742 self.assertEqual(sol_form.qty_delivered, 1, 'quantity delivered is editable')
743
744 def test_generated_project_stages(self):
745 """ This test checks that when a project is created on SO confirmation, the following stages are automatically
746 generated for the new project (assuming there is no project template set on the product):
747 - To Do
748 - In Progress
749 - Done
750 - Cancelled
751 """
752 sale_order = self.env['sale.order'].with_context(mail_notrack=True, mail_create_nolog=True).create({
753 'partner_id': self.partner.id,
754 })
755 product = self.env['product.product'].create({
756 'name': "Service with template",
757 'standard_price': 10,
758 'list_price': 20,
759 'type': 'service',
760 'invoice_policy': 'order',
761 'uom_id': self.uom_hour.id,
762 'default_code': 'c1',
763 'service_tracking': 'task_in_project',
764 'project_id': False, # will create a project,
765 'project_template_id': False, # no project template
766 })
767 sale_order_line = self.env['sale.order.line'].create({
768 'order_id': sale_order.id,
769 'name': product.name,
770 'product_id': product.id,
771 'product_uom_qty': 10,
772 'price_unit': product.list_price,
773 })
774 names = ['To Do', 'In Progress', 'Done', 'Cancelled']
775 project = sale_order_line._timesheet_create_project()
776 self.assertEqual(names, project.type_ids.mapped('name'), "The project stages' name should be equal to: %s" % names)
777
778 def test_sale_order_items_of_the_project_status(self):
779 """
780 Checks that the sale order items appearing in the project status display every
781 sale.order.line referrencing a product ignores the notes and sections
782 """
783 project = self.env['project.project'].create({
784 'name': 'Project X',
785 'partner_id': self.partner.id,
786 'allow_billable': True,
787 })
788 sale_order = self.env['sale.order'].create({
789 'partner_id': self.partner.id,
790 'order_line': [
791 Command.create({
792 'product_id': self.product_order_service1.id,
793 'product_uom_qty': 1,
794 }),
795 Command.create({
796 'name': "Section",
797 'display_type': "line_section",
798 }),
799 Command.create({
800 'name': "notes",
801 'display_type': "line_section",
802 }),
803 Command.create({
804 'product_id': self.product_a.id,
805 'product_uom_qty': 1,
806 }),
807 ],
808 'project_id': project.id,
809 })
810 relevant_sale_order_lines = sale_order.order_line.filtered(lambda sol: sol.product_id)
811 reported_sale_order_lines = self.env['sale.order.line'].search(project.action_view_sols()['domain'])
812 self.assertEqual(project.sale_order_line_count, 2)
813 self.assertEqual(relevant_sale_order_lines, reported_sale_order_lines)
814
815 def test_project_tasks_active_on_so_confirm(self):
816 """ Test if project and task are well unarchived when a SO with a service product using a project template
817 is confirmed.
818 """
819 # Create archived Project template with one task
820 self.archived_project_template = self.env['project.project'].create({
821 'name': 'Archived project template',
822 'allow_billable': True,
823 })
824 self.archived_project_template_task = self.env['project.task'].create({
825 'name': 'Task 1',
826 'project_id': self.archived_project_template.id,
827 })
828 self.archived_project_template.active = False
829
830 # Create service product using the project template
831 service_with_project_template = self.env['product.product'].create({
832 'name': 'Service with archived project template',
833 'type': 'service',
834 'invoice_policy': 'order',
835 'service_tracking': 'task_in_project',
836 'project_template_id': self.archived_project_template.id,
837 })
838
839 # Create SO with the service product
840 sale_order = self.env['sale.order'].create({'partner_id': self.partner.id})
841 self.env['sale.order.line'].create({
842 'product_id': service_with_project_template.id,
843 'order_id': sale_order.id,
844 })
845
846 self.assertFalse(len(sale_order.project_ids), "The SO should not have linked project before it is confirmed.")
847 sale_order.action_confirm()
848 self.assertEqual(len(sale_order.project_ids), 1, "The SO should have created project after it is confirmed.")
849 self.assertTrue(sale_order.project_ids.active, "The project should be active when SO is confirmed.")
850 self.assertTrue(all(sale_order.project_ids.with_context(active_test=False).tasks.mapped('active')), "All tasks should be unarchived for the project created when SO is confirmed.")
851
852 def test_sale_order_with_project_task_from_multi_companies(self):
853 uom_hour = self.env.ref("uom.product_uom_hour")
854 will_smith = self.env["res.partner"].create({"name": "Will Smith"})
855 multi_company_project = self.env["project.project"].create({
856 "name": "Multi Company Project",
857 "company_id": None,
858 "allow_billable": True,
859 })
860
861 company_a, company_b = self.env['res.company'].create([
862 {"name": "Company A"},
863 {"name": "Company B"},
864 ])
865
866 # cannot be done in batch because of `_check_sale_product_company` constraint
867 product_a, product_b = (
868 self.env["product.product"].with_company(company).create({
869 "name": "Task Creating Product",
870 "standard_price": 30,
871 "list_price": 90,
872 "type": "service",
873 "service_tracking": "task_global_project",
874 "invoice_policy": "order",
875 "uom_id": uom_hour.id,
876 "project_id": multi_company_project.id,
877 })
878 for company in [company_a, company_b]
879 )
880 sale_order_a, sale_order_b = self.env["sale.order"].create([
881 {
882 "partner_id": will_smith.id,
883 "order_line": [
884 Command.create({
885 "product_id": product.id,
886 "product_uom_qty": 10,
887 }),
888 Command.create({
889 "product_id": product.id,
890 "product_uom_qty": 10,
891 }),
892 ],
893 'company_id': company.id,
894 }
895 for company, product in zip([company_a, company_b], [product_a, product_b])
896 ])
897 (sale_order_a + sale_order_b).action_confirm()
898
899 for company in [company_a, company_b]:
900 self.assertEqual(multi_company_project.with_company(company).sale_order_count, 2, "Expected all sale orders to be counted by project")
901 self.assertEqual(
902 multi_company_project.with_company(company).sale_order_line_count,
903 len(sale_order_a.order_line) + len(sale_order_b.order_line), # expect 4
904 "Expected all sale order lines lines to be counted by project")
905 sale_order_action = multi_company_project.with_company(company).action_view_sos()
906 self.assertEqual(sale_order_action["type"], "ir.actions.act_window")
907 self.assertEqual(sale_order_action["res_model"], "sale.order")
908
909 def test_creating_AA_when_adding_service_to_confirmed_so(self):
910 sale_order = self.env['sale.order'].create({
911 'partner_id': self.partner.id,
912 'partner_invoice_id': self.partner.id,
913 'partner_shipping_id': self.partner.id,
914 })
915
916 self.env['sale.order.line'].create({
917 'product_id': self.product_a.id,
918 'product_uom_qty': 1,
919 'order_id': sale_order.id,
920 })
921
922 sale_order.action_confirm()
923 self.assertFalse(sale_order.project_account_id)
924
925 self.env['sale.order.line'].create({
926 'product_id': self.product_order_service4.id,
927 'product_uom_qty': 1,
928 'order_id': sale_order.id,
929 })
930
931 self.assertTrue(sale_order.project_account_id)
932
933 def test_cancel_multiple_quotations(self):
934 quotations = self.env['sale.order'].create([
935 {
936 'partner_id': self.partner.id,
937 'order_line': [
938 Command.create({'product_id': self.product.id}),
939 ],
940 },
941 {
942 'partner_id': self.partner.id,
943 'order_line': [
944 Command.create({'product_id': self.product.id}),
945 ],
946 }
947 ])
948 quotations._action_cancel()
949 self.assertEqual(set(quotations.mapped('state')), {'cancel'}, "Both quotations are in 'cancel' state.")
950
951 def test_onchange_sale_fields(self):
952 SaleOrder, SaleOrderLine = self.env['sale.order'], self.env['sale.order.line']
953 sale_orders = sale_order_0, sale_order_1 = SaleOrder.create([{'partner_id': self.partner.id}] * 2)
954 sale_order_line_0, sale_order_line_1 = SaleOrderLine.create([{
955 'order_id': sale_order.id,
956 'product_id': self.service_product.id,
957 } for sale_order in sale_orders])
958
959 self.project_global.partner_id = self.partner
960 with Form(self.project_global) as project_form:
961 project_form.sale_line_id = sale_order_line_0
962 self.assertEqual(
963 project_form.reinvoiced_sale_order_id, sale_order_0,
964 "Project's sale order should match its sale order line's order.",
965 )
966 project_form.sale_line_id = SaleOrderLine
967 project_form.reinvoiced_sale_order_id = sale_order_1
968 self.assertEqual(
969 project_form.sale_line_id, sale_order_line_1,
970 "Project's sale order line should match its sale order's first line.",
971 )
972
973 project_form.reinvoiced_sale_order_id = sale_order_0
974 self.assertEqual(
975 project_form.sale_line_id, sale_order_line_1,
976 "Project's sale order line shouldn't have change as it was already set.",
977 )
978
979 project_form.reinvoiced_sale_order_id = sale_order_1
980 project_form.sale_line_id = sale_order_line_0
981 self.assertEqual(
982 project_form.reinvoiced_sale_order_id, sale_order_1,
983 "Project's sale order shouldn't have change as it was already set.",
984 )
985
986 def test_task_compute_sale_order_id(self):
987 """
988 Check whether a task's sale_order_id is set iff its partner_id matches
989 the SO's partner_id, partner_invoice_id, or partner_shipping_id fields.
990 """
991 project_user = new_test_user(
992 self.env,
993 name='Project user',
994 login='Project user',
995 groups='project.group_project_user',
996 )
997 partners = [
998 self.partner, # partner_id
999 self.partner_a, # partner_invoice_id
1000 self.partner_b, # partner_shipping_id
1001 self.env['res.partner'].create({'name': "unrelated partner"}),
1002 ]
1003 sale_order = self.env['sale.order'].with_context(tracking_disable=True).create({
1004 'partner_id': partners[0].id,
1005 'partner_invoice_id': partners[1].id,
1006 'partner_shipping_id': partners[2].id,
1007 'order_line': [Command.create({'product_id': self.product_order_service1.id})],
1008 })
1009 sale_order.action_confirm()
1010
1011 task0, task1, task2, task3 = self.env['project.task'].with_user(project_user).create([{
1012 'name': f"Task {i}",
1013 'sale_line_id': sale_order.order_line.id,
1014 'project_id': self.project_global.id,
1015 'partner_id': partner.id,
1016 } for i, partner in enumerate(partners)])
1017
1018 self.assertEqual(task0.sale_order_id, sale_order, "Task matches SO's partner_id")
1019 self.assertEqual(task1.sale_order_id, sale_order, "Task matches SO's partner_invoice_id")
1020 self.assertEqual(task2.sale_order_id, sale_order, "Task matches SO's partner_shipping_id")
1021 self.assertFalse(task3.sale_order_id, "Task partner doesn't match any of the SO partners")
1022
1023 task3.with_user(project_user).write({
1024 'partner_id': self.partner.id,
1025 'sale_line_id': sale_order.order_line.id,
1026 })
1027 self.assertEqual(task3.sale_order_id, sale_order, "Task matches SO's partner_id")
1028
1029 def test_project_template_company(self):
1030 """
1031 When exactly one project is created on SO confirmation, and a project template is being used,
1032 the company of the created project should be the same as on the template.
1033 """
1034 product_with_project_template = self.env['product.product'].create({
1035 'name': 'product with template',
1036 'list_price': 1,
1037 'type': 'service',
1038 'service_tracking': 'project_only',
1039 'project_template_id': self.project_template.id,
1040 })
1041
1042 # SOs with one created project
1043 for company_id in (False, self.company.id):
1044 self.project_template.company_id = company_id
1045
1046 sale_order = self.env['sale.order'].create({'partner_id': self.partner.id})
1047 self.env['sale.order.line'].create({
1048 'product_id': product_with_project_template.id,
1049 'order_id': sale_order.id,
1050 })
1051 sale_order.action_confirm()
1052 self.assertEqual(self.project_template.company_id, sale_order.project_ids[0].company_id, "The created project should have the same company as the template")
1053
1054 # SO with two created projects
1055 self.project_template.company_id = False
1056 other_product = self.env['product.product'].create({
1057 'name': 'other product',
1058 'list_price': 1,
1059 'type': 'service',
1060 'service_tracking': 'task_in_project',
1061 })
1062
1063 sale_order = self.env['sale.order'].create({'partner_id': self.partner.id})
1064 self.env['sale.order.line'].create([{
1065 'product_id': product.id,
1066 'order_id': sale_order.id,
1067 } for product in (other_product, product_with_project_template)])
1068 sale_order.action_confirm()
1069 for project in sale_order:
1070 self.assertEqual(project.company_id, sale_order.company_id, "The company of the created project should be unchanged (and therefore the company of the SO)")
1071
1072 def test_action_view_project_ids(self):
1073 order = self.env['sale.order'].create({
1074 'name': 'Project Order',
1075 'partner_id': self.partner.id
1076 })
1077
1078 sol = self.env['sale.order.line'].create({
1079 'product_id': self.product_order_service4.id,
1080 'order_id': order.id,
1081 })
1082
1083 order.action_confirm()
1084 action = order.action_view_project_ids()
1085 self.assertEqual(action['type'], 'ir.actions.act_window', 'Should return a window action')
1086 self.assertEqual(action['context']['default_sale_line_id'], sol.id, 'The SOL linked to the SO should be chosen as default value')
1087
1088 self.product_order_service4.type = 'consu'
1089 action = order.action_view_project_ids()
1090 self.assertEqual(action['type'], 'ir.actions.act_window', 'Should return a window action')
1091 self.assertFalse(action['context']['default_sale_line_id'], 'No SOL should be set by default since the product changed')
1092
1093 def test_copy_so_doesnt_copy_project(self):
1094 origin = self.env['sale.order'].create({
1095 'name': 'Project Order',
1096 'partner_id': self.partner.id
1097 })
1098 self.env['sale.order.line'].create({
1099 'product_id': self.product_order_service4.id,
1100 'order_id': origin.id,
1101 })
1102 origin.action_confirm()
1103 self.assertTrue(origin.project_id)
1104 self.assertEqual(
1105 origin.order_line.analytic_distribution,
1106 origin.order_line.project_id._get_analytic_distribution(),
1107 )
1108 copy = origin.copy()
1109 self.assertFalse(copy.project_id)
1110 self.assertFalse(copy.order_line.analytic_distribution)
1111 copy.action_confirm()
1112 self.assertTrue(copy.project_id)
1113 self.assertEqual(
1114 copy.order_line.analytic_distribution,
1115 copy.order_line.project_id._get_analytic_distribution(),
1116 )
1117
1118 def test_confirm_sale_order_on_task_save(self):
1119 sale_order = self.env['sale.order'].create({
1120 'name': 'Sale Order',
1121 'partner_id': self.partner.id,
1122 })
1123 sale_order_line = self.env['sale.order.line'].create({
1124 'order_id': sale_order.id,
1125 'product_id': self.product_order_service1.id,
1126 })
1127 self.assertEqual(sale_order.state, 'draft')
1128
1129 task = self.env['project.task'].create({
1130 'name': 'Task',
1131 'project_id': self.project_global.id,
1132 })
1133 task.write({'sale_line_id': sale_order_line.id})
1134 self.assertEqual(sale_order.state, 'sale')
1135
1136 def test_confirm_sale_order_on_project_creation(self):
1137 sale_order = self.env['sale.order'].create({
1138 'name': 'Sale Order',
1139 'partner_id': self.partner.id,
1140 })
1141 sale_order_line = self.env['sale.order.line'].create({
1142 'order_id': sale_order.id,
1143 'product_id': self.product_order_service1.id,
1144 })
1145 self.assertEqual(sale_order.state, 'draft')
1146
1147 self.env['project.project'].create({
1148 'name': 'Project',
1149 'sale_line_id': sale_order_line.id,
1150 })
1151 self.assertEqual(sale_order.state, 'sale')
1152
1153 def test_create_project_on_fly(self):
1154 """
1155 Steps:
1156 1) Create a sale order with multiple order lines.
1157 2) On fly create a project
1158 3) Verify the project's default values.
1159 3) Confirm the sale order.
1160 4) Repeat step 2 and step 3.
1161 """
1162
1163 sale_order = self.env['sale.order'].create({
1164 'partner_id': self.partner.id,
1165 'order_line': [
1166 Command.create({'product_id': self.product_order_service1.id, 'sequence': 2}),
1167 Command.create({'product_id': self.product_order_service2.id, 'sequence': 1}),
1168 Command.create({'product_id': self.product_order_service3.id, 'sequence': 3}),
1169 ],
1170 })
1171
1172 def _create_project_on_fly():
1173 with Form(
1174 self.env['project.project'].with_context(
1175 default_partner_id=sale_order.partner_id.id,
1176 order_id=sale_order.id,
1177 order_state=sale_order.state
1178 )
1179 ) as project_form:
1180 project_form.name = "Test Project"
1181 return project_form.save()
1182
1183 project = _create_project_on_fly()
1184 self.assertListEqual(
1185 [project.partner_id, project.reinvoiced_sale_order_id.id, project.sale_line_id.id],
1186 [sale_order.partner_id, False, False],
1187 )
1188
1189 sale_order.action_confirm()
1190 project = _create_project_on_fly()
1191 self.assertListEqual(
1192 [project.partner_id.id, project.reinvoiced_sale_order_id.id, project.sale_line_id.id],
1193 [sale_order.partner_id.id, sale_order.id, sale_order.order_line[0].id],
1194 )
1195
1196 def test_analytics_on_so_confirmation_no_project(self):
1197 # Config 1: no project_id on the SO
1198 self.product_order_service3.project_template_id = self.project_template
1199 so = self.env['sale.order'].create({'partner_id': self.partner.id})
1200 sol_no_project, sol_task_in_global_project, sol_task_in_template_project, sol_new_project = self.env['sale.order.line'].create([
1201 {'order_id': so.id, 'product_id': self.product_order_service1.id, 'sequence': 1}, # no service_tracking
1202 {'order_id': so.id, 'product_id': self.product_order_service2.id, 'sequence': 2}, # service_tracking: 'task_global_project'
1203 {'order_id': so.id, 'product_id': self.product_order_service3.id, 'sequence': 3}, # service_tracking': 'task_in_project'
1204 {'order_id': so.id, 'product_id': self.product_order_service4.id, 'sequence': 4}, # service_tracking: 'project_only'
1205 ])
1206 n_analytic_accounts = self.env['account.analytic.account'].search_count([])
1207 so.action_confirm()
1208 self.assertEqual(
1209 n_analytic_accounts + 1,
1210 self.env['account.analytic.account'].search_count([]),
1211 "Only one analytic account should have been created due to the generation of both `sol_task_in_template_project` and `sol_new_project` projects."
1212 )
1213 self.assertEqual(len(so.order_line.project_id | so.order_line.task_id.project_id), 3, "Three projects should be linked to the SO.")
1214 self.assertFalse(sol_no_project.project_id, "`sol_no_project` should not generate any project.")
1215 self.assertEqual(
1216 so.project_id,
1217 sol_task_in_template_project.project_id,
1218 "The project of the SO should be set to the project with the lowest (sequence, id)."
1219 )
1220 self.assertNotEqual(
1221 sol_task_in_global_project.project_id.account_id,
1222 sol_task_in_template_project.project_id.account_id,
1223 "As the project of `sol_task_in_global_project` was not generated but already defined, its AA was kept the same."
1224 )
1225 self.assertEqual(
1226 sol_task_in_template_project.project_id.account_id,
1227 sol_new_project.project_id.account_id,
1228 "As the projects of `sol_task_in_template_project` and `sol_new_project` were generated, they share the same AA which was created after SO confirmation."
1229 )
1230
1231 def test_analytics_on_so_confirmation_project_with_accounts(self):
1232 # Config 2: a project_id on the SO with AAs
1233 # Also add an AA to the project template
1234 plan_name = self.analytic_plan._column_name()
1235 self.project_template[plan_name] = self.analytic_account_sale
1236 self.product_order_service3.project_template_id = self.project_template
1237 so = self.env['sale.order'].create({'partner_id': self.partner.id, 'project_id': self.project_global.id})
1238 sol_task_in_template_project, sol_new_project = self.env['sale.order.line'].create([
1239 {'order_id': so.id, 'product_id': self.product_order_service3.id},
1240 {'order_id': so.id, 'product_id': self.product_order_service4.id},
1241 ])
1242 so.action_confirm()
1243 self.assertEqual(len(so.order_line.project_id), 2, "Two projects should be linked to the SO.")
1244 self.assertEqual(
1245 self.project_global.account_id,
1246 sol_task_in_template_project.project_id.account_id,
1247 "The main AA of the project of `sol_task_in_template_project` should be the same as the main AA of the project set on the SO."
1248 )
1249 self.assertEqual(
1250 self.project_template[plan_name],
1251 sol_task_in_template_project.project_id[plan_name],
1252 "The other AA of the project of `sol_task_in_template_project` should be the same as the other AA of its project template."
1253 )
1254 self.assertEqual(
1255 self.project_global.account_id,
1256 sol_new_project.project_id.account_id,
1257 "The main AA of the project of `sol_new_project` should should be the same the main AA of the project set on the SO."
1258 )
1259 self.assertEqual(
1260 self.project_global[plan_name],
1261 sol_new_project.project_id[plan_name],
1262 "The other AA of the project of `sol_new_project` should be the same as the other AA of the project set on the SO."
1263 )
1264
1265 def test_analytics_on_so_confirmation_project_without_account(self):
1266 # Config 3: a project_id on the SO without AA
1267 self.product_order_service3.project_template_id = self.project_template
1268 self.project_global.account_id = False
1269 so = self.env['sale.order'].create({'partner_id': self.partner.id, 'project_id': self.project_global.id})
1270 sol_task_in_template_project, sol_new_project = self.env['sale.order.line'].create([
1271 {'order_id': so.id, 'product_id': self.product_order_service3.id},
1272 {'order_id': so.id, 'product_id': self.product_order_service4.id},
1273 ])
1274 so.action_confirm()
1275 self.assertEqual(len(so.order_line.project_id), 2, "Two projects should be linked to the SO.")
1276 self.assertFalse(self.project_global.account_id, "The AA of the project of the SO should still be empty.")
1277 self.assertEqual(
1278 sol_task_in_template_project.project_id.account_id,
1279 sol_new_project.project_id.account_id,
1280 "As the projects of `sol_task_in_template_project` and `sol_new_project` were generated, they share the same AA which was created after SO confirmation."
1281 )
1282
1283 def test_global_project_service_takes_so_project_on_so_confirmation(self):
1284 self.product_order_service2.project_id = False
1285 so = self.env['sale.order'].create({'partner_id': self.partner.id})
1286 sol_task_in_global_project, sol_new_project = self.env['sale.order.line'].create([
1287 {'order_id': so.id, 'product_id': self.product_order_service2.id},
1288 {'order_id': so.id, 'product_id': self.product_order_service3.id},
1289 ])
1290 so.action_confirm()
1291 self.assertEqual(
1292 so.project_id,
1293 sol_new_project.project_id,
1294 "The project of the SO should be set to the project that was generated by `sol_new_project` at SO confirmation."
1295 )
1296 self.assertEqual(
1297 so.project_id,
1298 sol_task_in_global_project.task_id.project_id,
1299 "The project of the task of `sol_task_in_global_project` should be set to the project of the SO."
1300 )
1301
1302 def test_global_project_service_takes_so_project_on_already_confirmed_so(self):
1303 self.product_order_service2.project_id = False
1304 so = self.env['sale.order'].create({'partner_id': self.partner.id})
1305 so.action_confirm()
1306 sol_task_in_global_project, sol_new_project = self.env['sale.order.line'].create([
1307 {'order_id': so.id, 'product_id': self.product_order_service2.id},
1308 {'order_id': so.id, 'product_id': self.product_order_service3.id},
1309 ])
1310 self.assertEqual(
1311 so.project_id,
1312 sol_new_project.project_id,
1313 "The project of the SO should be set to the project that was generated by `sol_new_project` after adding the SOLs in batch to the SO."
1314 )
1315 self.assertEqual(
1316 so.project_id,
1317 sol_task_in_global_project.task_id.project_id,
1318 "The project of the task of `sol_task_in_global_project` should be set to the project of the SO."
1319 )
1320
1321 def test_global_project_service_no_so_project_error(self):
1322 self.product_order_service2.project_id = False
1323 so = self.env['sale.order'].create({
1324 'partner_id': self.partner.id,
1325 'order_line': [Command.create({'product_id': self.product_order_service2.id})],
1326 })
1327 with self.assertRaises(UserError, msg="The SOL has a product which creates a task on SO confirmation, but no project is configured on the product or SO."):
1328 so.action_confirm()
1329
1330 def test_so_confirmation_in_batch(self):
1331 so1, so2 = self.env['sale.order'].create([{
1332 'partner_id': self.partner.id,
1333 'order_line': [Command.create({'product_id': self.product_order_service3.id})],
1334 } for _dummy in range(2)])
1335 (so1 | so2).action_confirm()
1336 self.assertEqual(
1337 so1.project_id,
1338 so1.order_line.project_id,
1339 "The project of `so1` should be set to the project that was generated at SO confirmation."
1340 )
1341 self.assertEqual(
1342 so2.project_id,
1343 so2.order_line.project_id,
1344 "The project of `so1` should be set to the project that was generated at SO confirmation."
1345 )
1346
1347 def test_group_expand_sales_order(self):
1348 """
1349 1. Create a sale order "Test Order" and a linked project task "Test Task."
1350 2. Set context with `gantt_start_date` and `gantt_scale`.
1351 3. Call `_group_expand_sales_order` and assert no sale orders are displayed without scheduled tasks.
1352 4. Call `_group_expand_sales_order` with "Test" and assert the matching sale order is displayed.
1353 """
1354 order = self.env['sale.order'].create({'name': 'Test Order', 'partner_id': self.partner.id})
1355 self.env['project.task'].create({
1356 'name': 'Test Task',
1357 'project_id': self.project_global.id,
1358 'sale_order_id': order.id,
1359 })
1360 domain = [
1361 ('planned_date_begin', '>=', Datetime.to_datetime('2023-01-01')),
1362 ('date_deadline', '<=', Datetime.to_datetime('2023-01-04')),
1363 ]
1364 Task = self.env['project.task'].with_context({
1365 'gantt_start_date': Datetime.to_datetime('2023-01-01'),
1366 'gantt_scale': 'month',
1367 })
1368
1369 displayed_sale_order = Task._group_expand_sales_order(None, domain)
1370 self.assertFalse(
1371 displayed_sale_order,
1372 'Sale orders without scheduled tasks should not be displayed in the Gantt view',
1373 )
1374
1375 displayed_sale_order = Task._group_expand_sales_order(None, [('sale_order_id', 'ilike', 'Test')] + domain)
1376 self.assertEqual(order, displayed_sale_order, 'The matching sale order should be displayed in the Gantt view')
1377
1378 def test_so_with_service_product_negative_qty(self):
1379 so = self.env['sale.order'].create({'partner_id': self.partner.id})
1380 sol = self.env['sale.order.line'].create({
1381 'order_id': so.id,
1382 'product_id': self.product_order_service2.id,
1383 'product_uom_qty': -5,
1384 })
1385 so.action_confirm()
1386 self.assertFalse(self.product_order_service2.project_id.task_ids)
1387 self.assertFalse(sol.task_id)
1388
1389 def test_create_sale_order_for_project(self):
1390 """ Test when user creates a SO inside stat button displayed in project form view
1391
1392 Test Case
1393 =========
1394 When the user clicks on the stat button `Make Billable`, the `create_for_project_id` is added
1395 to the contex. With that context, we will make sure the action_confirm will do nothing if the
1396 user clicks on it since the SO will automatically be confirmed in that use case.
1397 """
1398 self.project_global.partner_id = self.partner
1399 action_dict = self.project_global.with_context(
1400 create_for_project_id=self.project_global.id,
1401 default_project_id=self.project_global.id,
1402 default_partner_id=self.partner.id
1403 ).action_view_sos()
1404 sale_order = self.env['sale.order'].with_context(action_dict['context']).create({
1405 'order_line': [Command.create({
1406 'product_id': self.product_order_service2.id,
1407 'product_uom_qty': 2,
1408 })],
1409 })
1410 self.assertEqual(sale_order.partner_id, self.partner)
1411 self.assertEqual(sale_order.project_id, self.project_global)
1412 self.assertEqual(sale_order.state, 'sale')
1413 self.assertEqual(self.project_global.sale_line_id, sale_order.order_line)
1414
1415 sale_order.action_confirm() # no error should be raised even if the SO is already confirmed
1416
1417 def test_project_creation_from_sol_with_goods_type_product_should(self):
1418 """ Test that a project can be created from a confirmed sale order containing a 'goods' type product.
1419 Steps:
1420 - Create a sale order with a consumable (goods-type) product.
1421 - Confirm the sale order.
1422 - Trigger 'Create Project' action from the sale order.
1423 - Fill out and save the project form.
1424 - Ensure the created project is correctly linked to the sale order,
1425 but not to a specific sale order line.
1426 """
1427 sale_order = self.env['sale.order'].create({
1428 'partner_id': self.partner.id,
1429 'order_line': [
1430 Command.create({
1431 'product_id': self.product_consumable.id,
1432 }),
1433 ],
1434 })
1435
1436 sale_order.action_confirm()
1437 action = sale_order.action_create_project()
1438
1439 with Form(self.env['project.project'].with_context(action['context'])) as project_form:
1440 project_form.name = "test project"
1441 project = project_form.save()
1442
1443 self.assertEqual(project.reinvoiced_sale_order_id.id, sale_order.id, "The project should be linked to the SO.")
1444 self.assertFalse(project.sale_line_id, "The project should not be linked to sale order line.")
1445
1446 def test_analytics_on_so_confirmation_with_project_templates(self):
1447 project_template_1, project_template_2 = self.env['project.project'].create([
1448 {'name': 'Project Template 1', 'is_template': True},
1449 {'name': 'Project Template 2', 'is_template': True},
1450 ])
1451 product_with_project_template_1, product_with_project_template_2 = self.env['product.product'].create([
1452 {
1453 'name': 'Product with Project Template 1',
1454 'type': 'service',
1455 'service_tracking': 'project_only',
1456 'project_template_id': project_template_1.id,
1457 },
1458 {
1459 'name': 'Product with Project Template 2',
1460 'type': 'service',
1461 'service_tracking': 'project_only',
1462 'project_template_id': project_template_2.id,
1463 },
1464 ])
1465 so = self.env['sale.order'].create({'partner_id': self.partner.id})
1466 sol_1, sol_2 = self.env['sale.order.line'].create([
1467 {'order_id': so.id, 'product_id': product_with_project_template_1.id, 'sequence': 1},
1468 {'order_id': so.id, 'product_id': product_with_project_template_2.id, 'sequence': 2},
1469 ])
1470 n_analytic_accounts = self.env['account.analytic.account'].search_count([])
1471 so.action_confirm()
1472 self.assertEqual(
1473 n_analytic_accounts + 1,
1474 self.env['account.analytic.account'].search_count([]),
1475 "Only one analytic account should have been created due to the generation of both `sol_1` and `sol_2` projects.",
1476 )
1477 self.assertEqual(len(so.order_line.project_id), 2, "Two projects should be linked to the SO.")
1478 self.assertEqual(
1479 so.project_id,
1480 sol_1.project_id,
1481 "The project of the SO should be set to the project with the lowest (sequence, id).",
1482 )
1483 self.assertEqual(
1484 sol_1.project_id.account_id,
1485 sol_2.project_id.account_id,
1486 "As the projects of `sol_1` and `sol_2` were generated, they share the same AA which was created after SO confirmation.",
1487 )
1488 self.assertEqual(
1489 sol_1.analytic_distribution,
1490 {str(so.project_id.account_id.id): 100},
1491 "The analytic distribution of `sol_1` should be set to the reference AA of the SO.",
1492 )
1493 self.assertEqual(
1494 sol_2.analytic_distribution,
1495 {str(so.project_id.account_id.id): 100},
1496 "The analytic distribution of `sol_2` should be set to the reference AA of the SO.",
1497 )
1498
1499 def test_so_with_project_template(self):
1500 """ Test that a SO with a product using a project template creates the project
1501 and the task on SO confirmation, and set project's company to the product's template company.
1502 """
1503 product_with_project_template = self.env['product.product'].create({
1504 'name': 'product with template',
1505 'list_price': 1,
1506 'type': 'service',
1507 'service_tracking': 'project_only',
1508 'project_template_id': self.project_template.id,
1509 })
1510 partner = self.env['res.partner'].create({'name': 'Test Partner', 'company_id': self.env.company.id})
1511 sale_order = self.env['sale.order'].create({
1512 'partner_id': partner.id,
1513 'order_line': [Command.create({'product_id': product_with_project_template.id})],
1514 })
1515 sale_order.action_confirm()
1516 self.assertEqual(sale_order.project_ids[0].company_id, self.project_template.company_id)
1517 self.assertEqual(sale_order.project_ids[0].account_id.company_id, partner.company_id)
1518
1519 def test_template_hours_applied_and_fallback_hours_used_for_additional_tasks(self):
1520 """
1521 Steps:
1522 1. Set task template allocated_hours = 20.
1523 2. Create 2 products: 2 linked to template.
1524 3. Confirm sale order.
1525 4. Expect:
1526 - 1 task created.
1527 - Template-based task gets 20 hrs.
1528 """
1529 self.task_template.allocated_hours = 20
1530 product_1, product_2 = self.env['product.product'].create([{
1531 'name': 'Test product 1',
1532 'type': 'service',
1533 'service_tracking': 'task_global_project',
1534 'project_id': self.project_global.id,
1535 'task_template_id': self.task_template.id,
1536 'service_policy': 'ordered_prepaid',
1537 }, {
1538 'name': 'Test product 2',
1539 'type': 'service',
1540 'service_tracking': 'task_in_project',
1541 'project_template_id': self.project_global.id,
1542 'task_template_id': self.task_template.id,
1543 'service_policy': 'ordered_prepaid',
1544 }])
1545 order = self.env['sale.order'].create({
1546 'partner_id': self.partner.id,
1547 })
1548 sol1, sol2 = self.env['sale.order.line'].create([{
1549 'order_id': order.id,
1550 'product_id': product_1.id,
1551 'product_uom_qty': 2,
1552 }, {
1553 'order_id': order.id,
1554 'product_id': product_2.id,
1555 'product_uom_qty': 10,
1556 }])
1557
1558 order.action_confirm()
1559 self.assertEqual(order.tasks_count, 1, "1 task should be created")
1560 self.assertEqual((sol1 + sol2).task_id.allocated_hours, 20, "Template task should get 20 hrs")
1561
1562 def test_allocated_hours_computed_from_quantity_when_template_hours_missing(self):
1563 """
1564 Steps:
1565 1. Create a template without allocated_hours.
1566 2. Create product using the template with quantity 2.
1567 3. Confirm sale order.
1568 4. Expect:
1569 - 1 task created.
1570 - Task gets 2 hrs based on order quantity.
1571 """
1572 product = self.env['product.product'].create([{
1573 'name': 'Test product',
1574 'type': 'service',
1575 'service_tracking': 'task_global_project',
1576 'project_id': self.project_global.id,
1577 'task_template_id': self.task_template.id,
1578 'service_policy': 'ordered_prepaid',
1579 }])
1580 order = self.env['sale.order'].create({
1581 'partner_id': self.partner.id,
1582 'order_line': [
1583 Command.create({
1584 'product_id': product.id,
1585 'product_uom_qty': 2,
1586 }),
1587 ],
1588 })
1589
1590 order.action_confirm()
1591 self.assertEqual(order.tasks_count, 1, "1 task should be created")
1592 self.assertEqual(order.tasks_ids.allocated_hours, 2, "Task should get 2 hrs from qty")
1593
1594 def test_zero_hours_assigned_when_service_policy_is_manual(self):
1595 """
1596 Steps:
1597 1. Create product with delivered_manual service policy.
1598 2. Link it to task template.
1599 3. Confirm sale order.
1600 4. Expect:
1601 - 1 task created.
1602 - Task has 0 allocated hours.
1603 """
1604 product = self.env['product.product'].create([{
1605 'name': 'Test product',
1606 'type': 'service',
1607 'service_tracking': 'task_global_project',
1608 'project_id': self.project_global.id,
1609 'task_template_id': self.task_template.id,
1610 'service_policy': 'delivered_manual',
1611 }])
1612 order = self.env['sale.order'].create({
1613 'partner_id': self.partner.id,
1614 'order_line': [
1615 Command.create({
1616 'product_id': product.id,
1617 'product_uom_qty': 2,
1618 }),
1619 ],
1620 })
1621
1622 order.action_confirm()
1623 self.assertEqual(order.tasks_count, 1, "1 task should be created")
1624 self.assertEqual(order.tasks_ids.allocated_hours, 0, "Task should get 0 hrs (manual policy)")
1625
1626 def test_create_project_from_sale_order(self):
1627 """Test that a project created from a sale order is linked to that sale order."""
1628 sale_order = self.env['sale.order'].create({
1629 'partner_id': self.partner.id,
1630 'order_line': [Command.create({'product_id': self.product_order_service1.id})],
1631 })
1632 sale_order.action_confirm()
1633 action = sale_order.action_create_project()
1634 project = self.env['project.project'].with_context(action['context']).create({
1635 'name': 'Test Project',
1636 'allow_billable': True,
1637 })
1638 self.assertEqual(sale_order.project_id, project, "The created project should be linked to this sale order")
1639 self.assertEqual(project.reinvoiced_sale_order_id, sale_order, "The created project should be linked to this sale order")
1640
1641 def test_create_project_from_sale_order_none_service_type(self):
1642 """Test that a project created from a sale order is linked to that sale order."""
1643 sale_order = self.env['sale.order'].create({
1644 'partner_id': self.partner.id,
1645 'order_line': [Command.create({'product_id': self.company_data['product_order_cost'].id})],
1646 })
1647 sale_order.action_confirm()
1648 action = sale_order.action_create_project()
1649 project = self.env['project.project'].with_context(action['context']).create({
1650 'name': 'Test Project',
1651 'allow_billable': True,
1652 })
1653 self.assertEqual(sale_order.project_id, project, "The created project should be linked to this sale order")
1654
1655 def test_sale_order_project_task_smartbutton(self):
1656 """Test to verify that the project & task smart button is visible when a project is linked to a sale order.
1657 Steps:
1658 - Create a sale order with a product of type 'goods'.
1659 - Create a project and link it to the sale order.
1660 - Create a task and link it to the project.
1661 - Verify that the project is linked to the sale order.
1662 - Verify that the tasks is linked to the sale order.
1663 - Verify that the project & task smart button is hidden.
1664 - Confirm the sale order.
1665 - Verify the visibility of the project & task smart button.
1666 """
1667
1668 sale_order = self.env["sale.order"].create({
1669 "partner_id": self.partner.id,
1670 "order_line": [
1671 Command.create({
1672 "product_id": self.product_a.id,
1673 "product_uom_qty": 1,
1674 }),
1675 ],
1676 })
1677
1678 project = self.env["project.project"].create({
1679 "name": "Project X",
1680 "partner_id": self.partner.id,
1681 "allow_billable": True,
1682 "reinvoiced_sale_order_id": sale_order.id,
1683 })
1684
1685 self.env["project.task"].create({
1686 "name": "task 1",
1687 "project_id": project.id,
1688 })
1689
1690 self.assertEqual(
1691 (sale_order.project_count, sale_order.tasks_count),
1692 (1, 1),
1693 "The project and task should be linked to the sale order."
1694 )
1695 self.assertFalse(
1696 sale_order.show_project_button,
1697 "The project smart buttons should be hidden in the sale order."
1698 )
1699
1700 sale_order.action_confirm()
1701 sale_order._compute_show_project_and_task_button()
1702
1703 self.assertTrue(
1704 sale_order.show_project_button,
1705 "The project smart buttons should be shown in the sale order."
1706 )
1707
1708 def test_project_creation_with_and_without_template(self):
1709 """
1710 Test creating a project from a sale order, both with and without using a project template.
1711 Steps:
1712 ------
1713 1. Create a project template with one task.
1714
1715 Flow 1: Project creation without template
1716 -----------------------------------------
1717 2. Create a sale order and confirm it.
1718 3. Open the create project wizard without selecting any template.
1719 4. Create the project.
1720 5. Assert:
1721 - The project has no tasks.
1722 - The project is linked to the sale order.
1723
1724 Flow 2: Project creation with template
1725 --------------------------------------
1726 6. Create a new sale order and confirm it.
1727 7. Open the create project wizard and select the template.
1728 8. Create the project.
1729 9. Assert:
1730 - The project has one task (copied from template).
1731 - The project is linked to the sale order.
1732 """
1733 template_project = self.env['project.project'].create({
1734 'name': 'Template Project',
1735 'is_template': True,
1736 'task_ids': [Command.create({'name': 'Task 1'})],
1737 })
1738 sale_order_1 = self.env['sale.order'].create({
1739 'partner_id': self.partner.id,
1740 'order_line': [Command.create({'product_id': self.product_consumable.id})],
1741 })
1742 sale_order_1.action_confirm()
1743 action_1 = sale_order_1.action_create_project()
1744 view_id = self.env.ref('sale_project.sale_project_view_form_simplified_template').id
1745
1746 with Form(self.env[action_1['res_model']].with_context(action_1['context']), view=view_id) as wizard:
1747 project_action_1 = wizard.save().action_create_project_from_so()
1748 project_1 = self.env['project.project'].browse(project_action_1['context']['default_project_id'])
1749 self.assertFalse(project_1.task_ids, "Project should not have tasks when created without template.")
1750 self.assertEqual(
1751 project_1.reinvoiced_sale_order_id,
1752 sale_order_1,
1753 "Project should be linked to the sale order."
1754 )
1755
1756 sale_order_2 = self.env['sale.order'].create({
1757 'partner_id': self.partner.id,
1758 'order_line': [Command.create({'product_id': self.product_consumable.id})],
1759 })
1760 sale_order_2.action_confirm()
1761 action_2 = sale_order_2.action_create_project()
1762 with Form(self.env[action_2['res_model']].with_context(action_2['context']), view=view_id) as wizard:
1763 wizard.template_id = template_project
1764 project_action_2 = wizard.save().action_create_project_from_so()
1765 project_2 = self.env['project.project'].browse(project_action_2['context']['default_project_id'])
1766 self.assertEqual(project_2.task_count, 1, "Project should have 1 task copied from the template.")
1767 self.assertEqual(
1768 project_2.reinvoiced_sale_order_id,
1769 sale_order_2,
1770 "Project should be linked to the sale order."
1771 )
1772
1773 def test_task_sol_default_after_removing_so_from_project(self):
1774 """
1775 Steps:
1776 1. Create two project templates.
1777 2. Create two service products, each linked to one of the templates.
1778 3. Create a Sale Order with these two products and confirm it.
1779 4. Verify that two projects are created from the SO, each linked to its SOL.
1780 5. Remove the SO and SOL from the second project.
1781 6. Create a task in the second project **without context**, should not link any SOL.
1782 7. Create a task in the second project **with context** (from SO action), should pick the original SOL.
1783 """
1784 template_1, template_2 = self.env['project.project'].create([
1785 {'name': 'Project Template 1', 'is_template': True},
1786 {'name': 'Project Template 2', 'is_template': True},
1787 ])
1788 product_1, product_2 = self.env['product.product'].create([
1789 {
1790 'name': 'Product with Project Template 1',
1791 'type': 'service',
1792 'invoice_policy': 'order',
1793 'service_tracking': 'project_only',
1794 'project_template_id': template_1.id,
1795 },
1796 {
1797 'name': 'Product with Project Template 2',
1798 'type': 'service',
1799 'invoice_policy': 'order',
1800 'service_tracking': 'project_only',
1801 'project_template_id': template_2.id,
1802 },
1803 ])
1804 so = self.env['sale.order'].create({
1805 'partner_id': self.partner.id,
1806 'order_line': [
1807 Command.create({
1808 'product_id': product_1.id,
1809 'product_uom_qty': 1,
1810 }),
1811 Command.create({
1812 'product_id': product_2.id,
1813 'product_uom_qty': 1,
1814 }),
1815 ],
1816 })
1817 so.action_confirm()
1818 projects = self.env['project.project'].search([('sale_line_id', 'in', so.order_line.ids)])
1819 self.assertEqual(len(projects), 2, "Two projects should be created from the SO")
1820 project2 = projects[1]
1821 sol2 = project2.sale_line_id
1822 self.assertTrue(sol2, "Second project should have a SOL linked")
1823
1824 project2.write({'sale_order_id': False, 'sale_line_id': False})
1825
1826 task_no_context = self.env['project.task'].create({
1827 'name': 'Task without context',
1828 'project_id': project2.id,
1829 })
1830 self.assertFalse(task_no_context.sale_line_id, "Task without context should not have SOL")
1831
1832 task_with_context = self.env['project.task'].with_context(
1833 from_sale_order_action=True,
1834 default_sale_order_id=so.id,
1835 active_id=project2.id,
1836 ).create({'name': 'Task with context', 'project_id': project2.id})
1837 self.assertEqual(
1838 task_with_context.sale_line_id, sol2,
1839 "Task with context should pick the original SOL even if removed from project"
1840 )
1841
1842 def test_enable_milestones_settings_of_project_on_so_confirmation(self):
1843 self.product_service_delivered_milestone.service_tracking = 'project_only'
1844 so = self.env['sale.order'].create({
1845 'partner_id': self.partner.id,
1846 'order_line': [
1847 Command.create({'product_id': self.product_order_service4.id, 'sequence': 1}), # service_tracking: 'project_only', not based on project template, invoice policy: order
1848 Command.create({'product_id': self.product_service_delivered_milestone.id, 'sequence': 2}), # service_tracking: 'project_only', not based on project template, invoice policy: milestones
1849 ],
1850 })
1851 so.action_confirm()
1852 self.assertEqual(len(so.project_ids), 1, 'One project should be generated and linked to the SO.')
1853 self.assertTrue(
1854 so.project_ids.allow_milestones,
1855 'The generated project should have the "Allow Milestones" setting enabled, as one of the products has invoice policy based on milestones.',
1856 )
1857
1858 def test_sale_order_creation_without_service_product_for_project(self):
1859 """Test that a sale order is created for a project using a non-service product"""
1860 self.project_global.partner_id = self.partner
1861 action_dict = self.project_global.with_context(
1862 create_for_project_id=self.project_global.id,
1863 default_project_id=self.project_global.id,
1864 default_partner_id=self.partner.id
1865 ).action_view_sos()
1866
1867 self.product_milestone.type = 'consu'
1868 sale_order = self.env['sale.order'].with_context(action_dict['context']).create({
1869 'order_line': [Command.create({
1870 'product_id': self.product_milestone.id,
1871 'product_uom_qty': 1,
1872 })],
1873 })
1874
1875 self.assertEqual(sale_order.project_id, self.project_global)
1876 self.assertEqual(sale_order.partner_id, self.partner)
1877 self.assertFalse(self.project_global.sale_line_id)
1878 self.assertEqual(self.project_global.reinvoiced_sale_order_id, sale_order)
1879
1880 def test_allocated_hours_manual_delivery_service(self):
1881 """
1882 Test that allocated_hours match the quantity ordered on creation
1883 when the service product has 'delivered_manual' service policy.
1884 """
1885 self.product_service_delivered_manual.service_tracking = 'task_in_project'
1886 so = self.env['sale.order'].create({'partner_id': self.partner.id})
1887 sol = self.env['sale.order.line'].create({
1888 'order_id': so.id,
1889 'product_id': self.product_service_delivered_manual.id,
1890 'product_uom_qty': 10,
1891 })
1892 so.action_confirm()
1893 self.assertEqual(sol.task_id.allocated_hours, 10, "The allocated hours should be 10.")
1894
1895 def test_quotation_with_zero_unit_project_service(self):
1896 """
1897 Test checking that a project doesn't get created on order when ordering 0 units of the corresponding
1898 product service if it is optional. If the unit is increased to 1, a project should be created.
1899 """
1900 sale_order_with_option = self.env['sale.order'].create({
1901 'partner_id': self.partner.id,
1902 'order_line': [
1903 Command.create({
1904 'product_id': self.product_a.id,
1905 'product_uom_qty': 1,
1906 }),
1907 Command.create({
1908 'display_type': 'line_section',
1909 'name': "Optional products",
1910 'is_optional': True,
1911 }),
1912 Command.create({
1913 'product_id': self.product_order_service4.id,
1914 'product_uom_qty': 0,
1915 }),
1916 ],
1917 })
1918 optional_product_line = sale_order_with_option.order_line.filtered(lambda line: not line.display_type and line._is_line_optional())
1919 sale_order_with_option.action_confirm()
1920 self.assertFalse(optional_product_line.project_id)
1921 optional_product_line.write({'product_uom_qty': 1})
1922 self.assertEqual(optional_product_line.project_id.sale_order_id, sale_order_with_option)