[REF] resource: remove deprecated compatibility and rename methods

Old methods are still present since a long time and are deprecated since
saas-3. This compatibility layer adds unnecessary complexity to the module
API. Those methods should now be removed. Some renaming is also performed
to ease resource api understanding, notably to better differentiate
internal methods from other methods.

All addons are updated accordingly.

1 files changed, 35 insertions, 57 deletions

diff --git a/addons/resource/tests/test_resource.py b/addons/resource/tests/test_resource.py
index 528e5fac854..3190c6c8345 100644
--- a/addons/resource/tests/test_resource.py
+++ b/addons/resource/tests/test_resource.py
@@ -7,9 +7,8 @@ from datetime import datetime, timedelta, date
 from dateutil.relativedelta import relativedelta
 
 from odoo.fields import Date, Datetime
-from odoo.tools import float_compare
+from odoo.addons.resource.models.resource import seconds
 from odoo.addons.resource.tests.common import TestResourceCommon
-from odoo.tests import TransactionCase
 
 
 class TestIntervals(TestResourceCommon):
@@ -45,7 +44,7 @@ class TestIntervals(TestResourceCommon):
         ]
 
     def test_interval_clean(self):
-        cleaned_intervals = self.env['resource.calendar'].interval_clean(self.intervals)
+        cleaned_intervals = self.env['resource.calendar']._interval_clean(self.intervals)
         self.assertEqual(len(cleaned_intervals), 3)
         # First interval: 03, unchanged
         self.assertEqual(cleaned_intervals[0], (Datetime.from_string('2013-02-03 08:00:00'), Datetime.from_string('2013-02-03 10:00:00')))
@@ -56,14 +55,14 @@ class TestIntervals(TestResourceCommon):
 
     def test_interval_remove(self):
         working_interval = (Datetime.from_string('2013-02-04 08:00:00'), Datetime.from_string('2013-02-04 18:00:00'))
-        result = self.env['resource.calendar'].interval_remove_leaves(working_interval, self.intervals)
+        result = self.env['resource.calendar']._interval_remove_leaves(working_interval, self.intervals)
         self.assertEqual(len(result), 1)
         # First interval: 04, 14-17
         self.assertEqual(result[0], (Datetime.from_string('2013-02-04 14:00:00'), Datetime.from_string('2013-02-04 17:00:00')))
 
     def test_interval_schedule_hours(self):
-        cleaned_intervals = self.env['resource.calendar'].interval_clean(self.intervals)
-        result = self.env['resource.calendar'].interval_schedule_hours(cleaned_intervals, 5.5)
+        cleaned_intervals = self.env['resource.calendar']._interval_clean(self.intervals)
+        result = self.env['resource.calendar']._interval_schedule_hours(cleaned_intervals, 5.5)
         self.assertEqual(len(result), 2)
         # First interval: 03, 8-10 untouched
         self.assertEqual(result[0], (Datetime.from_string('2013-02-03 08:00:00'), Datetime.from_string('2013-02-03 10:00:00')))
@@ -71,9 +70,9 @@ class TestIntervals(TestResourceCommon):
         self.assertEqual(result[1], (Datetime.from_string('2013-02-04 08:00:00'), Datetime.from_string('2013-02-04 11:30:00')))
 
     def test_interval_schedule_hours_backwards(self):
-        cleaned_intervals = self.env['resource.calendar'].interval_clean(self.intervals)
+        cleaned_intervals = self.env['resource.calendar']._interval_clean(self.intervals)
         cleaned_intervals.reverse()
-        result = self.env['resource.calendar'].interval_schedule_hours(cleaned_intervals, 5.5, remove_at_end=False)
+        result = self.env['resource.calendar']._interval_schedule_hours(cleaned_intervals, 5.5, remove_at_end=False)
         self.assertEqual(len(result), 2)
         # First interval: 03, 8-10 untouched
         self.assertEqual(result[0], (Datetime.from_string('2013-02-04 17:00:00'), Datetime.from_string('2013-02-04 21:00:00')))
@@ -84,68 +83,68 @@ class TestIntervals(TestResourceCommon):
 class TestCalendarBasics(TestResourceCommon):
 
     def test_calendar_weekdays(self):
-        weekdays = self.calendar.get_weekdays()
+        weekdays = self.calendar._get_weekdays()
         self.assertEqual(weekdays, [1, 4])
 
     def test_calendar_next_day(self):
         # Test: next day: next day after day1 is day4
-        date = self.calendar.get_next_day(day_date=Date.from_string('2013-02-12'))
+        date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-12'))
         self.assertEqual(date, self.date2.date())
 
         # Test: next day: next day after day4 is (day1+7)
-        date = self.calendar.get_next_day(day_date=Date.from_string('2013-02-15'))
+        date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-15'))
         self.assertEqual(date, self.date1.date() + relativedelta(days=7))
 
         # Test: next day: next day after day4+1 is (day1+7)
-        date = self.calendar.get_next_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
+        date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
         self.assertEqual(date, self.date1.date() + relativedelta(days=7))
 
         # Test: next day: next day after day1-1 is day1
-        date = self.calendar.get_next_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
+        date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
         self.assertEqual(date, self.date1.date())
 
     def test_calendar_previous_day(self):
         # Test: previous day: previous day before day1 is (day4-7)
-        date = self.calendar.get_previous_day(day_date=Date.from_string('2013-02-12'))
+        date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-12'))
         self.assertEqual(date, self.date2.date() + relativedelta(days=-7))
 
         # Test: previous day: previous day before day4 is day1
-        date = self.calendar.get_previous_day(day_date=Date.from_string('2013-02-15'))
+        date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-15'))
         self.assertEqual(date, self.date1.date())
 
         # Test: previous day: previous day before day4+1 is day4
-        date = self.calendar.get_previous_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
+        date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
         self.assertEqual(date, self.date2.date())
 
         # Test: previous day: previous day before day1-1 is (day4-7)
-        date = self.calendar.get_previous_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
+        date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
         self.assertEqual(date, self.date2.date() + relativedelta(days=-7))
 
     def test_calendar_working_day_intervals_no_leaves(self):
         # Test: day0 without leaves: 1 interval
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=Datetime.from_string('2013-02-12 09:08:07'))
+        intervals = self.calendar._get_day_work_intervals(start_dt=Datetime.from_string('2013-02-12 09:08:07'))
         self.assertEqual(len(intervals), 1)
         self.assertEqual(intervals[0], (Datetime.from_string('2013-02-12 09:08:07'), Datetime.from_string('2013-02-12 16:00:00')))
 
         # Test: day1, beginning at 10:30 -> work from 10:30 (arrival) until 16:00
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=Datetime.from_string('2013-02-19 10:30:00'))
+        intervals = self.calendar._get_day_work_intervals(start_dt=Datetime.from_string('2013-02-19 10:30:00'))
         self.assertEqual(len(intervals), 1)
         self.assertEqual(intervals[0], (Datetime.from_string('2013-02-19 10:30:00'), Datetime.from_string('2013-02-19 16:00:00')))
 
         # Test: day3 without leaves: 2 interval
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=Datetime.from_string('2013-02-15 10:11:12'))
+        intervals = self.calendar._get_day_work_intervals(start_dt=Datetime.from_string('2013-02-15 10:11:12'))
         self.assertEqual(len(intervals), 2)
         self.assertEqual(intervals[0], (Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00')))
         self.assertEqual(intervals[1], (Datetime.from_string('2013-02-15 16:00:00'), Datetime.from_string('2013-02-15 23:00:00')))
 
     def test_calendar_working_day_intervals_leaves_generic(self):
         # Test: day0 with leaves outside range: 1 interval
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=Datetime.from_string('2013-02-12 07:00:00'), compute_leaves=True)
+        intervals = self.calendar._get_day_work_intervals(start_dt=Datetime.from_string('2013-02-12 07:00:00'), compute_leaves=True)
         self.assertEqual(len(intervals), 1)
         self.assertEqual(intervals[0], (Datetime.from_string('2013-02-12 08:00:00'), Datetime.from_string('2013-02-12 16:00:00')))
 
         # Test: day0 with leaves: 2 intervals because of leave between 9 ans 12, ending at 15:45:30
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=Datetime.from_string('2013-02-19 08:15:00'),
+        intervals = self.calendar._get_day_work_intervals(start_dt=Datetime.from_string('2013-02-19 08:15:00'),
                                                                end_dt=Datetime.from_string('2013-02-19 15:45:30'),
                                                                compute_leaves=True)
         self.assertEqual(len(intervals), 2)
@@ -154,7 +153,7 @@ class TestCalendarBasics(TestResourceCommon):
 
     def test_calendar_working_day_intervals_leaves_resource(self):
         # Test: day1+14 on leave, with resource leave computation
-        intervals = self.calendar.get_working_intervals_of_day(
+        intervals = self.calendar._get_day_work_intervals(
             Datetime.from_string('2013-02-26 07:00:00'),
             compute_leaves=True,
             resource_id=self.resource1_id
@@ -170,76 +169,60 @@ class TestCalendarBasics(TestResourceCommon):
             'date_from': self.date2 + relativedelta(days=7),
             'date_to': False,
         })
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date2)
+        intervals = self.calendar._get_day_work_intervals(start_dt=self.date2)
         self.assertEqual(intervals, [(Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00'))])
 
         attendance.write({
             'date_from': False,
             'date_to': self.date2 - relativedelta(days=7),
         })
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date2)
+        intervals = self.calendar._get_day_work_intervals(start_dt=self.date2)
         self.assertEqual(intervals, [(Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00'))])
 
         attendance.write({
             'date_from': self.date2 + relativedelta(days=7),
             'date_to': self.date2 - relativedelta(days=7),
         })
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date2)
+        intervals = self.calendar._get_day_work_intervals(start_dt=self.date2)
         self.assertEqual(intervals, [(Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00'))])
 
         attendance.write({
             'date_from': self.date2,
             'date_to': self.date2,
         })
-        intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date2)
+        intervals = self.calendar._get_day_work_intervals(start_dt=self.date2)
         self.assertEqual(len(intervals), 2)
         self.assertEqual(intervals[0], (Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00')))
         self.assertEqual(intervals[1], (Datetime.from_string('2013-02-15 16:00:00'), Datetime.from_string('2013-02-15 23:00:00')))
 
     def test_calendar_working_hours_of_date(self):
         # Test: day1, beginning at 10:30 -> work from 10:30 (arrival) until 16:00
-        wh = self.calendar.get_working_hours_of_date(start_dt=Datetime.from_string('2013-02-19 10:30:00'))
+        wh = self.calendar.get_work_hours_count(Datetime.from_string('2013-02-19 10:30:00'), Datetime.from_string('2013-02-19 18:00:00'))
         self.assertEqual(wh, 5.5, 'resource_calendar: wrong working interval / day time computing')
 
 
 class ResourceWorkingHours(TestResourceCommon):
 
     def test_calendar_working_hours(self):
-        # old API: resource without leaves
-        # res: 2 weeks -> 40 hours
-        res = self.calendar._interval_hours_get(
-            Datetime.from_string('2013-02-12 06:00:00'),
-            Datetime.from_string('2013-02-22 23:00:00'),
-            resource_id=self.resource1_id, exclude_leaves=True)
-        self.assertEqual(res, 40.0)
-
         # new API: resource without leaves
         # res: 2 weeks -> 40 hours
-        res = self.calendar.get_working_hours(
+        res = self.calendar.get_work_hours_count(
             Datetime.from_string('2013-02-12 06:00:00'),
             Datetime.from_string('2013-02-22 23:00:00'),
             compute_leaves=False, resource_id=self.resource1_id)
         self.assertEqual(res, 40.0)
 
     def test_calendar_working_hours_leaves(self):
-        # old API: resource and leaves
-        # res: 2 weeks -> 40 hours - (3+4) leave hours
-        res = self.calendar._interval_hours_get(
-            Datetime.from_string('2013-02-12 06:00:00'),
-            Datetime.from_string('2013-02-22 23:00:00'),
-            resource_id=self.resource1_id, exclude_leaves=False)
-        self.assertEqual(res, 33.0)
-
         # new API: resource and leaves
         # res: 2 weeks -> 40 hours - (3+4) leave hours
-        res = self.calendar.get_working_hours(
+        res = self.calendar.get_work_hours_count(
             Datetime.from_string('2013-02-12 06:00:00'),
             Datetime.from_string('2013-02-22 23:00:00'),
             compute_leaves=True, resource_id=self.resource1_id)
         self.assertEqual(res, 33.0)
 
     def test_calendar_hours_scheduling_backward(self):
-        res = self.calendar.schedule_hours(-40, day_dt=Datetime.from_string('2013-02-12 09:00:00'))
+        res = self.calendar._schedule_hours(-40, day_dt=Datetime.from_string('2013-02-12 09:00:00'))
         # current day, limited at 09:00 because of day_dt specified -> 1 hour
         self.assertEqual(res[-1], (Datetime.from_string('2013-02-12 08:00:00'), Datetime.from_string('2013-02-12 09:00:00')))
         # previous days: 5+7 hours / 8 hours / 5+7 hours -> 32 hours
@@ -258,7 +241,7 @@ class ResourceWorkingHours(TestResourceCommon):
         self.assertEqual(seconds(td) / 3600.0, 40.0)
 
     def test_calendar_hours_scheduling_forward(self):
-        res = self.calendar.schedule_hours(40, day_dt=Datetime.from_string('2013-02-12 09:00:00'))
+        res = self.calendar._schedule_hours(40, day_dt=Datetime.from_string('2013-02-12 09:00:00'))
         self.assertEqual(res[0], (Datetime.from_string('2013-02-12 09:00:00'), Datetime.from_string('2013-02-12 16:00:00')))
         self.assertEqual(res[1], (Datetime.from_string('2013-02-15 08:00:00'), Datetime.from_string('2013-02-15 13:00:00')))
         self.assertEqual(res[2], (Datetime.from_string('2013-02-15 16:00:00'), Datetime.from_string('2013-02-15 23:00:00')))
@@ -273,7 +256,7 @@ class ResourceWorkingHours(TestResourceCommon):
         self.assertEqual(seconds(td) / 3600.0, 40.0)
 
     def test_calendar_hours_scheduling_forward_leaves_resource(self):
-        res = self.calendar.schedule_hours(
+        res = self.calendar._schedule_hours(
             40, day_dt=Datetime.from_string('2013-02-12 09:00:00'),
             compute_leaves=True, resource_id=self.resource1_id
         )
@@ -293,12 +276,12 @@ class ResourceWorkingHours(TestResourceCommon):
         self.assertEqual(seconds(td) / 3600.0, 40.0)
 
     def test_calendar_days_scheduling(self):
-        res = self.calendar.schedule_days_get_date(5, day_date=Datetime.from_string('2013-02-12 09:08:07') )
+        res = self.calendar.plan_days(5, day_date=Datetime.from_string('2013-02-12 09:08:07') )
         self.assertEqual(res.date(), Datetime.from_string('2013-02-26 00:00:00').date(), 'resource_calendar: wrong days scheduling')
-        res = self.calendar.schedule_days_get_date(-2, day_date=Datetime.from_string('2013-02-12 09:08:07') )
+        res = self.calendar.plan_days(-2, day_date=Datetime.from_string('2013-02-12 09:08:07') )
         self.assertEqual(res.date(), Datetime.from_string('2013-02-08 00:00:00').date(), 'resource_calendar: wrong days scheduling')
 
-        res = self.calendar.schedule_days_get_date(
+        res = self.calendar.plan_days(
             5, day_date=Datetime.from_string('2013-02-12 09:08:07'),
             compute_leaves=True, resource_id=self.resource1_id)
         self.assertEqual(res.date(), Datetime.from_string('2013-03-01 00:00:00').date(), 'resource_calendar: wrong days scheduling')
@@ -439,8 +422,3 @@ class TestWorkDays(TestResourceCommon):
         self.assertFalse(r._is_work_day(date(1932, 11, 19)))  # sat
         self.assertFalse(r._is_work_day(date(1932, 11, 20)))  # sun
         self.assertFalse(r._is_work_day(date(1932, 12, 6)))  # personal leave
-
-def seconds(td):
-    assert isinstance(td, timedelta)
-
-    return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10.**6