def post(self,*args,**kwargs):
try:
twitter_id = kwargs.get('remoteID',None)
twitter_token = kwargs.get('remoteToken',None)
twitter_token_secret = kwargs.get('remoteTokenSecret',None)
logging.debug('\n\n{}\n{}\n{}\n\n'.format(
twitter_id,
twitter_token,
twitter_token_secret
)
)
user = levr.Customer.all().filter('twitter_id',twitter_id).get()
logging.debug(user)
if user:
#fallback to login
logging.debug('User exists!')
response = {
'user':api_utils.package_user(user,True,send_token=True)
}
else:
#create new user
user = social.Twitter(
twitter_id = twitter_id
)
try:
user, new_user_details, new_friends = user.first_time_connect(
twitter_id = twitter_id,
twitter_token = twitter_token,
twitter_token_secret = twitter_token_secret
)
except Exception,e:
levr.log_error()
assert False, 'Could not connect with twitter. '.format('')
#return the user
response = {
'user':api_utils.package_user(user,True,send_token=True),
'new_friends' : [enc.encrypt_key(f) for f in new_friends],
'new_user_details' : new_user_details
}
try:
if user.display_name == 'Jason K.':
from google.appengine.api import mail
mail.send_mail(sender="*****@*****.**",
to="*****@*****.**",
subject="Signup",
body='Jason signed up')
else:
levr.text_notify(user.display_name+' from Twitter!')
except:
levr.log_error()
api_utils.send_response(self,response,user)
def post(self, *args, **kwargs):
try:
twitter_id = kwargs.get('remoteID', None)
twitter_token = kwargs.get('remoteToken', None)
twitter_token_secret = kwargs.get('remoteTokenSecret', None)
logging.debug('\n\n{}\n{}\n{}\n\n'.format(twitter_id,
twitter_token,
twitter_token_secret))
user = levr.Customer.all().filter('twitter_id', twitter_id).get()
logging.debug(user)
if user:
#fallback to login
logging.debug('User exists!')
response = {
'user': api_utils.package_user(user, True, send_token=True)
}
else:
#create new user
user = social.Twitter(twitter_id=twitter_id)
try:
user, new_user_details, new_friends = user.first_time_connect(
twitter_id=twitter_id,
twitter_token=twitter_token,
twitter_token_secret=twitter_token_secret)
except Exception, e:
levr.log_error()
assert False, 'Could not connect with twitter. '.format('')
#return the user
response = {
'user': api_utils.package_user(user, True,
send_token=True),
'new_friends': [enc.encrypt_key(f) for f in new_friends],
'new_user_details': new_user_details
}
try:
if user.display_name == 'Jason K.':
from google.appengine.api import mail
mail.send_mail(sender="*****@*****.**",
to="*****@*****.**",
subject="Signup",
body='Jason signed up')
else:
levr.text_notify(user.display_name + ' from Twitter!')
except:
levr.log_error()
api_utils.send_response(self, response, user)
def get(self,*args,**kwargs):
'''
#PARTIALLY RESTRICTED
inputs:
Output:{
meta:{
success
errorMsg
}
response:{
<USER OBJECT>
}
'''
try:
logging.debug('USER INFO\n\n')
user = kwargs.get('user')
private = kwargs.get('private')
#create response object
response = {
'user' : api_utils.package_user(user,private)
}
#respond
api_utils.send_response(self,response,user)
except:
levr.log_error(self.request)
api_utils.send_error(self,'Server Error')
def get(self, *args, **kwargs):
'''
#PARTIALLY RESTRICTED
inputs:
Output:{
meta:{
success
errorMsg
}
response:{
<USER OBJECT>
}
'''
try:
logging.debug('USER INFO\n\n')
user = kwargs.get('user')
private = kwargs.get('private')
#create response object
response = {'user': api_utils.package_user(user, private)}
#respond
api_utils.send_response(self, response, user)
except:
levr.log_error(self.request)
api_utils.send_error(self, 'Server Error')
def post(self,*args,**kwargs):
#RESTRICTED
try:
#check token
facebook_token = kwargs.get('remoteToken',None)
# user = levr.Customer.all().filter('facebook_id',facebook_id).get()
user = social.Facebook(None,'verbose',facebook_token=facebook_token)
try:
new_user, new_user_details, new_friends = user.first_time_connect(
facebook_token = facebook_token,
)
except Exception,e:
levr.log_error()
assert False, 'Could not connect with facebook.'
#return the user
response = {
'user':api_utils.package_user(new_user,True,send_token=True),
'new_friends' : [enc.encrypt_key(f) for f in new_friends],
'new_user_details' : new_user_details
}
try:
levr.text_notify(new_user.display_name + 'from Facebook')
except:
levr.log_error()
api_utils.send_response(self,response,new_user)
def post(self, *args, **kwargs):
#RESTRICTED
try:
#check token
facebook_token = kwargs.get('remoteToken', None)
# user = levr.Customer.all().filter('facebook_id',facebook_id).get()
user = social.Facebook(None,
'verbose',
facebook_token=facebook_token)
try:
new_user, new_user_details, new_friends = user.first_time_connect(
facebook_token=facebook_token, )
except Exception, e:
levr.log_error()
assert False, 'Could not connect with facebook.'
#return the user
response = {
'user': api_utils.package_user(new_user, True,
send_token=True),
'new_friends': [enc.encrypt_key(f) for f in new_friends],
'new_user_details': new_user_details
}
try:
levr.text_notify(new_user.display_name + 'from Facebook')
except:
levr.log_error()
api_utils.send_response(self, response, new_user)
def post(self, *args, **kwargs):
try:
#RESTRICTED
logging.debug('CONNECT TWITTER\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
twitter_token = kwargs.get('remoteToken')
twitter_token_secret = kwargs.get('remoteTokenSecret')
twitter_id = kwargs.get('remoteID')
# development = kwargs.get('development')
user = social.Twitter(user, 'verbose')
try:
user, new_user_details, new_friends = user.first_time_connect(
twitter_id=twitter_id,
twitter_token=twitter_token,
twitter_token_secret=twitter_token_secret)
except Exception, e:
levr.log_error(e)
assert False, 'Could not connect with foursquare. '.format('')
#return the user
response = {
'user': api_utils.package_user(user, True),
'new_friends': [enc.encrypt_key(f) for f in new_friends],
'new_user_details': new_user_details
}
api_utils.send_response(self, response, user)
def post(self, *args, **kwargs):
try:
#RESTRICTED
user = kwargs.get('actor', None)
facebook_token = kwargs.get('remoteToken', None)
user = social.Facebook(user, 'verbose')
try:
user, new_user_details, new_friends = user.first_time_connect(
facebook_token=facebook_token, )
except Exception, e:
levr.log_error()
assert False, 'Could not connect with facebook.'
logging.debug(levr.log_model_props(user))
logging.debug(str(new_user_details))
#return the user
response = {
'user': api_utils.package_user(user, True),
'new_friends': [enc.encrypt_key(f) for f in new_friends],
'new_user_details': new_user_details
}
api_utils.send_response(self, response, user)
def post(self,*args,**kwargs):
try:
#RESTRICTED
user = kwargs.get('actor',None)
facebook_token = kwargs.get('remoteToken',None)
user = social.Facebook(user,'verbose')
try:
user, new_user_details, new_friends = user.first_time_connect(
facebook_token = facebook_token,
)
except Exception,e:
levr.log_error()
assert False, 'Could not connect with facebook.'
logging.debug(levr.log_model_props(user))
logging.debug(str(new_user_details))
#return the user
response = {
'user':api_utils.package_user(user,True),
'new_friends' : [enc.encrypt_key(f) for f in new_friends],
'new_user_details' : new_user_details
}
api_utils.send_response(self,response,user)
def post(self,*args,**kwargs):
try:
#RESTRICTED
logging.debug('CONNECT TWITTER\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
twitter_token = kwargs.get('remoteToken')
twitter_token_secret = kwargs.get('remoteTokenSecret')
twitter_id = kwargs.get('remoteID')
# development = kwargs.get('development')
user = social.Twitter(user,'verbose')
try:
user, new_user_details, new_friends = user.first_time_connect(
twitter_id = twitter_id,
twitter_token = twitter_token,
twitter_token_secret = twitter_token_secret
)
except Exception,e:
levr.log_error(e)
assert False, 'Could not connect with foursquare. '.format('')
#return the user
response = {
'user':api_utils.package_user(user,True),
'new_friends' : [enc.encrypt_key(f) for f in new_friends],
'new_user_details' : new_user_details
}
api_utils.send_response(self,response,user)
def get(self,*args,**kwargs):
try:
logging.info('Reporting for dudty, Captain')
#grabthe user from the input
user = kwargs.get('actor')
try:
data = api_utils.SpoofUndeadNinjaActivity(user).run()
logging.debug(levr.log_dict(data))
#set last login
user = data['user']
except:
levr.log_error()
user.date_last_login = datetime.now()
# logging.debug(user.date_last_login)
user.put()
response = {'user':api_utils.package_user(user,True)}
api_utils.send_response(self,response,user)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def post(self,*args,**kwargs):
try:
#check token
foursquare_token = kwargs.get('remoteToken',None)
user = levr.Customer.all().filter('foursquare_token',foursquare_token).get()
if user:
#fallback to login
response = {
'user':api_utils.package_user(user,True,send_token=True)
}
else:
#===============================================================
# NOTE: there is a remote chance that the users foursquare oauth_token would change.
# this would not recognize that
#===============================================================
try:
#create new user
user = social.Foursquare(
foursquare_token = foursquare_token
)
user, new_user_details, new_friends = user.first_time_connect(
foursquare_token = foursquare_token,
)
except Exception,e:
levr.log_error()
assert False, 'Could not connect with foursquare. '.format('')
#return the user
response = {
'user':api_utils.package_user(user,True,send_token=True),
'new_friends' : [enc.encrypt_key(f) for f in new_friends],
'new_user_details' : new_user_details
}
try:
levr.text_notify(user.display_name+' from Foursquare!')
except:
levr.log_error()
api_utils.send_response(self,response,user)
def get(self, *args, **kwargs):
'''
A user logs in with levr using an email or alias, and a password
'''
try:
#RESTRICTED
logging.debug('LOGIN LEVR\n\n\n')
logging.debug(kwargs)
email_or_owner = kwargs.get('email_or_owner')
pw = kwargs.get('pw')
pw = enc.encrypt_password(pw)
#check both email and password
r_email = levr.Customer.gql('WHERE email = :1 AND pw=:2',
email_or_owner, pw).get()
r_alias = levr.Customer.gql('WHERE alias = :1 AND pw=:2',
email_or_owner, pw).get()
if r_email:
#match based on email
existing_user = r_email
elif r_alias:
#match based on alias
existing_user = r_alias
else:
api_utils.send_error(self, 'Authentication failed.')
return
#create or refresh the alias
existing_user = levr.build_display_name(existing_user)
#===================================================================
# Spoof Ninja Activity!
#===================================================================
data = api_utils.SpoofUndeadNinjaActivity(existing_user).run()
logging.debug(levr.log_dict(data))
#set last login
existing_user = data['user']
#still here? update last login by putting
existing_user.put()
#package user, private setting, send token
response = {
'user':
api_utils.package_user(existing_user, True, send_token=True)
}
api_utils.send_response(self, response, existing_user)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def post(self, *args, **kwargs):
try:
#check token
foursquare_token = kwargs.get('remoteToken', None)
user = levr.Customer.all().filter('foursquare_token',
foursquare_token).get()
if user:
#fallback to login
response = {
'user': api_utils.package_user(user, True, send_token=True)
}
else:
#===============================================================
# NOTE: there is a remote chance that the users foursquare oauth_token would change.
# this would not recognize that
#===============================================================
try:
#create new user
user = social.Foursquare(foursquare_token=foursquare_token)
user, new_user_details, new_friends = user.first_time_connect(
foursquare_token=foursquare_token, )
except Exception, e:
levr.log_error()
assert False, 'Could not connect with foursquare. '.format(
'')
#return the user
response = {
'user': api_utils.package_user(user, True,
send_token=True),
'new_friends': [enc.encrypt_key(f) for f in new_friends],
'new_user_details': new_user_details
}
try:
levr.text_notify(user.display_name + ' from Foursquare!')
except:
levr.log_error()
api_utils.send_response(self, response, user)
def get(self,*args,**kwargs):
'''
A user logs in with levr using an email or alias, and a password
'''
try:
#RESTRICTED
logging.debug('LOGIN LEVR\n\n\n')
logging.debug(kwargs)
email_or_owner = kwargs.get('email_or_owner')
pw = kwargs.get('pw')
pw = enc.encrypt_password(pw)
#check both email and password
r_email = levr.Customer.gql('WHERE email = :1 AND pw=:2',email_or_owner,pw).get()
r_alias = levr.Customer.gql('WHERE alias = :1 AND pw=:2',email_or_owner,pw).get()
if r_email:
#match based on email
existing_user = r_email
elif r_alias:
#match based on alias
existing_user = r_alias
else:
api_utils.send_error(self,'Authentication failed.')
return
#create or refresh the alias
existing_user = levr.build_display_name(existing_user)
#===================================================================
# Spoof Ninja Activity!
#===================================================================
data = api_utils.SpoofUndeadNinjaActivity(existing_user).run()
logging.debug(levr.log_dict(data))
#set last login
existing_user = data['user']
#still here? update last login by putting
existing_user.put()
#package user, private setting, send token
response = {'user':api_utils.package_user(existing_user,True,send_token=True)}
api_utils.send_response(self,response,existing_user)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def post(self, *args, **kwargs):
try:
#RESTRICTED
logging.debug('CONNECT FOURSQUARE\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
foursquare_token = kwargs.get('remoteToken')
new_user_details = None
new_friends = None
#===================================================================
# Check to see if there are multiple accounts
# i.e. the user that is connecting w/ foursquare has an existing fs account with levr
#===================================================================
# check for an existing foursquare user
foursquare_user = levr.Customer.all().filter(
'foursquare_token', foursquare_token).get()
# If a user was found in the db with the requested foursquare credentials,
# and that user is not the same user as the one requesting the connection,
# merge the foursquare created account into the requesting user (i.e. the levr account user)
if foursquare_user and foursquare_user is not user:
#this means the user has multiple accounts that need to be merged
data = api_utils.merge_customer_info_from_B_into_A(
user, foursquare_user, 'foursquare')
user = data[0]
# Otherwise, act normally. Simply connect. If the user already has foursquare credentials,
# this will refresh their foursquare information
else:
#create an instance of the Foursquare social connection class
user = social.Foursquare(user, 'verbose')
try:
user, new_user_details, new_friends = user.first_time_connect(
foursquare_token=foursquare_token)
except Exception, e:
levr.log_error()
assert False, 'Could not connect with foursquare. '.format(
'')
response = {
'user': api_utils.package_user(user, True)
# 'new_friends' : [enc.encrypt_key(f) for f in new_friends],
# 'new_user_details' : new_user_details
}
if new_user_details:
response['new_user_details'] = new_user_details
if new_friends: response['new_friends'] = new_friends
api_utils.send_response(self, response, user)
def post(self,*args,**kwargs):
#RESTRICTED
try:
logging.debug(kwargs)
email = kwargs.get('email',None)
alias = kwargs.get('alias',None)
pw = kwargs.get('pw',None)
'''Check availability of username+pass, create and login if not taken'''
#check availabilities
r_email = levr.Customer.gql('WHERE email = :1',email).get()
r_alias = levr.Customer.gql('WHERE alias = :1',alias).get()
#if taken, send error
if r_email:
api_utils.send_error(self,'That email is already registered.')
return
if r_alias:
api_utils.send_error(self,'That alias is already registered.')
return
#still here? create a customer, then.
user = levr.create_new_user(
email=email,
alias=alias,
pw=enc.encrypt_password(pw))
#put and reply
#create or refresh the alias
user = levr.build_display_name(user)
try:
levr.text_notify(user.display_name+' from Levr!')
except:
levr.log_error()
#put and reply
user.put()
response = {'user':api_utils.package_user(user,True,send_token=True)}
api_utils.send_response(self,response,user)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def post(self,*args,**kwargs):
try:
#RESTRICTED
logging.debug('CONNECT FOURSQUARE\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
foursquare_token = kwargs.get('remoteToken')
new_user_details = None
new_friends = None
#===================================================================
# Check to see if there are multiple accounts
# i.e. the user that is connecting w/ foursquare has an existing fs account with levr
#===================================================================
# check for an existing foursquare user
foursquare_user = levr.Customer.all().filter('foursquare_token',foursquare_token).get()
# If a user was found in the db with the requested foursquare credentials,
# and that user is not the same user as the one requesting the connection,
# merge the foursquare created account into the requesting user (i.e. the levr account user)
if foursquare_user and foursquare_user is not user:
#this means the user has multiple accounts that need to be merged
data = api_utils.merge_customer_info_from_B_into_A(user,foursquare_user,'foursquare')
user = data[0]
# Otherwise, act normally. Simply connect. If the user already has foursquare credentials,
# this will refresh their foursquare information
else:
#create an instance of the Foursquare social connection class
user = social.Foursquare(user,'verbose')
try:
user, new_user_details, new_friends = user.first_time_connect(
foursquare_token = foursquare_token
)
except Exception,e:
levr.log_error()
assert False, 'Could not connect with foursquare. '.format('')
response = {
'user' : api_utils.package_user(user,True)
# 'new_friends' : [enc.encrypt_key(f) for f in new_friends],
# 'new_user_details' : new_user_details
}
if new_user_details: response['new_user_details'] = new_user_details
if new_friends: response['new_friends'] = new_friends
api_utils.send_response(self,response,user)
def get(self, *args, **kwargs):
'''
Get all of a users followers
#RESTRICTED
inputs:
Output:{
meta:{
success
errorMsg
}
response:{
followers:[
<USER OBJECT>
]
}
'''
try:
logging.info('GET USER FOLLOWERS\n\n\n')
logging.debug(kwargs)
user = kwargs.get('user')
# uid = user.key()
private = kwargs.get('private')
# limit = kwargs.get('limit')
# offset = kwargs.get('offset')
#PERFORM ACTIONS
#package each follower into <USER OBJECT>
followers = [
api_utils.package_user(u)
for u in levr.Customer.get(user.followers)
]
logging.debug(followers)
response = {
'numResults': followers.__len__(),
'followers': followers
}
#respond
api_utils.send_response(self, response, user)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def post(self, *args, **kwargs):
#RESTRICTED
try:
logging.debug(kwargs)
email = kwargs.get('email', None)
alias = kwargs.get('alias', None)
pw = kwargs.get('pw', None)
'''Check availability of username+pass, create and login if not taken'''
#check availabilities
r_email = levr.Customer.gql('WHERE email = :1', email).get()
r_alias = levr.Customer.gql('WHERE alias = :1', alias).get()
#if taken, send error
if r_email:
api_utils.send_error(self, 'That email is already registered.')
return
if r_alias:
api_utils.send_error(self, 'That alias is already registered.')
return
#still here? create a customer, then.
user = levr.create_new_user(email=email,
alias=alias,
pw=enc.encrypt_password(pw))
#put and reply
#create or refresh the alias
user = levr.build_display_name(user)
try:
levr.text_notify(user.display_name + ' from Levr!')
except:
levr.log_error()
#put and reply
user.put()
response = {
'user': api_utils.package_user(user, True, send_token=True)
}
api_utils.send_response(self, response, user)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def get(self,*args,**kwargs):
'''
Get all of a users followers
#RESTRICTED
inputs:
Output:{
meta:{
success
errorMsg
}
response:{
followers:[
<USER OBJECT>
]
}
'''
try:
logging.info('GET USER FOLLOWERS\n\n\n')
logging.debug(kwargs)
user = kwargs.get('user')
# uid = user.key()
private = kwargs.get('private')
# limit = kwargs.get('limit')
# offset = kwargs.get('offset')
#PERFORM ACTIONS
#package each follower into <USER OBJECT>
followers = [api_utils.package_user(u) for u in levr.Customer.get(user.followers)]
logging.debug(followers)
response = {
'numResults' : followers.__len__(),
'followers' : followers
}
#respond
api_utils.send_response(self,response,user)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def get(self, *args, **kwargs):
'''
Get all of a users uploaded deals
inputs: limit(optional), offset(optional)
response:{
deal: <DEAL OBJECT>
}
'''
try:
logging.info("\n\nGET USER UPLOADS")
logging.debug(kwargs)
user = kwargs.get('user')
uid = user.key()
private = kwargs.get('private')
limit = kwargs.get('limit')
offset = kwargs.get('offset')
#grab all deals that are owned by the specified customer
deals = levr.Deal.all().ancestor(uid).fetch(limit, offset=offset)
#package up the dealios
packaged_deals = [
api_utils.package_deal(deal, private) for deal in deals
]
#package the user object
packaged_user = api_utils.package_user(user, private)
#create response object
response = {
'numResults': str(packaged_deals.__len__()),
'deals': packaged_deals,
'user': packaged_user
}
#respond
api_utils.send_response(self, response, user)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def get(self,*args,**kwargs):
'''
Get all of a users uploaded deals
inputs: limit(optional), offset(optional)
response:{
deal: <DEAL OBJECT>
}
'''
try:
logging.info("\n\nGET USER UPLOADS")
logging.debug(kwargs)
user = kwargs.get('user')
uid = user.key()
private = kwargs.get('private')
limit = kwargs.get('limit')
offset = kwargs.get('offset')
#grab all deals that are owned by the specified customer
deals = levr.Deal.all().ancestor(uid).fetch(limit,offset=offset)
#package up the dealios
packaged_deals = [api_utils.package_deal(deal,private) for deal in deals]
#package the user object
packaged_user = api_utils.package_user(user,private)
#create response object
response = {
'numResults': str(packaged_deals.__len__()),
'deals' : packaged_deals,
'user' : packaged_user
}
#respond
api_utils.send_response(self,response,user)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def get(self, *args, **kwargs):
try:
logging.info('Reporting for dudty, Captain')
#grabthe user from the input
user = kwargs.get('actor')
try:
data = api_utils.SpoofUndeadNinjaActivity(user).run()
logging.debug(levr.log_dict(data))
#set last login
user = data['user']
except:
levr.log_error()
user.date_last_login = datetime.now()
# logging.debug(user.date_last_login)
user.put()
response = {'user': api_utils.package_user(user, True)}
api_utils.send_response(self, response, user)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def get(self,*args,**kwargs):
try:
contentID = args[0]
#spoof the contentID
#contentID='85ff49d2dcb94b99973c5a2b16c5df36'
#grab the associated floating content
floating_content = levr.FloatingContent.gql('WHERE contentID=:1',contentID).get()
action = floating_content.action
response = {'action':action}
if action == 'upload':
business = floating_content.business
assert business, 'Business could not be found'
#echo back the business
response.update({'business':api_utils.package_business(business)})
elif action == 'deal':
deal = floating_content.deal
assert deal,'Deal could not be found'
#echo bcak the deal
packaged_deals = [api_utils.package_deal(deal)]
response.update({'deals':packaged_deals})
user = floating_content.user
assert user, 'Could not find user'
#respond, and include levr_token
response.update({'user':api_utils.package_user(user,send_token=True)})
api_utils.send_response(self,response)
except AssertionError,e:
levr.log_error(e)
api_utils.send_error(self,e.message)
def get(self, *args, **kwargs):
try:
contentID = args[0]
#spoof the contentID
#contentID='85ff49d2dcb94b99973c5a2b16c5df36'
#grab the associated floating content
floating_content = levr.FloatingContent.gql(
'WHERE contentID=:1', contentID).get()
action = floating_content.action
response = {'action': action}
if action == 'upload':
business = floating_content.business
assert business, 'Business could not be found'
#echo back the business
response.update(
{'business': api_utils.package_business(business)})
elif action == 'deal':
deal = floating_content.deal
assert deal, 'Deal could not be found'
#echo bcak the deal
packaged_deals = [api_utils.package_deal(deal)]
response.update({'deals': packaged_deals})
user = floating_content.user
assert user, 'Could not find user'
#respond, and include levr_token
response.update(
{'user': api_utils.package_user(user, send_token=True)})
api_utils.send_response(self, response)
except AssertionError, e:
levr.log_error(e)
api_utils.send_error(self, e.message)
def post(self, *args, **kwargs): #@UnusedVariable
'''
Checks for existing account with that business
If the account exists, return true
@attention: Only handles the case where a single account is tied to no more than one business
@keyword email: required
@keyword password: required
@keyword business_name: required
@keyword vicinity: required
@keyword geo_point: required
@keyword types: require
@keyword development: optional
@return: packaged_user with levrToken, packaged_business
'''
# for invalid credential responses
user_doesnt_own_business_message = 'User does not own that business'
# for packaging
private = True
followers = False
# input values
email = kwargs.get('email')
password = kwargs.get('pw')
business_name = kwargs.get('businessName')
vicinity = kwargs.get('vicinity')
geo_point = kwargs.get('geoPoint')
types = kwargs.get('types')
development = kwargs.get(
'development', False
) # TODO: switch this to False by default when changing to live
phone_number = kwargs.get('phoneNumber', '')
try:
# Convert input data
password = enc.encrypt_password(password)
types = types.split(',')
logging.debug('{}\n{}\n{}\n{}'.format(repr(business_name),
repr(vicinity), geo_point,
repr(types)))
# check for existing entities
user = levr.Customer.all().filter('email', email).get()
requested_business = levr.Business.all().filter(
'business_name', business_name).filter('vicinity',
vicinity).get()
if user:
logging.info('User exists')
# check password
assert user.pw == password, 'Password does not match username'
# user should have a business
try:
business = user.businesses.get()
# if the user has a business, it should be the business that was requested
assert business, 'User does not own any businesses yet'
except:
logging.debug(
'user does not have a business yet - create one')
# if the user does not have a business yet, add this one.
business = levr.create_new_business(business_name,
vicinity,
geo_point,
types,
phone_number,
owner=user)
# assert False, user_doesnt_own_business_message
else:
logging.debug('User owns a business')
# logging.debug(levr.log_model_props(business.owner))
# logging.debug(levr.log_model_props(requested_business.owner))
# if requested_business:
# assert business.key() == requested_business.key(), user_doesnt_own_business_message
else:
logging.debug('User does not exist. Create a new one!!')
# Create an account for the user with that business
user = levr.create_new_user(
tester=development,
pw=password,
email=email,
display_name=business_name,
)
logging.debug(business_name)
logging.debug(levr.log_model_props(user))
if not requested_business:
logging.debug('requested business was not found')
business = levr.create_new_business(business_name,
vicinity,
geo_point,
types,
phone_number,
owner=user)
else:
logging.debug('requested business was found')
business = requested_business
#
business.owner = user
business.put()
logging.debug('business: ' + repr(business))
#===================================================================
# # Send message to the founders that someone has signed up for the app
#===================================================================
if not development:
try:
from google.appengine.api import mail
message = mail.AdminEmailMessage(
sender='*****@*****.**',
subject='New Merchant',
)
message.body = levr.log_model_props(
user, [
'email',
'display_name',
])
message.body += levr.log_model_props(
business, ['business_name', 'vicinity'])
message.check_initialized()
message.send()
except:
levr.log_error()
#===================================================================
# # package and send
#===================================================================
packaged_user = api_utils.package_user(user,
private,
followers,
send_token=True)
packaged_business = api_utils.package_business(business)
response = {'user': packaged_user, 'business': packaged_business}
self.send_response(response)
# TODO: Merchant connect - handle all cases - new and existing accounts
except AssertionError, e:
levr.log_error()
self.send_error(e)
def get(self,*args,**kwargs): #@UnusedVariable
'''
inputs: lat,lon,limit, query
response:{
[string,string]
}
/api/search/all?
lat=42.357632
&lon=-71.089432
&limit=50
&offset=0
&uid=tAvwdQhJqgEn8hL7fD1phb9z_c-GNGaQXr0fO3GJdErv19TaoeLGNiu51St9sfoYChA=
&levrToken=7ALUawsTs1R3_z_pK0YTx4cCkpfSFzuDCOM1XQCXWDM
&latitudeHalfDelta=0.023277
&longitudeHalfDelta=0.027466
'''
try:
tstart = datetime.now()
logging.debug('SEARCH BY QUERY \n\n\n')
# logging.debug(kwargs)
#GET PARAMS
logging.info(kwargs)
#assert False
geo_point = kwargs.get('geoPoint')
# radius = kwargs.get('radius')
# limit = kwargs.get('limit')
query = kwargs.get('query','all')
development = kwargs.get('development',False)
user = kwargs.get('actor')
lon_half_delta = kwargs.get('longitudeHalfDelta',0)
# lat_half_delta = kwargs.get('latitudeHalfDelta')
try:
logging.info(user.display_name)
except:
logging.info('unkown user')
times = {}
search = api_utils.Search(development,user)
# calc precision
precision = search.calc_precision_from_half_deltas(geo_point, lon_half_delta)
# create ghashes
ghash_list = search.create_ghash_list(geo_point, precision)
# calc bounding box
bounding_box = search.calc_bounding_box(ghash_list)
# fetch all deals in the ghash range
t1 = datetime.now()
deals = search.fetch_deals(ghash_list)
times.update({'fetch_deals_time':str(datetime.now() - t1)})
# filter deals by search query
t1 = datetime.now()
num_results,accepted_deals= search.filter_deals_by_query(deals, query)
times.update({'filter_deals_time': str(datetime.now() - t1)})
# increment deal views on levr deals
search.add_deal_views(deals)
# init package time
if query != 'all' and accepted_deals.__len__() != 0:
t1 = datetime.now()
packaged_deals = search.sort_and_package(accepted_deals)
package_time = datetime.now()-t1
else:
# act like a search all, use all deals
# decompose deals by origin
levr_deals, foursquare_deals = search.filter_deals_by_origin(deals)
if levr_deals.__len__() >5:
t1 = datetime.now()
packaged_deals = search.sort_and_package(levr_deals)
package_time = datetime.now()-t1
# qualify search results. do we need more?
else:
t1 = datetime.now()
packaged_deals = search.sort_and_package(deals)
package_time = datetime.now()-t1
# add foursquare deals
if foursquare_deals.__len__() < 5:
# search for more foursquare deals
try:
# grab search information
token = search.foursquare_token
deal_status = search.deal_status
foursquare_ids = search.get_foursquare_ids(deals)
# make remote call to foursquare
ft1 = datetime.now()
new_foursquare_deals = api_utils.search_foursquare(geo_point,token,deal_status,foursquare_ids)
times.update({'foursquare_search_time':str(datetime.now()-ft1)})
# add new foursquare deals
packaged_deals.extend(new_foursquare_deals)
except:
levr.log_error('Error in foursquare call or parsing.')
times.update({'package_time':package_time})
# else:
# params = {
# 'lat' : geo_point.lat,
# 'lon' : geo_point.lon,
# 'token' : token,
# 'foursquare_ids': foursquare_ids,
# 'deal_status' : deal_status
# }
#
# logging.debug('Sending this to the task: ' + json.dumps(params))
#
# #start the task
# taskqueue.add(url='/tasks/searchFoursquareTask',payload=json.dumps(params))
times.update({'total_time':datetime.now()-tstart})
#===================================================================
# Send response
#===================================================================
logging.info(levr.log_dict(times))
times = {key:str(times[key]) for key in times}
response = {
'searchPoint' : str(geo_point),
'numResults' : num_results,
'boundingBox' : bounding_box,
# 'ending_hashes' : list(searched_hash_set),
'num_total_results' : packaged_deals.__len__(),
'deals' : packaged_deals,
'times' : times
}
try:
response.update({
'user' : api_utils.package_user(self.user, True, False)
})
except:
logging.info('user not passed')
# assert False, response
self.send_response(response)
except:
levr.log_error()
self.send_error()
def get(self, *args, **kwargs): #@UnusedVariable
'''
inputs: lat,lon,limit, query
response:{
[string,string]
}
/api/search/all?
lat=42.357632
&lon=-71.089432
&limit=50
&offset=0
&uid=tAvwdQhJqgEn8hL7fD1phb9z_c-GNGaQXr0fO3GJdErv19TaoeLGNiu51St9sfoYChA=
&levrToken=7ALUawsTs1R3_z_pK0YTx4cCkpfSFzuDCOM1XQCXWDM
&latitudeHalfDelta=0.023277
&longitudeHalfDelta=0.027466
'''
try:
tstart = datetime.now()
logging.debug('SEARCH BY QUERY \n\n\n')
# logging.debug(kwargs)
#GET PARAMS
logging.info(kwargs)
#assert False
geo_point = kwargs.get('geoPoint')
# radius = kwargs.get('radius')
# limit = kwargs.get('limit')
query = kwargs.get('query', 'all')
development = kwargs.get('development', False)
user = kwargs.get('actor')
lon_half_delta = kwargs.get('longitudeHalfDelta', 0)
# lat_half_delta = kwargs.get('latitudeHalfDelta')
try:
logging.info(user.display_name)
except:
logging.info('unkown user')
times = {}
search = api_utils.Search(development, user)
# calc precision
precision = search.calc_precision_from_half_deltas(
geo_point, lon_half_delta)
# create ghashes
ghash_list = search.create_ghash_list(geo_point, precision)
# calc bounding box
bounding_box = search.calc_bounding_box(ghash_list)
# fetch all deals in the ghash range
t1 = datetime.now()
deals = search.fetch_deals(ghash_list)
times.update({'fetch_deals_time': str(datetime.now() - t1)})
# filter deals by search query
t1 = datetime.now()
num_results, accepted_deals = search.filter_deals_by_query(
deals, query)
times.update({'filter_deals_time': str(datetime.now() - t1)})
# increment deal views on levr deals
search.add_deal_views(deals)
# init package time
if query != 'all' and accepted_deals.__len__() != 0:
t1 = datetime.now()
packaged_deals = search.sort_and_package(accepted_deals)
package_time = datetime.now() - t1
else:
# act like a search all, use all deals
# decompose deals by origin
levr_deals, foursquare_deals = search.filter_deals_by_origin(
deals)
if levr_deals.__len__() > 5:
t1 = datetime.now()
packaged_deals = search.sort_and_package(levr_deals)
package_time = datetime.now() - t1
# qualify search results. do we need more?
else:
t1 = datetime.now()
packaged_deals = search.sort_and_package(deals)
package_time = datetime.now() - t1
# add foursquare deals
if foursquare_deals.__len__() < 5:
# search for more foursquare deals
try:
# grab search information
token = search.foursquare_token
deal_status = search.deal_status
foursquare_ids = search.get_foursquare_ids(deals)
# make remote call to foursquare
ft1 = datetime.now()
new_foursquare_deals = api_utils.search_foursquare(
geo_point, token, deal_status, foursquare_ids)
times.update({
'foursquare_search_time':
str(datetime.now() - ft1)
})
# add new foursquare deals
packaged_deals.extend(new_foursquare_deals)
except:
levr.log_error(
'Error in foursquare call or parsing.')
times.update({'package_time': package_time})
# else:
# params = {
# 'lat' : geo_point.lat,
# 'lon' : geo_point.lon,
# 'token' : token,
# 'foursquare_ids': foursquare_ids,
# 'deal_status' : deal_status
# }
#
# logging.debug('Sending this to the task: ' + json.dumps(params))
#
# #start the task
# taskqueue.add(url='/tasks/searchFoursquareTask',payload=json.dumps(params))
times.update({'total_time': datetime.now() - tstart})
#===================================================================
# Send response
#===================================================================
logging.info(levr.log_dict(times))
times = {key: str(times[key]) for key in times}
response = {
'searchPoint': str(geo_point),
'numResults': num_results,
'boundingBox': bounding_box,
# 'ending_hashes' : list(searched_hash_set),
'num_total_results': packaged_deals.__len__(),
'deals': packaged_deals,
'times': times
}
try:
response.update(
{'user': api_utils.package_user(self.user, True, False)})
except:
logging.info('user not passed')
# assert False, response
self.send_response(response)
except:
levr.log_error()
self.send_error()
def post(self,*args,**kwargs): #@UnusedVariable
'''
Checks for existing account with that business
If the account exists, return true
@attention: Only handles the case where a single account is tied to no more than one business
@keyword email: required
@keyword password: required
@keyword business_name: required
@keyword vicinity: required
@keyword geo_point: required
@keyword types: require
@keyword development: optional
@return: packaged_user with levrToken, packaged_business
'''
# for invalid credential responses
user_doesnt_own_business_message = 'User does not own that business'
# for packaging
private = True
followers = False
# input values
email = kwargs.get('email')
password = kwargs.get('pw')
business_name = kwargs.get('businessName')
vicinity = kwargs.get('vicinity')
geo_point = kwargs.get('geoPoint')
types = kwargs.get('types')
development = kwargs.get('development',False) # TODO: switch this to False by default when changing to live
phone_number = kwargs.get('phoneNumber','')
try:
# Convert input data
password = enc.encrypt_password(password)
types = types.split(',')
logging.debug('{}\n{}\n{}\n{}'.format(repr(business_name),repr(vicinity),geo_point,repr(types)))
# check for existing entities
user = levr.Customer.all().filter('email',email).get()
requested_business = levr.Business.all().filter('business_name',business_name).filter('vicinity',vicinity).get()
if user:
logging.info('User exists')
# check password
assert user.pw == password, 'Password does not match username'
# user should have a business
try:
business = user.businesses.get()
# if the user has a business, it should be the business that was requested
assert business, 'User does not own any businesses yet'
except:
logging.debug('user does not have a business yet - create one')
# if the user does not have a business yet, add this one.
business = levr.create_new_business(business_name,vicinity,geo_point,types,phone_number,
owner=user
)
# assert False, user_doesnt_own_business_message
else:
logging.debug('User owns a business')
# logging.debug(levr.log_model_props(business.owner))
# logging.debug(levr.log_model_props(requested_business.owner))
# if requested_business:
# assert business.key() == requested_business.key(), user_doesnt_own_business_message
else:
logging.debug('User does not exist. Create a new one!!')
# Create an account for the user with that business
user = levr.create_new_user(
tester=development,
pw=password,
email=email,
display_name=business_name,
)
logging.debug(business_name)
logging.debug(levr.log_model_props(user))
if not requested_business:
logging.debug('requested business was not found')
business = levr.create_new_business(business_name,vicinity,geo_point,types,phone_number,
owner=user
)
else:
logging.debug('requested business was found')
business = requested_business
#
business.owner = user
business.put()
logging.debug('business: '+repr(business))
#===================================================================
# # Send message to the founders that someone has signed up for the app
#===================================================================
if not development:
try:
from google.appengine.api import mail
message = mail.AdminEmailMessage(
sender = '*****@*****.**',
subject = 'New Merchant',
)
message.body = levr.log_model_props(user,['email','display_name',])
message.body += levr.log_model_props(business,['business_name','vicinity'])
message.check_initialized()
message.send()
except:
levr.log_error()
#===================================================================
# # package and send
#===================================================================
packaged_user = api_utils.package_user(user, private, followers,send_token=True)
packaged_business = api_utils.package_business(business)
response = {
'user' : packaged_user,
'business' : packaged_business
}
self.send_response(response)
# TODO: Merchant connect - handle all cases - new and existing accounts
except AssertionError,e:
levr.log_error()
self.send_error(e)
