def get(self):
self.response.headers['Content-Type'] = 'application/rss+xml'
query = self.request.get('q', '').lower()
limit = 200 # int(self.request.get('limit', -1))
grouped_by = self.request.get('grouped_by', '').lower()
min_date = None
try:
min_date_str = self.request.get('min_date')
if min_date_str:
min_date = helper.str_to_date(min_date_str, default_day=1)
except:
pass
max_date = None
try:
max_date_str = self.request.get('max_date')
if max_date_str:
max_date = helper.str_to_date(max_date_str, default_day=1) + relativedelta(hours=+20)
if len(max_date_str) <= 7:
max_date += relativedelta(months=1)
except:
pass
randomize = self.request.get('random') == 'true'
filtered_segments = SegmentSearch.segments(query, limit, grouped_by, min_date, max_date, randomize, True)
params = {'query': query, 'segments': filtered_segments, 'feed_url': self.request.url}
template_values = helper.init_template_values(params)
self.response.out.write(template.render(helper.get_template_path("podcast", "xml"),
template_values))
def proc_month(d):
if expanded[3][0] != '*':
diff_month = nearest_diff_method(d.month, expanded[3],
self.MONTHS_IN_YEAR)
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
reset_day = 1
if diff_month != None and diff_month != 0:
if is_prev:
d += relativedelta(months=diff_month)
reset_day = DAYS[d.month - 1]
d += relativedelta(day=reset_day,
hour=23,
minute=59,
second=59)
else:
d += relativedelta(months=diff_month,
day=reset_day,
hour=0,
minute=0,
second=0)
return True, d
return False, d
def proc_day_of_month(d):
if expanded[2][0] != '*':
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
if is_prev:
days_in_prev_month = DAYS[(month - 2) %
self.MONTHS_IN_YEAR]
diff_day = nearest_diff_method(d.day, expanded[2],
days_in_prev_month)
else:
diff_day = nearest_diff_method(d.day, expanded[2], days)
if diff_day != None and diff_day != 0:
if is_prev:
d += relativedelta(days=diff_day,
hour=23,
minute=59,
second=59)
else:
d += relativedelta(days=diff_day,
hour=0,
minute=0,
second=0)
return True, d
return False, d
def get(self, year=None, month=None):
year = helper.parse_int(year)
month = helper.parse_int(month)
if year and month:
try:
segment_month = datetime.date(year, month, 1)
except:
segment_month = None
if segment_month:
prev_month = segment_month - relativedelta(months=1)
next_month = segment_month + relativedelta(months=1)
params = {'segment_month': segment_month, \
'weekdays': WEEKDAYS, \
'prev_month': prev_month, 'next_month': next_month}
template_values = helper.init_template_values(params)
month_cal = make_month_calendar(segment_month)
if month_cal:
template_values.update(month_cal)
self.response.out.write(template.render(helper.get_template_path("segments_month"),
template_values))
else:
self.error(404)
else:
self.error(404)
def get(self):
self.response.headers['Content-Type'] = 'text/plain'
# months_delta = int(self.request.get('months', 1))
try:
hotel_id = int(self.request.get('hotel_id'))
except:
hotel_id = None
hotels = StarwoodProperty.all()
if hotel_id:
hotel = hotels.filter('id =', hotel_id).get()
else:
hotel = hotels.order('last_checked').get()
if not hotel:
self.response.out.write("Did not get a hotel.\n")
else:
logging.info("Getting availability for %s.\n" % hotel)
self.response.out.write("Got hotel %s [%s].\n" % (hotel.name, hotel.id))
added_task_count = 0
ratecodes = ['SPG%d' % (hotel.category)]
if hotel.category < 7:
ratecodes.append('SPGCP')
for ratecode in ratecodes:
start_date = datetime.date.today()
end_date = start_date + relativedelta(months=MONTHS_DELTA)
while start_date < end_date:
task = taskqueue.Task(url='/tasks/availability/fetch', \
name=TASK_NAME_FETCH_AVAILABILITY \
% (hotel.id, ratecode, start_date.year, \
start_date.month, MONTHS_DELTA, int(time.time())), \
method='GET', \
params={'hotel_id': hotel.id, 'ratecode': ratecode, \
'date': DATE_FORMAT % (start_date.year, start_date.month), \
'months_delta': MONTHS_DELTA})
try:
task.add(TASK_QUEUE_FETCH_AVAILABILITY)
self.response.out.write("Added task '%s' to task queue '%s'.\n" \
% (task.name, TASK_QUEUE_FETCH_AVAILABILITY))
added_task_count += 1
except TaskAlreadyExistsError:
self.response.out.write("Task '%s' already exists in task queue '%s'.\n" \
% (task.name, TASK_QUEUE_FETCH_AVAILABILITY))
except TombstonedTaskError:
self.response.out.write("Task '%s' is tombstoned in task queue '%s'.\n" \
% (task.name, TASK_QUEUE_FETCH_AVAILABILITY))
start_date += relativedelta(months=MONTHS_DELTA)
hotel.last_checked = datetime.datetime.now()
hotel.put()
def get(self):
self.response.headers['Content-Type'] = 'text/plain'
try:
hotel_id = int(self.request.get('hotel_id', default_value=''))
except:
hotel_id = None
#year_month = self.request.get('date', default_value='')
start_date = helper.str_to_date(self.request.get('date'))
months_delta = int(self.request.get('months_delta', default_value=1))
end_date = start_date + relativedelta(months=months_delta)
ratecode = self.request.get('ratecode', default_value='')
availability_data = None
if hotel_id and start_date and ratecode:
try:
availability_data = StarwoodParser.parse_availability( \
hotel_id=hotel_id,
start_date=YEAR_MONTH_FORMAT % (start_date.year, start_date.month),
end_date=YEAR_MONTH_FORMAT % (end_date.year, end_date.month),
ratecode=ratecode) \
.get('availability')
except:
pass
if availability_data:
added_task_count = 0
all_days = []
d = date.today() + relativedelta(days=0)
while d < end_date:
all_days.append(d)
d += relativedelta(days=1)
for year in availability_data:
for month in availability_data[year]:
for day, nights_data in availability_data[year][month].iteritems():
availability_date = date(year=year, month=month, day=day)
if availability_date in all_days:
all_days.remove(availability_date)
success = FetchStarwoodAvailability.enqueue_task( \
hotel_id=hotel_id, ratecode=ratecode,
day=availability_date, nights=nights_data.keys(),
writer=self.response.out.write)
if success:
added_task_count += 1
self.response.out.write("\nAdded %d tasks to the queue.\n" % (added_task_count))
# Delete the entities that don't have availability.
for day in all_days:
FetchStarwoodAvailability.enqueue_task(hotel_id=hotel_id, ratecode=ratecode, \
day=day, method='DELETE',
writer=self.response.out.write)
else:
self.response.out.write("Invalid request.")
def proc_minute(d):
if expanded[0][0] != '*':
diff_min = nearest_diff_method(d.minute, expanded[0], 60)
if diff_min != None and diff_min != 0:
if is_prev:
d += relativedelta(minutes = diff_min, second=59)
else:
d += relativedelta(minutes = diff_min, second=0)
return True, d
return False, d
def proc_hour(d):
if expanded[1][0] != '*':
diff_hour = nearest_diff_method(d.hour, expanded[1], 24)
if diff_hour != None and diff_hour != 0:
if is_prev:
d += relativedelta(hours = diff_hour, minute=59, second=59)
else:
d += relativedelta(hours = diff_hour, minute=0, second=0)
return True, d
return False, d
def proc_minute(d):
if expanded[0][0] != '*':
diff_min = nearest_diff_method(d.minute, expanded[0], 60)
if diff_min != None and diff_min != 0:
if is_prev:
d += relativedelta(minutes=diff_min, second=59)
else:
d += relativedelta(minutes=diff_min, second=0)
return True, d
return False, d
def proc_day_of_week(d):
if expanded[4][0] != '*':
diff_day_of_week = nearest_diff_method(d.isoweekday() % 7, expanded[4], 7)
if diff_day_of_week != None and diff_day_of_week != 0:
if is_prev:
d += relativedelta(days=diff_day_of_week, hour=23, minute=59, second=59)
else:
d += relativedelta(days=diff_day_of_week, hour=0, minute=0, second=0)
return True, d
return False, d
def proc_second(d):
if len(expanded) == 6:
if expanded[5][0] != '*':
diff_sec = nearest_diff_method(d.second, expanded[5], 60)
if diff_sec != None and diff_sec != 0:
dst += relativedelta(seconds = diff_sec)
return True, d
else:
d += relativedelta(second = 0)
return False, d
def proc_second(d):
if len(expanded) == 6:
if expanded[5][0] != '*':
diff_sec = nearest_diff_method(d.second, expanded[5], 60)
if diff_sec != None and diff_sec != 0:
dst += relativedelta(seconds=diff_sec)
return True, d
else:
d += relativedelta(second=0)
return False, d
def proc_hour(d):
if expanded[1][0] != '*':
diff_hour = nearest_diff_method(d.hour, expanded[1], 24)
if diff_hour != None and diff_hour != 0:
if is_prev:
d += relativedelta(hours=diff_hour,
minute=59,
second=59)
else:
d += relativedelta(hours=diff_hour, minute=0, second=0)
return True, d
return False, d
def get(self):
self.response.headers['Content-Type'] = 'text/plain'
queue_name = "setcoderate-lookup"
offset = int(self.request.get('offset', default_value=0))
limit = int(self.request.get('limit', default_value=1000))
try:
hotel_id = int(self.request.get('hotel_id', default_value=1234))
except:
hotel_id = 1234
try:
check_in = helper.str_to_date(self.request.get('check_in'))
except:
check_in = datetime.date.today() + relativedelta(months=1)
nights = int(self.request.get('nights', default_value=1))
check_out = check_in + relativedelta(days=nights)
session_cookie = json.loads(self.request.get('session_cookie'))
self.response.out.write('Creating SET lookup tasks using hotel #%d, from %s to %s...\n' \
% (hotel_id, helper.date_to_str(check_in), \
helper.date_to_str(check_out)))
prefix_len = len('StarwoodSetCode_')
for i, set_code in enumerate([int(key.name()[prefix_len:]) for key in db.Query(StarwoodSetCode, keys_only=True).filter('chainwide_rate =', False).filter('chainwide_discount =', False).order('code').fetch(limit=limit, offset=offset)]):
task_name = "setcoderatelookup-%d-%d-%s-%s-%d" \
% (set_code, hotel_id, \
''.join(helper.date_to_str(check_in).split('-')), \
''.join(helper.date_to_str(check_out).split('-')), \
int(time.time()))
task = taskqueue.Task(url='/tasks/%s' % queue_name, \
name=task_name, method='GET', \
params={'set_code': set_code, \
'hotel_id': hotel_id, \
'check_in': check_in, \
'check_out': check_out, \
'session_cookie': json.dumps(session_cookie)})
d = (offset + i, task.name, queue_name)
try:
task.add(queue_name)
self.response.out.write("%d.\tAdded task '%s' to task queue '%s'.\n" % d)
except TaskAlreadyExistsError:
self.response.out.write("%d.\tTask '%s' already exists in task queue '%s'.\n" % d)
except TombstonedTaskError:
self.response.out.write("%d.\tTask '%s' is tombstoned in task queue '%s'.\n" % d)
def date_iter(from_date=None):
from_date = from_date or date(2010, 4, 1)
to_date = date.today()
while to_date is None or from_date <= to_date:
yield from_date
from_date += relativedelta(months=+1)
return
def get(self):
def valid_setcode(soup):
try:
top_msg_div = soup.find('div', attrs={'id': 'topMsgDiv'})
if top_msg_div.find('span', attrs={'class': 'error'}) and bool(top_msg_div.find('p').contents[0].strip()):
return False
else:
return True
except:
return True
self.response.headers['Content-Type'] = 'text/plain'
try:
set_code = int(self.request.get('set_code', 0))
except:
set_code = None
if StarwoodSetCode.get_by_key_name(StarwoodSetCode.calc_key_name(set_code)):
self.response.out.write("SET code entity already created.")
return
try:
hotel_id = int(self.request.get('hotel_id', 0))
except:
hotel_id = None
name = None
if set_code and hotel_id:
check_in = date.today() + relativedelta(months=1)
check_out = check_in + relativedelta(days=1)
#url = "https://www.starwoodhotels.com/preferredguest/search/ratelist.html?corporateAccountNumber=%d&lengthOfStay=1&roomOccupancyTotal=001&requestedChainCode=SI&requestedAffiliationCode=SI&theBrand=SPG&submitActionID=search&arrivalDate=2010-09-15&departureDate=2010-09-16&propertyID=%d&ciDate=09/15/2010&coDate=09/19/2010&numberOfRooms=01&numberOfAdults=01&roomBedCode=&ratePlanName=&accountInputField=57464&foo=5232"
url = "https://www.starwoodhotels.com/preferredguest/search/ratelist.html?arrivalDate=%s&departureDate=%s&corporateAccountNumber=%d&propertyID=%d" \
% (helper.date_to_str(check_in), helper.date_to_str(check_out), set_code, hotel_id)
try:
response = urlfetch.fetch(url, deadline=10)
except DownloadError, details:
logging.error("DownloadError: %s" % details)
response = None
if response:
soup = BeautifulSoup(response.content)
if valid_setcode(soup):
try:
name = str(soup.find('table', attrs={'id': 'rateListTable'}).find('tbody').find('tr').find('td', attrs={'class': 'rateDescription'}).find('p').contents[0].strip())
except:
name = None
def proc_day_of_week(d):
if expanded[4][0] != '*':
diff_day_of_week = nearest_diff_method(d.isoweekday() % 7,
expanded[4], 7)
if diff_day_of_week != None and diff_day_of_week != 0:
if is_prev:
d += relativedelta(days=diff_day_of_week,
hour=23,
minute=59,
second=59)
else:
d += relativedelta(days=diff_day_of_week,
hour=0,
minute=0,
second=0)
return True, d
return False, d
def get(self):
self.response.headers['Content-Type'] = 'text/plain'
queue_name = "setcoderateblock-lookup"
limit = int(self.request.get('limit', default_value=100))
hotel_id = int(self.request.get('hotel_id', default_value=1234))
try:
check_in = helper.str_to_date(self.request.get('check_in'))
except:
check_in = datetime.date.today() + relativedelta(months=1)
nights = int(self.request.get('nights', default_value=1))
check_out = check_in + relativedelta(days=nights)
session_cookie = helper_starwood.get_session_cookie()
setcode_count = len(db.Query(StarwoodSetCode, keys_only=True).filter('chainwide_rate =', False).filter('chainwide_discount =', False).fetch(10000))
self.response.out.write("StarwoodSetCode count: %d\n\n" % setcode_count)
if True:
for i, offset in enumerate(xrange(0, setcode_count, limit)):
task_name = "setcoderate-block-%d-%s-%s-%d-%d-%d" \
% (hotel_id, \
''.join(helper.date_to_str(check_in).split('-')), \
''.join(helper.date_to_str(check_out).split('-')), \
offset, offset + limit, int(time.time()))
task = taskqueue.Task(url='/tasks/%s' % queue_name, \
name=task_name, method='GET', \
params={'hotel_id': hotel_id, \
'check_in': check_in, \
'check_out': check_out, \
'offset': offset, \
'limit': limit, \
'session_cookie': json.dumps(session_cookie)})
d = (i + 1, task.name, queue_name)
try:
task.add(queue_name)
self.response.out.write("%d.\tAdded task '%s' to task queue '%s'.\n" % d)
except TaskAlreadyExistsError:
self.response.out.write("%d.\tTask '%s' already exists in task queue '%s'.\n" % d)
except TombstonedTaskError:
self.response.out.write("%d.\tTask '%s' is tombstoned in task queue '%s'.\n" % d)
def proc_day_of_month(d):
if expanded[2][0] != '*':
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
if is_prev:
days_in_prev_month = DAYS[(month - 2) % self.MONTHS_IN_YEAR]
diff_day = nearest_diff_method(d.day, expanded[2], days_in_prev_month)
else:
diff_day = nearest_diff_method(d.day, expanded[2], days)
if diff_day != None and diff_day != 0:
if is_prev:
d += relativedelta(days=diff_day, hour=23, minute=59, second=59)
else:
d += relativedelta(days=diff_day, hour=0, minute=0, second=0)
return True, d
return False, d
def proc_month(d):
if expanded[3][0] != '*':
diff_month = nearest_diff_method(d.month, expanded[3], self.MONTHS_IN_YEAR)
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
reset_day = 1
if diff_month != None and diff_month != 0:
if is_prev:
d += relativedelta(months=diff_month)
reset_day = DAYS[d.month - 1]
d += relativedelta(day=reset_day, hour=23, minute=59, second=59)
else:
d += relativedelta(months=diff_month, day=reset_day,
hour=0, minute=0, second=0)
return True, d
return False, d
def get(self, year, month, day):
year = helper.parse_int(year)
month = helper.parse_int(month)
day = helper.parse_int(day)
date = datetime.date(year, month, day)
segments = SegmentSearch.segments(min_date=date, max_date=(date + relativedelta(days=1)), limit=-1)
segments.reverse()
self.response.out.write(template.render(helper.get_template_path("mobile_archive_day"),
{'date': date, 'segments': segments}))
def expand(self, nights_count=0):
rate_data = []
points = cash = 0
for night in xrange(nights_count):
date = self.date + relativedelta(days=night)
if self.ratecode == 'SPGCP':
rate = resources.CATEGORY_AWARD_CHOICES['cash_points'].get(int(self.hotel.category))
elif StarwoodParser.is_spg_points_rate(self.ratecode):
rate = StarwoodParser.mod_spg_points(self.hotel.category, date)
if rate:
rate_data.append({'date': date, 'rate': rate})
points += rate.get('points', 0)
cash += rate.get('cash', 0)
# 5th night free in category 3 and up
if nights_count == 5 and self.hotel.category >= 3 and StarwoodParser.is_spg_points_rate(self.ratecode):
points = int(points * 4 / 5)
return {'check_in': self.date, 'check_out': self.date + relativedelta(days=nights_count), \
'rates': rate_data, 'totals': {'points': points, 'cash': cash}}
def elapsed_human_time(dt1, dt2):
# check - must be datetime
if not isinstance(dt1, datetime.datetime) or not isinstance(dt2, datetime.datetime):
raise TypeError
if dt1 > dt2:
time_rel = relativedelta.relativedelta(dt1, dt2)
else:
time_rel = relativedelta.relativedelta(dt2, dt1)
# go through time
time_machine = "just now"
time_units = ["years", "months", "days", "hours", "minutes", "seconds"]
for idx, unit in enumerate(time_units):
unit_val = getattr(time_rel, unit)
# good enough
if unit_val > 1:
time_machine = "%i %s ago" % (unit_val, unit)
break
# need more info - special cases
elif unit_val == 1 and unit != "seconds":
next_unit = time_units[idx + 1]
next_unit_val = getattr(time_rel, next_unit)
# basically just checking plural time_units (e.g. second(s))
if next_unit_val > 1:
time_machine = "%i %s, %i %s ago" % (unit_val, unit[:-1], next_unit_val, next_unit)
elif next_unit_val == 1:
time_machine = "%i %s, %i %s ago" % (unit_val, unit[:-1], next_unit_val, next_unit[:-1])
else:
time_machine = "%i %s ago" % (unit_val, unit[:-1])
break
return time_machine
def get(self):
self.response.headers['Content-Type'] = 'application/json'
# determine if the request is from iOS/Cocoa Touch
is_ios_request = "CFNetwork" in self.request.headers['User-Agent']
q = self.request.get('q', '').lower()
limit = int(self.request.get('limit', MAX_RESULTS))
grouped_by = self.request.get('grouped_by', '').lower()
min_date = None
try:
min_date_str = self.request.get('min_date')
if min_date_str:
min_date = helper.str_to_date(min_date_str, default_day=1)
except:
pass
max_date = None
try:
max_date_str = self.request.get('max_date')
if max_date_str:
max_date = helper.str_to_date(max_date_str, default_day=1) + relativedelta(hours=+20)
if len(max_date_str) <= 7:
max_date += relativedelta(months=1)
except:
pass
randomize = self.request.get('random') == 'true'
filtered_segments = SegmentSearch.segments(query=q, limit=limit, grouped_by=grouped_by, \
min_date=min_date, max_date=max_date,
randomize=randomize, compact=is_ios_request,
is_ajax=True)
self.response.out.write("%s" % json.dumps({'segments': filtered_segments}))
def get(self):
self.response.headers['Content-Type'] = 'text/plain'
day = date.today() - relativedelta(days=1)
response = fetch_url("http://podcastrss.play.it/the-sports-junkies_mp3_128.xml")
if response and response.status_code == 200:
feed_soup = BeautifulSoup(response.content)
[copyright_el.extract() for copyright_el in feed_soup.findAll("copyright")]
self.response.out.write("%s\n\n\n" % feed_soup.prettify())
DailyFeedSnapshot.create(day, feed_soup.prettify())
msg = "Created a DailyFeedSnapshot for %s." % (day)
self.response.out.write(msg)
logging.info(msg)
else:
msg = "Could not create a DailyFeedSnapshot for %s." % (day)
self.response.out.write(msg)
logging.error(msg)
def do_lookup(self):
def clean_detail(soup):
return str(' '.join(soup.contents[0].replace('\n', ' ').split()).strip())
def parse_rate_details(rate_row):
rate_details = {}
bed_info = clean_detail(rate_row.find('td', attrs={'class': 'bedType'}).find('p'))
rate_details['bed_count'], rate_details['bed_type'] = int(bed_info.split()[0]), ' '.join(bed_info.replace(' Beds', '').split()[1:])
rate_details['description'] = clean_detail(rate_row.find('td', attrs={'class': 'roomFeatures'}).find('p'))
rate_detail_id = int(re.match(r"^getRateDetail\('(\d+)', '(\w+)'\)$", rate_row.find('td', attrs={'class': 'rateDescription'}).find('a')['onclick']).group(1))
rate_cell = rate_row.find('td', attrs={'class': 'averageDailyRatePerRoom'})
rate_details['rate'] = {}
try:
currency, room_rate = clean_detail(rate_cell.find('p')).split()
except:
room_rate = None
if room_rate:
rate_details['rate']['room'] = float(room_rate)
rate_details['rate']['currency'] = currency
try:
rate_details['rate']['total'] = float(clean_detail(rate_cell.find('p', 'roomTotal').find('a')).split()[1])
except:
pass
return rate_details, rate_detail_id
# https://www.starwoodhotels.com/preferredguest/search/ratedetail.html?ctx=ctxRooms&id=26370&ratePlanID=SETAND&workflow=35fdcd50-8400-4522-bbbd-bdf7773a6fa5&propertyID=1030
def more_rate_details(hotel_id, rate_detail_id, workflow_id, session_cookie):
# logging.info("session_cookie: %s" % session_cookie)
# url = "https://www.starwoodhotels.com/preferredguest/search/ratedetail.html?ctx=ctxRooms&id=%d&ratePlanID=%s&workflow=%s&propertyID=%d&searchCode=&sortOrder=&iATANumber=#undefined" \
# % (rate_detail_id, 'SETAND', workflow_id, hotel_id)
# response = urlfetch.fetch(url, deadline=10, headers=session_cookie)
# soup = BeautifulSoup(response.content)
# rate_plan_desc = soup.prettify()
# rate_plan_desc = clean_detail(soup.find('div', text="Rate Plan Description").nextSibling.contents[0])
# logging.info("\n\n\n\n%s\n\n\n\n" % rate_plan_desc)
pass
self.response.headers['Content-Type'] = 'text/plain'
rate_data = {}
try:
set_code = int(self.request.get('set_code', 0))
except:
set_code = None
try:
hotel_id = int(self.request.get('hotel_id', 0))
except:
hotel_id = None
if not (set_code and hotel_id):
rate_data['error'] = "Required set code and hotel id."
else:
try:
check_in = helper.str_to_date(self.request.get('check_in'))
except:
check_in = datetime.date.today() + relativedelta(months=1)
try:
check_out = helper.str_to_date(self.request.get('check_out'))
except:
check_out = check_in + relativedelta(days=1)
try:
session_cookie = json.loads(self.request.get('session_cookie'))
except:
session_cookie = None
if not session_cookie:
session_cookie = helper_starwood.get_session_cookie()
#url = "https://www.starwoodhotels.com/preferredguest/search/ratelist.html?corporateAccountNumber=%d&lengthOfStay=1&roomOccupancyTotal=001&requestedChainCode=SI&requestedAffiliationCode=SI&theBrand=SPG&submitActionID=search&arrivalDate=2010-09-15&departureDate=2010-09-16&propertyID=%d&ciDate=09/15/2010&coDate=09/19/2010&numberOfRooms=01&numberOfAdults=01&roomBedCode=&ratePlanName=&accountInputField=57464&foo=5232"
url = "https://www.starwoodhotels.com/preferredguest/search/ratelist.html?arrivalDate=%s&departureDate=%s&corporateAccountNumber=%d&propertyID=%d" \
% (helper.date_to_str(check_in), helper.date_to_str(check_out), set_code, hotel_id)
try:
response = urlfetch.fetch(url, deadline=10)
except DownloadError, details:
logging.error("DownloadError: %s" % details)
response = None
if response:
soup = BeautifulSoup(response.content)
try:
rate_name = clean_detail(soup.find('table', attrs={'id': 'rateListTable'}).find('tbody').find('tr').find('td', attrs={'class': 'rateDescription'}).find('p'))
except:
rate_name = None
try:
workflow_id = soup.find('form', attrs={'name': 'RateListForm'}).find('input', attrs={'name': 'workflowId'})['value']
except:
workflow_id = None
room_rates_data = []
for lowest_rate in soup.findAll('p', attrs={'class': 'roomRate lowestRateIndicator'}):
room_rate_data, rate_detail_id = parse_rate_details(lowest_rate.parent.parent)
room_rates_data.append(room_rate_data)
more_rate_details(hotel_id, rate_detail_id, workflow_id, session_cookie)
rate_data = {'set_code': set_code, 'hotel_id': hotel_id, \
'check_in': helper.date_to_str(check_in), \
'check_out': helper.date_to_str(check_out), \
'rate_name': rate_name, 'rooms': room_rates_data}
def get(self, year):
year = helper.parse_int(year)
min_date = datetime.date(year, 1, 1)
months_count = defaultdict(int)
for segment in SegmentSearch.segments(min_date=min_date, max_date=(min_date + relativedelta(years=1)), limit=-1):
months_count[segment['date'].month] += 1
months = [(datetime.date(year, month, 1), months_count[month]) for month in xrange(1, 13) if months_count.get(month)]
self.response.out.write(template.render(helper.get_template_path("mobile_archive_year"),
{'year': year, 'months': months}))
def make_month_calendar(segment_month):
segments = SegmentSearch.segments(min_date=segment_month, max_date=(segment_month + relativedelta(months=+1)), limit=-1)
segments.reverse()
active_days = [segment['date'].day for segment in segments]
active_days.reverse()
active_days = frozenset(active_days)
#console.log(segment_month.weekday())
all_days = [None] * (segment_month.weekday() % 5)
weekdays = [day for day in xrange(1, calendar.mdays[segment_month.month] + 1) if datetime.date(segment_month.year, segment_month.month, day).weekday() % 7 < 5]
all_days.extend(list(frozenset(weekdays)))
if len(active_days):
return {'all_days': all_days, 'active_days': active_days}
else:
None
def relative(**kwargs):
return date(relativedelta(**kwargs))
def relative(**kwargs):
return date(relativedelta(**kwargs))
def get(self, year, month, day):
year = helper.parse_int(year)
month = helper.parse_int(month)
day = helper.parse_int(day)
segment_date = datetime.date(year, month, day)
segments = SegmentSearch.segments(min_date=segment_date, max_date=(segment_date + relativedelta(days=+1)))
segments.reverse()
params = {'segments': segments, 'segment_date': segment_date}
template_values = helper.init_template_values(params)
self.response.out.write(template.render(helper.get_template_path("segments_day"),
template_values))
def get(self, year, month):
year = helper.parse_int(year)
month = helper.parse_int(month)
min_date = datetime.date(year, month, 1)
days_count = defaultdict(int)
for segment in SegmentSearch.segments(min_date=min_date, max_date=(min_date + relativedelta(months=1)), limit=-1):
days_count[segment['date'].day] += 1
days = [(datetime.date(year, month, day), days_count[day]) for day in xrange(1, calendar.mdays[month] + 1) if days_count.get(day)]
self.response.out.write(template.render(helper.get_template_path("mobile_archive_month"),
{'year': year, 'month': month, 'days': days}))
