[IMP] appointment_capacity: added test cases for usr/resource remaining capacity

dvpa-odoo · dvpa-odoo · commit 0d4e1d86db43 · 2025-04-10T11:02:24.000+05:30
diff --git a/appointment_capacity/__manifest__.py b/appointment_capacity/__manifest__.py
@@ -1,18 +1,18 @@
 {
-    'name': 'Appointment Capacity Management',
-    'version': '1.0',
-    'summary': 'Enhance appointment booking with multiple bookings and seats per slot.',
-    'description': """
+    "name": "Appointment Capacity Management",
+    "version": "1.0",
+    "summary": "Enhance appointment booking with multiple bookings and seats per slot.",
+    "description": """
         - Allows multiple bookings per time slot.
         - Supports multiple seats per slot.
     """,
-    'author': 'Darshan Patel',
-    'depends': ['appointment','appointment_account_payment', 'calendar'],
-    'data': [
-        'views/appointment_type_views.xml',
-        'views/appointment_template_appointment.xml',
-        'views/calendar_event_views.xml',
+    "author": "Darshan Patel",
+    "depends": ["appointment", "appointment_account_payment", "calendar"],
+    "data": [
+        "views/appointment_type_views.xml",
+        "views/appointment_template_appointment.xml",
+        "views/calendar_event_views.xml",
     ],
-    'installable': True,
-    'license': 'LGPL-3',
+    "installable": True,
+    "license": "LGPL-3",
 }
diff --git a/appointment_capacity/controllers/appointment.py b/appointment_capacity/controllers/appointment.py
@@ -16,13 +16,12 @@
 
 class AppointmentCapacityController(AppointmentController):
 
-
     def _prepare_appointment_type_page_values(self, appointment_type, staff_user_id=False, resource_selected_id=False, skip_resource_selection=False, **kwargs):
         """
         Overrides `_prepare_appointment_type_page_values` to include capacity management based on `capacity_type`.
         """
         values = super()._prepare_appointment_type_page_values(appointment_type, staff_user_id, resource_selected_id, **kwargs)
-        
+
         if appointment_type.capacity_type == 'multiple_seats':
             if appointment_type.schedule_based_on == 'users':
                 max_capacity_possible = appointment_type.user_capacity_count
@@ -31,10 +30,9 @@ def _prepare_appointment_type_page_values(self, appointment_type, staff_user_id=
                 max_capacity_possible = possible_combinations[-1][1] if possible_combinations else 1
         else:
             max_capacity_possible = 1
-        
-        values['max_capacity_possible'] = min(12, max_capacity_possible)
-        return values
 
+        values['max_capacity'] = min(12, max_capacity_possible)
+        return values
 
     @http.route()
     def appointment_form_submit(self, appointment_type_id, datetime_str, duration_str, name, phone, email, staff_user_id=None, available_resource_ids=None, asked_capacity=1,
@@ -106,7 +104,6 @@ def appointment_form_submit(self, appointment_type_id, datetime_str, duration_st
             if users_remaining_capacity['total_remaining_capacity'] < asked_capacity and appointment_type.capacity_type != 'one_booking':
                 return request.redirect('/appointment/%s?%s' % (appointment_type.id, keep_query('*', state='failed-staff-user')))
 
-
         guests = None
         if appointment_type.allow_guests:
             if guest_emails_str:
@@ -156,7 +153,7 @@ def appointment_form_submit(self, appointment_type_id, datetime_str, duration_st
             'partner_id': customer.id,
         }
 
-        for question in appointment_type.question_ids.filtered(lambda question: question.id in partner_inputs.keys()):
+        for question in appointment_type.question_ids.filtered(lambda question: question.id in partner_inputs):
             if question.question_type == 'checkbox':
                 answers = question.answer_ids.filtered(lambda answer: answer.id in partner_inputs[question.id])
                 answer_input_values.extend([
@@ -181,7 +178,7 @@ def appointment_form_submit(self, appointment_type_id, datetime_str, duration_st
                 booking_line_values.append({
                     'appointment_resource_id': resource.id,
                     'capacity_reserved': new_capacity_reserved,
-                    'capacity_used': new_capacity_reserved if resource.shareable and appointment_type.capacity_type != 'single_booking' else resource.capacity,
+                    'capacity_used': new_capacity_reserved if resource.shareable and appointment_type.capacity_type != 'one_booking' else resource.capacity,
                 })
         else:
             user_remaining_capacity = users_remaining_capacity['total_remaining_capacity']
diff --git a/appointment_capacity/models/appointment_booking.py b/appointment_capacity/models/appointment_booking.py
@@ -5,7 +5,7 @@ class AppointmentBookingLine(models.Model):
     _inherit = "appointment.booking.line"
 
     appointment_user_id = fields.Many2one('res.users', string="Appointment user", ondelete="cascade")
-    appointment_resource_id = fields.Many2one('appointment.resource', string="Appointment Resource",ondelete="cascade",required=False)
+    appointment_resource_id = fields.Many2one('appointment.resource', string="Appointment Resource", ondelete="cascade", required=False)
 
     @api.depends(
         "appointment_resource_id.capacity",
@@ -23,7 +23,7 @@ def _compute_capacity_used(self):
                 line.capacity_used = 1
             elif line.appointment_type_id.capacity_type == 'multiple_seats':
                 line.capacity_used = line.capacity_reserved
-            elif (not line.appointment_resource_id.shareable or line.appointment_type_id.capacity_type == 'single_booking') and line.appointment_type_id.schedule_based_on == 'resources':
+            elif (not line.appointment_resource_id.shareable or line.appointment_type_id.capacity_type == 'one_booking') and line.appointment_type_id.schedule_based_on == 'resources':
                 line.capacity_used = line.appointment_resource_id.capacity
             else:
                 line.capacity_used = line.capacity_reserved
diff --git a/appointment_capacity/models/appointment_type.py b/appointment_capacity/models/appointment_type.py
@@ -18,22 +18,20 @@ class AppointmentType(models.Model):
 
     capacity_type = fields.Selection(
         [
-            ("single_booking", "Single Booking"),
+            ("one_booking", "One Booking"),
             ("multiple_bookings", "Multiple Bookings"),
             ("multiple_seats", "Multiple Seats"),
         ],
         string="Capacity Type",
         required=True,
-        default="single_booking",
+        default="one_booking",
     )
-
     user_capacity_count = fields.Integer(
         "User cpacity count",
         default=1,
         help="Maximum number of users bookings per slot (for multiple bookings or multiple seats).",
     )
 
-
     @api.constrains("user_capacity_count")
     def _check_user_capacity_count(self):
         for record in self:
@@ -91,7 +89,7 @@ def _slot_availability_is_resource_available(self, slot, resource, availability_
         slot_start_dt_utc, slot_end_dt_utc = slot['UTC'][0], slot['UTC'][1]
         resource_to_bookings = availability_values.get('resource_to_bookings')
         # Check if there is already a booking line for the time slot and make it available
-        # only if the resource is shareable and the capacity_type is not single_booking.
+        # only if the resource is shareable and the capacity_type is not one_booking.
         # This avoid to mark the resource as "available" and compute unnecessary remaining capacity computation
         # because of potential linked resources.
         if resource_to_bookings.get(resource):
@@ -108,7 +106,6 @@ def _slot_availability_is_resource_available(self, slot, resource, availability_
 
         return True
 
-
     def _slot_availability_select_best_resources(self, capacity_info, asked_capacity):
         """ Check and select the best resources for the capacity needed
             :params main_resources_remaining_capacity <dict>: dict containing remaining capacities of resources available
@@ -120,7 +117,7 @@ def _slot_availability_select_best_resources(self, capacity_info, asked_capacity
         available_resources = self.env['appointment.resource'].concat(*capacity_info.keys()).sorted('sequence')
         if not available_resources:
             return self.env['appointment.resource']
-        if self.capacity_type == 'single_booking':
+        if self.capacity_type == 'one_booking':
             return available_resources[0] if self.assign_method != 'time_resource' else available_resources
 
         perfect_matches = available_resources.filtered(
@@ -209,10 +206,9 @@ def _slots_fill_users_availability(self, slots, start_dt, end_dt, filter_users=N
                 else:
                     slot['staff_user_id'] = available_staff_users
 
-
-
     def _slot_availability_is_user_available(self, slot, staff_user, availability_values, asked_capacity=1):
-        """ This method verifies if the user is available on the given slot.
+        """
+        This method verifies if the user is available on the given slot.
         It checks whether the user has calendar events clashing and if he
         is included in slot's restricted users.
 
@@ -247,7 +243,7 @@ def _slot_availability_is_user_available(self, slot, staff_user, availability_va
                 #     return False
                 for event in day_events:
                     if not event.allday and (event.start < slot_end_dt_utc and event.stop > slot_start_dt_utc):
-                        if self.capacity_type != "single_booking" and self == event.appointment_type_id:
+                        if self.capacity_type != "one_booking" and self == event.appointment_type_id:
                             if users_remaining_capacity['total_remaining_capacity'] >= asked_capacity:
                                 continue
                         return False
@@ -261,7 +257,7 @@ def _slot_availability_is_user_available(self, slot, staff_user, availability_va
         return True
 
     def _get_users_remaining_capacity(self, users, slot_start_utc, slot_stop_utc, availability_values=None):
-        """ 
+        """
         Compute the remaining capacity for users in a specific time slot.
         :param <res.users> users : record containing one or a multiple of user
         :param datetime slot_start_utc: start of slot (in naive UTC)
@@ -297,7 +293,7 @@ def _get_users_remaining_capacity(self, users, slot_start_utc, slot_stop_utc, av
         return users_remaining_capacity
 
     def _slot_availability_prepare_users_values(self, staff_users, start_dt, end_dt):
-        """ 
+        """
         Override to add booking values.
 
         :return: update ``super()`` values with users booking vaues, formatted like
@@ -312,11 +308,11 @@ def _slot_availability_prepare_users_values(self, staff_users, start_dt, end_dt)
 
     def _slot_availability_prepare_users_bookings_values(self, users, start_dt_utc, end_dt_utc):
         """
-        This method retrieves and organizes bookings for the given users within the specified time range. 
-        Users may handle multiple appointment types, so all overlapping bookings must be considered 
+        This method retrieves and organizes bookings for the given users within the specified time range.
+        Users may handle multiple appointment types, so all overlapping bookings must be considered
         to prevent double booking.
 
-        :param <res.users> users: A recordset of staff users for whom availability is being checked. 
+        :param <res.users> users: A recordset of staff users for whom availability is being checked.
         :param datetime start_dt_utc: The start of the appointment check boundary in UTC.
         :param datetime end_dt_utc: The end of the appointment check boundary in UTC.
 
@@ -339,7 +335,8 @@ def _slot_availability_prepare_users_bookings_values(self, users, start_dt_utc,
         }
 
     def _get_appointment_slots(self, timezone, filter_users=None, filter_resources=None, asked_capacity=1, reference_date=None):
-        """ Fetch available slots to book an appointment.
+        """
+        Fetch available slots to book an appointment.
 
         :param str timezone: timezone string e.g.: 'Europe/Brussels' or 'Etc/GMT+1'
         :param <res.users> filter_users: filter available slots for those users (can be a singleton
@@ -390,13 +387,13 @@ def _get_appointment_slots(self, timezone, filter_users=None, filter_resources=N
         if self.category == 'custom' and unique_slots:
             # Custom appointment type, the first day should depend on the first slot datetime
             start_first_slot = unique_slots[0].start_datetime
-            first_day_utc = start_first_slot if reference_date > start_first_slot else reference_date
+            first_day_utc = min(reference_date, start_first_slot)
             first_day = requested_tz.fromutc(first_day_utc + relativedelta(hours=self.min_schedule_hours))
             appointment_duration_days = (unique_slots[-1].end_datetime.date() - reference_date.date()).days
             last_day = requested_tz.fromutc(reference_date + relativedelta(days=appointment_duration_days))
         elif self.category == 'punctual':
             # Punctual appointment type, the first day is the start_datetime if it is in the future, else the first day is now
-            first_day = requested_tz.fromutc(self.start_datetime if self.start_datetime > now else now)
+            first_day = requested_tz.fromutc(max(now, self.start_datetime))
             last_day = requested_tz.fromutc(self.end_datetime)
         else:
             # Recurring appointment type
diff --git a/appointment_capacity/models/calender_event.py b/appointment_capacity/models/calender_event.py
@@ -1,5 +1,5 @@
 from odoo import models, fields, api
-from odoo.exceptions import ValidationError
+
 
 class CalendarEvent(models.Model):
     _inherit = "calendar.event"
@@ -15,13 +15,13 @@ def _inverse_resource_ids_or_capacity(self):
                 # Ignore the inverse and keep the previous booking lines when we duplicate an event
                 if self.env.context.get('is_appointment_copied'):
                     continue
-                if event.appointment_type_capacity_type != 'single_booking' and self.resource_total_capacity_reserved:
-                    capacity_to_reserve = self.resource_total_capacity_reserved
+                if event.appointment_type_capacity_type != 'one_booking' and event.resource_total_capacity_reserved:
+                    capacity_to_reserve = event.resource_total_capacity_reserved
                 else:
                     capacity_to_reserve = sum(event.booking_line_ids.mapped('capacity_reserved')) or sum(resources.mapped('capacity'))
                 event.booking_line_ids.sudo().unlink()
                 for resource in resources.sorted("shareable"):
-                    if event.appointment_type_capacity_type != 'single_booking' and capacity_to_reserve <= 0:
+                    if event.appointment_type_capacity_type != 'one_booking' and capacity_to_reserve <= 0:
                         break
                     booking_lines.append({
                         'appointment_resource_id': resource.id,
diff --git a/appointment_capacity/models/res_partner.py b/appointment_capacity/models/res_partner.py
@@ -1,11 +1,13 @@
 from odoo import models
 from datetime import datetime, time
 
+
 class ResPartnerInherited(models.Model):
     _inherit = 'res.partner'
 
     def calendar_verify_availability(self, date_start, date_end):
-        """ Verify availability of the partner(s) between 2 datetimes on their calendar.
+        """
+        Verify availability of the partner(s) between 2 datetimes on their calendar.
         We only verify events that are not linked to an appointment type with resources since
         someone could take multiple appointment for multiple resources. The availability of
         resources is managed separately by booking lines (see ``appointment.booking.line`` model)
@@ -26,7 +28,7 @@ def calendar_verify_availability(self, date_start, date_end):
         events_excluding_appointment_resource = all_events.filtered(lambda ev: ev.appointment_type_id.schedule_based_on != 'resources')
         for event in events_excluding_appointment_resource:
             if event.allday or (event.start < date_end and event.stop > date_start):
-                if event.appointment_type_id and event.appointment_type_id.capacity_type != 'single_booking' and all(user in event.appointment_type_id.staff_user_ids.partner_id for user in self):
+                if event.appointment_type_id and event.appointment_type_id.capacity_type != 'one_booking' and all(user in event.appointment_type_id.staff_user_ids.partner_id for user in self):
                     continue
                 if event.attendee_ids.filtered_domain(
                         [('state', '!=', 'declined'),
diff --git a/appointment_capacity/tests/__init__.py b/appointment_capacity/tests/__init__.py
@@ -0,0 +1 @@
+from . import test_appointment_booking
diff --git a/appointment_capacity/tests/test_appointment_booking.py b/appointment_capacity/tests/test_appointment_booking.py
diff --git a/appointment_capacity/views/appointment_type_views.xml b/appointment_capacity/views/appointment_type_views.xml
diff --git a/appointment_capacity/views/calendar_event_views.xml b/appointment_capacity/views/calendar_event_views.xml
