Exemplo n.º 1
0
  def post(self):
    isLocal = os.environ['SERVER_SOFTWARE'].startswith('Dev')
    if not isLocal:
      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')
    user_id = self.request.get('user')
    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

    user_key = users_dao.get_user_key(account_id, user_id)
    user_ref = users_dao.get_user(account_id, user_id)
    if user_ref:
      badge_instances = badges_dao.get_user_badges(user_ref)
      for b in badge_instances:
        badges_dao.delete_badge_instance(b.key().name())
      users_dao.delete_user(user_key)

    trophy_case_widget = TrophyCase(key_name=account_id)
    points_widget = Points(key_name=account_id)
    rank_widget = Rank(key_name=account_id)
    notifier_widget = Notifier(key_name=account_id)
    leader_widget = Leaderboard(key_name=account_id)
    milestones_widget = Milestones(key_name=account_id)
    acc = Accounts(key_name=account_id,
                   email=account_id,
                   password="******",
                   isEnabled=constants.ACCOUNT_STATUS.ENABLED, 
                   accountType="admin",
                   paymentType="free",
                   cookieKey="xxxxxxxxx", 
                   apiKey=api_key, 
                   trophyWidget=trophy_case_widget,
                   pointsWidget=points_widget,
                   rankWidget=rank_widget,
                   leaderWidget=leader_widget,
                   milestoneWidget=milestones_widget)

     # delete ten badges
    for ii in range(0,10):
      badgeKey = badges_dao.create_badge_key(account_id, badge_theme, str(ii), "private")
      badges_dao.delete_badge_image(badgeKey)
      badges_dao.delete_badge(badgeKey)

    widgets_dao.delete_widget(account_id, "TrophyCase")
    widgets_dao.delete_widget(account_id, "Points")
    widgets_dao.delete_widget(account_id, "Rank")
    widgets_dao.delete_widget(account_id, "Leaderboard")
    widgets_dao.delete_widget(account_id, "Notifier")
    widgets_dao.delete_widget(account_id, "Milestones")
    accounts_dao.delete_account(account_id)
    self.response.out.write(success_ret())
    return
Exemplo n.º 2
0
def get_entity(key_name, ent_type):
    if ent_type not in constants.PROTECTED_DB_TYPES:
        raise Exception()
    e = memcache.get(key=key_name, namespace=ent_type)
    if e:
        try:
            e = deserialize(e)
        except:
            logging.error(
                "Memcache_db: Unable to deserialize entity of type %s" %
                ent_type)
            e = None

    if not e:
        memcache.delete(key=key_name, namespace=ent_type)
        if ent_type == "Accounts":
            e = Accounts.get_by_key_name(key_name)
        elif ent_type == "Badges":
            e = Badges.get_by_key_name(key_name)
        elif ent_type == "BadgeInstance":
            e = BadgeInstance.get_by_key_name(key_name)
        elif ent_type == "BadgeImage":
            e = BadgeImage.get_by_key_name(key_name)
        elif ent_type == "Users":
            e = Users.get_by_key_name(key_name)
        elif ent_type == "TrophyCase":
            e = TrophyCase.get_by_key_name(key_name)
        elif ent_type == "Points":
            e = Points.get_by_key_name(key_name)
        elif ent_type == "Notifier":
            e = Notifier.get_by_key_name(key_name)
        elif ent_type == "Rank":
            e = Rank.get_by_key_name(key_name)
        elif ent_type == "PassPhrase":
            e = PassPhrase.get_by_key_name(key_name)
        elif ent_type == "Milestones":
            e = Milestones.get_by_key_name(key_name)
        elif ent_type == "Leaderboard":
            e = Leaderboard.get_by_key_name(key_name)
        else:
            raise Exception()
        if e:
            memcache.add(key=key_name,
                         value=str(serialize(e)),
                         namespace=ent_type)
    return e
Exemplo n.º 3
0
def __batch_get_entity(key_names, ent_type):
    if ent_type not in constants.PROTECTED_DB_TYPES:
        raise Exception()
    es = memcache.get_multi(keys=key_names, namespace=ent_type)
    ents = []
    db_ents = {}
    for key in key_names:
        e = None
        if key in es:
            try:
                e = deserialize(e)
                ents.append(e)
            except Exception, ex:
                logging.error(
                    "Memcache_db: Unable to deserialize entity of type %s with %s"
                    % (ent_type, str(ex)))
                e = None
        if not e:
            # These puts are in a loop, making this function slow
            memcache.delete(key=key, namespace=ent_type)
            if ent_type == "Accounts":
                dbent = Accounts.get_by_key_name(key)
                ents.append(dbebt)
                db_ents[key] = serialize(dbent)
            elif ent_type == "Badges":
                dbent = Badges.get_by_key_name(key)
                ents.append(dbebt)
                db_ents[key] = serialize(dbent)
            elif ent_type == "BadgeInstance":
                dbent = BadgeInstance.get_by_key_name(key)
                ents.append(dbebt)
                db_ents[key] = serialize(dbent)
            elif ent_type == "BadgeImage":
                dbent = BadgeImage.get_by_key_name(key)
                ents.append(dbebt)
                db_ents[key] = serialize(dbent)
            elif ent_type == "Users":
                dbent = Users.get_by_key_name(key)
                ents.append(dbebt)
                db_ents[key] = serialize(dbent)
            elif ent_type == "TrophyCases":
                dbent = TrophyCases.get_by_key_name(key)
                ents.append(dbebt)
                db_ents[key] = serialize(dbent)
            else:
                raise Exception()
Exemplo n.º 4
0
def __batch_get_entity(key_names, ent_type):
  if ent_type not in constants.PROTECTED_DB_TYPES:
    raise Exception()
  es = memcache.get_multi(keys=key_names, namespace=ent_type)
  ents = []
  db_ents = {}
  for key in key_names:
    e = None
    if key in es:
      try:
        e = deserialize(e) 
        ents.append(e)
      except Exception, ex:
        logging.error("Memcache_db: Unable to deserialize entity of type %s with %s"%(ent_type, str(ex)))
        e = None
    if not e:
      # These puts are in a loop, making this function slow
      memcache.delete(key=key, namespace=ent_type)
      if ent_type == "Accounts":
        dbent = Accounts.get_by_key_name(key)
        ents.append(dbebt)
        db_ents[key] = serialize(dbent)
      elif ent_type == "Badges":
        dbent = Badges.get_by_key_name(key)
        ents.append(dbebt)
        db_ents[key] = serialize(dbent)
      elif ent_type == "BadgeInstance":
        dbent = BadgeInstance.get_by_key_name(key)
        ents.append(dbebt)
        db_ents[key] = serialize(dbent)
      elif ent_type == "BadgeImage":
        dbent = BadgeImage.get_by_key_name(key)
        ents.append(dbebt)
        db_ents[key] = serialize(dbent)
      elif ent_type == "Users":
        dbent = Users.get_by_key_name(key)
        ents.append(dbebt)
        db_ents[key] = serialize(dbent)
      elif ent_type == "TrophyCases":
        dbent = TrophyCases.get_by_key_name(key)
        ents.append(dbebt)
        db_ents[key] = serialize(dbent)
      else:
        raise Exception()
Exemplo n.º 5
0
def get_entity(key_name, ent_type):
  if ent_type not in constants.PROTECTED_DB_TYPES:
    raise Exception()
  e = memcache.get(key=key_name, namespace=ent_type)
  if e:
    try:
      e = deserialize(e)
    except:
      logging.error("Memcache_db: Unable to deserialize entity of type %s"%ent_type)
      e = None 

  if not e:
    memcache.delete(key=key_name, namespace=ent_type)
    if ent_type == "Accounts":
      e = Accounts.get_by_key_name(key_name)
    elif ent_type == "Badges":
      e = Badges.get_by_key_name(key_name)
    elif ent_type == "BadgeInstance":
      e = BadgeInstance.get_by_key_name(key_name)
    elif ent_type == "BadgeImage":
      e = BadgeImage.get_by_key_name(key_name)
    elif ent_type == "Users":
      e = Users.get_by_key_name(key_name)
    elif ent_type == "TrophyCase":
      e = TrophyCase.get_by_key_name(key_name)
    elif ent_type == "Points":
      e = Points.get_by_key_name(key_name)
    elif ent_type == "Notifier":
      e = Notifier.get_by_key_name(key_name)
    elif ent_type == "Rank":
      e = Rank.get_by_key_name(key_name)
    elif ent_type == "PassPhrase":
      e = PassPhrase.get_by_key_name(key_name)
    elif ent_type == "Milestones":
      e = Milestones.get_by_key_name(key_name)
    elif ent_type == "Leaderboard":
      e = Leaderboard.get_by_key_name(key_name)
    else:
      raise Exception()
    if e:
      memcache.add(key=key_name,value=str(serialize(e)),namespace=ent_type)
  return e
Exemplo n.º 6
0
def is_in_db(key_name, ent_type):
  if ent_type not in constants.PROTECTED_DB_TYPES:
    raise Exception()
  e = None
  if ent_type == "Accounts":
    e = Accounts.get_by_key_name(key_name)
  elif ent_type == "Badges":
    e = Badges.get_by_key_name(key_name)
  elif ent_type == "BadgeInstance":
    e = BadgeInstance.get_by_key_name(key_name)
  elif ent_type == "BadgeImage":
    e = BadgeInstance.get_by_key_name(key_name)
  elif ent_type == "Users":
    e = Users.get_by_key_name(key_name)
  elif ent_type == "TrophyCases":
    e = TrophyCase.get_by_key_name(key_name)
  else:
    raise Exception()

  if e: return True
  else: return False
Exemplo n.º 7
0
def is_in_db(key_name, ent_type):
    if ent_type not in constants.PROTECTED_DB_TYPES:
        raise Exception()
    e = None
    if ent_type == "Accounts":
        e = Accounts.get_by_key_name(key_name)
    elif ent_type == "Badges":
        e = Badges.get_by_key_name(key_name)
    elif ent_type == "BadgeInstance":
        e = BadgeInstance.get_by_key_name(key_name)
    elif ent_type == "BadgeImage":
        e = BadgeInstance.get_by_key_name(key_name)
    elif ent_type == "Users":
        e = Users.get_by_key_name(key_name)
    elif ent_type == "TrophyCases":
        e = TrophyCase.get_by_key_name(key_name)
    else:
        raise Exception()

    if e: return True
    else: return False
Exemplo n.º 8
0
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
Exemplo n.º 9
0
def get_all_accounts():
  accounts = []
  aset = Accounts.all()
  for a in aset:
    accounts.append(get(a.email))
  return accounts
Exemplo n.º 10
0
def get_all_accounts():
  accounts = []
  aset = Accounts.all()
  for a in aset:
    accounts.append(get(a.email))
  return accounts