601 lines
21 KiB
Python
601 lines
21 KiB
Python
"""Action handler for OTA_HotelInvCountNotif:FreeRooms."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
from datetime import UTC, date, datetime, timedelta
|
|
from typing import Any
|
|
|
|
from sqlalchemy import delete, select
|
|
from sqlalchemy.dialects.postgresql import insert as pg_insert
|
|
from sqlalchemy.dialects.sqlite import insert as sqlite_insert
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from xsdata.formats.dataclass.serializers.config import SerializerConfig
|
|
from xsdata_pydantic.bindings import XmlParser, XmlSerializer
|
|
|
|
from .alpinebits_server import (
|
|
AlpineBitsAction,
|
|
AlpineBitsActionName,
|
|
AlpineBitsClientInfo,
|
|
AlpineBitsResponse,
|
|
Version,
|
|
validate_hotel_authentication,
|
|
)
|
|
from .const import HttpStatusCode
|
|
from .db import Hotel, HotelInventory, RoomAvailability
|
|
from .generated import (
|
|
ErrorType,
|
|
InvCountCountType,
|
|
OtaHotelInvCountNotifRq,
|
|
OtaHotelInvCountNotifRs,
|
|
UniqueIdInstance,
|
|
)
|
|
from .logging_config import get_logger
|
|
|
|
_LOGGER = get_logger(__name__)
|
|
|
|
SUPPORTED_CAPABILITIES = [
|
|
"OTA_HotelInvCountNotif_accept_rooms",
|
|
"OTA_HotelInvCountNotif_accept_categories",
|
|
"OTA_HotelInvCountNotif_accept_deltas",
|
|
"OTA_HotelInvCountNotif_accept_complete_set",
|
|
"OTA_HotelInvCountNotif_accept_out_of_order",
|
|
"OTA_HotelInvCountNotif_accept_out_of_market",
|
|
"OTA_HotelInvCountNotif_accept_closing_seasons",
|
|
]
|
|
|
|
CLOSING_SEASON_TYPE = "__CLOSE" # <= 8 chars per spec
|
|
SOURCE_FREEROOMS = "FreeRooms"
|
|
|
|
COUNT_TYPE_MAP = {
|
|
InvCountCountType.VALUE_2: "count_type_2",
|
|
InvCountCountType.VALUE_6: "count_type_6",
|
|
InvCountCountType.VALUE_9: "count_type_9",
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class FreeRoomsProcessingError(Exception):
|
|
"""Custom exception that carries HTTP and OTA error metadata."""
|
|
|
|
message: str
|
|
status_code: HttpStatusCode = HttpStatusCode.BAD_REQUEST
|
|
error_type: ErrorType = ErrorType.VALUE_13
|
|
code: str = "450"
|
|
|
|
def __str__(self) -> str:
|
|
return self.message
|
|
|
|
|
|
class FreeRoomsAction(AlpineBitsAction):
|
|
"""Handler for OTA_HotelInvCountNotif:FreeRooms requests."""
|
|
|
|
def __init__(self, config: dict | None = None):
|
|
self.name = AlpineBitsActionName.OTA_HOTEL_INV_COUNT_NOTIF_FREE_ROOMS
|
|
self.version = [Version.V2024_10, Version.V2022_10]
|
|
self.config = config or {}
|
|
self.supports = SUPPORTED_CAPABILITIES
|
|
|
|
self._parser = XmlParser()
|
|
self._serializer = XmlSerializer(
|
|
config=SerializerConfig(
|
|
pretty_print=True,
|
|
xml_declaration=True,
|
|
encoding="UTF-8",
|
|
)
|
|
)
|
|
|
|
async def handle(
|
|
self,
|
|
action: str,
|
|
request_xml: str,
|
|
version: Version,
|
|
client_info: AlpineBitsClientInfo,
|
|
dbsession: AsyncSession | None = None,
|
|
server_capabilities=None,
|
|
) -> AlpineBitsResponse:
|
|
"""Process FreeRooms inventory updates."""
|
|
try:
|
|
self._validate_action_name(action)
|
|
|
|
if request_xml is None:
|
|
raise FreeRoomsProcessingError("Missing request payload")
|
|
|
|
if dbsession is None:
|
|
raise FreeRoomsProcessingError(
|
|
"Database session unavailable",
|
|
HttpStatusCode.INTERNAL_SERVER_ERROR,
|
|
)
|
|
|
|
try:
|
|
request = self._parser.from_string(request_xml, OtaHotelInvCountNotifRq)
|
|
except Exception as exc: # pragma: no cover - serialization already tested upstream
|
|
_LOGGER.exception("Failed to parse FreeRooms request: %s", exc)
|
|
raise FreeRoomsProcessingError("Invalid XML payload") from exc
|
|
|
|
hotel_code = request.inventories.hotel_code if request.inventories else None
|
|
if not hotel_code:
|
|
raise FreeRoomsProcessingError("HotelCode attribute is required")
|
|
|
|
if not client_info or not client_info.username or not client_info.password:
|
|
raise FreeRoomsProcessingError(
|
|
"Missing authentication context",
|
|
HttpStatusCode.UNAUTHORIZED,
|
|
error_type=ErrorType.VALUE_11,
|
|
code="401",
|
|
)
|
|
|
|
if not validate_hotel_authentication(
|
|
client_info.username,
|
|
client_info.password,
|
|
hotel_code,
|
|
self.config,
|
|
):
|
|
raise FreeRoomsProcessingError(
|
|
f"Unauthorized FreeRooms notification for hotel {hotel_code}",
|
|
HttpStatusCode.UNAUTHORIZED,
|
|
error_type=ErrorType.VALUE_11,
|
|
code="401",
|
|
)
|
|
|
|
hotel = await self._fetch_hotel(dbsession, hotel_code)
|
|
if hotel is None:
|
|
raise FreeRoomsProcessingError(
|
|
f"Hotel {hotel_code} is not provisioned on this server"
|
|
)
|
|
|
|
is_complete_set = (
|
|
request.unique_id is not None
|
|
and request.unique_id.instance == UniqueIdInstance.COMPLETE_SET
|
|
)
|
|
update_type = "CompleteSet" if is_complete_set else "Delta"
|
|
|
|
inventory_cache: dict[tuple[str, str | None], HotelInventory] = {}
|
|
|
|
try:
|
|
if is_complete_set:
|
|
await self._process_complete_set(
|
|
dbsession, hotel, request, update_type, inventory_cache
|
|
)
|
|
else:
|
|
await self._process_delta(
|
|
dbsession, hotel, request, update_type, inventory_cache
|
|
)
|
|
await dbsession.commit()
|
|
except FreeRoomsProcessingError:
|
|
await dbsession.rollback()
|
|
raise
|
|
except Exception as exc: # pragma: no cover - defensive
|
|
await dbsession.rollback()
|
|
_LOGGER.exception("Unexpected FreeRooms failure: %s", exc)
|
|
return self._error_response(
|
|
"Internal server error while processing FreeRooms notification",
|
|
HttpStatusCode.INTERNAL_SERVER_ERROR,
|
|
)
|
|
|
|
_LOGGER.info(
|
|
"Processed FreeRooms %s update for hotel %s (%d inventory items)",
|
|
update_type,
|
|
hotel_code,
|
|
len(request.inventories.inventory),
|
|
)
|
|
return self._success_response()
|
|
except FreeRoomsProcessingError as exc:
|
|
return self._error_response(
|
|
exc.message,
|
|
exc.status_code,
|
|
error_type=exc.error_type,
|
|
code=exc.code,
|
|
)
|
|
|
|
def _validate_action_name(self, action: str) -> None:
|
|
expected = self.name.value[1]
|
|
if (action or "").strip() != expected:
|
|
raise FreeRoomsProcessingError(
|
|
f"Invalid action {action}, expected {expected}",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
async def _fetch_hotel(self, session: AsyncSession, hotel_code: str) -> Hotel | None:
|
|
stmt = select(Hotel).where(Hotel.hotel_id == hotel_code, Hotel.is_active.is_(True))
|
|
result = await session.execute(stmt)
|
|
return result.scalar_one_or_none()
|
|
|
|
async def _process_complete_set(
|
|
self,
|
|
session: AsyncSession,
|
|
hotel: Hotel,
|
|
request: OtaHotelInvCountNotifRq,
|
|
update_type: str,
|
|
inventory_cache: dict[tuple[str, str | None], HotelInventory],
|
|
) -> None:
|
|
await self._delete_existing_availability(session, hotel.hotel_id)
|
|
await self._process_inventories(
|
|
session, hotel, request, update_type, inventory_cache, enforce_closing_order=True
|
|
)
|
|
|
|
async def _process_delta(
|
|
self,
|
|
session: AsyncSession,
|
|
hotel: Hotel,
|
|
request: OtaHotelInvCountNotifRq,
|
|
update_type: str,
|
|
inventory_cache: dict[tuple[str, str | None], HotelInventory],
|
|
) -> None:
|
|
await self._process_inventories(
|
|
session, hotel, request, update_type, inventory_cache, enforce_closing_order=False
|
|
)
|
|
|
|
async def _delete_existing_availability(
|
|
self,
|
|
session: AsyncSession,
|
|
hotel_id: str,
|
|
) -> None:
|
|
subquery = select(HotelInventory.id).where(HotelInventory.hotel_id == hotel_id)
|
|
await session.execute(
|
|
delete(RoomAvailability).where(RoomAvailability.inventory_id.in_(subquery))
|
|
)
|
|
|
|
async def _process_inventories(
|
|
self,
|
|
session: AsyncSession,
|
|
hotel: Hotel,
|
|
request: OtaHotelInvCountNotifRq,
|
|
update_type: str,
|
|
inventory_cache: dict[tuple[str, str | None], HotelInventory],
|
|
enforce_closing_order: bool,
|
|
) -> None:
|
|
inventories = request.inventories.inventory if request.inventories else []
|
|
if not inventories:
|
|
raise FreeRoomsProcessingError(
|
|
"Request must include at least one Inventory block",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
rows_to_upsert: list[dict[str, Any]] = []
|
|
now = datetime.now(UTC)
|
|
encountered_standard = False
|
|
|
|
for inventory in inventories:
|
|
sac = inventory.status_application_control
|
|
if sac is None:
|
|
raise FreeRoomsProcessingError(
|
|
"StatusApplicationControl element is required for each Inventory",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
is_closing = self._is_closing_season(sac)
|
|
if is_closing:
|
|
if inventory.inv_counts is not None:
|
|
raise FreeRoomsProcessingError(
|
|
"Closing seasons cannot contain InvCounts data",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
if update_type != "CompleteSet":
|
|
raise FreeRoomsProcessingError(
|
|
"Closing seasons are only allowed on CompleteSet updates",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
if enforce_closing_order and encountered_standard:
|
|
raise FreeRoomsProcessingError(
|
|
"Closing seasons must appear before other inventory entries",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
rows_to_upsert.extend(
|
|
await self._process_closing_season(
|
|
session, hotel, sac, update_type, now, inventory_cache
|
|
)
|
|
)
|
|
continue
|
|
|
|
encountered_standard = True
|
|
rows_to_upsert.extend(
|
|
await self._process_inventory_item(
|
|
session,
|
|
hotel,
|
|
sac,
|
|
inventory.inv_counts,
|
|
update_type,
|
|
now,
|
|
inventory_cache,
|
|
)
|
|
)
|
|
|
|
await self._upsert_availability_rows(session, rows_to_upsert)
|
|
|
|
async def _process_closing_season(
|
|
self,
|
|
session: AsyncSession,
|
|
hotel: Hotel,
|
|
sac: OtaHotelInvCountNotifRq.Inventories.Inventory.StatusApplicationControl,
|
|
update_type: str,
|
|
timestamp: datetime,
|
|
inventory_cache: dict[tuple[str, str | None], HotelInventory],
|
|
) -> list[dict[str, Any]]:
|
|
if sac.inv_type_code or sac.inv_code:
|
|
raise FreeRoomsProcessingError(
|
|
"Closing season entries cannot specify InvTypeCode or InvCode",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
start_date, end_date = self._parse_date_range(sac.start, sac.end)
|
|
inventory_item = await self._ensure_inventory_item(
|
|
session,
|
|
hotel.hotel_id,
|
|
CLOSING_SEASON_TYPE,
|
|
None,
|
|
timestamp,
|
|
inventory_cache,
|
|
)
|
|
|
|
base_payload = {
|
|
"inventory_id": inventory_item.id,
|
|
"count_type_2": None,
|
|
"count_type_6": None,
|
|
"count_type_9": None,
|
|
"is_closing_season": True,
|
|
"last_updated": timestamp,
|
|
"update_type": update_type,
|
|
}
|
|
|
|
rows = []
|
|
for day in self._iter_days(start_date, end_date):
|
|
payload = dict(base_payload)
|
|
payload["date"] = day
|
|
rows.append(payload)
|
|
return rows
|
|
|
|
async def _process_inventory_item(
|
|
self,
|
|
session: AsyncSession,
|
|
hotel: Hotel,
|
|
sac: OtaHotelInvCountNotifRq.Inventories.Inventory.StatusApplicationControl,
|
|
inv_counts: (
|
|
OtaHotelInvCountNotifRq.Inventories.Inventory.InvCounts | None
|
|
),
|
|
update_type: str,
|
|
timestamp: datetime,
|
|
inventory_cache: dict[tuple[str, str | None], HotelInventory],
|
|
) -> list[dict[str, Any]]:
|
|
inv_type_code = (sac.inv_type_code or "").strip()
|
|
if not inv_type_code:
|
|
raise FreeRoomsProcessingError(
|
|
"InvTypeCode is required unless AllInvCode=\"true\"",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
inv_code = sac.inv_code.strip() if sac.inv_code else None
|
|
start_date, end_date = self._parse_date_range(sac.start, sac.end)
|
|
|
|
counts = self._extract_counts(inv_counts)
|
|
base_counts = {
|
|
"count_type_2": counts.get("count_type_2"),
|
|
"count_type_6": counts.get("count_type_6"),
|
|
"count_type_9": counts.get("count_type_9"),
|
|
}
|
|
|
|
inventory_item = await self._ensure_inventory_item(
|
|
session,
|
|
hotel.hotel_id,
|
|
inv_type_code,
|
|
inv_code,
|
|
timestamp,
|
|
inventory_cache,
|
|
)
|
|
|
|
base_payload = {
|
|
"inventory_id": inventory_item.id,
|
|
"is_closing_season": False,
|
|
"last_updated": timestamp,
|
|
"update_type": update_type,
|
|
**base_counts,
|
|
}
|
|
|
|
rows = []
|
|
for day in self._iter_days(start_date, end_date):
|
|
payload = dict(base_payload)
|
|
payload["date"] = day
|
|
rows.append(payload)
|
|
return rows
|
|
|
|
def _parse_date_range(self, start_str: str, end_str: str) -> tuple[date, date]:
|
|
try:
|
|
start_date = date.fromisoformat(start_str)
|
|
end_date = date.fromisoformat(end_str)
|
|
except ValueError as exc:
|
|
raise FreeRoomsProcessingError(
|
|
f"Invalid date format: {exc!s}",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
) from exc
|
|
|
|
if end_date < start_date:
|
|
raise FreeRoomsProcessingError(
|
|
"StatusApplicationControl End date cannot be before Start date",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
return start_date, end_date
|
|
|
|
def _iter_days(self, start_date: date, end_date: date):
|
|
current = start_date
|
|
while current <= end_date:
|
|
yield current
|
|
current += timedelta(days=1)
|
|
|
|
def _is_closing_season(
|
|
self,
|
|
sac: OtaHotelInvCountNotifRq.Inventories.Inventory.StatusApplicationControl,
|
|
) -> bool:
|
|
return (sac.all_inv_code or "").strip().lower() == "true"
|
|
|
|
def _extract_counts(
|
|
self,
|
|
inv_counts: OtaHotelInvCountNotifRq.Inventories.Inventory.InvCounts | None,
|
|
) -> dict[str, int | None]:
|
|
if inv_counts is None or not inv_counts.inv_count:
|
|
return {}
|
|
|
|
parsed: dict[str, int] = {}
|
|
for count in inv_counts.inv_count:
|
|
column_name = COUNT_TYPE_MAP.get(count.count_type)
|
|
if column_name is None:
|
|
raise FreeRoomsProcessingError(
|
|
f"Unsupported CountType {count.count_type}",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
if column_name in parsed:
|
|
raise FreeRoomsProcessingError(
|
|
f"Duplicate CountType {count.count_type.value} detected",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
try:
|
|
value = int(count.count)
|
|
except ValueError as exc:
|
|
raise FreeRoomsProcessingError(
|
|
f"Invalid Count value '{count.count}'",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
) from exc
|
|
|
|
if value < 0:
|
|
raise FreeRoomsProcessingError(
|
|
"Count values must be non-negative",
|
|
HttpStatusCode.BAD_REQUEST,
|
|
)
|
|
|
|
parsed[column_name] = value
|
|
|
|
return parsed
|
|
|
|
async def _ensure_inventory_item(
|
|
self,
|
|
session: AsyncSession,
|
|
hotel_id: str,
|
|
inv_type_code: str,
|
|
inv_code: str | None,
|
|
timestamp: datetime,
|
|
cache: dict[tuple[str, str | None], HotelInventory],
|
|
) -> HotelInventory:
|
|
cache_key = (inv_type_code, inv_code)
|
|
if cache_key in cache:
|
|
return cache[cache_key]
|
|
|
|
filters = [
|
|
HotelInventory.hotel_id == hotel_id,
|
|
HotelInventory.inv_type_code == inv_type_code,
|
|
]
|
|
if inv_code is None:
|
|
filters.append(HotelInventory.inv_code.is_(None))
|
|
else:
|
|
filters.append(HotelInventory.inv_code == inv_code)
|
|
|
|
stmt = select(HotelInventory).where(*filters)
|
|
result = await session.execute(stmt)
|
|
inventory_item = result.scalar_one_or_none()
|
|
|
|
if inventory_item:
|
|
inventory_item.last_updated = timestamp
|
|
else:
|
|
inventory_item = HotelInventory(
|
|
hotel_id=hotel_id,
|
|
inv_type_code=inv_type_code,
|
|
inv_code=inv_code,
|
|
source=SOURCE_FREEROOMS,
|
|
first_seen=timestamp,
|
|
last_updated=timestamp,
|
|
)
|
|
session.add(inventory_item)
|
|
await session.flush()
|
|
|
|
cache[cache_key] = inventory_item
|
|
return inventory_item
|
|
|
|
async def _upsert_availability_rows(
|
|
self,
|
|
session: AsyncSession,
|
|
rows: list[dict[str, Any]],
|
|
) -> None:
|
|
if not rows:
|
|
return
|
|
|
|
bind = session.get_bind()
|
|
dialect_name = bind.dialect.name if bind else ""
|
|
table = RoomAvailability.__table__
|
|
|
|
if dialect_name == "postgresql":
|
|
stmt = pg_insert(table).values(rows)
|
|
stmt = stmt.on_conflict_do_update(
|
|
index_elements=["inventory_id", "date"],
|
|
set_=self._build_upsert_set(stmt),
|
|
)
|
|
await session.execute(stmt)
|
|
return
|
|
|
|
if dialect_name == "sqlite":
|
|
stmt = sqlite_insert(table).values(rows)
|
|
stmt = stmt.on_conflict_do_update(
|
|
index_elements=["inventory_id", "date"],
|
|
set_=self._build_upsert_set(stmt),
|
|
)
|
|
await session.execute(stmt)
|
|
return
|
|
|
|
await self._upsert_with_fallback(session, rows)
|
|
|
|
def _build_upsert_set(self, stmt):
|
|
return {
|
|
"count_type_2": stmt.excluded.count_type_2,
|
|
"count_type_6": stmt.excluded.count_type_6,
|
|
"count_type_9": stmt.excluded.count_type_9,
|
|
"is_closing_season": stmt.excluded.is_closing_season,
|
|
"last_updated": stmt.excluded.last_updated,
|
|
"update_type": stmt.excluded.update_type,
|
|
}
|
|
|
|
async def _upsert_with_fallback(
|
|
self, session: AsyncSession, rows: list[dict[str, Any]]
|
|
) -> None:
|
|
for row in rows:
|
|
stmt = select(RoomAvailability).where(
|
|
RoomAvailability.inventory_id == row["inventory_id"],
|
|
RoomAvailability.date == row["date"],
|
|
)
|
|
result = await session.execute(stmt)
|
|
existing = result.scalar_one_or_none()
|
|
|
|
if existing:
|
|
existing.count_type_2 = row["count_type_2"]
|
|
existing.count_type_6 = row["count_type_6"]
|
|
existing.count_type_9 = row["count_type_9"]
|
|
existing.is_closing_season = row["is_closing_season"]
|
|
existing.last_updated = row["last_updated"]
|
|
existing.update_type = row["update_type"]
|
|
else:
|
|
session.add(RoomAvailability(**row))
|
|
|
|
def _success_response(self) -> AlpineBitsResponse:
|
|
response = OtaHotelInvCountNotifRs(version="7.000", success="")
|
|
xml = self._serializer.render(
|
|
response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
|
|
)
|
|
return AlpineBitsResponse(xml, HttpStatusCode.OK)
|
|
|
|
def _error_response(
|
|
self,
|
|
message: str,
|
|
status_code: HttpStatusCode,
|
|
error_type: ErrorType = ErrorType.VALUE_13,
|
|
code: str = "450",
|
|
) -> AlpineBitsResponse:
|
|
error = OtaHotelInvCountNotifRs.Errors.Error(
|
|
type_value=error_type,
|
|
code=code,
|
|
content=[message],
|
|
)
|
|
errors = OtaHotelInvCountNotifRs.Errors(error=[error])
|
|
response = OtaHotelInvCountNotifRs(version="7.000", errors=errors)
|
|
xml = self._serializer.render(
|
|
response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
|
|
)
|
|
return AlpineBitsResponse(xml, status_code)
|