def add_notifier(acc_ref):
logging.error("Had to add a Notifier widget to an account " + str(acc_ref.key().name()))
new_notifier = Notifier(key_name=acc_ref.key().name())
memcache_db.save_entity(new_notifier, acc_ref.key().name())
acc_ref.notifierWidget = new_notifier
accounts_dao.save(acc_ref)
return new_notifier
def add_rank(acc_ref):
logging.error("Had to add a Rank widget to an account " + str(acc_ref.key().name()))
new_rank= Rank(key_name=acc_ref.key().name())
memcache_db.save_entity(new_rank, acc_ref.key().name())
acc_ref.rankWidget = new_rank
accounts_dao.save(acc_ref)
return new_rank
def add_milestones(acc_ref):
logging.error("Had to add a Milestones widget to an account " + str(acc_ref.key().name()))
new_milestones = Milestones(key_name=acc_ref.key().name())
memcache_db.save_entity(new_milestones, acc_ref.key().name())
acc_ref.milestonesWidget = new_milestones
accounts_dao.save(acc_ref)
return new_milestones
def add_leader(acc_ref):
logging.error("Had to add a Leader widget to an account " + str(acc_ref.key().name()))
new_leader= Leaderboard(key_name=acc_ref.key().name())
memcache_db.save_entity(new_leader, acc_ref.key().name())
acc_ref.leaderWidget = new_leader
accounts_dao.save(acc_ref)
return new_leader
def add_notifier(acc_ref):
logging.error("Had to add a Notifier widget to an account " + str(acc_ref.key().name()))
new_notifier = Notifier(key_name=acc_ref.key().name())
memcache_db.save_entity(new_notifier, acc_ref.key().name())
acc_ref.notifierWidget = new_notifier
accounts_dao.save(acc_ref)
return new_notifier
def create_widget_for_account_by_email(widget_name, email):
"""
Creates a new widget for the account, will return widget object if success, else it will return None
"""
new_widget = None
property_name = None
if widget_name == "TrophyCase":
new_widget = TrophyCase(key_name=email)
property_name = "trophyWidget"
elif widget_name == "Rank":
new_widget = Rank(key_name=email)
property_name = "rankWidget"
elif widget_name == "Points":
new_widget = Points(key_name=email)
property_name = "pointsWidget"
elif widget_name == "Notifier":
new_widget = Notifier(key_name=email)
property_name = "notifierWidget"
elif widget_name == "Milestones":
new_widget = Milestones(key_name=email)
property_name = "milestoneWidget"
elif widget_name == "Leaderboard":
new_widget = Leaderboard(key_name=email)
property_name = "leaderWidget"
if new_widget!= None:
memcache_db.save_entity(new_widget, email)
update_fields = { property_name : new_widget }
memcache_db.update_fields(email, "Accounts", update_fields)
else:
logging.info("Unable to create widget because widget type unknown: " + widget_name)
return new_widget
def create_widget_for_account_by_email(widget_name, email):
"""
Creates a new widget for the account, will return widget object if success, else it will return None
"""
new_widget = None
property_name = None
if widget_name == "TrophyCase":
new_widget = TrophyCase(key_name=email)
property_name = "trophyWidget"
elif widget_name == "Rank":
new_widget = Rank(key_name=email)
property_name = "rankWidget"
elif widget_name == "Points":
new_widget = Points(key_name=email)
property_name = "pointsWidget"
elif widget_name == "Notifier":
new_widget = Notifier(key_name=email)
property_name = "notifierWidget"
elif widget_name == "Milestones":
new_widget = Milestones(key_name=email)
property_name = "milestoneWidget"
elif widget_name == "Leaderboard":
new_widget = Leaderboard(key_name=email)
property_name = "leaderWidget"
if new_widget!= None:
memcache_db.save_entity(new_widget, email)
update_fields = { property_name : new_widget }
memcache_db.update_fields(email, "Accounts", update_fields)
else:
logging.info("Unable to create widget because widget type unknown: " + widget_name)
return new_widget
def add_milestones(acc_ref):
logging.error("Had to add a Milestones widget to an account " + str(acc_ref.key().name()))
new_milestones = Milestones(key_name=acc_ref.key().name())
memcache_db.save_entity(new_milestones, acc_ref.key().name())
acc_ref.milestonesWidget = new_milestones
accounts_dao.save(acc_ref)
return new_milestones
def add_points(acc_ref):
logging.error("Had to add a Points widget to an account " + str(acc_ref.key().name()))
new_points= Points(key_name=acc_ref.key().name())
memcache_db.save_entity(new_points, acc_ref.key().name())
acc_ref.pointsWidget = new_points
accounts_dao.save(acc_ref)
return new_points
def add_points(acc_ref):
logging.error("Had to add a Points widget to an account " + str(acc_ref.key().name()))
new_points= Points(key_name=acc_ref.key().name())
memcache_db.save_entity(new_points, acc_ref.key().name())
acc_ref.pointsWidget = new_points
accounts_dao.save(acc_ref)
return new_points
def add_trophy_case(acc_ref):
logging.error("Had to add a Trophy widget to an account " + str(acc_ref.key().name()))
new_trophy_case= TrophyCase(key_name=acc_ref.key().name())
memcache_db.save_entity(new_trophy_case, acc_ref.key().name())
acc_ref.trophyWidget = new_trophy_case
accounts_dao.save(acc_ref)
return new_trophy_case
def add_leader(acc_ref):
logging.error("Had to add a Leader widget to an account " + str(acc_ref.key().name()))
new_leader= Leaderboard(key_name=acc_ref.key().name())
memcache_db.save_entity(new_leader, acc_ref.key().name())
acc_ref.leaderWidget = new_leader
accounts_dao.save(acc_ref)
return new_leader
def add_trophy_case(acc_ref):
logging.error("Had to add a Trophy widget to an account " + str(acc_ref.key().name()))
new_trophy_case= TrophyCase(key_name=acc_ref.key().name())
memcache_db.save_entity(new_trophy_case, acc_ref.key().name())
acc_ref.trophyWidget = new_trophy_case
accounts_dao.save(acc_ref)
return new_trophy_case
def add_rank(acc_ref):
logging.error("Had to add a Rank widget to an account " + str(acc_ref.key().name()))
new_rank= Rank(key_name=acc_ref.key().name())
memcache_db.save_entity(new_rank, acc_ref.key().name())
acc_ref.rankWidget = new_rank
accounts_dao.save(acc_ref)
return new_rank
def create_badge_image(badge_key, perm, acc, imgbuf, img_type):
badge_img = BadgeImage(key_name=badge_key,
permissions=perm,
creator=acc,
image=imgbuf,
imgType=img_type)
memcache_db.save_entity(badge_img, badge_key)
return badge_img
def create_badge_image(badge_key, perm, acc, imgbuf, img_type):
badge_img = BadgeImage(key_name=badge_key,
permissions = perm,
creator=acc,
image=imgbuf,
imgType = img_type)
memcache_db.save_entity(badge_img, badge_key)
return badge_img
def get_encrypt_secret():
secret = memcache_db.get_entity(constants.ENCRYPTION_KEYNAME, "PassPhrase")
if not secret:
phrase = gen_random(8) #must be 8 characters long
ent = PassPhrase(key_name=constants.ENCRYPTION_KEYNAME, secret=phrase)
memcache_db.save_entity(ent, constants.ENCRYPTION_KEYNAME)
return phrase
else:
return secret.secret
def get_aes_encrypt_secret():
secret = memcache_db.get_entity(constants.AES_ENCRYPTION_KEYNAME, "PassPhrase")
if not secret:
phrase = gen_random(16) # must be 16 chars long
ent = PassPhrase(key_name=constants.AES_ENCRYPTION_KEYNAME, secret=phrase)
memcache_db.save_entity(ent, constants.AES_ENCRYPTION_KEYNAME)
return phrase
else:
return secret.secret
def get_update_secret():
secret = memcache_db.get_entity(constants.UPDATE.SECRET_KEYNAME, "PassPhrase")
if not secret:
phrase = gen_random(16)
ent = PassPhrase(key_name=constants.UPDATE.SECRET_KEYNAME, secret=phrase)
memcache_db.save_entity(ent, constants.UPDATE.SECRET_KEYNAME)
return phrase
else:
return secret.secret
def get_update_secret():
secret = memcache_db.get_entity(constants.UPDATE.SECRET_KEYNAME,
"PassPhrase")
if not secret:
phrase = gen_random(16)
ent = PassPhrase(key_name=constants.UPDATE.SECRET_KEYNAME,
secret=phrase)
memcache_db.save_entity(ent, constants.UPDATE.SECRET_KEYNAME)
return phrase
else:
return secret.secret
def create_badge_type(
badge_key,
badge_name,
badge_des,
account,
badge_theme,
img_type,
imgbuf=None,
blob_info=None,
perm="private",
btype="free",
stype="blob",
is_enabled="yes",
):
"""
Storage is either using a BadgeImage or through the blobstore api for
faster and cheaper serving of images
"""
blob_key = None
storage_type = "blob"
badge_image = None
download_link = ""
if imgbuf:
storage_type = "db"
badge_image = create_badge_image(badge_key, perm, account, imgbuf, img_type)
download_link = get_full_link("badge/d?bk=" + badge_key)
elif blob_info:
storage_type = "blob"
blob_key = blob_info.key()
download_link = images.get_serving_url(str(blob_key))
logging.info("Badge serving url:" + str(download_link))
else:
logging.error("Create badge type error: No image to save for badge type")
raise
badge = Badges(
key_name=badge_key,
name=badge_name,
altText=badge_des,
description=badge_des,
setType=btype,
isEnabled=is_enabled,
creator=account,
permissions=perm,
storageType=storage_type,
imageKey=badge_image,
blobKey=blob_key,
downloadLink=download_link,
theme=badge_theme,
)
# Store it as a badge image
memcache_db.save_entity(badge, badge_key)
return badge
def create_badge_type(badge_key,
badge_name,
badge_des,
account,
badge_theme,
img_type,
imgbuf=None,
blob_info=None,
perm="private",
btype="free",
stype="blob",
is_enabled="yes"):
"""
Storage is either using a BadgeImage or through the blobstore api for
faster and cheaper serving of images
"""
blob_key = None
storage_type = "blob"
badge_image = None
download_link = ""
if imgbuf:
storage_type = "db"
badge_image = create_badge_image(badge_key, perm, account, imgbuf,
img_type)
download_link = get_full_link("badge/d?bk=" + badge_key)
elif blob_info:
storage_type = "blob"
blob_key = blob_info.key()
download_link = images.get_serving_url(str(blob_key))
else:
logging.error(
"Create badge type error: No image to save for badge type")
raise
badge = Badges(key_name=badge_key,
name=badge_name,
altText=badge_des,
description=badge_des,
setType=btype,
isEnabled=is_enabled,
creator=account,
permissions=perm,
storageType=storage_type,
imageKey=badge_image,
blobKey=blob_key,
downloadLink=download_link,
theme=badge_theme)
# Store it as a badge image
memcache_db.save_entity(badge, badge_key)
return badge
def create_new_user(account_id, user_id):
"""
Create a new user entity and save
Look up account with account_id and use in reference when creating new user
"""
account_entity = memcache_db.get_entity(account_id, "Accounts")
user_key = get_user_key(account_id, user_id)
new_user = Users(key_name=user_key,
userid=user_id,
isEnabled="yes",
accountRef=account_entity)
try:
memcache_db.save_entity(new_user, user_key)
except:
logging.error("Error saving new user entity")
return
def create_new_user(account_id, user_id):
"""
Create a new user entity and save
Look up account with account_id and use in reference when creating new user
"""
account_entity = memcache_db.get_entity(account_id, "Accounts")
user_key= get_user_key(account_id, user_id)
new_user = Users(key_name=user_key,
userid=user_id,
isEnabled="yes",
accountRef=account_entity)
try:
memcache_db.save_entity(new_user, user_key)
except:
logging.error("Error saving new user entity")
return
def create_badge_instance(badge_instance_key,
badge_ref,
user_ref,
isawarded,
points,
points_needed,
perm,
link,
reason,
expiration=None):
if isawarded == "yes":
date = datetime.date.today()
datet = datetime.datetime.now()
else:
date = None
datet = None
if date:
new_badge_instance = BadgeInstance(key_name=badge_instance_key,
badgeRef=badge_ref,
userRef=user_ref,
awarded=isawarded,
pointsEarned=points,
pointsRequired=points_needed,
permissions=perm,
downloadLink=link,
reason=reason,
awardDate=date,
awardDateTime=datet)
else:
new_badge_instance = BadgeInstance(key_name=badge_instance_key,
badgeRef=badge_ref,
userRef=user_ref,
awarded=isawarded,
pointsEarned=points,
pointsRequired=points_needed,
permissions=perm,
downloadLink=link,
reason=reason)
memcache_db.save_entity(new_badge_instance, badge_instance_key)
return new_badge_instance
def create_badge_instance(badge_instance_key,
badge_ref,
user_ref,
isawarded,
points,
points_needed,
perm,
link,
reason,
expiration=None):
if isawarded == "yes":
date = datetime.date.today()
datet = datetime.datetime.now()
else:
date = None
datet = None
if date:
new_badge_instance = BadgeInstance(key_name=badge_instance_key,
badgeRef=badge_ref,
userRef=user_ref,
awarded=isawarded,
pointsEarned=points,
pointsRequired=points_needed,
permissions=perm,
downloadLink=link,
reason=reason,
awardDate = date,
awardDateTime = datet)
else:
new_badge_instance = BadgeInstance(key_name=badge_instance_key,
badgeRef=badge_ref,
userRef=user_ref,
awarded=isawarded,
pointsEarned=points,
pointsRequired=points_needed,
permissions=perm,
downloadLink=link,
reason=reason)
memcache_db.save_entity(new_badge_instance, badge_instance_key)
return new_badge_instance
def test1(self):
key = "*****@*****.**"
ent_type = "Accounts"
trophy_case_widget = TrophyCase(key_name=key)
points_widget = Points(key_name=key)
rank_widget = Rank(key_name=key)
newacc = Accounts(
key_name=key,
password="******",
email=key,
isEnabled="enabled",
accountType="bronze",
paymentType="free",
cookieKey="xxx",
apiKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget,
)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.email != key:
return "Error getting same account. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.email != key:
return "Error getting same account from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"email": "*****@*****.**"}
ret2 = memcache_db.update_fields(key, ent_type, diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.email != "*****@*****.**":
return "Error getting same account after altering entity. Subtest 3"
try:
memcache_db.delete_entity(newacc, key)
except Exception:
return "Error deleting entity. Subtest 4"
return "Success"
def test1(self):
key = "*****@*****.**"
ent_type = "Accounts"
trophy_case_widget = TrophyCase(key_name=key)
points_widget = Points(key_name=key)
rank_widget = Rank(key_name=key)
newacc = Accounts(key_name=key,
password="******",
email=key,
isEnabled="enabled",
accountType="bronze",
paymentType="free",
cookieKey="xxx",
apiKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.email != key:
return "Error getting same account. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.email != key:
return "Error getting same account from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"email": "*****@*****.**"}
ret2 = memcache_db.update_fields(key, ent_type, diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.email != "*****@*****.**":
return "Error getting same account after altering entity. Subtest 3"
try:
memcache_db.delete_entity(newacc, key)
except Exception:
return "Error deleting entity. Subtest 4"
return "Success"
def get_or_create_user(account_id, user_id, acc_ref):
"""
Create the user if it doesnt exist
"""
user_ref = get_user(account_id, user_id)
if not user_ref:
# insert a new user, but lacking optional fields
user_key = get_user_key(account_id, user_id)
new_user = Users(key_name=user_key,
userid=user_id,
isEnabled="yes",
accountRef=acc_ref)
try:
memcache_db.save_entity(new_user, user_key)
except:
logging.error("Error saving user with key %s, userid %s for account %s"%\
(user_key, user_id, account_id))
return None
user_ref = get_user(account_id, user_id)
if not user_ref:
logging.error("Error getting user with key %s, userid %s for account %s"%\
(user_key, user_id, account_id))
return None
return user_ref
def get_or_create_user(account_id, user_id, acc_ref):
"""
Create the user if it doesnt exist
"""
user_ref = get_user(account_id, user_id)
if not user_ref:
# insert a new user, but lacking optional fields
user_key= get_user_key(account_id, user_id)
new_user = Users(key_name=user_key,
userid=user_id,
isEnabled="yes",
accountRef=acc_ref)
try:
memcache_db.save_entity(new_user, user_key)
except:
logging.error("Error saving user with key %s, userid %s for account %s"%\
(user_key, user_id, account_id))
return None
user_ref = get_user(account_id, user_id)
if not user_ref:
logging.error("Error getting user with key %s, userid %s for account %s"%\
(user_key, user_id, account_id))
return None
return user_ref
def save_user(user_ref, user_key):
return memcache_db.save_entity(user_ref, user_key)
def create_account(email,
password,
enable=False,
account_type="bronze",
payment_type="free"):
"""
Creates an account with all the other needed dependencies properly initialized.
"""
"""
Required:
email = db.EmailProperty(required=True)
password = db.StringProperty(required=True);
isEnabled = db.StringProperty(required=True, choices=ACCOUNT_STATUS.RANGE_OF_VALUES)
accountType = db.StringProperty(required=True, choices=set(ACCOUNT_TYPES))
paymentType = db.StringProperty(required=True,choices=set(PAYMENT_TYPES))
cookieKey = db.StringProperty(required=True)
apiKey = db.StringProperty(required=True)
trophyWidget = db.ReferenceProperty(required=True, reference_class=TrophyCase)
pointsWidget = db.ReferenceProperty(required=True, reference_class=Points)
rankWidget = db.ReferenceProperty(required=True, reference_class=Rank)
"""
new_trophy_case = TrophyCase(key_name=email)
memcache_db.save_entity(new_trophy_case, email)
new_rank = Rank(key_name=email)
memcache_db.save_entity(new_rank, email)
new_points = Points(key_name=email)
memcache_db.save_entity(new_points, email)
new_notifier = Notifier(key_name=email)
memcache_db.save_entity(new_notifier, email)
new_leader = Leaderboard(key_name=email)
memcache_db.save_entity(new_leader, email)
new_milestones = Milestones(key_name=email)
memcache_db.save_entity(new_milestones, email)
""" Generate an API key """
api_key = str(uuid.uuid4())
""" Hash the password """
hashed_password = hashlib.sha1(password).hexdigest()
enable_account = ACCOUNT_STATUS.PENDING_CREATE
if enable:
enable_account = ACCOUNT_STATUS.ENABLED
newacc = Accounts(key_name=email,
email=email,
password=hashed_password,
isEnabled=enable_account,
accountType=account_type,
paymentType=payment_type,
apiKey=api_key,
cookieKey="xxxxxxxxxxxxxx",
trophyWidget=new_trophy_case,
pointsWidget=new_points,
rankWidget=new_rank,
notifierWidget=new_notifier,
leaderWidget=new_leader,
milestoneWidget=new_milestones)
try:
memcache_db.save_entity(newacc, email)
except:
logging.error("Failed to create account")
users_dao.create_new_user(email, constants.ANONYMOUS_USER)
return newacc
def save(acc_ref):
memcache_db.save_entity(acc_ref, acc_ref.key().name())
def post(self):
isLocal = os.environ['SERVER_SOFTWARE'].startswith('Dev')
if not isLocal:
return
secret = self.request.get('secret')
if secret != TOPSECRET:
bad_args()
return
api_key = self.request.get('apikey')
account_id = self.request.get('accountid')
badge_id = self.request.get('badgeid')
badge_theme = self.request.get('theme')
if not badge_theme or not badge_id or not account_id or not api_key:
ret = bad_args()
self.response.out.write(ret)
return
acc = accounts_dao.create_account(account_id, "xxx000xxx", enable=True)
from serverside.entities import memcache_db
acc.apiKey = "ABCDEFGHI"
memcache_db.save_entity(acc, account_id)
# remote paths are used because the SDK cannot fetch from itself
# because it is single threaded and would cause deadlock
badge_list = ["http://cdn2.iconfinder.com/data/icons/crystalproject/128x128/apps/keditbookmarks.png",
"http://cdn4.iconfinder.com/data/icons/Merry_Christmas_by_jj_maxer/golden%20star.png",
"http://cdn1.iconfinder.com/data/icons/CrystalClear/128x128/actions/bookmark.png",
"http://cdn4.iconfinder.com/data/icons/token/Token,%20128x128,%20PNG/Star-Favorites.png",
"http://cdn4.iconfinder.com/data/icons/supermario/PNG/Star.png",
"http://cdn5.iconfinder.com/data/icons/SOPHISTIQUE/graphics/png/128/star.png",
"http://cdn3.iconfinder.com/data/icons/humano2/128x128/actions/bookmark-new.png",
"http://cdn2.iconfinder.com/data/icons/web2/Icons/Favorite_128x128.png",
"http://cdn5.iconfinder.com/data/icons/water_gaming_pack/128/star_wars_battlefront.png",
"http://cdn2.iconfinder.com/data/icons/spaceinvaders/blackhole.png"]
# Create ten badges
for ii in range(0,10):
newbadge = badge_list[ii]
try:
result = urlfetch.fetch(url=newbadge)
except:
error("Is one of the badges no longer available? Check %s"%newbadge)
return
imgbuf = result.content
if len(imgbuf) == 0:
error("One of the downloads did not work! url:%s"%newbadge)
return
badge_key = badges_dao.create_badge_key(account_id, badge_theme, str(ii), "private")
# Create the file
file_name = files.blobstore.create(mime_type='application/octet-stream')
# Open the file and write to it
with files.open(file_name, 'a') as f:
f.write(imgbuf)
# Finalize the file. Do this before attempting to read it.
files.finalize(file_name)
# Get the file's blob key
blob_key = files.blobstore.get_blob_key(file_name)
blob_info = blobstore.BlobInfo.get(blob_key)
# TODO test with different types of images
badges_dao.create_badge_type(badge_key,
str(ii),
"badge description",
acc,
badge_theme,
"png",
blob_info=blob_info)
# End of for loop
self.response.out.write(success_ret())
return
def test4(self):
account_key = "[email protected]"
trophy_case_widget = TrophyCase(key_name=account_key)
points_widget = Points(key_name=account_key)
rank_widget = Rank(key_name=account_key)
newacc = Accounts(key_name=account_key,
password="******",
email="[email protected]",
isEnabled="enabled",
accountType="bronze",
paymentType="free",
apiKey="xxx",
cookieKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save an account
ret = memcache_db.save_entity(newacc, account_key)
user_key = "testuser1"
newuser = Users(key_name=user_key,
userid=user_key,
isEnabled="yes",
accountRef=newacc,
tags=user_key)
try:
memcache_db.delete_entity(newacc, user_key)
except Exception:
pass
# Save a user
ret = memcache_db.save_entity(newacc, user_key)
# Create a Badge Type
badge_key = "testbadge1"
badgetype = Badges(key_name=badge_key,
name="badge1",
description=badge_key,
altText="a really cool badge",
setType="free",
isEnabled="yes",
creator=newacc,
permissions="private",
storageType="blob",
blobKey="xxxx")
try:
memcache_db.delete_entity(badgetype, badge_key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(badgetype, badge_key)
key = "testbadgeinstance1"
ent_type = "BadgeInstance"
badgeinstance = BadgeInstance(key_name=key,
awarded="no",
badgeRef=badgetype,
userRef=newuser,
pointRequired=10,
pointsEarned=0,
permissions="private")
try:
memcache_db.delete_entity(badgeinstance, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(badgeinstance, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.awarded != "no":
return "Error getting same entity. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.awarded != "no":
return "Error getting same entity from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"pointsRequired": 11, "awarded": "no"}
inc_diction = {"pointsEarned": 5}
ret2 = memcache_db.update_fields(key, ent_type, diction, inc_diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.pointsRequired!= 11 \
or sameent.pointsEarned != 5:
return "Error getting same entity after altering entity. Subtest 3"
# Cleanup
try:
memcache_db.delete_entity(badgeinstance, key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(newacc, account_key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(badgetype, badge_key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(newuser, user_key)
except Exception:
return "Error deleting entity. Subtest 4"
return "Success"
def test3(self):
account_key = "[email protected]"
trophy_case_widget = TrophyCase(key_name=account_key)
points_widget = Points(key_name=account_key)
rank_widget = Rank(key_name=account_key)
newacc = Accounts(key_name=account_key,
password="******",
email="[email protected]",
isEnabled="enabled",
accountType="bronze",
paymentType="free",
apiKey="xxx",
cookieKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget)
try:
memcache_db.delete_entity(newacc, account_key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, account_key)
key = "testuser1"
ent_type = "Users"
newacc = Users(key_name=key,
userid=key,
isEnabled="yes",
accountRef=newacc,
tags=key)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.tags != key:
return "Error getting same entity. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.tags != key:
return "Error getting same entity from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"tags": "goodbye:hello"}
ret2 = memcache_db.update_fields(key, ent_type, diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.tags != "goodbye:hello":
return "Error getting same entity after altering entity. Subtest 3"
try:
memcache_db.delete_entity(newacc, account_key)
memcache_db.delete_entity(sameent, key)
except Exception:
return "Error deleting entity. Subtest 4"
return "Success"
def create_account(email,
password,
enable=False,
account_type="bronze",
payment_type="free"):
"""
Creates an account with all the other needed dependencies properly initialized.
"""
"""
Required:
email = db.EmailProperty(required=True)
password = db.StringProperty(required=True);
isEnabled = db.StringProperty(required=True, choices=ACCOUNT_STATUS.RANGE_OF_VALUES)
accountType = db.StringProperty(required=True, choices=set(ACCOUNT_TYPES))
paymentType = db.StringProperty(required=True,choices=set(PAYMENT_TYPES))
cookieKey = db.StringProperty(required=True)
apiKey = db.StringProperty(required=True)
trophyWidget = db.ReferenceProperty(required=True, reference_class=TrophyCase)
pointsWidget = db.ReferenceProperty(required=True, reference_class=Points)
rankWidget = db.ReferenceProperty(required=True, reference_class=Rank)
"""
new_trophy_case = TrophyCase(key_name=email)
memcache_db.save_entity(new_trophy_case, email)
new_rank = Rank(key_name=email)
memcache_db.save_entity(new_rank, email)
new_points = Points(key_name=email)
memcache_db.save_entity(new_points, email)
new_notifier = Notifier(key_name=email)
memcache_db.save_entity(new_notifier, email)
new_leader = Leaderboard(key_name=email)
memcache_db.save_entity(new_leader, email)
new_milestones = Milestones(key_name=email)
memcache_db.save_entity(new_milestones, email)
""" Generate an API key """
api_key = str(uuid.uuid4())
""" Hash the password """
hashed_password = hashlib.sha1(password).hexdigest()
enable_account = ACCOUNT_STATUS.PENDING_CREATE
if enable:
enable_account = ACCOUNT_STATUS.ENABLED
newacc = Accounts(key_name = email,
email = email,
password = hashed_password,
isEnabled = enable_account,
accountType = account_type,
paymentType = payment_type,
apiKey = api_key,
cookieKey = "xxxxxxxxxxxxxx",
trophyWidget = new_trophy_case,
pointsWidget = new_points,
rankWidget = new_rank,
notifierWidget = new_notifier,
leaderWidget = new_leader,
milestoneWidget = new_milestones)
try:
memcache_db.save_entity(newacc, email)
except:
logging.error("Failed to create account")
users_dao.create_new_user(email, constants.ANONYMOUS_USER)
return newacc
def test4(self):
account_key = "[email protected]"
trophy_case_widget = TrophyCase(key_name=account_key)
points_widget = Points(key_name=account_key)
rank_widget = Rank(key_name=account_key)
newacc = Accounts(
key_name=account_key,
password="******",
email="[email protected]",
isEnabled="enabled",
accountType="bronze",
paymentType="free",
apiKey="xxx",
cookieKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget,
)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save an account
ret = memcache_db.save_entity(newacc, account_key)
user_key = "testuser1"
newuser = Users(key_name=user_key, userid=user_key, isEnabled="yes", accountRef=newacc, tags=user_key)
try:
memcache_db.delete_entity(newacc, user_key)
except Exception:
pass
# Save a user
ret = memcache_db.save_entity(newacc, user_key)
# Create a Badge Type
badge_key = "testbadge1"
badgetype = Badges(
key_name=badge_key,
name="badge1",
description=badge_key,
altText="a really cool badge",
setType="free",
isEnabled="yes",
creator=newacc,
permissions="private",
storageType="blob",
blobKey="xxxx",
)
try:
memcache_db.delete_entity(badgetype, badge_key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(badgetype, badge_key)
key = "testbadgeinstance1"
ent_type = "BadgeInstance"
badgeinstance = BadgeInstance(
key_name=key,
awarded="no",
badgeRef=badgetype,
userRef=newuser,
pointRequired=10,
pointsEarned=0,
permissions="private",
)
try:
memcache_db.delete_entity(badgeinstance, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(badgeinstance, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.awarded != "no":
return "Error getting same entity. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.awarded != "no":
return "Error getting same entity from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"pointsRequired": 11, "awarded": "no"}
inc_diction = {"pointsEarned": 5}
ret2 = memcache_db.update_fields(key, ent_type, diction, inc_diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.pointsRequired != 11 or sameent.pointsEarned != 5:
return "Error getting same entity after altering entity. Subtest 3"
# Cleanup
try:
memcache_db.delete_entity(badgeinstance, key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(newacc, account_key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(badgetype, badge_key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(newuser, user_key)
except Exception:
return "Error deleting entity. Subtest 4"
return "Success"
def save(acc_ref): memcache_db.save_entity(acc_ref, acc_ref.key().name())
def test3(self):
account_key = "[email protected]"
trophy_case_widget = TrophyCase(key_name=account_key)
points_widget = Points(key_name=account_key)
rank_widget = Rank(key_name=account_key)
newacc = Accounts(
key_name=account_key,
password="******",
email="[email protected]",
isEnabled="enabled",
accountType="bronze",
paymentType="free",
apiKey="xxx",
cookieKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget,
)
try:
memcache_db.delete_entity(newacc, account_key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, account_key)
key = "testuser1"
ent_type = "Users"
newacc = Users(key_name=key, userid=key, isEnabled="yes", accountRef=newacc, tags=key)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.tags != key:
return "Error getting same entity. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.tags != key:
return "Error getting same entity from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"tags": "goodbye:hello"}
ret2 = memcache_db.update_fields(key, ent_type, diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.tags != "goodbye:hello":
return "Error getting same entity after altering entity. Subtest 3"
try:
memcache_db.delete_entity(newacc, account_key)
memcache_db.delete_entity(sameent, key)
except Exception:
return "Error deleting entity. Subtest 4"
return "Success"
def save_user(user_ref, user_key): return memcache_db.save_entity(user_ref, user_key)
def test2(self):
account_key = "raj"
trophy_case_widget = TrophyCase(key_name=account_key)
points_widget = Points(key_name=account_key)
rank_widget = Rank(key_name=account_key)
newacc = Accounts(key_name=account_key,
password="******",
email="[email protected]",
isEnabled="enabled",
accountType="bronze",
paymentType="free",
apiKey="xxx",
cookieKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, account_key)
key = "testbadge1"
ent_type = "Badges"
newacc = Badges(key_name=key,
name="badge1",
description=key,
altText="a really cool badge",
setType="free",
isEnabled="yes",
creator=newacc,
permissions="private",
blobKey="xxxx",
storageType="blob")
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.description != key:
return "Error getting same account. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.description != key:
return "Error getting same account from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"isEnabled": "no", "permissions": "public"}
ret2 = memcache_db.update_fields(key, ent_type, diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.isEnabled != "no" or sameent.permissions != "public":
return "Error getting same account after altering entity. Subtest 3"
try:
memcache_db.delete_entity(sameent, key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(newacc, account_key)
except Exception:
return "Error deleting account. Subtest 5"
return "Success"
def test2(self):
account_key = "raj"
trophy_case_widget = TrophyCase(key_name=account_key)
points_widget = Points(key_name=account_key)
rank_widget = Rank(key_name=account_key)
newacc = Accounts(
key_name=account_key,
password="******",
email="[email protected]",
isEnabled="enabled",
accountType="bronze",
paymentType="free",
apiKey="xxx",
cookieKey="xxx",
trophyWidget=trophy_case_widget,
pointsWidget=points_widget,
rankWidget=rank_widget,
)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, account_key)
key = "testbadge1"
ent_type = "Badges"
newacc = Badges(
key_name=key,
name="badge1",
description=key,
altText="a really cool badge",
setType="free",
isEnabled="yes",
creator=newacc,
permissions="private",
blobKey="xxxx",
storageType="blob",
)
try:
memcache_db.delete_entity(newacc, key)
except Exception:
pass
# Save and get saved ent
ret = memcache_db.save_entity(newacc, key)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.description != key:
return "Error getting same account. Subtest 1"
# purge from memcache and get from db
memcache.delete(key=key, namespace=ent_type)
sameent = memcache_db.get_entity(key, ent_type)
if sameent.description != key:
return "Error getting same account from DB (no cache). Subtest 2"
# Set and get new user name
diction = {"isEnabled": "no", "permissions": "public"}
ret2 = memcache_db.update_fields(key, ent_type, diction)
ret2 = sameent.put()
if ret != ret2:
self.response.out.write("Error getting key name")
sameent = memcache_db.get_entity(key, ent_type)
if sameent.isEnabled != "no" or sameent.permissions != "public":
return "Error getting same account after altering entity. Subtest 3"
try:
memcache_db.delete_entity(sameent, key)
except Exception:
return "Error deleting entity. Subtest 4"
try:
memcache_db.delete_entity(newacc, account_key)
except Exception:
return "Error deleting account. Subtest 5"
return "Success"
