def get(self, collection): print "Get waypoints" parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) parser.add_argument('size', type=int, default=10) parser.add_argument('noTotal', type=ArgumentValidator.create('boolTrue'),default=False) parser.add_argument('newer', default=None) parser.add_argument('offset', type=int, default=None) # newer date - offset (in seconds) #parser.add_argument('only_approved',default=True) #parser.add_argument('collection',default='') #parser.add_argument('toplevel',default='') #parser.add_argument('count_greater',type=int,default=0) args = parser.parse_args() args.total = not args.noTotal #try: #toplevel_key=ndb.Key(urlsafe=args.toplevel) #except: #toplevel_key=None #try: #collection_key=ndb.Key(urlsafe=args.collection) #except: #return make_bad_request_exception("Wrong collection key") query = model.WayPoint.qry(collection=g.col_key,compare_date='>modified',date=args.newer, time_offset=args.offset) wps_future = query.fetch_page_async(args.size, start_cursor=args.cursor) if args.total: total_count_future = query.count_async(keys_only=True) wps, next_cursor, more = wps_future.get_result() wps = [u.to_dict(include=model.WayPoint.get_public_properties()) for u in wps] if args.total: total_count = total_count_future.get_result() else: total_count = None return make_list_response(wps, next_cursor, more, total_count)
def get(self): print "Get tags" parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) parser.add_argument('size', type=int, default=10) parser.add_argument('total', type=ArgumentValidator.create('boolTrue'),default=True) parser.add_argument('only_approved',default=True) parser.add_argument('collection',default='') parser.add_argument('toplevel',default='') parser.add_argument('count_greater',type=int,default=0) args = parser.parse_args() try: toplevel_key=ndb.Key(urlsafe=args.toplevel) except: toplevel_key=None try: collection_key=ndb.Key(urlsafe=args.collection) except: collection_key=None query = model.Tag.qry(toplevel=toplevel_key, collection=collection_key, only_approved=args.only_approved, count_greater=args.count_greater) tags_future = query.fetch_page_async(args.size, start_cursor=args.cursor) if args.total: total_count_future = query.count_async(keys_only=True) tags, next_cursor, more = tags_future.get_result() tags = [u.to_dict(include=model.Tag.get_public_properties()) for u in tags] #print next_cursor if args.total: total_count = total_count_future.get_result() else: total_count = None return make_list_response(tags, next_cursor, more, total_count)
def get(self, username): parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) parser.add_argument('q', type=str,default='') parser.add_argument('size', type=int,default=10) args = parser.parse_args() # current user key user_key = g.user_db.key if auth.is_admin() or user_db.key == auth.current_user_key(): query = model.CollectionUser.qry(user=user_key) collection_keys_future = query.fetch_async(limit=args.size*4,keys_only=True) # do something else here? collection_keys = collection_keys_future.get_result() collection_keys = [key.parent() for key in collection_keys] # Search for users in this collections users = []; for key in collection_keys: query = model.CollectionUser.query(ancestor=key) if len(args.q) > 2: query = query \ .filter(model.CollectionUser.user.username >= args.q) \ .filter(model.CollectionUser.user.username <= unicode(args.q) + u"\ufffd")\ .order(model.CollectionUser.user.username) else: query = query.order(model.CollectionUser.modified) users_future = query.fetch_async( limit=args.size, projection=['modified','user.username','user.email','user.avatar_url','user_key']) users = users + users_future.get_result() #users = users + [{'key':u.key,'modified':u.modified} for u in users_future.get_result()] # check if a user with this name or email exists: user_db = model.User.get_by_email_or_username(args.q) if len(args.q)>2 else None if user_db: # create temp user with modified now -> first in list user = model.CollectionUser( user_key= user_db.key, user = model.User(username = user_db.username, email = user_db.email, avatar_url = user_db.avatar_url), name = "Just Temp User", modified = datetime.datetime.now(), created = datetime.datetime.now() ) users.append(user) # sort users after its last modification users = util.sort_uniq(users,'modified','user_key',reverse=False) #users = [u.urlsafe() for u in users] users = [u.to_dict(include=['modified','user','user_key']) for u in users] total = len(users) if total > args.size: users = users[:args.size] return make_list_response(users, None, total > args.size, total)
def get(self): parser = reqparse.RequestParser() parser.add_argument("cursor", type=ArgumentValidator.create("cursor")) args = parser.parse_args() users_future = User.query().order(-User.created).fetch_page_async(10, start_cursor=args.cursor) total_count_future = User.query().count_async(keys_only=True) users, next_cursor, more = users_future.get_result() users = [u.to_dict(include=User.get_public_properties()) for u in users] return make_list_response(users, next_cursor, more, total_count_future.get_result())
def post(self): """Sends feedback email to admin""" if not config.CONFIG_DB.feedback_email: return abort(418) parser = reqparse.RequestParser() parser.add_argument('message', type=ArgumentValidator.create('feedback'), required=True) parser.add_argument('email', type=UserValidator.create('email', required=False)) args = parser.parse_args() body = '%s\n\n%s' % (args.message, args.email) kwargs = {'reply_to': args.email} if args.email else {} task.send_mail_notification('%s...' % body[:48].strip(), body, **kwargs) return make_empty_ok_response()
def get(self): parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) args = parser.parse_args() positions_future = Position.query() \ .order(-Position.created) \ .fetch_page_async(10, start_cursor=args.cursor) total_count_future = Position.query().count_async(keys_only=True) positions, next_cursor, more = positions_future.get_result() positions = [u.to_dict(include=Position.get_public_properties()) for u in positions] return make_list_response(positions, next_cursor, more, total_count_future.get_result())
def get(self): parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) args = parser.parse_args() items_future = Hackathon.query() \ .order(-Hackathon.modified) \ .fetch_page_async(10, start_cursor=args.cursor) total_count_future = Hackathon.query().count_async(keys_only=True) items, next_cursor, more = items_future.get_result() items = [u.to_dict(include=Hackathon.get_public_properties()) for u in items] return make_list_response(items, next_cursor, more, total_count_future.get_result())
def get(self): parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) parser.add_argument('page') parser.add_argument('keyword') parser.add_argument('location') args = parser.parse_args() keyw = args.get('keyword') loc = args.get('location') page = args.get('page') if not keyw: keyw = "" if not loc: loc = "" if not page: page=0 else: page=int(page) positions_future = Position.query() \ .order(-Position.created) \ .fetch_page_async(10000, start_cursor=args.get('cursor')) total_count_future = Position.query().count_async(keys_only=True) positions, next_cursor, more = positions_future.get_result() positions = [p.to_dict(include=Position.get_public_properties()) for p in positions] pos = [] pos = [elem for elem in positions if (elem["title"].find(keyw) != -1 or elem["description"].find(keyw) != -1) and elem["location"].find(loc) != -1] ipage=10 until=((page+1)*ipage) if until > len(pos): until=len(pos) npos = pos[page*ipage:until] pages=math.ceil(len(pos)/float(ipage)) # for x in range(0,len(positions)): # if positions[x]["title"].find(keyw) != -1: # pos.append(positions[x]) return make_new_list_response(npos, pages, len(npos), len(pos), page*ipage)
def get(self): parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) parser.add_argument('description') parser.add_argument('location') args = parser.parse_args() positions_future = Position.query() \ .order(-Position.created) \ .fetch_page_async(10, start_cursor=args.cursor) total_count_future = Position.query().count_async(keys_only=True) positions, next_cursor, more = positions_future.get_result() positions = [p.to_json() for p in positions] positions = [p for p in positions if args.description.lower() in p["description"].lower()] positions = [p for p in positions if args.location.lower() in p["location"].lower()] return make_list_response(positions, next_cursor, more, total_count_future.get_result())
def get(self, key): parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) args = parser.parse_args() user_id = g.model_db.id() if auth.current_user_db().id() != user_id: # not allowed to access other registrations return ApiException.error(403) items_future = Hackathon.query(Hackathon.user_id==user_id) \ .order(-Hackathon.modified) \ .fetch_page_async(10, start_cursor=args.cursor) total_count_future = Hackathon.query(Hackathon.user_id==user_id).count_async(keys_only=True) items, next_cursor, more = items_future.get_result() items = [u.to_dict(include=Hackathon.get_public_properties()) for u in items] return make_list_response(items, next_cursor, more, total_count_future.get_result())
def get(self, collection,query): parser = reqparse.RequestParser() parser.add_argument('cursor', type=ArgumentValidator.create('cursor')) #parser.add_argument('q', type=str,default='') parser.add_argument('size', type=int,default=30) parser.add_argument('only_names', type=ArgumentValidator.create('boolTrue'),default=False) args = parser.parse_args() tags = [] try: collection = ndb.Key(urlsafe=collection) except: collection = model.Collection.top_key() # Check if the user has read permission for the collection TODO if auth.is_admin(): # check if name is already a full tag key = model.Tag.tag_to_key(query,collection) try: db = key.get() except: key = model.Tag.tag_to_key(query) try: db = key.get() except: db = False if db: dbs_related, more = db.related(char_limit=200) #tags = [db.name] + db.related() tags = [r.related_to for r in dbs_related] tags = [db.name] + tags else: gae_qry = model.Tag.query(model.Tag.collection == collection) if len(query) > 1: gae_qry = gae_qry \ .filter(model.Tag.name >= query) \ .filter(model.Tag.name <= unicode(query) + u"\ufffd")\ .order(model.Tag.name) else: gae_qry = gae_qry.order(model.Tag.cnt) tags_future = gae_qry.fetch_async( limit=args.size, projection=['name']) tags = tags_future.get_result() tags = [r.name for r in tags] rel_tags = [] for tag in tags: key = model.Tag.tag_to_key(tag,collection) try: db = key.get() if db: dbs_related, more = db.related(char_limit=100) rel_tags = [r.related_to for r in dbs_related] tags = tags+rel_tags #[:5] except: pass if len(tags) > args.size+5: break #tags = list(set(tags)) tags = list(OrderedDict.fromkeys(tags)) total = len(tags) tags = tags[:args.size] if not args.only_names: tags = model.Tag.get_tag_infos(tags,collection) return make_list_response(tags, False, total > len(tags), total)
def get(self): parser = default_parser() parser.add_argument('expenses', type=ArgumentValidator.create('boolTrue'),default=False) parser.add_argument('travelers', type=ArgumentValidator.create('boolTrue'),default=False) parser.add_argument('locations', type=ArgumentValidator.create('boolTrue'),default=False) args = parser.parse_args() compare ,date = to_compare_date(args.newer, args.older, args.orderBy) query = model.Trip.qry(order_by_date=args.orderBy, \ compare_date = compare, date = date, time_offset=args.offset, \ ancestor=auth.current_user_key()) dbs_future = query.fetch_page_async(args.size, start_cursor=args.cursor) # Count how many results are available (only of prameter total is given!) total_count_future = query.count_async(keys_only=True) if args.total else False # Get result, this is needed to do the other things. dbs, next_cursor, more = dbs_future.get_result() # Create already a dictionary, this is used to add data instead of keys dbs = [db.to_dict(include=model.Trip.get_public_properties()) for db in dbs] # get locations async (only if not only keys are requested) if (args.locations): locs_future = [] for db in dbs: if db['locations']: locs_future.append(ndb.get_multi_async([ndb.Key(urlsafe=key) for key in db['locations']])) else: locs_future.append(None) i=0 for loc_future in locs_future: if loc_future: # is a locatio given? locs = [f.get_result() for f in loc_future] locs = [db.to_dict(include=model.Location.get_public_properties()) for db in locs] u=0 if (args.expenses or args.travelers or True): for loc in locs: for trans in ['trans_start','trans_end']: wayPt = locs[u][trans].get('waypoints',[]) locs[u][trans]['geo'] = wayPt[-1] if len(wayPt) > 0 else None if args.travelers: locs[u]['fellow_travelers'] = [ndb.Key(urlsafe=db).get().to_dict(include= model.FellowTraveler.get_public_properties()) for db in loc['fellow_travelers']] if args.expenses: #print "Get expenses" #print loc['expenses'] locs[u]['expenses'] = [{"amount": e['amount'] if 'amount' in e else 0, "note": e['note'] if 'note' in e else "", "type":ndb.Key(urlsafe=e['type']).get(). to_dict(include=model.ExpenseType.get_public_properties()) if 'type' in e and e['type'] else None} for e in loc['expenses']] u+=1 dbs[i]['locations'] = locs else: # empty locations dbs[i]['locations'] = [] i += 1 #dbs = [db.to_dict(include=model.Trip.get_public_properties()) for db in dbs] total_count = total_count_future.get_result() if total_count_future else False return make_list_response(dbs, next_cursor, more, total_count)