py_tasks_melange: comparison app/soc/logic/models/base.py

equal deleted inserted replaced

-:97c4a718d6f4
+:13efb916a73c
 class Error(Exception):
 """Base class for all exceptions raised by this module.
 """
+pass
+class InvalidArgumentError(Error):
+"""Raised when an invalid argument is passed to a method.
+For example, if an argument is None, but must always be non-False.
+"""
+pass
+class NoEntityError(InvalidArgumentError):
+"""Raised when no entity is passed to a method that requires one.
+"""
 pass
 class Logic(object):
 """Base logic for entity classes.
 entity: the unaltered entity
 name: the name of the field to be changed
 value: the new value
 """
+if not entity:
+raise NoEntityError
+if not entity_properties or (name not in entity_properties):
+raise InvalidArgumentError
 return True
 def _onCreate(self, entity):
 """Called when an entity has been created.
 Classes that override this can use it to do any post-creation operations.
 """
+if not entity:
+raise NoEntityError
 sidebar.flush()
 def _onUpdate(self, entity):
 """Called when an entity has been updated.
 Classes that override this can use it to do any post-update operations.
 """
-pass
+if not entity:
+raise NoEntityError
 def _onDelete(self, entity):
 """Called when an entity has been deleted.
 Classes that override this can use it to do any post-deletion operations.
 """
-pass
+if not entity:
+raise NoEntityError
 def getKeyNameFromFields(self, fields):
 """Returns the KeyName constructed from fields dict for this type of entity.
 The KeyName is in the following format:
 <key_value1>/<key_value2>/.../<key_valueN>
 """
+if not fields:
+raise InvalidArgumentError
 key_field_names = self.getKeyFieldNames()
 # check if all key_field_names for this entity are present in fields
 if not all(field in fields.keys() for field in key_field_names):
-raise Error("Not all the required key fields are present")
+raise InvalidArgumentError("Not all the required key fields are present")
 if not all(fields.get(field) for field in key_field_names):
-raise Error("Not all KeyValues are non-false")
+raise InvalidArgumentError("Not all KeyValues are non-false")
 # construct the KeyValues in the order given by getKeyFieldNames()
 keyvalues = []
 for key_field_name in key_field_names:
 keyvalues.append(fields[key_field_name])
 # construct the KeyName in the appropriate format
 return '/'.join(keyvalues)
 def getFullModelClassName(self):
 """Returns fully-qualified model module.class name string.
 """
 return '%s.%s' % (self._model.__module__, self._model.__name__)
 def getKeyValuesFromEntity(self, entity):
 """Extracts the key values from entity and returns them.
 Args:
 entity: the entity from which to extract the key values
 """
+if not entity:
+raise NoEntityError
 return [entity.scope_path, entity.link_id]
 def getKeyValuesFromFields(self, fields):
 """Extracts the key values from a dict and returns them.
 Args:
 fields: the dict from which to extract the key values
 """
+if not all( (i in fields for i in ['scope_path', 'link_id']) ):
+raise InvalidArgumentError
 return [fields['scope_path'], fields['link_id']]
 def getKeyFieldNames(self):
 """Returns an array with the names of the Key Fields.
 required translations/modifications performed.
 Args:
 dictionary: The arguments to massage
 """
+if not dictionary:
+raise InvalidArgumentError
 keys = self.getKeyFieldNames()
 values = self.getKeyValuesFromFields(dictionary)
 key_fields = dicts.zip(keys, values)
 Args:
 key_name: key name of entity
 """
+if not key_name:
+raise InvalidArgumentError
 return self._model.get_by_key_name(key_name)
 def getFromKeyFields(self, fields):
 """Returns the entity for the specified key names, or None if not found.
 Args:
 fields: a dict containing the fields of the entity that
 uniquely identifies it
 """
+if not fields:
+raise InvalidArgumentError
 key_fields = self.getKeyFieldsFromFields(fields)
 if all(key_fields.values()):
 key_name = self.getKeyNameFromFields(key_fields)
 Returns:
 The original entity with any supplied properties changed.
 """
+if not entity:
+raise NoEntityError
+if not entity_properties:
+raise InvalidArgumentError
 def update():
 return self._unsafeUpdateEntityProperties(entity, entity_properties)
 entity = db.run_in_transaction(update)
 properties changed, or a new entity now associated with the
 supplied key_name and properties.
 """
 entity = self.getFromKeyName(key_name)
 create_entity = not entity
 if create_entity:
 # entity did not exist, so create one in a transaction
 entity = self._model.get_or_insert(key_name, **properties)
 # there is no way to be sure if get_or_insert() returned a new entity or
 # got an existing one due to a race, so update with properties anyway,
 # in a transaction
 entity = self.updateEntityProperties(entity, properties, silent=True)
 # a new entity has been created call _onCreate
 self._onCreate(entity)
 else:
 # the entity has been updated call _onUpdate
 self._onUpdate(entity)
 return entity
 def isDeletable(self, entity):
 """Returns whether the specified entity can be deleted.
 Args:
 entity: an existing entity in datastore
 """
 return True
 def delete(self, entity):
 """Delete existing entity from datastore.
 Args:
 entity: an existing entity in datastore
 """
 entity.delete()

changeset 1513	13efb916a73c
parent 1512	97c4a718d6f4
child 1514	4a233f5a4264