def get(self,*args,**kwargs):
'''
Input: uid
response: {}
'''
try:
logging.debug('DELETE FAVORITE\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
deal = kwargs.get('deal')
# uid = user.key()
dealID = deal.key()
#if the deal is in the users favorites, remove it. else do nothing
if dealID in user.favorites:
user.favorites.remove(dealID)
#replace entities
db.put(user)
response = {}
api_utils.send_response(self,response,user)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def get(self, *args, **kwargs):
'''
Get information about a deal.
Input: None
Output:{
meta:{
success
errorMsg
}
response:{
<DEAL OBJECT>
}
}
'''
try:
logging.debug('DEAL INFO\n\n\n')
logging.debug(kwargs)
deal = kwargs.get('deal')
private = kwargs.get('private')
assert deal, 'Deal could not be found'
response = {'deal': api_utils.package_deal(deal, private)}
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:
logging.info('fetchUploadURL\n\n\n')
logging.debug(kwargs)
user = kwargs.get('user')
#create blobstore user
upload_url = blobstore.create_upload_url('/api/upload/post')
logging.debug(upload_url)
if os.environ['SERVER_SOFTWARE'].startswith('Development') == True:
#we are on the development environment
URL = 'http://0.0.0.0:8080/'
else:
#we are deployed on the server
URL = 'levr.com/'
#create share url
share_url = URL + levr.create_unique_id()
response = {'uploadURL': upload_url, 'shareURL': share_url}
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 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): #@UnusedVariable
'''
@keyword actor: required
@keyword deal: required
@keyword development: required
@requires: user is the owner of the deal
@return: success
@rtype: Boolean
'''
user = kwargs.get('actor')
deal = kwargs.get('deal')
# development = kwargs.get('development')
try:
#assure that this user does own the deal
assert deal.parent_key() == user.key()
deal.reanimate()
deal.put()
# TODO: this should package all of the deals
private = True
packaged_deal = api_utils.package_deal(deal, private)
response = {'deal': packaged_deal}
api_utils.send_response(self, response, user)
except AssertionError, e:
self.send_error(e)
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):
'''
Get information about a deal.
Input: None
Output:{
meta:{
success
errorMsg
}
response:{
<DEAL OBJECT>
}
}
'''
try:
logging.debug('DEAL INFO\n\n\n')
logging.debug(kwargs)
deal = kwargs.get('deal')
private = kwargs.get('private')
assert deal, 'Deal could not be found'
response = {
'deal' : api_utils.package_deal(deal,private)
}
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
'''
@keyword actor:
@keyword deal:
@requires: user is the owner of the deal
@return: Success
@rtype: bool
'''
user = kwargs.get('actor')
deal = kwargs.get('deal')
try:
# assure that the user is the owner of the deal
assert deal.parent_key() == user.key(), 'User does not own that deal'
# expire the deal without a notification only if active
if deal.deal_status == levr.DEAL_STATUS_ACTIVE \
or deal.deal_status == levr.DEAL_STATUS_TEST:
deal.expire()
deal.put()
# otherwise, do nothing.
private = True
packaged_deal = api_utils.package_deal(deal, private)
response = {
'deal' : packaged_deal
}
api_utils.send_response(self,response, user)
except AssertionError,e:
self.send_error(e)
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): #@UnusedVariable
'''
@keyword actor: required
@keyword deal: required
@keyword development: required
@requires: user is the owner of the deal
@return: success
@rtype: Boolean
'''
user = kwargs.get('actor')
deal = kwargs.get('deal')
# development = kwargs.get('development')
try:
#assure that this user does own the deal
assert deal.parent_key() == user.key()
deal.reanimate()
deal.put()
# TODO: this should package all of the deals
private = True
packaged_deal = api_utils.package_deal(deal, private)
response = {
'deal' : packaged_deal
}
api_utils.send_response(self,response, user)
except AssertionError,e:
self.send_error(e)
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 get(self,*args,**kwargs): #@UnusedVariable
'''
@keyword actor:
@keyword action: if the deal will be a new deal or if it will be edited
@return: url
@rtype: string
'''
user = kwargs.get('actor')
action = kwargs.get('action')
try:
if action == 'add':
upload_url = blobstore.create_upload_url(NEW_DEAL_UPLOAD_URL)
elif action == 'edit':
upload_url = blobstore.create_upload_url(EDIT_DEAL_UPLOAD_URL)
else:
raise KeyError('Action not recognized: '+str(action))
response = {
'uploadURL' : upload_url
}
api_utils.send_response(self,response,user)
except KeyError,e:
self.send_error(e)
def post(self, *args, **kwargs): #@UnusedVariable
'''
@keyword actor:
@keyword deal:
@requires: user is the owner of the deal
@return: Success
@rtype: bool
'''
user = kwargs.get('actor')
deal = kwargs.get('deal')
try:
# assure that the user is the owner of the deal
assert deal.parent_key() == user.key(
), 'User does not own that deal'
# expire the deal without a notification only if active
if deal.deal_status == levr.DEAL_STATUS_ACTIVE \
or deal.deal_status == levr.DEAL_STATUS_TEST:
deal.expire()
deal.put()
# otherwise, do nothing.
private = True
packaged_deal = api_utils.package_deal(deal, private)
response = {'deal': packaged_deal}
api_utils.send_response(self, response, user)
except AssertionError, e:
self.send_error(e)
def get(self, *args, **kwargs):
try:
logging.info("fetchUploadURL\n\n\n")
logging.debug(kwargs)
user = kwargs.get("user")
# create blobstore user
upload_url = blobstore.create_upload_url("/api/upload/post")
logging.debug(upload_url)
if os.environ["SERVER_SOFTWARE"].startswith("Development") == True:
# we are on the development environment
URL = "http://0.0.0.0:8080/"
else:
# we are deployed on the server
URL = "levr.com/"
# create share url
share_url = URL + levr.create_unique_id()
response = {"uploadURL": upload_url, "shareURL": share_url}
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):
'''
Input: uid
response: {}
'''
try:
logging.debug('DELETE FAVORITE\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
deal = kwargs.get('deal')
# uid = user.key()
dealID = deal.key()
#if the deal is in the users favorites, remove it. else do nothing
if dealID in user.favorites:
user.favorites.remove(dealID)
#replace entities
db.put(user)
response = {}
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:
#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 get(self, *args, **kwargs):
'''
/user/uid/favorites
Get all of a users favorite deals
inputs:
response:{
numResults: <int>
deals: [<deal>,<deal>]
}
'''
#RESTRICTED
try:
logging.info("\n\nGET USER FAVORITES")
logging.info(kwargs)
logging.info(args)
user = kwargs.get('user')
# uid = user.key()
private = kwargs.get('private')
limit = kwargs.get('limit')
offset = kwargs.get('offset')
#grab all favorites
favorites = user.favorites
#check list is longer than offset
if favorites.__len__() > offset:
#grab list from offset to end
favorites = favorites[offset:]
#check list is longer than limit
if favorites.__len__() > limit:
#there are more favorites than the limit requests so shorten favorites
favorites = favorites[:limit]
#fetch all favorite entities
favorites = levr.Deal.get(favorites)
deals = []
#package each deal object
for deal in favorites:
if deal:
deals.append(api_utils.package_deal(deal, False))
else:
#favorites is either empty or the offset is past the length of it
deals = []
#create response object
response = {'numResults': str(favorites.__len__()), 'deals': deals}
logging.debug(response)
#respond
api_utils.send_response(self, response, user)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def post(self):
#curl --data 'businessName=alonsostestbusiness&vicinity=testVicinity&phone=%2B16052610083&geoPoint=-71.234,43.2345' http://www.levr.com/api/merchant/initialize | python -mjson.tool
'''REMEMBER PHONE NUMBER FORMATTING STUFF'''
api_utils.send_error(
self,
'Hey ethan. Ask alonso about the formatting of the phone number.')
return
#Grab incoming merchant data
business_name = self.request.get('businessName')
if business_name == '':
api_utils.send_error(
self, 'Required parameter not passed: businessName')
return
vicinity = self.request.get('vicinity')
if vicinity == '':
api_utils.send_error(self,
'Required parameter not passed: vicinity')
return
phone = self.request.get('phone')
if phone == '':
api_utils.send_error(self, 'Required parameter not passed: phone')
return
geo_point = self.request.get('geoPoint')
if geo_point == '':
api_utils.send_error(self,
'Required parameter not passed: geo_point')
return
#check if business entity already exists based on phone number
business = levr.Business.gql('WHERE business_name = :1 AND phone = :2',
business_name, phone).get()
if business:
#if a business has been created and an owner has been set, return an error
if business.owner:
logging.info('Owner is set!')
api_utils.send_error(
self,
'That business has already been verified. If you need help, email [email protected]'
)
return
#if a business has been created but no owner has been set, return the business
else:
logging.debug('Creating a new business.')
#create a new business entity with no owner
business = levr.Business()
business.business_name = business_name
business.vicinity = vicinity
business.phone = phone
business.geo_point = levr.geo_converter(geo_point)
business.activation_code = str(int(time.time()))[-4:]
#put
business.put()
#reply with business object
response = {'business': api_utils.package_business(business)}
api_utils.send_response(self, response)
def get(self, *args, **kwargs):
'''
Input: uid
'''
try:
logging.debug("REPORT\n\n\n")
logging.debug(kwargs)
user = kwargs.get('actor')
deal = kwargs.get('deal')
uid = user.key()
dealID = deal.key()
#create report Entity
levr.ReportedDeal(uid=uid, dealID=dealID).put()
#is it a foursquare deal that got reported?
if deal.origin == 'foursquare':
#get the business
business = levr.Business.get(deal.businessID)
#get the business' foursquare ID
foursquare_id = business.foursquare_id
#is the user a foursquare user?
if user.foursquare_token > '':
token = user.foursquare_token
else:
token = 'random'
#fire off a task to review the foursquare deals for this business
task_params = {
'foursquare_id': foursquare_id,
'token': token,
'deal_id': str(deal.key()),
'uid': str(user.key()),
'deal_status': deal.deal_status
}
taskqueue.add(url='/tasks/foursquareDealUpdateTask',
payload=json.dumps(task_params))
#send notification via email
message = mail.EmailMessage(
sender="LEVR AUTOMATED <*****@*****.**>",
subject="New Reported Deal",
to="*****@*****.**")
logging.debug(message)
body = 'New Reported Deal\n\n'
body += levr.log_model_props(user, ['email', 'display_name', ''])
body += str(user.email) + ' is reporting ' + str(deal.deal_text)
message.body = body
logging.debug(message.body)
message.send()
api_utils.send_response(self, {}, user)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def get(self):
try:
promotions = [promo.PROMOTIONS[key] for key in promo.PROMOTIONS]
response = {'promotions': promotions}
api_utils.send_response(self, response)
except AssertionError, e:
self.send_error(e)
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):
'''
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 get(self):
try:
promotions = [promo.PROMOTIONS[key] for key in promo.PROMOTIONS]
response = {
'promotions' : promotions
}
api_utils.send_response(self,response)
except AssertionError,e:
self.send_error(e)
def post(self):
#curl --data 'businessName=alonsostestbusiness&vicinity=testVicinity&phone=%2B16052610083&geoPoint=-71.234,43.2345' http://www.levr.com/api/merchant/initialize | python -mjson.tool
'''REMEMBER PHONE NUMBER FORMATTING STUFF'''
api_utils.send_error(self,'Hey ethan. Ask alonso about the formatting of the phone number.')
return
#Grab incoming merchant data
business_name = self.request.get('businessName')
if business_name == '':
api_utils.send_error(self,'Required parameter not passed: businessName')
return
vicinity = self.request.get('vicinity')
if vicinity == '':
api_utils.send_error(self,'Required parameter not passed: vicinity')
return
phone = self.request.get('phone')
if phone == '':
api_utils.send_error(self,'Required parameter not passed: phone')
return
geo_point = self.request.get('geoPoint')
if geo_point == '':
api_utils.send_error(self,'Required parameter not passed: geo_point')
return
#check if business entity already exists based on phone number
business = levr.Business.gql('WHERE business_name = :1 AND phone = :2',business_name,phone).get()
if business:
#if a business has been created and an owner has been set, return an error
if business.owner:
logging.info('Owner is set!')
api_utils.send_error(self,'That business has already been verified. If you need help, email [email protected]')
return
#if a business has been created but no owner has been set, return the business
else:
logging.debug('Creating a new business.')
#create a new business entity with no owner
business = levr.Business()
business.business_name = business_name
business.vicinity = vicinity
business.phone = phone
business.geo_point = levr.geo_converter(geo_point)
business.activation_code = str(int(time.time()))[-4:]
#put
business.put()
#reply with business object
response = {'business':api_utils.package_business(business)}
api_utils.send_response(self,response)
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:
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):
'''
A user (specified in ?uid=USER_ID) stops following the user specified in (/api/USER_ID/follow)
If the user is not a follower and they request to unfollow, then nothing happens and success is true
inputs: followerID(required)
Output:{
meta:{
success
errorMsg
}
'''
try:
logging.info('\n\nUSER REMOVE FOLLOWER')
logging.debug(kwargs)
user = kwargs.get('user')
# uid = user.key()
actor = kwargs.get('actor')
actorID = actor.key()
private = kwargs.get('private')
#PERFORM ACTIONS
#grab a list of existing followers
old_followers = user.followers
logging.debug(old_followers)
#check if in list of existing followers
if actorID in old_followers:
logging.debug('Follower exists')
#create new list of followers that excludes the requested id
new_followers = [u for u in old_followers if u != actorID]
logging.debug(new_followers)
#replace list of followers
user.followers = new_followers
#replace user that lost a follower
db.put(user)
else:
logging.debug('follower does not exist. Do nothing')
#respond
api_utils.send_response(self,{},actor)
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):
'''
A user (specified in ?uid=USER_ID) stops following the user specified in (/api/USER_ID/follow)
If the user is not a follower and they request to unfollow, then nothing happens and success is true
inputs: followerID(required)
Output:{
meta:{
success
errorMsg
}
'''
try:
logging.info('\n\nUSER REMOVE FOLLOWER')
logging.debug(kwargs)
user = kwargs.get('user')
# uid = user.key()
actor = kwargs.get('actor')
actorID = actor.key()
private = kwargs.get('private')
#PERFORM ACTIONS
#grab a list of existing followers
old_followers = user.followers
logging.debug(old_followers)
#check if in list of existing followers
if actorID in old_followers:
logging.debug('Follower exists')
#create new list of followers that excludes the requested id
new_followers = [u for u in old_followers if u != actorID]
logging.debug(new_followers)
#replace list of followers
user.followers = new_followers
#replace user that lost a follower
db.put(user)
else:
logging.debug('follower does not exist. Do nothing')
#respond
api_utils.send_response(self, {}, actor)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def get(self, *args, **kwargs):
'''
#RESTRICTED
inputs: limit,offset,since
response:{
numResults : <int>
notifications:[
<NOTIFICATION OBJECT>
]
}
'''
try:
logging.info('NOTIFICATIONS\n\n\n')
logging.debug('NOTIFICATIONS\n\n\n')
logging.debug(kwargs)
user = kwargs.get('user')
private = kwargs.get('private')
sinceDate = kwargs.get('since')
logging.debug('sinceDate: ' + str(sinceDate))
logging.debug('last notified: ' + str(user.last_notified))
#get notifications
notifications = user.get_notifications(sinceDate)
logging.debug('notifications: ' + str(notifications.__len__()))
#package up the notifications
packaged_notifications = [
api_utils.package_notification(n) for n in notifications
]
response = {
'numResults': packaged_notifications.__len__(),
'notifications': packaged_notifications
}
api_utils.send_response(self, response)
# logging.debug(notes)
#replace user
#!!!!!!!IMPORTANT!!!!
user.put()
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):
'''
#RESTRICTED
inputs: limit,offset,since
response:{
numResults : <int>
notifications:[
<NOTIFICATION OBJECT>
]
}
'''
try:
logging.info('NOTIFICATIONS\n\n\n')
logging.debug('NOTIFICATIONS\n\n\n')
logging.debug(kwargs)
user = kwargs.get('user')
private = kwargs.get('private')
sinceDate = kwargs.get('since')
logging.debug('sinceDate: '+str(sinceDate))
logging.debug('last notified: '+str(user.last_notified))
#get notifications
notifications = user.get_notifications(sinceDate)
logging.debug('notifications: '+str(notifications.__len__()))
#package up the notifications
packaged_notifications = [api_utils.package_notification(n) for n in notifications]
response = {
'numResults' : packaged_notifications.__len__(),
'notifications' : packaged_notifications
}
api_utils.send_response(self,response)
# logging.debug(notes)
#replace user
#!!!!!!!IMPORTANT!!!!
user.put()
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): #@UnusedVariable
user = kwargs.get('actor')
promotion_id = kwargs.get('promotionID')
deal = kwargs.get('deal')
self.tags = kwargs.get('tags', [])
# development = kwargs.get('development')
try:
# init super class
super(SetPromotionHandler, self).__initialize__(deal, user)
self.run_promotion(promotion_id, tags=self.tags, auto_put=True)
# return success
response = self.get_all_deals_response()
api_utils.send_response(self, response, user)
except AssertionError, e:
self.send_error(str(e))
def post(self,*args,**kwargs): #@UnusedVariable
user = kwargs.get('actor')
promotion_id = kwargs.get('promotionID')
deal = kwargs.get('deal')
self.tags = kwargs.get('tags',[])
# development = kwargs.get('development')
try:
# init super class
super(SetPromotionHandler,self).__initialize__(deal,user)
self.run_promotion(promotion_id,tags=self.tags,auto_put=True)
# return success
response = self.get_all_deals_response()
api_utils.send_response(self,response, user)
except AssertionError,e:
self.send_error(str(e))
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):
try:
#should only return deals with a foursquare_id set
deals = levr.Deal.all().filter('foursquare_id >','').fetch(None)
logging.debug('number of foursquare deals: '+str(deals.__len__()))
# for deal in deals:
# assert deal.foursquare_id, 'A deal was returned that does not have a foursquare id. change the query.'
return_deals = [api_utils.package_deal(deal) for deal in deals if deal.foursquare_id]
response = {
'foursquareDeals' : return_deals,
'numFoursquareDeals' : return_deals.__len__()
}
api_utils.send_response(self,response)
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 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 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):
try:
#should only return deals with a foursquare_id set
deals = levr.Deal.all().filter('foursquare_id >', '').fetch(None)
logging.debug('number of foursquare deals: ' +
str(deals.__len__()))
# for deal in deals:
# assert deal.foursquare_id, 'A deal was returned that does not have a foursquare id. change the query.'
return_deals = [
api_utils.package_deal(deal) for deal in deals
if deal.foursquare_id
]
response = {
'foursquareDeals': return_deals,
'numFoursquareDeals': return_deals.__len__()
}
api_utils.send_response(self, response)
except:
levr.log_error()
api_utils.send_error(self, 'Server Error')
def get(self, *args, **kwargs):
'''
A user (specified in ?uid=USER_ID) follows the user specified in (/api/USER_ID/follow)
inputs: uid(required)
Response:{
None
}
'''
try:
logging.info('\n\n\n\t\t\t USER ADD FOLLOWER\n\n\n')
user = kwargs.get('user')
# uid = user.key()
actor = kwargs.get('actor')
actorID = actor.key()
private = kwargs.get('private')
#add actor to the list of followers
if actorID not in user.followers:
user.followers.append(actorID)
#PERFORM ACTIONS
if not levr.create_notification('newFollower', user.key(),
actorID):
api_utils.send_error(self, 'Server Error')
return
#get notifications
db.put([user, actor])
#respond
api_utils.send_response(self,
{'dt': str(actor.date_last_notified)},
actor)
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 get(self, *args, **kwargs): #@UnusedVariable
'''
@keyword actor:
@keyword action: if the deal will be a new deal or if it will be edited
@return: url
@rtype: string
'''
user = kwargs.get('actor')
action = kwargs.get('action')
try:
if action == 'add':
upload_url = blobstore.create_upload_url(NEW_DEAL_UPLOAD_URL)
elif action == 'edit':
upload_url = blobstore.create_upload_url(EDIT_DEAL_UPLOAD_URL)
else:
raise KeyError('Action not recognized: ' + str(action))
response = {'uploadURL': upload_url}
api_utils.send_response(self, response, user)
except KeyError, e:
self.send_error(e)
def get(self,*args,**kwargs):
'''
A user (specified in ?uid=USER_ID) follows the user specified in (/api/USER_ID/follow)
inputs: uid(required)
Response:{
None
}
'''
try:
logging.info('\n\n\n\t\t\t USER ADD FOLLOWER\n\n\n')
user = kwargs.get('user')
# uid = user.key()
actor = kwargs.get('actor')
actorID = actor.key()
private = kwargs.get('private')
#add actor to the list of followers
if actorID not in user.followers:
user.followers.append(actorID)
#PERFORM ACTIONS
if not levr.create_notification('newFollower',user.key(),actorID):
api_utils.send_error(self,'Server Error')
return
#get notifications
db.put([user,actor])
#respond
api_utils.send_response(self,{'dt':str(actor.date_last_notified)},actor)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def post(self,*args,**kwargs): #@UnusedVariable
'''
@keyword actor: required
@keyword business: required
@keyword description: required
@keyword deal_text: required
@keyword development: required
@requires: an image is uploaded - need the blob_key
@return: the newly created deal object
@rtype: dict
'''
user = kwargs.get('actor')
business = kwargs.get('business')
description = kwargs.get('description')
deal_text = kwargs.get('dealText')
development = kwargs.get('development')
img_key = ''
try:
#===================================================================
# Assure that an image was uploaded
#===================================================================
if self.get_uploads():
upload = self.get_uploads()[0]
blob_key= upload.key()
img_key = blob_key
upload_flag = True
else:
upload_flag = False
raise KeyError('Image was not uploaded')
#===================================================================
# Assemble the deal parameters! And create the deal!!
#===================================================================
params = {
'user' : user,
'uid' : user.key(),
'business' : business,
'deal_description' : description,
'deal_line1' : deal_text,
'development' : development,
'img_key' : img_key
}
# TODO: add pin_color = 'green' to the deal
# TODO: add origin = 'merchant'
deal_entity = levr.dealCreate(params, 'phone_merchant', upload_flag)
# if an image was uploaded, rotate it.
if upload_flag == True:
try:
# Synchronously rotate the image
api_utils.rotate_image(blob_key,deal_entity)
except:
levr.log_error('An image could not be rotated. It was sent to the task que: '+str(blob_key))
# Send the image to the img rotation task que
task_params = {
'blob_key' : str(blob_key)
}
logging.info('Sending this to the img rotation task: '+str(task_params))
taskqueue.add(url=IMAGE_ROTATION_TASK_URL,payload=json.dumps(task_params))
#===================================================================
# Aw hell.. why not give them some karma too.
#===================================================================
user.karma += 5
# no need to level_check on them though...
user.put()
#===================================================================
# Create some nifty notifications
#===================================================================
try:
levr.create_notification('followedUpload',user.followers,user.key(),deal_entity)
except:
levr.log_error()
#===================================================================
# Respond with all of the users deals
#===================================================================
private = True
deals = api_utils.fetch_all_users_deals(user)
packaged_deals = api_utils.package_deal_multi(deals, private)
response = {
'deals' : packaged_deals
}
api_utils.send_response(self,response, user)
except Exception,e:
levr.log_error(e)
api_utils.send_error(self,'Server Error')
def post(self,*args,**kwargs): #@UnusedVariable
'''
@keyword actor: required
@keyword deal: required
@keyword description: optional
@keyword dealText: optional
@var new_img_key: optional - the blob key of the uploaded image
@return: the new deal object
@rtype: dict
'''
user = kwargs.get('actor')
deal = kwargs.get('deal')
description = kwargs.get('description',None)
deal_text = kwargs.get('dealText',None)
try:
# assure that the user is the owner of the deal
assert deal.parent_key() == user.key(), 'User does not own that deal'
#===================================================================
# Check for image upload
#===================================================================
if self.get_uploads():
new_img_key = self.get_uploads()[0].key()
# grab old key so we can delete it
old_img_key = deal.img
# replace with new key
deal.img = new_img_key
# delete that old key
old_img_key.delete()
try:
# Synchronously rotate the image
api_utils.rotate_image(new_img_key)
except:
levr.log_error('An image could not be rotated. \
It was sent to the task que: '+str(new_img_key))
# Send the image to the img rotation task que
task_params = {
'blob_key' : str(new_img_key)
}
logging.info('Sending this to the img rotation task: '+str(task_params))
taskqueue.add(url=IMAGE_ROTATION_TASK_URL,payload=json.dumps(task_params))
else:
assert description or deal_text, 'Thanks for sending me something to update.'
#===================================================================
# Update new deal informations
#===================================================================
if description:
deal.description = description
if deal_text:
deal.deal_text = deal_text
# TODO: add new tags to the deal for the new information that was added
deal.put()
private = True
deals = api_utils.fetch_all_users_deals(user)
packaged_deals = api_utils.package_deal_multi(deals, private)
response = {
'deals' : packaged_deals
}
api_utils.send_response(self,response, user)
except AssertionError,e:
api_utils.send_error(self,e.message)
def get(self,*args,**kwargs):
'''
/user/uid/favorites
Get all of a users favorite deals
inputs:
response:{
numResults: <int>
deals: [<deal>,<deal>]
}
'''
#RESTRICTED
try:
logging.info("\n\nGET USER FAVORITES")
logging.info(kwargs)
logging.info(args)
user = kwargs.get('user')
# uid = user.key()
private = kwargs.get('private')
limit = kwargs.get('limit')
offset = kwargs.get('offset')
#grab all favorites
favorites = user.favorites
#check list is longer than offset
if favorites.__len__() > offset:
#grab list from offset to end
favorites = favorites[offset:]
#check list is longer than limit
if favorites.__len__() > limit:
#there are more favorites than the limit requests so shorten favorites
favorites = favorites[:limit]
#fetch all favorite entities
favorites = levr.Deal.get(favorites)
deals = []
#package each deal object
for deal in favorites:
if deal:
deals.append(api_utils.package_deal(deal,False))
else:
#favorites is either empty or the offset is past the length of it
deals = []
#create response object
response = {
'numResults': str(favorites.__len__()),
'deals' : deals
}
logging.debug(response)
#respond
api_utils.send_response(self,response,user)
except:
levr.log_error()
api_utils.send_error(self,'Server Error')
def get(self, dealID, *args, **kwargs):
try:
logging.debug('UPVOTE\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
uid = user.key()
deal = kwargs.get('deal')
dealID = deal.key()
#===================================================================
# Note, if this code changes, you should also change the code in /cronjobs/undeadActivity because it was copied and pasted...
#===================================================================
#favorite
logging.debug(
levr.log_model_props(user,
['upvotes', 'downvotes', 'favorites']))
logging.debug(levr.log_model_props(deal, ['upvotes', 'downvotes']))
if dealID in user.upvotes:
logging.debug('flag deal in upvotes')
#user is removing the upvote
#remove the offending deal from the user upvotes
user.upvotes.remove(dealID)
#decrement the deal upvotes
deal.upvotes -= 1
#do not change the karma of the user who uploaded it
#do not remove from favorites
#do not remove notification
db.put([user, deal])
elif dealID in user.downvotes:
logging.debug('flag deal is in downvotes')
#remove deal from downvotes
user.downvotes.remove(dealID)
#decrement the deals downvotes
deal.downvotes -= 1
#add deal to upvotes
user.upvotes.append(dealID)
#increment the number of upvotes
deal.upvotes += 1
#add deal to favorites
if dealID not in user.favorites:
user.favorites.append(dealID)
#do not change the karma of the user who uploaded
#do not add notification for the ninja
db.put([user, deal])
pass
else:
logging.debug('flag deal not in upvotes or downvotes')
# If the deal is in the users favorites, then they upvoted the deal at one point and then
# removed that upvote either via another upvote or a downvote, and they are trying to upvote again
# At this point, the deal should get its upvote back, but the ninja gets no karma because they do not
# lose a karma point when the deal is downloaded
if dealID not in user.favorites:
#get owner of the deal
ninja = levr.Customer.get(deal.key().parent())
#check owner. if the owner is a dummy owner left over from an account transfer, grab the real owner.
if ninja.email == '*****@*****.**':
logging.debug(
'\n\n\n \t\t\t DUMMY NINJA! REDIRECTING REFERENCE TO THE REAL ONE!!! \n\n\n'
)
ninja = levr.Customer.get(ninja.pw)
#compare owner to user doing the voting
if ninja.key() == user.key():
#ninja is upvoting his own deal
#increase that users karma! reward for uploading a deal!
user.karma += 1
#level check!
levr.level_check(user)
else:
#increase the ninjas karma
ninja.karma += 1
#level check!
levr.level_check(ninja)
#replace ninja. we dont want him anymore
ninja.put()
#add to upvote list
user.upvotes.append(dealID)
# #increase the deal upvotes
deal.upvotes += 1
#add to users favorites list if not there already
if dealID not in user.favorites:
user.favorites.append(dealID)
#create favorite notification for the ninja that uploaded
levr.create_notification('favorite', ninja.key(), uid,
dealID)
db.put([user, deal])
#put actor and ninja and deal back
assert deal, 'Deal was not found'
response = {'deal': api_utils.package_deal(deal)}
api_utils.send_response(self, response, user)
except AssertionError, e:
levr.log_error(e)
api_utils.send_error(self, e.message)
def get(self, dealID, *args, **kwargs):
try:
logging.debug('DOWNVOTE\n\n\n')
logging.debug(kwargs)
user = kwargs.get('actor')
# uid = user.key()
deal = kwargs.get('deal')
dealID = deal.key()
#favorite
logging.debug(levr.log_model_props(user))
if dealID in user.downvotes:
logging.debug('flag deal is in downvotes')
user.downvotes.remove(dealID)
#decrement the deal downvotes
deal.downvotes -= 1
#do not change the karma of the user who uploaded it
#do not add to favorites
#do not create notification
db.put([user, deal])
elif dealID in user.upvotes:
logging.debug('flag deal is in downvotes')
#remove from user upvotes
user.upvotes.remove(dealID)
#decrement deal upvotes
deal.upvotes -= 1
#add to user downvotes
user.downvotes.append(dealID)
#increment deal downvotes
deal.downvotes += 1
#replace entities
db.put([user, deal])
else:
logging.debug('Flag deal not in upvotes or downvotes')
#add to user downvotes
user.downvotes.append(dealID)
#downvote deal
deal.downvotes += 1
#replace entities
db.put([user, deal])
assert deal, 'Deal could not be found'
response = {'deal': api_utils.package_deal(deal)}
api_utils.send_response(self, response, user)
except AssertionError, e:
levr.log_error()
api_utils.send_error(self, e.message)
def get(self,*args,**kwargs):
try:
#if we hit this handler it means that a user has both a levr account, and an account with the external service
#we need to figure out which service (via the contentID prefix)
#then, we need to figure out if we're dealing with two separate accounts
#if so, we need to merge these two accounts and update references (are there any?)
#grab and parse contentID to figure out what service the user has previously linked with
logging.debug(kwargs)
user = kwargs.get('actor')
uid = user.key()
contentID = kwargs.get('contentID')
assert contentID,'contentID is not being passed'
# contentID = args[0]
service = contentID[0:3]
#grab the floating content and the requesting user
floating_content = levr.FloatingContent.gql('WHERE contentID=:1',contentID).get()
# donor = floating_content.user
if service=='fou':
logging.debug('The user came from foursquare')
if user.foursquare_connected != True:
#add the foursquare information from the donor to the levr user
#create an instance of the Foursquare social connection class
task_params = {
'uid' : uid,
'contentID' : contentID,
'service' : 'foursquare'
}
taskqueue.add(url='/tasks/mergeUsersTask',payload=json.dumps(task_params))
elif service=='fac':
logging.debug('The user came from facebook')
if user.facbook_connected != True:
#merge these two users
task_params = {
'uid' : uid,
'contentID' : contentID,
'service' : 'facebook'
}
taskqueue.add(url='/tasks/mergeUsersTask',payload=json.dumps(task_params))
#merge stuff hereeeee
elif service=='twi':
logging.debug('The user came from twitter')
if user.twitter_connected != True:
#merge these two users
task_params = {
'uid' : uid,
'contentID' : contentID,
'service' : 'twitter'
}
taskqueue.add(url='/tasks/mergeUsersTask',payload=json.dumps(task_params))
#merge stuff hereeeee
else:
raise Exception('contentID prefix not recognized: '+service)
#now that that fuckery is done with, grab and return the content requested
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})
#respond, including the token because why the hell not
#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)
