java.lang.Object
- org.neotropic.kuwaiba.core.persistence.reference.neo4j.BusinessEntityManagerImpl

All Implemented Interfaces:

AbstractEntityManager, BusinessEntityManager
```
@Service
public class BusinessEntityManagerImpl
extends Object
implements BusinessEntityManager
```
Business entity manager reference implementation (using Neo4J as backend).

Author:

Charles Edward Bedon Cortazar <charles.bedon@kuwaiba.org>

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`BusinessEntityManagerImpl.AttributeDefinitionSet`	This class wraps a set of attribute definitions necessary to create objects with default values

Constructor Summary

Constructors
Constructor Description

BusinessEntityManagerImpl()
Main constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addParentToSpecialObject(String specialObjectClass, String specialObjectId, String parentClass, String parentId)`	Breaks the special hierarchy to enable special children to have more than one parent.
`long`	`attachFileToObject(String name, String tags, byte[] file, String className, String objectId)`	Relates a file to an inventory object
`boolean`	`canDeleteObject(String className, String oid)`	Checks recursively if it's safe to delete a single object
`String[]`	`copyObjects(String targetClassName, String targetOid, HashMap<String,List<String>> objects, boolean recursive)`	Copy a set of objects
`String`	`copyPoolItem(String poolId, String poolItemClassName, String poolItemId, boolean recursive)`	Copy a pool item from a pool to another pool
`String[]`	`copySpecialObjects(String targetClassName, String targetOid, HashMap<String,List<String>> objects, boolean recursive)`	Copy a set of special objects (this is used to copy objects when they are containment are set in the special containment hierarchy) use case: to move physical links into a wire Container
`long`	`countChildren(String objectClass, String objectId)`	Counts if an object has children
`long`	`countSpecialChildren(String objectClass, String objectId)`	Counts if an object has special children
`String[]`	`createBulkObjects(String className, String parentClassName, String parentOid, String namePattern, String templateId)`	Creates multiple objects using a given name pattern
`String[]`	`createBulkSpecialObjects(String className, String parentClassName, String parentId, int numberOfSpecialObjects, String namePattern)`	Creates multiple special objects using a given name pattern
`long`	`createClassLevelReport(String className, String reportName, String reportDescription, String script, int outputType, boolean enabled)`	Creates a class level report (a report that will be available for all instances of a given class -and its subclasses-)
`String`	`createContact(String contactClass, String customerClassName, String customerId)`	Creates a contact.Contacts are always associated to a customer
`String`	`createHeadlessObject(String className, HashMap<String,String> attributes, String templateId)`	Creates an object without parent.
`long`	`createInventoryLevelReport(String reportName, String reportDescription, String script, int outputType, boolean enabled, List<StringPair> parameters)`	Creates an inventory level report (a report that is not tied to a particlar instance or class.
`String`	`createObject(String className, String parentClassName, String parentOid, HashMap<String,String> attributes, String templateId)`	Creates a new inventory object
`String`	`createObject(String className, String parentClassName, HashMap<String,String> attributes, String templateId, String criteria)`	Creates an object
`org.neo4j.graphdb.Node`	`createObject(org.neo4j.graphdb.Node classNode, ClassMetadata classToMap, HashMap<String,String> attributes)`
`String`	`createPoolItem(String poolId, String className, HashMap<String,String> attributes, String templateId)`	Creates an object inside a pool
`String`	`createSpecialObject(String className, String parentClassName, String parentOid, HashMap<String,String> attributes, String templateId)`	Creates a new inventory object for a domain specific model (where the standard containment rules don't apply)
`HashMap<String,String>`	`createSpecialObjectUsingTemplate(String className, String parentClassName, String parentOid, HashMap<String,String> attributes, String templateId)`	Equal to `BusinessEntityManager.createSpecialObject(java.lang.String, java.lang.String, java.lang.String, java.util.HashMap, java.lang.String)` but the return is a map of ids.
`void`	`createSpecialRelationship(String aObjectClass, String aObjectId, String bObjectClass, String bObjectId, String name, boolean unique)`	Creates a relationship between two elements and labels it.
`void`	`createSpecialRelationship(String aObjectClass, String aObjectId, String bObjectClass, String bObjectId, String name, boolean unique, HashMap<String,Object> properties)`	This method creates a special relationship with a set of property values
`void`	`deleteContact(String contactClass, String contactId)`	Deletes a contact
`void`	`deleteObject(String className, String oid, boolean releaseRelationships)`	Deletes a single object
`void`	`deleteObjects(HashMap<String,List<String>> objects, boolean releaseRelationships)`	Deletes a set of objects
`ChangeDescriptor`	`deleteReport(long reportId)`	Deletes a report
`void`	`detachFileFromObject(long fileObjectId, String className, String objectId)`	Releases (and deletes) a file associated to an inventory object
`byte[]`	`executeClassLevelReport(String objectClassName, String objectId, long reportId)`	Executes a class level report and returns the result.
`byte[]`	`executeInventoryLevelReport(long reportId, List<StringPair> parameters)`	Executes an inventory level report and returns the result.
`List<BusinessObjectLightList>`	`findRoutesThroughSpecialRelationships(String objectAClassName, String objectAId, String objectBClassName, String objectBId, String relationshipName)`	Finds all possible routes between two given inventory objects
`List<AnnotatedBusinessObjectLight>`	`getAnnotatedSpecialAttribute(String objectClass, String objectId, String specialAttributeName)`	This method will extract the object at the other side of the special relationship and all the properties of the relationship itself
`String`	`getAttributeValueAsString(String objectClass, String objectId, String attributeName)`	Utility method that returns the value of an attribute of a given object as a string.
`HashMap<String,String>`	`getAttributeValuesAsString(String objectClass, String objectId)`	Fetches the attributes of an inventory object (and their values) and returns them as strings.
`List<BusinessObject>`	`getChildrenOfClass(String parentOid, String parentClass, String classToFilter, int page, int maxResults)`	Gets the direct children of a given object of a given class.
`List<BusinessObjectLight>`	`getChildrenOfClassLight(String parentOid, String parentClass, String classToFilter, int maxResults)`	Same as getChildrenOfClass, but returns only the light version of the objects
`List<BusinessObjectLight>`	`getChildrenOfClassLightRecursive(String parentOid, String parentClass, String classToFilter, HashMap<String,String> attributesToFilter, int page, int limit)`	Gets all class and abstract class children of a given class to filter in a hierarchy with root in the given parent.
`List<ReportMetadataLight>`	`getClassLevelReports(String className, boolean recursive, boolean includeDisabled)`	Gets the class level reports associated to the given class (or its superclasses)
`BusinessObjectLight`	`getCommonParent(String aObjectClass, String aOid, String bObjectClass, String bOid)`	Finds the common parent between two objects.
`Contact`	`getContact(String contactClass, String contactId)`	Gets the entire information of a given contact
`List<Contact>`	`getContacts(int page, int limit, HashMap<String,Object> filters)`
`List<Contact>`	`getContactsForCustomer(String customerClass, String customerId)`	Retrieves the list of contacts associated to a customer
`FileObject`	`getFile(long fileObjectId, String className, String objectId)`	Retrieves a particular file associated to an inventory object.
`List<FileObjectLight>`	`getFilesForObject(String className, String objectId)`	Fetches the files associated to an inventory object.
`Map<BusinessObjectLight,List<FileObjectLight>>`	`getFilesFromRelatedListTypeItems(String uuid)`	Retrieves a map with the files related to the list type item attributes of the given object
`BusinessObject`	`getFirstParentOfClass(String objectClassName, String oid, String objectToMatchClassName)`	Gets the first occurrence of a parent with a given class (according to the special and standard containment hierarchy) (for example "give me the parent of this port until you find the nearest rack")
`org.neo4j.graphdb.Node`	`getInstanceOfClass(long classId, String oid)`	Boiler-plate code.
`org.neo4j.graphdb.Node`	`getInstanceOfClass(String className, String oid)`	Boiler-plate code.
`org.neo4j.graphdb.Node`	`getInstanceOfClass(org.neo4j.graphdb.Node classNode, String oid)`
`List<ReportMetadataLight>`	`getInventoryLevelReports(boolean includeDisabled)`	Gets the inventory class reports.
`List<BusinessObjectLight>`	`getMultipleParents(String objectClassName, String objectId)`	Gets the parents of an object that breaks the containment rule of having only one parent.
`BusinessObject`	`getObject(String className, String oid)`	Gets the detailed information about an object
`List<BusinessObjectLight>`	`getObjectChildren(long classId, String oid, int maxResults)`	Gets the children of a given object, providing the class and object id.
`List<BusinessObjectLight>`	`getObjectChildren(String className, String oid, int maxResults)`	Gets the children of a given object
`List<BusinessObjectLight>`	`getObjectChildren(String className, String oid, HashMap<String,String> filters, long skip, long limit)`	Get a set of children to the given the parent class name and id.
`long`	`getObjectChildrenCount(String className, String oid, HashMap<String,String> filters)`	Get the child count given the parent class name and id.
`BusinessObjectLight`	`getObjectLight(String className, String oid)`	Gets the simplified information about an object
`List<BusinessObjectLight>`	`getObjectsByNameAndClassName(List<String> names, int skip, int limit, String... clasessToFilter)`	Gets a set of objects by its exact names and class names, used to know if an object with the same its already created in the inventory e.g.
`List<BusinessObject>`	`getObjectsOfClass(String className, int maxResults)`	Recursively gets all the instances of given class
`List<BusinessObjectLight>`	`getObjectsOfClassLight(String className, HashMap<String,String> filters, long skip, long limit)`	Recursively gets all the light instances of given class
`List<BusinessObjectLight>`	`getObjectSpecialChildren(String objectClass, String objectId)`	Gets the special children of a given object
`long`	`getObjectSpecialChildrenCount(String objectClass, String objectId, String... childrenClassNamesToFilter)`	Gets the special children of a given object
`List<BusinessObjectLight>`	`getObjectSpecialChildrenWithFilters(String objectClass, String objectId, List<String> childrenClassNamesToFilter, int page, int limit)`	Gets the special children of a given object
`List<BusinessObject>`	`getObjectsWithFilter(String className, String filterName, String filterValue)`	Same as `BusinessEntityManager.getObjectsWithFilterLight(java.lang.String, java.lang.String, java.lang.String)`, but returns the full information about the objects involved
`List<BusinessObjectLight>`	`getObjectsWithFilterLight(String className, String filterName, String filterValue)`	Retrieves a list of light instances of a given class given a simple filter.
`BusinessObjectLight`	`getParent(String objectClass, String oid)`	Gets the parent of a given object in the containment hierarchy
`List<BusinessObjectLight>`	`getParents(String objectClassName, String oid)`	Retrieves recursively the list of parents of an object in the containment hierarchy
`List<BusinessObjectLight>`	`getParentsUntilFirstOfClass(String objectClass, String oid, String... objectToMatchClassNames)`	Gets the list of parents (according to the special and standard containment hierarchy) until it finds an instance of class objectToMatchClassName (for example "give me the parents of this port until you find the nearest rack")
`BusinessObjectLight`	`getPhysicalNodeToObjectInWarehouse(String objectClassName, String objectId)`	Gets the physical node of a warehouse item
`InventoryObjectPool`	`getPool(String poolId)`	Gets a pool by its id
`List<BusinessObjectLight>`	`getPoolItems(String poolId, int limit)`	Retrieves the list of objects from a pool
`List<BusinessObjectLight>`	`getPoolItemsByClassName(String poolId, String className, int page, int limit)`	Retrieves the list of objects from a pool
`long`	`getPoolItemsCount(String poolId, String className)`	Count the total of objects in a pool
`List<InventoryObjectPool>`	`getPoolsInObject(String objectClassName, String objectId, String poolClass)`	Retrieves the pools associated to a particular object
`List<InventoryObjectPool>`	`getPoolsInPool(String parentPoolId, String poolClassName)`	Retrieves the pools associated to a particular pool
`long`	`getPoolsInPoolCount(String parentPoolId, String poolClassName)`	Retrieves the total count of pools associated to a particular pool
`ReportMetadata`	`getReport(long reportId)`	Gets the information related to a class level report.
`List<InventoryObjectPool>`	`getRootPools(String className, int type, boolean includeSubclasses)`	Retrieves the pools that don't have any parent and are normally intended to be managed by the Pool Manager
`List<BusinessObjectLight>`	`getSiblings(String className, String oid, int maxResults)`	Gets the siblings of a given object in the containment hierarchy
`List<BusinessObjectLight>`	`getSpecialAttribute(String objectClass, String objectId, String specialAttributeName)`	Gets the value of a special attribute.
`HashMap<String,List<BusinessObjectLight>>`	`getSpecialAttributes(String className, String objectId, String... attributeNames)`	Returns the specified special relationships of a given object as a hashmap whose keys are the names of the relationships and the values the list of related objects.
`List<BusinessObjectLight>`	`getSpecialChildrenOfClassLight(String parentOid, String parentClass, String classToFilter, int maxResults)`	Returns the special children of a given object as RemoteBusinessObjectLight instances.This method is not recursive.
`List<BusinessObjectLight>`	`getSpecialChildrenOfClassLightRecursive(String parentOid, String parentClass, String classToFilter, int maxResults)`	Gets all class and abstract class special children of a given class to filter in a hierarchy with root in the given parent.
`List<BusinessObjectLight>`	`getSuggestedChildrenWithFilter(String parentClass, String parentId, String filter, boolean ignoreSpecialChildren, int skip, int limit, String... clasessToFilter)`	Gets a set of suggested children with filter (no recursive).
`List<BusinessObjectLight>`	`getSuggestedObjectsWithFilter(String filter, int limit)`	Suggests a number of objects based on a search string.
`List<BusinessObjectLight>`	`getSuggestedObjectsWithFilter(String filter, int skip, int limit, String... clasessToFilter)`	Gets a set of suggested objects with filter.
`List<BusinessObjectLight>`	`getSuggestedObjectsWithFilter(String filter, String superClass, int limit)`	Same as `BusinessEntityManager.getSuggestedObjectsWithFilter(java.lang.String, int)`, but the results will be instances of the super class provided or one of its subclasses.
`HashMap<String,List<BusinessObjectLight>>`	`getSuggestedObjectsWithFilterGroupedByClassName(List<String> classesNamesToFilter, String filter, long classesSkip, long classesLimit, long objectSkip, long objectLimit)`	Suggests a number of objects based on a search string.
`HashMap<String,List<InventoryObjectPool>>`	`getSuggestedPoolsByName(List<String> classesNamesToFilter, String nameTofilter, long poolSkip, long poolLimit, long objectSkip, long objectLimit)`	Suggests a number of pools based on a search string (the pool name).
`List<BusinessObjectLight>`	`getWarehousesInObject(String objectClassName, String objectId)`	Gets the warehouses in a object
`BusinessObjectLight`	`getWarehouseToObject(String objectClassName, String objectId)`	Gets warehouse related to object
`boolean`	`hasRelationship(String objectClass, String objectId, String relationshipName, int numberOfRelationships)`	Checks if an object has a given number of standard relationships with another object
`boolean`	`hasSpecialAttribute(String objectClass, String objectId, String attributeName)`	Check if an object has a given special attribute.
`boolean`	`hasSpecialRelationship(String objectClass, String objectId, String relationshipName, int numberOfRelationships)`	Checks if an object has a given number of special relationships with another object
`void`	`initCache()`	This optional method clears and builds the cache components needed in the current entity manager.
`boolean`	`isParent(String parentClass, String parentId, String childClass, String childId)`	Checks if a given object is parent to another, according to the standard or special containment hierarchy.
`void`	`moveObjects(String targetClassName, String targetOid, HashMap<String,String[]> objects)`	Move a list of objects to a new parent: this methods ignores those who can't be moved and raises an OperationNotPermittedException, however, it will move those which can be moved
`void`	`moveObjectsToPool(String targetClassName, String targetOid, HashMap<String,String[]> objects)`	Move a list of objects to a new parent: this methods ignores those who can't be moved and raises an OperationNotPermittedException, however, it will move those which can be moved
`void`	`movePoolItem(String poolId, String poolItemClassName, String poolItemId)`	Move a pool item from a pool to another pool
`void`	`moveSpecialObjects(String targetClassName, String targetOid, HashMap<String,String[]> objects)`	Move a list of objects to a new parent(taking into account the special hierarchy containment): this methods ignores those who can't be moved and raises an OperationNotPermittedException, however, it will move those which can be moved
`void`	`releaseRelationships(String objectClass, String objectId, List<String> relationshipsToRelease)`	Releases all the relationships with the given names associated to the object provided.
`void`	`releaseSpecialRelationship(String objectClass, String objectId, String otherObjectId, String name)`	Release all special relationships with a given name
`void`	`releaseSpecialRelationshipInTargetObject(String objectClass, String objectId, String relationshipName, String targetId)`	Release all special relationships with a given name whose target object id matches with the one provided
`List<Contact>`	`searchForContacts(String searchString, int maxResults)`	Searches in all the properties of a contact for a given string
`void`	`setConfiguration(Properties configuration)`	Configuration variables (usually, yet not necessarily read from a config file) that will be used to process some calls (for example file paths or constants).
`void`	`updateContact(String contactClass, String contactId, List<StringPair> properties)`	Updates a contact's information
`void`	`updateFileProperties(long fileObjectId, List<StringPair> properties, String className, String objectId)`	Updates the properties of a file object (name or tags)
`ChangeDescriptor`	`updateObject(String className, String oid, HashMap<String,String> attributes)`	Updates an object attributes.
`ChangeDescriptor`	`updateReport(long reportId, String reportName, String reportDescription, Boolean enabled, Integer type, String script)`	Updates the properties of an existing class level report.
`ChangeDescriptor`	`updateReportParameters(long reportId, List<StringPair> parameters)`	Updates the parameters of a report

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - BusinessEntityManagerImpl
```
@Autowired
public BusinessEntityManagerImpl()
```
    Main constructor. It receives references to the other entity managers
- Method Detail
  - initCache
```
public void initCache()
```
    Description copied from interface: AbstractEntityManager
    
    This optional method clears and builds the cache components needed in the current entity manager.
    
    Specified by:
    
    initCache in interface AbstractEntityManager
  - setConfiguration
```
public void setConfiguration(Properties configuration)
```
    Description copied from interface: AbstractEntityManager
    
    Configuration variables (usually, yet not necessarily read from a config file) that will be used to process some calls (for example file paths or constants).
    
    Specified by:
    
    setConfiguration in interface AbstractEntityManager
    
    Parameters:
    
    configuration - The set of properties. Each EM should document its variables and what are their default values.
  - createObject
```
public String createObject(String className,
                           String parentClassName,
                           String parentOid,
                           HashMap<String,String> attributes,
                           String templateId)
                    throws BusinessObjectNotFoundException,
                           OperationNotPermittedException,
                           MetadataObjectNotFoundException,
                           InvalidArgumentException,
                           ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Creates a new inventory object
    
    Specified by:
    
    createObject in interface BusinessEntityManager
    
    Parameters:
    
    className - Name of the class which this object will be instantiated from
    
    parentClassName - Parent object class name. If null, the parent will be the DummyRoot node
    
    parentOid - Parent's oid. If -1, the parent will be the DummyRoot node
    
    attributes - Attributes to be set by default in the new object. It's a HashMap where the keys are the attribute names and the values, the values for such attributes. Note that binary type attributes can't be set here.
    
    templateId - Template id to be used to create the current object. Template values can be overridden if "attributeValues" is not empty. Use an empty string or null to not use a Template.
    
    Returns:
    
    The object's id
    
    Throws:
    
    BusinessObjectNotFoundException - Thrown if the parent id is not found
    
    OperationNotPermittedException - If there's a business constraint that doesn't allow to create the object.
    
    MetadataObjectNotFoundException - Thrown if the object's class can't be found
    
    InvalidArgumentException - If any of the attribute values has an invalid value or format.
    
    ApplicationObjectNotFoundException - If the specified template could not be found
  - createObject
```
public String createObject(String className,
                           String parentClassName,
                           HashMap<String,String> attributes,
                           String templateId,
                           String criteria)
                    throws MetadataObjectNotFoundException,
                           BusinessObjectNotFoundException,
                           InvalidArgumentException,
                           OperationNotPermittedException,
                           ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Creates an object
    
    Specified by:
    
    createObject in interface BusinessEntityManager
    
    Parameters:
    
    className - Class the object will be instance of
    
    parentClassName - Class of the parent the object will be instance of. Use root for the navigation tree
    
    attributes - Dictionary with the names and the values of the attributes to be set.
    
    templateId - The id of the template to be used to create this object. This id was probably retrieved by {@link ApplicationEntityManager.getTemplatesForClass(String)} before. Use a null or empty string to not use a template.
    
    criteria - Criteria to search for the parent. This is a string with two parts: One is the name of the attribute and the other its value, both separated by a fixed colon :. Example: name:Colombia
    
    Returns:
    
    The id of the new object.
    
    Throws:
    
    MetadataObjectNotFoundException - Thrown if the object's class can't be found
    
    BusinessObjectNotFoundException - Thrown if the parent id is not found
    
    InvalidArgumentException - If any of the attribute values has an invalid value or format.
    
    OperationNotPermittedException - If there's a business constraint that doesn't allow to create the object.
    
    ApplicationObjectNotFoundException - If the specified template could not be found.
  - createSpecialObject
```
public String createSpecialObject(String className,
                                  String parentClassName,
                                  String parentOid,
                                  HashMap<String,String> attributes,
                                  String templateId)
                           throws BusinessObjectNotFoundException,
                                  OperationNotPermittedException,
                                  MetadataObjectNotFoundException,
                                  InvalidArgumentException,
                                  ApplicationObjectNotFoundException
```
    Creates a new inventory object for a domain specific model (where the standard containment rules don't apply)
    
    Specified by:
    
    createSpecialObject in interface BusinessEntityManager
    
    Parameters:
    
    className - Name of the class which this object will be instantiated from
    
    parentClassName - Parent object class name
    
    parentOid - Parent's oid
    
    attributes - Attributes to be set by default in the new object. It's a HashMap where the keys are the attribute names and the values, the values for such attributes. Note that binary type attributes can't be set here.
    
    templateId - The id of the template to be used to create this object. This id was probably retrieved by {@link ApplicationEntityManager.getTemplatesForClass(String)} before. Use a null or empty string to not use a template.
    
    Returns:
    
    The id of the new object.
    
    Throws:
    
    MetadataObjectNotFoundException - Thrown if the object's class can't be found
    
    BusinessObjectNotFoundException - Thrown if the parent id is not found
    
    OperationNotPermittedException - If the update can't be performed due to a format issue
    
    InvalidArgumentException - If any of the attribute values has an invalid value or format.
    
    ApplicationObjectNotFoundException - If the specified template could not be found.
  - createSpecialObjectUsingTemplate
```
public HashMap<String,String> createSpecialObjectUsingTemplate(String className,
                                                                     String parentClassName,
                                                                     String parentOid,
                                                                     HashMap<String,String> attributes,
                                                                     String templateId)
                                                              throws BusinessObjectNotFoundException,
                                                                     OperationNotPermittedException,
                                                                     MetadataObjectNotFoundException,
                                                                     InvalidArgumentException,
                                                                     ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Equal to BusinessEntityManager.createSpecialObject(java.lang.String, java.lang.String, java.lang.String, java.util.HashMap, java.lang.String) but the return is a map of ids. Creates a new inventory object for a domain specific model (where the standard containment rules don't apply)
    
    Specified by:
    
    createSpecialObjectUsingTemplate in interface BusinessEntityManager
    
    Parameters:
    
    className - Name of the class which this object will be instantiated from
    
    parentClassName - Parent object class name
    
    parentOid - Parent's oid
    
    attributes - Attributes to be set by default in the new object. It's a HashMap where the keys are the attribute names and the values, the values for such attributes. Note that binary type attributes can't be set here.
    
    templateId - The id of the template to be used to create this object. This id was probably retrieved by {@link ApplicationEntityManager.getTemplatesForClass(String)} before. Use a null or empty string to not use a template.
    
    Returns:
    
    The id of the new object.
    
    Throws:
    
    BusinessObjectNotFoundException - Thrown if the parent id is not found
    
    OperationNotPermittedException - If the update can't be performed due to a format issue
    
    MetadataObjectNotFoundException - Thrown if the object's class can't be found
    
    InvalidArgumentException - If any of the attribute values has an invalid value or format.
    
    ApplicationObjectNotFoundException - If the specified template could not be found.
  - addParentToSpecialObject
```
public void addParentToSpecialObject(String specialObjectClass,
                                     String specialObjectId,
                                     String parentClass,
                                     String parentId)
                              throws BusinessObjectNotFoundException,
                                     OperationNotPermittedException,
                                     MetadataObjectNotFoundException,
                                     InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Breaks the special hierarchy to enable special children to have more than one parent.
    
    Specified by:
    
    addParentToSpecialObject in interface BusinessEntityManager
    
    Parameters:
    
    specialObjectClass - Special object class name
    
    specialObjectId - Special Object Id
    
    parentClass - Parent Object class
    
    parentId - Parent Object id
    
    Throws:
    
    BusinessObjectNotFoundException
    
    OperationNotPermittedException
    
    MetadataObjectNotFoundException
    
    InvalidArgumentException
  - createHeadlessObject
```
public String createHeadlessObject(String className,
                                   HashMap<String,String> attributes,
                                   String templateId)
                            throws OperationNotPermittedException,
                                   MetadataObjectNotFoundException,
                                   InvalidArgumentException,
                                   ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Creates an object without parent. This might be particularly useful for complex models. Use it carefully to avoid leaving orphan objects. Always provide custom methods to delete
    
    Specified by:
    
    createHeadlessObject in interface BusinessEntityManager
    
    Parameters:
    
    className - The class name of the object to be created.
    
    attributes - The initial set of attributes (as pairs attribute name - value) to be set. These values will override those in the template used (if any).
    
    templateId - The id of the template to be used to create the object. Use null or an empty string to not use any template.
    
    Returns:
    
    The id of the newly created object.
    
    Throws:
    
    OperationNotPermittedException - If the class provided is marked as in design or it is abstract.
    
    MetadataObjectNotFoundException - If the class provided does not exist.
    
    InvalidArgumentException - If the format of any of the default attributes provided is incorrect.
    
    ApplicationObjectNotFoundException - If the template provided does not exist.
  - createPoolItem
```
public String createPoolItem(String poolId,
                             String className,
                             HashMap<String,String> attributes,
                             String templateId)
                      throws ApplicationObjectNotFoundException,
                             InvalidArgumentException,
                             MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Creates an object inside a pool
    
    Specified by:
    
    createPoolItem in interface BusinessEntityManager
    
    Parameters:
    
    poolId - Parent pool id
    
    className - Class this object is going to be instance of
    
    attributes - The list of attributes to be set initially. The values are serialized objects.
    
    templateId - The id of the template to be used to create this object. This id was probably retrieved by {@link ApplicationEntityManager.getTemplatesForClass(String)} before. Use a null or empty string to not use a template.
    
    Returns:
    
    the id of the newly created object
    
    Throws:
    
    ApplicationObjectNotFoundException - If the parent pool can't be found
    
    InvalidArgumentException - If any of the attributes or its type is invalid
    
    MetadataObjectNotFoundException - If the class name could not be found
  - createBulkObjects
```
public String[] createBulkObjects(String className,
                                  String parentClassName,
                                  String parentOid,
                                  String namePattern,
                                  String templateId)
                           throws MetadataObjectNotFoundException,
                                  OperationNotPermittedException,
                                  BusinessObjectNotFoundException,
                                  InvalidArgumentException,
                                  ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Creates multiple objects using a given name pattern
    
    Specified by:
    
    createBulkObjects in interface BusinessEntityManager
    
    Parameters:
    
    className - The class name for the new objects
    
    parentClassName - The parent class name for the new objects
    
    parentOid - The object id of the parent
    
    namePattern - A pattern to create the names for the new objects
    
    templateId - a template id for the objects creation, it could be null if no template is required
    
    Returns:
    
    An arrays of ids for the new objects
    
    Throws:
    
    MetadataObjectNotFoundException - If the className or the parentClassName can not be found.
    
    OperationNotPermittedException - If the className is not a possible children of parentClassName. If the className is not in design or are abstract. If the className is not an InventoryObject.
    
    BusinessObjectNotFoundException - If the parent node can not be found.
    
    InvalidArgumentException - If the given name pattern not match with the regular expression to build the new object name.
    
    ApplicationObjectNotFoundException - if the given template id does not exist.
  - createBulkSpecialObjects
```
public String[] createBulkSpecialObjects(String className,
                                         String parentClassName,
                                         String parentId,
                                         int numberOfSpecialObjects,
                                         String namePattern)
                                  throws MetadataObjectNotFoundException,
                                         BusinessObjectNotFoundException,
                                         OperationNotPermittedException,
                                         InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Creates multiple special objects using a given name pattern
    
    Specified by:
    
    createBulkSpecialObjects in interface BusinessEntityManager
    
    Parameters:
    
    className - The class name for the new special objects
    
    parentClassName - The parent class name for the new special objects
    
    parentId - The object id of the parent
    
    numberOfSpecialObjects - Number of special objects to be created
    
    namePattern - A pattern to create the names for the new special objects
    
    Returns:
    
    An array of ids for the new special objects
    
    Throws:
    
    MetadataObjectNotFoundException - If the className or the parentClassName can not be found.
    
    BusinessObjectNotFoundException - If the parent node can not be found.
    
    OperationNotPermittedException - If the className is not a possible special children of parentClassName. If the className is not in design or are abstract. If the className is not an InventoryObject.
    
    InvalidArgumentException - If the given name pattern not match with the regular expression to build the new object name.
  - getObject
```
public BusinessObject getObject(String className,
                                String oid)
                         throws BusinessObjectNotFoundException,
                                MetadataObjectNotFoundException,
                                InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the detailed information about an object
    
    Specified by:
    
    getObject in interface BusinessEntityManager
    
    Parameters:
    
    className - Object class name
    
    oid - Object's oid
    
    Returns:
    
    A detailed representation of the requested object
    
    Throws:
    
    BusinessObjectNotFoundException - If the requested object can't be found
    
    MetadataObjectNotFoundException - If the className class can't be found
    
    InvalidArgumentException - If the object id can not be found.
  - getObjectLight
```
public BusinessObjectLight getObjectLight(String className,
                                          String oid)
                                   throws BusinessObjectNotFoundException,
                                          MetadataObjectNotFoundException,
                                          InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the simplified information about an object
    
    Specified by:
    
    getObjectLight in interface BusinessEntityManager
    
    Parameters:
    
    className - Object class name
    
    oid - Object's oid
    
    Returns:
    
    A detailed representation of the requested object
    
    Throws:
    
    BusinessObjectNotFoundException - If the requested object can't be found
    
    MetadataObjectNotFoundException - If the className class can't be found
    
    InvalidArgumentException - If the oid is null
  - getObjectsWithFilterLight
```
public List<BusinessObjectLight> getObjectsWithFilterLight(String className,
                                                           String filterName,
                                                           String filterValue)
                                                    throws MetadataObjectNotFoundException,
                                                           InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves a list of light instances of a given class given a simple filter. This method will search for all objects with a string-based attribute (filterName) whose value matches a value provided (filterValue)
    
    Specified by:
    
    getObjectsWithFilterLight in interface BusinessEntityManager
    
    Parameters:
    
    className - The class of the objects to be searched. This method support abstract superclasses as well
    
    filterName - The attribute to be used as filter. This will work only with String-type attributes. Example: serialNumber
    
    filterValue - The value to be use to match the instances. Example "Serial-12345"
    
    Returns:
    
    The list of instances that matches the filterName/filterValue criteria
    
    Throws:
    
    MetadataObjectNotFoundException - If the class provided could not be found
    
    InvalidArgumentException - If the uuid attribute could not be found in the result nodes
  - getObjectsWithFilter
```
public List<BusinessObject> getObjectsWithFilter(String className,
                                                 String filterName,
                                                 String filterValue)
                                          throws MetadataObjectNotFoundException,
                                                 InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Same as BusinessEntityManager.getObjectsWithFilterLight(java.lang.String, java.lang.String, java.lang.String), but returns the full information about the objects involved
    
    Specified by:
    
    getObjectsWithFilter in interface BusinessEntityManager
    
    Parameters:
    
    className - The class of the objects to be searched. This method support abstract superclasses as well
    
    filterName - The attribute to be used as filter. This will work only with String-type attributes. Example: serialNumber
    
    filterValue - The value to be use to match the instances. Example "Serial-12345"
    
    Returns:
    
    The list of instances that matches the filterName/filterValue criteria
    
    Throws:
    
    MetadataObjectNotFoundException - If the class provided could not be found
    
    InvalidArgumentException - If it's not possible to construct the RemoteBusinessObjects from the information in the database
  - getSuggestedObjectsWithFilter
```
public List<BusinessObjectLight> getSuggestedObjectsWithFilter(String filter,
                                                               int limit)
```
    Description copied from interface: BusinessEntityManager
    
    Suggests a number of objects based on a search string. The search string is matched against the name of the object, its class name or its class display name.
    
    Specified by:
    
    getSuggestedObjectsWithFilter in interface BusinessEntityManager
    
    Parameters:
    
    filter - The string to use as search filter.
    
    limit - The limit of results. Use -1 to retrieve all.
    
    Returns:
    
    A list of up to #limit suggested objects matching the criteria, alphabetically sorted.
  - getSuggestedObjectsWithFilter
```
public List<BusinessObjectLight> getSuggestedObjectsWithFilter(String filter,
                                                               String superClass,
                                                               int limit)
```
    Description copied from interface: BusinessEntityManager
    
    Same as BusinessEntityManager.getSuggestedObjectsWithFilter(java.lang.String, int), but the results will be instances of the super class provided or one of its subclasses. In reality, this method could do the same as BusinessEntityManager.getSuggestedObjectsWithFilter(java.lang.String, int) with superClass set to InventoryObject, but the implementation of both methods may differ significantly in terms of performance and complexity.
    
    Specified by:
    
    getSuggestedObjectsWithFilter in interface BusinessEntityManager
    
    Parameters:
    
    filter - The search string
    
    superClass - The results will be instances of this class or one of its subclasses
    
    limit - The limit of results. Use -1 to retrieve all
    
    Returns:
    
    A list of up to #limit suggested objects matching the criteria, alphabetically sorted
  - getSuggestedObjectsWithFilter
```
public List<BusinessObjectLight> getSuggestedObjectsWithFilter(String filter,
                                                               int skip,
                                                               int limit,
                                                               String... clasessToFilter)
```
    Description copied from interface: BusinessEntityManager
    
    Gets a set of suggested objects with filter.
    
    Specified by:
    
    getSuggestedObjectsWithFilter in interface BusinessEntityManager
    
    Parameters:
    
    filter - a possible part of the name of an object(s) or class(es).
    
    skip - The number of leading suggested objects to skip.
    
    limit - The number of suggested objects the result should be limited to.
    
    clasessToFilter - The suggested objects will be instance of this classes or subclasses.
    
    Returns:
    
    List of suggested objects.
  - getObjectsByNameAndClassName
```
public List<BusinessObjectLight> getObjectsByNameAndClassName(List<String> names,
                                                              int skip,
                                                              int limit,
                                                              String... clasessToFilter)
                                                       throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets a set of objects by its exact names and class names, used to know if an object with the same its already created in the inventory e.g. an IP address or a subnet in the ipam module can not be repeated
    
    Specified by:
    
    getObjectsByNameAndClassName in interface BusinessEntityManager
    
    Parameters:
    
    names - the exact names of the objects
    
    skip - the page
    
    limit - the limit per page
    
    clasessToFilter - class names of the objects
    
    Returns:
    
    a list of objects
    
    Throws:
    
    InvalidArgumentException
  - getSuggestedChildrenWithFilter
```
public List<BusinessObjectLight> getSuggestedChildrenWithFilter(String parentClass,
                                                                String parentId,
                                                                String filter,
                                                                boolean ignoreSpecialChildren,
                                                                int skip,
                                                                int limit,
                                                                String... clasessToFilter)
```
    Description copied from interface: BusinessEntityManager
    
    Gets a set of suggested children with filter (no recursive).
    
    Specified by:
    
    getSuggestedChildrenWithFilter in interface BusinessEntityManager
    
    Parameters:
    
    parentClass - The parent class name.
    
    parentId - The parent id.
    
    filter - Filter children (no recursive) by name or class.
    
    ignoreSpecialChildren - True to ignore special children in the suggested children (no recursive).
    
    skip - The number of leading children to skip.
    
    limit - The number of children the result should be limited to.
    
    clasessToFilter - The suggested children will be instance of this classes or subclasses.
    
    Returns:
    
    List of suggested children (no recursive).
  - getAttributeValueAsString
```
public String getAttributeValueAsString(String objectClass,
                                        String objectId,
                                        String attributeName)
                                 throws MetadataObjectNotFoundException,
                                        BusinessObjectNotFoundException,
                                        InvalidArgumentException,
                                        ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Utility method that returns the value of an attribute of a given object as a string. In date-type attributes, it will return the formated dated, while in list types, it will return the name of the linked element
    
    Specified by:
    
    getAttributeValueAsString in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - The class of the object
    
    objectId - The id of the object
    
    attributeName - The attribute whose value will be retrieved
    
    Returns:
    
    The value of the requested attribute. Null values are possible
    
    Throws:
    
    MetadataObjectNotFoundException - If the class of the object could not be found
    
    BusinessObjectNotFoundException - If the object itself could not be found
    
    InvalidArgumentException - Check with the data model integrity, because this would mean that a the type of the attribute should be a list type, but it's not
    
    ApplicationObjectNotFoundException - Check with the data model integrity, because this would mean that a list type item related to the object is not an instance of the right list type class
  - getAttributeValuesAsString
```
public HashMap<String,String> getAttributeValuesAsString(String objectClass,
                                                               String objectId)
                                                        throws MetadataObjectNotFoundException,
                                                               BusinessObjectNotFoundException,
                                                               InvalidArgumentException,
                                                               ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Fetches the attributes of an inventory object (and their values) and returns them as strings. This is useful mainly to display property sheets and reports, so it's not necessary to always check if an attribute is a list type and retrieve its string representation
    
    Specified by:
    
    getAttributeValuesAsString in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - The class of the object
    
    objectId - The id of the object
    
    Returns:
    
    A dictionary with the name of the attributes and their values represented as strings
    
    Throws:
    
    MetadataObjectNotFoundException - If the class of the object could not be found
    
    BusinessObjectNotFoundException - If the object itself could not be found
    
    InvalidArgumentException - Check with the data model integrity, because this would mean that a the type of the attribute should be a list type, but it's not
    
    ApplicationObjectNotFoundException - Check with the data model integrity, because this would mean that a list type item related to the object is not an instance of the right list type class
  - getCommonParent
```
public BusinessObjectLight getCommonParent(String aObjectClass,
                                           String aOid,
                                           String bObjectClass,
                                           String bOid)
                                    throws BusinessObjectNotFoundException,
                                           MetadataObjectNotFoundException,
                                           InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Finds the common parent between two objects.
    
    Specified by:
    
    getCommonParent in interface BusinessEntityManager
    
    Parameters:
    
    aObjectClass - Object A class name.
    
    aOid - Object A id.
    
    bObjectClass - Object B class name.
    
    bOid - Object B id.
    
    Returns:
    
    The common parent or null if none.
    
    Throws:
    
    BusinessObjectNotFoundException - If any of the objects could not be found.
    
    MetadataObjectNotFoundException - If any of the classes provided could not be found.
    
    InvalidArgumentException - If the database object could not be properly mapped into a serializable Java object.
  - getParent
```
public BusinessObjectLight getParent(String objectClass,
                                     String oid)
                              throws BusinessObjectNotFoundException,
                                     MetadataObjectNotFoundException,
                                     InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the parent of a given object in the containment hierarchy
    
    Specified by:
    
    getParent in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    oid - Object id
    
    Returns:
    
    The immediate parent. Null if the parent is null. A dummy object with id -1 if the parent is DummyRoot
    
    Throws:
    
    BusinessObjectNotFoundException - If the requested object can't be found
    
    MetadataObjectNotFoundException - If any of the class nodes involved is malformed
    
    InvalidArgumentException - If the database object could not be properly mapped into a serializable java object.
  - getParents
```
public List<BusinessObjectLight> getParents(String objectClassName,
                                            String oid)
                                     throws BusinessObjectNotFoundException,
                                            MetadataObjectNotFoundException,
                                            InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves recursively the list of parents of an object in the containment hierarchy
    
    Specified by:
    
    getParents in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - Object class
    
    oid - Object id
    
    Returns:
    
    The list of parents
    
    Throws:
    
    BusinessObjectNotFoundException - If the object does not exist
    
    MetadataObjectNotFoundException - if the class can not be found
    
    InvalidArgumentException - If the oid is null
  - getParentsUntilFirstOfClass
```
public List<BusinessObjectLight> getParentsUntilFirstOfClass(String objectClass,
                                                             String oid,
                                                             String... objectToMatchClassNames)
                                                      throws BusinessObjectNotFoundException,
                                                             MetadataObjectNotFoundException,
                                                             ApplicationObjectNotFoundException,
                                                             InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the list of parents (according to the special and standard containment hierarchy) until it finds an instance of class objectToMatchClassName (for example "give me the parents of this port until you find the nearest rack")
    
    Specified by:
    
    getParentsUntilFirstOfClass in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Class of the object to get the parents from
    
    oid - Id of the object to get the parents from
    
    objectToMatchClassNames - Classes of the objects that will limit the search. It can be a superclass, if you want to match many classes at once
    
    Returns:
    
    The list of parents until an instance of objectToMatchClassName is found. If no instance of that class is found, all parents until the Dummy Root will be returned
    
    Throws:
    
    BusinessObjectNotFoundException - If the object to evaluate can not be found
    
    MetadataObjectNotFoundException - If any of the classes provided could not be found
    
    ApplicationObjectNotFoundException - If the object provided is not in the standard containment hierarchy
    
    InvalidArgumentException - If the oid is null
  - getFirstParentOfClass
```
public BusinessObject getFirstParentOfClass(String objectClassName,
                                            String oid,
                                            String objectToMatchClassName)
                                     throws BusinessObjectNotFoundException,
                                            MetadataObjectNotFoundException,
                                            ApplicationObjectNotFoundException,
                                            InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the first occurrence of a parent with a given class (according to the special and standard containment hierarchy) (for example "give me the parent of this port until you find the nearest rack")
    
    Specified by:
    
    getFirstParentOfClass in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - Class of the object to get the parent from
    
    oid - Id of the object to get the parent from
    
    objectToMatchClassName - Class of the object that will limit the search. It can be a superclass, if you want to match many classes at once
    
    Returns:
    
    The the first occurrence of a parent with a given class. If no instance of that class is found, the child of Dummy Root related in this hierarchy will be returned
    
    Throws:
    
    BusinessObjectNotFoundException - If the object to evaluate can not be found
    
    MetadataObjectNotFoundException - If any of the classes provided could not be found
    
    ApplicationObjectNotFoundException - If the object provided is not in the standard containment hierarchy
    
    InvalidArgumentException - If the oid is null
  - getMultipleParents
```
public List<BusinessObjectLight> getMultipleParents(String objectClassName,
                                                    String objectId)
                                             throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the parents of an object that breaks the containment rule of having only one parent. For example the links and containers in the Outside Plant Module.
    
    Specified by:
    
    getMultipleParents in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - Object Class Name.
    
    objectId - Object Id.
    
    Returns:
    
    The set of parents.
    
    Throws:
    
    InvalidArgumentException - If the object class is null. If the object id is null.
  - isParent
```
public boolean isParent(String parentClass,
                        String parentId,
                        String childClass,
                        String childId)
                 throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Checks if a given object is parent to another, according to the standard or special containment hierarchy.
    
    Specified by:
    
    isParent in interface BusinessEntityManager
    
    Parameters:
    
    parentClass - Alleged parent Class Name.
    
    parentId - Alleged parent id.
    
    childClass - Child Class Name.
    
    childId - Child Id.
    
    Returns:
    
    True if the given parent has the given child (according to the special and standard containment hierarchy)
    
    Throws:
    
    InvalidArgumentException
  - deleteObjects
```
public void deleteObjects(HashMap<String,List<String>> objects,
                          boolean releaseRelationships)
                   throws BusinessObjectNotFoundException,
                          MetadataObjectNotFoundException,
                          OperationNotPermittedException,
                          InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Deletes a set of objects
    
    Specified by:
    
    deleteObjects in interface BusinessEntityManager
    
    Parameters:
    
    objects - a hashmap where the class name is the key and the value is a list of long containing the ids of the objects to be deleted that are instance of the key class
    
    releaseRelationships - If all the relationships should be release upon deleting the objects. If false, an OperationNotPermittedException will be raised if the object has incoming relationships.
    
    Throws:
    
    BusinessObjectNotFoundException - If the requested object can't be found
    
    MetadataObjectNotFoundException - If the requested object class can't be found
    
    OperationNotPermittedException - If the update can't be performed due a business rule or because the object is blocked or it has relationships and releaseRelationships is false
    
    InvalidArgumentException - If the uuid can not be found
  - deleteObject
```
public void deleteObject(String className,
                         String oid,
                         boolean releaseRelationships)
                  throws BusinessObjectNotFoundException,
                         MetadataObjectNotFoundException,
                         OperationNotPermittedException,
                         InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Deletes a single object
    
    Specified by:
    
    deleteObject in interface BusinessEntityManager
    
    Parameters:
    
    className - Object's class name
    
    oid - Objects oid
    
    releaseRelationships - Release relationships automatically. If set to false, it will fail if the object already has incoming relationships
    
    Throws:
    
    BusinessObjectNotFoundException - If the object couldn't be found
    
    MetadataObjectNotFoundException - If the class could not be found
    
    OperationNotPermittedException - If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships.
    
    InvalidArgumentException - If the oid is null
  - updateObject
```
public ChangeDescriptor updateObject(String className,
                                     String oid,
                                     HashMap<String,String> attributes)
                              throws MetadataObjectNotFoundException,
                                     BusinessObjectNotFoundException,
                                     OperationNotPermittedException,
                                     InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Updates an object attributes. Note that you can't set binary attributes through this method. Use setBinaryAttributes instead.
    
    Specified by:
    
    updateObject in interface BusinessEntityManager
    
    Parameters:
    
    className - Object class name
    
    oid - Object's oid
    
    attributes - The attributes to be updated (the key is the attribute name, the value is and array with the value -or values in case of MANY TO MANY list type attributes-)
    
    Returns:
    
    The summary of the changes that were made
    
    Throws:
    
    MetadataObjectNotFoundException - If the object class can't be found
    
    BusinessObjectNotFoundException - If the object can't be found
    
    OperationNotPermittedException - If the update can't be performed due a business rule or because the object is blocked
    
    InvalidArgumentException - If any of the names provided does not exist or can't be set using this method or of the value of any of the attributes can not be mapped correctly or if the class provided is not a subclass of InventoryObject.
  - createSpecialRelationship
```
public void createSpecialRelationship(String aObjectClass,
                                      String aObjectId,
                                      String bObjectClass,
                                      String bObjectId,
                                      String name,
                                      boolean unique)
                               throws BusinessObjectNotFoundException,
                                      OperationNotPermittedException,
                                      MetadataObjectNotFoundException,
                                      InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Creates a relationship between two elements and labels it. Use with extreme care, since it can create arbitrary relationships
    
    Specified by:
    
    createSpecialRelationship in interface BusinessEntityManager
    
    Parameters:
    
    aObjectClass - a side object class
    
    aObjectId - a side object id
    
    bObjectClass - b side object class
    
    bObjectId - b side object id
    
    name - Name to label the new relationship
    
    unique - If there could be only one relationship between both elements with that name
    
    Throws:
    
    BusinessObjectNotFoundException - If any of the objects can't be found
    
    OperationNotPermittedException - if any of the objects involved can't be connected (i.e. if it's not an inventory object)
    
    MetadataObjectNotFoundException - if any of the classes provided can not be found
    
    InvalidArgumentException - If the a/bObjectId are null
  - createSpecialRelationship
```
public void createSpecialRelationship(String aObjectClass,
                                      String aObjectId,
                                      String bObjectClass,
                                      String bObjectId,
                                      String name,
                                      boolean unique,
                                      HashMap<String,Object> properties)
                               throws BusinessObjectNotFoundException,
                                      OperationNotPermittedException,
                                      MetadataObjectNotFoundException,
                                      InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    This method creates a special relationship with a set of property values
    
    Specified by:
    
    createSpecialRelationship in interface BusinessEntityManager
    
    Parameters:
    
    aObjectClass - The class of the first object to related
    
    aObjectId - The id of the first object to related
    
    bObjectClass - The class of the second object to related
    
    bObjectId - The id of the first object to related
    
    name - The name of the relationship
    
    unique - If there could be only one relationship between both elements with that name
    
    properties - A hash with the set of properties and their respective values
    
    Throws:
    
    BusinessObjectNotFoundException - If any of the objects can not be found
    
    OperationNotPermittedException - If, due to a business rule, the objects can not be related
    
    MetadataObjectNotFoundException - If any of the classes specified does not exist
    
    InvalidArgumentException - If the a/bObjectId are null
  - releaseSpecialRelationship
```
public void releaseSpecialRelationship(String objectClass,
                                       String objectId,
                                       String otherObjectId,
                                       String name)
                                throws BusinessObjectNotFoundException,
                                       MetadataObjectNotFoundException,
                                       InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Release all special relationships with a given name
    
    Specified by:
    
    releaseSpecialRelationship in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - Object id
    
    otherObjectId - The object we want to be released from. -1 To all objects related with relationships with that name
    
    name - Relationship name
    
    Throws:
    
    BusinessObjectNotFoundException - If the object can not be found
    
    MetadataObjectNotFoundException - If the class can not be found
    
    InvalidArgumentException - If objectId or otherObjectId are null
  - releaseSpecialRelationshipInTargetObject
```
public void releaseSpecialRelationshipInTargetObject(String objectClass,
                                                     String objectId,
                                                     String relationshipName,
                                                     String targetId)
                                              throws BusinessObjectNotFoundException,
                                                     MetadataObjectNotFoundException,
                                                     InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Release all special relationships with a given name whose target object id matches with the one provided
    
    Specified by:
    
    releaseSpecialRelationshipInTargetObject in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - Object id
    
    relationshipName - Relationship name
    
    targetId - Id of the object at the end of the relationship
    
    Throws:
    
    BusinessObjectNotFoundException - If the object can not be found
    
    MetadataObjectNotFoundException - If the class can not be found
    
    InvalidArgumentException - If the object/targetId are null
  - moveObjectsToPool
```
public void moveObjectsToPool(String targetClassName,
                              String targetOid,
                              HashMap<String,String[]> objects)
                       throws BusinessObjectNotFoundException,
                              OperationNotPermittedException,
                              MetadataObjectNotFoundException,
                              InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Move a list of objects to a new parent: this methods ignores those who can't be moved and raises an OperationNotPermittedException, however, it will move those which can be moved
    
    Specified by:
    
    moveObjectsToPool in interface BusinessEntityManager
    
    Parameters:
    
    targetClassName - Parent's class name
    
    targetOid - Parent's oid
    
    objects - Map using the object class name as keys and the respective objects oids as values
    
    Throws:
    
    BusinessObjectNotFoundException - If the object or its new parent can't be found
    
    OperationNotPermittedException - If the update can't be performed due to a business rule
    
    MetadataObjectNotFoundException - If the object's or new parent's class can't be found
    
    InvalidArgumentException - If inventory object/pool does no have uuid
  - moveObjects
```
public void moveObjects(String targetClassName,
                        String targetOid,
                        HashMap<String,String[]> objects)
                 throws BusinessObjectNotFoundException,
                        OperationNotPermittedException,
                        MetadataObjectNotFoundException,
                        InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Move a list of objects to a new parent: this methods ignores those who can't be moved and raises an OperationNotPermittedException, however, it will move those which can be moved
    
    Specified by:
    
    moveObjects in interface BusinessEntityManager
    
    Parameters:
    
    targetClassName - Parent's class name
    
    targetOid - Parent's oid
    
    objects - Map using the object class name as keys and the respective objects oids as values
    
    Throws:
    
    BusinessObjectNotFoundException - If the object or its new parent can't be found
    
    OperationNotPermittedException - If the update can't be performed due to a business rule
    
    MetadataObjectNotFoundException - If the object's or new parent's class can't be found
    
    InvalidArgumentException - If inventory object/pool does not have uuid
  - moveSpecialObjects
```
public void moveSpecialObjects(String targetClassName,
                               String targetOid,
                               HashMap<String,String[]> objects)
                        throws BusinessObjectNotFoundException,
                               OperationNotPermittedException,
                               MetadataObjectNotFoundException,
                               InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Move a list of objects to a new parent(taking into account the special hierarchy containment): this methods ignores those who can't be moved and raises an OperationNotPermittedException, however, it will move those which can be moved
    
    Specified by:
    
    moveSpecialObjects in interface BusinessEntityManager
    
    Parameters:
    
    targetClassName - Parent's class name
    
    targetOid - Parent's oid
    
    objects - Map using the object class name as keys and the respective objects oids as values
    
    Throws:
    
    BusinessObjectNotFoundException - If the object or its new parent can't be found
    
    OperationNotPermittedException - If the update can't be performed due to a business rule
    
    MetadataObjectNotFoundException - If the object's or new parent's class can't be found
    
    InvalidArgumentException - If an inventory object/pool does not have uuid
  - movePoolItem
```
public void movePoolItem(String poolId,
                         String poolItemClassName,
                         String poolItemId)
                  throws ApplicationObjectNotFoundException,
                         InvalidArgumentException,
                         BusinessObjectNotFoundException,
                         MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Move a pool item from a pool to another pool
    
    Specified by:
    
    movePoolItem in interface BusinessEntityManager
    
    Parameters:
    
    poolId - The id of the pool node
    
    poolItemClassName - The class name for the pool item
    
    poolItemId - The id for the pool item
    
    Throws:
    
    ApplicationObjectNotFoundException - If the pool node can not be found
    
    InvalidArgumentException - If the pool item can not be move to the selected pool
    
    BusinessObjectNotFoundException - If the pool item can not be found
    
    MetadataObjectNotFoundException - If the pool item class name can no be found
  - copyObjects
```
public String[] copyObjects(String targetClassName,
                            String targetOid,
                            HashMap<String,List<String>> objects,
                            boolean recursive)
                     throws BusinessObjectNotFoundException,
                            OperationNotPermittedException,
                            MetadataObjectNotFoundException,
                            InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Copy a set of objects
    
    Specified by:
    
    copyObjects in interface BusinessEntityManager
    
    Parameters:
    
    targetClassName - Target parent's class name
    
    targetOid - Target parent's oid
    
    objects - Hashmap with the objects class names as keys and their oids as values
    
    recursive - If this operation should also copy the children objects recursively
    
    Returns:
    
    A list containing the newly created object ids
    
    Throws:
    
    BusinessObjectNotFoundException - If any of the template objects couldn't be found
    
    OperationNotPermittedException - If the target parent can't contain any of the new instances
    
    MetadataObjectNotFoundException - If any of the provided classes couldn't be found
    
    InvalidArgumentException - If an inventory object id is null
  - copySpecialObjects
```
public String[] copySpecialObjects(String targetClassName,
                                   String targetOid,
                                   HashMap<String,List<String>> objects,
                                   boolean recursive)
                            throws BusinessObjectNotFoundException,
                                   OperationNotPermittedException,
                                   MetadataObjectNotFoundException,
                                   InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Copy a set of special objects (this is used to copy objects when they are containment are set in the special containment hierarchy) use case: to move physical links into a wire Container
    
    Specified by:
    
    copySpecialObjects in interface BusinessEntityManager
    
    Parameters:
    
    targetClassName - Target parent's class name
    
    targetOid - Target parent's oid
    
    objects - Hashmap with the objects class names as keys and their oids as values
    
    recursive - If this operation should also copy the children objects recursively
    
    Returns:
    
    A list containing the newly created object ids
    
    Throws:
    
    BusinessObjectNotFoundException - If any of the template objects couldn't be found
    
    OperationNotPermittedException - If the target parent can't contain any of the new instances
    
    MetadataObjectNotFoundException - If any of the provided classes couldn't be found
    
    InvalidArgumentException - If the objects can not be copied to the specified parent (most likely due to containment restrictions).
  - copyPoolItem
```
public String copyPoolItem(String poolId,
                           String poolItemClassName,
                           String poolItemId,
                           boolean recursive)
                    throws ApplicationObjectNotFoundException,
                           InvalidArgumentException,
                           BusinessObjectNotFoundException,
                           MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Copy a pool item from a pool to another pool
    
    Specified by:
    
    copyPoolItem in interface BusinessEntityManager
    
    Parameters:
    
    poolId - The id of the pool node
    
    poolItemClassName - The class name for the pool item
    
    poolItemId - The id for the pool item
    
    recursive - If this operation should also copy the children objects recursively
    
    Returns:
    
    The newly created object id
    
    Throws:
    
    ApplicationObjectNotFoundException - If the pool node can not be found
    
    InvalidArgumentException - If the pool item can not be move to the selected pool
    
    BusinessObjectNotFoundException - If the pool item can not be found
    
    MetadataObjectNotFoundException - If the pool item class name can no be found
  - getObjectChildren
```
public List<BusinessObjectLight> getObjectChildren(String className,
                                                   String oid,
                                                   int maxResults)
                                            throws BusinessObjectNotFoundException,
                                                   MetadataObjectNotFoundException,
                                                   InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the children of a given object
    
    Specified by:
    
    getObjectChildren in interface BusinessEntityManager
    
    Parameters:
    
    className - Object's class name
    
    oid - Object's oid
    
    maxResults - max number of children to be returned, -1 to return all
    
    Returns:
    
    The list of children
    
    Throws:
    
    BusinessObjectNotFoundException - If the object or its new parent can't be found
    
    MetadataObjectNotFoundException - If the object's can't be found
    
    InvalidArgumentException - If oid is null
  - getObjectChildren
```
public List<BusinessObjectLight> getObjectChildren(long classId,
                                                   String oid,
                                                   int maxResults)
                                            throws BusinessObjectNotFoundException,
                                                   MetadataObjectNotFoundException,
                                                   InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the children of a given object, providing the class and object id.
    
    Specified by:
    
    getObjectChildren in interface BusinessEntityManager
    
    Parameters:
    
    classId - The id of the class the object is instance of
    
    oid - The oid of the object
    
    maxResults - The max number of results to be retrieved. Use 0 to retrieve all
    
    Returns:
    
    The list of children.
    
    Throws:
    
    BusinessObjectNotFoundException - If the object could not be found.
    
    MetadataObjectNotFoundException - If the class could not be found.
    
    InvalidArgumentException - If the oid is null
  - getSiblings
```
public List<BusinessObjectLight> getSiblings(String className,
                                             String oid,
                                             int maxResults)
                                      throws MetadataObjectNotFoundException,
                                             BusinessObjectNotFoundException,
                                             InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the siblings of a given object in the containment hierarchy
    
    Specified by:
    
    getSiblings in interface BusinessEntityManager
    
    Parameters:
    
    className - Object class
    
    oid - Object oid
    
    maxResults - Max number of results to be returned
    
    Returns:
    
    List of siblings
    
    Throws:
    
    MetadataObjectNotFoundException - If the class does not exist
    
    BusinessObjectNotFoundException - If the object does not exist
    
    InvalidArgumentException - If the oid is null
  - getObjectsOfClassLight
```
public List<BusinessObjectLight> getObjectsOfClassLight(String className,
                                                        HashMap<String,String> filters,
                                                        long skip,
                                                        long limit)
                                                 throws InvalidArgumentException,
                                                        MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Recursively gets all the light instances of given class
    
    Specified by:
    
    getObjectsOfClassLight in interface BusinessEntityManager
    
    Parameters:
    
    className - Class name. It must be a subclass of InventoryObject
    
    filters - map of filters key: attribute name, value: attribute value
    
    skip - page or number of elements to skip
    
    limit - max count of child per page
    
    Returns:
    
    a set of instances of the class
    
    Throws:
    
    InvalidArgumentException - If the class name is null
    
    MetadataObjectNotFoundException - If the provided class name doesn't exists
  - getObjectsOfClass
```
public List<BusinessObject> getObjectsOfClass(String className,
                                              int maxResults)
                                       throws MetadataObjectNotFoundException,
                                              InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Recursively gets all the instances of given class
    
    Specified by:
    
    getObjectsOfClass in interface BusinessEntityManager
    
    Parameters:
    
    className - Class name. It mist be a subclass of InventoryObject
    
    maxResults - Max number of results. 0 to get all
    
    Returns:
    
    a list of instances
    
    Throws:
    
    MetadataObjectNotFoundException - if the class can not be found
    
    InvalidArgumentException - If the class is not subclass of InventoryObject
  - getChildrenOfClass
```
public List<BusinessObject> getChildrenOfClass(String parentOid,
                                               String parentClass,
                                               String classToFilter,
                                               int page,
                                               int maxResults)
                                        throws MetadataObjectNotFoundException,
                                               BusinessObjectNotFoundException,
                                               InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the direct children of a given object of a given class.
    
    Specified by:
    
    getChildrenOfClass in interface BusinessEntityManager
    
    Parameters:
    
    parentOid - parent id
    
    parentClass - Parent class
    
    classToFilter - Class to be match against
    
    page - the number of page of the number of elements to skip
    
    maxResults - max number of results. 0 to get all
    
    Returns:
    
    A list of children of parentid/parentClass instance that are instances of classToFilter.
    
    Throws:
    
    MetadataObjectNotFoundException - If any of the classes can not be found
    
    BusinessObjectNotFoundException - If parent object can not be found
    
    InvalidArgumentException - If the database objects can not be correctly mapped into serializable Java objects.
  - getSpecialChildrenOfClassLight
```
public List<BusinessObjectLight> getSpecialChildrenOfClassLight(String parentOid,
                                                                String parentClass,
                                                                String classToFilter,
                                                                int maxResults)
                                                         throws MetadataObjectNotFoundException,
                                                                BusinessObjectNotFoundException,
                                                                InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Returns the special children of a given object as RemoteBusinessObjectLight instances.This method is not recursive.
    
    Specified by:
    
    getSpecialChildrenOfClassLight in interface BusinessEntityManager
    
    Parameters:
    
    parentOid - The id of the parent object
    
    parentClass - The class name of the parent object
    
    classToFilter - The superclass/class to be used to filter the results. You can also use abstract superclasses.
    
    maxResults - The max number of results to fetch. Use -1 to retrieve all
    
    Returns:
    
    The list of special children of the given object, filtered using classToFilter
    
    Throws:
    
    MetadataObjectNotFoundException - If the parent class name provided could not be found
    
    BusinessObjectNotFoundException - If the parent object could not be found
    
    InvalidArgumentException - If the filter class is invalid.
  - getChildrenOfClassLightRecursive
```
public List<BusinessObjectLight> getChildrenOfClassLightRecursive(String parentOid,
                                                                  String parentClass,
                                                                  String classToFilter,
                                                                  HashMap<String,String> attributesToFilter,
                                                                  int page,
                                                                  int limit)
                                                           throws MetadataObjectNotFoundException,
                                                                  BusinessObjectNotFoundException,
                                                                  InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets all class and abstract class children of a given class to filter in a hierarchy with root in the given parent. i.e.: all the ports in Router, all the Routers in a City
    
    Specified by:
    
    getChildrenOfClassLightRecursive in interface BusinessEntityManager
    
    Parameters:
    
    parentOid - Object id of the root parent of the hierarchy
    
    parentClass - Class name of the root parent of the hierarchy
    
    classToFilter - Class name of the expected children
    
    attributesToFilter - if filtering by the attributes of the retrieved objects
    
    page - The page or the number of elements to skip, no pagination -1
    
    limit - Maximum number of results, -1 no limit
    
    Returns:
    
    The list of object instance of the given class to filter
    
    Throws:
    
    MetadataObjectNotFoundException - If the parent class is not found
    
    BusinessObjectNotFoundException - If the parent is not found
    
    InvalidArgumentException - If the parent Id is null
  - getSpecialChildrenOfClassLightRecursive
```
public List<BusinessObjectLight> getSpecialChildrenOfClassLightRecursive(String parentOid,
                                                                         String parentClass,
                                                                         String classToFilter,
                                                                         int maxResults)
                                                                  throws MetadataObjectNotFoundException,
                                                                         BusinessObjectNotFoundException,
                                                                         InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets all class and abstract class special children of a given class to filter in a hierarchy with root in the given parent. Use case: used in some class level and inventory level reports script
    
    Specified by:
    
    getSpecialChildrenOfClassLightRecursive in interface BusinessEntityManager
    
    Parameters:
    
    parentOid - Object id of the root parent of the hierarchy
    
    parentClass - Class name of the root parent of the hierarchy
    
    classToFilter - Class name of the expected children
    
    maxResults - Maximum number of results, -1 no limit
    
    Returns:
    
    The list of object instance of the given class to filter
    
    Throws:
    
    MetadataObjectNotFoundException - If the parent class is not found
    
    BusinessObjectNotFoundException - If the parent is not found
    
    InvalidArgumentException - If the parent Id is null
  - getChildrenOfClassLight
```
public List<BusinessObjectLight> getChildrenOfClassLight(String parentOid,
                                                         String parentClass,
                                                         String classToFilter,
                                                         int maxResults)
                                                  throws MetadataObjectNotFoundException,
                                                         BusinessObjectNotFoundException,
                                                         InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Same as getChildrenOfClass, but returns only the light version of the objects
    
    Specified by:
    
    getChildrenOfClassLight in interface BusinessEntityManager
    
    Parameters:
    
    parentOid - parent id
    
    parentClass - Parent class
    
    classToFilter - Class to be match against
    
    maxResults - max number of results. 0 to get all
    
    Returns:
    
    A list of children of parentid/parentClass instance, instances of classToFilter
    
    Throws:
    
    MetadataObjectNotFoundException - If any of the classes can not be found
    
    BusinessObjectNotFoundException - If parent object can not be found
    
    InvalidArgumentException - If the parent object id is null
  - getSpecialAttribute
```
public List<BusinessObjectLight> getSpecialAttribute(String objectClass,
                                                     String objectId,
                                                     String specialAttributeName)
                                              throws BusinessObjectNotFoundException,
                                                     MetadataObjectNotFoundException,
                                                     InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the value of a special attribute. A special attribute is one belonging to a business domain specific attribute (usually a model. Domain specific attribute information is not filed under the standard metadata but a special one. Implementations may vary)
    
    Specified by:
    
    getSpecialAttribute in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - object's class
    
    objectId - object's id
    
    specialAttributeName - Special attribute name
    
    Returns:
    
    A list of objects related to the object through a special relationship. An empty array if the object provided is not related to others using that relationship.
    
    Throws:
    
    BusinessObjectNotFoundException - if the object can not be found
    
    MetadataObjectNotFoundException - if either the object class or the attribute can not be found
    
    InvalidArgumentException - If the object id is null
  - getAnnotatedSpecialAttribute
```
public List<AnnotatedBusinessObjectLight> getAnnotatedSpecialAttribute(String objectClass,
                                                                       String objectId,
                                                                       String specialAttributeName)
                                                                throws BusinessObjectNotFoundException,
                                                                       MetadataObjectNotFoundException,
                                                                       InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    This method will extract the object at the other side of the special relationship and all the properties of the relationship itself
    
    Specified by:
    
    getAnnotatedSpecialAttribute in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - The class of the object whose special attribute will be retrieved from
    
    objectId - The object's id
    
    specialAttributeName - The name of the special attribute
    
    Returns:
    
    The list of elements related with such relationship plus the properties of theirs relationships
    
    Throws:
    
    BusinessObjectNotFoundException - If the object could not be found
    
    MetadataObjectNotFoundException - If the object class could not be found
    
    InvalidArgumentException - If the object id is null
  - getSpecialAttributes
```
public HashMap<String,List<BusinessObjectLight>> getSpecialAttributes(String className,
                                                                            String objectId,
                                                                            String... attributeNames)
                                                                     throws MetadataObjectNotFoundException,
                                                                            BusinessObjectNotFoundException,
                                                                            InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Returns the specified special relationships of a given object as a hashmap whose keys are the names of the relationships and the values the list of related objects. If no filter (attributeNames) is provided, all special attributes (relationships) will be returned
    
    Specified by:
    
    getSpecialAttributes in interface BusinessEntityManager
    
    Parameters:
    
    className - Object class
    
    objectId - Object Id
    
    attributeNames - The list of special attributes (relationships) to be fetched. if none provided, the method will return all of them.
    
    Returns:
    
    The hash map with the existing special relationships and the associated objects
    
    Throws:
    
    MetadataObjectNotFoundException - If the class provided does not exist
    
    BusinessObjectNotFoundException - if the object does not exist
    
    InvalidArgumentException - If the object id is null
  - getObjectSpecialChildren
```
public List<BusinessObjectLight> getObjectSpecialChildren(String objectClass,
                                                          String objectId)
                                                   throws MetadataObjectNotFoundException,
                                                          BusinessObjectNotFoundException,
                                                          InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the special children of a given object
    
    Specified by:
    
    getObjectSpecialChildren in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - object id
    
    Returns:
    
    The list of special children.
    
    Throws:
    
    MetadataObjectNotFoundException - If the class could not be found
    
    BusinessObjectNotFoundException - If the object could not be found.
    
    InvalidArgumentException - If the object id is null
  - getObjectSpecialChildrenWithFilters
```
public List<BusinessObjectLight> getObjectSpecialChildrenWithFilters(String objectClass,
                                                                     String objectId,
                                                                     List<String> childrenClassNamesToFilter,
                                                                     int page,
                                                                     int limit)
                                                              throws MetadataObjectNotFoundException,
                                                                     BusinessObjectNotFoundException,
                                                                     InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the special children of a given object
    
    Specified by:
    
    getObjectSpecialChildrenWithFilters in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - object id
    
    page - the number of results to skip or the page
    
    Returns:
    
    The list of special children.
    
    Throws:
    
    MetadataObjectNotFoundException - If the class could not be found
    
    BusinessObjectNotFoundException - If the object could not be found.
    
    InvalidArgumentException - If the object id is null
  - getObjectSpecialChildrenCount
```
public long getObjectSpecialChildrenCount(String objectClass,
                                          String objectId,
                                          String... childrenClassNamesToFilter)
                                   throws BusinessObjectNotFoundException,
                                          InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the special children of a given object
    
    Specified by:
    
    getObjectSpecialChildrenCount in interface BusinessEntityManager
    
    objectId - object id
    
    Returns:
    
    The list of special children.
    
    Throws:
    
    BusinessObjectNotFoundException - If the object could not be found.
    
    InvalidArgumentException - If the object id is null
  - hasRelationship
```
public boolean hasRelationship(String objectClass,
                               String objectId,
                               String relationshipName,
                               int numberOfRelationships)
                        throws BusinessObjectNotFoundException,
                               MetadataObjectNotFoundException,
                               InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Checks if an object has a given number of standard relationships with another object
    
    Specified by:
    
    hasRelationship in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - Object id
    
    relationshipName - Relationship name
    
    numberOfRelationships - Number of relationships
    
    Returns:
    
    True if the object has numberOfRelationships relationships with another object
    
    Throws:
    
    BusinessObjectNotFoundException - If the object can not be found
    
    MetadataObjectNotFoundException - If objectClass does not exist
    
    InvalidArgumentException - If the object id is null
  - hasSpecialAttribute
```
public boolean hasSpecialAttribute(String objectClass,
                                   String objectId,
                                   String attributeName)
                            throws MetadataObjectNotFoundException,
                                   BusinessObjectNotFoundException,
                                   InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Check if an object has a given special attribute.
    
    Specified by:
    
    hasSpecialAttribute in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - Object id
    
    attributeName - Attribute name
    
    Returns:
    
    True if the object has special attributes
    
    Throws:
    
    MetadataObjectNotFoundException
    
    BusinessObjectNotFoundException
    
    InvalidArgumentException
  - countChildren
```
public long countChildren(String objectClass,
                          String objectId)
                   throws MetadataObjectNotFoundException,
                          BusinessObjectNotFoundException,
                          InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Counts if an object has children
    
    Specified by:
    
    countChildren in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - Object id
    
    Returns:
    
    Number of children
    
    Throws:
    
    MetadataObjectNotFoundException
    
    BusinessObjectNotFoundException
    
    InvalidArgumentException
  - countSpecialChildren
```
public long countSpecialChildren(String objectClass,
                                 String objectId)
                          throws MetadataObjectNotFoundException,
                                 BusinessObjectNotFoundException,
                                 InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Counts if an object has special children
    
    Specified by:
    
    countSpecialChildren in interface BusinessEntityManager
    
    Returns:
    
    Number of special children
    
    Throws:
    
    MetadataObjectNotFoundException
    
    BusinessObjectNotFoundException
    
    InvalidArgumentException
  - releaseRelationships
```
public void releaseRelationships(String objectClass,
                                 String objectId,
                                 List<String> relationshipsToRelease)
                          throws MetadataObjectNotFoundException,
                                 BusinessObjectNotFoundException,
                                 InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Releases all the relationships with the given names associated to the object provided. If no relationships with such names exist, the method will do nothing. Use this method with extreme care, you can seriously affect the relational integrity of the system
    
    Specified by:
    
    releaseRelationships in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - The class of the target object
    
    objectId - The id of the target object
    
    relationshipsToRelease - An array with the relationships to be released
    
    Throws:
    
    MetadataObjectNotFoundException - If the class provided does not exist
    
    BusinessObjectNotFoundException - If the object could not be found
    
    InvalidArgumentException - If any of the relationships is now allowed according to the defined data model
  - hasSpecialRelationship
```
public boolean hasSpecialRelationship(String objectClass,
                                      String objectId,
                                      String relationshipName,
                                      int numberOfRelationships)
                               throws BusinessObjectNotFoundException,
                                      MetadataObjectNotFoundException,
                                      InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Checks if an object has a given number of special relationships with another object
    
    Specified by:
    
    hasSpecialRelationship in interface BusinessEntityManager
    
    Parameters:
    
    objectClass - Object class
    
    objectId - Object id
    
    relationshipName - Relationship name
    
    numberOfRelationships - Number of relationships
    
    Returns:
    
    True if the object has numberOfRelationships relationships with another object
    
    Throws:
    
    BusinessObjectNotFoundException - If the object can not be found
    
    MetadataObjectNotFoundException - if objectClass does not exist
    
    InvalidArgumentException - If the object id is null
  - createContact
```
public String createContact(String contactClass,
                            String customerClassName,
                            String customerId)
                     throws BusinessObjectNotFoundException,
                            InvalidArgumentException,
                            MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Creates a contact.Contacts are always associated to a customer
    
    Specified by:
    
    createContact in interface BusinessEntityManager
    
    Parameters:
    
    contactClass - Class of the contact. This class should always be a subclass of GenericContact
    
    customerClassName - The class of the customer this contact will be associated to
    
    customerId - The id of the customer this contact will be associated to
    
    Returns:
    
    The id of the newly created contact
    
    Throws:
    
    BusinessObjectNotFoundException - If the customer could not be found
    
    InvalidArgumentException - If any of the properties or its value is invalid
    
    MetadataObjectNotFoundException - If the customer class could not be found
  - updateContact
```
public void updateContact(String contactClass,
                          String contactId,
                          List<StringPair> properties)
                   throws BusinessObjectNotFoundException,
                          InvalidArgumentException,
                          MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Updates a contact's information
    
    Specified by:
    
    updateContact in interface BusinessEntityManager
    
    Parameters:
    
    contactClass - The class of the contact
    
    contactId - The id of the contact
    
    properties - The attributes to be updated. The list types require only the id of the linked list type as a string
    
    Throws:
    
    BusinessObjectNotFoundException - If the contact could not be found
    
    InvalidArgumentException - If any of the properties or its value is invalid
    
    MetadataObjectNotFoundException - If the contact class could not be found
  - deleteContact
```
public void deleteContact(String contactClass,
                          String contactId)
                   throws BusinessObjectNotFoundException,
                          InvalidArgumentException,
                          MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Deletes a contact
    
    Specified by:
    
    deleteContact in interface BusinessEntityManager
    
    Parameters:
    
    contactClass - The class of the contact
    
    contactId - The id of the contact
    
    Throws:
    
    BusinessObjectNotFoundException - If the contact could not be found
    
    InvalidArgumentException - If the name is empty or there's an attempt to change the creationDate
    
    MetadataObjectNotFoundException - If the class could not be found
  - getContact
```
public Contact getContact(String contactClass,
                          String contactId)
                   throws BusinessObjectNotFoundException,
                          MetadataObjectNotFoundException,
                          InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the entire information of a given contact
    
    Specified by:
    
    getContact in interface BusinessEntityManager
    
    Parameters:
    
    contactClass - The class of the contact
    
    contactId - The id of the contact
    
    Returns:
    
    the contact
    
    Throws:
    
    BusinessObjectNotFoundException - If the contact could not be found
    
    MetadataObjectNotFoundException - If the contact class could not be found
    
    InvalidArgumentException - If the contact is malformed and the customer it should be related to does not exist
  - getContactsForCustomer
```
public List<Contact> getContactsForCustomer(String customerClass,
                                            String customerId)
                                     throws BusinessObjectNotFoundException,
                                            MetadataObjectNotFoundException,
                                            InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves the list of contacts associated to a customer
    
    Specified by:
    
    getContactsForCustomer in interface BusinessEntityManager
    
    Parameters:
    
    customerClass - The class of the customer the contacts belong to
    
    customerId - The id of the customer the contacts belong to
    
    Returns:
    
    The list of contacts
    
    Throws:
    
    BusinessObjectNotFoundException - If the customer could not be found
    
    MetadataObjectNotFoundException - If the customer class could not be found
    
    InvalidArgumentException - If an error occurs while building the contact objects
  - searchForContacts
```
public List<Contact> searchForContacts(String searchString,
                                       int maxResults)
                                throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Searches in all the properties of a contact for a given string
    
    Specified by:
    
    searchForContacts in interface BusinessEntityManager
    
    Parameters:
    
    searchString - The string to be matched
    
    maxResults - The max number of results. Use -1 to retrieve al results
    
    Returns:
    
    The list of contacts that matches the search criteria
    
    Throws:
    
    InvalidArgumentException - If an error occurs while building the contact objects
  - getContacts
```
public List<Contact> getContacts(int page,
                                 int limit,
                                 HashMap<String,Object> filters)
                          throws InvalidArgumentException
```
    Specified by:
    
    getContacts in interface BusinessEntityManager
    
    Parameters:
    
    page - current page
    
    limit - limit of results per page. -1 to retrieve them all
    
    filters - The response may be filtered by customer (use key customer, value the customer name, a String) by type (use key type, value the type name, a String) by contact name (use key contact_name, value the contact name, a String) by contact email1 (use key contact_email1, value the contact email1, a String) by contact email2 (use key contact_email2, value the contact email2, a String)
    
    Returns:
    
    The list of contacts that matches the search criteria
    
    Throws:
    
    InvalidArgumentException - If an error occurs while building the contact objects
  - attachFileToObject
```
public long attachFileToObject(String name,
                               String tags,
                               byte[] file,
                               String className,
                               String objectId)
                        throws BusinessObjectNotFoundException,
                               OperationNotPermittedException,
                               MetadataObjectNotFoundException,
                               InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Relates a file to an inventory object
    
    Specified by:
    
    attachFileToObject in interface BusinessEntityManager
    
    Parameters:
    
    name - The name of the file
    
    tags - The tags that describe the contents of the file
    
    file - The file itself
    
    className - The class of the object the file will be attached to
    
    objectId - The id of the object the file will be attached to
    
    Returns:
    
    The id of the resulting file object
    
    Throws:
    
    BusinessObjectNotFoundException - If the inventory object could not be found
    
    OperationNotPermittedException - If there's some sort of system restriction that prevented the file to be created
    
    MetadataObjectNotFoundException - If the class provided does not exist
    
    InvalidArgumentException - If the file size exceeds the max permitted (default value is 10MB)
  - getFilesForObject
```
public List<FileObjectLight> getFilesForObject(String className,
                                               String objectId)
                                        throws BusinessObjectNotFoundException,
                                               MetadataObjectNotFoundException,
                                               InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Fetches the files associated to an inventory object. Note that this call won't retrieve the actual files, but only references to them
    
    Specified by:
    
    getFilesForObject in interface BusinessEntityManager
    
    Parameters:
    
    className - The class of the object whose files will be fetched from
    
    objectId - The id of the object whose files will be fetched from
    
    Returns:
    
    The list of files
    
    Throws:
    
    BusinessObjectNotFoundException - If the object could not be found
    
    MetadataObjectNotFoundException - If the class provided does not exist
    
    InvalidArgumentException - If the object id is null
  - getFile
```
public FileObject getFile(long fileObjectId,
                          String className,
                          String objectId)
                   throws BusinessObjectNotFoundException,
                          InvalidArgumentException,
                          MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves a particular file associated to an inventory object. This call returns the actual file
    
    Specified by:
    
    getFile in interface BusinessEntityManager
    
    Parameters:
    
    fileObjectId - The id of the file object
    
    className - The class of the object the file is associated to
    
    objectId - The id of the object the file is associated to
    
    Returns:
    
    The file
    
    Throws:
    
    BusinessObjectNotFoundException - If the object could not be found
    
    InvalidArgumentException - If for some low level reason, the file could not be read from its original location
    
    MetadataObjectNotFoundException - If the class provided does not exist
  - detachFileFromObject
```
public void detachFileFromObject(long fileObjectId,
                                 String className,
                                 String objectId)
                          throws BusinessObjectNotFoundException,
                                 InvalidArgumentException,
                                 MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Releases (and deletes) a file associated to an inventory object
    
    Specified by:
    
    detachFileFromObject in interface BusinessEntityManager
    
    Parameters:
    
    fileObjectId - The id of the file object
    
    className - The class of the object the file is associated to
    
    objectId - The id of the object the file is associated to
    
    Throws:
    
    BusinessObjectNotFoundException - If the object could not be found
    
    InvalidArgumentException - If for some low level reason, the file could not be deleted from disk
    
    MetadataObjectNotFoundException - If the class provided does not exist
  - updateFileProperties
```
public void updateFileProperties(long fileObjectId,
                                 List<StringPair> properties,
                                 String className,
                                 String objectId)
                          throws BusinessObjectNotFoundException,
                                 ApplicationObjectNotFoundException,
                                 InvalidArgumentException,
                                 MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Updates the properties of a file object (name or tags)
    
    Specified by:
    
    updateFileProperties in interface BusinessEntityManager
    
    Parameters:
    
    fileObjectId - The id of the file object
    
    properties - The set of properties as a dictionary key-value. Valid keys are "name" and "tags"
    
    className - The class of the object the file is attached to
    
    objectId - The id of the object the file is attached to
    
    Throws:
    
    BusinessObjectNotFoundException - If the object file is attached to could not be found
    
    ApplicationObjectNotFoundException - If the file object could not be found
    
    InvalidArgumentException - if any of the properties has an invalid name or if the file name is empty
    
    MetadataObjectNotFoundException - If the class of the object file is attached to could not be found
  - getFilesFromRelatedListTypeItems
```
public Map<BusinessObjectLight,List<FileObjectLight>> getFilesFromRelatedListTypeItems(String uuid)
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves a map with the files related to the list type item attributes of the given object
    
    Specified by:
    
    getFilesFromRelatedListTypeItems in interface BusinessEntityManager
    
    Parameters:
    
    uuid - the object id
    
    Returns:
    
    The map with the files. The key is the list type item and the value a list with the related files
  - findRoutesThroughSpecialRelationships
```
public List<BusinessObjectLightList> findRoutesThroughSpecialRelationships(String objectAClassName,
                                                                           String objectAId,
                                                                           String objectBClassName,
                                                                           String objectBId,
                                                                           String relationshipName)
                                                                    throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Finds all possible routes between two given inventory objects
    
    Specified by:
    
    findRoutesThroughSpecialRelationships in interface BusinessEntityManager
    
    Parameters:
    
    objectAClassName - Inventory object A class name
    
    objectAId - Inventory object A id
    
    objectBClassName - Inventory object B class name
    
    objectBId - Inventory object B id
    
    relationshipName - The name of the relationship used to navigate through nodes and find the route
    
    Returns:
    
    A list of the routes, including only the nodes as RemoteBusinessObjectLights
    
    Throws:
    
    InvalidArgumentException - If any of the inventory objects does not have uuid
  - getWarehousesInObject
```
public List<BusinessObjectLight> getWarehousesInObject(String objectClassName,
                                                       String objectId)
                                                throws MetadataObjectNotFoundException,
                                                       InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the warehouses in a object
    
    Specified by:
    
    getWarehousesInObject in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - The class of the object
    
    objectId - The id of the object
    
    Returns:
    
    Gets the warehouses in a object
    
    Throws:
    
    MetadataObjectNotFoundException - If the specified class could not be found.
    
    InvalidArgumentException
  - getWarehouseToObject
```
public BusinessObjectLight getWarehouseToObject(String objectClassName,
                                                String objectId)
                                         throws MetadataObjectNotFoundException,
                                                BusinessObjectNotFoundException,
                                                InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets warehouse related to object
    
    Specified by:
    
    getWarehouseToObject in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - The class of the object
    
    objectId - The id of the object
    
    Returns:
    
    Gets warehouse related to object.
    
    Throws:
    
    MetadataObjectNotFoundException - If the specified class could not be found.
    
    BusinessObjectNotFoundException - If the object provided could not be found.
    
    InvalidArgumentException
  - getPhysicalNodeToObjectInWarehouse
```
public BusinessObjectLight getPhysicalNodeToObjectInWarehouse(String objectClassName,
                                                              String objectId)
                                                       throws MetadataObjectNotFoundException,
                                                              BusinessObjectNotFoundException,
                                                              InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the physical node of a warehouse item
    
    Specified by:
    
    getPhysicalNodeToObjectInWarehouse in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - The class of the object
    
    objectId - The id of the object
    
    Returns:
    
    Gets the physical node of a warehouse item
    
    Throws:
    
    MetadataObjectNotFoundException - If the specified class could not be found.
    
    BusinessObjectNotFoundException - If the object provided could not be found.
    
    InvalidArgumentException
  - createClassLevelReport
```
public long createClassLevelReport(String className,
                                   String reportName,
                                   String reportDescription,
                                   String script,
                                   int outputType,
                                   boolean enabled)
                            throws MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Creates a class level report (a report that will be available for all instances of a given class -and its subclasses-)
    
    Specified by:
    
    createClassLevelReport in interface BusinessEntityManager
    
    Parameters:
    
    className - Class this report is going to be related to. It can be ab abstract class and the report will be available for all its subclasses
    
    reportName - Name of the report.
    
    reportDescription - ReportMetadata description.
    
    script - Script text.
    
    outputType - What will be the default output of this report? See RemoteReportLight for possible values
    
    enabled - If enabled, a report can be executed.
    
    Returns:
    
    The id of the newly created report.
    
    Throws:
    
    MetadataObjectNotFoundException - If the class provided could not be found.
  - createInventoryLevelReport
```
public long createInventoryLevelReport(String reportName,
                                       String reportDescription,
                                       String script,
                                       int outputType,
                                       boolean enabled,
                                       List<StringPair> parameters)
                                throws ApplicationObjectNotFoundException,
                                       InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Creates an inventory level report (a report that is not tied to a particlar instance or class. In most cases, they also receive parameters)
    
    Specified by:
    
    createInventoryLevelReport in interface BusinessEntityManager
    
    Parameters:
    
    reportName - Name of the report.
    
    reportDescription - ReportMetadata description.
    
    script - Script text.
    
    outputType - What will be the default output of this report? See InventoryLevelReportDescriptor for possible values
    
    enabled - If enabled, a report can be executed.
    
    parameters - Optional (it might be either null or an empty list). The list of the parameters that this report will support and optional default values. They will always be captured as strings, so it's up to the author of the report the sanitization and conversion of the inputs
    
    Returns:
    
    The id of the newly created report.
    
    Throws:
    
    ApplicationObjectNotFoundException - If the dummy root could not be found, which is actually a severe problem.
    
    InvalidArgumentException - If any of the parameter names is null or empty
  - deleteReport
```
public ChangeDescriptor deleteReport(long reportId)
                              throws ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Deletes a report
    
    Specified by:
    
    deleteReport in interface BusinessEntityManager
    
    Parameters:
    
    reportId - The id of the report.
    
    Returns:
    
    The summary of the changes
    
    Throws:
    
    ApplicationObjectNotFoundException - If the report could not be found.
  - updateReport
```
public ChangeDescriptor updateReport(long reportId,
                                     String reportName,
                                     String reportDescription,
                                     Boolean enabled,
                                     Integer type,
                                     String script)
                              throws ApplicationObjectNotFoundException,
                                     InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Updates the properties of an existing class level report.
    
    Specified by:
    
    updateReport in interface BusinessEntityManager
    
    Parameters:
    
    reportId - Id of the report.
    
    reportName - The name of the report. Null to leave it unchanged.
    
    reportDescription - The description of the report. Null to leave it unchanged.
    
    enabled - Is the report enabled? . Null to leave it unchanged.
    
    type - Type of the output of the report. See LocalReportLight for possible values
    
    script - Text of the script.
    
    Returns:
    
    The summary of the changes
    
    Throws:
    
    ApplicationObjectNotFoundException - If the report could not be found.
    
    InvalidArgumentException - If any of the report properties has a wrong or unexpected format.
  - updateReportParameters
```
public ChangeDescriptor updateReportParameters(long reportId,
                                               List<StringPair> parameters)
                                        throws ApplicationObjectNotFoundException,
                                               InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Updates the parameters of a report
    
    Specified by:
    
    updateReportParameters in interface BusinessEntityManager
    
    Parameters:
    
    reportId - The id of the report
    
    parameters - The list of parameters and optional default values. Those with null values will be deleted and the ones that didn't exist previously will be created.
    
    Returns:
    
    The summary of the changes
    
    Throws:
    
    ApplicationObjectNotFoundException - If the report was not found.
    
    InvalidArgumentException - If the any of the parameters has an invalid name.
  - getClassLevelReports
```
public List<ReportMetadataLight> getClassLevelReports(String className,
                                                      boolean recursive,
                                                      boolean includeDisabled)
                                               throws MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the class level reports associated to the given class (or its superclasses)
    
    Specified by:
    
    getClassLevelReports in interface BusinessEntityManager
    
    Parameters:
    
    className - The class to extract the reports from.
    
    recursive - False to get only the directly associated reports. True top get also the reports associate top its superclasses
    
    includeDisabled - True to also include the reports marked as disabled. False to return only the enabled ones.
    
    Returns:
    
    The list of reports.
    
    Throws:
    
    MetadataObjectNotFoundException - If the class could not be found
  - getInventoryLevelReports
```
public List<ReportMetadataLight> getInventoryLevelReports(boolean includeDisabled)
                                                   throws ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the inventory class reports.
    
    Specified by:
    
    getInventoryLevelReports in interface BusinessEntityManager
    
    Parameters:
    
    includeDisabled - True to also include the reports marked as disabled. False to return only the enabled ones.
    
    Returns:
    
    The list of reports.
    
    Throws:
    
    ApplicationObjectNotFoundException - f the dummy root could not be found, which is actually a severe problem.
  - getReport
```
public ReportMetadata getReport(long reportId)
                         throws ApplicationObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Gets the information related to a class level report.
    
    Specified by:
    
    getReport in interface BusinessEntityManager
    
    Parameters:
    
    reportId - The id of the report.
    
    Returns:
    
    The report.
    
    Throws:
    
    ApplicationObjectNotFoundException - If the report could not be found.
  - executeClassLevelReport
```
public byte[] executeClassLevelReport(String objectClassName,
                                      String objectId,
                                      long reportId)
                               throws MetadataObjectNotFoundException,
                                      ApplicationObjectNotFoundException,
                                      BusinessObjectNotFoundException,
                                      InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Executes a class level report and returns the result.
    
    Specified by:
    
    executeClassLevelReport in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - The class of the instance that will be used as input for the report.
    
    objectId - The id of the instance that will be used as input for the report.
    
    reportId - The id of the report.
    
    Returns:
    
    The result of the report execution.
    
    Throws:
    
    MetadataObjectNotFoundException - If the class could not be found.
    
    ApplicationObjectNotFoundException - If the report could not be found.
    
    BusinessObjectNotFoundException - If the inventory object could not be found.
    
    InvalidArgumentException - If there's an error during the execution of the report.
  - executeInventoryLevelReport
```
public byte[] executeInventoryLevelReport(long reportId,
                                          List<StringPair> parameters)
                                   throws ApplicationObjectNotFoundException,
                                          InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Executes an inventory level report and returns the result.
    
    Specified by:
    
    executeInventoryLevelReport in interface BusinessEntityManager
    
    Parameters:
    
    reportId - The id of the report.
    
    parameters - List of pairs param name - param value.
    
    Returns:
    
    The result of the report execution.
    
    Throws:
    
    ApplicationObjectNotFoundException - If the report could not be found.
    
    InvalidArgumentException - If the associated script exits with error.
  - getRootPools
```
public List<InventoryObjectPool> getRootPools(String className,
                                              int type,
                                              boolean includeSubclasses)
                                       throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves the pools that don't have any parent and are normally intended to be managed by the Pool Manager
    
    Specified by:
    
    getRootPools in interface BusinessEntityManager
    
    Parameters:
    
    className - The class name used to filter the results. Only the pools with a className attribute matching the provided value will be returned. Use null if you want to get all
    
    type - The type of pools that should be retrieved. Root pools can be for general purpose, or as roots in models
    
    includeSubclasses - Use true if you want to get only the pools whose className property matches exactly the one provided, and false if you want to also include the subclasses
    
    Returns:
    
    A set of pools
    
    Throws:
    
    InvalidArgumentException - If a root pool does not have the uuid
  - getPoolsInObject
```
public List<InventoryObjectPool> getPoolsInObject(String objectClassName,
                                                  String objectId,
                                                  String poolClass)
                                           throws BusinessObjectNotFoundException,
                                                  InvalidArgumentException,
                                                  MetadataObjectNotFoundException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves the pools associated to a particular object
    
    Specified by:
    
    getPoolsInObject in interface BusinessEntityManager
    
    Parameters:
    
    objectClassName - The parent object class name
    
    objectId - The parent object id
    
    poolClass - The class name used to filter the results. Only the pools with a className attribute matching the provided value will be returned. Use null if you want to get all
    
    Returns:
    
    A set of pools
    
    Throws:
    
    BusinessObjectNotFoundException - If the parent object can not be found
    
    InvalidArgumentException - If a pool does not have uuid
    
    MetadataObjectNotFoundException - If the argument poolClass is not a valid class.
  - getPoolsInPool
```
public List<InventoryObjectPool> getPoolsInPool(String parentPoolId,
                                                String poolClassName)
                                         throws ApplicationObjectNotFoundException,
                                                InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves the pools associated to a particular pool
    
    Specified by:
    
    getPoolsInPool in interface BusinessEntityManager
    
    Parameters:
    
    parentPoolId - The parent pool id
    
    poolClassName - The class name used to filter the results. Only the pools with a className attribute matching the provided value will be returned. Use null if you want to get all
    
    Returns:
    
    A set of pools
    
    Throws:
    
    ApplicationObjectNotFoundException - If the parent object can not be found
    
    InvalidArgumentException - If any pool does no have uuid
  - getPoolsInPoolCount
```
public long getPoolsInPoolCount(String parentPoolId,
                                String poolClassName)
                         throws ApplicationObjectNotFoundException,
                                InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves the total count of pools associated to a particular pool
    
    Specified by:
    
    getPoolsInPoolCount in interface BusinessEntityManager
    
    Parameters:
    
    parentPoolId - The parent pool id
    
    poolClassName - The class name used to filter the results. Only the pools with a className attribute matching the provided value will be returned. Use null if you want to get all
    
    Returns:
    
    the total count of the pools
    
    Throws:
    
    ApplicationObjectNotFoundException - If the parent object can not be found
    
    InvalidArgumentException - If any pool does no have uuid
  - getPool
```
public InventoryObjectPool getPool(String poolId)
                            throws ApplicationObjectNotFoundException,
                                   InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Gets a pool by its id
    
    Specified by:
    
    getPool in interface BusinessEntityManager
    
    Parameters:
    
    poolId - The pool's id
    
    Returns:
    
    the pool as a Pool object
    
    Throws:
    
    ApplicationObjectNotFoundException - If the pool could not be found
    
    InvalidArgumentException - If the pool id is null or the result pool does not have uuid
  - getPoolItems
```
public List<BusinessObjectLight> getPoolItems(String poolId,
                                              int limit)
                                       throws ApplicationObjectNotFoundException,
                                              InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves the list of objects from a pool
    
    Specified by:
    
    getPoolItems in interface BusinessEntityManager
    
    Parameters:
    
    poolId - Parent pool id
    
    limit - the results limit. per page 0 to avoid the limit
    
    Returns:
    
    The list of items inside the pool
    
    Throws:
    
    ApplicationObjectNotFoundException - If the pool id provided is not valid
    
    InvalidArgumentException - If the pool item is an inventory object and it does not have the uuid
  - getPoolItemsByClassName
```
public List<BusinessObjectLight> getPoolItemsByClassName(String poolId,
                                                         String className,
                                                         int page,
                                                         int limit)
                                                  throws ApplicationObjectNotFoundException,
                                                         InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Retrieves the list of objects from a pool
    
    Specified by:
    
    getPoolItemsByClassName in interface BusinessEntityManager
    
    Parameters:
    
    poolId - Parent pool id
    
    className - a given className to retrieve a set of objects of that className form the pool used when the pool is a Generic class and could have objects of different class
    
    page - the number of values of the result to skip or the page 0 to avoid
    
    limit - the results limit. per page 0 to avoid the limit
    
    Returns:
    
    The list of items inside the pool
    
    Throws:
    
    ApplicationObjectNotFoundException - If the pool id provided is not valid
    
    InvalidArgumentException - If the pool item is an inventory object and it does not have the uuid
  - getPoolItemsCount
```
public long getPoolItemsCount(String poolId,
                              String className)
                       throws ApplicationObjectNotFoundException,
                              InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Count the total of objects in a pool
    
    Specified by:
    
    getPoolItemsCount in interface BusinessEntityManager
    
    Parameters:
    
    poolId - Parent pool id
    
    className - a given className to retrieve a set of objects of that className form the pool used when the pool is a Generic class and could have objects of different class
    
    Returns:
    
    The count of items inside the pool
    
    Throws:
    
    ApplicationObjectNotFoundException - If the pool id provided is not valid
    
    InvalidArgumentException - If the pool item is an inventory object and it does not have the uuid
  - getInstanceOfClass
```
public org.neo4j.graphdb.Node getInstanceOfClass(String className,
                                                 String oid)
                                          throws MetadataObjectNotFoundException,
                                                 BusinessObjectNotFoundException,
                                                 InvalidArgumentException
```
    Boiler-plate code. Gets a particular instance given the class name and the oid. Callers must handle associated transactions
    
    Parameters:
    
    className - object class name
    
    oid - object id
    
    Returns:
    
    a Node representing the entity
    
    Throws:
    
    MetadataObjectNotFoundException - id the class could not be found
    
    BusinessObjectNotFoundException - if the object could not be found
    
    InvalidArgumentException - If the object id is null
  - getInstanceOfClass
```
public org.neo4j.graphdb.Node getInstanceOfClass(long classId,
                                                 String oid)
                                          throws MetadataObjectNotFoundException,
                                                 BusinessObjectNotFoundException
```
    Boiler-plate code. Gets a particular instance given the class name and the oid
    
    Parameters:
    
    classId - object class id
    
    oid - object id
    
    Returns:
    
    a Node representing the entity
    
    Throws:
    
    MetadataObjectNotFoundException - if the class could not be found
    
    BusinessObjectNotFoundException
  - getInstanceOfClass
```
public org.neo4j.graphdb.Node getInstanceOfClass(org.neo4j.graphdb.Node classNode,
                                                 String oid)
                                          throws BusinessObjectNotFoundException
```
    Throws:
    
    BusinessObjectNotFoundException
  - createObject
```
public org.neo4j.graphdb.Node createObject(org.neo4j.graphdb.Node classNode,
                                           ClassMetadata classToMap,
                                           HashMap<String,String> attributes)
                                    throws InvalidArgumentException,
                                           MetadataObjectNotFoundException
```
    Throws:
    
    InvalidArgumentException
    
    MetadataObjectNotFoundException
  - canDeleteObject
```
public boolean canDeleteObject(String className,
                               String oid)
                        throws BusinessObjectNotFoundException,
                               MetadataObjectNotFoundException,
                               OperationNotPermittedException,
                               InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Checks recursively if it's safe to delete a single object
    
    Specified by:
    
    canDeleteObject in interface BusinessEntityManager
    
    Parameters:
    
    className - Object's class name
    
    oid - Objects oid
    
    Returns:
    
    True if the object does not have relationships that keep it from being deleted. False otherwise.
    
    Throws:
    
    BusinessObjectNotFoundException - If the object couldn't be found
    
    MetadataObjectNotFoundException - If the requested object class can't be found
    
    OperationNotPermittedException - If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships.
    
    InvalidArgumentException
  - getObjectChildrenCount
```
public long getObjectChildrenCount(String className,
                                   String oid,
                                   HashMap<String,String> filters)
                            throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Get the child count given the parent class name and id.
    
    Specified by:
    
    getObjectChildrenCount in interface BusinessEntityManager
    
    Parameters:
    
    className - Parent class name
    
    oid - Parent id
    
    filters - map of filters key: attribute name, value: attribute value
    
    Returns:
    
    The count of child
    
    Throws:
    
    InvalidArgumentException - If the class name is null
  - getObjectChildren
```
public List<BusinessObjectLight> getObjectChildren(String className,
                                                   String oid,
                                                   HashMap<String,String> filters,
                                                   long skip,
                                                   long limit)
                                            throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Get a set of children to the given the parent class name and id.
    
    Specified by:
    
    getObjectChildren in interface BusinessEntityManager
    
    Parameters:
    
    className - Parent class name
    
    oid - Parent id
    
    filters - null for no filter, map of filters key: attribute name, value: attribute value
    
    skip - Skip index
    
    limit - Max count of child
    
    Returns:
    
    Set of children
    
    Throws:
    
    InvalidArgumentException - If the class name is null
  - getSuggestedObjectsWithFilterGroupedByClassName
```
public HashMap<String,List<BusinessObjectLight>> getSuggestedObjectsWithFilterGroupedByClassName(List<String> classesNamesToFilter,
                                                                                                       String filter,
                                                                                                       long classesSkip,
                                                                                                       long classesLimit,
                                                                                                       long objectSkip,
                                                                                                       long objectLimit)
                                                                                                throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Suggests a number of objects based on a search string. This search string will be case-insensitive-matched against the name of the objects and classes in the inventory attributes to filter.
    
    Specified by:
    
    getSuggestedObjectsWithFilterGroupedByClassName in interface BusinessEntityManager
    
    filter - value to filter in the attribute name of every business object name or class name o class display name
    
    Returns:
    
    Set of children
    
    Throws:
    
    InvalidArgumentException - If the class name, skip or limit are null
  - getSuggestedPoolsByName
```
public HashMap<String,List<InventoryObjectPool>> getSuggestedPoolsByName(List<String> classesNamesToFilter,
                                                                               String nameTofilter,
                                                                               long poolSkip,
                                                                               long poolLimit,
                                                                               long objectSkip,
                                                                               long objectLimit)
                                                                        throws InvalidArgumentException
```
    Description copied from interface: BusinessEntityManager
    
    Suggests a number of pools based on a search string (the pool name). This search string will be case-insensitive-matched against the name of the objects and classes in the inventory attributes to filter.
    
    Specified by:
    
    getSuggestedPoolsByName in interface BusinessEntityManager
    
    Returns:
    
    Set of pools
    
    Throws:
    
    InvalidArgumentException - If the class name, skip or limit are null

Class BusinessEntityManagerImpl

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BusinessEntityManagerImpl

Method Detail

initCache

setConfiguration

createObject

createObject

createSpecialObject

createSpecialObjectUsingTemplate

addParentToSpecialObject

createHeadlessObject

createPoolItem

createBulkObjects

createBulkSpecialObjects

getObject

getObjectLight

getObjectsWithFilterLight

getObjectsWithFilter

getSuggestedObjectsWithFilter

getSuggestedObjectsWithFilter

getSuggestedObjectsWithFilter

getObjectsByNameAndClassName

getSuggestedChildrenWithFilter

getAttributeValueAsString

getAttributeValuesAsString

getCommonParent

getParent

getParents

getParentsUntilFirstOfClass

getFirstParentOfClass

getMultipleParents

isParent

deleteObjects

deleteObject

updateObject

createSpecialRelationship

createSpecialRelationship

releaseSpecialRelationship

releaseSpecialRelationshipInTargetObject

moveObjectsToPool

moveObjects

moveSpecialObjects

movePoolItem

copyObjects

copySpecialObjects

copyPoolItem

getObjectChildren

getObjectChildren

getSiblings

getObjectsOfClassLight

getObjectsOfClass

getChildrenOfClass

getSpecialChildrenOfClassLight

getChildrenOfClassLightRecursive

getSpecialChildrenOfClassLightRecursive

getChildrenOfClassLight

getSpecialAttribute

getAnnotatedSpecialAttribute

getSpecialAttributes

getObjectSpecialChildren

getObjectSpecialChildrenWithFilters

getObjectSpecialChildrenCount

hasRelationship

hasSpecialAttribute

countChildren

countSpecialChildren

releaseRelationships

hasSpecialRelationship

createContact

updateContact

deleteContact

getContact

getContactsForCustomer

searchForContacts

getContacts