def home(request):
""" Landing page """
# complete oauth retrieving token (unless already in session)
login_code = request.GET.get('code', '')
if not request.session.has_key(ACCESS_TOKEN) and not login_code:
return render(request, 'home.html')
elif not request.session.has_key(ACCESS_TOKEN) and login_code:
client = foursquare.Foursquare(client_id=settings.CLIENT_ID,
client_secret=settings.CLIENT_SECRET,
redirect_uri=settings.REDIRECT_URI)
access_token = client.oauth.get_token(login_code)
request.session[ACCESS_TOKEN] = access_token
request.session["is_logged_in"] = True
client = foursquare.Foursquare(access_token=request.session[ACCESS_TOKEN])
access_token = request.session[ACCESS_TOKEN]
user = client.users()
user_id = user["user"]["id"]
request.session[USER] = user
checkins = client.users.checkins()
with open(os.path.join(settings.NEW_USER_DIRECTORY, user_id),
'w+') as outfile:
json.dump(user, outfile)
with open(os.path.join(settings.CHECKINS_DIRECTORY, user_id),
'w+') as outfile:
json.dump(checkins, outfile)
return redirect('/recommend/')
def search_activity(ciudad, cultural, festivas, ludicas):
CLIENT_ID = 'OTXPMRAIY0GHYDTPXELL1EDHFYNVVRFEMQLHUUVXNEYV1DDS'
CLIENT_SECRET = '50FCYQPJSHM4CBVXVQFKXVM2AMKAIAEQ3LDZVZZZ44O10MTV'
contenidoActivity = {}
if str(cultural) == 'Sí':
client = foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
cul = client.venues.search(
params={
'll': GEO[str(ciudad)],
'intent': 'browse',
'radius': '4000',
'query': 'monument'
})
k = cul["venues"]
for result in k:
contenidoActivity[result["name"]] = "C"
if str(festivas) == 'Sí':
client = foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
fes = client.venues.search(
params={
'll': GEO[str(ciudad)],
'intent': 'browse',
'radius': '4000',
'query': 'party'
})
k = fes["venues"]
for result in k:
contenidoActivity[result["name"]] = "F"
if str(ludicas) == 'Sí':
client = foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
lud = client.venues.search(
params={
'll': GEO[str(ciudad)],
'intent': 'browse',
'radius': '4000',
'query': 'casino'
})
k = lud["venues"]
for result in k:
contenidoActivity[result["name"]] = "L"
return contenidoActivity
async def callback(code: str = None, db: Session = Depends(get_db)):
if not code:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST)
redirect_uri = 'http://' + os.environ.get("DOMAIN") + '/callback'
client = foursquare.Foursquare(client_id=cid,
client_secret=cs,
redirect_uri=redirect_uri)
access_token = client.oauth.get_token(code)
client = foursquare.Foursquare(access_token=access_token)
user = client.users()
user_id = user["user"]["id"]
token = create_tokens(db=db, user_id=user_id, at=access_token)
return token
def test_basic_auth(self):
"Testing basic HTTP authentication."
fs = foursquare.Foursquare(
foursquare.BasicCredentials(username, password))
test_result = fs.test()
self.assertEqual(test_result['response'], 'ok')
user = fs.user()
self.failUnless('user' in user)
# Now try with a bad user/password
fs = foursquare.Foursquare(
foursquare.BasicCredentials(username,
'passworddontmatter' + password))
self.assertRaises(foursquare.FoursquareRemoteException,
lambda: fs.user())
def auth_4sq(client_id, client_secret):
# Construct the client object
client = foursquare.Foursquare(client_id=client_id,
client_secret=client_secret)
# Build the authorization url for your app
auth_uri = client.oauth.auth_url()
return client
def main():
add_table_venue_meta()
add_table_venue_photo_4sq()
add_table_venue_tips()
client = foursquare.Foursquare(
config.foursquare_client_id,
client_secret=config.foursquare_client_secret)
all_plazas = client.venues.search(
params={
'near': 'New York City',
'limit': 50,
'intent': 'browse',
'radius': 5000,
'categoryId': '4bf58dd8d48988d164941735'
})
print all_plazas
cnt = 0
for v in all_plazas['venues']:
time.sleep(10)
venue_id = v['id']
print 'progress: %d/%d -> %s' % (cnt, len(all_plazas), v['name'])
crawler = VenueMetaCrawler()
crawler.grab_meta_data(venue_id)
crawler = VenuePhotoCrawlerFoursquare()
crawler.grab_photo(venue_id)
crawler = VenueTipsCrawler()
crawler.grab_tip(venue_id)
def get_status(self):
client = foursquare.Foursquare(
config.foursquare_client_id,
client_secret=config.foursquare_client_secret)
all_plazas = client.venues.search(
params={
'near': 'New York City',
'limit': 50,
'intent': 'browse',
'radius': 5000,
'categoryId': '4bf58dd8d48988d164941735'
})
queue = Queue.Queue()
for i in range(3):
t = Job(queue)
t.setDaemon(True)
t.start()
ids = []
for v in all_plazas['venues']:
ids.append(v['id'])
queue.put(v['id'])
queue.join()
return "done"
"""
"""
return 'ok'
def fs_rating_dict(location, restaurant):
CLIENT_ID = u'OO3LVQ50PEU241GACB3GMFGOQCEMBBGMJKXHFP1IYO2MECOI'
CLIENT_SECRET = u'TXQPMS1KMG4DBNFFAA4OBEMEEJG3FW0SNPPGZ0IKGNLQIRE1'
client = foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
rating_dict = {}
#get venue id from search
venue_info = client.venues.search(params={
'near': location,
'query': restaurant,
'limit': 1
})
if len(venue_info['venues']) == 0:
rating_dict[restaurant] = 0
return rating_dict
else:
venue_id = venue_info['venues'][0]['id']
if len(venue_info['venues']) == 0:
rating_dict[restaurant] = 0
return rating_dict
else:
venue_id = venue_info['venues'][0]['id']
#get average rating
details = client.venues(venue_id)
rating = details['venue'].get('rating')
if rating == None:
rating_dict[restaurant] = 0
else:
#divide by 2 to compare to yelp's ratings
adjusted_rating = rating / 2
rating_dict[restaurant] = adjusted_rating
return rating_dict
def fs_price_tier_dict(location, restaurant):
CLIENT_ID = u'OO3LVQ50PEU241GACB3GMFGOQCEMBBGMJKXHFP1IYO2MECOI'
CLIENT_SECRET = u'TXQPMS1KMG4DBNFFAA4OBEMEEJG3FW0SNPPGZ0IKGNLQIRE1'
client = foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
price_tier_dict = {}
#get venue id from search
venue_info = client.venues.search(params={
'near': location,
'query': restaurant,
'limit': 1
})
if venue_info['venues'] == None:
price_tier_dict[restaurant] = 0
else:
if len(venue_info['venues']) == 0:
price_tier_dict[restaurant] = 0
return price_tier_dict
else:
venue_id = venue_info['venues'][0]['id']
details = client.venues(venue_id)
price = details['venue'].get('price')
if price == None:
price_tier = 0
price_tier_dict[restaurant] = price_tier
else:
price_tier = price.get('tier')
price_tier_dict[restaurant] = price_tier
return price_tier_dict
def get_foursquare_restaurants(zipcode):
cid = 'CR35KTWYW2ORWUVSKYRO2DBJQS5IHUGZ0L3AUD1NNEJ1DFVO'
csec = '0CJSR410CJYIF3YQBPFBCPAUAXTCJW5JXMJ4ABRDXAKWPZVF'
result = []
client = foursquare.Foursquare(client_id=cid, client_secret=csec)
auth_uri = client.oauth.auth_url()
# ex['groups'][0]['items'][0]['venue']['location']
limit = client.venues.explore(params={
'query': 'restaurant',
'near': str(zipcode),
'limit': '1',
'offset': '0'
})['totalResults']
limit = int(limit)
for i in range(0, limit, 50):
restaurants = client.venues.explore(
params={
'query': 'restaurant',
'limit': '50',
'offset': str(i),
'near': str(zipcode)
})['groups'][0]['items']
for restaurant in restaurants:
result.append(foursquare_to_json(restaurant))
return result
def getMenus(self, venues=None):
"""
Description
-----------
A method for returning venue menu query response data.
Parameters
----------
venues: list;
A list of venue id numbers to query for menu data.
"""
if venues is None:
venues_dict = self.JSON_DATA['VENUES']
client = foursquare.Foursquare(
client_id=self.CREDENTIALS['fsid'],
client_secret=self.CREDENTIALS['fssecret'])
unique_ids = []
menus = {}
try:
for key in venues_dict:
print("Querying menu data for key:", key)
for venue in venues_dict[key]['venues']:
venue_name = venue['name']
venue_id = venue['id']
if (venue_id in unique_ids):
pass
else:
unique_ids += [venue_id]
response = client.venues.menu(venue_id)
menus[venue_name] = response
except:
traceback.print_exc()
self.JSON_DATA['MENUS'] = menus
print("Menu query operation complete!")
return #menus
def handle(self, *args, **options):
logger.info("Starting foursquare job")
app = SocialApp.objects.filter(provider='foursquare')[0]
for bookowner in BookOwner.objects.filter(check_foursquare=True):
self.user = bookowner.user
self.book = bookowner.book
try:
token = SocialToken.objects.get(account__user=self.user,
app=app)
except SocialToken.DoesNotExist:
token = None
sentry.error("No foursquare token found",
exc_info=True,
extra={'user': self.user})
if token:
self.client = foursquare.Foursquare(access_token=token.token)
if self.user and self.book and self.client:
checkins = self.get_checkins()
self.foursquare_user_id = self.get_foursquare_user_details(
).get('id')
for checkin in checkins:
self.handle_checkin(checkin)
def get_check_in_info(id):
global i
dt = date.today()
# url = "https://api.foursquare.com/v2/venues/" + id + '?oauth_token=' + FOURSQUARE_ACCESS_TOKEN + '&v=' + dt.strftime('%Y%m%d')
client = foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
data = dict(client.venues(id))
# print url
# data = json.load(urllib2.urlopen(url))
checkin = data['venue']
# date_info = checkin['createdAt']
timezoneoffset = checkin['timeZone']
location = checkin['location']
lat = location['lat']
lng = location['lng']
categories = checkin['categories']
categories_name = ""
for item in categories:
categories_name += item['name'] + '\n'
# print user_id, lat, lng, date_info, categories_name
temp = str(lat) + '\t' + str(lng) + '\t' + categories_name + '\n'
print temp
with open("test.txt", "a") as myfile:
i += 1
print i
myfile.write(categories_name + '\n')
def generate_graph():
CLIENT_ID = "..."
CLIENT_SECRET = "..."
client = foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
G = nx.Graph()
search = client.venues.explore(params={'near': 'Rome,Italy'})
for group in search['groups']:
#creates all the nodes
for venue in group['items']:
G.add_node(venue["venue"]["id"],
id=venue["venue"]["id"],
name=venue["venue"]["name"],
pos=(venue["venue"]["location"]["lat"],
venue["venue"]["location"]["lng"]),
country=venue["venue"]["location"]["country"],
size=10)
#creates the edges between next venues
for venue in group['items']:
nextVenues = client.venues.nextvenues(venue["venue"]["id"])
for nextvenue in nextVenues["nextVenues"]["items"]:
v1 = G.node[venue["venue"]["id"]]
if (nextvenue["id"] in G):
v2 = G.node[nextvenue["id"]]
G.add_edge(v1["id"],
v2["id"],
distance=venues_distance(v1, v2))
return G
def login(request):
""" Login through foursquare """
client = foursquare.Foursquare(client_id=settings.CLIENT_ID,
client_secret=settings.CLIENT_SECRET,
redirect_uri=settings.REDIRECT_URI)
auth_uri = client.oauth.auth_url()
return redirect(auth_uri)
def test_oauth(self):
if not TEST_OAUTH:
return
# Authorization dance.
oauth_key = raw_input('Enter your foursquare oauth consumer key: ')
oauth_secret = raw_input(
'Enter your foursquare oauth consumer secret: ')
fs = foursquare.Foursquare(
foursquare.OAuthCredentials(oauth_key, oauth_secret))
app_token = fs.request_token()
auth_url = fs.authorize(app_token)
raw_input(
'Please go the following URL and authorize your app, then press enter: %s\n'
% (auth_url, ))
# In case we're being piped usernames and passwords and keys and secrets and...
time.sleep(15)
user_token = fs.access_token(app_token)
fs.credentials.set_access_token(user_token)
# Now we can test some methods.
test_result = fs.test()
self.assertEqual(test_result['response'], 'ok')
user = fs.user()
self.failUnless('user' in user)
def admin_settings(request, plugin):
context = RequestContext(request)
settings_form = plugin.get_site_settings_form()
if request.method == 'POST':
if 'submit-settings' in request.POST:
settings_form = forms.SiteSettingsForm(request.POST)
if settings_form.is_valid():
client_id = settings_form.cleaned_data['client_id']
client_secret = settings_form.cleaned_data['client_secret']
venue_id = settings_form.cleaned_data['venue_id']
client = foursquare.Foursquare(client_id=client_id,
client_secret=client_secret)
venue = None
try:
# Search for the venue. Simultaneous validates all three credentials.
if venue_id:
venue = client.venues(venue_id)
except foursquare.FoursquareException, e:
messages.error(
request,
'Error testing Foursquare connection: %s' % str(e))
else:
plugin.save_site_settings_form(settings_form)
plugin.save_venue_detail(venue)
messages.success(request, 'Settings updated')
def connect_foursquare():
global places
conn = sqlite3.connect(
'/home/kevin/workspace/FourSquare/foursquare.sqlite')
conn.text_factory = str
now = datetime.datetime.now()
for k in places.keys():
print k
client = foursquare.Foursquare(
client_id='GJPWWXSBRKXNNZ1EHX2S2K53HW1PD0MORDFCGKPZKX0DVFV1',
client_secret='LNXDLIAMJSPXZ3QJ02A4LXIADKEMF0XJWQI5MXXU5NQN5LJD')
venues = client.venues.trending(
{
"ll": places[k],
"limit": 50,
"radius": 2000
}, multi=False)["venues"]
for venue in venues:
val = [(venue["location"]["lat"], venue["location"]["lng"],
venue["name"], venue["categories"][0]["name"], str(now),
venue["hereNow"]["count"], k)]
conn.executemany(
"INSERT INTO foursquare (lat,long,name,type,datetime,count,city_py) VALUES (?,?,?,?,?,?,?) ",
val)
conn.commit()
conn.close()
def main():
job = Job()
client = foursquare.Foursquare(
config.foursquare_client_id,
client_secret=config.foursquare_client_secret)
all_plazas = client.venues.search(
params={
'near': 'New York City',
'limit': 50,
'intent': 'browse',
'radius': 5000,
'categoryId': '4bf58dd8d48988d164941735'
})
ids = []
for v in all_plazas['venues']:
ids.append(v['id'])
t = Thread(target=job.download, args=(ids, ))
t.setDaemon(True)
t.start()
print 'The thread started'
second = 0
while (1):
second += 1
time.sleep(1)
job.report()
def makeFoursquareClient(access_token=None):
redirect_uri = generateRedirectUri()
return foursquare.Foursquare(client_id = CONFIG['client_id'],
client_secret = SECRETS['client_secret'],
access_token = access_token,
redirect_uri = redirect_uri,
version = CONFIG['api_version'])
def get_token(cli_id, cli_sec, session):
client_id = cli_id
client_secret = cli_sec
client = foursquare.Foursquare(
client_id=client_id,
client_secret=client_secret,
redirect_uri='http://127.0.0.1:3000/auth/return')
auth_url = client.oauth.auth_url()
print 'get access token...'
token = ''
try:
# for those first time get access token ,and for those already have the token will throw an exception
html = session.get(auth_url).content
authpage = BS(html, 'html.parser')
_xsrf = authpage.find('input',
{'name': 'fs-request-signature'})['value']
data = {'shouldAuthorize': 'true', 'fs-request-signature': _xsrf}
# the stmt will throw a exception when send data
resp = session.post(auth_url, data, headers)
except requests.exceptions.ConnectionError, e:
print 'access_token:'
code = str(e).split('?')[1][5:53]
access_token = client.oauth.get_token(code)
token = access_token
print access_token
def __init__(self, user_profile, fs_client_ID=foursquare_API_client_ID,
fs_client_secret=foursquare_API_client_secret, intent=fs_intent,
limit=fs_limit):
"""
Initializes the Recommender object instance
Parameters
----------
user_profile: dictionary
Dictionary with user preferences
fs_client_ID: string
Foursquare API client ID
fs_client_secret: string
Foursquare API client password
"""
# Instantiate Foursquare API wrapper
self.fs_client = foursquare.Foursquare(client_id=fs_client_ID,
client_secret=fs_client_secret)
self.user_profile = user_profile
self.intent = intent
self.limit = limit
self.recommendations = None
def getFoursquareCheckIns(date):
"""
Gets the check-ins occurred in NY from a starting date.
:param date: (Y-m-d).
:return: dictionary {(long, lat) : number of check-ins}.
"""
client = foursquare.Foursquare(
client_id='FUG50WOUTS2FHTCUIVFUUXFFTUGGIC1CITI53KBXPAVDFDV0',
client_secret='2BLM42NTYGLNAA0J3ECOZSHJVJ0ZBC1S32MWBF24JWDN5PIX')
checkins = client.venues.explore(
params={
'near': 'New York, NY',
'afterTimestamp': date,
'time': 'any',
'day': 'any'
})
dict = {}
for checkin in checkins['groups']:
for item in checkin['items']:
lat = item['venue']['location']['lat']
lng = item['venue']['location']['lng']
cic = item['venue']['stats']['checkinsCount']
dict[(lng, lat)] = cic
return dict
def main():
client = foursquare.Foursquare(client_id=FS_CLIENT_ID,
client_secret=FS_CLIENT_SECRET)
places = client.venues.search(params={
'll': '40.7,-74.0',
'limit': '100'
})['venues']
for place in places:
print place
name = place['name']
try:
category = place['categories'][0]['shortName']
except IndexError, KeyError:
category = None
pop = 10
geotag = tweetanalysis.analyzer.GeoTag(place['location']['lat'],
place['location']['lng'])
addr = ' '.join(place['location']['formattedAddress'])
if category:
try:
models.Venue.Query.get(name=name)
print '{} already exists'.format(name)
return None
except query.QueryResourceDoesNotExist:
venue = models.Venue.build(name=name,
category=category,
pop=pop,
geotag=geotag,
addr=str(addr))
venue.save()
return venue
def __init__(self):
self.boba_places = pd.read_csv('./data/boba_final.csv')
self.client = foursquare.Foursquare(client_id='key-here',
client_secret='key-here')
self.test_data = pd.read_csv("./data/Reviews.csv")
self.log_model = self.train_model()
self.vectorizer = None
def check_consumer_tokens(service, key, secret):
""" Checks if the service tokens are ok, facebook not implemeted yet """
if key != '' and secret != '':
if service == 'Twitter':
auth = tweepy.OAuthHandler(str(key), str(secret))
try:
auth.get_authorization_url()
return True
except:
pass
if service == 'Foursquare':
client = foursquare.Foursquare(str(key), str(secret))
try:
client.oauth.auth_url()
return True
except:
pass
if service == 'Facebook':
return True
return False
def get_user_book_client(self, app, profile):
user = profile.user
book = None
token = None
client = None
try:
book = BookOwner.objects.get(user=user).book
except BookOwner.DoesNotExist:
book = None
logger.error(
"No BookOwner found for: {} ({})".format(user, user.id)
)
try:
token = SocialToken.objects.get(account__user=user, app=app)
except SocialToken.DoesNotExist:
token = None
logger.error(
"No foursquare token found for: {} ({})".format(user, user.id),
)
if token:
client = foursquare.Foursquare(access_token=token.token)
return user, book, client
def setUp(self):
self.apis = []
for lang in ('es', 'fr', 'de', 'it', 'ja', 'th', 'ko', 'ru', 'pt',
'id'):
self.apis.append(
foursquare.Foursquare(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
lang=lang))
def __init__(self, output_path=DATA_PATH + '/' + CITY + '/foursquare'):
super(FourSquareRetriever, self).__init__(output_path)
self.key = next(FOURSQUARE_KEYS_ITER)
self.output_path = output_path
self.dataset_path = self.output_path + '/venues.csv'
self.client = foursquare.Foursquare(
client_id=self.key['client_id'],
client_secret=self.key['client_secret'])
def setUp(self):
self.apis = []
for lang in ("es", "fr", "de", "it", "ja", "th", "ko", "ru", "pt", "id"):
self.apis.append(
foursquare.Foursquare(
client_id=CLIENT_ID, client_secret=CLIENT_SECRET, lang=lang
)
)
