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
