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