def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
city = self.request.get('city').encode('utf8')
city_id = self.request.get('city_id')
plan_id = self.request.get('plan_id')
params = {
'format': 'json',
'action': 'query',
'prop': 'extracts',
'titles': city,
'redirects': 1,
'exsentences': 4,
'explaintext': 1
}
params = urllib.urlencode(params)
details = json.loads(urllib.urlopen(wikipedia['WIKI_BASE_URL'] % params).read())
if 'query' in details and 'pages' in details['query'] and details['query']['pages']:
page_ids = details['query']['pages'].keys()
page_id = page_ids.pop()
page = None
if page_id:
page = details['query']['pages'][page_id]
summary = None
if page and 'extract' in page:
summary = page['extract']
summary = [i for i in summary.split('.')]
if len(summary) > 1:
summary = summary[1:]
summary = '.'.join(summary)
if summary:
query = ("UPDATE cities SET summary = %s WHERE id = %s")
cursor.execute(query, (summary, city_id))
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(summary))
def start_master_producer(topic, vfile, no_producers, machines, brokers):
signal.signal(signal.SIGINT, signal_handler)
signal.pause()
s = Sync(topic, internal_sync_topic, vfile, no_producers, machines,
brokers)
remote_producers, local_producers = s.synchronize()
print("Total threads starting in master producer are " +
str(int(local_producers)))
producer_list = []
for i in range(0, int(local_producers)):
p = VideoProducer(master_prod_conf, topic, vfile)
p.start()
producer_list.append(p)
for prod_thread in producer_list:
prod_thread.join()
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
photo_id = self.request.get('photo_id')
city_id = self.request.get('city_id')
plan_id = self.request.get('plan_id')
params = {
'api_key': flickr['FLICKR_API_KEY'],
'method': flickr['FLICKR_GET_SIZE'],
'photo_id': photo_id,
'format': 'json',
'nojsoncallback': 1
}
params = urllib.urlencode(params)
photo_details = json.loads(urllib2.urlopen(flickr['FLICKR_BASE_URL'] % params, timeout=10).read())
if 'sizes' in photo_details and 'size' in photo_details['sizes']:
for size in photo_details['sizes']['size']:
if size and 'label' in size and 'source' in size and 'width' in size and 'height' in size:
if size['label'] in ['Small', 'Small 320', 'Square', 'Large Square', 'Thumbnail']:
continue
details = (
photo_id,
city_id,
size['label'],
size['source'],
int(size['width']),
int(size['height'])
)
cursor.execute("INSERT IGNORE INTO photos (photo_id, city_id, size, url, width, height) VALUES (%s, %s, %s, %s, %s, %s)", details)
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(photo_details))
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
location = self.request.get('location')
types = self.request.get('types')
city_id = self.request.get('city_id')
plan_id = self.request.get('plan_id')
# Check if we already have this state stored in the database
params = {
'sensor': 'true',
'location': location,
'language': 'en',
'types': types,
'radius': 1000,
'rankby': 'prominence',
'key': config['API_KEY']
}
params = urllib.urlencode(params)
places = json.loads(urllib.urlopen(gapi['GOOGLE_PLACES_SEARCH'] % params).read())
places_queue = taskqueue.Queue('places')
if 'status' in places and places['status'] == 'OK' and 'results' in places and places['results']:
for place in places['results']:
if 'reference' not in place:
continue
details = {
'id': None,
'name': None,
'reference': None,
'types': None,
'vicinity': None,
'latitude': None,
'longitude': None,
'icon': None
}
if 'id' in place and place['id']:
details['id'] = place['id']
if 'reference' and place['reference']:
details['reference'] = place['reference']
if 'name' in place and place['name']:
details['name'] = place['name']
if 'geometry' in place and place['geometry'] and 'location' in place['geometry'] and place['geometry']['location']:
details['latitude'] = place['geometry']['location']['lat']
details['longitude'] = place['geometry']['location']['lng']
if 'types' in place and place['types']:
details['types'] = '|'.join(place['types'])
if 'icon' in place and place['icon']:
details['icon'] = place['icon']
if 'vicinity' in place and place['vicinity']:
details['vicinity'] = place['vicinity']
if not all(details.values()):
continue
details['rating'] = None
if 'rating' in place and place['rating']:
details['rating'] = place['rating']
place_db = (
details['id'],
city_id,
details['reference'],
details['types'],
details['name'],
details['vicinity'],
details['latitude'],
details['longitude'],
details['rating'],
details['icon'],
str(datetime.datetime.now())
)
cursor.execute(
"""INSERT IGNORE INTO places (gapi_id, city_id, reference, types, name, vicinity, latitude, longitude, rating, icon, created)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
place_db
);
place_id = cursor.lastrowid
if 'photos' in place and place['photos'] and place_id:
for photo in place['photos']:
if 'photo_reference' in photo and photo['photo_reference']:
cursor.execute("INSERT IGNORE INTO places_photos (place_id, reference) VALUES (%s, %s)", (place_id, photo['photo_reference']))
if place_id:
t = taskqueue.Task(
url='/api/google/places/details',
params={
'reference': details['reference'],
'place_id': place_id,
'plan_id': plan_id
},
method='GET'
)
places_queue.add(t)
s.count_tasks(plan_id)
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(places))
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
city = self.request.get('city').encode('utf8')
city_id = self.request.get('city_id')
plan_id = self.request.get('plan_id')
# Process query string
query = [item.replace(',', '') for item in city.split()]
query.append('travel')
query = '+'.join(query)
params = {
'key': config['API_KEY'],
'q': query,
'maxResults': 30,
'orderBy': 'relevance',
'country': 'US'
}
params = urllib.urlencode(params)
books = json.loads(urllib.urlopen(gapi['GOOGLE_BOOKS_SEARCH'] % params).read())
if 'items' in books and books['items']:
for item in books['items']:
book_db = {
'book_id': None,
'title': None,
'description': None,
'thumbnail': None,
'url': None
}
if 'id' in item and item['id']:
book_db['book_id'] = item['id']
if 'volumeInfo' in item and item['volumeInfo'] and 'title' in item['volumeInfo'] and item['volumeInfo']['title']:
book_db['title'] = item['volumeInfo']['title']
if 'volumeInfo' in item and item['volumeInfo'] and 'description' in item['volumeInfo'] and item['volumeInfo']['description']:
book_db['description'] = item['volumeInfo']['description']
if 'volumeInfo' in item and item['volumeInfo'] and 'imageLinks' in item['volumeInfo'] and item['volumeInfo']['imageLinks']:
img = item['volumeInfo']['imageLinks']
if 'thumbnail' in img and img['thumbnail']:
book_db['thumbnail'] = img['thumbnail']
if 'volumeInfo' in item and item['volumeInfo'] and 'infoLink' in item['volumeInfo'] and item['volumeInfo']['infoLink']:
book_db['url'] = item['volumeInfo']['infoLink']
if not all(book_db.values()):
continue
cursor.execute(
"INSERT IGNORE INTO cities_books (city_id, book_id, title, description, thumbnail, url) VALUES (%s, %s, %s, %s, %s, %s)",
(city_id, book_db['book_id'], book_db['title'], book_db['description'], book_db['thumbnail'], book_db['url'])
)
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(books))
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
city = self.request.get('city').encode('utf8')
city_id = self.request.get('city_id')
plan_id = self.request.get('plan_id')
# Process query string
query = [item.replace(',', '') for item in city.split()]
query.append('travel')
query = '+'.join(query)
params = {
'part': 'snippet',
'key': config['API_KEY'],
'type': 'video',
'order': 'relevance',
'maxResults': 30,
'videoDefinition': 'high',
'q': query
}
params = urllib.urlencode(params)
videos = json.loads(urllib.urlopen(gapi['GOOGLE_VIDEOS_SEARCH'] % params).read())
if 'items' in videos and videos['items']:
for item in videos['items']:
video_db = {
'video_id': None,
'title': None,
'thumbnail': None
}
if 'id' in item and item['id'] and 'videoId' in item['id'] and item['id']['videoId']:
video_db['video_id'] = item['id']['videoId']
if 'snippet' in item and item['snippet'] and 'title' in item['snippet'] and item['snippet']['title']:
video_db['title'] = item['snippet']['title']
if 'snippet' in item and item['snippet'] and 'thumbnails' in item['snippet'] and item['snippet']['thumbnails']:
thumb = item['snippet']['thumbnails']
if 'high' in thumb and thumb['high'] and 'url' in thumb['high'] and thumb['high']['url']:
video_db['thumbnail'] = thumb['high']['url']
if not all(video_db.values()):
continue
cursor.execute(
"INSERT IGNORE INTO cities_videos (city_id, video_id, title, thumbnail) VALUES (%s, %s, %s, %s)",
(city_id, video_db['video_id'], video_db['title'], video_db['thumbnail'])
)
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(videos))
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
place_id = self.request.get('place_id')
reference = self.request.get('reference')
plan_id = self.request.get('plan_id')
if not place_id:
# Sync completed Task
s.update_count(plan_id)
return False
params = {
'sensor': 'true',
'reference': reference,
'language': 'en',
'key': config['API_KEY']
}
params = urllib.urlencode(params)
details = json.loads(urllib.urlopen(gapi['GOOGLE_PLACES_DETAILS'] % params).read())
if 'result' in details and details['result'] and 'photos' in details['result'] and details['result']['photos']:
for photo in details['result']['photos']:
if 'photo_reference' in photo and photo['photo_reference']:
cursor.execute("INSERT IGNORE INTO places_photos (place_id, reference) VALUES (%s, %s)", (place_id, photo['photo_reference']))
if 'result' in details and details['result'] and 'reviews' in details['result'] and details['result']['reviews']:
for review in details['result']['reviews']:
place_review = {
'author_id': None,
'author_name': None,
'review': None,
'rating': None,
'reviewed_on': None
}
if 'text' in review and review['text']:
place_review['review'] = review['text']
if 'author_url' in review and review['author_url']:
place_review['author_id'] = urlparse.urlparse(review['author_url']).path[1:]
if 'author_name' in review and review['author_name']:
place_review['author_name'] = review['author_name']
if 'rating' in review and review['rating']:
place_review['rating'] = review['rating']
if 'time' in review and review['time']:
place_review['reviewed_on'] = datetime.datetime.fromtimestamp(review['time'])
if not all(place_review.values()):
continue
place_review['aspects'] = None
if 'aspects' in review and review['aspects']:
place_review['aspects'] = json.dumps(review['aspects'])
review_db = (
place_id,
place_review['author_id'],
place_review['author_name'],
place_review['review'],
place_review['aspects'],
place_review['rating'],
place_review['reviewed_on'],
httpExists(gapi['GOOGLE_PROFILE_PHOTO'] % place_review['author_id'])
)
cursor.execute(
"""INSERT INTO places_reviews (place_id, author_id, author_name, review, aspects, rating, reviewed_on, has_photo)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s)""",
review_db
)
if 'result' in details and details['result'] and 'events' in details['result'] and details['result']['events']:
for event in details['result']['events']:
place_event = {
'event_id': None,
'start_time': None,
'summary': None,
'url': None
}
if 'event_id' in event and event['event_id']:
place_event['event_id'] = event['event_id']
if 'start_time' in event and event['start_time']:
place_event['start_time'] = event['start_time']
if 'summary' in event and event['summary']:
place_event['summary'] = event['summary']
if 'url' in event and event['url']:
place_event['url'] = event['url']
if not all(place_event.values()):
continue
event_db = (
place_id,
place_event['event_id'],
place_event['start_time'],
place_event['summary'],
place_event['url']
)
cursor.execute(
"""INSERT INTO places_events (place_id, event_id, start_time, summary, url)
VALUES (%s, %s, %s, %s, %s)""",
event_db
)
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(details))
import pypeerassets as pa
from binascii import hexlify, unhexlify
from sqlalchemy.exc import IntegrityError
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from models import Card, Deck, Balance
from utils.state import init_state
from utils.sync import Sync
from conf import *
import sys
connection = Sync().connect()
node = connection.node
engine = create_engine(db_engine)
Session = sessionmaker(bind=engine)
session = Session()
def init_p2thkeys():
if autoload:
pa.pautils.load_p2th_privkey_into_local_node(node, production)
def load_key(deck):
try:
wif = pa.Kutil(privkey=unhexlify(deck.id), network=node.network).wif
node.importprivkey( wif, deck.id)
sys.stdout.write('\rImported {}'.format(wif))
sys.stdout.flush()
except:
pass
def get(self):
city = self.request.get('city')
city_id = self.request.get('city_id')
plan_id = self.request.get('plan_id')
latitude = self.request.get('latitude')
longitude = self.request.get('longitude')
tag_mode = self.request.get('tag_mode') or 'all'
# Sync Directive
s = Sync()
# Process query string
city_query = []
try:
city_query = [remove_accents(city).encode('utf8')]
except:
city_query = [city.encode('utf8')]
query = city_query
if tag_mode == 'all':
query.extend(['travel', '-women', '-girl', '-woman', '-nude'])
query = ' '.join(query)
params = {
'api_key': flickr['FLICKR_API_KEY'],
'method': flickr['FLICKR_SEARCH'],
'text': query,
'per_page': 40,
'page': 1,
'privacy_filter': 1,
'content_type': 1,
'sort': 'interestingness-desc',
'media': 'photos',
'format': 'json',
'nojsoncallback': 1
}
params = urllib.urlencode(params)
photos = json.loads(urllib2.urlopen(flickr['FLICKR_BASE_URL'] % params, timeout=10).read())
flickr_queue = taskqueue.Queue('flickr')
photo_count = 0
if 'photos' in photos and 'photo' in photos['photos']:
for photo in photos['photos']['photo']:
if 'id' in photo and photo['id']:
t = taskqueue.Task(
url='/api/flickr/get_size',
params={
'photo_id': photo['id'],
'city_id': city_id,
'plan_id': plan_id
},
method='GET'
)
flickr_queue.add(t)
s.count_tasks(plan_id)
photo_count = photo_count + 1
# Safe Query for Flickr
if photo_count < 5 and tag_mode == 'all':
query = []
query.extend(['forest', 'hills', 'clouds', 'summer', 'spring', 'winter', 'autumn', 'sky', 'mountains', '-women', '-girl', '-woman', '-nude'])
query = ' '.join(query)
params = {
'api_key': flickr['FLICKR_API_KEY'],
'method': flickr['FLICKR_SEARCH'],
'text': query,
'per_page': 20,
'page': 1,
'privacy_filter': 1,
'content_type': 1,
'sort': 'interestingness-desc',
'media': 'photos',
'format': 'json',
'nojsoncallback': 1
}
params = urllib.urlencode(params)
photos = json.loads(urllib2.urlopen(flickr['FLICKR_BASE_URL'] % params, timeout=10).read())
if 'photos' in photos and 'photo' in photos['photos']:
for photo in photos['photos']['photo']:
if 'id' in photo and photo['id']:
t = taskqueue.Task(
url='/api/flickr/get_size',
params={
'photo_id': photo['id'],
'city_id': city_id,
'plan_id': plan_id
},
method='GET'
)
flickr_queue.add(t)
s.count_tasks(plan_id)
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(photos))
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
# Get task specifics
city_id = self.request.get('city_id')
hotel_id = self.request.get('hotel_id')
plan_id = self.request.get('plan_id')
expedia_hotel_id = self.request.get('expedia_hotel_id')
# Compose signature
created = datetime.datetime.now()
now = datetime.datetime.utcnow()
now = calendar.timegm(now.utctimetuple())
sig = expedia['EXPEDIA_API_KEY'] + expedia['EXPEDIA_API_SECRET'] + str(now)
# Generate signature hash
m = hashlib.md5()
m.update(sig.encode('utf-8'))
signature = m.hexdigest()
params = {
'cid': expedia['EXPEDIA_CID'],
'apiKey': expedia['EXPEDIA_API_KEY'],
'sig': signature,
'hotelId': expedia_hotel_id,
'_type': 'json'
}
params = urllib.urlencode(params)
photos = json.loads(urllib2.urlopen(expedia['EXPEDIA_PHOTOS_SEARCH'] % params, timeout=20).read())
# Dear programmer, please remember to replace _s with _y and _z
if 'HotelRoomImageResponse' in photos and photos['HotelRoomImageResponse']:
photos = photos['HotelRoomImageResponse']
if 'RoomImages' in photos and photos['RoomImages']:
photos = photos['RoomImages']
if 'RoomImage' in photos and photos['RoomImage']:
photos = photos['RoomImage']
if not photos:
# Sync completed Task
s.update_count(plan_id)
return
if type(photos) is dict:
photos = [photos]
for photo in photos:
if 'url' in photo and photo['url']:
if not httpExists(photo['url']):
continue
if not httpExists(photo['url'].replace('_s', '_y')):
continue
photo_db = (
city_id,
hotel_id,
expedia_hotel_id,
photo['url'],
httpExists(photo['url'].replace('_s', '_z')),
created
)
query = ("""INSERT INTO hotels_photos (city_id, hotel_id, expedia_hotel_id, url, is_large, created)
VALUES (%s, %s, %s, %s, %s, %s)""")
cursor.execute(query, photo_db)
# Save everything in DB
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(photos))
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
# Get task specifics
country = self.request.get('country')
city = self.request.get('city')
city_id = self.request.get('city_id')
plan_id = self.request.get('plan_id')
future_day = self.request.get('future_day')
future_day = datetime.datetime.strptime(future_day, '%Y-%m-%d')
# Filter Characters
try:
city= remove_accents(city).encode('utf8')
except:
city = city.encode('utf8')
# Compose signature
created = datetime.datetime.now()
now = datetime.datetime.utcnow()
now = calendar.timegm(now.utctimetuple())
sig = expedia['EXPEDIA_API_KEY'] + expedia['EXPEDIA_API_SECRET'] + str(now)
# Generate signature hash
m = hashlib.md5()
m.update(sig.encode('utf-8'))
signature = m.hexdigest()
params = {
'cid': expedia['EXPEDIA_CID'],
'apiKey': expedia['EXPEDIA_API_KEY'],
'sig': signature,
'currencyCode': 'USD',
'city': city,
'countryCode': country,
'arrivalDate': future_day.strftime('%m/%d/%Y'),
'departureDate': (future_day + datetime.timedelta(days=10)).strftime('%m/%d/%Y'),
'numberOfResults': 16,
'_type': 'json'
}
params = urllib.urlencode(params)
hotels = json.loads(urllib2.urlopen(expedia['EXPEDIA_HOTELS_SEARCH'] % params, timeout=20).read())
# The Queue
hotels_queue = taskqueue.Queue('hotels')
if 'HotelListResponse' in hotels and hotels['HotelListResponse']:
hotels = hotels['HotelListResponse']
if 'HotelList' in hotels and hotels['HotelList']:
hotels = hotels['HotelList']
if 'HotelSummary' in hotels and hotels['HotelSummary']:
hotels = hotels['HotelSummary']
if not hotels:
# Sync completed Task
s.update_count(plan_id)
return
if type(hotels) is dict:
hotels = [hotels]
for hotel in hotels:
new_hotel = {
'hotel_id': None,
'name': None,
'thumbnail': None,
'description': None,
'location_description': None,
'url': None,
'latitude': None,
'longitude': None,
'address': None,
'high_rate': None,
'low_rate': None,
'rating': None
}
if 'hotelId' in hotel and hotel['hotelId']:
new_hotel['hotel_id'] = hotel['hotelId']
if 'name' in hotel and hotel['name']:
new_hotel['name'] = hotel['name']
if 'thumbNailUrl' in hotel and hotel['thumbNailUrl']:
new_hotel['thumbnail'] = expedia['EXPEDIA_IMAGES_BASE_URL'] + hotel['thumbNailUrl']
if 'shortDescription' in hotel and hotel['shortDescription']:
new_hotel['description'] = hotel['shortDescription']
if 'locationDescription' in hotel and hotel['locationDescription']:
new_hotel['location_description'] = hotel['locationDescription']
if 'deepLink' in hotel and hotel['deepLink']:
new_hotel['url'] = hotel['deepLink']
if 'latitude' in hotel and hotel['latitude']:
new_hotel['latitude'] = hotel['latitude']
if 'longitude' in hotel and hotel['longitude']:
new_hotel['longitude'] = hotel['longitude']
if 'address1' in hotel and hotel['address1']:
new_hotel['address'] = hotel['address1']
if 'lowRate' in hotel and hotel['lowRate']:
new_hotel['low_rate'] = hotel['lowRate']
if 'highRate' in hotel and hotel['highRate']:
new_hotel['high_rate'] = hotel['highRate']
if 'hotelRating' in hotel and hotel['hotelRating']:
new_hotel['rating'] = hotel['hotelRating']
if not all(new_hotel.values()):
continue
new_hotel['trip_advisor_rating'] = None
if 'tripAdvisorRating' in hotel and hotel['tripAdvisorRating']:
new_hotel['trip_advisor_rating'] = hotel['tripAdvisorRating']
new_hotel['amenity_mask'] = None
if 'amenityMask' in hotel and hotel['amenityMask']:
new_hotel['amenity_mask'] = hotel['amenityMask']
# Add new hotel to database
hotel_db = (
city_id,
new_hotel['hotel_id'],
new_hotel['name'],
new_hotel['thumbnail'],
new_hotel['description'],
new_hotel['location_description'],
new_hotel['url'],
new_hotel['latitude'],
new_hotel['longitude'],
new_hotel['address'],
new_hotel['low_rate'],
new_hotel['high_rate'],
new_hotel['rating'],
new_hotel['trip_advisor_rating'],
new_hotel['amenity_mask'],
future_day,
created
)
query = ("""INSERT INTO cities_hotels (city_id, hotel_id, name, thumbnail, description,
location_description, url, latitude, longitude, address, low_rate, high_rate,
rating, trip_advisor_rating, amenity_mask, filter_date, created)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""")
cursor.execute(query, hotel_db)
hotel_id = cursor.lastrowid
# Let's grab some photos for this hotel
t = taskqueue.Task(
url='/api/expedia/photos/search',
params={
'plan_id': plan_id,
'city_id': city_id,
'hotel_id': hotel_id,
'expedia_hotel_id': new_hotel['hotel_id']
},
method='GET'
)
hotels_queue.add(t)
s.count_tasks(plan_id)
# Write everything in DB
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(hotels))
def post(self):
# Check if User is already logged in
if not self.session.get('google_id'):
return self.redirect('/')
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Every entity is created NOW
created = str(datetime.datetime.now())
# Get current user
user_id = self.session.get('user_id')
# Get address
city = self.request.get('city')
# Get geolocation data
latitude = self.request.get('latitude')
longitude = self.request.get('longitude')
# Check to see if we have a valid location
if not latitude or not longitude:
self.session['tj__plan__error'] = 'The location you have selected is unknown. Please try again.'
return self.redirect('/plan')
country = self.request.get('country')
short_city = self.request.get('short_city')
future_day = self.request.get('future_day_submit')
# Check to see if user filled in the future day
if not future_day:
self.session['tj__plan__error'] = 'Please select a future date around which you would like to plan your trip.'
return self.redirect('/plan')
# Extra Validation
future_day = datetime.datetime.strptime(future_day, '%Y-%m-%d')
future_tmp = calendar.timegm(future_day.utctimetuple())
future_day = future_day.strftime('%Y-%m-%d')
# Check to see if we have short_city
if not short_city:
short_city = city.split(',')[0]
# Get preferences
places = self.request.get_all('places[]')
# Check to see if the user has selected at least one type of place
if not len(places):
self.session['tj__plan__error'] = 'Please select at least one type of place that you would like to visit.'
return self.redirect('/plan')
places = '|'.join(places)
events = self.request.get_all('events[]')
# Check to see if the user has selected at least one type of event
if not len(events):
self.session['tj__plan__error'] = 'Please select at least one type of event that you would like to attend.'
return self.redirect('/plan')
events = '|'.join(events)
# Do an extra call to Places API
params = {
'sensor': 'true',
'location': str(latitude) + ',' + str(longitude),
'language': 'en',
'types': places,
'radius': 1000,
'rankby': 'prominence',
'key': config['API_KEY']
}
params = urllib.urlencode(params)
test_pl = json.loads(urllib.urlopen(gapi['GOOGLE_PLACES_SEARCH'] % params).read())
if 'status' not in test_pl or test_pl['status'] != 'OK' or 'results' not in test_pl or not test_pl['results'] or len(test_pl['results']) < 3:
self.session['tj__plan__error'] = 'We couldn\'t find places that met your criteria. Please try to select more types.'
return self.redirect('/plan')
# Check if the city already exists in the Database
query = ("""SELECT id,
latitude,
longitude,
country
FROM cities
WHERE latitude = %s
AND longitude = %s""")
cursor.execute(query, (latitude, longitude))
city_db = cursor.fetchone()
# Add city to database if it's not there
if city_db is None:
new_city = (
short_city,
city,
latitude,
longitude,
country,
created
)
query = ("""INSERT IGNORE INTO cities
(name, address, latitude, longitude, country, created)
VALUES (%s, %s, %s, %s, %s, %s)""")
cursor.execute(query, new_city)
city_id = cursor.lastrowid
else:
city_id = city_db['id']
# Write plan to database
new_plan = (
user_id,
city_id,
places,
events,
datetime.datetime.fromtimestamp(future_tmp)
)
query = ("""INSERT INTO plans
(user_id, city_id, types, events, future_day)
VALUES (%s, %s, %s, %s, %s)""")
cursor.execute(query, new_plan)
db_conn.commit()
plan_id = cursor.lastrowid
# Let's fire up the Main queue
main_queue = taskqueue.Queue('main')
# Sync Directive
s = Sync()
# Let's search for some cool places
location = str(latitude + ',' + longitude)
t = taskqueue.Task(
url='/api/google/places/search',
params={
'location': location,
'types': places,
'city_id': city_id,
'plan_id': plan_id
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# Let's find some awesome videos
t = taskqueue.Task(
url='/api/google/videos/search',
params={
'city': short_city,
'city_id': city_id,
'plan_id': plan_id
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# Fancy reading a book?
t = taskqueue.Task(
url='/api/google/books/search',
params={
'city': short_city,
'city_id': city_id,
'plan_id': plan_id
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# Photos from flickr
t = taskqueue.Task(
url='/api/flickr/search',
params={
'city': short_city,
'city_id': city_id,
'plan_id': plan_id,
'latitude': latitude,
'longitude': longitude
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# Let's grab some events so we don't get bored on our trip
t = taskqueue.Task(
url='/api/eventbrite/events/search',
params={
'city': short_city,
'city_id': city_id,
'country': country,
'latitude': latitude,
'longitude': longitude,
'categories': events,
'plan_id': plan_id,
'future_day': future_day
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# What about hotels?
t = taskqueue.Task(
url='/api/expedia/hotels/search',
params={
'city': short_city,
'city_id': city_id,
'plan_id': plan_id,
'country': country,
'future_day': future_day
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# How about a little wikipedia knowledge
t = taskqueue.Task(
url='/api/wikipedia/summary',
params={
'city': short_city,
'city_id': city_id,
'plan_id': plan_id
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# But what about the weather?
t = taskqueue.Task(
url='/api/forecast/future',
params={
'plan_id': plan_id,
'latitude': latitude,
'longitude': longitude,
'future_day': str(future_tmp)
},
method='GET'
)
main_queue.add(t)
s.count_tasks(plan_id)
# Write to DB
db_conn.commit()
# Let's go somewhere beautiful
return self.redirect('/plans')
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
# Every entity is created NOW
created = str(datetime.datetime.now())
city = self.request.get('city')
city_id = self.request.get('city_id')
country = self.request.get('country')
plan_id = self.request.get('plan_id')
latitude = self.request.get('latitude')
longitude = self.request.get('longitude')
categories = self.request.get('categories')
categories = categories.replace('|', ',')
future_day = self.request.get('future_day')
future_day = datetime.datetime.strptime(future_day, '%Y-%m-%d')
# Filter Characters
try:
city= remove_accents(city).encode('utf8')
except:
city = city.encode('utf8')
params = {
'app_key': eventbrite['EVENTBRITE_API_KEY'],
'city': city,
'country': country,
'max': 16,
'category': categories,
'date': '%s %s' % (future_day.strftime('%Y-%m-%d'), (future_day + datetime.timedelta(days=30)).strftime('%Y-%m-%d')),
'display': 'repeat_schedule'
}
params = urllib.urlencode(params)
events = json.loads(urllib.urlopen(eventbrite['EVENTBRITE_EVENT_SEARCH'] % params).read())
# Let the parsing begin
if 'events' in events and events['events']:
for item in events['events']:
new_event = {
'eventbrite_id': None,
'title': None,
'url': None,
'start_date': None,
'end_date': None,
'venue_latitude': None,
'venue_longitude': None,
'organizer_name': None
}
if 'event' not in item:
continue
event = item['event']
if 'id' in event and event['id']:
new_event['eventbrite_id'] = event['id']
if 'title' in event and event['title']:
new_event['title'] = event['title']
if 'url' in event and event['url']:
new_event['url'] = event['url']
if 'start_date' in event and event['start_date']:
new_event['start_date'] = event['start_date']
if 'end_date' in event and event['end_date']:
new_event['end_date'] = event['end_date']
if 'venue' in event and event['venue'] and 'latitude' in event['venue'] and event['venue']['latitude']:
new_event['venue_latitude'] = event['venue']['latitude']
if 'venue' in event and event['venue'] and 'longitude' in event['venue'] and event['venue']['longitude']:
new_event['venue_longitude'] = event['venue']['longitude']
if 'organizer' in event and event['organizer'] and 'name' in event['organizer'] and event['organizer']['name']:
new_event['organizer_name'] = event['organizer']['name']
# If minimum requirements are not met we move on
if not all(new_event.values()):
continue
new_event['logo'] = None
if 'logo' in event and event['logo']:
new_event['logo'] = event['logo']
new_event['organizer_url'] = None
if 'organizer' in event and event['organizer'] and 'url' in event['organizer'] and event['organizer']['url']:
new_event['organizer_url'] = event['organizer']['url']
new_event['venue_name'] = None
if 'venue' in event and event['venue'] and 'name' in event['venue'] and event['venue']['name']:
new_event['venue_name'] = event['venue']['name']
new_event['venue_address'] = None
if 'venue' in event and event['venue'] and 'address' in event['venue'] and event['venue']['address']:
new_event['venue_address'] = event['venue']['address']
new_event['venue_address_2'] = None
if 'venue' in event and event['venue'] and 'address_2' in event['venue'] and event['venue']['address_2']:
new_event['venue_address_2'] = event['venue']['address_2']
new_event['repeats'] = 0
if 'repeats' in event and event['repeats'] == 'yes':
new_event['repeats'] = 1
new_event['repeat_schedule'] = None
if 'repeat_schedule' in event and event['repeat_schedule']:
new_event['repeat_schedule'] = event['repeat_schedule']
new_event['categories'] = None
if 'category' in event and event['category']:
new_event['categories'] = event['category']
# Insert the new event into our database
event_db = (
city_id,
new_event['eventbrite_id'],
new_event['title'],
new_event['url'],
new_event['logo'],
new_event['categories'],
new_event['start_date'],
new_event['end_date'],
new_event['venue_latitude'],
new_event['venue_longitude'],
new_event['venue_address'],
new_event['venue_address_2'],
new_event['venue_name'],
new_event['organizer_name'],
new_event['organizer_url'],
new_event['repeats'],
json.dumps(new_event['repeat_schedule']),
future_day,
created
)
query = ("""INSERT IGNORE INTO cities_events
(city_id, eventbrite_id, title, url, logo, categories, start_date, end_date, venue_latitude,
venue_longitude, venue_address, venue_address_2, venue_name, organizer_name,
organizer_url, repeats, repeat_schedule, filter_date, created)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""")
cursor.execute(query, event_db)
# Write everything in DB
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(events))
def get(self):
# MySQL Cursor
db_conn = self.connection
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
# Sync Directive
s = Sync()
# Created Time
created = datetime.datetime.now()
# Get task specific data
plan_id = self.request.get('plan_id')
latitude = self.request.get('latitude')
longitude = self.request.get('longitude')
future_day = self.request.get('future_day')
params = [latitude, longitude, future_day]
params = ','.join(params)
print forecast['FORECAST_FUTURE'] % (forecast['FORECAST_API_KEY'], params)
weather = json.loads(urllib.urlopen(forecast['FORECAST_FUTURE'] % (forecast['FORECAST_API_KEY'], params)).read())
new_forecast = {
'offset': None,
'hourly_data': None
}
if 'offset' in weather and weather['offset'] is not None:
new_forecast['offset'] = weather['offset']
if 'hourly' in weather and weather['hourly'] and 'data' in weather['hourly'] and weather['hourly']['data']:
new_forecast['hourly_data'] = json.dumps(weather['hourly']['data'])
if not new_forecast['hourly_data']:
# Sync completed Task
s.update_count(plan_id)
return
new_forecast['icon'] = None
if 'hourly' in weather and weather['hourly'] and 'icon' in weather['hourly'] and weather['hourly']['icon']:
new_forecast['icon'] = weather['hourly']['icon']
new_forecast['summary'] = None
if 'hourly' in weather and weather['hourly'] and 'summary' in weather['hourly'] and weather['hourly']['summary']:
new_forecast['summary'] = weather['hourly']['summary']
# Save everything in our DB
forecast_db = (
plan_id,
future_day,
new_forecast['summary'],
int(new_forecast['offset']),
new_forecast['icon'],
new_forecast['hourly_data'],
created
)
query = ("""INSERT IGNORE INTO plans_forecast
(plan_id, future_day, summary, offset, icon, hourly_data, created)
VALUES (%s, %s, %s, %s, %s, %s, %s)""")
cursor.execute(query, forecast_db)
db_conn.commit()
# Sync completed Task
s.update_count(plan_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(weather))
