diff --git a/appointment_update/__init__.py b/appointment_update/__init__.py new file mode 100644 index 00000000000..91c5580fed3 --- /dev/null +++ b/appointment_update/__init__.py @@ -0,0 +1,2 @@ +from . import controllers +from . import models diff --git a/appointment_update/__manifest__.py b/appointment_update/__manifest__.py new file mode 100644 index 00000000000..1685514605e --- /dev/null +++ b/appointment_update/__manifest__.py @@ -0,0 +1,13 @@ +{ + 'name': 'Appointment update', + 'version': '1.0', + 'description': """ +Allow clients to Schedule Appointments through the Portal and book multiple appointment + """, + 'depends': ['appointment', 'appointment_account_payment', 'website_appointment'], + 'data': [ + 'views/appointment_update_type_views.xml', + ], + 'installable': True, + 'license': 'OEEL-1', +} diff --git a/appointment_update/controllers/__init__.py b/appointment_update/controllers/__init__.py new file mode 100644 index 00000000000..31b949e5055 --- /dev/null +++ b/appointment_update/controllers/__init__.py @@ -0,0 +1 @@ +from . import appointment_update diff --git a/appointment_update/controllers/appointment_update.py b/appointment_update/controllers/appointment_update.py new file mode 100644 index 00000000000..2b95b559e40 --- /dev/null +++ b/appointment_update/controllers/appointment_update.py @@ -0,0 +1,181 @@ +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.tools import email_normalize +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 AppointmentUpdateController(AppointmentController): + + def _prepare_appointment_type_page_values(self, appointment_type, staff_user_id=False, resource_selected_id=False, **kwargs): + result = 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 + track_capacity = appointment_type.track_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 + if track_capacity == 'one_booking_per_slot' or track_capacity == 'multiple_booking_per_slot': + max_capacity_possible = 1 + elif track_capacity == 'multiple_seat_per_slot': + if appointment_type.schedule_based_on == 'users': + max_capacity_possible = appointment_type.total_booking + 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 + result['max_capacity'] = min(12, max_capacity_possible) + return result + + 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; + """ + # res = super().appointment_form_submit(appointment_type_id, datetime_str, duration_str, name, phone, email, staff_user_id, available_resource_ids, asked_capacity, guest_emails_str, **kwargs) + + 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 + 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'))) + + 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 = [] + track_capacity = appointment_type.track_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, + # my code changes + 'capacity_used': new_capacity_reserved if track_capacity != 'one_booking_per_slot' and resource.shareable else resource.capacity + }) + 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) diff --git a/appointment_update/models/__init__.py b/appointment_update/models/__init__.py new file mode 100644 index 00000000000..ff835dc7e51 --- /dev/null +++ b/appointment_update/models/__init__.py @@ -0,0 +1,2 @@ +from . import appointment_update_type +from . import appointment_update_booking_line diff --git a/appointment_update/models/appointment_update_booking_line.py b/appointment_update/models/appointment_update_booking_line.py new file mode 100644 index 00000000000..86afdce8ad6 --- /dev/null +++ b/appointment_update/models/appointment_update_booking_line.py @@ -0,0 +1,17 @@ +from odoo import api, models + +class AppointmentBookingLine(models.Model): + _inherit = "appointment.booking.line" + + @api.depends('appointment_resource_id.capacity', 'appointment_resource_id.shareable','appointment_type_id.track_capacity', 'capacity_reserved', 'appointment_type_id.total_booking') + 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.track_capacity == 'multiple_booking_per_slot': + 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.track_capacity == 'one_booking_per_slot'): + line.capacity_used = line.appointment_resource_id.capacity + else: + line.capacity_used = line.capacity_reserved diff --git a/appointment_update/models/appointment_update_type.py b/appointment_update/models/appointment_update_type.py new file mode 100644 index 00000000000..76db70e9406 --- /dev/null +++ b/appointment_update/models/appointment_update_type.py @@ -0,0 +1,56 @@ +from odoo import api, fields, models + +class AppointmentType(models.Model): + _inherit = "appointment.type" + + track_capacity = fields.Selection( + [ + ("one_booking_per_slot", "One Booking Per Slot"), + ("multiple_booking_per_slot", "Multiple Booking Per Slot"), + ("multiple_seat_per_slot", "Multiple Seat Per Slot"), + ], + string="Capacities", + store=True, + default="one_booking_per_slot", + compute="_compute_resource_manage_capacity", + required=True, + readonly=False, + help="""Manage the maximum number of bookings that seats and resources can handle. "One booking per slot" means each user can book a slot exclusively, +while "multiple bookings per slot" allows multiple bookings based on user input. +"Multiple seat per slot" indicates that bookings can be made according to the user's capacity.""", + ) + total_booking = fields.Integer("Total Booking", default=1) + + _sql_constraints = [ + ("check_total_booking", "check(total_booking >= 1)", "total booking/seats should be at least 1."), + ] + + @api.onchange("track_capacity") + def _onchange_track_capacity(self): + if (self.track_capacity == "one_booking_per_slot"): + self.resource_manage_capacity = False + else: + self.resource_manage_capacity = True + + def _slot_availability_is_resource_available(self, slot, resource, availability_values): + result = super()._slot_availability_is_resource_available(slot,resource, availability_values) + + slot_start_dt_utc, slot_end_dt_utc = slot['UTC'][0], slot['UTC'][1] + resource_to_bookings = availability_values.get('resource_to_bookings') + + if resource_to_bookings.get(resource): + if resource_to_bookings[resource].filtered(lambda bl: bl.event_start < slot_end_dt_utc and bl.event_stop > slot_start_dt_utc): + if self.track_capacity == "multiple_booking_per_slot": + result = True + elif self.track_capacity == "multiple_seat_per_slot": + result = resource.shareable + return result + + def _slot_availability_select_best_resources(self, capacity_info, asked_capacity): + result = super()._slot_availability_select_best_resources(capacity_info, asked_capacity) + available_resources = self.env['appointment.resource'].concat(*capacity_info.keys()).sorted('sequence') + + if self.track_capacity == "one_booking_per_slot": + return available_resources[0] if self.assign_method != "time_resource" else available_resources + + return result diff --git a/appointment_update/views/appointment_update_type_views.xml b/appointment_update/views/appointment_update_type_views.xml new file mode 100644 index 00000000000..f5d7b8343fa --- /dev/null +++ b/appointment_update/views/appointment_update_type_views.xml @@ -0,0 +1,53 @@ + + + + appointment.type.view.form.inherit.appointment.update.type.view + appointment.type + + + + + + 1 + + + + + appointment.type.view.form.inherit.appointment.update.type.view + appointment.type + + + + per booking + + + per seat + + + + + +