[IMP] appointment_capacity: support user capacity customization

implement to single ticket per slot and multiple booking per slot
drop down selection and availability based on users and resources we can
ask for fronted side integer number to how many times particular slot is
booking when multiple booking selection also we have to add multiple seat
per slot when user want to multiple seat at a time.

Author: assk-odoo

appointment_capacity/__init__.py

@@ -0,0 +1,2 @@
+from . import controllers
+from . import models

appointment_capacity/__manifest__.py

@@ -0,0 +1,20 @@
+{
+    'name': "Appointment Capacity",
+    'summary': "change the capacity of the appointment based on the user and resource",
+    'description':"capacity of the appointment is change base on the type of the appointment",
+    'author':"sujal asodariya",
+    'version':"1.0",
+    'depends':[
+        "appointment",
+        "website",
+        "calendar",
+        "account_auto_transfer",
+    ],
+    'data':[
+        'views/appointment_template_views.xml',
+        'views/appointment_type_views.xml',
+    ],
+    'installable':True,
+    'application':True,
+    'license':"LGPL-3",
+}

appointment_capacity/controllers/__init__.py

@@ -0,0 +1 @@
+from . import appointment_booking 

appointment_capacity/controllers/appointment_booking.py

@@ -0,0 +1,213 @@
+import json
+import pytz 
+import re
+from dateutil.relativedelta import relativedelta
+from urllib.parse import unquote_plus
+from werkzeug.exceptions import NotFound
+from odoo import fields
+from odoo.http import request
+from odoo import http
+from odoo.addons.base.models.ir_qweb import keep_query
+from odoo.addons.phone_validation.tools import phone_validation
+from odoo.addons.appointment.controllers.appointment import AppointmentController
+
+class AppointmentCapacityOverride(AppointmentController):
+
+    def _prepare_appointment_type_page_values(self, appointment_type, staff_user_id=False, resource_selected_id=False, **kwargs):
+        res = super()._prepare_appointment_type_page_values(appointment_type, staff_user_id, resource_selected_id, **kwargs)
+
+        filter_resource_ids = json.loads(kwargs.get('filter_resource_ids') or '[]')
+        resources_possible = self._get_possible_resources(appointment_type, filter_resource_ids)
+        resource_default = resource_selected = request.env['appointment.resource']
+        staff_user_id = int(staff_user_id) if staff_user_id else False
+        resource_selected_id = int(resource_selected_id) if resource_selected_id else False
+        manage_capacity_type = appointment_type.resource_capacity
+
+        max_capacity_possible = 0
+
+        if resources_possible:
+            if resource_selected_id and resource_selected_id in resources_possible.ids and appointment_type.assign_method != 'time_resource':
+                resource_selected = request.env['appointment.resource'].sudo().browse(resource_selected_id)
+            elif appointment_type.assign_method == 'resource_time':
+                resource_default = resources_possible[0]
+
+        # my code changes
+        manage_capacity_type = appointment_type.resource_capacity
+        if manage_capacity_type == 'one_booking' or manage_capacity_type == 'multi_booking':
+            max_capacity_possible = 1
+        elif manage_capacity_type == 'multi_seat':
+            if appointment_type.schedule_based_on == 'users':
+                max_capacity_possible = appointment_type.capacity_count or 1  # Default to 1 if not set
+            else:
+                possible_combinations = (resource_selected or resource_default or resources_possible)._get_filtered_possible_capacity_combinations(1, {})
+                max_capacity_possible = possible_combinations[-1][1] if possible_combinations else 1
+        res['max_capacity'] = min(12, max_capacity_possible)
+        return res
+
+    @http.route(['/appointment/<int:appointment_type_id>/submit'],
+                type='http', auth="public", website=True, methods=["POST"])
+    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,
+                                guest_emails_str=None, **kwargs):
+        """
+        Create the event for the appointment and redirect on the validation page with a summary of the appointment.
+
+        :param appointment_type_id: the appointment type id related
+        :param datetime_str: the string representing the datetime
+        :param duration_str: the string representing the duration
+        :param name: the name of the user sets in the form
+        :param phone: the phone of the user sets in the form
+        :param email: the email of the user sets in the form
+        :param staff_user_id: the user selected for the appointment
+        :param available_resource_ids: the resources ids available for the appointment
+        :param asked_capacity: asked capacity for the appointment
+        :param str guest_emails: optional line-separated guest emails. It will
+        fetch or create partners to add them as event attendees;
+        """
+        
+        domain = self._appointments_base_domain(
+            filter_appointment_type_ids=kwargs.get('filter_appointment_type_ids'),
+            search=kwargs.get('search'),
+            invite_token=kwargs.get('invite_token')
+        )
+        available_appointments = self._fetch_and_check_private_appointment_types(
+            kwargs.get('filter_appointment_type_ids'),
+            kwargs.get('filter_staff_user_ids'),
+            kwargs.get('filter_resource_ids'),
+            kwargs.get('invite_token'),
+            domain=domain,
+        )
+        appointment_type = available_appointments.filtered(lambda appt: appt.id == int(appointment_type_id))
+
+        if not appointment_type:
+            raise NotFound()
+        timezone = request.session.get('timezone') or appointment_type.appointment_tz
+        tz_session = pytz.timezone(timezone)
+        datetime_str = unquote_plus(datetime_str)
+        date_start = tz_session.localize(fields.Datetime.from_string(datetime_str)).astimezone(pytz.utc).replace(tzinfo=None)
+        duration = float(duration_str)
+        date_end = date_start + relativedelta(hours=duration)
+        invite_token = kwargs.get('invite_token')
+
+        staff_user = request.env['res.users']
+        resources = request.env['appointment.resource']
+        resource_ids = None
+        asked_capacity = int(asked_capacity)
+        resources_remaining_capacity = None
+        users_remaining_capacity = None
+        if appointment_type.schedule_based_on == 'resources':
+            resource_ids = json.loads(unquote_plus(available_resource_ids))
+            # Check if there is still enough capacity (in case someone else booked with a resource in the meantime)
+            resources = request.env['appointment.resource'].sudo().browse(resource_ids).exists()
+            if any(resource not in appointment_type.resource_ids for resource in resources):
+                raise NotFound()
+            resources_remaining_capacity = appointment_type._get_resources_remaining_capacity(resources, date_start, date_end, with_linked_resources=False)
+            if resources_remaining_capacity['total_remaining_capacity'] < asked_capacity:
+                return request.redirect('/appointment/%s?%s' % (appointment_type.id, keep_query('*', state='failed-resource')))
+            # change for the users selection
+        else:
+            # check availability of the selected user again (in case someone else booked while the client was entering the form)
+            staff_user = request.env['res.users'].sudo().search([('id', '=', int(staff_user_id))])
+            if staff_user not in appointment_type.staff_user_ids:
+                raise NotFound()
+            users_remaining_capacity = appointment_type._get_users_remaining_capacity(staff_user, date_start, date_end)
+            if staff_user and not staff_user.partner_id.calendar_verify_availability(date_start, date_end) or (appointment_type.resource_capacity != 'one_booking' and users_remaining_capacity['total_remaining_capacity'] < asked_capacity):
+                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:
+                guests = request.env['calendar.event'].sudo()._find_or_create_partners(guest_emails_str)
+
+        customer = self._get_customer_partner()
+
+        # email is mandatory
+        new_customer = not customer.email
+        if not new_customer and customer.email != email and customer.email_normalized != email_normalize(email):
+            new_customer = True
+        if not new_customer:
+            # phone is mandatory
+            if not customer.phone:
+                customer.phone = customer._phone_format(number=phone) or phone
+            else:
+                customer_phone_fmt = customer._phone_format(fname="phone")
+                input_country = self._get_customer_country()
+                input_phone_fmt = phone_validation.phone_format(phone, input_country.code, input_country.phone_code, force_format="E164", raise_exception=False)
+                new_customer = customer.phone != phone and customer_phone_fmt != input_phone_fmt
+
+        if new_customer:
+            customer = customer.sudo().create({
+                'name': name,
+                'phone': customer._phone_format(number=phone, country=self._get_customer_country()) or phone,
+                'email': email,
+                'lang': request.lang.code,
+            })
+
+        # partner_inputs dictionary structures all answer inputs received on the appointment submission: key is question id, value
+        # is answer id (as string) for choice questions, text input for text questions, array of ids for multiple choice questions.
+        partner_inputs = {}
+        appointment_question_ids = appointment_type.question_ids.ids
+        for k_key, k_value in [item for item in kwargs.items() if item[1]]:
+            question_id_str = re.match(r"\bquestion_([0-9]+)\b", k_key)
+            if question_id_str and int(question_id_str.group(1)) in appointment_question_ids:
+                partner_inputs[int(question_id_str.group(1))] = k_value
+                continue
+            checkbox_ids_str = re.match(r"\bquestion_([0-9]+)_answer_([0-9]+)\b", k_key)
+            if checkbox_ids_str:
+                question_id, answer_id = [int(checkbox_ids_str.group(1)), int(checkbox_ids_str.group(2))]
+                if question_id in appointment_question_ids:
+                    partner_inputs[question_id] = partner_inputs.get(question_id, []) + [answer_id]
+
+        # The answer inputs will be created in _prepare_calendar_event_values from the values in answer_input_values
+        answer_input_values = []
+        base_answer_input_vals = {
+            'appointment_type_id': appointment_type.id,
+            'partner_id': customer.id,
+        }
+
+        for question in appointment_type.question_ids.filtered(lambda question: question.id in partner_inputs.keys()):
+            if question.question_type == 'checkbox':
+                answers = question.answer_ids.filtered(lambda answer: answer.id in partner_inputs[question.id])
+                answer_input_values.extend([
+                    dict(base_answer_input_vals, question_id=question.id, value_answer_id=answer.id) for answer in answers
+                ])
+            elif question.question_type in ['select', 'radio']:
+                answer_input_values.append(
+                    dict(base_answer_input_vals, question_id=question.id, value_answer_id=int(partner_inputs[question.id]))
+                )
+            elif question.question_type in ['char', 'text']:
+                answer_input_values.append(
+                    dict(base_answer_input_vals, question_id=question.id, value_text_box=partner_inputs[question.id].strip())
+                )
+
+        booking_line_values = []
+        resource_capacity = appointment_type.resource_capacity
+        if appointment_type.schedule_based_on == 'resources':
+            capacity_to_assign = asked_capacity
+            for resource in resources:
+                resource_remaining_capacity = resources_remaining_capacity.get(resource)
+                new_capacity_reserved = min(resource_remaining_capacity, capacity_to_assign, resource.capacity)
+                capacity_to_assign -= new_capacity_reserved
+                booking_line_values.append({
+                    'appointment_resource_id': resource.id,
+                    'capacity_reserved': new_capacity_reserved,
+                    'capacity_used': new_capacity_reserved if resource_capacity != 'one_booking' and resource.shareable else resource.capacity
+                })
+                # changes for the users selection
+        else:
+            user_remaining_capacity = users_remaining_capacity['total_remaining_capacity']
+            new_capacity_reserved = min(user_remaining_capacity, asked_capacity, appointment_type.capacity_count)
+            booking_line_values.append({
+                    'appointment_user_id': staff_user.id,
+                    'capacity_reserved': new_capacity_reserved,
+                    'capacity_used': new_capacity_reserved,
+                    })
+                
+        if invite_token:
+            appointment_invite = request.env['appointment.invite'].sudo().search([('access_token', '=', invite_token)])
+        else:
+            appointment_invite = request.env['appointment.invite']
+
+        return self._handle_appointment_form_submission(
+            appointment_type, date_start, date_end, duration, answer_input_values, name,
+            customer, appointment_invite, guests, staff_user, asked_capacity, booking_line_values
+        )

appointment_capacity/models/__init__.py

@@ -0,0 +1,6 @@
+from . import appointment_type
+from . import appointment_booking_line
+from . import calender_event
+from . import res_partner
+from . import calender_booking_line
+

appointment_capacity/models/appointment_booking_line.py

@@ -0,0 +1,21 @@
+from odoo import api, models,fields
+
+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)
+
+    @api.depends('appointment_resource_id.capacity', 'appointment_resource_id.shareable',
+                'appointment_type_id.resource_capacity', 'capacity_reserved','appointment_type_id.capacity_count')
+    def _compute_capacity_used(self):
+        self.capacity_used = 0
+        for line in self:
+            if line.capacity_reserved == 0:
+                line.capacity_used = 0
+            elif line.appointment_type_id.resource_capacity == 'multi_booking':
+                line.capacity_used = 1
+            elif line.appointment_type_id.schedule_based_on == 'resources' and (not line.appointment_resource_id.shareable or line.appointment_type_id.resource_capacity == 'one_booking'):
+                line.capacity_used = line.appointment_resource_id.capacity
+            else:
+                line.capacity_used = line.capacity_reserved