def create(cls, ancestor_model, data): items = getattr(ancestor_model, cls.JSON_NAME) or [] item_data = _.pick(data, cls.PUBLIC_PROPERTIES) prev_keys = [] for item in items: # get all prev keys prev_keys.append(item.key) # keep track of all used keys item_db = cls( key=str(uuid.uuid4()), **item_data) is_valid, error = cls.is_valid(item_db) if not is_valid: return False, error while True: # generate a unique key for this new workplace try: prev_keys.index(item_db.key) item_db.key = str(uuid.uuid4()) except ValueError: break items.append(item_db) setattr(ancestor_model, cls.JSON_NAME, items) ancestor_model.put() return True, item_db.to_dict(include=cls.PUBLIC_PROPERTIES)
def populate(self, **kwargs): """Extended ndb.Model populate method, so it can ignore properties, which are not defined in model class without throwing error """ kwargs = _.omit(kwargs, Base.PUBLIC_PROPERTIES + ['key', 'id']) # We don't want to populate those properties kwargs = _.pick(kwargs, _.keys(self._properties)) # We want to populate only real model properties super(Base, self).populate(**kwargs)
def put(self, collection): """Updates waypoint properties""" print "Update waypoint property" update_properties = ['name', 'creator', 'description', 'key'] # TODO urls update_properties = ['collection', 'key','name','description','tags','geo'] data = _.pick(request.json, update_properties) if 'collection' not in data: if data['collection'] != collection: return make_bad_request_exception("Wrong collection key") else: data['collection'] = collection if 'creator' not in data: data['creator'] = auth.current_user_key() else: data['creator'] = ndb.Key(urlsafe=data['creator']) if 'geo' in data: data['geo'] = ndb.GeoPt(data['geo']) try: data['key'] = ndb.Key(urlsafe=data['key']) except: data['key'] = None try: data['collection'] = ndb.Key(urlsafe=data['collection']) except: return make_bad_request_exception("Wrong collection key") #print data # TODO key from new data or as argument key = model.WayPoint.create_or_update(**data) return {'key':key.urlsafe(),'id':key.id()}
def put(self, key): """Updates expense type's properties""" update_properties = ['name', 'description', 'icon_url', 'icon_name', 'added_by','key'] new_data = _.pick(request.json, update_properties) new_data['added_by'] = ndb.Key(urlsafe=new_data['added_by']) key = model.ExpenseType.create_or_update(urlsafe=True, **new_data) properties = model.ExpenseType.get_public_properties() return key.get().to_dict(include=properties)
def put(self, key): """Updates positions's properties""" update_properties = [ "title", "location", "type_", "description", "how_to_apply", "company", "company_url", "company_logo"] new_data = _.pick(request.json, update_properties) g.model_db.populate(**new_data) g.model_db.put() return new_data, 200
def put(self, key): """Updates user's properties""" update_properties = ['created_at', 'title', 'location', 'type_', 'description', 'how_to_apply', 'company', 'company_url', 'company_logo', 'url'] new_data = _.pick(request.json, update_properties) g.model_db.populate(**new_data) g.model_db.put() return make_empty_ok_response()
def put(self, key): """Updates user's properties""" update_properties = ['name', 'bio', 'email', 'location', 'facebook', 'github', 'gplus', 'linkedin', 'twitter', 'instagram'] if auth.is_admin(): update_properties += ['verified', 'active', 'admin'] new_data = _.pick(request.json, update_properties) g.model_db.populate(**new_data) g.model_db.put() return make_empty_ok_response()
def post(self, key): user_id = g.model_db.id() if auth.current_user_db().id() != user_id: # not allowed to create registrations for other people return ApiException.error(403) item_db = Hackathon.get_or_create(g.model_db, 'spring_2016') # this is the name of the hackathon on feb 19, 2016 update_properties = ['rsvp', 'resume', 'skills', 'maker', 'phone', 'shirt', 'gender', 'superpower'] new_item_data = _.pick(request.json, update_properties) item_db.populate(**new_item_data) item_db.put() return item_db.to_dict(include=Hackathon.get_public_properties())
def put(self, key): user_id = g.model_db.id() profile = Profile.get_by('user_id', user_id) if auth.current_user_db().id() != user_id: # logged in return ApiException.error(108) new_profile_data = _.pick(request.json, Profile.ALL_NON_STRUCTURED_PROPERTIES) profile.populate(**new_profile_data) profile.put() return profile.to_dict(include=profile.get_all_properties())
def put(self, key): """Updates user's properties""" update_properties = [ 'name', 'bio', 'email', 'location', 'facebook', 'github', 'gplus', 'linkedin', 'twitter', 'instagram' ] if auth.is_admin(): update_properties += ['verified', 'active', 'admin'] new_data = _.pick(request.json, update_properties) g.model_db.populate(**new_data) g.model_db.put() return make_empty_ok_response()
def put(self, key, item_key): item_db = ndb.Key(urlsafe=item_key).get() if not item_db: return ApiException.error(404) if auth.current_user_db().id() != item_db.user_id: return ApiException.error(403) update_properties = ['rsvp', 'resume', 'skills', 'makers', 'phone', 'shirt', 'gender', 'superpower'] new_profile_data = _.pick(request.json, update_properties) item_db.populate(**new_profile_data) item_db.put() return item_db.to_dict(include=Hackathon.get_public_properties())
def update(cls, ancestor_model, key, data): items = getattr(ancestor_model, cls.JSON_NAME) or [] item_data = _.pick(data, cls.PUBLIC_PROPERTIES) for index, item in enumerate(items): if item.key == key: item.populate(**item_data) is_valid, error = cls.is_valid(item) if not is_valid: return False, error items[index] = item setattr(ancestor_model, cls.JSON_NAME, items) ancestor_model.put() return True, item.to_dict(include=cls.PUBLIC_PROPERTIES) return False, cls.JSON_NAME + ' not found'
def create_or_update(cls,key=None, urlsafe=False, parent=None, **kwargs): """ Updates an entity or creates a new one. If key is None it creates a new entity, if key is set it gets it. Returns key """ def omit(data, omit_list): values = {} for k, v in data.iteritems(): if isinstance(v, dict): # iterable, not string values[k] = omit(v,omit_list) elif k not in omit_list: values[k] = v return values print "CREATE OR UPDATE" print cls if key and (key != "new" or key !="add"): print "GOT key" print key if urlsafe: print "User urlsave" key = ndb.Key(urlsafe=key) print key db = key.get() print kwargs kwargs = omit(kwargs, Base.PUBLIC_PROPERTIES + ['key', 'id']) # We don't want to populate those properties print "kwargs after omiting" print "=============================" print kwargs db.populate(**kwargs) else: print "Save new one" print "properties are:" print _.keys(cls._properties) # We don't want to populate those properties kwargs = omit(kwargs, Base.PUBLIC_PROPERTIES + ['key', 'id']) # We want to populate only real model properties kwargs = _.pick(kwargs, _.keys(cls._properties)) # TODO should be deep! print "____________________________________" print "kwargs" print kwargs db = cls(parent=parent,**kwargs) key = db.put() return key
def dict_to_list(input_dict): """Creates list from dictionary with true booloean values This function is primarily useful for converting passed data from Angular checkboxes, since angular ng-model can't return list of checked group of checkboxes, instead it returns something like {'a': True, 'b': True} for each checkbox Example: >>> dict_to_list({'a': True, 'b': True, 'c': False}) ['a', 'b'] Args: input_dict (dict): Dict with boolean values Returns: list: list of truthful values """ return _.keys(_.pick(input_dict, _.identity))
def post(self, key): """Updates simulation's properties""" update_properties = ['name', 'description', 'location', 'soil_attributes', 'start_date', 'end_date', 'crop_name', 'sowing_date', 'tsum1', 'tsum2'] if auth.is_admin(): update_properties += ['owner_id'] new_data = _.pick(request.json, update_properties) print("SAVE POST: Received simulation data: ", new_data) g.model_db.populate(**new_data) g.model_db.put() #return make_empty_ok_response() if auth.is_admin(): properties = Simulation.get_private_properties() else: properties = Simulation.get_public_properties() return g.model_db.to_dict(include=properties)
def post(self, key): """Updates user's properties""" update_properties = [ 'name', 'bio', 'email', 'location', 'avatar_url', 'facebook', 'github', 'gplus', 'linkedin', 'twitter', 'instagram' ] if auth.is_admin(): update_properties += ['verified', 'active', 'admin'] new_data = _.pick(request.json, update_properties) g.model_db.populate(**new_data) g.model_db.put() #return make_empty_ok_response() if auth.is_admin(): properties = User.get_private_properties() else: properties = User.get_public_properties() return g.model_db.to_dict(include=properties)
def post(self): new_data = _.pick(request.json, Crumb.get_public_properties()) crumb = Crumb() crumb.populate(**new_data) mapbox_params = { 'url': 'https://api.mapbox.com/geocoding/v5/mapbox.places', 'token': 'pk.eyJ1Ijoic2lkaGFydGEiLCJhIjoiY2ltczg2OW1yMDFpNHZsbTR6MWs5ZHlwbSJ9.T5h2oS8vItUFM9__uoRvaA', 'lng': crumb.lng, 'lat': crumb.lat } mapbox_url = '{url}/{lng},{lat}.json?access_token={token}&types=address'.format(**mapbox_params) response = json.load(urllib2.urlopen(mapbox_url)) addresses = response['features'] if addresses != None and len(addresses): crumb.place = addresses[0]['place_name'] crumb.put() return make_empty_ok_response()
def post(self, key): """Updates user's properties""" update_properties = [ 'first_name', 'last_name', 'avatar_url', 'email', 'username' ] if auth.is_admin(): update_properties += ['verified', 'active', 'admin'] new_user_data = _.pick(request.json, update_properties) new_email_set = False new_email = new_user_data.get('email') if new_email != g.model_db.email: UserValidator.create('unique_email')(new_email) new_email_set = True new_username = new_user_data.get('username') if new_username != g.model_db.username: UserValidator.create('unique_username')(new_username) g.model_db.populate(**new_user_data) g.model_db.put() return g.model_db.to_dict(include=User.get_public_properties())
def put(self, key): """Updates user's properties""" update_properties = [ "name", "bio", "email", "location", "facebook", "github", "gplus", "linkedin", "twitter", "instagram", ] if auth.is_admin(): update_properties += ["verified", "active", "admin"] new_data = _.pick(request.json, update_properties) g.model_db.populate(**new_data) g.model_db.put() return make_empty_ok_response()
def post(self): new_data = _.pick(request.json, Crumb.get_public_properties()) crumb = Crumb() crumb.populate(**new_data) mapbox_params = { 'url': 'https://api.mapbox.com/geocoding/v5/mapbox.places', 'token': 'pk.eyJ1Ijoic2lkaGFydGEiLCJhIjoiY2ltczg2OW1yMDFpNHZsbTR6MWs5ZHlwbSJ9.T5h2oS8vItUFM9__uoRvaA', 'lng': crumb.lng, 'lat': crumb.lat } mapbox_url = '{url}/{lng},{lat}.json?access_token={token}&types=address'.format( **mapbox_params) response = json.load(urllib2.urlopen(mapbox_url)) addresses = response['features'] if addresses != None and len(addresses): crumb.place = addresses[0]['place_name'] crumb.put() return make_empty_ok_response()
def put(self, key): # TODO check and use key if given """Updates expense type's properties""" update_properties = ['name', 'description', 'avatar_url', 'locations','key'] new_data = _.pick(request.json, update_properties) #new_data['added_by'] = ndb.Key(urlsafe=new_data['added_by']) # get trip key (if new) print "UPDATE TRIP" print new_data print "key" print new_data.get('key') if new_data.get("key","new") == "new" or new_data.get("key") == "add" : trip_key = model.Trip.create_or_update(urlsafe=True, parent=auth.current_user_key(), name=new_data['name']) new_data['key'] = trip_key.urlsafe(); else: trip_key = ndb.Key(urlsafe=new_data.get("key")) # prepare data loc_keys = [] for loc in new_data['locations']: user_keys = [] for user in loc['fellow_travelers']: if user.get("new",True): user_keys.append(model.FellowTraveler.create_or_update(urlsafe=True, parent=auth.current_user_key(), added_by=auth.current_user_key(), **user)) else: user_keys.append(ndb.Key(urlsafe=user.get("key",False))) loc['fellow_travelers'] = user_keys start_date = datetime.datetime.strptime(loc['start_datetime'][0:19],"%Y-%m-%dT%H:%M:%S") if loc.get('start_datetime',False) else None end_date = datetime.datetime.strptime(loc['end_datetime'][0:19],"%Y-%m-%dT%H:%M:%S") if loc.get('end_datetime',False) else None print "Dates are:" print start_date print end_date loc['start_datetime'] = start_date loc['end_datetime'] = end_date loc['trip'] = trip_key if loc['geo']: loc['geo'] = ndb.GeoPt(lat=loc['geo']['lat'],lon=loc['geo']['lng']) print "SAVE EXPENSES" if loc['expenses']: loc['expenses'] = [{"amount":float(e.get('amount',0) or 0), "note":e.get('note',""), "type":ndb.Key(urlsafe=e['type']) if e.get('type',False) else None} for e in loc['expenses']] print loc['expenses'] if 'trans_start' in loc: loc['trans_start']['waypoints'] = [ndb.GeoPt(lat=m.get('lat'),lon=m.get('lng')) for m in loc['trans_start'].get('waypoints',[])] if 'trans_end' in loc: loc['trans_end']['waypoints'] = [ndb.GeoPt(lat=m.get('lat'),lon=m.get('lng')) for m in loc['trans_end'].get('waypoints',[])] #loc['trans_end']['waypoints'] = [ndb.GetPt(lat=m.lat,lon=m.lng) for m in loc.trans_end.get('waypoints',[])[])] if loc.get("new",True): print "Save/update location" loc_keys.append(model.Location.create_or_update(urlsafe=True,\ parent=auth.current_user_key(), **loc)) else: print "Don't save/update location (not changes)" loc_keys.append(ndb.Key(urlsafe=loc.get("key",False))) new_data['locations'] = loc_keys key = model.Trip.create_or_update(urlsafe=True, parent=auth.current_user_key(), **new_data) properties = model.Trip.get_public_properties() return key.get().to_dict(include=properties)
def pick(self, obj, attributes): def map_function(value, key): return self.key_for_attribute(key) return _.map_keys(_.pick(obj, attributes), map_function)