462 lines
17 KiB
Python
462 lines
17 KiB
Python
from typing import Union, Optional, Any, TypeVar
|
|
from pydantic import BaseModel, ConfigDict, Field
|
|
from dataclasses import dataclass
|
|
from enum import Enum
|
|
|
|
# Import the generated classes
|
|
from generated.alpinebits import OtaHotelResNotifRq, OtaResRetrieveRs
|
|
|
|
# Define type aliases for the two Customer types
|
|
NotifCustomer = OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer
|
|
RetrieveCustomer = OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer
|
|
|
|
# Define type aliases for HotelReservationId types
|
|
NotifHotelReservationId = OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId
|
|
RetrieveHotelReservationId = OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId
|
|
|
|
|
|
# phonetechtype enum 1,3,5 voice, fax, mobile
|
|
class PhoneTechType(Enum):
|
|
VOICE = "1"
|
|
FAX = "3"
|
|
MOBILE = "5"
|
|
|
|
|
|
@dataclass
|
|
class CustomerData:
|
|
"""Simple data class to hold customer information without nested type constraints."""
|
|
|
|
given_name: str
|
|
surname: str
|
|
name_prefix: None | str = None
|
|
name_title: None | str = None
|
|
phone_numbers: list[tuple[str, None | PhoneTechType]] = (
|
|
None # (phone_number, phone_tech_type)
|
|
)
|
|
email_address: None | str = None
|
|
email_newsletter: None | bool = (
|
|
None # True for "yes", False for "no", None for not specified
|
|
)
|
|
address_line: None | str = None
|
|
city_name: None | str = None
|
|
postal_code: None | str = None
|
|
country_code: None | str = None # Two-letter country code
|
|
address_catalog: None | bool = (
|
|
None # True for "yes", False for "no", None for not specified
|
|
)
|
|
gender: None | str = None # "Unknown", "Male", "Female"
|
|
birth_date: None | str = None
|
|
language: None | str = None # Two-letter language code
|
|
|
|
def __post_init__(self):
|
|
if self.phone_numbers is None:
|
|
self.phone_numbers = []
|
|
|
|
|
|
class CustomerFactory:
|
|
"""Factory class to create Customer instances for both OtaHotelResNotifRq and OtaResRetrieveRs."""
|
|
|
|
@staticmethod
|
|
def create_notif_customer(data: CustomerData) -> NotifCustomer:
|
|
"""Create a Customer for OtaHotelResNotifRq."""
|
|
return CustomerFactory._create_customer(NotifCustomer, data)
|
|
|
|
@staticmethod
|
|
def create_retrieve_customer(data: CustomerData) -> RetrieveCustomer:
|
|
"""Create a Customer for OtaResRetrieveRs."""
|
|
return CustomerFactory._create_customer(RetrieveCustomer, data)
|
|
|
|
@staticmethod
|
|
def _create_customer(customer_class: type, data: CustomerData) -> Any:
|
|
"""Internal method to create a customer of the specified type."""
|
|
|
|
# Create PersonName
|
|
person_name = customer_class.PersonName(
|
|
given_name=data.given_name,
|
|
surname=data.surname,
|
|
name_prefix=data.name_prefix,
|
|
name_title=data.name_title,
|
|
)
|
|
|
|
# Create telephone list
|
|
telephones = []
|
|
for phone_number, phone_tech_type in data.phone_numbers:
|
|
telephone = customer_class.Telephone(
|
|
phone_number=phone_number,
|
|
phone_tech_type=phone_tech_type.value if phone_tech_type else None,
|
|
)
|
|
telephones.append(telephone)
|
|
|
|
# Create email if provided
|
|
email = None
|
|
if data.email_address:
|
|
remark = None
|
|
if data.email_newsletter is not None:
|
|
remark = f"newsletter:{'yes' if data.email_newsletter else 'no'}"
|
|
|
|
email = customer_class.Email(value=data.email_address, remark=remark)
|
|
|
|
# Create address if any address fields are provided
|
|
address = None
|
|
if any(
|
|
[data.address_line, data.city_name, data.postal_code, data.country_code]
|
|
):
|
|
country_name = None
|
|
if data.country_code:
|
|
country_name = customer_class.Address.CountryName(
|
|
code=data.country_code
|
|
)
|
|
|
|
address_remark = None
|
|
if data.address_catalog is not None:
|
|
address_remark = f"catalog:{'yes' if data.address_catalog else 'no'}"
|
|
|
|
address = customer_class.Address(
|
|
address_line=data.address_line,
|
|
city_name=data.city_name,
|
|
postal_code=data.postal_code,
|
|
country_name=country_name,
|
|
remark=address_remark,
|
|
)
|
|
|
|
# Create the customer
|
|
return customer_class(
|
|
person_name=person_name,
|
|
telephone=telephones,
|
|
email=email,
|
|
address=address,
|
|
gender=data.gender,
|
|
birth_date=data.birth_date,
|
|
language=data.language,
|
|
)
|
|
|
|
@staticmethod
|
|
def from_notif_customer(customer: NotifCustomer) -> CustomerData:
|
|
"""Convert a NotifCustomer back to CustomerData."""
|
|
return CustomerFactory._customer_to_data(customer)
|
|
|
|
@staticmethod
|
|
def from_retrieve_customer(customer: RetrieveCustomer) -> CustomerData:
|
|
"""Convert a RetrieveCustomer back to CustomerData."""
|
|
return CustomerFactory._customer_to_data(customer)
|
|
|
|
@staticmethod
|
|
def _customer_to_data(customer: Any) -> CustomerData:
|
|
"""Internal method to convert any customer type to CustomerData."""
|
|
|
|
# Extract phone numbers
|
|
phone_numbers = []
|
|
if customer.telephone:
|
|
for tel in customer.telephone:
|
|
phone_numbers.append(
|
|
(
|
|
tel.phone_number,
|
|
PhoneTechType(tel.phone_tech_type)
|
|
if tel.phone_tech_type
|
|
else None,
|
|
)
|
|
)
|
|
|
|
# Extract email info
|
|
email_address = None
|
|
email_newsletter = None
|
|
if customer.email:
|
|
email_address = customer.email.value
|
|
if customer.email.remark:
|
|
if "newsletter:yes" in customer.email.remark:
|
|
email_newsletter = True
|
|
elif "newsletter:no" in customer.email.remark:
|
|
email_newsletter = False
|
|
|
|
# Extract address info
|
|
address_line = None
|
|
city_name = None
|
|
postal_code = None
|
|
country_code = None
|
|
address_catalog = None
|
|
|
|
if customer.address:
|
|
address_line = customer.address.address_line
|
|
city_name = customer.address.city_name
|
|
postal_code = customer.address.postal_code
|
|
|
|
if customer.address.country_name:
|
|
country_code = customer.address.country_name.code
|
|
|
|
if customer.address.remark:
|
|
if "catalog:yes" in customer.address.remark:
|
|
address_catalog = True
|
|
elif "catalog:no" in customer.address.remark:
|
|
address_catalog = False
|
|
|
|
return CustomerData(
|
|
given_name=customer.person_name.given_name,
|
|
surname=customer.person_name.surname,
|
|
name_prefix=customer.person_name.name_prefix,
|
|
name_title=customer.person_name.name_title,
|
|
phone_numbers=phone_numbers,
|
|
email_address=email_address,
|
|
email_newsletter=email_newsletter,
|
|
address_line=address_line,
|
|
city_name=city_name,
|
|
postal_code=postal_code,
|
|
country_code=country_code,
|
|
address_catalog=address_catalog,
|
|
gender=customer.gender,
|
|
birth_date=customer.birth_date,
|
|
language=customer.language,
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class HotelReservationIdData:
|
|
"""Simple data class to hold hotel reservation ID information without nested type constraints."""
|
|
|
|
res_id_type: str # Required field - pattern: [0-9]+
|
|
res_id_value: None | str = None # Max 64 characters
|
|
res_id_source: None | str = None # Max 64 characters
|
|
res_id_source_context: None | str = None # Max 64 characters
|
|
|
|
|
|
class HotelReservationIdFactory:
|
|
"""Factory class to create HotelReservationId instances for both OtaHotelResNotifRq and OtaResRetrieveRs."""
|
|
|
|
@staticmethod
|
|
def create_notif_hotel_reservation_id(
|
|
data: HotelReservationIdData,
|
|
) -> NotifHotelReservationId:
|
|
"""Create a HotelReservationId for OtaHotelResNotifRq."""
|
|
return HotelReservationIdFactory._create_hotel_reservation_id(
|
|
NotifHotelReservationId, data
|
|
)
|
|
|
|
@staticmethod
|
|
def create_retrieve_hotel_reservation_id(
|
|
data: HotelReservationIdData,
|
|
) -> RetrieveHotelReservationId:
|
|
"""Create a HotelReservationId for OtaResRetrieveRs."""
|
|
return HotelReservationIdFactory._create_hotel_reservation_id(
|
|
RetrieveHotelReservationId, data
|
|
)
|
|
|
|
@staticmethod
|
|
def _create_hotel_reservation_id(
|
|
hotel_reservation_id_class: type, data: HotelReservationIdData
|
|
) -> Any:
|
|
"""Internal method to create a hotel reservation id of the specified type."""
|
|
return hotel_reservation_id_class(
|
|
res_id_type=data.res_id_type,
|
|
res_id_value=data.res_id_value,
|
|
res_id_source=data.res_id_source,
|
|
res_id_source_context=data.res_id_source_context,
|
|
)
|
|
|
|
@staticmethod
|
|
def from_notif_hotel_reservation_id(
|
|
hotel_reservation_id: NotifHotelReservationId,
|
|
) -> HotelReservationIdData:
|
|
"""Convert a NotifHotelReservationId back to HotelReservationIdData."""
|
|
return HotelReservationIdFactory._hotel_reservation_id_to_data(
|
|
hotel_reservation_id
|
|
)
|
|
|
|
@staticmethod
|
|
def from_retrieve_hotel_reservation_id(
|
|
hotel_reservation_id: RetrieveHotelReservationId,
|
|
) -> HotelReservationIdData:
|
|
"""Convert a RetrieveHotelReservationId back to HotelReservationIdData."""
|
|
return HotelReservationIdFactory._hotel_reservation_id_to_data(
|
|
hotel_reservation_id
|
|
)
|
|
|
|
@staticmethod
|
|
def _hotel_reservation_id_to_data(
|
|
hotel_reservation_id: Any,
|
|
) -> HotelReservationIdData:
|
|
"""Internal method to convert any hotel reservation id type to HotelReservationIdData."""
|
|
return HotelReservationIdData(
|
|
res_id_type=hotel_reservation_id.res_id_type,
|
|
res_id_value=hotel_reservation_id.res_id_value,
|
|
res_id_source=hotel_reservation_id.res_id_source,
|
|
res_id_source_context=hotel_reservation_id.res_id_source_context,
|
|
)
|
|
|
|
|
|
# Define type aliases for ResGuests types
|
|
NotifResGuests = OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests
|
|
RetrieveResGuests = OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests
|
|
|
|
|
|
class ResGuestFactory:
|
|
"""Factory class to create complete ResGuests structures with a primary customer."""
|
|
|
|
@staticmethod
|
|
def create_notif_res_guests(customer_data: CustomerData) -> NotifResGuests:
|
|
"""Create a complete ResGuests structure for OtaHotelResNotifRq with primary customer."""
|
|
return ResGuestFactory._create_res_guests(
|
|
NotifResGuests, NotifCustomer, customer_data
|
|
)
|
|
|
|
@staticmethod
|
|
def create_retrieve_res_guests(customer_data: CustomerData) -> RetrieveResGuests:
|
|
"""Create a complete ResGuests structure for OtaResRetrieveRs with primary customer."""
|
|
return ResGuestFactory._create_res_guests(
|
|
RetrieveResGuests, RetrieveCustomer, customer_data
|
|
)
|
|
|
|
@staticmethod
|
|
def _create_res_guests(
|
|
res_guests_class: type, customer_class: type, customer_data: CustomerData
|
|
) -> Any:
|
|
"""Internal method to create complete ResGuests structure."""
|
|
|
|
# Create the customer using the existing CustomerFactory
|
|
customer = CustomerFactory._create_customer(customer_class, customer_data)
|
|
|
|
# Create Profile with the customer
|
|
profile = res_guests_class.ResGuest.Profiles.ProfileInfo.Profile(
|
|
customer=customer
|
|
)
|
|
|
|
# Create ProfileInfo with the profile
|
|
profile_info = res_guests_class.ResGuest.Profiles.ProfileInfo(profile=profile)
|
|
|
|
# Create Profiles with the profile_info
|
|
profiles = res_guests_class.ResGuest.Profiles(profile_info=profile_info)
|
|
|
|
# Create ResGuest with the profiles
|
|
res_guest = res_guests_class.ResGuest(profiles=profiles)
|
|
|
|
# Create ResGuests with the res_guest
|
|
return res_guests_class(res_guest=res_guest)
|
|
|
|
@staticmethod
|
|
def extract_primary_customer(
|
|
res_guests: Union[NotifResGuests, RetrieveResGuests],
|
|
) -> CustomerData:
|
|
"""Extract the primary customer data from a ResGuests structure."""
|
|
|
|
# Navigate down the nested structure to get the customer
|
|
customer = res_guests.res_guest.profiles.profile_info.profile.customer
|
|
|
|
# Use the existing CustomerFactory conversion method
|
|
if isinstance(res_guests, NotifResGuests):
|
|
return CustomerFactory.from_notif_customer(customer)
|
|
else:
|
|
return CustomerFactory.from_retrieve_customer(customer)
|
|
|
|
|
|
# Usage examples
|
|
if __name__ == "__main__":
|
|
# Create customer data using simple data class
|
|
customer_data = CustomerData(
|
|
given_name="John",
|
|
surname="Doe",
|
|
name_prefix="Mr.",
|
|
phone_numbers=[
|
|
("+1234567890", PhoneTechType.MOBILE), # Phone number with type
|
|
("+0987654321", None), # Phone number without type
|
|
],
|
|
email_address="john.doe@example.com",
|
|
email_newsletter=True,
|
|
address_line="123 Main Street",
|
|
city_name="Anytown",
|
|
postal_code="12345",
|
|
country_code="US",
|
|
address_catalog=False,
|
|
gender="Male",
|
|
birth_date="1980-01-01",
|
|
language="en",
|
|
)
|
|
|
|
# Create customer for OtaHotelResNotifRq
|
|
notif_customer = CustomerFactory.create_notif_customer(customer_data)
|
|
print(
|
|
"Created NotifCustomer:",
|
|
notif_customer.person_name.given_name,
|
|
notif_customer.person_name.surname,
|
|
)
|
|
|
|
# Create customer for OtaResRetrieveRs
|
|
retrieve_customer = CustomerFactory.create_retrieve_customer(customer_data)
|
|
print(
|
|
"Created RetrieveCustomer:",
|
|
retrieve_customer.person_name.given_name,
|
|
retrieve_customer.person_name.surname,
|
|
)
|
|
|
|
# Convert back to data class
|
|
converted_data = CustomerFactory.from_notif_customer(notif_customer)
|
|
print("Converted back to data:", converted_data.given_name, converted_data.surname)
|
|
|
|
# Verify they contain the same information
|
|
print("Original and converted data match:", customer_data == converted_data)
|
|
|
|
print("\n--- HotelReservationIdFactory Examples ---")
|
|
|
|
# Create hotel reservation ID data
|
|
reservation_id_data = HotelReservationIdData(
|
|
res_id_type="123",
|
|
res_id_value="RESERVATION-456",
|
|
res_id_source="HOTEL_SYSTEM",
|
|
res_id_source_context="BOOKING_ENGINE",
|
|
)
|
|
|
|
# Create HotelReservationId for both types
|
|
notif_res_id = HotelReservationIdFactory.create_notif_hotel_reservation_id(
|
|
reservation_id_data
|
|
)
|
|
retrieve_res_id = HotelReservationIdFactory.create_retrieve_hotel_reservation_id(
|
|
reservation_id_data
|
|
)
|
|
|
|
print(
|
|
"Created NotifHotelReservationId:",
|
|
notif_res_id.res_id_type,
|
|
notif_res_id.res_id_value,
|
|
)
|
|
print(
|
|
"Created RetrieveHotelReservationId:",
|
|
retrieve_res_id.res_id_type,
|
|
retrieve_res_id.res_id_value,
|
|
)
|
|
|
|
# Convert back to data class
|
|
converted_res_id_data = HotelReservationIdFactory.from_notif_hotel_reservation_id(
|
|
notif_res_id
|
|
)
|
|
print(
|
|
"Converted back to reservation ID data:",
|
|
converted_res_id_data.res_id_type,
|
|
converted_res_id_data.res_id_value,
|
|
)
|
|
|
|
# Verify they contain the same information
|
|
print(
|
|
"Original and converted reservation ID data match:",
|
|
reservation_id_data == converted_res_id_data,
|
|
)
|
|
|
|
print("\n--- ResGuestFactory Examples ---")
|
|
|
|
# Create complete ResGuests structure for OtaHotelResNotifRq - much simpler!
|
|
notif_res_guests = ResGuestFactory.create_notif_res_guests(customer_data)
|
|
print(
|
|
"Created NotifResGuests with customer:",
|
|
notif_res_guests.res_guest.profiles.profile_info.profile.customer.person_name.given_name,
|
|
)
|
|
|
|
# Create complete ResGuests structure for OtaResRetrieveRs - much simpler!
|
|
retrieve_res_guests = ResGuestFactory.create_retrieve_res_guests(customer_data)
|
|
print(
|
|
"Created RetrieveResGuests with customer:",
|
|
retrieve_res_guests.res_guest.profiles.profile_info.profile.customer.person_name.given_name,
|
|
)
|
|
|
|
# Extract primary customer data back from ResGuests structure
|
|
extracted_data = ResGuestFactory.extract_primary_customer(retrieve_res_guests)
|
|
print("Extracted customer data:", extracted_data.given_name, extracted_data.surname)
|
|
|
|
# Verify roundtrip conversion
|
|
print("Roundtrip conversion successful:", customer_data == extracted_data)
|