def get(self, request: http.HttpRequest, *args: Any,
**kwargs: Any) -> http.HttpResponse:
self._plan_id = cf.get_int_or_none(
request.GET.get('plan')) or 0 # noqa
if self._plan_id <= 0:
return self.json_error(_('agenda:plan:error'))
data = self.load_reservation_request()
if data == Nothing:
return http.HttpResponseServerError()
self._reservation = data.unwrap()
self._rate_id = cf.get_int_or_none(request.GET.get('rate')) # noqa
if self._plan_id == self._reservation.plan_id and self._rate_id is None:
self._rate_id = self._reservation.rate_id
return self.process_usecase(
CalculateNewReservation,
self.kwargs['hid'],
self._reservation.roomtype_id,
self._plan_id,
self._reservation.checkin,
self._reservation.checkout,
self._reservation.guests,
request.user,
rate_id=self._rate_id,
)
def parse_reservation_date_from_input(
self,
data: Dict[str,
Any]) -> Union[http.HttpResponse, ReservationRequest]:
roomtype_id = cf.get_int_or_none(data.get('room_type')) or 0
if roomtype_id <= 0:
return self.json_error(_('agenda:room_type:error'))
plan_id = cf.get_int_or_none(data.get('plan')) or 0
if plan_id <= 0:
return self.json_error(_('agenda:plan:error'))
period = cf.parse_period(data.get('period', ''))
if period == Nothing:
return self.json_error(_('agenda:period:error'))
start_date, end_date = period.unwrap()
guest_count = cf.get_int_or_none(data.get('guest_count')) or 0
if guest_count <= 0:
return self.json_error(_('agenda:guest_count:error'))
try:
reservation = ReservationRequest(
roomtype_id=roomtype_id,
plan_id=plan_id,
checkin=start_date,
checkout=end_date,
guests=guest_count,
guest_name=data.get('guest_name', '').strip(),
guest_surname=data.get('guest_surname', '').strip(),
guest_email=data.get('guest_email', '').strip(),
guest_phone=self.parse_phone(data),
notes=data.get('notes', '').strip(),
)
except ValidationError as err:
Logger.warning(__name__,
f"Error create a new Reservation Request: {err}")
return http.HttpResponseServerError()
return reservation
def post(self, request: http.HttpRequest, *args: Any,
**kwargs: Any) -> http.HttpResponse:
data = request.POST.dict() # noqa
value = self.load_reservation_request()
if value == Nothing:
return http.HttpResponseServerError()
self._reservation = value.unwrap()
self._reservation.plan_id = cf.get_int_or_none(data.get('plan')) or 0
if self._reservation.plan_id <= 0:
return self.json_error(_('agenda:plan:error'))
self._reservation.rate_id = cf.get_int_or_none(data.get('rate'))
if self._reservation.rate_id <= 0:
return self.json_error(_('agenda:rate:error'))
try:
self.assign_prices_to_reservation(
request.POST.getlist('prices')) # noqa
except (IndexError, AssertionError):
return self.json_error(_('agenda:price:error'))
return self.process_usecase(CreateReservation, self.kwargs['hid'],
self._reservation, request.user)
def select_room(
self,
ctx: dataclasses.dataclass) -> ResultE[dataclasses.dataclass]:
pk = cf.get_int_or_none(ctx.room_id) or 0
if pk <= 0:
return self._error('Missed Room ID', ctx,
self._case_errors.missed_room)
try:
data = self._rooms_repo.get(pk)
except Exception as err:
return self._error(
f"Error select Room ID={pk} in House ID={ctx.house.id}",
ctx,
self._case_errors.error,
exc=err)
if data == Nothing:
return self._error(
f"Unknown Room ID={pk} in House ID={ctx.house.id}", ctx,
self._case_errors.missed_room)
ctx.room = data.unwrap()
if ctx.room.house_id != ctx.house.id:
return self._error(
f"Unknown Room ID={pk} in House ID={ctx.house.id}", ctx,
self._case_errors.missed_room)
return Success(ctx)
def post(self, request: http.HttpRequest, *args: Any,
**kwargs: Any) -> http.HttpResponse:
pk = cf.get_int_or_none(self.kwargs.get('pk')) or 0
if pk <= 0:
raise http.Http404('Wrong or missed Reservation ID')
return self.process_usecase(AcceptHoldReservation,
self.kwargs.get('hid'), pk, request.user)
def post(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse:
price_ids = [cf.get_int_or_none(x) for x in request.POST.getlist('price_verify')] # noqa
price_ids = [x for x in price_ids if x is not None and x > 0]
return self.process_usecase(
AcceptReservationChanges, self.kwargs['hid'], self.kwargs['pk'], request.user, price_ids=price_ids
)
def select_rate_by_id(ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.rate_id) or 0
if pk <= 0 or not ctx.rates:
return Success(ctx)
_rates = {x.id: x for x in ctx.rates}
ctx.rate = _rates.get(pk)
return Success(ctx)
def execute(
self,
pk: str,
house_id: int,
room_id: int,
start_date: datetime.date,
end_date: datetime.date,
reason: RoomCloseReasons,
user: '******',
notes: str = '',
) -> ResultE[ReservationUpdateContext]:
pk = cf.get_int_or_none((pk or '').split('-')[0]) or 0
ctx = Context(
pk=pk,
house_id=house_id,
room_id=room_id,
start_date=start_date,
end_date=end_date,
reason=reason,
user=user,
notes=notes,
)
return flow(
ctx,
self.select_house,
bind_result(self.select_room),
bind_result(self.select_reservation),
bind_result(self.check_room_is_free),
bind_result(self.make_reservation_from_data),
bind_result(self.save_reservation),
bind_result(self.accept_reservation),
bind_result(self.write_changelog),
bind_result(self.make_result),
)
def select_rate(self, ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.request.rate_id) or 0
if pk <= 0:
return self._error('Missed Rate ID', ctx,
self._case_errors.missed_rate)
try:
rates = self._prices_repo.select_rates(ctx.house,
room_type=ctx.room_type,
plan_id=ctx.rate_plan.id,
user=ctx.user)
except Exception as err:
return self._error(
f"Error select Rates for Room Type ID={ctx.room_type.id} in House ID={ctx.house.id}",
ctx,
self._case_errors.error,
exc=err,
)
rates = [x for x in rates if x.id == pk]
if not rates:
return self._error(
f"Unknown Rate ID={pk} for Room Type ID={ctx.room_type.id} in House ID={ctx.house.id}",
ctx,
self._case_errors.missed_rate,
)
ctx.rate = rates[0]
return Success(ctx)
def execute(self, house_id: int, pk: int, contact_id: int, attribute: str, value: Any) -> ResultE['Reservation']:
ctx = Context(
house_id=house_id,
pk=pk,
contact_id=cf.get_int_or_none(contact_id) or 0,
attribute=(attribute or '').strip().lower(),
value=value,
)
if ctx.contact_id <= 0:
return self._error(
f"Missed Contact ID for update Guest information in Reservation ID={ctx.pk}",
ctx,
self._case_errors.error,
)
if ctx.attribute == '':
return self._error(
f"Missed attribute for update Guest information in Reservation ID={ctx.pk}",
ctx,
self._case_errors.error,
)
if ctx.attribute not in ('name', 'email', 'phone'):
return self._error(
f"Unsupported attribute [{ctx.attribute}] for update Guest information in Reservation ID={ctx.pk}",
ctx,
self._case_errors.error,
)
return flow(
ctx,
self.select_house,
bind_result(self.select_reservation),
bind_result(self.check_reservation),
bind_result(self.make_reservation_from_data),
bind_result(self.save_reservation),
bind_result(lambda x: Success(x.reservation)),
)
def channel_file_format(record):
fmt = ["{level} {time:YYYY-MM-DD HH:mm:ss,SSS} "]
if isinstance(record["extra"].get("channel"), Channels):
channel = record["extra"]["channel"].name.lower()
fmt.append(f"[{channel}]")
if cf.get_int_or_none(record["extra"].get("house")) is not None:
house_id = cf.get_int_or_none(record["extra"]["house"])
fmt.append(f"[H:{house_id}]")
if (record["extra"].get("request_id") or "").strip() != "":
fmt.append(f'[ParentRID:{record["extra"]["request_id"]}]')
fmt.append(" {message} \n")
format_string = "".join(fmt)
if record.get("exception") is not None:
format_string += "{exception} \n"
return format_string
def post(self, request: http.HttpRequest, *args: Any,
**kwargs: Any) -> http.HttpResponse:
pk = cf.get_int_or_none(self.kwargs['pk']) or 0
if pk <= 0:
raise http.Http404('Missed or wrong Reservation ID')
return self.process_usecase(CancelReservation, self.kwargs['hid'], pk,
request.user)
def get_house_log_name(routing: Dict[str, Any]) -> str:
if not isinstance(routing.get("channel"), Channels):
return ""
channel = routing["channel"].name.lower()
house_id = cf.get_int_or_none(routing.get("house"))
if house_id is None:
return ""
return f"ch-{house_id}-{channel}"
def model_to_reservation(self,
model: ReservationModel,
with_deleted_rooms: bool = False) -> Reservation:
if model.guest_contact_ids is not None and model.guest_contact_ids != '':
contact_ids = [
cf.get_int_or_none(x)
for x in model.guest_contact_ids.split(',')
]
contact_ids = [x for x in contact_ids if x is not None and x > 0]
else:
contact_ids = []
reservation = Reservation(
id=model.pk,
house_id=model.house_id, # noqa
connection_id=model.connection.id
if model.connection is not None else None,
source=ReservationSources.get_by_name(model.source),
channel=Channels.get_by_name(model.channel),
channel_id=model.channel_id,
status=ReservationStatuses.get_by_name(model.status),
close_reason=RoomCloseReasons.get_by_name(model.close_reason),
checkin=model.checkin,
checkout=model.checkout,
room_count=model.room_count,
currency=model.currency,
price=model.price,
price_accepted=model.price_accepted,
tax=model.tax,
fees=model.fees,
netto_price=model.netto_price,
netto_price_accepted=model.netto_price_accepted,
guest_name=model.guest_name,
guest_surname=model.guest_surname,
guest_email=model.guest_email,
guest_phone=model.guest_phone,
guest_country=model.guest_country,
guest_nationality=model.guest_nationality,
guest_city=model.guest_city,
guest_address=model.guest_address,
guest_post_code=model.guest_post_code,
guest_comments=model.guest_comments,
guest_contact_id=model.guest_contact_id,
guest_contact_ids=contact_ids,
promo=model.promo,
creditcard_info=model.creditcard_info,
payment_info=model.payment_info,
booked_at=model.booked_at,
is_verified=model.is_verified,
opportunity_id=model.opportunity_id,
quotation_id=model.quotation_id,
)
queryset = model.rooms.all(
) if with_deleted_rooms else model.rooms.active() # noqa
for room in queryset:
reservation.rooms.append(self.model_to_reservation_room(room))
return reservation
def get_context_data(self,
ctx: 'ReservationDetailsContext' = None,
**kwargs: Any) -> Dict[str, Any]:
context = super().get_context_data(**kwargs)
context.update(ctx.asdict())
context['CURRENT_HOUSE'] = ctx.house
context['reservation_rooms'] = self.prepare_rooms(ctx.reservation)
context['guest_id'] = cf.get_int_or_none(
self.request.GET.get('guest_id')) # noqa
context[
'pending_balance'] = ctx.reservation.price_accepted - ctx.payed_amount
return context
def parse_rooms(
data: Dict[str, Any]) -> Tuple[Optional[int], Optional[int]]:
grid = data.get('grid', '').strip().lower()
grid_id = cf.get_int_or_none(data.get('grid_id')) or 0
if grid == 'roomtype':
if grid_id <= 0:
raise http.Http404('Unknown Room Type ID')
return grid_id, None
elif grid == 'room':
if grid_id <= 0:
raise http.Http404('Unknown Room ID')
return None, grid_id
return None, None
def execute(self, pk: str, house_id: int,
user: '******') -> ResultE['Reservation']:
pk = cf.get_int_or_none((pk or '').split('-')[0]) or 0
ctx = Context(pk=pk, house_id=house_id, user=user)
return flow(
ctx,
self.select_house,
bind_result(self.select_reservation),
bind_result(self.check_reservation),
bind_result(self.make_reservation_from_data),
bind_result(self.save_reservation),
bind_result(self.write_changelog),
bind_result(lambda x: Success(x.reservation)),
)
def select_reservation_room(self, ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.room_id) or 0
if pk <= 0:
return self._error('Missed Reservation Room ID', ctx,
self._case_errors.missed_reservation)
rooms = {x.id: x for x in ctx.reservation.rooms}
if pk not in rooms:
return self._error(
f"Unknown Room ID={pk} in Reservation ID={ctx.reservation.id} House ID={ctx.house.id}",
ctx,
self._case_errors.missed_reservation,
)
ctx.reservation_room = rooms[pk]
return Success(ctx)
def get(
self,
house_id: int,
roomtype_id: int,
dates: Union[datetime.date, List[datetime.date]],
) -> Dict[datetime.date, Optional[int]]:
if isinstance(dates, datetime.date):
dates = [dates]
if not isinstance(dates, list):
raise AssertionError("Wrong input for OccupancyRepo.get")
name = cache_keys.occupancy(house_id, roomtype_id)
result = self.get_store().hmget(name,
[self.format_date(x) for x in dates])
return {x: cf.get_int_or_none(y) for x, y in zip(dates, result)}
def post(self, request: http.HttpRequest, *args: Any,
**kwargs: Any) -> http.HttpResponse:
data = request.POST.dict() # noqa
plan_id = cf.get_int_or_none(data.get('rate_plan')) or 0
if plan_id <= 0:
return self.json_error(_('agenda:plan:error'))
return self.process_usecase(
UpdateReservationPrices,
self.kwargs['hid'],
self.kwargs['pk'],
self.kwargs['rid'],
plan_id,
request.user,
self.parse_price_data(data),
)
def select_rate_plan(self, ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.plan_id) or 0
if pk <= 0:
return self._error('Missed Rate Plan ID', ctx, self._case_errors.missed_rateplan)
try:
data = self._prices_repo.get_plan(ctx.house.odoo_id, pk, user=ctx.user)
except Exception as err:
return self._error(
f"Error select Rate Plan ID={pk} in House ID={ctx.house.id}", ctx, self._case_errors.error, exc=err
)
if data == Nothing:
return self._error(
f"Unknown Rate Plan ID={pk} in House ID={ctx.house.id}", ctx, self._case_errors.missed_rateplan
)
ctx.rate_plan = data.unwrap()
return Success(ctx)
def post(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse:
data = request.POST.dict() # noqa
period = cf.parse_period(data.get('period', ''))
if period == Nothing:
return self.json_error(_('agenda:period:error'))
start_date, end_date = period.unwrap()
room_id = cf.get_int_or_none(data.get('room')) or 0
if room_id <= 0:
return self.json_error(_('agenda:room:error'))
reason = RoomCloseReasons.get_by_name(data.get('status', ''))
if reason is None:
return self.json_error(_('agenda:status:error'))
notes = data.get('notes', '')
return self.process_usecase(
CreateRoomClose, self.kwargs['hid'], room_id, start_date, end_date, reason, request.user, notes=notes
)
def select_room_type(
self,
ctx: dataclasses.dataclass) -> ResultE[dataclasses.dataclass]:
pk = cf.get_int_or_none(ctx.roomtype_id) or 0
if pk <= 0:
return self._error('Wrong Room Type ID', ctx,
self._case_errors.missed_roomtype)
try:
data = self._roomtypes_repo.get(ctx.house, pk, user=ctx.user)
except Exception as err:
return self._error(f"Error select Room Type ID={pk}",
ctx,
self._case_errors.error,
exc=err)
if data == Nothing:
return self._error(f"Unknown Room Type ID={pk}", ctx,
self._case_errors.missed_roomtype)
ctx.room_type = data.unwrap()
return Success(ctx)
def select_room_type(self, ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.request.roomtype_id) or 0
if pk <= 0:
return self._error('Missed Room Type ID', ctx,
self._case_errors.missed_roomtype)
try:
data = self._roomtypes_repo.get(ctx.house, pk=pk, user=ctx.user)
if data == Nothing:
return self._error(
f"Unknown Room Type ID={pk} in House ID={ctx.house.id}",
ctx, self._case_errors.missed_roomtype)
except Exception as err:
return self._error(
f"Error select Room Type ID={pk} in House ID={ctx.house.id}",
ctx,
self._case_errors.error,
exc=err)
ctx.room_type = data.unwrap()
return Success(ctx)
def select_reservation(self, ctx: dataclasses.dataclass) -> ResultE[dataclasses.dataclass]:
"""Select reservation from Repository and check if it is acceptable"""
pk = cf.get_int_or_none(ctx.pk) or 0
if pk <= 0:
return self._error('Missed Reservation ID', ctx, ReservationErrors.missed_reservation)
try:
data = self._reservations_repo.get(pk)
except Exception as err:
return self._error(
f"Error select Reservation ID={pk} in House ID={ctx.house.id}", ctx, ReservationErrors.error, exc=err
)
if data == Nothing:
return self._error(
f"Unknown Reservation ID={pk} in House ID={ctx.house.id}", ctx, ReservationErrors.missed_reservation
)
if hasattr(ctx, 'source'):
ctx.source = data.unwrap()
else:
ctx.reservation = data.unwrap()
return Success(ctx)
def parse_price_data(
data: Dict[str, Any]) -> Dict[datetime.date, Dict[str, Any]]:
result = {}
pattern = re.compile(r'\[(\d{4}-\d{2}-\d{2})]')
for key, value in data.items():
if not key.startswith('room[') and not key.startswith('price['):
continue
match = pattern.search(key)
if match is None:
continue
day = cf.get_date_or_none(match.group(1))
if day is None:
continue
if day not in result:
result[day] = {'room': None, 'price': None, 'day': day}
if key.startswith('room['):
result[day]['room'] = cf.get_int_or_none(value)
elif key.startswith('price['):
result[day]['price'] = cf.get_decimal_or_none(value)
return result
def select_reservation_from_db(self, ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.reservation_id) or 0
if pk <= 0:
return self._error('Missed Reservation ID', ctx,
self._case_errors.missed_reservation)
try:
data = self._reservations_repo.get(pk)
except Exception as err:
return self._error(f"Error select Reservation ID={pk}",
ctx,
self._case_errors.error,
exc=err)
if data == Nothing:
return self._error(f"Unknown Reservation ID={pk}", ctx,
self._case_errors.missed_reservation)
ctx.reservation = data.unwrap()
if ctx.reservation.status == ReservationStatuses.CANCEL:
return self._error(f"Reservation ID={pk} is cancelled", ctx,
self._case_errors.missed_reservation)
return Success(ctx)
def select_user(self, ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.user_id) or 0
try:
if pk > 0:
data = self._members_repo.get_user_by_id(pk)
else:
data = self._members_repo.get_bot_user(ctx.house.company.id)
except Exception as err:
return self._error(
f"Error select User ID={pk} in Company ID={ctx.house.company.id}",
ctx,
self._case_errors.missed_user,
exc=err,
)
if data == Nothing:
return self._error(
f"Unknown User ID={pk} in Company ID={ctx.house.company.id}",
ctx, self._case_errors.missed_user)
ctx.user = data.unwrap()
return Success(ctx)
def select_room(self, ctx: Context) -> ResultE[Context]:
if ctx.room_id is None:
return Success(ctx)
pk = cf.get_int_or_none(ctx.room_id) or 0
if pk <= 0:
return self._error('Wrong Room ID', ctx,
self._case_errors.missed_room)
try:
data = self._rooms_repo.get(pk)
except Exception as err:
return self._error(
f"Error select Room ID={pk} in House ID={ctx.house.id}",
ctx,
self._case_errors.error,
exc=err)
if data == Nothing:
return self._error(
f"Unknown Room ID={pk} in House ID={ctx.house.id}", ctx,
self._case_errors.missed_room)
ctx.room = data.unwrap()
return Success(ctx)
def post(self, request: http.HttpRequest, *args: Any,
**kwargs: Any) -> http.HttpResponse:
data = request.POST.dict() # noqa
pk = data.get('pk', '').strip()
if pk == '' or '-' not in pk:
return self.json_error(_('common.error:system'))
self._reservation_id = cf.get_int_or_none(data.get('rid')) or 0
if self._reservation_id <= 0:
return self.json_error(_('agenda:error:unknown_reservation'))
roomtype_id, room_id = self.parse_rooms(data)
return self.process_usecase(
MoveReservation,
pk,
self._reservation_id,
self.kwargs['hid'],
roomtype_id=roomtype_id,
room_id=room_id,
user=request.user,
)
