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 execute_simple(self): wubookObj = self.env['wubook'] irValuesObj = self.env['ir.values'] for rec in self: irValuesObj.sudo().set_default('hotel.config.settings', 'parity_pricelist_id', rec.parity_pricelist_id.id) irValuesObj.sudo().set_default('hotel.config.settings', 'parity_restrictions_id', rec.parity_restrictions_id.id) import_data = rec.import_data if rec.import_data: date_start_dt = date_utils.get_datetime(rec.date_start) date_end_dt = date_utils.get_datetime(rec.date_end) # Availability wresAvail = wubookObj.fetch_rooms_values( date_start_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), date_end_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT)) # Pricelist wresPrices = wubookObj.fetch_plan_prices( rec.parity_pricelist_id.wpid, date_start_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), date_end_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT)) # Restrictions wresRestr = wubookObj.fetch_rplan_restrictions( date_start_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), date_end_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), rec.parity_restrictions_id.wpid) if not wresAvail or not wresPrices or not wresRestr: raise ValidationError(_("Errors importing data from WuBook")) # Reservations wubookObj.fetch_new_bookings()
def _can_confirm(self): for vroom in self: date_start = date_utils.get_datetime(vroom.checkin) date_end = date_utils.get_datetime(vroom.checkout) date_diff = date_utils.date_diff(date_start, date_end, hours=False) if vroom.max_rooms > 0 and vroom.min_stay <= date_diff: vroom.can_confirm = True else: vroom.can_confirm = False
def _check_date_start_date_end(self): if self.applied_on == '1_global': self.date_start = False self.date_end = False elif self.date_start and self.date_end: date_start_dt = date_utils.get_datetime(self.date_start) date_end_dt = date_utils.get_datetime(self.date_end) if date_end_dt < date_start_dt: raise ValidationError(_("Invalid Dates"))
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 _generate_pricelist_items(self, channel_plan_id, date_from, date_to, plan_prices): hotel_room_type_obj = self.env['hotel.room.type'] pricelist = self.env['product.pricelist'].search( [('wpid', '=', channel_plan_id)], limit=1) if pricelist: pricelist_item_obj = self.env['product.pricelist.item'] dfrom_dt = date_utils.get_datetime(date_from) dto_dt = date_utils.get_datetime(date_to) days_diff = date_utils.date_diff(dfrom_dt, dto_dt, hours=False) + 1 for i in range(0, days_diff): ndate_dt = dfrom_dt + timedelta(days=i) for k_rid, v_rid in plan_prices.iteritems(): room_type = hotel_room_type_obj.search( [('wrid', '=', k_rid)], limit=1) if room_type: pricelist_item = pricelist_item_obj.search( [('pricelist_id', '=', pricelist.id), ('date_start', '=', ndate_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)), ('date_end', '=', ndate_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)), ('compute_price', '=', 'fixed'), ('applied_on', '=', '1_product'), ('product_tmpl_id', '=', room_type.product_id.product_tmpl_id.id)], limit=1) vals = { 'fixed_price': plan_prices[k_rid][i], 'wpushed': True, } if pricelist_item: pricelist_item.with_context({ 'wubook_action': False }).write(vals) else: vals.update({ 'pricelist_id': pricelist.id, 'date_start': ndate_dt.strftime(DEFAULT_SERVER_DATE_FORMAT), 'date_end': ndate_dt.strftime(DEFAULT_SERVER_DATE_FORMAT), 'compute_price': 'fixed', 'applied_on': '1_product', 'product_tmpl_id': room_type.product_id.product_tmpl_id.id }) pricelist_item_obj.with_context({ 'wubook_action': False }).create(vals) return True
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 fetch_rooms_values(self, date_from, date_to, rooms=False): rcode, results = self._server.fetch_rooms_values( self._session_info[0], self._session_info[1], date_utils.get_datetime(date_from).strftime( DEFAULT_WUBOOK_DATE_FORMAT), date_utils.get_datetime(date_to).strftime( DEFAULT_WUBOOK_DATE_FORMAT), rooms) if rcode != 0: raise ChannelConnectorError("Can't fetch rooms values from WuBook", { 'message': results, }) return results
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 import_plan_prices(self): pricelist_id = self.env['product.pricelist'].browse( self.env.context.get('active_id')) if pricelist_id: for record in self: date_start_dt = date_utils.get_datetime(record.date_start) date_end_dt = date_utils.get_datetime(record.date_end) wres = self.env['wubook'].fetch_plan_prices( pricelist_id.wpid, date_start_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), date_end_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT)) if not wres: raise ValidationError(_("Can't fetch plan prices \ from WuBook")) return True
def _generate_room_values(self, dfrom, dto, values, set_max_avail=False): channel_room_type_restr_obj = self.env[ 'channel.hotel.room.type.restriction'] channel_hotel_room_type_obj = self.env['channel.hotel.room.type'] def_restr_plan = channel_room_type_restr_obj.search([ ('channel_plan_id', '=', '0') ]) _logger.info("==== ROOM VALUES (%s -- %s)", dfrom, dto) _logger.info(values) for k_rid, v_rid in values.iteritems(): room_type = channel_hotel_room_type_obj.search( [('channel_plan_id', '=', k_rid)], limit=1) if room_type: date_dt = date_utils.get_datetime( dfrom, dtformat=DEFAULT_WUBOOK_DATE_FORMAT) for day_vals in v_rid: date_str = date_dt.strftime(DEFAULT_SERVER_DATE_FORMAT) day_vals.update({ 'room_type_id': room_type.odoo_id.id, 'date': date_str, }) self._map_room_values_availability(day_vals, set_max_avail) if def_restr_plan: day_vals.update( {'restriction_plan_id': def_restr_plan.odoo_id.id}) self._map_room_values_restrictions(day_vals) date_dt = date_dt + timedelta(days=1) return True
def _hcalendar_get_count_reservations_json_data(self, dfrom, dto): vrooms = self.env['hotel.virtual.room'].search([]) date_start = date_utils.get_datetime(dfrom, hours=False) date_diff = date_utils.date_diff(dfrom, dto, hours=False) + 1 hotel_vroom_obj = self.env['hotel.virtual.room'] vrooms = hotel_vroom_obj.search([]) json_data = {} for vroom in vrooms: for i in range(0, date_diff): cur_date = date_start + timedelta(days=i) cur_date_str = cur_date.strftime(DEFAULT_SERVER_DATE_FORMAT) json_data.setdefault(vroom.id, []).append({ 'date': cur_date_str, 'num': len( hotel_vroom_obj.check_availability_virtual_room( cur_date_str, cur_date_str, virtual_room_id=vroom.id)), }) return json_data
def _hcalendar_availability_json_data(self, dfrom, dto): date_start = date_utils.get_datetime(dfrom, hours=False) date_diff = date_utils.date_diff(dfrom, dto, hours=False) + 1 vrooms = self.env['hotel.virtual.room'].search([]) json_data = {} for vroom in vrooms: json_data[vroom.id] = [] for i in range(0, date_diff): cur_date = date_start + timedelta(days=i) cur_date_str = cur_date.strftime(DEFAULT_SERVER_DATE_FORMAT) avail = self.env['hotel.virtual.room.availability'].search([ ('date', '=', cur_date_str), ('virtual_room_id', '=', vroom.id) ]) if avail: json_data[vroom.id].append({ 'id': avail.id, 'date': avail.date, 'avail': avail.avail, 'no_ota': avail.no_ota, }) else: json_data[vroom.id].append({ 'id': False, 'date': cur_date_str, 'avail': vroom.max_real_rooms, 'no_ota': False, }) return json_data
def _hcalendar_events_json_data(self, dfrom, dto): date_start = date_utils.get_datetime(dfrom, hours=False) - timedelta(days=1) date_start_str = date_start.strftime(DEFAULT_SERVER_DATETIME_FORMAT) user_id = self.env['res.users'].browse(self.env.uid) domain = [] if user_id.pms_allowed_events_tags: domain.append(('categ_ids', 'in', user_id.pms_allowed_events_tags)) if user_id.pms_denied_events_tags: domain.append( ('categ_ids', 'not in', user_id.pms_denied_events_tags)) events_raw = self.env['calendar.event'].search(domain) events_ll = self.env['calendar.event'].search([('start', '<=', dto), ('stop', '>=', date_start_str)]) events_lr = self.env['calendar.event'].search([('start', '>=', date_start_str), ('stop', '<=', dto)]) events = (events_ll | events_lr) & events_raw json_data = [] for event in events: json_data.append([ event.id, event.name, event.start, event.location, ]) return json_data
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 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 _compute_max(self): for res in self: user = self.env['res.users'].browse(self.env.uid) date_start = date_utils.get_datetime(res.checkin) date_end = date_utils.get_datetime(res.checkout) date_diff = date_utils.date_diff(date_start, date_end, hours=False) minstay_restrictions = self.env[ 'hotel.virtual.room.restriction.item'].search([ ('virtual_room_id', '=', res.virtual_room_id.id), ]) avail_restrictions = self.env[ 'hotel.virtual.room.availability'].search([ ('virtual_room_id', '=', res.virtual_room_id.id) ]) real_max = len( res.virtual_room_id.check_availability_virtual_room( res.checkin, res.checkout, res.virtual_room_id.id)) res.real_avail = real_max avail = 100000 min_stay = 0 dates = [] for i in range(0, date_diff): ndate_dt = date_start + timedelta(days=i) ndate_str = ndate_dt.strftime(DEFAULT_SERVER_DATE_FORMAT) dates.append(ndate_str) if minstay_restrictions: date_min_days = minstay_restrictions.filtered( lambda r: r.date_start <= ndate_str and \ r.date_end >= ndate_str).min_stay if date_min_days > min_stay: min_stay = date_min_days if user.has_group('hotel.group_hotel_call'): if avail_restrictions: max_avail = avail_restrictions.filtered( lambda r: r.date == ndate_str).wmax_avail if max_avail < avail: avail = min(max_avail, real_max) else: avail = real_max if avail < 100000 and avail > 0: res.max_rooms = avail else: res.max_rooms = 0 if min_stay > 0: res.min_stay = min_stay
def _generate_booking_vals(self, broom, checkin_str, checkout_str, is_cancellation, channel_info, wstatus, crcode, rcode, room_type, split_booking, dates_checkin, dates_checkout, book): # Generate Reservation Day Lines reservation_line_ids = [] tprice = 0.0 for brday in broom['roomdays']: wndate = date_utils.get_datetime( brday['day'], dtformat=DEFAULT_WUBOOK_DATE_FORMAT).replace(tzinfo=pytz.utc) if date_utils.date_in(wndate, dates_checkin[0], dates_checkout[0] - timedelta(days=1), hours=False) == 0: reservation_line_ids.append((0, False, { 'date': wndate.strftime(DEFAULT_SERVER_DATE_FORMAT), 'price': brday['price'] })) tprice += brday['price'] persons = room_type.wcapacity if 'ancillary' in broom and 'guests' in broom['ancillary']: persons = broom['ancillary']['guests'] vals = { 'channel_reservation_id': rcode, 'ota_id': channel_info and channel_info.id, 'ota_reservation_id': crcode, 'channel_raw_data': json.dumps(book), 'wstatus': wstatus, 'wmodified': book['was_modified'], 'odoo_id': [ 0, False, { 'checkin': checkin_str, 'checkout': checkout_str, 'adults': persons, 'children': book['children'], 'reservation_line_ids': reservation_line_ids, 'price_unit': tprice, 'to_assign': True, 'to_read': True, 'state': is_cancellation and 'cancelled' or 'draft', 'room_type_id': room_type.id, 'splitted': split_booking, } ], } _logger.info("===== CONTRUCT RESERV") _logger.info(vals) return vals
def check_change_dates(self): if self.exit_date <= self.enter_date: date_1 = date_utils.get_datetime(self.enter_date) date_2 = date_1 + datetime.timedelta(days=1) self.update({ 'exit_date': date_2, }) raise ValidationError( _('Departure date, is prior to arrival. Check it now. %s') % (date_2))
def create_reservation(self, channel_room_id, customer_name, email, city, phone, address, country_code, checkin, checkout, adults, children, notes=''): customer_name = _partner_split_name(customer_name) customer = { 'lname': customer_name[0], 'fname': customer_name[1], 'email': email, 'city': city, 'phone': phone, 'street': address, 'country': country_code, 'arrival_hour': date_utils.get_datetime(checkin).strftime("%H:%M"), 'notes': notes } rcode, results = self._server.new_reservation( self._session_info[0], self._session_info[1], date_utils.get_datetime(checkin).strftime( DEFAULT_WUBOOK_DATE_FORMAT), date_utils.get_datetime(checkout).strftime( DEFAULT_WUBOOK_DATE_FORMAT), {channel_room_id: [adults + children, 'nb']}, customer, adults + children) if rcode != 0: raise ChannelConnectorError("Can't create reservations in wubook", { 'message': results, 'date_from': checkin, 'date_to': checkout, }) return results
def import_plan_restrictions(self): restriction_id = self.env['hotel.room.type.restriction'].browse( self.env.context.get('active_id')) if restriction_id: for record in self: date_start_dt = date_utils.get_datetime(record.date_start) date_end_dt = date_utils.get_datetime(record.date_end) if int(restriction_id.wpid) == 0: wres = self.env['wubook'].fetch_rooms_values( date_start_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), date_end_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT)) else: wres = self.env['wubook'].fetch_rplan_restrictions( date_start_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), date_end_dt.strftime(DEFAULT_WUBOOK_DATE_FORMAT), restriction_id.wpid) if not wres: raise ValidationError( _("Can't fetch restrictions \ from WuBook")) return True
def update_plan_prices(self, channel_plan_id, date_from, prices): rcode, results = self._server.update_plan_prices( self._session_info[0], self._session_info[1], channel_plan_id, date_utils.get_datetime(date_from).strftime( DEFAULT_WUBOOK_DATE_FORMAT), prices) if rcode != 0: raise ChannelConnectorError( "Can't update pricing plan in wubook", { 'message': results, 'channel_plan_id': channel_plan_id, 'date_from': date_from, }) return results
def onchange_product_id(self): for line in self: if line.checkin and line.checkout: room = self.env['hotel.room'].search([('product_id.id', '=', line.product_id.id)]) if line.adults == 0: line.adults = room.capacity line.virtual_room_id = room.price_virtual_room.id checkout_dt = date_utils.get_datetime(line.checkout) checkout_dt -= timedelta(days=1) occupied = self.env['hotel.reservation'].occupied( line.checkin, checkout_dt.strftime(DEFAULT_SERVER_DATE_FORMAT)) rooms_occupied = occupied.mapped('product_id.id') if line.product_id.id in rooms_occupied: raise ValidationError( _("This room is occupied!, please, choice other room or change the reservation date" ))
def get_hcalendar_restrictions_data(self, dfrom, dto): restriction_id = self.env['ir.values'].sudo().get_default( 'hotel.config.settings', 'parity_restrictions_id') if restriction_id: restriction_id = int(restriction_id) date_start = date_utils.get_datetime(dfrom, hours=False) \ - timedelta(days=1) date_diff = date_utils.date_diff(dfrom, dto, hours=False) + 1 # Get Prices json_rooms_rests = {} vrooms = self.env['hotel.virtual.room'].search( [], order='hcal_sequence ASC') vroom_rest_obj = self.env['hotel.virtual.room.restriction.item'] for vroom in vrooms: days = {} for i in range(0, date_diff): ndate = date_start + timedelta(days=i) ndate_str = ndate.strftime(DEFAULT_SERVER_DATE_FORMAT) rest_id = vroom_rest_obj.search([ ('virtual_room_id', '=', vroom.id), ('date_start', '>=', ndate_str), ('date_end', '<=', ndate_str), ('applied_on', '=', '0_virtual_room'), ('restriction_id', '=', restriction_id) ], limit=1) if rest_id and (rest_id.min_stay or rest_id.min_stay_arrival or rest_id.max_stay or rest_id.max_stay_arrival or rest_id.closed or rest_id.closed_arrival or rest_id.closed_departure): days.update({ ndate.strftime("%d/%m/%Y"): ( rest_id.min_stay, rest_id.min_stay_arrival, rest_id.max_stay, rest_id.max_stay_arrival, rest_id.closed, rest_id.closed_arrival, rest_id.closed_departure) }) json_rooms_rests.update({vroom.id: days}) return json_rooms_rests
def get_hcalendar_reservations_data(self, dfrom, dto, rooms): date_start = date_utils.get_datetime(dfrom, hours=False) \ - timedelta(days=1) date_start_str = date_start.strftime(DEFAULT_SERVER_DATETIME_FORMAT) room_product_ids = rooms.mapped('product_id.id') reservations_raw = self.env['hotel.reservation'].search( [ ('product_id', 'in', room_product_ids), ('state', 'in', ['draft', 'confirm', 'booking', 'done', False ]), ], order="checkin DESC, checkout ASC, adults DESC, children DESC") reservations_ll = self.env['hotel.reservation'].search([ ('checkin', '<=', dto), ('checkout', '>=', date_start_str) ]) reservations_lr = self.env['hotel.reservation'].search([ ('checkin', '>=', date_start_str), ('checkout', '<=', dto) ]) reservations = (reservations_ll | reservations_lr) & reservations_raw return self._hcalendar_reservation_data(reservations)
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 _generate_room_values(self, dfrom, dto, values, set_max_avail=False): room_type_restr_obj = self.env['hotel.room.type.restriction'] hotel_room_type_obj = self.env['hotel.room.type'] def_restr_plan = room_type_restr_obj.search([('wpid', '=', '0')]) _logger.info("==== ROOM VALUES (%s -- %s)", dfrom, dto) _logger.info(values) for k_rid, v_rid in values.iteritems(): room_type = hotel_room_type_obj.search([('wrid', '=', k_rid)], limit=1) if room_type: date_dt = date_utils.get_datetime( dfrom, dtformat=DEFAULT_WUBOOK_DATE_FORMAT) for day_vals in v_rid: date_str = date_dt.strftime(DEFAULT_SERVER_DATE_FORMAT) self._get_room_values_availability(room_type.id, date_str, day_vals, set_max_avail) if def_restr_plan: self._get_room_values_restrictions( def_restr_plan.id, room_type.id, date_str, day_vals) date_dt = date_dt + timedelta(days=1) return True
def refresh_availability(self, checkin, checkout, product_id): date_start = date_utils.get_datetime(checkin) # Not count end day of the reservation date_diff = date_utils.date_diff(checkin, checkout, hours=False) vroom_obj = self.env['hotel.virtual.room'] virtual_room_avail_obj = self.env['hotel.virtual.room.availability'] vrooms = vroom_obj.search([('room_ids.product_id', '=', product_id)]) for vroom in vrooms: if vroom.wrid and vroom.wrid != '': for i in range(0, date_diff): ndate_dt = date_start + timedelta(days=i) ndate_str = ndate_dt.strftime(DEFAULT_SERVER_DATE_FORMAT) avail = len( vroom_obj.check_availability_virtual_room( ndate_str, ndate_str, virtual_room_id=vroom.id)) max_avail = vroom.max_real_rooms vroom_avail_id = virtual_room_avail_obj.search( [('virtual_room_id', '=', vroom.id), ('date', '=', ndate_str)], limit=1) if vroom_avail_id and vroom_avail_id.wmax_avail >= 0: max_avail = vroom_avail_id.wmax_avail avail = max(min(avail, vroom.total_rooms_count, max_avail), 0) if vroom_avail_id: vroom_avail_id.write({'avail': avail}) else: virtual_room_avail_obj.create({ 'virtual_room_id': vroom.id, 'date': ndate_str, 'avail': avail, })
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
def get_hcalendar_pricelist_data(self, dfrom, dto): pricelist_id = self.env['ir.values'].sudo().get_default( 'hotel.config.settings', 'parity_pricelist_id') if pricelist_id: pricelist_id = int(pricelist_id) date_start = date_utils.get_datetime(dfrom, hours=False) \ - timedelta(days=1) date_diff = date_utils.date_diff(date_start, dto, hours=False) + 1 # Get Prices json_rooms_prices = {pricelist_id: []} vrooms = self.env['hotel.virtual.room'].search( [], order='hcal_sequence ASC') vroom_pr_cached_obj = self.env['virtual.room.pricelist.cached'] for vroom in vrooms: days = {} for i in range(0, date_diff): ndate = date_start + timedelta(days=i) ndate_str = ndate.strftime(DEFAULT_SERVER_DATE_FORMAT) prod_price_id = vroom_pr_cached_obj.search([ ('virtual_room_id', '=', vroom.id), ('date', '=', ndate_str) ], limit=1) days.update({ ndate.strftime("%d/%m/%Y"): prod_price_id and prod_price_id.price or vroom.product_id.with_context( quantity=1, date=ndate_str, pricelist=pricelist_id).price }) json_rooms_prices[pricelist_id].append({ 'room': vroom.id, 'days': days, 'title': vroom.name, }) return json_rooms_prices