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_session(self, request, email, ssid, expiration): """ Encrypt parameters, set valid in DB, set cookie on client """ account = memcache_db.get_entity(email, "Accounts") if account != None: update_fields = {"cookieKey" : ssid} memcache_db.update_fields(email, "Accounts", update_fields) email_enc = encryption.des_encrypt_str(email) ssid_enc = encryption.des_encrypt_str(ssid) exp_enc = encryption.des_encrypt_str(expiration) import base64 import string email_encoded = string.rstrip(base64.encodestring(email_enc), "\n") ssid_encoded = string.rstrip(base64.encodestring(ssid_enc), "\n") exp_encoded = string.rstrip(base64.encodestring(exp_enc), "\n") # the email will be set as the key so we can use it to look up in the DB request.response.headers.add_header("Set-Cookie", WEB_ADMIN_PARAMS.COOKIE_EMAIL_PARAM + "=" + email_encoded) request.response.headers.add_header("Set-Cookie", WEB_ADMIN_PARAMS.COOKIE_KEY_PARAM + "=" + ssid_encoded) request.response.headers.add_header("Set-Cookie", WEB_ADMIN_PARAMS.COOKIE_EXPIRATION + "=" + exp_encoded) """ Create a new session object and return it """ self.email = email self.ssid = ssid self.expiration = expiration self.account = account return self else: return None
def terminate(self): """ Remove cookie_key from datastore """ email = self.email if email != None and email != "": account = memcache_db.get_entity(self.email, "Accounts") if account != None: update_fields = {"cookieKey" : "nada" } memcache_db.update_fields(email, "Accounts", update_fields)
def change_account_password(email, new_password): """ Change value in data store, also do hashing """ values = {"password": hashlib.sha1(new_password).hexdigest()} try: memcache_db.update_fields(email, "Accounts", values) return True except: logging.info("Password change failed.") return False
def change_account_password(email, new_password): """ Change value in data store, also do hashing """ values = {"password" : hashlib.sha1(new_password).hexdigest()} try: memcache_db.update_fields(email, "Accounts", values) return True except: logging.info("Password change failed.") return False
def update_badge_instance(badge_key, diction, incr_fields): # Get the old one, and if it was just now awarded set the date/time if "awarded" in diction and diction["awarded"] == "yes": try: badge_ref = memcache_db.get_entity(badge_instance_key, "BadgeInstance") if badge_ref and badge_ref.awarded == "no": diction["awardDate"] = datetime.date.today() diction["awardDateTime"] = datetime.datetime.now() except: diction["awardDate"] = datetime.date.today() diction["awardDateTime"] = datetime.datetime.now() return memcache_db.update_fields(badge_key, "BadgeInstance", fields=diction, increment_fields=incr_fields)
def update_widget_property(email, entity_name, property_name, property_value): """ Saves desired property with new value for the specified entity type """ """ Check to see if the value string is a number or boolean """ logging.info("Try to persist value, but first find out what it is!") try: value = long(property_value) update_fields = { property_name : value } memcache_db.update_fields(email, entity_name, update_fields) logging.info("Seems to be a number") return True except: try: bool_value = bool(property_value) if property_value == "True": update_fields = { property_name : True } else: update_fields = { property_name : False } memcache_db.update_fields(email, entity_name, update_fields) logging.info("Seems to be a boolean") return True except: try: update_fields = { property_name : property_value } memcache_db.update_fields(email, entity_name, update_fields) logging.info("Seems to be a string") return True except: return False
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 update_badge_instance(badge_key, diction, incr_fields): # Get the old one, and if it was just now awarded set the date/time if 'awarded' in diction and diction['awarded'] == "yes": try: badge_ref = memcache_db.get_entity(badge_instance_key, "BadgeInstance") if badge_ref and badge_ref.awarded == "no": diction['awardDate'] = datetime.date.today() diction['awardDateTime'] = datetime.datetime.now() except: diction['awardDate'] = datetime.date.today() diction['awardDateTime'] = datetime.datetime.now() return memcache_db.update_fields(badge_key, "BadgeInstance", fields=diction, increment_fields=incr_fields)
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 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 add_resource_link(badge_key, url): diction = {'resourceLink': url} return memcache_db.update_fields(badge_key, "Badges", fields=diction)
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 update_user(user_key, dict, incr_fields): return memcache_db.update_fields(user_key, "Users", fields=dict, increment_fields=incr_fields)
def add_expiration(badge_key, date): diction = {'expiration': date} return memcache_db.update_fields(badge_key, "Badges", fields=diction)
def set_user_points(account_id, user_id, points): fields = {"points" : points} user_key = get_user_key(account_id, user_id) return memcache_db.update_fields(user_key, "Users", fields)
def set_user_points(account_id, user_id, points): fields = {"points": points} user_key = get_user_key(account_id, user_id) return memcache_db.update_fields(user_key, "Users", fields)
def add_resource_link(badge_key, url): diction = {"resourceLink": url} return memcache_db.update_fields(badge_key, "Badges", fields=diction)
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 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 add_expiration(badge_key, date): diction = {"expiration": date} return memcache_db.update_fields(badge_key, "Badges", fields=diction)