def test_action_confirm(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt, self.tz_hotel)
checkout_utc_dt = checkin_utc_dt + timedelta(days=2)
date_diff = date_utils.date_diff(
checkin_utc_dt, checkout_utc_dt, hours=False) + 1
wbooks = [
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2, {
self.hotel_room_type_budget.wrid: {
'occupancy': [1],
'dayprices': [15.0, 15.0]
}
})
]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
self.assertTrue(any(processed_rids), "Reservation not found")
self.assertFalse(errors, "Reservation errors")
nreserv = self.env['hotel.reservation'].search(
[('wrid', '=', processed_rids[0])], order='id ASC', limit=1)
self.assertTrue(nreserv, "Can't found reservation")
nreserv.folio_id.action_confirm()
self.assertEqual(nreserv.folio_id.state, 'sale',
"Reservation not confirmed")
def text_invalid_booking_amount(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt,
self.tz_hotel)
# Create Reservation
num_issues = self.env['wubook.issue'].search_count([])
nbook = self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_special.wrid: {
'occupancy': [2], # 2 Reservation Line
'dayprices': [15.0, 15.0] # 2 Days
}
}, channel=self.wubook_channel_test.wid)
nbook['amount'] = 30.75
wbooks = [nbook]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
self.assertEqual(len(processed_rids), 1, "Reservation not found")
self.assertFalse(errors, "Reservation errors")
self.assertNotEqual(self.env['wubook.issue'].search_count([]), num_issues)
def test_get_restrictions(self):
now_utc_dt = date_utils.now()
rests = self.hotel_vroom_budget.sudo(
self.user_hotel_manager).get_restrictions(
now_utc_dt.strftime(
DEFAULT_SERVER_DATE_FORMAT))
self.assertTrue(any(rests), "Restrictions not found")
def test_action_cancel(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt, self.tz_hotel)
checkout_utc_dt = checkin_utc_dt + timedelta(days=2)
date_diff = date_utils.date_diff(
checkin_utc_dt, checkout_utc_dt, hours=False) + 1
wbooks = [
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_budget.wrid: {
'occupancy': [1], # 1 Reservation Line
'dayprices': [15.0, 15.0] # 2 Days
}
})
]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
# Check Creation
self.assertTrue(any(processed_rids), "Reservation not found")
self.assertFalse(errors, "Reservation errors")
hotel_reserv_obj = self.env['hotel.reservation']
nreserv = hotel_reserv_obj.sudo(self.user_hotel_manager).search([
('wrid', 'in', processed_rids)
])
self.assertTrue(nreserv, "Reservation not found")
nreserv.sudo(self.user_hotel_manager).action_cancel()
self.assertEqual(nreserv.state, 'cancelled',
"Rervation don't cancelled")
def test_update_price(self):
now_utc_dt = date_utils.now()
now_utc_str = now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)
room_type_tmpl_id = self.hotel_room_type_special.product_id.product_tmpl_id
pritem_obj = self.env['product.pricelist.item']
plitem = pritem_obj.search([
('pricelist_id', '=', self.parity_pricelist_id),
('product_tmpl_id', '=', room_type_tmpl_id.id),
('date_start', '=', now_utc_str), ('date_end', '=', now_utc_str),
('applied_on', '=', '1_product'), ('compute_price', '=', 'fixed')
])
old_price = plitem.fixed_price
self.pricelist_1.update_price(self.hotel_room_type_special.id,
now_utc_str, 999.9)
plitem = pritem_obj.search([
('pricelist_id', '=', self.parity_pricelist_id),
('product_tmpl_id', '=', room_type_tmpl_id.id),
('date_start', '=', now_utc_str), ('date_end', '=', now_utc_str),
('applied_on', '=', '1_product'), ('compute_price', '=', 'fixed')
])
new_price = plitem.fixed_price
self.assertNotEqual(old_price, new_price,
"Hotel Calendar can't change price")
self.assertEqual(new_price, 999.9, "Hotel Calendar can't change price")
def test_calendar_reservations(self):
now_utc_dt = date_utils.now()
adv_utc_dt = now_utc_dt + timedelta(days=15)
vrooms = (self.hotel_vroom_budget, )
hotel_cal_mngt_obj = self.env['hotel.calendar.management'].sudo(
self.user_hotel_manager)
reserv_start_utc_dt = now_utc_dt + timedelta(days=3)
reserv_end_utc_dt = reserv_start_utc_dt + timedelta(days=3)
folio = self.create_folio(self.user_hotel_manager, self.partner_2)
reservation = self.create_reservation(self.user_hotel_manager, folio,
reserv_start_utc_dt,
reserv_end_utc_dt,
self.hotel_room_simple_100,
"Reservation Test #1")
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
adv_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
self.parity_pricelist_id, self.parity_restrictions_id, True)
avail_end_utc_dt = reserv_end_utc_dt - timedelta(days=1)
for vroom in vrooms:
for k_pr, v_pr in hcal_data['count_reservations'].iteritems():
if k_pr == vroom.id: # Only Check Test Cases
for k_info, v_info in enumerate(v_pr):
ndate = date_utils.get_datetime(v_info['date'])
if date_utils.date_in(ndate, reserv_start_utc_dt,
avail_end_utc_dt) == 0:
self.assertEqual(
v_info['num'], 1, "Hotel Calendar Management \
Availability doesn't match!")
def test_invalid_input_calendar_data(self):
now_utc_dt = date_utils.now()
adv_utc_dt = now_utc_dt + timedelta(days=15)
hotel_cal_mngt_obj = self.env['hotel.calendar.management'].sudo(
self.user_hotel_manager)
with self.assertRaises(ValidationError):
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
False, adv_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.parity_pricelist_id, self.parity_restrictions_id, True)
with self.assertRaises(ValidationError):
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT), False,
self.parity_pricelist_id, self.parity_restrictions_id, True)
with self.assertRaises(ValidationError):
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
False, False, self.parity_pricelist_id,
self.parity_restrictions_id, True)
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
adv_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT), False, False,
True)
self.assertTrue(
any(hcal_data), "Hotel Calendar invalid default \
management parity models!")
def test_create_reservation(self):
now_utc_dt = date_utils.now()
reserv_start_utc_dt = now_utc_dt + timedelta(days=3)
reserv_end_utc_dt = reserv_start_utc_dt + timedelta(days=3)
folio = self.create_folio(self.user_hotel_manager, self.partner_2)
reservation = self.create_reservation(self.user_hotel_manager, folio,
reserv_start_utc_dt,
reserv_end_utc_dt,
self.hotel_room_double_200,
"Reservation Test #1")
reserv_start_dt = date_utils.dt_as_timezone(reserv_start_utc_dt,
self.tz_hotel)
reserv_end_dt = date_utils.dt_as_timezone(
reserv_end_utc_dt - timedelta(days=1), self.tz_hotel)
self.assertEqual(reservation.reservation_lines[0].date,
reserv_start_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
"Reservation lines don't start in the correct date")
self.assertEqual(reservation.reservation_lines[-1].date,
reserv_end_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
"Reservation lines don't end in the correct date")
total_price = 0.0
for rline in reservation.reservation_lines:
total_price += rline.price
self.assertEqual(folio.amount_untaxed, total_price,
"Folio amount doesn't match with reservation lines")
def test_write(self):
now_utc_dt = date_utils.now()
day_utc_dt = now_utc_dt + timedelta(days=20)
budget_product_id = self.hotel_room_type_budget.product_id
pr_item_obj = self.env['product.pricelist.item']
parity_pricelist = self.env['product.pricelist'].browse(
[self.parity_pricelist_id])
parity_pricelist.write({'wpid': 1234})
pricelist_item = pr_item_obj.sudo(self.user_hotel_manager).create({
'pricelist_id':
self.parity_pricelist_id,
'date_start':
day_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
'date_end':
day_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
'compute_price':
'fixed',
'applied_on':
'1_product',
'product_tmpl_id':
budget_product_id.product_tmpl_id.id,
'fixed_price':
99.0,
})
self.assertTrue(pricelist_item, "Can't create test pricelist")
pricelist_item.write({'fixed_price': 30.0})
self.assertEqual(pricelist_item.fixed_price, 30.0, "Invalid price")
def set_parity_pricelist_id(self):
pricelist_id = super(
HotelConfiguration, self).set_parity_pricelist_id()
self.env['virtual.room.pricelist.cached'].search([]).unlink()
pricelist_items = self.env['product.pricelist.item'].search([
('pricelist_id', '=', pricelist_id)
])
vroom_obj = self.env['hotel.virtual.room']
for pitem in pricelist_items:
date_start = pitem.date_start
product_tmpl_id = pitem.product_tmpl_id.id
fixed_price = pitem.fixed_price
vroom = vroom_obj.search([
('product_id.product_tmpl_id', '=', product_tmpl_id),
('date_start', '>=', date_utils.now().strftime(
DEFAULT_SERVER_DATETIME_FORMAT))
], limit=1)
vroom_pr_cached_obj.create({
'virtual_room_id': vroom.id,
'date': date_start,
'price': prod_price,
})
return pricelist_id
def fetch_rooms_values(self, dfrom, dto, rooms=False, set_max_avail=False):
# Sanitize Dates
now_dt = date_utils.now()
dfrom_dt = date_utils.get_datetime(dfrom)
dto_dt = date_utils.get_datetime(dto)
if dto_dt < now_dt:
return True
if dfrom_dt < now_dt:
dfrom_dt = now_dt
if dfrom_dt > dto_dt:
dfrom_dt, dto_dt = dto_dt, dfrom_dt
try:
results = self.backend_adapter.fetch_rooms_values(
dfrom_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT),
dto_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), rooms)
self._generate_room_values(dfrom,
dto,
results,
set_max_avail=set_max_avail)
except ChannelConnectorError as err:
self.create_issue('room',
_("Can't fetch rooms values from WuBook"),
err.data['message'],
dfrom=dfrom,
dto=dto)
return False
return True
def test_excluded_taxes(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt, self.tz_hotel)
# Invalid Occupancy
wbooks = [
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_budget.wrid: {
'occupancy': [1],
'dayprices': [15.0, 15.0]
}
},
brooms_ancillary={
"tax_inclusive": False,
"taxes": 9.99,
"fees": 0.0,
}
)]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
self.assertFalse(errors)
self.assertTrue(any(processed_rids))
nreserv = self.env['hotel.reservation'].search([
('wrid', 'in', processed_rids)
], order="id ASC", limit=1)
self.assertNotEqual(nreserv.amount_room, 30.0, "Invalid Prices!")
def update_price(self):
for line in self:
now_utc_dt = date_utils.now()
if not self.checkin:
self.checkin = self.folio_wizard_id.checkin
if not self.checkout:
self.checkout = self.folio_wizard_id.checkout
if self.rooms_num > self.max_rooms:
raise ValidationError(_("There are not enough rooms!"))
# UTC -> Hotel tz
tz = self.env['ir.values'].get_default('hotel.config.settings',
'tz_hotel')
chkin_utc_dt = date_utils.get_datetime(self.checkin)
chkout_utc_dt = date_utils.get_datetime(self.checkout)
if chkin_utc_dt >= chkout_utc_dt:
dpt_hour = self.env['ir.values'].get_default(
'hotel.config.settings', 'default_departure_hour')
checkout_str = (
chkin_utc_dt +
timedelta(days=1)).strftime(DEFAULT_SERVER_DATE_FORMAT)
checkout_str = "%s %s:00" % (checkout_str, dpt_hour)
checkout_dt = date_utils.get_datetime(checkout_str, stz=tz)
checkout_utc_dt = date_utils.dt_as_timezone(checkout_dt, 'UTC')
self.checkout = checkout_utc_dt.strftime(
DEFAULT_SERVER_DATETIME_FORMAT)
checkout_dt = date_utils.get_datetime(self.checkout, stz=tz)
# Reservation end day count as free day. Not check it
checkout_dt -= timedelta(days=1)
nights = days_diff = date_utils.date_diff(self.checkin,
self.checkout,
hours=False)
start_date_dt = date_utils.dt_as_timezone(chkin_utc_dt, tz)
# Reservation end day count as free day. Not check it
checkout_dt -= timedelta(days=1)
pricelist_id = self.env['ir.values'].sudo().get_default(
'hotel.config.settings', 'parity_pricelist_id')
if pricelist_id:
pricelist_id = int(pricelist_id)
res_price = 0
for i in range(0, nights):
ndate = start_date_dt + timedelta(days=i)
ndate_str = ndate.strftime(DEFAULT_SERVER_DATE_FORMAT)
prod = self.virtual_room_id.product_id.with_context(
lang=self.folio_wizard_id.partner_id.lang,
partner=self.folio_wizard_id.partner_id.id,
quantity=1,
date=ndate_str,
pricelist=pricelist_id,
uom=self.virtual_room_id.product_id.uom_id.id)
res_price += prod.price
self.price = res_price - (res_price * self.discount) / 100
self.total_price = self.rooms_num * self.price
self.amount_reservation = self.total_price
def test_write(self):
now_utc_dt = date_utils.now()
day_utc_dt = now_utc_dt + timedelta(days=20)
day_utc_str = day_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)
rest_item_obj = self.env['hotel.virtual.room.restriction.item']
restriction = rest_item_obj.search([], limit=1)
self.assertTrue(restriction, "Can't found restriction for test")
restriction.write({'min_stay': 3, 'date_start': day_utc_str})
self.assertEqual(restriction.min_stay, 3, "Invalid Max Avail")
self.assertEqual(restriction.date_start, day_utc_str, "Invalid Date")
def test_complex_booking(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt,
self.tz_hotel)
checkout_utc_dt = checkin_utc_dt + timedelta(days=2)
date_diff = date_utils.date_diff(checkin_utc_dt, checkout_utc_dt,
hours=False) + 1
wbooks = [self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_budget.wrid: {
'occupancy': [1, 1], # 2 Reservation Line
'dayprices': [15.0, 15.0] # 2 Days
}
}
)]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
# Check Creation
self.assertTrue(any(processed_rids), "Reservation not found")
self.assertFalse(errors, "Reservation errors")
nreservs = self.env['hotel.reservation'].search([
('wrid', 'in', processed_rids)
], order='id ASC')
self.assertEqual(len(nreservs), 2, "Reservations not found")
for nreserv in nreservs:
# Check State
self.assertEqual(nreserv.state, 'draft',
"Invalid reservation state")
# Check Dates
self.assertEqual(
nreserv.checkin,
checkin_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
"Invalid Checkin Reservation Date")
self.assertEqual(
nreserv.checkout,
checkout_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
"Invalid Checkout Reservation Date")
# Check Price
self.assertEqual(nreserv.price_unit, 30.0,
"Invalid Reservation Price")
# Check Reservation Lines
self.assertTrue(any(nreserv.reservation_lines),
"Reservation lines snot found")
dates_arr = date_utils.generate_dates_list(checkin_dt, date_diff-1)
for k_line, v_line in enumerate(nreserv.reservation_lines):
self.assertEqual(dates_arr[k_line], v_line['date'],
"Invalid Reservation Lines Dates")
def test_import_channels_info(self):
now_utc_dt = date_utils.now()
day_utc_dt = now_utc_dt + timedelta(days=20)
info_channel = self.env['wubook.channel.info'].create({
'wid':
1234,
'name':
'Test Channel',
})
self.assertTrue(info_channel, "Can't create test channel info")
info_channel.import_channels_info()
def test_write(self):
now_utc_dt = date_utils.now()
day_utc_dt = now_utc_dt + timedelta(days=1)
vroom_avail_obj = self.env['hotel.virtual.room.availability']
avail = vroom_avail_obj.search(
[('virtual_room_id', '=', self.hotel_vroom_budget.id),
('date', '=', now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT))],
limit=1)
avail.write({
'avail': 1,
})
self.assertEqual(avail.avail, 1, "Invalid avail")
def push_priceplans(self):
unpushed = self.env['product.pricelist.item'].search(
[('wpushed', '=', False),
('date_start', '>=', date_utils.now(
hours=False).strftime(DEFAULT_SERVER_DATE_FORMAT))],
order="date_start ASC")
if any(unpushed):
date_start = date_utils.get_datetime(
unpushed[0].date_start, dtformat=DEFAULT_SERVER_DATE_FORMAT)
date_end = date_utils.get_datetime(
unpushed[-1].date_start, dtformat=DEFAULT_SERVER_DATE_FORMAT)
days_diff = date_utils.date_diff(date_start, date_end,
hours=False) + 1
prices = {}
pricelist_ids = self.env['product.pricelist'].search([
('wpid', '!=', False), ('active', '=', True)
])
for pr in pricelist_ids:
prices.update({pr.wpid: {}})
unpushed_pl = self.env['product.pricelist.item'].search([
('wpushed', '=', False), ('pricelist_id', '=', pr.id)
])
product_tmpl_ids = unpushed_pl.mapped('product_tmpl_id')
for pt_id in product_tmpl_ids:
room_type = self.env['hotel.room.type'].search(
[('product_id.product_tmpl_id', '=', pt_id.id)],
limit=1)
if room_type:
prices[pr.wpid].update({room_type.wrid: []})
for i in range(0, days_diff):
prod = room_type.product_id.with_context({
'quantity':
1,
'pricelist':
pr.id,
'date':
(date_start + timedelta(days=i)
).strftime(DEFAULT_SERVER_DATE_FORMAT),
})
prices[pr.wpid][room_type.wrid].append(prod.price)
_logger.info("UPDATING PRICES IN WUBOOK...")
_logger.info(prices)
for k_pk, v_pk in prices.iteritems():
if any(v_pk):
self.backend_adapter.update_plan_prices(
k_pk, date_start.strftime(DEFAULT_SERVER_DATE_FORMAT),
v_pk)
unpushed.with_context({
'wubook_action': False
}).write({'wpushed': True})
return True
def test_overbooking(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt, self.tz_hotel)
# Invalid Occupancy
wbooks = [
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_budget.wrid: {
'occupancy': [1],
'dayprices': [15.0, 15.0]
}
}
),
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_budget.wrid: {
'occupancy': [1],
'dayprices': [15.0, 15.0]
}
}
),
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_budget.wrid: {
'occupancy': [1],
'dayprices': [15.0, 15.0]
}
}
)]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
self.assertFalse(errors, "Overbooking don't handled")
self.assertTrue(any(processed_rids), "Overbooking don't handled")
nreservs = self.env['hotel.reservation'].search([
('wrid', 'in', processed_rids)
], order="id ASC")
self.assertFalse(nreservs[0].overbooking,
"Overbooking don't handled")
self.assertFalse(nreservs[1].overbooking,
"Overbooking don't handled")
self.assertTrue(nreservs[2].overbooking,
"Overbooking don't handled")
def test_write(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt,
self.tz_hotel)
checkout_utc_dt = checkin_utc_dt + timedelta(days=2)
date_diff = date_utils.date_diff(checkin_utc_dt, checkout_utc_dt,
hours=False) + 1
wbooks = [
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_room_type_budget.wrid: {
'occupancy': [1],
'dayprices': [15.0, 15.0]
}
}
),
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_1,
{
self.hotel_room_type_budget.wrid: {
'occupancy': [1],
'dayprices': [15.0, 15.0]
}
}
)
]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
self.assertTrue(any(processed_rids), "Reservation not found")
self.assertFalse(errors, "Reservation errors")
self.partner_2.sudo(self.user_hotel_manager).write({
'vat': 'ES00000000T'
})
self.partner_1.sudo(self.user_hotel_manager).write({
'vat': 'ES00000000T',
'unconfirmed': True,
})
reservation = self.env['hotel.reservation'].search([
('wrid', '=', processed_rids[1])
], order='id ASC', limit=1)
self.assertTrue(reservation, "Can't found reservation")
self.assertFalse(self.partner_1.active, "Uncofirmed user still active")
self.assertEqual(reservation.partner_id.id,
self.partner_2.id,
"Old Partner not changed")
def test_complex_bookings(self):
now_utc_dt = date_utils.now()
checkin_utc_dt = now_utc_dt + timedelta(days=3)
checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt,
self.tz_hotel)
checkout_utc_dt = checkin_utc_dt + timedelta(days=2)
date_diff = date_utils.date_diff(checkin_utc_dt, checkout_utc_dt,
hours=False) + 1
wbooks = [
self.create_wubook_booking(
self.user_hotel_manager,
checkin_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_special.wrid: {
'occupancy': [2], # 2 Reservation Line
'dayprices': [15.0, 15.0] # 2 Days
}
}
),
self.create_wubook_booking(
self.user_hotel_manager,
(checkin_dt - timedelta(days=3)).strftime(
DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_special.wrid: {
'occupancy': [2], # 2 Reservation Line
'dayprices': [15.0, 15.0] # 2 Days
}
}
),
self.create_wubook_booking(
self.user_hotel_manager,
(checkin_dt + timedelta(days=3)).strftime(
DEFAULT_SERVER_DATETIME_FORMAT),
self.partner_2,
{
self.hotel_vroom_special.wrid: {
'occupancy': [2], # 2 Reservation Line
'dayprices': [15.0, 15.0] # 2 Days
}
}
)
]
processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \
self.env['wubook'].sudo().generate_reservations(wbooks)
self.assertEqual(len(processed_rids), 3, "Reservation not found")
self.assertFalse(errors, "Reservation errors")
def test_invalid_input_calendar_data(self):
now_utc_dt = date_utils.now()
adv_utc_dt = now_utc_dt + timedelta(days=15)
hotel_reserv_obj = self.env['hotel.reservation'].sudo(
self.user_hotel_manager)
with self.assertRaises(ValidationError):
hcal_data = hotel_reserv_obj.get_hcalendar_all_data(
False, adv_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT))
with self.assertRaises(ValidationError):
hcal_data = hotel_reserv_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT), False)
with self.assertRaises(ValidationError):
hcal_data = hotel_reserv_obj.get_hcalendar_all_data(False, False)
def test_calendar_prices(self):
now_utc_dt = date_utils.now()
adv_utc_dt = now_utc_dt + timedelta(days=15)
room_types = (self.hotel_room_type_budget, self.hotel_room_type_special)
hotel_cal_mngt_obj = self.env['hotel.calendar.management'].sudo(
self.user_hotel_manager)
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
adv_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
self.default_pricelist_id,
self.default_restriction_id,
True)
for room_type in room_types:
for k_pr, v_pr in hcal_data['prices'].iteritems():
if k_pr == room_type.id: # Only Check Test Cases
for k_info, v_info in enumerate(v_pr):
if k_info >= len(self.prices_tmp[room_type.id]):
break
self.assertEqual(v_info['price'],
self.prices_tmp[room_type.id][k_info],
"Hotel Calendar Management Prices \
doesn't match!")
# REMOVE PRICES
prices_obj = self.env['product.pricelist.item'].sudo(
self.user_hotel_manager)
prod_tmpl_ids = (
self.hotel_room_type_budget.product_id.product_tmpl_id.id,
self.hotel_room_type_special.product_id.product_tmpl_id.id
)
pr_ids = prices_obj.search([
('pricelist_id', '=', self.default_pricelist_id),
('product_tmpl_id', 'in', prod_tmpl_ids),
])
pr_ids.sudo(self.user_hotel_manager).unlink()
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
adv_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
self.default_pricelist_id,
self.default_restriction_id,
True)
self.assertFalse(any(hcal_data['prices']), "Hotel Calendar Management \
Prices doesn't match after remove!")
def onchange_checks(self):
'''
When you change checkin or checkout it will checked it
and update the qty of hotel folio line
-----------------------------------------------------------------
@param self: object pointer
'''
self.ensure_one()
now_utc_dt = date_utils.now()
if not self.checkin:
self.checkin = time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
if not self.checkout:
self.checkout = time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
# UTC -> Hotel tz
tz = self.env['ir.values'].get_default('hotel.config.settings',
'tz_hotel')
chkin_utc_dt = date_utils.get_datetime(self.checkin)
chkout_utc_dt = date_utils.get_datetime(self.checkout)
if chkin_utc_dt >= chkout_utc_dt:
dpt_hour = self.env['ir.values'].get_default(
'hotel.config.settings', 'default_departure_hour')
checkout_str = (
chkin_utc_dt +
timedelta(days=1)).strftime(DEFAULT_SERVER_DATE_FORMAT)
checkout_str = "%s %s:00" % (checkout_str, dpt_hour)
checkout_dt = date_utils.get_datetime(checkout_str, stz=tz)
checkout_utc_dt = date_utils.dt_as_timezone(checkout_dt, 'UTC')
self.checkout = checkout_utc_dt.strftime(
DEFAULT_SERVER_DATETIME_FORMAT)
checkout_dt = date_utils.get_datetime(self.checkout, stz=tz)
# Reservation end day count as free day. Not check it
checkout_dt -= timedelta(days=1)
virtual_room_ids = self.env['hotel.virtual.room'].search([])
virtual_rooms = []
for virtual in virtual_room_ids:
virtual_rooms.append((0, False, {
'virtual_room_id': virtual.id,
'checkin': self.checkin,
'checkout': self.checkout,
'folio_wizard_id': self.id,
}))
self.virtual_room_wizard_ids = virtual_rooms
for virtual in self.virtual_room_wizard_ids:
virtual.update_price()
def test_calendar_restrictions(self):
now_utc_dt = date_utils.now()
adv_utc_dt = now_utc_dt + timedelta(days=15)
room_types = (self.hotel_room_type_budget, self.hotel_room_type_special)
hotel_cal_mngt_obj = self.env['hotel.calendar.management'].sudo(
self.user_hotel_manager)
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
adv_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
self.default_pricelist_id,
self.default_restriction_id,
True)
for room_type in room_types:
for k_pr, v_pr in hcal_data['restrictions'].iteritems():
if k_pr == room_type.id: # Only Check Test Cases
for k_info, v_info in enumerate(v_pr):
rest_items = self.restrictions_min_stay_tmp[room_type.id]
if k_info >= len(rest_items):
break
self.assertEqual(
v_info['min_stay'],
self.restrictions_min_stay_tmp[room_type.id][k_info],
"Hotel Calendar Management Restrictions \
doesn't match!")
# REMOVE RESTRICTIONS
rest_it_obj = self.env['hotel.room.type.restriction.item'].sudo(
self.user_hotel_manager)
rest_ids = rest_it_obj.search([
('restriction_id', '=', self.default_restriction_id),
('room_type_id', 'in', (self.hotel_room_type_budget.id,
self.hotel_room_type_special.id)),
])
rest_ids.sudo(self.user_hotel_manager).unlink()
hcal_data = hotel_cal_mngt_obj.get_hcalendar_all_data(
now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
adv_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
self.default_pricelist_id,
self.default_restriction_id,
True)
self.assertFalse(
any(hcal_data['restrictions']),
"Hotel Calendar Management Restrictions doesn't match \
after remove!")
def action_folios_amount(self):
now_utc_dt = date_utils.now()
now_utc_str = now_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
reservations = self.env['hotel.reservation'].search([
('checkout', '<=', now_utc_str)
])
folio_ids = reservations.mapped('folio_id.id')
folios = self.env['hotel.folio'].search([('id', 'in', folio_ids)])
folios = folios.filtered(lambda r: r.invoices_amount > 0)
return {
'name': _('Pending'),
'view_type': 'form',
'view_mode': 'tree,form',
'res_model': 'hotel.folio',
'type': 'ir.actions.act_window',
'domain': [('id', 'in', folios.ids)]
}
def test_swap_reservation(self):
hcal_reserv_obj = self.env['hotel.reservation'].sudo(
self.user_hotel_manager)
now_utc_dt = date_utils.now()
# CREATE RESERVATIONS
reserv_start_utc_dt = now_utc_dt + timedelta(days=3)
reserv_end_utc_dt = reserv_start_utc_dt + timedelta(days=3)
folio_a = self.create_folio(self.user_hotel_manager, self.partner_2)
reservation_a = self.create_reservation(
self.user_hotel_manager,
folio_a,
reserv_start_utc_dt,
reserv_end_utc_dt,
self.hotel_room_double_200,
"Reservation Test #1")
self.assertTrue(reservation_a,
"Hotel Calendar create test reservation!")
folio_a.sudo(self.user_hotel_manager).action_confirm()
folio_b = self.create_folio(self.user_hotel_manager, self.partner_2)
reservation_b = self.create_reservation(
self.user_hotel_manager,
folio_b,
reserv_start_utc_dt,
reserv_end_utc_dt,
self.hotel_room_simple_101,
"Reservation Test #2")
self.assertTrue(reservation_b,
"Hotel Calendar can't create test reservation!")
folio_b.sudo(self.user_hotel_manager).action_confirm()
self.assertTrue(
hcal_reserv_obj.swap_reservations(reservation_a.ids,
reservation_b.ids),
"Hotel Calendar invalid swap operation"
)
self.assertEqual(reservation_a.product_id.id,
self.hotel_room_simple_101.product_id.id,
"Hotel Calendar wrong swap operation")
self.assertEqual(reservation_b.product_id.id,
self.hotel_room_double_200.product_id.id,
"Hotel Calendar wrong swap operation")
def _get_default_checkout(self):
folio = False
default_departure_hour = self.env['ir.values'].get_default(
'hotel.config.settings', 'default_departure_hour')
if 'folio_id' in self._context:
folio = self.env['hotel.folio'].search([
('id', '=', self._context['folio_id'])
])
if folio and folio.room_lines:
return folio.room_lines[0].checkout
else:
tz_hotel = self.env['ir.values'].get_default(
'hotel.config.settings', 'tz_hotel')
now_utc_dt = date_utils.now() + timedelta(days=1)
ndate = "%s %s:00" % \
(now_utc_dt.strftime(DEFAULT_SERVER_DATE_FORMAT),
default_departure_hour)
ndate_dt = date_utils.get_datetime(ndate, stz=tz_hotel)
ndate_dt = date_utils.dt_as_timezone(ndate_dt, 'UTC')
return ndate_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
def test_cancel_folio(self):
now_utc_dt = date_utils.now()
org_reserv_start_utc_dt = now_utc_dt + timedelta(days=3)
org_reserv_end_utc_dt = org_reserv_start_utc_dt + timedelta(days=6)
folio = self.create_folio(self.user_hotel_manager, self.partner_2)
reservation_a = self.create_reservation(self.user_hotel_manager, folio,
org_reserv_start_utc_dt,
org_reserv_end_utc_dt,
self.hotel_room_double_200,
"Reservation Test #1")
reservation_b = self.create_reservation(self.user_hotel_manager, folio,
org_reserv_start_utc_dt,
org_reserv_end_utc_dt,
self.hotel_room_simple_100,
"Reservation Test #2")
self.assertEqual(len(folio.room_lines), 2, 'Invalid room lines count')
folio.action_cancel()
self.assertEqual(folio.state, 'cancel', 'Invalid folio state')
for rline in folio.room_lines:
self.assertEqual(rline.state, 'cancelled',
'Invalid reservation state')
def push_availability(self):
room_type_avail_ids = self.env['hotel.room.type.availability'].search([
('wpushed', '=', False),
('date', '>=',
date_utils.now(hours=False).strftime(DEFAULT_SERVER_DATE_FORMAT))
])
room_types = room_type_avail_ids.mapped('room_type_id')
avails = []
for room_type in room_types:
room_type_avails = room_type_avail_ids.filtered(
lambda x: x.room_type_id.id == room_type.id)
days = []
for room_type_avail in room_type_avails:
room_type_avail.with_context({
'wubook_action': False
}).write({'wpushed': True})
wavail = room_type_avail.avail
if wavail > room_type_avail.wmax_avail:
wavail = room_type_avail.wmax_avail
date_dt = date_utils.get_datetime(
room_type_avail.date, dtformat=DEFAULT_SERVER_DATE_FORMAT)
days.append({
'date':
date_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT),
'avail':
wavail,
'no_ota':
room_type_avail.no_ota and 1 or 0,
# 'booked': room_type_avail.booked and 1 or 0,
})
avails.append({'id': room_type.wrid, 'days': days})
_logger.info("UPDATING AVAILABILITY IN WUBOOK...")
_logger.info(avails)
if any(avails):
self.backend_adapter.update_availability(avails)
return True
