py_tasks_melange: comparison app/soc/logic/model.py

equal deleted inserted replaced

-:812abb9a7e3b
+:972d28056d9d
 from soc.logic import out_of_band
 def getFullClassName(cls):
 """Returns fully-qualified module.class name string."""
 return '%s.%s' % (cls.__module__, cls.__name__)
 def buildTypedQueryString(base_class, derived_class=None):
 """Returns a GQL query string compatible with PolyModel.
 derived_class: optional more-specific Model class that
 derives from base_class, such as soc.models.document.Document;
 default is None, in which case the inheritance_line
 property is *not* tested by the returned query string
 """
 query_str_parts = ['SELECT * FROM ', base_class.__name__]
 if derived_class:
 query_str_parts.extend(
 [" WHERE inheritance_line = '", getFullClassName(derived_class), "'"])
 base_class, derived_class: see buildTypedQueryString()
 order_by: optional field name by which to order the query results;
 default is None, in which case no ORDER BY clause is placed in
 the query string
 """
 query_str_parts = [
 buildTypedQueryString(base_class, derived_class=derived_class)]
 if order_by:
 query_str_parts.extend([' ORDER BY ', order_by])
 Args:
 limit: max amount of entities to return
 offset: optional offset in entities list which defines first entity to
 return; default is zero (first entity)
 """
 query_string = buildOrderedQueryString(
 base_class, derived_class=derived_class, order_by=order_by)
 query = db.GqlQuery(query_string)
 of the supplied (non-None) fields
 OR
 possibly None if query had no results for the supplied field
 that was used.
 """
 # SELECT * FROM base_class WHERE inheritance_line = 'derived_class'
 typed_query_str = buildTypedQueryString(
 base_class, derived_class=derived_class)
 if derived_class:
 if that offset would be less than zero
 OR
 None if there are no nearest entities or the offset of the beginning of
 the range cannot be found for some reason
 """
 # find entity "nearest" to supplied fields
 nearest_entities, field = getNearestEntities(
 base_class, fields_to_try, derived_class=derived_class)
 if not nearest_entities:
 """"Returns User entity for key_name or None if not found.
 -
 -    Args:
 -      key_name: key name of entity
 """
 return self._model.get_by_key_name(key_name)
 def getFromFields(self, **kwargs):
 """Returns the entity for a given link name, or None if not found.
 Args:
-link_name: a link name of the entity that uniquely identifies it
+**kwargs: the fields of the entity that uniquely identifies it
 """
-# lookup by Sponsor key name
 key_name = self.getKeyNameForFields(**kwargs)
 if key_name:
 entity = self._model.get_by_key_name(key_name)
 else:
 entity = None
 return entity
 def getIfFields(self, **kwargs):
-"""Returns Sponsor entity for supplied link name if one exists.
+"""Returns entity for supplied link name if one exists.
 Args:
-link_name: a link name of the Sponsor that uniquely identifies it
+**kwargs: the fields of the entity that uniquely identifies it
 Returns:
-* None if link name is false.
+* None if a field is false.
-* Sponsor entity for supplied link_name
+* Eentity for supplied fields
 Raises:
 out_of_band.ErrorResponse if link name is not false, but no Sponsor entity
 with the supplied link name exists in the Datastore
 """
 if not all(kwargs.values()):
 # exit without error, to let view know that link_name was not supplied
 return None
 entity = self.getFromFields(**kwargs)
 return entity
 fields = []
 for key, value in kwargs.iteritems():
-fields.extend('"%s" is "%s"' % (key, value))
+fields.extend('"%s" is "%s" ' % (key, value))
 # else: fields were supplied, but there is no Entity that has it
 raise out_of_band.ErrorResponse(
 'There is no %s with %s.' % (self._name, ''.join(fields)), status=404)
 def getKeyNameForFields(self, **kwargs):
-"""Return a Datastore key_name for a Sponsor from the link name.
+"""Return a Datastore key_name for a Entity from the specified fields.
 Args:
-link_name: a link name of the entity that uniquely identifies it
+**kwargs: the fields of the entity that uniquely identifies it
 """
 if not all(kwargs.values()):
 return None
 return self._keyName(**kwargs)
 Args:
 limit: max amount of entities to return
 offset: optional offset in entities list which defines first entity to
 return; default is zero (first entity)
 """
 query = self._model.all()
 return query.fetch(limit, offset)
 def updateModelProperties(self, model, **model_properties):
 """Update existing model entity using supplied model properties.
 properties and their values
 Returns:
 the original model entity with any supplied properties changed
 """
 def update():
 return self._unsafeUpdateModelProperties(model, **model_properties)
 return db.run_in_transaction(update)
 def _unsafeUpdateModelProperties(self, model, **model_properties):
 """(see updateModelProperties)
 Like updateModelProperties(), but not run within a transaction.
 """
 properties = model.properties()
 for prop in properties.values():
 name = prop.name
 def updateOrCreateFromKeyName(self, properties, key_name):
 """Update existing entity, or create new one with supplied properties.
 Args:
-link_name: a link_name of the entity that uniquely identifies it
+properties: dictionairy with entity properties and their values
-**properties: keyword arguments that correspond to entity
+key_name: the key_name of the entity that uniquely identifies it
-properties and their values
 Returns:
 the entity corresponding to the key_name, with any supplied
 properties changed, or a new entity now associated with the
 supplied key_name and properties.
 """Delete existing entity from datastore.
 Args:
 entity: an existing entity in datastore
 """
 entity.delete()

changeset 305	972d28056d9d
parent 303	4f1bb54ddae5
child 310	0386d634ad9f