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 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_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_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 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 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_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_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 onchange_dates(self): for line in self: if not self.checkin: self.checkin = self.folio_wizard_id.checkin if not self.checkout: self.checkout = self.folio_wizard_id.checkout hotel_tz = self.env['ir.values'].sudo().get_default( 'hotel.config.settings', 'hotel_tz') start_date_utc_dt = date_utils.get_datetime(line.checkin) start_date_dt = date_utils.dt_as_timezone(start_date_utc_dt, hotel_tz) if line.virtual_room_id: pricelist_id = self.env['ir.values'].sudo().get_default( 'hotel.config.settings', 'parity_pricelist_id') if pricelist_id: pricelist_id = int(pricelist_id) nights = days_diff = date_utils.date_diff(line.checkin, line.checkout, hours=False) res_price = 0 res_partner = self.partner_id or self.env[ 'res.partner'].browse('1') for i in range(0, nights): ndate = start_date_dt + timedelta(days=i) ndate_str = ndate.strftime(DEFAULT_SERVER_DATE_FORMAT) prod = line.virtual_room_id.product_id.with_context( lang=self.partner_id.lang, partner=self.partner_id.id, quantity=1, date=ndate_str, pricelist=pricelist_id, uom=line.product_id.uom_id.id) res_price += prod.price adults = self.env['hotel.room'].search([ ('product_id.id', '=', line.product_id.id) ]).capacity res_price = res_price - (res_price * self.discount) / 100 line.amount_reservation = res_price line.price = res_price checkout_dt = date_utils.get_datetime(self.checkout) checkout_dt -= timedelta(days=1) occupied = self.env['hotel.reservation'].occupied( self.checkin, checkout_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)) rooms_occupied = occupied.mapped('product_id.id') domain_rooms = [('isroom', '=', True), ('id', 'not in', rooms_occupied)] return {'domain': {'product_id': domain_rooms}}
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 _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_save_changes(self): now_utc_dt = date_utils.now() adv_utc_dt = now_utc_dt + timedelta(days=3) room_types = (self.hotel_room_type_budget, ) hotel_cal_mngt_obj = self.env['hotel.calendar.management'].sudo( self.user_hotel_manager) # Generate new prices prices = (144.0, 170.0, 30.0, 50.0) cprices = {} for k_item, v_item in enumerate(prices): ndate_utc_dt = now_utc_dt + timedelta(days=k_item) cprices.setdefault(self.hotel_room_type_budget.id, []).append({ 'date': ndate_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT), 'price': v_item }) # Generate new restrictions restrictions = { 'min_stay': (3, 2, 4, 1), 'max_stay': (5, 8, 9, 3), 'min_stay_arrival': (2, 3, 6, 2), 'max_stay_arrival': (4, 7, 7, 4), 'closed_departure': (False, True, False, True), 'closed_arrival': (True, False, False, False), 'closed': (False, False, True, True), } crestrictions = {} for i in range(0, 4): ndate_utc_dt = now_utc_dt + timedelta(days=i) crestrictions.setdefault( self.hotel_room_type_budget.id, []).append({ 'date': ndate_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT), 'closed_arrival': restrictions['closed_arrival'][i], 'max_stay': restrictions['max_stay'][i], 'min_stay': restrictions['min_stay'][i], 'closed_departure': restrictions['closed_departure'][i], 'closed': restrictions['closed'][i], 'min_stay_arrival': restrictions['min_stay_arrival'][i], 'max_stay_arrival': restrictions['max_stay_arrival'][i], }) # Generate new availability avails = (1, 2, 2, 1) cavails = {} for k_item, v_item in enumerate(avails): ndate_utc_dt = now_utc_dt + timedelta(days=k_item) ndate_dt = date_utils.dt_as_timezone(ndate_utc_dt, self.tz_hotel) cavails.setdefault(self.hotel_room_type_budget.id, []).append({ 'date': ndate_dt.strftime(DEFAULT_SERVER_DATE_FORMAT), 'avail': v_item, 'no_ota': False, }) # Save new values hotel_cal_mngt_obj.save_changes(self.parity_pricelist_id, self.parity_restrictions_id, cprices, crestrictions, cavails) # Check data integrity 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) for room_type in room_types: for k_pr, v_pr in hcal_data['availability'].iteritems(): if k_pr == room_type.id: # Only Check Test Cases for k_info, v_info in enumerate(v_pr): self.assertEqual( v_info['avail'], avails[k_info], "Hotel Calendar Management \ Availability doesn't match!") 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): self.assertEqual( v_info['min_stay'], restrictions['min_stay'][k_info], "Hotel Calendar Management \ Restrictions doesn't match!") self.assertEqual( v_info['max_stay'], restrictions['max_stay'][k_info], "Hotel Calendar Management \ Restrictions doesn't match!") self.assertEqual( v_info['min_stay_arrival'], restrictions['min_stay_arrival'][k_info], "Hotel Calendar Management Restrictions \ doesn't match!") self.assertEqual( v_info['max_stay_arrival'], restrictions['max_stay_arrival'][k_info], "Hotel Calendar Management Restrictions \ doesn't match!") self.assertEqual( v_info['closed_departure'], restrictions['closed_departure'][k_info], "Hotel Calendar Management Restrictions \ doesn't match!") self.assertEqual( v_info['closed_arrival'], restrictions['closed_arrival'][k_info], "Hotel Calendar Management Restrictions \ doesn't match!") self.assertEqual( v_info['closed'], restrictions['closed'][k_info], "Hotel Calendar Management Restrictions \ doesn't match!") 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): self.assertEqual( v_info['price'], prices[k_info], "Hotel Calendar \ Management Prices doesn't match!")
def create_wubook_booking(self, creator, checkin, partner, rinfo, channel=0, notes='', brooms_ancillary=None): rcode = randint(100000, 999999) crcode = randint(100000, 999999) brate = randint(100000, 999999) id_woodoo = randint(100000, 999999) if not partner.email or partner.email == '': self.raiseException("Partner doesn't have a mail") now_utc_dt = date_utils.now() now_dt = date_utils.dt_as_timezone(now_utc_dt, self.tz_hotel) checkin_utc_dt = date_utils.get_datetime(checkin) checkin_dt = date_utils.dt_as_timezone(checkin_utc_dt, self.tz_hotel) numdays = 0 for k_room, v_room in rinfo.iteritems(): numdays = max(len(v_room['dayprices']), numdays) checkout_utc_dt = checkin_utc_dt + timedelta(days=numdays) checkout_dt = date_utils.dt_as_timezone(checkout_utc_dt, self.tz_hotel) date_diff = date_utils.date_diff(checkin_utc_dt, checkout_utc_dt, hours=False) # Generate Day Prices dayprices = {} total_amount = 0.0 for k_room, v_room in rinfo.iteritems(): for price in v_room['dayprices']: dayprices.setdefault(k_room, []).append(price) total_amount += price # Generate Values rooms = [] rooms_occu = [] booked_rooms = [] vroom_obj = self.env['hotel.virtual.room'] max_persons = 0 for k_room, v_room in rinfo.iteritems(): vroom = vroom_obj.search([('wrid', '=', k_room)], limit=1) # Generate Rooms for price in range(0, len(v_room['occupancy'])): rooms.append(k_room) # Generate Rooms Occupancies for val in v_room['occupancy']: # Generate Rooms Occupancies rooms_occu.append({ 'id': k_room, 'occupancy': val, }) # Generate Booked Rooms roomdays = [] for k_price, v_price in enumerate(v_room['dayprices']): ndate = checkin_dt + timedelta(days=k_price) roomdays.append({ 'ancillary': {}, 'rate_id': 3, 'price': v_price, 'day': ndate.strftime(DEFAULT_WUBOOK_DATE_FORMAT) }) booked_rooms.append({ 'ancillary': { 'channel_room_id': 1, 'channel_room_name': vroom.name, 'addons': [], 'guests': val }, 'room_id': k_room, 'roomdays': roomdays }) if brooms_ancillary: booked_rooms[len(booked_rooms) - 1]['ancillary'].update(brooms_ancillary) if val > max_persons: max_persons = val return { 'id_channel': channel, 'special_offer': '', 'reservation_code': rcode, 'dayprices': dayprices, 'arrival_hour': checkin_dt.strftime(DEFAULT_WUBOOK_TIME_FORMAT), 'booked_rate': brate, 'rooms': ','.join(map(str, rooms)), 'customer_mail': partner.email, 'customer_country': 'ES', 'children': 0, 'payment_gateway_fee': '', 'modified_reservations': [], 'customer_surname': ' '.join(partner.name.split(' ')[1:]), 'date_departure': checkout_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), 'amount_reason': '', 'customer_city': partner.city, 'opportunities': 0, 'date_received': now_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), 'rooms_occupancies': rooms_occu, 'sessionSeed': '', 'booked_rooms': booked_rooms, 'customer_name': partner.name.split(' ')[0], 'date_arrival': checkin_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), 'status': WUBOOK_STATUS_CONFIRMED, 'was_modified': 0, 'channel_reservation_code': crcode, 'men': max_persons, 'orig_amount': total_amount, 'customer_phone': partner.mobile or partner.phone or '', 'customer_notes': notes, 'customer_address': partner.street, 'device': -1, 'addons_list': [], 'status_reason': '', 'roomnight': date_diff - 1, 'boards': '', 'customer_language': 32, 'fount': '', 'channel_data': {}, 'room_opportunities': 0, 'customer_zip': partner.zip, 'amount': total_amount, 'id_woodoo': id_woodoo, 'cc_info': 1, 'customer_language_iso': 'es' }
def test_splitted_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 book_a = 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] } } ) book_b = self.create_wubook_booking( self.user_hotel_manager, (checkin_dt + timedelta(days=2)).strftime( DEFAULT_SERVER_DATETIME_FORMAT), self.partner_2, { self.hotel_vroom_budget.wrid: { 'occupancy': [1], 'dayprices': [15.0, 15.0] } } ) wbooks = [book_a, book_b] processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \ self.env['wubook'].sudo().generate_reservations(wbooks) self.assertEqual(len(processed_rids), 2, "Reservation not found") self.assertFalse(errors, "Reservation errors") reserv = self.env['hotel.reservation'].search([ ('wrid', '=', book_b['reservation_code']) ], order='id ASC', limit=1) self.assertTrue(reserv, "Rervation doesn't exists") self.assertEqual( reserv.product_id.id, self.hotel_room_simple_100.product_id.id, "Unexpected room assigned") reserv.product_id = \ self.hotel_room_simple_101.product_id.id 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, 20.0, 17.0] } } ) ] 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") # Check Splitted Integrity nreservs = self.env['hotel.reservation'].search([ ('wrid', 'in', processed_rids) ], order="id ASC") _logger.info(nreservs) self.assertEqual(len(nreservs), 2, "Reservations not found") date_dt = date_utils.get_datetime(nreservs[0].checkin) self.assertEqual(nreservs[0].reservation_lines[0].date, date_dt.strftime(DEFAULT_SERVER_DATE_FORMAT), "Invalid split") date_dt = date_utils.get_datetime(nreservs[1].checkin) self.assertEqual(nreservs[1].reservation_lines[0].date, date_dt.strftime(DEFAULT_SERVER_DATE_FORMAT), "Invalid split") self.assertEqual(nreservs[0].price_unit, 30.0, "Invalid split price") self.assertEqual(nreservs[1].price_unit, 37.0, "Invalid split price") self.assertEqual(nreservs[1].parent_reservation.id, nreservs[0].id, "Invalid split parent reservation") self.assertEqual(nreservs[0].product_id.id, self.hotel_room_simple_101.product_id.id, "Invalid room assigned") self.assertEqual(nreservs[1].product_id.id, self.hotel_room_simple_100.product_id.id, "Invalid room assigned")
def create_reservations(self): self.ensure_one() total = 0 cmds = [] for line in self.virtual_room_wizard_ids: if line.rooms_num == 0: continue if line.rooms_num > line.max_rooms: raise ValidationError(_("Too many rooms!")) elif line.virtual_room_id: checkout_dt = date_utils.get_datetime(line.checkout) occupied = self.env['hotel.reservation'].occupied( line.checkin, checkout_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)) rooms_occupied = occupied.mapped('product_id.id') free_rooms = self.env['hotel.room'].search( [('product_id.id', 'not in', rooms_occupied), ('price_virtual_room.id', '=', line.virtual_room_id.id)], order='sequence', limit=line.rooms_num) room_ids = free_rooms.mapped('product_id.id') product_list = self.env['product.product'].search([('id', 'in', room_ids)]) nights = days_diff = date_utils.date_diff(line.checkin, line.checkout, hours=False) hotel_tz = self.env['ir.values'].sudo().get_default( 'hotel.config.settings', 'hotel_tz') start_date_utc_dt = date_utils.get_datetime(self.checkin) start_date_dt = date_utils.dt_as_timezone( start_date_utc_dt, hotel_tz) for room in product_list: 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 res_partner = self.partner_id or self.env[ 'res.partner'].browse('1') for i in range(0, nights): ndate = start_date_dt + timedelta(days=i) ndate_str = ndate.strftime(DEFAULT_SERVER_DATE_FORMAT) prod = line.virtual_room_id.product_id.with_context( lang=self.partner_id.lang, partner=self.partner_id.id, quantity=1, date=ndate_str, pricelist=pricelist_id, uom=room.uom_id.id) res_price += prod.price adults = self.env['hotel.room'].search([ ('product_id.id', '=', room.id) ]).capacity res_price = res_price - (res_price * line.discount) / 100 total += res_price cmds.append((0, False, { 'checkin': line.checkin, 'checkout': line.checkout, 'discount': line.discount, 'product_id': room.id, 'nights': nights, 'adults': adults, 'children': 0, 'virtual_room_id': line.virtual_room_id, 'price': res_price, 'amount_reservation': res_price })) self.reservation_wizard_ids = cmds self.total = total
def test_generate_room_values(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=1) checkout_dt = date_utils.dt_as_timezone(checkout_utc_dt, self.tz_hotel) vroom_restr_item_obj = self.env['hotel.virtual.room.restriction.item'] vrooms = [self.hotel_vroom_budget, self.hotel_vroom_special] values = self.create_wubook_rooms_values( vrooms, [{ 'closed_arrival': 0, 'booked': 0, 'max_stay_arrival': 9, 'max_stay': 0, 'price': 150.0, 'min_stay': 0, 'closed_departure': '1', 'avail': 0, 'closed': 0, 'min_stay_arrival': 0, 'no_ota': 0, }, { 'closed_arrival': 0, 'booked': 0, 'max_stay_arrival': 9, 'max_stay': 0, 'price': 50.0, 'min_stay': 0, 'closed_departure': '1', 'avail': 0, 'closed': 0, 'min_stay_arrival': 0, 'no_ota': 0, }]) self.env['wubook'].sudo().generate_room_values( checkin_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), checkout_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), values) for vroom in vrooms: items = vroom_restr_item_obj.search([ ('virtual_room_id', '=', vroom.id), ('date_start', '>=', checkin_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)), ('date_end', '<=', checkout_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)), ('restriction_id', '=', self.restriction_default_id) ]) self.assertTrue(any(items), "Hotel Wubook Invalid fetch room values") for item in items: self.assertTrue( item.closed_departure, "Hotel Wubook Invalid fetch room values") self.assertEqual( item.max_stay_arrival, 9, "Hotel Wubook Invalid fetch room values")
def test_cancel_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 def check_state(wrids, state): reservs = self.env['hotel.reservation'].sudo().search([ ('wrid', 'in', wrids) ]) self.assertTrue(any(reservs), "Reservations not found") for reserv in reservs: self.assertEqual( reserv.state, state, "Reservation state invalid") # Create Reservation 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) 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") # Cancel It wbooks = [self.cancel_booking(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") check_state(processed_rids, 'cancelled') # Can't confirm cancelled bookings reserv = self.env['hotel.reservation'].sudo().search([ ('wrid', 'in', processed_rids) ], limit=1) with self.assertRaises(ValidationError): reserv.confirm() # Create Reservation and Cancel It 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 } }) cbook = self.cancel_booking(nbook) wbooks = [nbook, cbook] processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \ self.env['wubook'].sudo().generate_reservations(wbooks) self.assertEqual(len(processed_rids), 2, "Reservation not found") self.assertFalse(errors, "Reservation errors") check_state(processed_rids, 'cancelled')
def _generate_reservations(self, bookings): _logger.info("=== BOOKINGS FROM WUBOOK") _logger.info(bookings) default_arrival_hour = self.env['ir.default'].sudo().get( 'res.config.settings', 'default_arrival_hour') default_departure_hour = self.env['ir.default'].sudo().get( 'res.config.settings', 'default_departure_hour') # Get user timezone tz_hotel = self.env['ir.default'].sudo().get('res.config.settings', 'tz_hotel') res_partner_obj = self.env['res.partner'] channel_reserv_obj = self.env['channel.hotel.reservation'] hotel_reserv_obj = self.env['hotel.reservation'] hotel_folio_obj = self.env['hotel.folio'] channel_room_type_obj = self.env['channel.hotel.room.type'] hotel_room_type_obj = self.env['hotel.room.type'] # Space for store some data for construct folios processed_rids = [] failed_reservations = [] checkin_utc_dt = False checkout_utc_dt = False split_booking = False for book in bookings: # This create a new folio splitted_map = {} is_cancellation = book['status'] in WUBOOK_STATUS_BAD bstatus = str(book['status']) rcode = str(book['reservation_code']) crcode = str(book['channel_reservation_code']) \ if book['channel_reservation_code'] else 'undefined' # Can't process failed reservations # (for example set a invalid new reservation and receive in # the same transaction an cancellation) if crcode in failed_reservations: self.create_issue( 'reservation', "Can't process a reservation that previusly failed!", '', channel_object_id=book['reservation_code']) continue # Get dates for the reservation (GMT->UTC) arr_hour = default_arrival_hour if book['arrival_hour'] == "--" \ else book['arrival_hour'] checkin = "%s %s" % (book['date_arrival'], arr_hour) checkin_dt = date_utils.get_datetime( checkin, dtformat=DEFAULT_WUBOOK_DATETIME_FORMAT, stz=tz_hotel) checkin_utc_dt = date_utils.dt_as_timezone(checkin_dt, 'UTC') checkin = checkin_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT) checkout = "%s %s" % (book['date_departure'], default_departure_hour) checkout_dt = date_utils.get_datetime( checkout, dtformat=DEFAULT_WUBOOK_DATETIME_FORMAT, stz=tz_hotel) checkout_utc_dt = date_utils.dt_as_timezone(checkout_dt, 'UTC') checkout = checkout_utc_dt.strftime(DEFAULT_SERVER_DATETIME_FORMAT) # Search Folio. If exists. folio_id = False if crcode != 'undefined': reserv_folio = channel_reserv_obj.search( [('ota_reservation_id', '=', crcode)], limit=1) if reserv_folio: folio_id = reserv_folio.odoo_id.folio_id else: reserv_folio = channel_reserv_obj.search( [('channel_reservation_id', '=', rcode)], limit=1) if reserv_folio: folio_id = reserv_folio.odoo_id.folio_id # Need update reservations? sreservs = channel_reserv_obj.search([('channel_reservation_id', '=', rcode)]) reservs = folio_id.room_lines if folio_id else sreservs.mapped( lambda x: x.odoo_id) reservs_processed = False if any(reservs): folio_id = reservs[0].folio_id for reserv in reservs: if reserv.channel_reservation_id == rcode: binding_id = reserv.channel_bind_ids[0] binding_id.write({ 'channel_raw_data': json.dumps(book), 'wstatus': str(book['status']), 'wstatus_reason': book.get('status_reason', ''), }) reserv.with_context({ 'wubook_action': False }).write({ 'to_read': True, 'to_assign': True, 'price_unit': book['amount'], 'customer_notes': book['customer_notes'], }) if reserv.partner_id.unconfirmed: reserv.partner_id.write( self._generate_partner_vals(book)) reservs_processed = True if is_cancellation: reserv.with_context({ 'wubook_action': False }).action_cancel() elif reserv.state == 'cancelled': reserv.with_context({ 'wubook_action': False, }).write({ 'discount': 0.0, 'state': 'confirm', }) # Do Nothing if already processed 'wrid' if reservs_processed: processed_rids.append(rcode) continue # Search Customer customer_mail = book.get('customer_mail', False) partner_id = False if customer_mail: partner_id = res_partner_obj.search( [('email', '=', customer_mail)], limit=1) if not partner_id: partner_id = res_partner_obj.create( self._generate_partner_vals(book)) # Search Wubook Channel Info channel_info = self.env['hotel.channel.connector.ota.info'].search( [('ota_id', '=', str(book['id_channel']))], limit=1) reservations = [] used_rooms = [] # Iterate booked rooms for broom in book['booked_rooms']: room_type = channel_room_type_obj.search( [('channel_room_id', '=', broom['room_id'])], limit=1) if not room_type: self.create_issue( 'reservation', "Can't found any room type associated to '%s' \ in this hotel" % book['rooms'], '', channel_object_id=book['reservation_code']) failed_reservations.append(crcode) continue dates_checkin = [checkin_utc_dt, False] dates_checkout = [checkout_utc_dt, False] split_booking = False split_booking_parent = False # This perhaps create splitted reservation while dates_checkin[0]: checkin_str = dates_checkin[0].strftime( DEFAULT_SERVER_DATETIME_FORMAT) checkout_str = dates_checkout[0].strftime( DEFAULT_SERVER_DATETIME_FORMAT) vals = self._generate_booking_vals( broom, checkin_str, checkout_str, is_cancellation, channel_info, bstatus, crcode, rcode, room_type.odoo_id, split_booking, dates_checkin, dates_checkout, book, ) if vals['price_unit'] != book['amount']: self.create_issue( 'reservation', "Invalid reservation total price! %.2f != %.2f" % (vals['price_unit'], book['amount']), '', channel_object_id=book['reservation_code']) free_rooms = room_type.odoo_id.check_availability_room( checkin_str, checkout_str, room_type_id=room_type.odoo_id.id, notthis=used_rooms) if any(free_rooms): vals.update({ 'product_id': free_rooms[0].product_id.id, 'name': free_rooms[0].name, }) reservations.append((0, False, vals)) used_rooms.append(free_rooms[0].id) if split_booking: if not split_booking_parent: split_booking_parent = len(reservations) else: splitted_map.setdefault( split_booking_parent, []).append(len(reservations)) dates_checkin = [dates_checkin[1], False] dates_checkout = [dates_checkout[1], False] else: date_diff = ( dates_checkout[0].replace( hour=0, minute=0, second=0, microsecond=0) - dates_checkin[0].replace( hour=0, minute=0, second=0, microsecond=0)).days if date_diff <= 0: if split_booking: if split_booking_parent: del reservations[split_booking_parent - 1:] if split_booking_parent in splitted_map: del splitted_map[split_booking_parent] # Can't found space for reservation vals = self._generate_booking_vals( broom, checkin_utc_dt, checkout_utc_dt, is_cancellation, channel_info, bstatus, crcode, rcode, room_type.odoo_id, False, (checkin_utc_dt, False), (checkout_utc_dt, False), book, ) vals.update({ 'product_id': room_type.odoo_id.room_ids[0].product_id.id, 'name': room_type.odoo_id.name, 'overbooking': True, }) reservations.append((0, False, vals)) self.create_issue( 'reservation', "Reservation imported with overbooking state", '', channel_object_id=rcode) dates_checkin = [False, False] dates_checkout = [False, False] split_booking = False else: split_booking = True dates_checkin = [ dates_checkin[0], dates_checkin[0] + timedelta(days=date_diff - 1) ] dates_checkout = [ dates_checkout[0] - timedelta(days=1), checkout_utc_dt ] if split_booking: self.create_issue('reservation', "Reservation Splitted", '', channel_object_id=rcode) # Create Folio if not any(failed_reservations) and any(reservations): try: # TODO: Improve 'addons_list' & discounts addons = str(book['addons_list']) if any( book['addons_list']) else '' discounts = book.get('discount', '') vals = { 'room_lines': reservations, 'wcustomer_notes': "%s\nADDONS:\n%s\nDISCOUNT:\n%s" % (book['customer_notes'], addons, discounts), 'channel_type': 'web', } _logger.info("=== FOLIO CREATE") _logger.info(reservations) if folio_id: folio_id.with_context({ 'wubook_action': False }).write(vals) else: vals.update({ 'partner_id': partner_id.id, 'wseed': book['sessionSeed'] }) folio_id = hotel_folio_obj.with_context({ 'wubook_action': False }).create(vals) # Update Reservation Spitted Parents sorted_rlines = folio_id.room_lines.sorted(key='id') for k_pid, v_pid in splitted_map.iteritems(): preserv = sorted_rlines[k_pid - 1] for pid in v_pid: creserv = sorted_rlines[pid - 1] creserv.parent_reservation = preserv.id processed_rids.append(rcode) except ChannelConnectorError as err: self.create_issue('reservation', err.data['message'], '', channel_object_id=rcode) failed_reservations.append(crcode) return (processed_rids, any(failed_reservations), checkin_utc_dt, checkout_utc_dt)
def test_invalid_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 # 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': [3], 'dayprices': [15.0, 15.0] } } )] processed_rids, errors, checkin_utc_dt, checkout_utc_dt = \ self.env['wubook'].sudo().generate_reservations(wbooks) self.assertTrue(errors, "Invalid reservation created") self.assertFalse(any(processed_rids), "Invalid reservation created") # No Real Rooms Avail 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, 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, "Invalid reservation created") self.assertTrue(any(processed_rids), "Invalid reservation created") nreservs = self.env['hotel.reservation'].search([ ('wrid', 'in', processed_rids) ], order='id ASC') self.assertEqual(nreservs[0].state, 'draft', "Overbooking don't handled") self.assertTrue(nreservs[1].overbooking, "Overbooking don't handled") # No Real Rooms Avail 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=1)).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=1)).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, "Invalid Reservation created") self.assertFalse(errors, "Invalid Reservation created") nreservs = self.env['hotel.reservation'].search([ ('wrid', 'in', processed_rids) ], order='id ASC') for nreserv in nreservs: self.assertTrue(nreserv.overbooking, "Overbooking don't handled")