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 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 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)
