Interface KuwaibaSoapWebService

  • All Known Implementing Classes:
    KuwaibaSoapWebServiceImpl

    public interface KuwaibaSoapWebService
    The principal northbound interface. A simple, yet comprehensive, SOAP-based web service.
    Author:
    Charles Edward Bedon Cortazar <charles.bedon@kuwaiba.org>
    • Method Detail

      • createSession

        RemoteSession createSession​(String username,
                                    String password,
                                    int sessionType)
                             throws ServerSideException
        Creates a session. Only one session per type is allowed. If a new session is created and there was already one of the same type, the old one will be discarded. See RemoteSession.TYPE_XXX for possible session types. System users can not create sessions.
        Parameters:
        username - user login name
        password - user password
        sessionType - The type of session to be created. This type depends on what kind of client is trying to access (a desktop client, a web client, a web service user, etc. See RemoteSession.TYPE_XXX for possible session types
        Returns:
        A session object, including the session token
        Throws:
        ServerSideException - If the user does not exist If the password is incorrect or if the user is not enabled.
      • closeSession

        void closeSession​(String sessionId)
                   throws ServerSideException
        Closes a session
        Parameters:
        sessionId - Session token
        Throws:
        ServerSideException - If the session ID is Invalid or the IP does not match with the one registered for this session
      • getUsersInGroup

        List<RemoteUserInfo> getUsersInGroup​(long groupId,
                                             String sessionId)
                                      throws ServerSideException
        Retrieves the users in a group
        Parameters:
        groupId - The id of the group
        sessionId - Session token
        Returns:
        The list of users in the requested group
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the group does not exist or something unexpected happened.
      • getGroupsForUser

        List<GroupInfoLight> getGroupsForUser​(long userId,
                                              String sessionId)
                                       throws ServerSideException
        Retrieves the groups a user belongs to
        Parameters:
        userId - The id of the user
        sessionId - Session token
        Returns:
        The list of groups the user belongs to
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the group does not exist or something unexpected happened.
      • getGroups

        List<GroupInfo> getGroups​(String sessionId)
                           throws ServerSideException
        Retrieves the list of groups
        Parameters:
        sessionId - Session token
        Returns:
        A group object list
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or any possible error raised at runtime
      • createUser

        long createUser​(String username,
                        String password,
                        String firstName,
                        String lastName,
                        boolean enabled,
                        int type,
                        String email,
                        List<PrivilegeInfo> privileges,
                        long defaultGroupId,
                        String sessionId)
                 throws ServerSideException
        Creates a user. System users can be created but not deleted or modified. Create system users only if you are a developer, as they can only be modified or deleted by accessing directly to the database.
        Parameters:
        username - User name. Can't be null, empty or have non standard characters.
        password - A password (in plain text, it'll be encrypted later). Can't be null nor an empty string
        firstName - User's first name
        lastName - User's last name
        enabled - Is this user enable by default?
        type - The type of the user. See UserProfileLight.USER_TYPE* for possible values
        email - User's email
        privileges - A list privileges that will be granted to this user.
        defaultGroupId - Default group this user will be associated to. Users always belong to at least one group. Other groups can be added later.
        sessionId - Session token
        Returns:
        The new user Id
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the username is null or empty or the username already exists, if the user type is invalid or if the password is an empty string, or if it is attempted to change the user name of the admin user name, or if this operation is attempted on a system user. Also, if the new user type is invalid.
      • setUserProperties

        void setUserProperties​(long oid,
                               String username,
                               String firstName,
                               String lastName,
                               String password,
                               int enabled,
                               int type,
                               String email,
                               String sessionId)
                        throws ServerSideException
        Sets the properties of a given user using the id to search for it
        Parameters:
        oid - User id
        username - New user's name. Use null to leave it unchanged.
        password - New user's password. Use null to leave it unchanged
        firstName - New user's first name. Use null to leave it unchanged
        lastName - New user's last name. Use null to leave it unchanged
        enabled - 0 for false, 1 for true, -1 to leave it unchanged
        type - User type. See UserProfile.USER_TYPE* for possible values. Use -1 to leave it unchanged
        email - New user's email
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the username is null or empty or the username already exists, if the user type is invalid or if the password is an empty string, or if it is attempted to change the user name of the admin user name, or if this operation is attempted on a system user. Also, if the new user type is invalid.
      • addUserToGroup

        void addUserToGroup​(long userId,
                            long groupId,
                            String sessionId)
                     throws ServerSideException
        Adds a user to a group
        Parameters:
        userId - The id of the user to be added to the group
        groupId - Id of the group which the user will be added to
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the user is already related to that group or if the user or group can not be found.
      • removeUserFromGroup

        void removeUserFromGroup​(long userId,
                                 long groupId,
                                 String sessionId)
                          throws ServerSideException
        Removes a user from a group
        Parameters:
        userId - The id of the user to be added to the group
        groupId - Id of the group which the user will be added to
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the user is not related to that group or if the user or the group could not be found
      • setPrivilegeToUser

        void setPrivilegeToUser​(long userId,
                                String featureToken,
                                int accessLevel,
                                String sessionId)
                         throws ServerSideException
        Sets a privilege to a user. If the privilege already exists, the access level is updated, otherwise, the new privilege is added to the user.
        Parameters:
        userId - The user Id
        featureToken - The feature token. See class Privilege for details. Note that this token must match to the one expected by the client application. That's the only way the correct features will be enabled.
        accessLevel - The feature token. See class Privilege.ACCESS_LEVEL* for details.
        sessionId - Session token
        Throws:
        ServerSideException - If the access level is invalid, if the featureToken has a wrong format or if the user already has that privilege or if the user could not be found.
      • setPrivilegeToGroup

        void setPrivilegeToGroup​(long groupId,
                                 String featureToken,
                                 int accessLevel,
                                 String sessionId)
                          throws ServerSideException
        Sets a privilege to a group. If the privilege already exists, the access level is updated, otherwise, the new privilege is added to the group.
        Parameters:
        groupId - The user Id
        featureToken - The feature token. See class Privilege for details. Note that this token must match to the one expected by the client application. That's the only way the correct features will be enabled.
        accessLevel - The feature token. See class Privilege.ACCESS_LEVEL* for details.
        sessionId - Session token
        Throws:
        ServerSideException - If the access level is invalid, if the featureToken has a wrong format or if the group already has that privilege or if the group could not be found
      • removePrivilegeFromUser

        void removePrivilegeFromUser​(long userId,
                                     String featureToken,
                                     String sessionId)
                              throws ServerSideException
        Removes a privilege from a user
        Parameters:
        userId - Id of the user
        featureToken - The feature token. See class Privilege for details.
        sessionId - Session token
        Throws:
        ServerSideException - If the feature token is not related to the user or if the user could not be found
      • removePrivilegeFromGroup

        void removePrivilegeFromGroup​(long groupId,
                                      String featureToken,
                                      String sessionId)
                               throws ServerSideException
        Removes a privilege from a user
        Parameters:
        groupId - Id of the group
        featureToken - The feature token. See class Privilege for details.
        sessionId - Session token
        Throws:
        ServerSideException - If the feature token is not related to the group or if the group could not be found
      • createGroup

        long createGroup​(String groupName,
                         String description,
                         List<Long> users,
                         String sessionId)
                  throws ServerSideException
        Creates a group
        Parameters:
        groupName - Group name
        description - Group description
        users - List of user ids to be related to this group
        sessionId - Session token
        Returns:
        The group id
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the provided users could not be found
      • setGroupProperties

        void setGroupProperties​(long oid,
                                String groupName,
                                String description,
                                String sessionId)
                         throws ServerSideException
        Sets the properties for an existing group
        Parameters:
        oid - Group id
        groupName - New group name (null if unchanged)
        description - New group description (null if unchanged)
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the privileges ids is invalid. If the group could not be found.
      • deleteUsers

        void deleteUsers​(List<Long> oids,
                         String sessionId)
                  throws ServerSideException
        Deletes a list of users
        Parameters:
        oids - List of user ids to be deleted
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the users is the default administrator, which can't be deleted Generic exception encapsulating any possible error raised at runtime
      • deleteGroups

        void deleteGroups​(List<Long> oids,
                          String sessionId)
                   throws ServerSideException
        Deletes a list of groups
        Parameters:
        oids - list of group ids to be deleted
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the group you are trying to delete contains the default administrator Generic exception encapsulating any possible error raised at runtime
      • getObjectRelatedView

        RemoteViewObject getObjectRelatedView​(String oid,
                                              String objectClass,
                                              long viewId,
                                              String sessionId)
                                       throws ServerSideException
        Gets a particular view related to an object
        Parameters:
        oid - Object id
        objectClass - Object class
        viewId - The view id
        sessionId - Session token
        Returns:
        The View object (which is basically an XML document)
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object or the view can not be found If the corresponding class metadata can not be found If the provided view type is not supported
      • getObjectRelatedViews

        List<RemoteViewObjectLight> getObjectRelatedViews​(String oid,
                                                          String objectClass,
                                                          int viewType,
                                                          int limit,
                                                          String sessionId)
                                                   throws ServerSideException
        Returns list of views associated to an object
        Parameters:
        oid - Object id
        objectClass - Object class
        viewType - View type
        limit - Max number of results
        sessionId - Session token
        Returns:
        List of objects related to the object
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If the corresponding class metadata can not be found If the provided view type is not supported
      • getGeneralViews

        RemoteViewObjectLight[] getGeneralViews​(String viewClass,
                                                int limit,
                                                String sessionId)
                                         throws ServerSideException
        Gets all views that are not related to a particular object
        Parameters:
        viewClass - View class. Used to filter
        limit - Max number if results
        sessionId - Session token
        Returns:
        A list of views
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the view class does not exist If the user is not allowed to query for general views
      • getGeneralView

        RemoteViewObject getGeneralView​(long viewId,
                                        String sessionId)
                                 throws ServerSideException
        Gets the information of a particular view
        Parameters:
        viewId - View id
        sessionId - Session token
        Returns:
        The view
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the requested view
      • createListTypeItemRelatedView

        long createListTypeItemRelatedView​(String listTypeItemId,
                                           String listTypeItemClassName,
                                           String viewClassName,
                                           String name,
                                           String description,
                                           byte[] structure,
                                           byte[] background,
                                           String sessionId)
                                    throws ServerSideException
        Creates a view for a given list type item. If there's already a view of the provided view type, it will be overwritten
        Parameters:
        listTypeItemId - list type item id
        listTypeItemClassName - list type item class name
        viewClassName - view class name
        name - view name
        description - view description
        structure - XML document with the view structure
        background - background image
        sessionId - Session token
        Returns:
        The id of the new view.
        Throws:
        ServerSideException - If the list type item class can not be found If the view type is not supported
      • updateListTypeItemRelatedView

        void updateListTypeItemRelatedView​(String listTypeItemId,
                                           String listTypeItemClass,
                                           long viewId,
                                           String name,
                                           String description,
                                           byte[] structure,
                                           byte[] background,
                                           String sessionId)
                                    throws ServerSideException
        Updates a view for a given list type item. If there's already a view of the provided view type, it will be overwritten
        Parameters:
        listTypeItemId - list type item id
        listTypeItemClass - list type item class
        viewId - viewId
        name - view name
        description - view description
        structure - XML document with the view structure
        background - Background image. If null, the previous will be removed, if 0-sized array, it will remain unchanged
        sessionId - Session token
        Throws:
        ServerSideException - If the list type item can not be found If the list type item class can not be found If the view type is not supported
      • getListTypeItemRelatedView

        RemoteViewObject getListTypeItemRelatedView​(String listTypeItemId,
                                                    String listTypeItemClass,
                                                    long viewId,
                                                    String sessionId)
                                             throws ServerSideException
        Gets a view related to a list type item, given its id. An example of these views is a layout associated to a particular device model
        Parameters:
        listTypeItemId - list type item id
        listTypeItemClass - list type item class
        viewId - view id
        sessionId - Session token
        Returns:
        The associated view (there should be only one of each type). Null if there's none yet
        Throws:
        ServerSideException - If the list type item or the view can not be found. If the corresponding class metadata can not be found. If the provided view type is not supported.
      • getListTypeItemRelatedViews

        RemoteViewObjectLight[] getListTypeItemRelatedViews​(String listTypeItemId,
                                                            String listTypeItemClass,
                                                            int limit,
                                                            String sessionId)
                                                     throws ServerSideException
        Gets all the views related to a list type item. An example of these views is a layout associated to a particular device model
        Parameters:
        listTypeItemId - list type item id
        listTypeItemClass - list type class name
        limit - max number of results
        sessionId - Session token
        Returns:
        The associated views
        Throws:
        ServerSideException - If the corresponding class metadata can not be found If the provided view type is not supported
      • deleteListTypeItemRelatedView

        void deleteListTypeItemRelatedView​(String listTypeItemId,
                                           String listTypeItemClass,
                                           long viewId,
                                           String sessionId)
                                    throws ServerSideException
        Deletes a view related to a list type item
        Parameters:
        listTypeItemId - list type item id
        listTypeItemClass - list type class name
        viewId - related view id
        sessionId - Session token
        Throws:
        ServerSideException - If the list type item class can not be found If the list type item can no be found using the id If the view can not be found
      • getDeviceLayoutStructure

        byte[] getDeviceLayoutStructure​(String oid,
                                        String className,
                                        String sessionId)
                                 throws ServerSideException
        Gets the device layout structure
        Parameters:
        oid - object id
        className - class of object
        sessionId - Session id token
        Returns:
        the structure of the device layout
        Throws:
        ServerSideException
      • createObjectRelatedView

        long createObjectRelatedView​(String objectId,
                                     String objectClass,
                                     String name,
                                     String description,
                                     String viewClassName,
                                     byte[] structure,
                                     byte[] background,
                                     String sessionId)
                              throws ServerSideException
        Creates a view an relates it to an existing object
        Parameters:
        objectId - Object id
        objectClass - Object class
        name - View name
        description - View description
        viewClassName - View class name
        structure - Structure (as an XML document)
        background - Background
        sessionId - Session id
        Returns:
        The id of the newly created view
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If the object class can not be found If the view type is not supported
      • createGeneralView

        long createGeneralView​(String viewClass,
                               String name,
                               String description,
                               byte[] structure,
                               byte[] background,
                               String sessionId)
                        throws ServerSideException
        Creates a general view (a view that is not associated to any object)
        Parameters:
        viewClass - View class
        name - View name
        description - Description
        structure - Structure
        background - background
        sessionId - Session id
        Returns:
        The id of the newly created view
        Throws:
        ServerSideException - If the user is not allowed to invoke the method InvalidArgumentException if the view type is invalid
      • updateObjectRelatedView

        void updateObjectRelatedView​(String objectOid,
                                     String objectClass,
                                     long viewId,
                                     String viewName,
                                     String viewDescription,
                                     byte[] structure,
                                     byte[] background,
                                     String sessionId)
                              throws ServerSideException
        Updates an object view (a view that is linked to a particular object)
        Parameters:
        objectOid - Object id
        objectClass - Object class
        viewId - View id
        viewName - View name. Null to leave unchanged
        viewDescription - View description. Null to leave unchanged
        structure - View structure. Null to leave unchanged
        background - Background. Null to leave unchanged
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the view type is not supported
      • updateGeneralView

        void updateGeneralView​(long viewId,
                               String viewName,
                               String viewDescription,
                               byte[] structure,
                               byte[] background,
                               String sessionId)
                        throws ServerSideException
        Updates a general view (a view that is not linked to any particular object)
        Parameters:
        viewId - View id
        viewName - View name. Null to leave unchanged
        viewDescription - View Description. Null to leave unchanged
        structure - View structure. Null to leave unchanged
        background - Background. Null to leave unchanged
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the view type is invalid or if the background could not be saved. If the view couldn't be found
      • deleteGeneralView

        void deleteGeneralView​(List<Long> oids,
                               String sessionId)
                        throws ServerSideException
        Deletes views
        Parameters:
        oids - Ids of the views to be deleted
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the view can't be found
      • createListTypeItem

        String createListTypeItem​(String className,
                                  String name,
                                  String displayName,
                                  String sessionId)
                           throws ServerSideException
        Creates a list type item
        Parameters:
        className - List type item class name
        name - List type item name
        displayName - List type item display name
        sessionId - Session token
        Returns:
        the id of the new object
        Throws:
        ServerSideException - If the class provided is not a list type If the class is abstract or marked as in design.
      • updateListTypeItem

        void updateListTypeItem​(String className,
                                String oid,
                                List<StringPair> attributes,
                                String sessionId)
                         throws ServerSideException
        Updates a list type item. Formerly this functionality was provided by updateObject, but the implementation was split in two methods.
        Parameters:
        className - The class of the LTI to be updated. it must be a subclass of GenericObjectList
        oid - The id of the LTI to be updated.
        attributes - The attributes to be changed.
        sessionId - The session token.
        Throws:
        ServerSideException - If the LTI does not exist or if the class provided is not a subclass of GenericObjectList.
      • deleteListTypeItem

        void deleteListTypeItem​(String className,
                                String oid,
                                boolean releaseRelationships,
                                String sessionId)
                         throws ServerSideException
        Deletes a list type item
        Parameters:
        className - list type item class name
        oid - list type item id
        releaseRelationships - should the deletion process release the relationships attached to this object
        sessionId - Session token
        Throws:
        ServerSideException - If the class provided is not a list type If the user can't delete a list type item
      • getListTypeItem

        RemoteObject getListTypeItem​(String listTypeClassName,
                                     String listTypeItemId,
                                     String sessionId)
                              throws ServerSideException
        Retrieves list type item given its id
        Parameters:
        listTypeClassName - The class name of list type item
        listTypeItemId - The id of list type item
        sessionId - Session token
        Returns:
        A RemoteBusinessObject instance representing the item
        Throws:
        ServerSideException - If className is not an existing class If the class provided is not a list type
      • getListTypeItems

        List<RemoteObjectLight> getListTypeItems​(String className,
                                                 String sessionId)
                                          throws ServerSideException
        Retrieves all items for a single list type
        Parameters:
        className - The list type class
        sessionId - Session token
        Returns:
        a list of list type items
        Throws:
        ServerSideException - If className is not an existing class If the class provided is not a list type
      • executeQuery

        RemoteResultRecord[] executeQuery​(TransientQuery query,
                                          String sessionId)
                                   throws ServerSideException
        Executes a complex query generated using the Graphical Query Builder. Please note that the first record is reserved for the column headers, so and empty result set will have at least one record.
        Parameters:
        query - The TransientQuery object (a code friendly version of the graphical query designed at client side).
        sessionId - session id to check permissions
        Returns:
        An array of records (the first raw is used to put the headers)
        Throws:
        ServerSideException - If the class to be search is cannot be found If the user is not allowed to invoke the method
      • createQuery

        long createQuery​(String queryName,
                         long ownerOid,
                         byte[] queryStructure,
                         String description,
                         String sessionId)
                  throws ServerSideException
        Creates a query using the Graphical Query Builder
        Parameters:
        queryName - Query name
        ownerOid - OwnerOid. Null if public
        queryStructure - XML document as a byte array
        description - a short descriptions for the query
        sessionId - session id to check permissions
        Returns:
        a RemoteObjectLight wrapping the newly created query
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the owner could not be found.
      • saveQuery

        void saveQuery​(long queryOid,
                       String queryName,
                       long ownerOid,
                       byte[] queryStructure,
                       String description,
                       String sessionId)
                throws ServerSideException
        Save the query made in the graphical Query builder
        Parameters:
        queryOid - query oid to be updated
        queryName - query name (the same if unchanged)
        ownerOid - owneroid (if unchanged)
        queryStructure - XML document if unchanged. Null otherwise
        description - Query description. Null if unchanged
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the query can not be found
      • deleteQuery

        void deleteQuery​(long queryOid,
                         String sessionId)
                  throws ServerSideException
        Deletes a query
        Parameters:
        queryOid - Query id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the query could not be found
      • getQueries

        RemoteQueryLight[] getQueries​(boolean showPublic,
                                      String sessionId)
                               throws ServerSideException
        Retrieves all saved queries
        Parameters:
        showPublic - should this method return the public queries along with the private to this user?
        sessionId - Session token
        Returns:
        A list with the available queries
        Throws:
        ServerSideException - If the user is not allowed to invoke the method Generic exception encapsulating any possible error raised at runtime
      • getQuery

        RemoteQuery getQuery​(long queryOid,
                             String sessionId)
                      throws ServerSideException
        Retrieves a saved query
        Parameters:
        queryOid - Query id
        sessionId - Session token
        Returns:
        The query
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the query could not be found
      • getClassHierarchy

        byte[] getClassHierarchy​(boolean showAll,
                                 String sessionId)
                          throws ServerSideException
        Creates an XML document describing the class hierarchy
        Parameters:
        showAll - should this method return all entity classes or only InventoryObject subclasses
        sessionId - session identifier
        Returns:
        A byte array containing the class hierarchy as an XML document.
        Throws:
        ServerSideException - If one of the core classes could not be found
      • createRootPool

        String createRootPool​(String name,
                              String description,
                              String instancesOfClass,
                              int type,
                              String sessionId)
                       throws ServerSideException
        Creates a pool without a parent. They're used as general purpose place to put inventory objects, or as root for particular models
        Parameters:
        name - Pool name
        description - Pool description
        instancesOfClass - What kind of objects can this pool contain?
        type - Type of pool. For possible values see ApplicationManager.POOL_TYPE_XXX
        sessionId - The session token
        Returns:
        The id of the new pool
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the log root node could not be found
      • createPoolInObject

        String createPoolInObject​(String parentClassname,
                                  String parentId,
                                  String name,
                                  String description,
                                  String instancesOfClass,
                                  int type,
                                  String sessionId)
                           throws ServerSideException
        Creates a pool that will have as parent an inventory object. This special containment structure can be used to provide support for new models
        Parameters:
        parentClassname - Class name of the parent object
        parentId - Id of the parent object
        name - Pool name
        description - Pool descriptionCreates a pool that will have as parent an inventory object. This special containment structure can be used to provide support for new models
        instancesOfClass - What kind of objects can this pool contain?
        type - Type of pool. For possible values see ApplicationManager.POOL_TYPE_XXX
        sessionId - The session token
        Returns:
        The id of the new pool
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If instancesOfClass is not a valid subclass of InventoryObject If the parent object can not be found
      • createPoolInPool

        String createPoolInPool​(String parentId,
                                String name,
                                String description,
                                String instancesOfClass,
                                int type,
                                String sessionId)
                         throws ServerSideException
        Creates a pool that will have as parent another pool. This special containment structure can be used to provide support for new models
        Parameters:
        parentId - Id of the parent pool
        name - Pool name
        description - Pool description
        instancesOfClass - What kind of objects can this pool contain?
        type - Type of pool. Not used so far, but it will be in the future. It will probably be used to help organize the existing pools
        sessionId - The session token
        Returns:
        The id of the new pool
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If instancesOfClass is not a valid subclass of InventoryObject If the parent object can not be found
      • createPoolItem

        String createPoolItem​(String poolId,
                              String className,
                              String[] attributeNames,
                              String[] attributeValues,
                              String templateId,
                              String sessionId)
                       throws ServerSideException
        Creates an object within a pool
        Parameters:
        poolId - Id of the pool under which the object will be created
        className - Class this object is going to be instance of
        attributeNames - Attributes to be set in the new object. Null or empty array for none
        attributeValues - Attributes to be set in the new object (values). Null for none. The size of this array must match attributeNames size
        templateId - Template to be used. Use -1 to not use any template
        sessionId - Session identifier
        Returns:
        The id of the newly created object
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If attributeNames and attributeValues have different sizes If the class name could not be found
      • deletePools

        void deletePools​(String[] ids,
                         String sessionId)
                  throws ServerSideException
        Deletes a set of pools
        Parameters:
        ids - Pools to be deleted
        sessionId - Session identifier
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the pools to be deleted couldn't be found If any of the objects in the pool can not be deleted because it's not a business related instance (it's more a security restriction)
      • getRootPools

        List<RemotePool> getRootPools​(String className,
                                      int type,
                                      boolean includeSubclasses,
                                      String sessionId)
                               throws ServerSideException
        Retrieves the pools that don't have any parent and are normally intended to be managed by the Pool Manager
        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
        sessionId - Session token
        Returns:
        A set of pools
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or in case something goes wrong
      • getPoolsInObject

        List<RemotePool> getPoolsInObject​(String objectClassName,
                                          String objectId,
                                          String poolClass,
                                          String sessionId)
                                   throws ServerSideException
        Retrieves all the pools that are children of a particular object.
        Parameters:
        objectClassName - Object class.
        objectId - Object id.
        poolClass - Type of the pools that are to be retrieved (that is, the class of the objects contained within the pool)
        sessionId - Session id.
        Returns:
        A list of children pools.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or if the parent object can not be found or if the argument poolClass is not a valid class.
      • getPoolsInPool

        List<RemotePool> getPoolsInPool​(String parentPoolId,
                                        String poolClass,
                                        String sessionId)
                                 throws ServerSideException
        Gets the pools contained inside a pool.
        Parameters:
        parentPoolId - Parent pool id.
        poolClass - Class of the objects contained by the desired pool (not the parent pool).
        sessionId - Session token.
        Returns:
        A list of children pools
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the parent object can not be found
      • getPool

        RemotePool getPool​(String poolId,
                           String sessionId)
                    throws ServerSideException
        Retrieves information about a particular pool
        Parameters:
        poolId - The id of the pool
        sessionId - The session token
        Returns:
        The pool object
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the pool could not be found
      • setPoolProperties

        void setPoolProperties​(String poolId,
                               String name,
                               String description,
                               String sessionId)
                        throws ServerSideException
        Updates pool name and description
        Parameters:
        poolId - Pool Id
        name - Pool name
        description - Pool description
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method Generic exception encapsulating any possible error raised at runtime
      • getPoolItems

        List<RemoteObjectLight> getPoolItems​(String poolId,
                                             int limit,
                                             String sessionId)
                                      throws ServerSideException
        Gets the objects contained into a pool
        Parameters:
        poolId - Parent pool id
        limit - limit of results. -1 to return all
        sessionId - Session identifier
        Returns:
        The list of items
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the pool id provided is not valid
      • createTask

        long createTask​(String name,
                        String description,
                        boolean enabled,
                        boolean commitOnExecute,
                        String script,
                        List<StringPair> parameters,
                        RemoteTaskScheduleDescriptor schedule,
                        RemoteTaskNotificationDescriptor notificationType,
                        String sessionId)
                 throws ServerSideException
        Creates and schedule a task. A task is an application entity that allows to run jobs that will be executed depending on certain schedule
        Parameters:
        name - Task name
        description - Task description
        enabled - Is the task enabled?
        commitOnExecute - Should this task commit the changes (if any) after its execution? Handle with extreme care, you are basically running arbitrary code and affecting the db
        script - The script to be executed
        parameters - The parameters for the script
        schedule - When the task should be executed
        notificationType - How the result of the task should be notified to the associated users
        sessionId - The session token
        Returns:
        The id of the newly created task
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task is disabled If something goes wrong
      • updateTaskProperties

        void updateTaskProperties​(long taskId,
                                  String propertyName,
                                  String propertyValue,
                                  String sessionId)
                           throws ServerSideException
        Updates any of these properties from a task: name, description, enabled and script
        Parameters:
        taskId - Task id
        propertyName - Property name. Possible values: "name", "description", "enabled" and "script"
        propertyValue - The value of the property. For the property "enabled", the allowed values are "true" and "false"
        sessionId - The session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task could not be found If the property name has an invalid value
      • updateTaskParameters

        void updateTaskParameters​(long taskId,
                                  List<StringPair> parameters,
                                  String sessionId)
                           throws ServerSideException
        Updates the parameters of a task. If any of the values is null, that parameter will be deleted, if the parameter does not exist, it will be created
        Parameters:
        taskId - Task id
        parameters - The parameters to be modified as pairs paramName/paramValue. A null value means that that parameter should be deleted
        sessionId - The session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task could not be found
      • updateTaskSchedule

        void updateTaskSchedule​(long taskId,
                                RemoteTaskScheduleDescriptor schedule,
                                String sessionId)
                         throws ServerSideException
        Updates a task schedule
        Parameters:
        taskId - Task id
        schedule - New schedule
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task could not be found
      • updateTaskNotificationType

        void updateTaskNotificationType​(long taskId,
                                        RemoteTaskNotificationDescriptor notificationType,
                                        String sessionId)
                                 throws ServerSideException
        Updates a task notification type
        Parameters:
        taskId - Task id
        notificationType - New notification type
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task could not be found
      • getTask

        RemoteTask getTask​(long taskId,
                           String sessionId)
                    throws ServerSideException
        Retrieves the information about a particular task
        Parameters:
        taskId - Id of the task
        sessionId - Session token
        Returns:
        A remote task object representing the task
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task could not be found
      • getTasks

        List<RemoteTask> getTasks​(String sessionId)
                           throws ServerSideException
        Gets all the registered tasks
        Parameters:
        sessionId - Session token
        Returns:
        A list of task objects
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or in case something goes wrong
      • getTasksForUser

        List<RemoteTask> getTasksForUser​(long userId,
                                         String sessionId)
                                  throws ServerSideException
        Gets all the tasks related to a particular user
        Parameters:
        userId - User id
        sessionId - Session token
        Returns:
        A list of task objects
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the user can not be found
      • getSubscribersForTask

        List<RemoteUserInfoLight> getSubscribersForTask​(long taskId,
                                                        String sessionId)
                                                 throws ServerSideException
        Gets the users subscribed to a particular task.
        Parameters:
        taskId - Task id.
        sessionId - Session token.
        Returns:
        The list of subscribed users.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method Id the task could not be found
      • deleteTask

        void deleteTask​(long taskId,
                        String sessionId)
                 throws ServerSideException
        Deletes a task and unsubscribes all users from it
        Parameters:
        taskId - Task id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task could not be found
      • subscribeUserToTask

        void subscribeUserToTask​(long userId,
                                 long taskId,
                                 String sessionId)
                          throws ServerSideException
        Subscribes a user to a task, so it will be notified of the result of its execution
        Parameters:
        taskId - Id of the task
        userId - Id of the user
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the user is already subscribed to the task
      • unsubscribeUserFromTask

        void unsubscribeUserFromTask​(long userId,
                                     long taskId,
                                     String sessionId)
                              throws ServerSideException
        Unsubscribes a user from a task, so it will no longer be notified about the result of its execution
        Parameters:
        taskId - Id of the task
        userId - Id of the user
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task or the user could not be found
      • executeTask

        RemoteTaskResult executeTask​(long taskId,
                                     String sessionId)
                              throws ServerSideException
        Executes a task on demand.
        Parameters:
        taskId - The task id
        sessionId - The session token
        Returns:
        A RemoteTaskResult object wrapping the task execution messages and details.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the task doesn't have a script
      • createContact

        String createContact​(String contactClass,
                             List<StringPair> properties,
                             String customerClassName,
                             String customerId,
                             String sessionId)
                      throws ServerSideException
        Creates a contact
        Parameters:
        contactClass - The class of the new contact. It must be a subclass of GenericContact
        properties - A dictionary (key-value list) with the set of string-type attributes to be set. No string-type attributes are not currently supported. Attribute name is mandatory.
        customerClassName - The class of the customer this contact will be associated to
        customerId - The id of the customer this contact will be associated to
        sessionId - The session token
        Returns:
        The id of the newly created contact
        Throws:
        ServerSideException - If the contact class provided is not a valid GenericCustomer, or if the customer does not exist or if any of the properties does not exist or its type is invalid (not a string)
      • updateContact

        void updateContact​(String contactClass,
                           String contactId,
                           List<StringPair> properties,
                           String sessionId)
                    throws ServerSideException
        Updates a set of properties of a contact
        Parameters:
        contactClass - The class of the contact to be updated
        contactId - The id of the contact to be updated
        properties - A set of pairs key-value with the properties to be updated
        sessionId - The session token
        Throws:
        ServerSideException - If the contact could not be found or if any of the attributes to be set could not be found or has an invalid value
      • deleteContact

        void deleteContact​(String contactClass,
                           String contactId,
                           String sessionId)
                    throws ServerSideException
        Deletes a contact
        Parameters:
        contactClass - The class of the contact to be deleted
        contactId - The id of the contact to be deleted
        sessionId - The session token
        Throws:
        ServerSideException - If the contact was not found
      • getContact

        RemoteContact getContact​(String contactClass,
                                 String contactId,
                                 String sessionId)
                          throws ServerSideException
        Gets the whole information about a contact
        Parameters:
        contactClass - The class of the contact
        contactId - The id of the contact
        sessionId - The session token
        Returns:
        The contact object
        Throws:
        ServerSideException - If the contact could not be found
      • searchForContacts

        List<RemoteContact> searchForContacts​(String searchString,
                                              int maxResults,
                                              String sessionId)
                                       throws ServerSideException
        Searches for contacts given a search string, This string will be searched in the attribute values of all contacts
        Parameters:
        searchString - The string to be searched. Use null or an empty string to retrieve all the contacts
        maxResults - Maximum number of results. Use -1 to retrieve all results at once
        sessionId - The session token
        Returns:
        The list of contacts for whom at least one of their attributes matches
        Throws:
        ServerSideException - If the contact could not be found
      • getContactsForCustomer

        List<RemoteContact> getContactsForCustomer​(String customerClass,
                                                   String customerId,
                                                   String sessionId)
                                            throws ServerSideException
        Retrieves the contacts associated to a given customer
        Parameters:
        customerClass - The class of the customer to get the contacts from
        customerId - The id of the customer to get the contacts from
        sessionId - The session token
        Returns:
        The list of contacts associated to the customer
        Throws:
        ServerSideException - If the customer could not be found
      • getContacts

        List<RemoteContact> getContacts​(int page,
                                        int limit,
                                        List<StringPair> filters,
                                        String sessionId)
                                 throws ServerSideException
        Retrieves the list of contacts that matches the search criteria
        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)
        sessionId - The session token
        Returns:
        The list of contacts that matches the search criteria
        Throws:
        ServerSideException - If an error occurs while building the contact objects
      • createConfigurationVariable

        long createConfigurationVariable​(String configVariablesPoolId,
                                         String name,
                                         String description,
                                         int type,
                                         boolean masked,
                                         String valueDefinition,
                                         String sessionId)
                                  throws ServerSideException
        Creates a configuration variable inside a pool. A configuration variable is a place where a value will be stored so it can retrieved by whomever need it. These variables are typically used to store values that help other modules to work, such as URLs, user names, dimensions, etc
        Parameters:
        configVariablesPoolId - The id of the pool where the config variable will be put
        name - The name of the pool. This value can not be null or empty. Duplicate variable names are not allowed
        description - The description of the what the variable does
        type - The type of the variable. Use 1 for number, 2 for strings, 3 for booleans, 4 for unidimensional arrays and 5 for matrixes.
        masked - If the value should be masked when rendered (for security reasons, for example)
        valueDefinition - In most cases (primitive types like numbers, strings or booleans) will be the actual value of the variable as a string (for example "5" or "admin" or "true"). For arrays and matrixes use the following notation:
        Arrays: (value1,value2,value3,valueN), matrix: [(row1col1, row1col2,... row1colN), (row2col1, row2col2,... row2colN), (rowNcol1, rowNcol2,... rowNcolN)]. The values will be interpreted as strings
        sessionId - The session token
        Returns:
        The id of the newly created variable
        Throws:
        ServerSideException - If the parent pool could not be found or if the name is empty, the type is invalid, the value definition is empty
      • updateConfigurationVariable

        void updateConfigurationVariable​(String name,
                                         String propertyToUpdate,
                                         String newValue,
                                         String sessionId)
                                  throws ServerSideException
        Updates the value of a configuration variable. See ##createConfigurationVariable(long, java.lang.String, java.lang.String, int, boolean, java.lang.String, java.lang.String) for value definition syntax
        Parameters:
        name - The current name of the variable that will be modified
        propertyToUpdate - The name of the property to be updated. Possible values are: "name", "description", "type", "masked" and "value"
        newValue - The new value as string
        sessionId - The session token
        Throws:
        ServerSideException - If the property to be updated can not be recognized or if the configuration variable can not be found
      • deleteConfigurationVariable

        void deleteConfigurationVariable​(String name,
                                         String sessionId)
                                  throws ServerSideException
        Deletes a configuration variable
        Parameters:
        name - The name of the variable to be deleted
        sessionId - The session token
        Throws:
        ServerSideException - If the configuration variable could not be found
      • getConfigurationVariableValue

        RemoteObject getConfigurationVariableValue​(String name,
                                                   String sessionId)
                                            throws ServerSideException
        Retrieves only the value of a configuration variable. Masked values are returned as null.
        Parameters:
        name - The name of the variable. Masked values are returned as null.
        sessionId - The session token
        Returns:
        The value of the variable as a java object/data type. The numbers are returned as floats. The arrays and matrixes are returned as ArrayList<String> and ArrayList instances respectively
        Throws:
        ServerSideException - If the variable could not be found
      • getConfigurationVariablesInPool

        List<RemoteConfigurationVariable> getConfigurationVariablesInPool​(String poolId,
                                                                          String sessionId)
                                                                   throws ServerSideException
        Gets the configuration variables in a configuration variable pool
        Parameters:
        poolId - The id pool to retrieve the variables from
        sessionId - The session token
        Returns:
        The list of configuration variables in the given pool
        Throws:
        ServerSideException - If the pool could not be found
      • getConfigurationVariablesWithPrefix

        List<RemoteConfigurationVariable> getConfigurationVariablesWithPrefix​(String prefix,
                                                                              String sessionId)
                                                                       throws ServerSideException
        Gets the configuration variables with a given prefix
        Parameters:
        prefix - The prefix of the variables name
        sessionId - The session token
        Returns:
        The list of configuration variables with the given prefix
        Throws:
        ServerSideException - If the prefix could not be found
      • getAllConfigurationVariables

        List<RemoteConfigurationVariable> getAllConfigurationVariables​(String sessionId)
                                                                throws ServerSideException
        Gets all the configuration variables in the database, no matter what pool they belong to
        Parameters:
        sessionId - The session token
        Returns:
        The list of existing configuration variables
        Throws:
        ServerSideException - In case of an unexpected server side error
      • getConfigurationVariablesPools

        List<RemotePool> getConfigurationVariablesPools​(String sessionId)
                                                 throws ServerSideException
        Retrieves the list of pools of configuration variables.
        Parameters:
        sessionId - The session token.
        Returns:
        The available pools of configuration variables.
        Throws:
        ServerSideException - If an unexpected error occurred.
      • createConfigurationVariablesPool

        String createConfigurationVariablesPool​(String name,
                                                String description,
                                                String sessionId)
                                         throws ServerSideException
        Creates a pool of configuration variables.
        Parameters:
        name - The name of the pool. Empty or null values are not allowed.
        description - The description of the pool.
        sessionId - The session token.
        Returns:
        The id of the newly created pool.
        Throws:
        ServerSideException - If the name provided is null or empty.
      • updateConfigurationVariablesPool

        void updateConfigurationVariablesPool​(String poolId,
                                              String propertyToUpdate,
                                              String value,
                                              String sessionId)
                                       throws ServerSideException
        Updates an attribute of a given configuration variables pool.
        Parameters:
        poolId - The id of the pool to update.
        propertyToUpdate - The property to update. The valid values are "name" and "description".
        value - The value of the property to be updated.
        sessionId - The session token.
        Throws:
        ServerSideException - If the pool could not be found or If the property provided is not valid.
      • deleteConfigurationVariablesPool

        void deleteConfigurationVariablesPool​(String poolId,
                                              String sessionId)
                                       throws ServerSideException
        Deletes a configuration variables pool. Deleting a pool also deletes the configuration variables contained within.
        Parameters:
        poolId - The id of the pool to be deleted.
        sessionId - The session token.
        Throws:
        ServerSideException - If the pool could not be found.
      • createProxy

        String createProxy​(String proxyPoolId,
                           String proxyClass,
                           List<StringPair> attributes,
                           String sessionId)
                    throws ServerSideException
        Creates an inventory proxy. Inventory proxies are used to integrate third party-applications with Kuwaiba. Sometimes these applications must refer to assets managed by Kuwaiba from another perspective (financial, for example). In these applications, multiple Kuwaiba inventory assets might be represented by a single entity (e.g. a router with slots, boards and ports might just be something like "standard network device"). Proxies are used to map multiple inventory elements into a single entity. It's a sort of "impedance matching" between systems that refer to the same real world object from different perspectives.
        Parameters:
        proxyPoolId - The parent pool id.
        proxyClass - The proxy class. Must be subclass of GenericProxy.
        attributes - The set of initial attributes. If no attribute name is specified, an empty string will be used.
        sessionId - Session token.
        Returns:
        The id of the newly created proxy.
        Throws:
        ServerSideException - If the parent pool could not be found or if any of the initial attributes could not be mapped or if the proxy class could not be found.
      • deleteProxy

        void deleteProxy​(String proxyClass,
                         String proxyId,
                         String sessionId)
                  throws ServerSideException
        Deletes a proxy and delete its association with the related inventory objects. These objects will remain untouched.
        Parameters:
        proxyClass - The class of the proxy.
        proxyId - The id of the proxy
        sessionId - Session token.
        Throws:
        ServerSideException - If the proxy could not be found or if the proxy class could not be found.
      • updateProxy

        void updateProxy​(String proxyClass,
                         String proxyId,
                         List<StringPair> attributes,
                         String sessionId)
                  throws ServerSideException
        Updates one or many proxy attributes.
        Parameters:
        proxyId - The parent pool id,
        proxyClass - The class of the proxy.
        attributes - The set of initial attributes. If no attribute name is specified, an empty string will be used.
        sessionId - Session token.
        Throws:
        ServerSideException - If the parent pool could not be found or if any of the initial attributes could not be mapped or if the proxy class could not be found.
      • createProxyPool

        String createProxyPool​(String name,
                               String description,
                               String sessionId)
                        throws ServerSideException
        Creates a proxy pool.
        Parameters:
        name - The name of the pool.
        description - The description of the pool.
        sessionId - Session token.
        Returns:
        The id of the newly created proxy.
        Throws:
        ServerSideException - In case something unexpected happened.
      • updateProxyPool

        void updateProxyPool​(String proxyPoolId,
                             String attributeName,
                             String attributeValue,
                             String sessionId)
                      throws ServerSideException
        Updates an attribute of a proxy pool.
        Parameters:
        proxyPoolId - The id of the pool to be updated.
        attributeName - The name of the pool attribute to be updated. Valid values are "name" and "description"
        attributeValue - The value of the attribute. Null values will be ignored.
        sessionId - Session token.
        Throws:
        ServerSideException - If the pool could not be found or if an unknown attribute name is provided.
      • deleteProxyPool

        void deleteProxyPool​(String proxyPoolId,
                             String sessionId)
                      throws ServerSideException
        Deletes a proxy pool.
        Parameters:
        proxyPoolId - The id of the pool.
        sessionId - Session token.
        Throws:
        ServerSideException - If the pool could not be found.
      • getProxyPools

        List<RemotePool> getProxyPools​(String sessionId)
                                throws ServerSideException
        Retrieves the list of pools of proxies.
        Parameters:
        sessionId - Session token.
        Returns:
        The available pools of inventory proxies.
        Throws:
        ServerSideException - If case something unexpected happened.
      • getProxiesInPool

        List<RemoteInventoryProxy> getProxiesInPool​(String proxyPoolId,
                                                    String sessionId)
                                             throws ServerSideException
        Gets the list of inventory proxies in a given pool.
        Parameters:
        proxyPoolId - The id of the parent pool.
        sessionId - Session token.
        Returns:
        The proxies
        Throws:
        ServerSideException - If the parent pool could not be found or if the object in the database can not be mapped into an InventoryProxy instance.
      • associateObjectToProxy

        void associateObjectToProxy​(String objectClass,
                                    String objectId,
                                    String proxyClass,
                                    String proxyId,
                                    String sessionId)
                             throws ServerSideException
        Associates an inventory object to an inventory proxy.
        Parameters:
        objectClass - The class of the object.
        objectId - The id of the object.
        proxyClass - The class of the proxy.
        proxyId - The id of the proxy.
        sessionId - Session token.
        Throws:
        ServerSideException - If the inventory object could not be found or if the proxy could not be found or if the two entities are already related.
      • releaseObjectFromProxy

        void releaseObjectFromProxy​(String objectClass,
                                    String objectId,
                                    String proxyClass,
                                    String proxyId,
                                    String sessionId)
                             throws ServerSideException
        Releases an inventory previously related to an inventory proxy.
        Parameters:
        objectClass - The class of the object.
        objectId - The id of the object.
        proxyClass - The class of the proxy.
        proxyId - The id of the proxy.
        sessionId - Session token.
        Throws:
        ServerSideException - If the inventory object could not be found or if the proxy could not be found.
      • createValidatorDefinition

        long createValidatorDefinition​(String name,
                                       String description,
                                       String classToBeApplied,
                                       String script,
                                       boolean enabled,
                                       String sessionId)
                                throws ServerSideException
        Creates a validator definition.
        Parameters:
        name - The name of the validator. It's recommended to use camel case notation (for example thisIsAName). This field is mandatory
        description - The optional description of the validator
        classToBeApplied - The class or super class of the classes whose instances will be checked against this validator
        script - The groovy script containing the logic of the validator , that is, the
        enabled - If this validador should be applied or not
        sessionId - The session token
        Returns:
        The id of the newly created validator definition
        Throws:
        ServerSideException - If the name is null or empty or if the classToBeApplied argument could not be found
      • updateValidatorDefinition

        void updateValidatorDefinition​(long validatorDefinitionId,
                                       String name,
                                       String description,
                                       String classToBeApplied,
                                       String script,
                                       Boolean enabled,
                                       String sessionId)
                                throws ServerSideException
        Updates the properties of a validator. The null values will be ignored
        Parameters:
        validatorDefinitionId - The id of teh validator definition to be updated
        name - The new name, if any, null otherwise
        description - The new description, if any, null otherwise
        classToBeApplied - The new class to be associated to this validator, if any, null otherwise
        script - The new script, if any, null otherwise
        enabled - If the validator should be enabled or not, if any, null otherwise
        sessionId - The session token
        Throws:
        ServerSideException - If the validator definition could not be found or if the classToBeApplied parameter is not valid or if the name is not null, but it is empty
      • getValidatorDefinitionsForClass

        List<RemoteValidatorDefinition> getValidatorDefinitionsForClass​(String className,
                                                                        String sessionId)
                                                                 throws ServerSideException
        Retrieves all the validator definitions inside a class
        Parameters:
        className - The class to retrieve the validator definitions from.
        sessionId - The session token
        Returns:
        The list of validator definitions
        Throws:
        ServerSideException - In case of an unexpected server side error
      • runValidationsForObject

        List<RemoteValidator> runValidationsForObject​(String objectClass,
                                                      long objectId,
                                                      String sessionId)
                                               throws ServerSideException
        Runs the existing validations for the class associated to the given object. Validators set to enabled = false will be ignored
        Parameters:
        objectClass - The class of the object
        objectId - The id of the object
        sessionId - The session token
        Returns:
        The list of validators associated to the object and its class
        Throws:
        ServerSideException - If the object can not be found
      • deleteValidatorDefinition

        void deleteValidatorDefinition​(long validatorDefinitionId,
                                       String sessionId)
                                throws ServerSideException
        Deletes a validator definition
        Parameters:
        validatorDefinitionId - the id of the validator to be deleted
        sessionId - The session token
        Throws:
        ServerSideException - If the validator definition could not be found
      • getObjectChildrenForClassWithId

        List<RemoteObjectLight> getObjectChildrenForClassWithId​(String oid,
                                                                long objectClassId,
                                                                int maxResults,
                                                                String sessionId)
                                                         throws ServerSideException
        Gets the children of a given object given his class id and object id
        Parameters:
        objectClassId - object's class id
        oid - object's id
        maxResults - Max number of children to be returned. O for all
        sessionId - Session token
        Returns:
        An array of all the direct children of the provided object according with the current container hierarchy
        Throws:
        ServerSideException - If the class could not be found
      • getObjectChildren

        List<RemoteObjectLight> getObjectChildren​(String objectClassName,
                                                  String oid,
                                                  int maxResults,
                                                  String sessionId)
                                           throws ServerSideException
        Gets the children of a given object given his class name and object id
        Parameters:
        oid - Object's oid
        objectClassName - object's class name
        maxResults - Max number of children to be returned. O for all
        sessionId - Session token
        Returns:
        An array of all the direct children of the provided object according with the current container hierarchy
        Throws:
        ServerSideException - If the class could not be found.
      • getSiblings

        List<RemoteObjectLight> getSiblings​(String objectClassName,
                                            String oid,
                                            int maxResults,
                                            String sessionId)
                                     throws ServerSideException
        Returns the siblings of an object in the containment hierarchy
        Parameters:
        objectClassName - Object class
        oid - Object oid
        maxResults - Max number of results to be returned
        sessionId - Session token
        Returns:
        List of siblings
        Throws:
        ServerSideException - If the class does not exist If the object does not exist
      • getChildrenOfClass

        List<RemoteObject> getChildrenOfClass​(String parentOid,
                                              String parentClass,
                                              String childrenClass,
                                              int page,
                                              int maxResults,
                                              String sessionId)
                                       throws ServerSideException
        Gets all children of an object of a given class
        Parameters:
        parentOid - Parent whose children are requested
        parentClass - Class name of the element we want the children from
        childrenClass - The type of children we want to retrieve
        page - the number of elements to skip in the query
        maxResults - Max number of children to be returned. O for all
        sessionId - Session token
        Returns:
        An array with the children objects
        Throws:
        ServerSideException - If any of the classes can not be found If parent object can not be found If the database objects can not be correctly mapped into serializable Java objects.
      • getChildrenOfClassLightRecursive

        List<RemoteObjectLight> getChildrenOfClassLightRecursive​(String parentOid,
                                                                 String parentClass,
                                                                 String childrenClass,
                                                                 int maxResults,
                                                                 String sessionId)
                                                          throws ServerSideException
        Gets recursively all children of an object of a given class
        Parameters:
        parentOid - Parent whose children are requested
        parentClass - Class name of the element we want the children from
        childrenClass - The type of children we want to retrieve
        maxResults - Max number of children to be returned. O for all
        sessionId - Session token
        Returns:
        An array with the children objects
        Throws:
        ServerSideException - If any of the classes can not be found If parent object can not be found If the database objects can not be correctly mapped into serializable Java objects.
      • getChildrenOfClassLight

        List<RemoteObjectLight> getChildrenOfClassLight​(String parentOid,
                                                        String parentClass,
                                                        String childrenClass,
                                                        int maxResults,
                                                        String sessionId)
                                                 throws ServerSideException
        Gets all children of an object of a given class
        Parameters:
        parentOid - Object oid whose children will be returned
        parentClass -
        childrenClass -
        maxResults - Max number of children to be returned. O for all
        sessionId - Session token
        Returns:
        An array with children
        Throws:
        ServerSideException - If any of the classes can not be found If parent object can not be found
      • getSpecialChildrenOfClassLight

        List<RemoteObjectLight> getSpecialChildrenOfClassLight​(String parentOid,
                                                               String parentClass,
                                                               String classToFilter,
                                                               int maxResults,
                                                               String sessionId)
                                                        throws ServerSideException
        Returns the special children of a given object as RemoteObjectLight instances. This method is not recursive.
        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.
        sessionId - The session token.
        Returns:
        The list of special children of the given object, filtered using classToFilter.
        Throws:
        ServerSideException - If the parent class name provided could not be found or if the parent object could not be found.
      • getSpecialChildrenOfClassLightRecursive

        List<RemoteObjectLight> getSpecialChildrenOfClassLightRecursive​(String parentOid,
                                                                        String parentClass,
                                                                        String classToFilter,
                                                                        int maxResults,
                                                                        String sessionId)
                                                                 throws ServerSideException
        Returns the special children of a given object as RemoteObjectLight instances in a recursive fashion.
        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.
        sessionId - The session token.
        Returns:
        The recursive list of special children of the given object, filtered using classToFilter.
        Throws:
        ServerSideException - If the parent class name provided could not be found or if the parent object could not be found.
      • getObject

        RemoteObject getObject​(String objectClass,
                               String oid,
                               String sessionId)
                        throws ServerSideException
        Gets the complete information about a given object (all its attributes)
        Parameters:
        objectClass - Object class
        oid - Object id
        sessionId - Session token
        Returns:
        a representation of the entity as a RemoteObject. The list of attribute values is a hashmap of strings (should be mapped to actual types by the consumer of the service). Single list types are represented by the id of the list type item (a numeric value), while multiple list types are strings wit the ids of the related list type items separated by semicolons (e.g. 123;786576;92332)
        Throws:
        ServerSideException - If the className class could not be found If the requested object could not be found If the object id could not be found
      • getObjectLight

        RemoteObjectLight getObjectLight​(String objectClass,
                                         String oid,
                                         String sessionId)
                                  throws ServerSideException
        Gets the basic information about a given object (oid, classname, name)
        Parameters:
        objectClass - Object class name
        oid - Object oid
        sessionId - Session token
        Returns:
        a representation of the entity as a RemoteObjectLight
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getObjectsWithFilterLight

        List<RemoteObjectLight> getObjectsWithFilterLight​(String className,
                                                          String filterName,
                                                          String filterValue,
                                                          String sessionId)
                                                   throws ServerSideException
        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)
        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. To list type attributes the filter must be applied to the name. Example: filterName: model, filterValue: XYZ
        filterValue - The value to be use to match the instances. Example "Serial-12345"
        sessionId - The session token
        Returns:
        The list of instances that matches the filterName/filterValue criteria
        Throws:
        ServerSideException - if the class provided could not be found
      • getObjectsWithFilter

        List<RemoteObject> getObjectsWithFilter​(String className,
                                                String filterName,
                                                String filterValue,
                                                String sessionId)
                                         throws ServerSideException
        Same as getObjectsWithFilterLight(java.lang.String, java.lang.String, java.lang.String, java.lang.String), but returns RemoteObjects instead of RemoteObjectLights
        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. To list type attributes the filter must be applied to the name. Example: filterName: model, filterValue: XYZ
        filterValue - The value to be use to match the instances. Example "Serial-12345"
        sessionId - The session token
        Returns:
        The list of instances that matches the filterName/filterValue criteria
        Throws:
        ServerSideException - if the class provided could not be found
      • getObjectsOfClassLight

        List<RemoteObjectLight> getObjectsOfClassLight​(String className,
                                                       List<StringPair> attributesToFilter,
                                                       int page,
                                                       int maxResults,
                                                       String sessionId)
                                                throws ServerSideException
        Gets all objects of a given class
        Parameters:
        className - Class name
        attributesToFilter - attributes to filter for
        page - number of results to skip. Use -1 to retrieve all
        maxResults - Max number of results. Use -1 to retrieve all
        sessionId - Session token
        Returns:
        A list of instances of @className
        Throws:
        ServerSideException - If the class can not be found If the class is not subclass of InventoryObject
      • getCommonParent

        RemoteObjectLight getCommonParent​(String aObjectClass,
                                          String aOid,
                                          String bObjectClass,
                                          String bOid,
                                          String sessionId)
                                   throws ServerSideException
        Gets the common parent between an a object and b object
        Parameters:
        aObjectClass - Object a class name
        aOid - Object a id
        bObjectClass - Object b class name
        bOid - Object a id
        sessionId - Session Id token
        Returns:
        The common parent
        Throws:
        ServerSideException - If the requested object can't be found If any of the class nodes involved is malformed If the database object could not be properly mapped into a serializable java object.
      • getParent

        RemoteObjectLight getParent​(String objectClass,
                                    String oid,
                                    String sessionId)
                             throws ServerSideException
        Gets the parent of a given object in the standard and special containment hierarchy
        Parameters:
        objectClass - Object class of child
        oid - Object id for the child
        sessionId - Session id
        Returns:
        The parent object
        Throws:
        ServerSideException - If the requested object can't be found If any of the class nodes involved is malformed If the database object could not be properly mapped into a serializable java object.
      • getParents

        List<RemoteObjectLight> getParents​(String objectClass,
                                           String oid,
                                           String sessionId)
                                    throws ServerSideException
        Retrieves all the ancestors of an object in the containment hierarchy. If the provided object is in a pool, the ancestor pools will be returned.
        Parameters:
        objectClass - Object class
        oid - Object id.
        sessionId - Session token.
        Returns:
        The list of ancestors.
        Throws:
        ServerSideException - In case something goes wrong.
      • getSpecialAttributes

        RemoteObjectSpecialRelationships getSpecialAttributes​(String objectClass,
                                                              String oid,
                                                              String sessionId)
                                                       throws ServerSideException
        Returns all the 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
        Parameters:
        objectClass - Object class
        oid - Object id
        sessionId - Session token
        Returns:
        An object comprising the list of special relationships of the given object and the other end of such relationship
        Throws:
        ServerSideException - If case something goes wrong
      • getParentsUntilFirstOfClass

        List<RemoteObjectLight> getParentsUntilFirstOfClass​(String objectClass,
                                                            String oid,
                                                            String objectToMatchClassName,
                                                            String sessionId)
                                                     throws ServerSideException
        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")
        Parameters:
        objectClass - Class of the object to get the parents from
        oid - Id of the object to get the parents 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
        sessionId - Session token
        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:
        ServerSideException - If the object to evaluate can not be found or if any of the classes provided could not be found.
      • getFirstParentOfClass

        RemoteObjectLight getFirstParentOfClass​(String objectClass,
                                                String oid,
                                                String objectToMatchClassName,
                                                String sessionId)
                                         throws ServerSideException
        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")
        Parameters:
        objectClass - 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
        sessionId - The session id token
        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:
        ServerSideException - If the object to evaluate can not be found If any of the classes provided could not be found If the object provided is not in the standard containment hierarchy
      • getParentOfClass

        RemoteObject getParentOfClass​(String objectClass,
                                      String oid,
                                      String parentClass,
                                      String sessionId)
                               throws ServerSideException
        Gets the first parent of an object which matches the given class in the containment hierarchy
        Parameters:
        objectClass - Object class
        oid - Object oid
        parentClass - Class to be matched
        sessionId - sssion Id
        Returns:
        The direct parent of the provided object.
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getSpecialAttribute

        List<RemoteObjectLight> getSpecialAttribute​(String objectClass,
                                                    String oid,
                                                    String attributeName,
                                                    String sessionId)
                                             throws ServerSideException
        Gets the value of a special attribute, this is, those related to a model, such as cables connected to ports
        Parameters:
        objectClass - Object's class
        oid - object oid
        attributeName - attribute's name
        sessionId - Session token
        Returns:
        A list of the values related to the given object through attributeName. Note that this is a string array on purpose, so the values used not necessarily are not longs
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getObjectSpecialChildren

        List<RemoteObjectLight> getObjectSpecialChildren​(String objectClass,
                                                         String objectId,
                                                         String sessionId)
                                                  throws ServerSideException
        Gets the special children of a given object. This relationship depends on the model. The relationship between a container and the links in the physical layer model is an example of this kind of relationships.
        Parameters:
        objectClass - The class of the object to be searched.
        objectId - The id of the object to be searched.
        sessionId - Session token.
        Returns:
        A list of special children.
        Throws:
        ServerSideException - If the class could not be found If the object could not be found
      • updateObject

        void updateObject​(String className,
                          String oid,
                          List<StringPair> attributes,
                          String sessionId)
                   throws ServerSideException
        Updates attributes of a given object
        Parameters:
        className - object's class name
        oid - Object id
        attributes - A dictionary with pairs key-value, being key, the attribute name, and value, the serialized version of the attribute value. Single list types are represented by the id of the list type item (a numeric value), while multiple list types are strings wit the ids of the related list type items separated by semicolons (e.g. 123;786576;92332)
        sessionId - Session token
        Throws:
        ServerSideException - If the object class can't be found If the object can't be found If the update can't be performed due a business rule or because the object is blocked 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.
      • createObject

        String createObject​(String className,
                            String parentObjectClassName,
                            String parentOid,
                            String[] attributeNames,
                            String[] attributeValues,
                            String templateId,
                            String sessionId)
                     throws ServerSideException
        Creates a business object
        Parameters:
        className - New object class name
        parentObjectClassName - New object parent's class name
        parentOid - New object parent's id
        attributeNames - Names of the attributes to be set at creation time
        attributeValues - Values for those attributes
        templateId - Template id. Use -1 to not use any template
        sessionId - Session token
        Returns:
        the id of the new object
        Throws:
        ServerSideException - If the object's class can't be found If the parent id is not found If there's a business constraint that doesn't allow to create the object. If any of the attribute values has an invalid value or format. If the specified template could not be found
      • createSpecialObject

        String createSpecialObject​(String className,
                                   String parentObjectClassName,
                                   String parentOid,
                                   String[] attributeNames,
                                   String[] attributeValues,
                                   String templateId,
                                   String sessionId)
                            throws ServerSideException
        Creates a special business object. It's a generic method to create objects proper to special models. Parent object won't be linked to the new object through a conventional containment relationship
        Parameters:
        className - New object class name
        parentObjectClassName - New object parent's class name
        parentOid - New object parent's id
        attributeNames - Names of the attributes to be set at creation time
        attributeValues - Values for those attributes
        templateId - Template id. Use -1 to not use any template
        sessionId - Session token
        Returns:
        the id of the new object
        Throws:
        ServerSideException - If the object's class can't be found If the parent id is not found If the update can't be performed due to a format issue If any of the attribute values has an invalid value or format. If the specified template could not be found.
      • deleteObject

        void deleteObject​(String className,
                          String oid,
                          boolean releaseRelationships,
                          String sessionId)
                   throws ServerSideException
        Deletes a set of objects. Note that this method must be used only for business objects (not metadata or application ones)
        Parameters:
        className - Objects class names
        oid - object id from the objects to be deleted
        releaseRelationships - Should the deletion be forced, deleting all the relationships?
        sessionId - Session token
        Throws:
        ServerSideException - If the object couldn't be found If the class could not be found If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships.
      • deleteObjects

        void deleteObjects​(String[] classNames,
                           String[] oids,
                           boolean releaseRelationships,
                           String sessionId)
                    throws ServerSideException
        Deletes a set of objects. Note that this method must be used only for business objects (not metadata or application ones)
        Parameters:
        classNames - Objects class names
        oids - object id from the objects to be deleted
        releaseRelationships - Should the deletion be forced, deleting all the relationships?
        sessionId - Session token
        Throws:
        ServerSideException - If the requested object can't be found If the requested object class can't be found 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 If it was not possible to release the possible unique attributes
      • moveObjectsToPool

        void moveObjectsToPool​(String targetClass,
                               String targetOid,
                               String[] objectClasses,
                               String[] objectOids,
                               String sessionId)
                        throws ServerSideException
        Moves objects from their current parent to a pool target object.
        Parameters:
        targetClass - New parent object id
        targetOid - The new parent's oid
        objectClasses - Class names of the objects to be moved
        objectOids - Oids of the objects to be moved
        sessionId - Session token
        Throws:
        ServerSideException - If the object's or new parent's class can't be found If the object or its new parent can't be found If the update can't be performed due to a business rule
      • moveObjects

        void moveObjects​(String targetClass,
                         String targetOid,
                         String[] objectClasses,
                         String[] objectOids,
                         String sessionId)
                  throws ServerSideException
        Moves objects from their current parent to a target object.
        Parameters:
        targetClass - New parent object id
        targetOid - The new parent's oid
        objectClasses - Class names of the objects to be moved
        objectOids - Oids of the objects to be moved
        sessionId - Session token
        Throws:
        ServerSideException - If the object's or new parent's class can't be found If the object or its new parent can't be found If the update can't be performed due to a business rule
      • moveSpecialObjects

        void moveSpecialObjects​(String targetClass,
                                String targetOid,
                                String[] objectClasses,
                                String[] objectOids,
                                String sessionId)
                         throws ServerSideException
        Moves special objects from their current parent to a target object.
        Parameters:
        targetClass - New parent object id
        targetOid - The new parent's oid
        objectClasses - Class names of the objects to be moved
        objectOids - Oids of the objects to be moved
        sessionId - Session token
        Throws:
        ServerSideException - If the object's or new parent's class can't be found If the object or its new parent can't be found If the update can't be performed due to a business rule
      • movePoolItemToPool

        void movePoolItemToPool​(String poolId,
                                String poolItemClassName,
                                String poolItemId,
                                String sessionId)
                         throws ServerSideException
        Move a pool item from a pool to another pool
        Parameters:
        poolId - The id of the pool node
        poolItemClassName - The class name for the pool item
        poolItemId - The id for the pool item
        sessionId - Session token
        Throws:
        ServerSideException - If the pool node can not be found If the pool item can not be move to the selected pool If the pool item can not be found If the pool item class name can no be found
      • copyObjects

        String[] copyObjects​(String targetClass,
                             String targetOid,
                             String[] objectClasses,
                             String[] objectOids,
                             boolean recursive,
                             String sessionId)
                      throws ServerSideException
        Copy objects from its current parent to a target. This is not a deep copy. Only the selected object will be copied, not the children
        Parameters:
        targetClass - The new parent class name
        targetOid - The new parent oid
        objectClasses - Class names of the objects to be copied
        objectOids - Oids of the objects to be copied
        recursive - should the objects be copied recursively? (themselves plus their children)
        sessionId - Session token
        Returns:
        An array with the ids of the new objects
        Throws:
        ServerSideException - If any of the provided classes couldn't be found If any of the template objects couldn't be found If the target parent can't contain any of the new instances
      • copySpecialObjects

        String[] copySpecialObjects​(String targetClass,
                                    String targetOid,
                                    String[] objectClasses,
                                    String[] objectOids,
                                    boolean recursive,
                                    String sessionId)
                             throws ServerSideException
        Copy special objects from its current parent to a target. This is not a deep copy. Only the selected object will be copied, not the children
        Parameters:
        targetClass - The new parent class name
        targetOid - The new parent oid
        objectClasses - Class names of the objects to be copied
        objectOids - Oids of the objects to be copied
        recursive - should the objects be copied recursively? (themselves plus their children)
        sessionId - Session token
        Returns:
        An array with the ids of the new objects
        Throws:
        ServerSideException - If any of the provided classes couldn't be found If any of the template objects couldn't be found If the target parent can't contain any of the new instances
      • copyPoolItemToPool

        void copyPoolItemToPool​(String poolId,
                                String poolItemClassName,
                                String poolItemId,
                                boolean recursive,
                                String sessionId)
                         throws ServerSideException
        Copy a pool item from a pool to another pool
        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
        sessionId - Session token
        Throws:
        ServerSideException - If the pool node can not be found If the pool item can not be move to the selected pool If the pool item can not be found If the pool item class name can no be found
      • getMandatoryAttributesInClass

        List<RemoteAttributeMetadata> getMandatoryAttributesInClass​(String className,
                                                                    String sessionId)
                                                             throws ServerSideException
        Retrieves the mandatory attributes for a given class
        Parameters:
        className - The class name
        sessionId - Session token
        Returns:
        The list of mandatory attributes in the given class
        Throws:
        ServerSideException - If the class doesn't exist
      • createBulkObjects

        String[] createBulkObjects​(String className,
                                   String parentClassName,
                                   String parentOid,
                                   String namePattern,
                                   String templateId,
                                   String sessionId)
                            throws ServerSideException
        Creates multiple objects using a given name pattern
        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 - the id template to create the object, it can be null if not a template is going to be used
        sessionId - Session id token
        Returns:
        A list of ids for the new objects
        Throws:
        ServerSideException - If the className or the parentClassName can not be found. 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. If the parent node can not be found. If the given name pattern not match with the regular expression to build the new object name.
      • createBulkSpecialObjects

        String[] createBulkSpecialObjects​(String className,
                                          String parentClassName,
                                          String parentId,
                                          String namePattern,
                                          String templateId,
                                          String sessionId)
                                   throws ServerSideException
        Creates multiple special objects using a given naming pattern
        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
        namePattern - A pattern to create the names for the new special objects
        templateId - The template to be used for the new set of objects.
        sessionId - Session id token
        Returns:
        A list of ids for the new special objects
        Throws:
        ServerSideException - If the className or the parentClassName can not be found. If the parent node can not be found. If the given name pattern not match with the regular expression to build the new object name. 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. If the template could not be found.
      • connectMirrorPort

        void connectMirrorPort​(String[] aObjectClass,
                               String[] aObjectId,
                               String[] bObjectClass,
                               String[] bObjectId,
                               String sessionId)
                        throws ServerSideException
        Connect two ports using a mirror relationship
        Parameters:
        aObjectClass - Port A class
        aObjectId - Port A id
        bObjectClass - Port B class
        bObjectId - Port B id
        sessionId - Session token
        Throws:
        ServerSideException - If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found
      • connectMirrorMultiplePort

        void connectMirrorMultiplePort​(String aObjectClass,
                                       String aObjectId,
                                       List<String> bObjectClasses,
                                       List<String> bObjectIds,
                                       String sessionId)
                                throws ServerSideException
        Connect two ports using a mirrorMultiple relationship
        Parameters:
        aObjectClass - Port a class
        aObjectId - Port a id
        bObjectClasses - Port b classes
        bObjectIds - Port b ids
        sessionId - Session token
        Throws:
        ServerSideException
      • releaseMirrorPort

        void releaseMirrorPort​(String objectClass,
                               String objectId,
                               String sessionId)
                        throws ServerSideException
        Releases a port mirroring relationship between two ports, receiving one of the ports as parameter
        Parameters:
        objectClass - Object class
        objectId - Object id
        sessionId - Session token
        Throws:
        ServerSideException - If the object can not be found If the class can not be found
      • releaseMirrorMultiplePort

        void releaseMirrorMultiplePort​(String objectClass,
                                       String objectId,
                                       String sessionId)
                                throws ServerSideException
        Releases a port mirroring multiple relationship between two ports, receiving one of the ports as parameter
        Parameters:
        objectClass - Object class
        objectId - Object id
        sessionId - Session token
        Throws:
        ServerSideException - If the object can not be found If the class can not be found
      • createPhysicalConnection

        String createPhysicalConnection​(String aObjectClass,
                                        String aObjectId,
                                        String bObjectClass,
                                        String bObjectId,
                                        String name,
                                        String connectionClass,
                                        String templateId,
                                        String sessionId)
                                 throws ServerSideException
        Creates a physical connection (a container or a link). The validations are made at server side (this is, if the connection can be established between the two endpoints, if they're not already connected, etc)
        Parameters:
        aObjectClass - "a" endpoint object class
        aObjectId - "a" endpoint object id
        bObjectClass - "b" endpoint object class
        bObjectId - "b" endpoint object id
        name - COnnection name. Leave empty if you want to use the one in the template
        connectionClass - Class used to create the connection. See Constants class for supported values
        templateId - Id of the template for class connectionClass. Use -1 if you want to create a connection without template
        sessionId - Session token
        Returns:
        The new connection id
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object's class can't be found If the parent id is not found If the update can't be performed due to a format issue If any of the attribute values has an invalid value or format. If the specified template could not be found. If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found
      • createPhysicalConnections

        String[] createPhysicalConnections​(String[] aObjectClasses,
                                           String[] aObjectIds,
                                           String[] bObjectClasses,
                                           String[] bObjectIds,
                                           String name,
                                           String connectionClass,
                                           String templateId,
                                           String sessionId)
                                    throws ServerSideException
        Creates a physical connection (a container or a link). The validations are made at server side (this is, if the connection can be established between the two endpoints, if they're not already connected, etc)
        Parameters:
        aObjectClasses - "a" endpoints object class
        aObjectIds - "a" endpoints object id
        bObjectClasses - "b" endpoints object class
        bObjectIds - "b" endpoints object id
        name - COnnection name. Leave empty if you want to use the one in the template
        connectionClass - Class used to create the connection. See Constants class for supported values
        templateId - Id of the template for class connectionClass. Use -1 if you want to create a connection without template
        sessionId - Session token
        Returns:
        The new connection id
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object's class can't be found If the parent id is not found If the update can't be performed due to a format issue If any of the attribute values has an invalid value or format. If the specified template could not be found. If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found
      • getPhysicalConnectionEndpoints

        RemoteObjectLight[] getPhysicalConnectionEndpoints​(String connectionClass,
                                                           String connectionId,
                                                           String sessionId)
                                                    throws ServerSideException
        Returns the endpoints of a physical connection
        Parameters:
        connectionClass - Connection class
        connectionId - Connection id
        sessionId - Session token
        Returns:
        An array of two positions: the first is the A endpoint and the second is the B endpoint
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If either the object class or the attribute can not be found
      • getLogicalLinkDetails

        @Deprecated
        RemoteLogicalConnectionDetails getLogicalLinkDetails​(String linkClass,
                                                             String linkId,
                                                             String sessionId)
                                                      throws ServerSideException
        Deprecated.
        Returns the structure of a logical connection. The current implementation is quite simple and the return object simply provides the endpoints and the next ports connected to such endpoints using a physical connection
        Parameters:
        linkClass - The class of the connection to be evaluated
        linkId - The id of the connection to be evaluated
        sessionId - Session token
        Returns:
        An object with the details of the connection and the physical resources associated to it
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the provided connection could not be found
      • validateSavedE2EView

        RemoteViewObject validateSavedE2EView​(List<String> linkClasses,
                                              List<String> linkIds,
                                              RemoteViewObject savedView,
                                              String sessionId)
                                       throws ServerSideException
        Validates a saved structure of a end to end view. The current implementation provides the endpoints and the next ports connected to such endpoints using a physical connection also adds continuity if a VLAN or a BridgeDomain is found
        Parameters:
        linkClasses - The class of the connection to be evaluated
        linkIds - The id of the connection to be evaluated
        savedView - a given saved view to validate
        sessionId - Session token
        Returns:
        An object with the details of the connection and the physical resources associated to it
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the provided connection could not be found
      • getE2View

        RemoteViewObject getE2View​(List<String> linkClasses,
                                   List<String> linkIds,
                                   boolean includeVLANs,
                                   boolean includeBDIs,
                                   String sessionId)
                            throws ServerSideException
        Returns the structure of a logical connection. The current implementation is quite simple and the return object simply provides the endpoints and the next ports connected to such endpoints using a physical connection
        Parameters:
        linkClasses - The class of the connection to be evaluated
        linkIds - The id of the connection to be evaluated
        includeVLANs - true to include the bridge domains continuity
        includeBDIs - true to include the bridge domains continuity
        sessionId - Session token
        Returns:
        An object with the details of the connection and the physical resources associated to it
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the provided connection could not be found
      • getContainersBetweenObjects

        List<RemoteObjectLight> getContainersBetweenObjects​(String objectAClass,
                                                            String objectAId,
                                                            String objectBClass,
                                                            String objectBId,
                                                            String containerClass,
                                                            String sessionId)
                                                     throws ServerSideException
        Retrieves the existing containers between two given nodes.
        Parameters:
        objectAClass - The class of the object A.
        objectAId - The id of the object A.
        objectBClass - The class of the object B. (end point B class)
        objectBId - The id of the object B (end point B id).
        containerClass - The class of the containers to be return.
        sessionId - Session token
        Returns:
        A list with the common wire containers between the two objects
        Throws:
        ServerSideException - if an objects doesn't exist or if a given class doesn't exist
      • getPhysicalConnectionsInObject

        List<RemoteObjectLightList> getPhysicalConnectionsInObject​(String objectClass,
                                                                   String objectId,
                                                                   String sessionId)
                                                            throws ServerSideException
        Loops through all instances of GenericCommunicationsPort at any level inside the given object and gets the physical path. Only the ports with connections (physicalPath.size > 1) are returned
        Parameters:
        objectClass - The class of the object.
        objectId - The id of the object.
        sessionId - Session token
        Returns:
        A list of physical paths from all the ports with connections inside the given object. See getPhysicalPath for details about the structure of each entry
        Throws:
        ServerSideException - In the same cases as getChildrenOfClassLightRecursive and getPhysicalPath
      • getPhysicalPath

        List<RemoteObjectLight> getPhysicalPath​(String objectClass,
                                                String objectId,
                                                String sessionId)
                                         throws ServerSideException
        Gets the physical trace of connections and ports from a given port.
        Parameters:
        objectClass - Object class
        objectId - Object id
        sessionId - Session token
        Returns:
        An array containing the sorted elements in the physical path of the given port. The first element is the port from which the trace is generated, while the last is the destination port until which there is physical continuity. If the source port does not have any connection, the physical path will have only one element (that port).
        Throws:
        ServerSideException - If the user is not allowed to invoke the method
      • getPhysicalTree

        RemoteObjectRelatedObjects getPhysicalTree​(String objectClass,
                                                   String objectId,
                                                   String sessionId)
                                            throws ServerSideException
        Gets the tree representation of all physical paths.
        Parameters:
        objectClass - Port object class
        objectId - Port object id
        sessionId - Session token
        Returns:
        A tree representation of all physical paths.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the objects involved in the path cannot be found If any of the object classes involved in the path cannot be found If any of the objects involved in the path has a malformed list type attribute If any of the objects involved in the path has an invalid objectId or className
      • connectPhysicalLinks

        void connectPhysicalLinks​(String[] sideAClassNames,
                                  String[] sideAIds,
                                  String[] linksClassNames,
                                  String[] linksIds,
                                  String[] sideBClassNames,
                                  String[] sideBIds,
                                  String sessionId)
                           throws ServerSideException
        Connects pairs of ports (if they are not connected already) using physical link
        Parameters:
        sideAClassNames - The list of classes of one of the sides of the connection
        sideAIds - The list of ids the objects on one side of the connection
        linksClassNames - the classes of the links that will connect the two sides
        linksIds - The ids of these links
        sideBClassNames - The list of classes of the other side of the connection
        sideBIds - The list of ids the objects on the other side of the connection
        sessionId - Session token
        Throws:
        ServerSideException - If the object can not be found If either the object class or the attribute can not be found If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found If the object activity log could no be found
      • connectPhysicalContainers

        void connectPhysicalContainers​(String[] sideAClassNames,
                                       String[] sideAIds,
                                       String[] containersClassNames,
                                       String[] containersIds,
                                       String[] sideBClassNames,
                                       String[] sideBIds,
                                       String sessionId)
                                throws ServerSideException
        Connects pairs of elements (of any class except subclasses of GenericPort) using containers (subclasses of GenericPhysicalContainer)
        Parameters:
        sideAClassNames - The list of classes of one of the sides of the connection
        sideAIds - The list of ids the objects on one side of the connection
        containersClassNames - the classes of the containers that will connect the two sides
        containersIds - The ids of these containers
        sideBClassNames - The list of classes of the other side of the connection
        sideBIds - The list of ids the objects on the other side of the connection
        sessionId - Session token
        Throws:
        ServerSideException - If any of the provided objects can not be found, if the endpoints are already connected, or if one of the endpoints is a port
      • disconnectPhysicalConnection

        void disconnectPhysicalConnection​(String connectionClass,
                                          String connectionId,
                                          int sideToDisconnect,
                                          String sessionId)
                                   throws ServerSideException
        Disconnects a side or both sides of a physical connection (a link or a container)
        Parameters:
        connectionClass - Class of the connection to be edited
        connectionId - Id of the connection to be edited
        sideToDisconnect - Side to disconnect. Use 1 to disconnect only the side a, 2 to disconnect only side b and 3 to disconnect both sides at once
        sessionId - Session token
        Throws:
        ServerSideException - If the object can not be found If either the object class or the attribute can not be found If the class provided does not exist If any of the relationships is now allowed according to the defined data model If the object activity log could no be found
      • reconnectPhysicalConnection

        void reconnectPhysicalConnection​(String connectionClass,
                                         String connectionId,
                                         String newASideClass,
                                         String newASideId,
                                         String newBSideClass,
                                         String newBSideId,
                                         String sessionId)
                                  throws ServerSideException
        Changes one or both sides (endpoints) of a physical connection (link or container). Use this method carefully in containers, as it does not check if the endpoints of the links inside the container that was reconnected are consistent with its new endpoints. Also note that when used in physical links, the link will NOT be moved (as in the special containment hierarchy) to the nearest common parent of both endpoints. This method can not be used to disconnect connections, to do that use #disconnectPhysicalConnection(java.lang.String, long, int, java.lang.String).
        Parameters:
        connectionClass - The class of the connection to be modified
        connectionId - The id of the connection to be modified
        newASideClass - The class of the new side A of the connection. Use null if this side is not to be changed.
        newASideId - The id of the new side A of the connection. Use -1 if this side is not to be changed.
        newBSideClass - The class of the new side B of the connection. Use null if this side is not to be changed.
        newBSideId - The id of the new side B of the connection. Use -1 if this side is not to be changed.
        sessionId - The session token
        Throws:
        ServerSideException - If any of the objects provided could not be found or if the new endpoint is not a port (if reconnecting a link) or if it is a port (if reconnecting a container)
      • deletePhysicalConnection

        void deletePhysicalConnection​(String objectClass,
                                      String objectId,
                                      String sessionId)
                               throws ServerSideException
        Deletes a physical connection
        Parameters:
        objectClass - Object class
        objectId - Object id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object couldn't be found If the class could not be found If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships. If the log root node could not be found
      • getBusinessObjectAuditTrail

        ApplicationLogEntry[] getBusinessObjectAuditTrail​(String objectClass,
                                                          String objectId,
                                                          int limit,
                                                          String sessionId)
                                                   throws ServerSideException
        Retrieves the log entries for a given [business] object
        Parameters:
        objectClass - Object class
        objectId - Object id
        limit - Max number of results (0 to retrieve all)
        sessionId - Session token
        Returns:
        The object's audit trail
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the class provided is not subclass of InventoryObject
      • getGeneralActivityAuditTrail

        ApplicationLogEntry[] getGeneralActivityAuditTrail​(int page,
                                                           int limit,
                                                           String sessionId)
                                                    throws ServerSideException
        Retrieves the list of activity log entries
        Parameters:
        page - current page
        limit - limit of results per page. 0 to retrieve them all
        sessionId - The session id
        Returns:
        The list of activity log entries
        Throws:
        ServerSideException - If the user is not allowed to invoke the method, If anything goes wrong
      • attachFileToObject

        long attachFileToObject​(String name,
                                String tags,
                                byte[] file,
                                String className,
                                String objectId,
                                String sessionId)
                         throws ServerSideException
        Attaches a file to an inventory object
        Parameters:
        name - The name of the file. It's more like its title, instead of the file name
        tags - A semicolon (";") separated string with the tags associated to this document. These tags can be used to help find documents in a search
        file - The actual file
        className - The class name of the inventory object the file will be attached to
        objectId - The id of the inventory object the file will be attached to
        sessionId - Session token
        Returns:
        The id of the file object that was created
        Throws:
        ServerSideException - If the file can not be saved or if there's already a file with that name related to the object or if the file exceeds the max size configured
      • detachFileFromObject

        void detachFileFromObject​(long fileObjectId,
                                  String className,
                                  String objectId,
                                  String sessionId)
                           throws ServerSideException
        Detaches a file from an inventory object. Note that the file will also be deleted.
        Parameters:
        fileObjectId - The id of the file object
        className - The class of the object the file will be detached from
        objectId - The id of the object the file will be detached from
        sessionId - The session token
        Throws:
        ServerSideException - If the object or its class could not be found, or if the file object could not be found or if there was a problem physically deleting the file from disk
      • getFilesForObject

        List<RemoteFileObjectLight> getFilesForObject​(String className,
                                                      String objectId,
                                                      String sessionId)
                                               throws ServerSideException
        Retrieves the files associated to a given inventory object
        Parameters:
        className - The class of the object o retrieve the files from
        objectId - The id of the object o retrieve the files from
        sessionId - The session token
        Returns:
        A list of light file objects
        Throws:
        ServerSideException - If the object or its class could not be found
      • getFile

        RemoteFileObject getFile​(long fileObjectId,
                                 String className,
                                 String objectId,
                                 String sessionId)
                          throws ServerSideException
        Retrieves a particular file from those attached to an inventory object. The returned object contains the contents of the file
        Parameters:
        fileObjectId - The id of the file object
        className - The class of the object the file will be detached from
        objectId - The id of the object the file will be detached from
        sessionId - The session token
        Returns:
        The object file encapsulating the contents of the file.
        Throws:
        ServerSideException - If the object or its class could not be found, or if the file object could not be found or if there was a problem physically deleting the file from disk
      • updateFileProperties

        void updateFileProperties​(long fileObjectId,
                                  List<StringPair> properties,
                                  String className,
                                  String objectId,
                                  String sessionId)
                           throws ServerSideException
        Updates the properties of a file object (name or tags)
        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
        sessionId - The session token
        Throws:
        ServerSideException - If the object file is attached to could not be found or if the file object could not be found or if any of the properties has an invalid name or if the file name is empty or if the class of the object file is attached to could not be found
      • createClass

        long createClass​(String className,
                         String displayName,
                         String description,
                         boolean isAbstract,
                         boolean isCustom,
                         boolean isCountable,
                         boolean isInDesign,
                         String parentClassName,
                         byte[] icon,
                         byte[] smallIcon,
                         int color,
                         String sessionId)
                  throws ServerSideException
        Creates a class metadata object. This method is still under testing and might be buggy
        Parameters:
        className - Class name
        displayName - Class display name
        description - Class description
        isAbstract - is this class abstract?
        isCustom - Is this class part of the core of the application (can not be deleted) or if it's an extension to the default data model. In most cases, this should be "true".
        parentClassName - Parent class name
        isCountable - NOt used so far. It's intended to be used to mark the classes that are created to make consistent the model, but that are not actual inventory elements, such as Slots
        icon - Icon for views. The size is limited by the value in Constants.MAX_ICON_SIZE and it's typically 32x32 pixels
        isInDesign - Says if a class can be instantiated or not. This is useful if you are creating many classes and want to avoid the users to create objects from those classes until you have finished the data model roll-out.
        smallIcon - Icon for trees. The size is limited by the value in Constants.MAX_ICON_SIZE
        sessionId - Session token
        color - The color to be used to display the instances of this class (depends on the client used)
        Returns:
        the id of the new class metadata object
        Throws:
        ServerSideException - If the specified parent class doesn't exist If the reference node doesn't exist If any of the fields of the class definition has an invalid value
      • setClassProperties

        void setClassProperties​(long classId,
                                String className,
                                String displayName,
                                String description,
                                byte[] smallIcon,
                                byte[] icon,
                                int color,
                                Boolean isAbstract,
                                Boolean isInDesign,
                                Boolean isCustom,
                                Boolean isCountable,
                                String sessionId)
                         throws ServerSideException
        Updates a class metadata properties. Use null values for those properties that shouldn't be touched
        Parameters:
        classId -
        className - metadata name. Null if unchanged
        displayName - New class metadata display name. Null if unchanged
        description - New class metadata description. Null if unchanged
        isAbstract - is this class abstract?
        icon - New icon for views. Null if unchanged. The size is limited by the value in Constants.MAX_ICON_SIZE
        color - The color of the instances of this class.
        smallIcon - New icon for trees. Null if unchanged. The size is limited by the value in Constants.MAX_ICON_SIZE
        isInDesign - If the class is in design stage (see createClass).
        isCustom - If the class is custom (see createClass).
        isCountable - If the class is countable (see createClass).
        sessionId - Session token
        Throws:
        ServerSideException - If there is any problem retrieving an object, while checking if every created object of the class with an attributes marked as mandatory has value.
      • hasAttribute

        boolean hasAttribute​(String className,
                             String attributeName,
                             String sessionId)
                      throws ServerSideException
        Checks if a class has a attribute with a given name
        Parameters:
        className - Class name
        attributeName - Attribute name
        sessionId - Session token
        Returns:
        True if the given class has the attribute
        Throws:
        ServerSideException - If there is no a class with such className
      • getAttribute

        RemoteAttributeMetadata getAttribute​(String className,
                                             String attributeName,
                                             String sessionId)
                                      throws ServerSideException
        Gets a class attribute, using the class name as key to find it
        Parameters:
        className - the class name
        attributeName -
        sessionId - Session token
        Returns:
        the class attribute
        Throws:
        ServerSideException - If there is no a class with such className If the attributeName does not exist
      • getAttributeForClassWithId

        RemoteAttributeMetadata getAttributeForClassWithId​(String classId,
                                                           String attributeName,
                                                           String sessionId)
                                                    throws ServerSideException
        Gets a class attribute, using the class id as key to find it
        Parameters:
        classId - Class id
        attributeName - Attribute name
        sessionId - Session token
        Returns:
        The attribute definition
        Throws:
        ServerSideException - If there is no a class with such classId If the attributeName does not exist
      • createAttribute

        void createAttribute​(String className,
                             String name,
                             String displayName,
                             String type,
                             String description,
                             boolean administrative,
                             boolean visible,
                             boolean isReadOnly,
                             boolean noCopy,
                             boolean unique,
                             boolean mandatory,
                             boolean multiple,
                             int order,
                             String sessionId)
                      throws ServerSideException
        Adds an attribute to a class using its name as key to find it. If value of a given attribute is null, a default value will be set (except for the name, which is mandatory)
        Parameters:
        className - Class name where the attribute will be attached
        name - attribute name
        displayName - attribute display name
        type - attribute type
        description - attribute description
        administrative - is the attribute administrative?
        visible - is the attribute visible?
        noCopy - Marks an attribute as not to be copied during a copy operation.
        isReadOnly - is the attribute read only?
        unique - should this attribute be unique?
        mandatory - is the attribute mandatory when an object is created
        multiple - Indicates if the attribute is a multiple selection list type. This flag has no effect in primitive types, such as strings or numbers
        order - Tells the system how to sort the attributes. A call to any method that returns the attributes of a class will return them sorted by order. This is useful to show the attributes in property sheets in order of importance, for example. The default value is 1000
        sessionId - session token
        Throws:
        ServerSideException - If there is no a class with such className If any of the parameters to create the attribute has a wrong value
      • createAttributeForClassWithId

        void createAttributeForClassWithId​(long ClassId,
                                           String name,
                                           String displayName,
                                           String type,
                                           String description,
                                           boolean administrative,
                                           boolean visible,
                                           boolean readOnly,
                                           boolean noCopy,
                                           boolean unique,
                                           boolean mandatory,
                                           boolean multiple,
                                           int order,
                                           String sessionId)
                                    throws ServerSideException
        Adds an attribute to a class using its id as key to find it. If value of a given attribute is null, a default value will be put in place (except for the name, which is mandatory)
        Parameters:
        ClassId - Class id where the attribute will be attached
        name - attribute name
        displayName - attribute display name
        type - attribute type
        description - attribute description
        administrative - is the attribute administrative?
        visible - is the attribute visible?
        readOnly - is the attribute read only?
        noCopy - Marks an attribute as not to be copied during a copy operation.
        unique - should this attribute be unique?
        mandatory - is the attribute mandatory when an object is created
        multiple - Indicates if the attribute is a multiple selection list type. This flag has no effect in primitive types, such as strings or numbers
        order - Tells the system how to sort the attributes. A call to any method that returns the attributes of a class will return them sorted by order. This is useful to show the attributes in property sheets in order of importance, for example. The default value is 1000
        sessionId - session token
        Throws:
        ServerSideException - If any of the parameters to create the attribute has a wrong value
      • setAttributeProperties

        void setAttributeProperties​(String className,
                                    long attributeId,
                                    String name,
                                    String displayName,
                                    String description,
                                    String type,
                                    Boolean administrative,
                                    Boolean mandatory,
                                    Boolean multiple,
                                    Boolean noCopy,
                                    Boolean readOnly,
                                    Boolean unique,
                                    Boolean visible,
                                    Integer order,
                                    String sessionId)
                             throws ServerSideException
        Updates a class attribute taking its name as key to find it. If value of a given attribute is null, the old value will remain unchanged.
        Parameters:
        className - Class the attribute belongs to
        attributeId - attribute id
        name - attribute name
        displayName - attribute display name
        type - attribute type
        description - attribute description
        administrative - is the attribute administrative?
        visible - is the attribute visible?
        readOnly - is the attribute read only?
        unique - should this attribute be unique?
        mandatory - is the attribute mandatory when an object is created
        multiple - Indicates if the attribute is a multiple selection list type. This flag has no effect in primitive types, such as strings or numbers
        noCopy - can this attribute be copy in copy/paste operation?
        order - Tells the system how to sort the attributes. A call to any method that returns the attributes of a class will return them sorted by order. This is useful to show the attributes in property sheets in order of importance, for example. The default value is 1000
        sessionId - session token
        Throws:
        ServerSideException - If an object can't be find, while it is checking if every object of the class (or subclasses) has a value in an attribute marked as mandatory
      • setAttributePropertiesForClassWithId

        void setAttributePropertiesForClassWithId​(long classId,
                                                  long attributeId,
                                                  String name,
                                                  String displayName,
                                                  String description,
                                                  String type,
                                                  Boolean administrative,
                                                  Boolean mandatory,
                                                  Boolean multiple,
                                                  Boolean noCopy,
                                                  Boolean readOnly,
                                                  Boolean unique,
                                                  Boolean visible,
                                                  Integer order,
                                                  String sessionId)
                                           throws ServerSideException
        Updates a class attribute taking its id as key to find it. If value of a given attribute is null, the old value will remain unchanged.
        Parameters:
        classId - Class the attribute belongs to
        attributeId - attribute id
        name - attribute name
        displayName - attribute display name
        type - attribute type
        description - attribute description
        administrative - is the attribute administrative?
        visible - is the attribute visible?
        readOnly - is the attribute read only?
        unique - should this attribute be unique?
        mandatory - is the attribute mandatory when an object is created
        multiple - Indicates if the attribute is a multiple selection list type. This flag has no effect in primitive types, such as strings or numbers
        noCopy - can this attribute be copy in copy/paste operation?
        order - Tells the system how to sort the attributes. A call to any method that returns the attributes of a class will return them sorted by order. This is useful to show the attributes in property sheets in order of importance, for example. The default value is 1000
        sessionId - session token
        Throws:
        ServerSideException - If an object can't be find, while it is checking if every object of the class (or subclasses) has a value in an attribute marked as mandatory
      • deleteAttribute

        void deleteAttribute​(String className,
                             String attributeName,
                             String sessionId)
                      throws ServerSideException
        Deletes an attribute from a class using the class name as key to find it
        Parameters:
        className - Class name
        attributeName - Attribute name
        sessionId - Session token
        Throws:
        ServerSideException - If the class could not be found. If the attributes name or creationDate are to be deleted.
      • deleteAttributeForClassWithId

        void deleteAttributeForClassWithId​(long classId,
                                           String attributeName,
                                           String sessionId)
                                    throws ServerSideException
        Deletes an attribute from a class using the class id as key to find it
        Parameters:
        classId - Class id
        attributeName - Attribute name
        sessionId - Session token
        Throws:
        ServerSideException - If the class could not be found. If the attributes name or creationDate are to be deleted.
      • getClass

        RemoteClassMetadata getClass​(String className,
                                     String sessionId)
                              throws ServerSideException
        Gets the metadata of a given class using its name as key to find it
        Parameters:
        className - Class name
        sessionId - Session token
        Returns:
        The metadata as a ClassInfo instance
        Throws:
        ServerSideException - If there is no class with such className
      • getClassWithId

        RemoteClassMetadata getClassWithId​(long classId,
                                           String sessionId)
                                    throws ServerSideException
        Gets the metadata of a given class using its id as key to find it
        Parameters:
        classId - Class metadata object id
        sessionId - session token
        Returns:
        The metadata as a ClassInfo instance
        Throws:
        ServerSideException - If there is no class with such classId
      • getSubClassesLight

        List<RemoteClassMetadataLight> getSubClassesLight​(String className,
                                                          boolean includeAbstractClasses,
                                                          boolean includeSelf,
                                                          String sessionId)
                                                   throws ServerSideException
        Gets the subclasses of a given class
        Parameters:
        className - Class name
        includeAbstractClasses - should the result include the abstract classes?
        includeSelf - Should the list include the subclasses and the parent class?
        sessionId - Session token
        Returns:
        The list of subclasses
        Throws:
        ServerSideException - If the provided class is not a subclass of InventoryObject
      • getSubClassesLightNoRecursive

        List<RemoteClassMetadataLight> getSubClassesLightNoRecursive​(String className,
                                                                     boolean includeAbstractClasses,
                                                                     boolean includeSelf,
                                                                     String sessionId)
                                                              throws ServerSideException
        Gets the subclasses of a given class
        Parameters:
        className - Class name
        includeAbstractClasses - should the result include the abstract classes?
        includeSelf - Should the list include the subclasses and the parent class?
        sessionId - Session token
        Returns:
        The list of subclasses
        Throws:
        ServerSideException - Exception If the class could not be found.
      • getAllClasses

        List<RemoteClassMetadata> getAllClasses​(boolean includeListTypes,
                                                String sessionId)
                                         throws ServerSideException
        Retrieves the metadata for the entire class hierarchy as ClassInfo instances
        Parameters:
        sessionId - Session token
        includeListTypes - boolean to indicate if the list should include the subclasses of GenericObjectList
        Returns:
        An array with the metadata for the entire class hierarchy as ClassInfo instances
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getAllClassesLight

        List<RemoteClassMetadataLight> getAllClassesLight​(boolean includeListTypes,
                                                          String sessionId)
                                                   throws ServerSideException
        Retrieves the metadata for the entire class hierarchy as ClassInfoLight instances
        Parameters:
        sessionId - Session token
        includeListTypes - boolean to indicate if the list should include the subclasses of GenericObjectList
        Returns:
        An array with the metadata for the entire class hierarchy as ClassInfoLight instances
        Throws:
        ServerSideException - If GenericListType class does not exist.
      • deleteClass

        void deleteClass​(String className,
                         String sessionId)
                  throws ServerSideException
        Deletes a class from the data model using its name as key to find it
        Parameters:
        className - Class name
        sessionId - Session token
        Throws:
        ServerSideException - If there is not a class with de ClassName If the class is a core class, has instances, has incoming relationships or is a list type that is used by another class.
      • deleteClassWithId

        void deleteClassWithId​(long classId,
                               String sessionId)
                        throws ServerSideException
        Deletes a class from the data model using its id as key to find it
        Parameters:
        classId - Class id
        sessionId - Session token
        Throws:
        ServerSideException - If the class is a core class, has instances, has incoming relationships or is a list type that is used by another class.
      • getPossibleChildren

        List<RemoteClassMetadataLight> getPossibleChildren​(String parentClassName,
                                                           String sessionId)
                                                    throws ServerSideException
        Gets the possible children of a class according to the containment hierarchy. This method is recursive, and if a possible child is an abstract class, it gets its non-abstract subclasses
        Parameters:
        parentClassName - Class to retrieve its possible children
        sessionId - Session token
        Returns:
        A list of possible children as ClassInfoLight instances An array with the metadata for the entire class hierarchy as ClassInfoLight instances
        Throws:
        ServerSideException - If the class can not be found
      • getPossibleSpecialChildren

        List<RemoteClassMetadataLight> getPossibleSpecialChildren​(String parentClassName,
                                                                  String sessionId)
                                                           throws ServerSideException
        Gets the possible special children of a class according to the containment hierarchy. This method is recursive, and if a possible special child is an abstract class, it gets its non-abstract subclasses
        Parameters:
        parentClassName - Class to retrieve its possible special children
        sessionId - Session token
        Returns:
        A list of possible special children as ClassInfoLight instances
        Throws:
        ServerSideException - If the class can not be found
      • getPossibleChildrenNoRecursive

        List<RemoteClassMetadataLight> getPossibleChildrenNoRecursive​(String parentClassName,
                                                                      String sessionId)
                                                               throws ServerSideException
        Gets the possible children of a class according to the containment hierarchy. This method is not recursive, and only returns the direct possible children, even if they're abstract
        Parameters:
        parentClassName - Class to retrieve its possible children
        sessionId - Session token
        Returns:
        An array with the metadata for the entire class hierarchy as ClassInfoLight instances
        Throws:
        ServerSideException - If the class could not be found
      • getPossibleSpecialChildrenNoRecursive

        List<RemoteClassMetadataLight> getPossibleSpecialChildrenNoRecursive​(String parentClassName,
                                                                             String sessionId)
                                                                      throws ServerSideException
        Gets the possible special children of a class according to the containment hierarchy. This method is not recursive, and only returns the direct possible special children, even if they're abstract
        Parameters:
        parentClassName - Class to retrieve its possible special children
        sessionId - Session token
        Returns:
        A List with the metadata for the entire class hierarchy as ClassInfoLight instances
        Throws:
        ServerSideException - If the class could not be found
      • addPossibleChildrenForClassWithId

        void addPossibleChildrenForClassWithId​(long parentClassId,
                                               long[] newPossibleChildren,
                                               String sessionId)
                                        throws ServerSideException
        Adds possible children to a given class using its id as argument. If any of the arguments provided are already added, it will abort the operation and rise an exception
        Parameters:
        parentClassId - Class to attach the new possible children
        newPossibleChildren - List of new possible children. Abstract classes are de-aggregated
        sessionId - Session token
        Throws:
        ServerSideException - If any of the possible children or the parent doesn't exist If any of the possible children classes already are possible children.
      • addPossibleSpecialChildrenWithId

        void addPossibleSpecialChildrenWithId​(long parentClassId,
                                              long[] possibleSpecialChildren,
                                              String sessionId)
                                       throws ServerSideException
        Adds possible special children to a given class using its id as argument. If any of the arguments provided are already added, it will abort the operation and rise an exception
        Parameters:
        parentClassId - Class to attach the new possible special children
        possibleSpecialChildren - List of new possible children. Abstract classes are de-aggregated
        sessionId - Session token
        Throws:
        ServerSideException - If any of the possible children or the parent doesn't exist If any of the possible children classes already are possible special children.
      • addPossibleChildren

        void addPossibleChildren​(String parentClassName,
                                 String[] childrenToBeAdded,
                                 String sessionId)
                          throws ServerSideException
        Adds possible children to a given class using its name as argument. If any of the arguments provided are already added, it will abort the operation and rise an exception
        Parameters:
        parentClassName - Class to attach the new possible children
        childrenToBeAdded - List of new possible children. Abstract classes are de-aggregated
        sessionId - Session token
        Throws:
        ServerSideException - If the parent class or any of the possible children can not be found If any of the given possible children can not be a possible children of parentClassName
      • addPossibleSpecialChildren

        void addPossibleSpecialChildren​(String parentClassName,
                                        String[] possibleSpecialChildren,
                                        String sessionId)
                                 throws ServerSideException
        Adds special possible children to a given class using its name. If any of the arguments provided are already added, it will abort the operation and rise an exception
        Parameters:
        parentClassName - Class to attach the new possible special children
        possibleSpecialChildren - List of new possible special children. Abstract classes are de-aggregated
        sessionId - Session token
        Throws:
        ServerSideException - If the parent class or any of the possible children can not be found If any of the given possible children can not be a possible children of parentClassName
      • removePossibleChildrenForClassWithId

        void removePossibleChildrenForClassWithId​(long parentClassId,
                                                  long[] childrenToBeRemoved,
                                                  String sessionId)
                                           throws ServerSideException
        Removes a set of possible children for a given class
        Parameters:
        parentClassId - Class the possible children are going to be removed from
        childrenToBeRemoved - List of ids of classes to be removed as possible children
        sessionId - Session token
        Throws:
        ServerSideException - If any of the ids provided can't be found
      • removePossibleSpecialChildren

        void removePossibleSpecialChildren​(long parentClassId,
                                           long[] specialChildrenToBeRemoved,
                                           String sessionId)
                                    throws ServerSideException
        Removes a set of possible special children for a given class.
        Parameters:
        parentClassId - Parent Class of the possible special children are going to be removed from
        specialChildrenToBeRemoved - List of ids of classes to be remove as possible special children
        sessionId - Session token
        Throws:
        ServerSideException - If any of the ids provided can't be found
      • getUpstreamContainmentHierarchy

        List<RemoteClassMetadataLight> getUpstreamContainmentHierarchy​(String className,
                                                                       boolean recursive,
                                                                       String sessionId)
                                                                throws ServerSideException
        Gets the containment hierarchy of a given class, but upwards (i.e. for Building, it could return City, Country, Continent)
        Parameters:
        className - Class to be evaluated
        recursive - do it recursively or not
        sessionId -
        Returns:
        List of classes in the upstream containment hierarchy
        Throws:
        ServerSideException - If className does not correspond to any existing class
      • getUpstreamSpecialContainmentHierarchy

        List<RemoteClassMetadataLight> getUpstreamSpecialContainmentHierarchy​(String className,
                                                                              boolean recursive,
                                                                              String sessionId)
                                                                       throws ServerSideException
        Gets the special containment hierarchy of a given class, but upwards (i.e. for Building, it could return City, Country, Continent)
        Parameters:
        className - Class to be evaluated
        recursive - Do it recursively or not
        sessionId - Session id token
        Returns:
        List of classes in upstream special containment hierarchy
        Throws:
        ServerSideException - If className does not correspond to any existing class
      • getUpstreamClassHierarchy

        List<RemoteClassMetadataLight> getUpstreamClassHierarchy​(String className,
                                                                 boolean includeSelf,
                                                                 String sessionId)
                                                          throws ServerSideException
        Gets the parent classes of a given class up to RootObject.
        Parameters:
        className - The class to get the superclasses from
        includeSelf - If the result should also include the class in className
        sessionId - The session token
        Returns:
        The list of super classes until the root of the hierarchy
        Throws:
        ServerSideException - If the class provided could not be found
      • isSubClassOf

        boolean isSubClassOf​(String className,
                             String allegedParentClass,
                             String sessionId)
                      throws ServerSideException
        Tests if a class is subclass of another.
        Parameters:
        className - Class to be tested.
        allegedParentClass - Class to be tested against.
        sessionId - Session token.
        Returns:
        If the tested class is subclass of allegedParentClass or not.
        Throws:
        ServerSideException - In case something goes wrong.
      • bulkUpload

        String bulkUpload​(byte[] file,
                          int commitSize,
                          int dataType,
                          String sessionId)
                   throws ServerSideException
        Creates many objects at once given a well formatted file. See user manual for details on how to format the file
        Parameters:
        file - The file with size no greater
        commitSize - The records are not committed one by one, but in batch. This number tells Kuwaiba how many records (lines) to commit at once.
        dataType - What kind of data contains the file, listTypes, inventory objects, etc
        sessionId - Session token.
        Returns:
        The result of the operation.
        Throws:
        ServerSideException - If something goes wrong.
      • downloadBulkLoadLog

        byte[] downloadBulkLoadLog​(String fileName,
                                   String sessionId)
                            throws ServerSideException
        Retrieves the log file product of a bulk load operation.
        Parameters:
        fileName - The name of the file (provided by the method that performs the bulk creation)
        sessionId - Session token
        Returns:
        The contents of the file.
        Throws:
        ServerSideException - If something goes wrong.
      • createTemplate

        String createTemplate​(String templateClass,
                              String templateName,
                              String sessionId)
                       throws ServerSideException
        Creates a template.
        Parameters:
        templateClass - The class you want to create a template for.
        templateName - The name of the template.
        sessionId - Session token.
        Returns:
        The id of the newly created template.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the provided class does not exist If the template class is abstract.
      • createTemplateElement

        String createTemplateElement​(String templateElementClass,
                                     String templateElementParentClassName,
                                     String templateElementParentId,
                                     String templateElementName,
                                     String sessionId)
                              throws ServerSideException
        Creates an object inside a template.
        Parameters:
        templateElementClass - Class of the object you want to create.
        templateElementParentClassName - Class of the parent to the object you want to create.
        templateElementParentId - Id of the parent to the object you want to create.
        templateElementName - Name of the element.
        sessionId - Session token.
        Returns:
        The id of the new object.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object (or its parent) class could not be found If the parent object could not be found If the class provided to create the new element from is abstract.
      • createTemplateSpecialElement

        String createTemplateSpecialElement​(String tsElementClass,
                                            String tsElementParentClassName,
                                            String tsElementParentId,
                                            String tsElementName,
                                            String sessionId)
                                     throws ServerSideException
        Creates an special object inside a template.
        Parameters:
        tsElementClass - Class of the special object you want to create.
        tsElementParentClassName - Class of the parent to the special object you want to create.
        tsElementParentId - Id of the parent to the special object you want to create.
        tsElementName - Name of the element.
        sessionId - Session token.
        Returns:
        The id of the new object.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the element class are not a possible special child of the element parent class If the element class given are abstract If the element class or element parent class can not be found If the element parent can no be found
      • createBulkTemplateElement

        String[] createBulkTemplateElement​(String templateElementClassName,
                                           String templateElementParentClassName,
                                           String templateElementParentId,
                                           String templateElementNamePattern,
                                           String sessionId)
                                    throws ServerSideException
        Creates multiple template elements using a given name pattern
        Parameters:
        templateElementClassName - The class name of the new set of template elements
        templateElementParentClassName - The parent class name of the new set of template elements
        templateElementParentId - The parent id of the new set of template elements
        templateElementNamePattern - Name pattern of the new set of template elements
        sessionId - Session id token
        Returns:
        An array of ids for the new template elements
        Throws:
        ServerSideException - If the parent class name or the template element class name cannot be found If the given template element class cannot be a child of the given parent If the parent class name cannot be found If the given pattern to generate the name has less possibilities that the number of template elements to be created
      • createBulkSpecialTemplateElement

        String[] createBulkSpecialTemplateElement​(String stElementClass,
                                                  String stElementParentClassName,
                                                  String stElementParentId,
                                                  String stElementNamePattern,
                                                  String sessionId)
                                           throws ServerSideException
        Creates multiple special template elements using a given name pattern
        Parameters:
        stElementClass - The class name of the new set of special template elements
        stElementParentClassName - The parent class name of the new set of special template elements
        stElementParentId - The parent id of the new set of special template elements
        stElementNamePattern - Name pattern of the new set of special template elements
        sessionId - Session id token
        Returns:
        An array if ids for the new special template elements
        Throws:
        ServerSideException - If the parent class name or the special template element class name cannot be found If the given special template element class cannot be a child of the given parent If the parent class name cannot be found If the given pattern to generate the name has less possibilities that the number of special template elements to be created
      • updateTemplateElement

        void updateTemplateElement​(String templateElementClass,
                                   String templateElementId,
                                   String[] attributeNames,
                                   String[] attributeValues,
                                   String sessionId)
                            throws ServerSideException
        Updates the value of an attribute of a template element.
        Parameters:
        templateElementClass - Class of the element you want to update.
        templateElementId - Id of the element you want to update.
        attributeNames - Names of the attributes that you want to be updated as an array of strings.
        attributeValues - The values of the attributes you want to update. For list types, it's the id of the related type
        sessionId - Session token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the classes provided as arguments do not exist If the template element could not be found If the arrays attributeNames and attributeValues have different sizes
      • deleteTemplateElement

        void deleteTemplateElement​(String templateElementClass,
                                   String templateElementId,
                                   String sessionId)
                            throws ServerSideException
        Deletes an element within a template or a template itself.
        Parameters:
        templateElementClass - The template element class.
        templateElementId - The template element id.
        sessionId - Session token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the element's class could not be found. If the element could not be found.
      • getTemplatesForClass

        List<RemoteObjectLight> getTemplatesForClass​(String className,
                                                     String sessionId)
                                              throws ServerSideException
        Gets the templates available for a given class
        Parameters:
        className - Class whose templates we need
        sessionId - Session token
        Returns:
        A list of templates (actually, the top element) as a list of RemoteOObjects
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the class provided could not be found.
      • copyTemplateElements

        String[] copyTemplateElements​(String[] sourceObjectsClassNames,
                                      String[] sourceObjectsIds,
                                      String newParentClassName,
                                      String newParentId,
                                      String sessionId)
                               throws ServerSideException
        Copy template elements within templates. Should not be used to copy entire templates.
        Parameters:
        sourceObjectsClassNames - Array with the class names of the elements to be copied.
        sourceObjectsIds - Array with the ids of the elements to be copied.
        newParentClassName - Class of the parent of the copied objects.
        newParentId - Id of the parent of the copied objects.
        sessionId - Session token.
        Returns:
        An array with the ids of the newly created elements in the same order they were provided.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If any of the classes could not be found. If any of the source template elements could not be found. If the arrays provided as arguments have different sizes.
      • copyTemplateSpecialElements

        String[] copyTemplateSpecialElements​(String[] sourceObjectsClassNames,
                                             String[] sourceObjectsIds,
                                             String newParentClassName,
                                             String newParentId,
                                             String sessionId)
                                      throws ServerSideException
        Copy template special elements within templates. Should not be used to copy entire templates.
        Parameters:
        sourceObjectsClassNames - Array with the class names of the special elements to be copied.
        sourceObjectsIds - Array with the ids of the special elements to be copied.
        newParentClassName - Class of the parent of the copied objects.
        newParentId - Id of the parent of the copied objects.
        sessionId - Session token.
        Returns:
        An array with the ids of the newly created special elements in the same order they were provided.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the arrays provided as arguments have different sizes. If any of the classes could not be found. If any of the source template elements could not be found.
      • getTemplateElementChildren

        List<RemoteObjectLight> getTemplateElementChildren​(String templateElementClass,
                                                           String templateElementId,
                                                           String sessionId)
                                                    throws ServerSideException
        Retrieves the children of a given template element.
        Parameters:
        templateElementClass - Template element class.
        templateElementId - Template element id.
        sessionId -
        Returns:
        The template element's children as a list of RemoteBusinessObjectLight instances.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method
      • getTemplateSpecialElementChildren

        List<RemoteObjectLight> getTemplateSpecialElementChildren​(String tsElementClass,
                                                                  String tsElementId,
                                                                  String sessionId)
                                                           throws ServerSideException
        Retrieves the children of a given template special element.
        Parameters:
        tsElementClass - Template special element class.
        tsElementId - Template special element id.
        sessionId -
        Returns:
        The template element's children as a list of RemoteBusinessObjectLight instances.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method
      • getTemplateElement

        RemoteObject getTemplateElement​(String templateElementClass,
                                        String templateElementId,
                                        String sessionId)
                                 throws ServerSideException
        Retrives all the information of a given template element.
        Parameters:
        templateElementClass - Template element class.
        templateElementId - Template element id.
        sessionId - session token
        Returns:
        The template element information
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the template class does not exist If the template element could not be found If an attribute value can't be mapped into value
      • createClassLevelReport

        long createClassLevelReport​(String className,
                                    String reportName,
                                    String reportDescription,
                                    String script,
                                    int outputType,
                                    boolean enabled,
                                    String sessionId)
                             throws ServerSideException
        Creates a class level report (a report that will be available for all instances of a given class -and its subclasses-)
        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 - Report description.
        script - Script text.
        outputType - What will be the default output of this report? See ClassLevelReportDescriptor for possible values
        enabled - If enabled, a report can be executed.
        sessionId - Session token
        Returns:
        The id of the newly created report.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the class provided could not be found.
      • createInventoryLevelReport

        long createInventoryLevelReport​(String reportName,
                                        String reportDescription,
                                        String script,
                                        int outputType,
                                        boolean enabled,
                                        List<StringPair> parameters,
                                        String sessionId)
                                 throws ServerSideException
        Creates an inventory level report (a report that is not tied to a particlar instance or class. In most cases, they also receive parameters)
        Parameters:
        reportName - Name of the report.
        reportDescription - Report 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 array). The list of the names parameters that this report will support. They will always be captured as strings, so it's up to the author of the report the sanitization and conversion of the inputs
        sessionId - Session token
        Returns:
        The id of the newly created report.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the dummy root could not be found, which is actually a severe problem.
      • deleteReport

        void deleteReport​(long reportId,
                          String sessionId)
                   throws ServerSideException
        Deletes a report
        Parameters:
        reportId - The id of the report.
        sessionId - Session token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the report could not be found.
      • updateReport

        void updateReport​(long reportId,
                          String reportName,
                          String reportDescription,
                          Boolean enabled,
                          Integer type,
                          String script,
                          String sessionId)
                   throws ServerSideException
        Updates the properties of an existing class level report.
        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.
        sessionId - Session token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the report properties has a wrong or unexpected format If the report could not be found.
      • updateReportParameters

        void updateReportParameters​(long reportId,
                                    List<StringPair> parameters,
                                    String sessionId)
                             throws ServerSideException
        Updates the value of any of the parameters of a given report.
        Parameters:
        reportId - Report id.
        parameters - List of pairs attribute-value of the report. Valid values are name, description, script and enabled.
        sessionId - Session token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the any of the parameters has an invalid name
      • getClassLevelReports

        List<RemoteReportMetadataLight> getClassLevelReports​(String className,
                                                             boolean recursive,
                                                             boolean includeDisabled,
                                                             String sessionId)
                                                      throws ServerSideException
        Gets the class level reports associated to the given class (or its superclasses)
        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.
        sessionId - Session token.
        Returns:
        The list of reports.
        Throws:
        ServerSideException - If the class could not be found If the user is not allowed to invoke the method
      • getInventoryLevelReports

        List<RemoteReportMetadataLight> getInventoryLevelReports​(boolean includeDisabled,
                                                                 String sessionId)
                                                          throws ServerSideException
        Gets the inventory class reports.
        Parameters:
        includeDisabled - True to also include the reports marked as disabled. False to return only the enabled ones.
        sessionId - Session token.
        Returns:
        The list of reports.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the dummy root could not be found, which is actually a severe problem.
      • getReport

        RemoteReportMetadata getReport​(long reportId,
                                       String sessionId)
                                throws ServerSideException
        Gets the information related to a class level report.
        Parameters:
        reportId - The id of the report.
        sessionId - Session token.
        Returns:
        The report.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the report could not be found.
      • executeClassLevelReport

        byte[] executeClassLevelReport​(String objectClassName,
                                       String objectId,
                                       long reportId,
                                       String sessionId)
                                throws ServerSideException
        Executes a class level report and returns the result.
        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.
        sessionId - Session token.
        Returns:
        The result of the report execution.
        Throws:
        ServerSideException - If the class could not be found or if the report could not be found or if the inventory object could not be found or if there's an error during the execution of the report.
      • executeInventoryLevelReport

        byte[] executeInventoryLevelReport​(long reportId,
                                           List<StringPair> parameters,
                                           String sessionId)
                                    throws ServerSideException
        Executes an inventory level report and returns the result.
        Parameters:
        reportId - The id of the report.
        parameters - List of pairs param name - param value
        sessionId - Session token.
        Returns:
        The result of the report execution.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or If the report could not be found or if the associated script exits with error.
      • createFavoritesFolderForUser

        long createFavoritesFolderForUser​(String favoritesFolderName,
                                          long userId,
                                          String sessionId)
                                   throws ServerSideException
        Creates a favorites folder for User.
        Parameters:
        favoritesFolderName - Bookmark folder name
        userId - User id
        sessionId - The session token
        Returns:
        The id of the new Bookmark folder
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or If the user can not be found or If the name is null or empty
      • deleteFavoritesFolders

        void deleteFavoritesFolders​(long[] favoritesFolderId,
                                    long userId,
                                    String sessionId)
                             throws ServerSideException
        Deletes a set of favorites folders
        Parameters:
        favoritesFolderId - Bookmark folder id
        userId - The User id
        sessionId - The session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or If any favorites folder in the array can not be found
      • getFavoritesFoldersForUser

        List<RemoteFavoritesFolder> getFavoritesFoldersForUser​(long userId,
                                                               String sessionId)
                                                        throws ServerSideException
        Gets the list of favorites folders of a given User.
        Parameters:
        userId - User id
        sessionId - The session token
        Returns:
        The list of Bookmarks for user
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or If the user can not be found
      • addObjectsToFavoritesFolder

        void addObjectsToFavoritesFolder​(String[] objectClass,
                                         String[] objectId,
                                         long favoritesFolderId,
                                         long userId,
                                         String sessionId)
                                  throws ServerSideException
        Associates a list of objects to an existing favorites folder
        Parameters:
        objectClass - Object class name
        objectId - Object id
        favoritesFolderId - Bookmark folder id
        userId - The User id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the favorites folder can not be found If the object can not be found If the object have a relationship with the favorite folder
      • removeObjectsFromFavoritesFolder

        void removeObjectsFromFavoritesFolder​(String[] objectClass,
                                              String[] objectId,
                                              long favoritesFolderId,
                                              long userId,
                                              String sessionId)
                                       throws ServerSideException
        Removes a list of objects from a given favorites folder
        Parameters:
        objectClass - Object class name
        objectId - Object id
        favoritesFolderId - Bookmark folder id
        userId - User id the favorites folder belongs to
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the favorites folder can not be found If the object can not be found If the object can not be found
      • getObjectsInFavoritesFolder

        List<RemoteObjectLight> getObjectsInFavoritesFolder​(long favoritesFolderId,
                                                            long userId,
                                                            int limit,
                                                            String sessionId)
                                                     throws ServerSideException
        Gets the objects in a to favorites folder
        Parameters:
        favoritesFolderId - Bookmark folder id
        userId - User Id
        limit - Max number of results. Use -1 to retrieve all.
        sessionId - Session token
        Returns:
        The list of objects
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the favorites folder can not be found
      • getFavoritesFoldersForObject

        List<RemoteFavoritesFolder> getFavoritesFoldersForObject​(long userId,
                                                                 String objectClass,
                                                                 String objectId,
                                                                 String sessionId)
                                                          throws ServerSideException
        Gets the favorites folders an object is included into.
        Parameters:
        userId - User Id
        objectClass - Object Class name
        objectId - Object id
        sessionId - Session token
        Returns:
        The list of bookmarks where an object is associated
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If the object is associated to a bookmark folder but The favorites folder is not associated to the current user
      • getFavoritesFolder

        RemoteFavoritesFolder getFavoritesFolder​(long favoritesFolderId,
                                                 long userId,
                                                 String sessionId)
                                          throws ServerSideException
        Gets a favorites folder
        Parameters:
        favoritesFolderId - Bookmark folder id
        userId - User id
        sessionId - Session token
        Returns:
        The Bookmark folder
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the favorites folder can not be found
      • updateFavoritesFolder

        void updateFavoritesFolder​(long favoritesFolderId,
                                   String favoritesFolderName,
                                   long userId,
                                   String sessionId)
                            throws ServerSideException
        Updates a favorites folder
        Parameters:
        favoritesFolderId - Favorites folder id
        favoritesFolderName - Favorites folder name
        userId - User id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the favorites folder can not be found If the name of the favorites folder is null or empty
      • createBusinessRule

        long createBusinessRule​(String ruleName,
                                String ruleDescription,
                                int ruleType,
                                int ruleScope,
                                String appliesTo,
                                String ruleVersion,
                                List<String> constraints,
                                String sessionId)
                         throws ServerSideException
        Creates a business rule given a set of constraints
        Parameters:
        ruleName - Rule name
        ruleDescription - Rule description
        ruleType - Rule type. See BusinesRule.TYPE* for possible values.
        ruleScope - The scope of the rule. See BusinesRule.SCOPE* for possible values.
        appliesTo - The class this rule applies to. Can not be null.
        ruleVersion - The version of the rule. Useful to migrate it if necessary in further versions of the platform
        constraints - An array with the definition of the logic to be matched with the rule. Can not be empty or null
        sessionId - Session token
        Returns:
        The id of the newly created business rule
        Throws:
        ServerSideException - If any of the parameters is null (strings) or leer than 1 or if the constraints array is null or empty
      • deleteBusinessRule

        void deleteBusinessRule​(long businessRuleId,
                                String sessionId)
                         throws ServerSideException
        Deletes a business rule
        Parameters:
        businessRuleId - Rule id
        sessionId - Session token
        Throws:
        ServerSideException - If the given rule does not exist
      • getBusinessRules

        List<RemoteBusinessRule> getBusinessRules​(int type,
                                                  String sessionId)
                                           throws ServerSideException
        Retrieves the business rules of a particular type.
        Parameters:
        type - Rule type. See BusinesRule.TYPE* for possible values. Use -1 to retrieve all
        sessionId - Session token
        Returns:
        The list of business rules with the matching type.
        Throws:
        ServerSideException - If something unexpected happens
      • launchSupervisedSynchronizationTask

        List<RemoteSyncFinding> launchSupervisedSynchronizationTask​(long syncGroupId,
                                                                    String sessionId)
                                                             throws ServerSideException
        Executes a supervised synchronization job, which consist on connecting to the sync data source using the configuration attached to the given sync group and finding the differences between the information currently in the inventory platform and what's in the sync data source. A supervised sync job needs a human to review the differences and decide what to do, while an automated sync job automatically decides what to do based on built-in business rules. Please note that the execution might take some time, so it is expected that the client to implement an asynchronous call
        Parameters:
        syncGroupId - The sync group id
        sessionId - The session token
        Returns:
        A list of differences that require the authorization of a user to be resolved
        Throws:
        ServerSideException - If the sync group could not be found or if
      • launchAutomatedSynchronizationTask

        List<RemoteSyncResult> launchAutomatedSynchronizationTask​(long syncGroupId,
                                                                  String providersName,
                                                                  String sessionId)
                                                           throws ServerSideException
        Executes an automated synchronization job, which consist on connecting to the sync data source using the configuration attached to the given sync group and finding the differences between the information currently in the inventory platform and what's in the sync data source. An automated sync job does not need human intervention it automatically decides what to do based on built-in business rules
        Parameters:
        syncGroupId - The sync group id
        providersName -
        sessionId - The session token
        Returns:
        The set of results
        Throws:
        ServerSideException - If the sync group could not be found
      • launchAdHocAutomatedSynchronizationTask

        List<RemoteSyncResult> launchAdHocAutomatedSynchronizationTask​(List<Long> synDsConfigIds,
                                                                       String providersName,
                                                                       String sessionId)
                                                                throws ServerSideException
        Executes an automated synchronization job, which consist on connecting to the sync data source using the configuration attached to the given sync group and finding the differences between the information currently in the inventory platform and what's in the sync data source. An automated sync job does not need human intervention it automatically decides what to do based on built-in business rules
        Parameters:
        synDsConfigIds - The sync data source configurations ids
        providersName -
        sessionId - The session token
        Returns:
        The set of results
        Throws:
        ServerSideException - If the sync group could not be found
      • executeSyncActions

        List<RemoteSyncResult> executeSyncActions​(long syncGroupId,
                                                  List<RemoteSyncAction> actions,
                                                  String sessionId)
                                           throws ServerSideException
        Executes the synchronization actions that the user selected after check the list of findings
        Parameters:
        syncGroupId - the sync groupId
        actions - the list findings to be processed
        sessionId - the session token
        Returns:
        the list of results after the actions were executed
        Throws:
        ServerSideException
      • killJob

        void killJob​(long jobId,
                     String sessionId)
              throws ServerSideException
        Kills a job given its id
        Parameters:
        jobId - id of job to kill
        sessionId - the session id token
        Throws:
        ServerSideException - If the job cannot be found
      • createSDHTransportLink

        String createSDHTransportLink​(String classNameEndpointA,
                                      String idEndpointA,
                                      String classNameEndpointB,
                                      String idEndpointB,
                                      String linkType,
                                      String defaultName,
                                      String sessionId)
                               throws ServerSideException
        Creates an SDH transport link (STMX)
        Parameters:
        classNameEndpointA - The class name of the endpoint A (some kind of port)
        idEndpointA - Id of endpoint A
        classNameEndpointB - The class name of the endpoint Z (some kind of port)
        idEndpointB - Id of endpoint Z
        linkType - Type of link (STM1, STM4, STM16, STM256, etc)
        defaultName - The default name of the transport link.
        sessionId - Session token
        Returns:
        The id of the newly created transport link
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or If any of the requested objects can't be found or If any of the classes provided can not be found or If any of the objects involved can't be connected.
      • createSDHContainerLink

        String createSDHContainerLink​(String classNameEndpointA,
                                      String idEndpointA,
                                      String classNameEndpointB,
                                      String idEndpointB,
                                      String linkType,
                                      List<RemoteSDHPosition> positions,
                                      String defaultName,
                                      String sessionId)
                               throws ServerSideException
        Creates an SDH container link (VCX). In practical terms, it's always a high order container, such a VC4XXX
        Parameters:
        classNameEndpointA - The class name of the endpoint A (a GenericCommunicationsEquipment)
        idEndpointA - Id of endpoint A
        classNameEndpointB - The class name of the endpoint B (GenericCommunicationsEquipment)
        idEndpointB - Id of endpoint B
        linkType - Type of link (VC4, VC3, V12, etc. A VC12 alone doesn't make much sense, though)
        positions - This param specifies the transport links and positions used by the container. For more details on how this works, please read the "SDH Model: Technical Design and Tools" document. Please note that is greatly advisable to provide them already sorted
        defaultName - the name to be assigned to the new element. If null, an empty string will be used
        sessionId - Sesion token
        Returns:
        The id of the newly created container link
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or If any of the requested objects can't be found or If any of the classes provided can not be found or If any of the objects involved can't be connected.
      • createSDHTributaryLink

        String createSDHTributaryLink​(String classNameEndpointA,
                                      String idEndpointA,
                                      String classNameEndpointB,
                                      String idEndpointB,
                                      String linkType,
                                      List<RemoteSDHPosition> positions,
                                      String defaultName,
                                      String sessionId)
                               throws ServerSideException
        Creates an SDH tributary link (VCXTributaryLink)
        Parameters:
        classNameEndpointA - The class name of the endpoint A (some kind of tributary port)
        idEndpointA - Id of endpoint A
        classNameEndpointB - The class name of the endpoint B (some kind of tributary port)
        idEndpointB - Id of endpoint B
        linkType - Type of link (VC4TributaryLink, VC3TributaryLink, V12TributaryLink, etc)
        positions - This param specifies the transport links and positions used by the container. For more details on how this works, please read the SDH Model: Technical Design and Tools document. Please note that is greatly advisable to provide them already sorted. Please note that creating a tributary link automatically creates a container link to deliver it
        defaultName - the name to be assigned to the new element
        sessionId - Session token
        Returns:
        The id of the newly created tributary link
        Throws:
        ServerSideException - If the user is not allowed to invoke the method or If any of the requested objects can't be found or If any of the classes provided can not be found or If any of the objects involved can't be connected.
      • deleteSDHTransportLink

        void deleteSDHTransportLink​(String transportLinkClass,
                                    String transportLinkId,
                                    boolean forceDelete,
                                    String sessionId)
                             throws ServerSideException
        Deletes a transport link
        Parameters:
        transportLinkClass - Transport Link class
        transportLinkId - Transport link id
        forceDelete - Delete recursively all SDH elements transported by the transport link
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the transport link could not be found
      • deleteSDHContainerLink

        void deleteSDHContainerLink​(String containerLinkClass,
                                    String containerLinkId,
                                    boolean forceDelete,
                                    String sessionId)
                             throws ServerSideException
        Deletes a container link
        Parameters:
        containerLinkClass - Container link class
        containerLinkId - Container class id
        forceDelete - Delete recursively all SDH elements contained by the container link
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the container link could not be found
      • deleteSDHTributaryLink

        void deleteSDHTributaryLink​(String tributaryLinkClass,
                                    String tributaryLinkId,
                                    String sessionId)
                             throws ServerSideException
        Deletes a tributary link and its corresponding container link. This method will delete all the object relationships.
        Parameters:
        tributaryLinkClass - The class of the tributary link
        tributaryLinkId - the id of the tributary link
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the tributary link could not be found
      • findSDHRoutesUsingTransportLinks

        List<RemoteObjectLightList> findSDHRoutesUsingTransportLinks​(String communicationsEquipmentClassA,
                                                                     String communicationsEquipmentIdA,
                                                                     String communicationsEquipmentClassB,
                                                                     String communicationsEquipmentIB,
                                                                     String sessionId)
                                                              throws ServerSideException
        Finds a route between two GenericcommunicationsEquipment based on the TransportLinks network map (for more details on how this works, please read the SDH Model: Technical Design and Tools document)
        Parameters:
        communicationsEquipmentClassA - The class of one of the route endpoints
        communicationsEquipmentIdA - The id of one of the route endpoints
        communicationsEquipmentClassB - The class of the other route endpoint
        communicationsEquipmentIB - The id of the other route endpoint
        sessionId - Session token
        Returns:
        A sorted list of RemoteObjectLights containing the route. This list includes the transport links and the nodes in between, including the very endpoints
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the given communication equipment is no subclass of GenericCommunicationsEquipment
      • findSDHRoutesUsingContainerLinks

        List<RemoteObjectLightList> findSDHRoutesUsingContainerLinks​(String communicationsEquipmentClassA,
                                                                     String communicationsEquipmentIdA,
                                                                     String communicationsEquipmentClassB,
                                                                     String communicationsEquipmentIB,
                                                                     String sessionId)
                                                              throws ServerSideException
        Finds a route between two GenericcommunicationsEquipment based on the ContainerLinks network map (for more details on how this works, please read the SDH Model: Technical Design and Tools document)
        Parameters:
        communicationsEquipmentClassA - The class of one of the route endpoints
        communicationsEquipmentIdA - The id of one of the route endpoints
        communicationsEquipmentClassB - The class of the other route endpoint
        communicationsEquipmentIB - The id of the other route endpoint
        sessionId - Session token
        Returns:
        A sorted list of RemoteObjectLights containing the route. This list includes the transport links and the nodes in between, including the very endpoints
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the given communication equipment is no subclass of GenericCommunicationsEquipment
      • getSDHTransportLinkStructure

        List<RemoteSDHContainerLinkDefinition> getSDHTransportLinkStructure​(String transportLinkClass,
                                                                            String transportLinkId,
                                                                            String sessionId)
                                                                     throws ServerSideException
        Retrieves the container links within a transport link (e.g. the VC4XX in and STMX)
        Parameters:
        transportLinkClass - Transportlink's class
        transportLinkId - Transportlink's id
        sessionId - Session token
        Returns:
        The list of the containers that go through that transport link
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the given transport link is no subclass of GenericSDHTransportLink
      • getSDHContainerLinkStructure

        List<RemoteSDHContainerLinkDefinition> getSDHContainerLinkStructure​(String containerLinkClass,
                                                                            String containerLinkId,
                                                                            String sessionId)
                                                                     throws ServerSideException
        Gets the internal structure of a container link. This is useful to provide information about the occupation of a link. This is only applicable to VC4XX
        Parameters:
        containerLinkClass - Container class
        containerLinkId - Container Id
        sessionId - Session token
        Returns:
        The list of containers contained in the container
        Throws:
        ServerSideException - If the user is not authorized to know the structure of a container link, if the container supplied is not subclass of GenericSDHHighOrderContainerLink, if the container could not be found or if the class could not be found
      • getSubnetPools

        List<RemotePool> getSubnetPools​(String parentId,
                                        String className,
                                        String sessionId)
                                 throws ServerSideException
        Retrieves all the pools of subnets
        Parameters:
        parentId - parent id parent id of the pool, -1 to retrieve the pools from the root nodes
        className - IPv4 or IPv6 subnet
        sessionId - the session token
        Returns:
        a set of subnet pools
        Throws:
        ServerSideException - if there are not IPAM root nodes or if can't get the pools of a subnet pool
      • getSubnets

        List<RemoteObjectLight> getSubnets​(String poolId,
                                           int limit,
                                           String sessionId)
                                    throws ServerSideException
        Retrieves the subnets of a given pool id
        Parameters:
        poolId - subnet pool id
        limit - limit of returned subnets, -1 to no limit
        sessionId - the session token
        Returns:
        a set of subnets
        Throws:
        ServerSideException - if the given subnet pool id is not valid
      • createSubnetPool

        String createSubnetPool​(String parentId,
                                String subnetPoolName,
                                String subnetPoolDescription,
                                String className,
                                String sessionId)
                         throws ServerSideException
        Creates a pool of subnets if the parentId is -1 the pool will be created in the default root for pools of subnets
        Parameters:
        parentId - subnet parent Id, -1 to if want to create the pool in the root node
        subnetPoolName - subnet pool name
        subnetPoolDescription - subnet pool description
        className - if is a IPv4 or an IPv6 subnet
        sessionId - session token
        Returns:
        id of the created subnet pool
        Throws:
        ServerSideException - if the IPAM root nodes doesn't exists, or if the IPv4 or IPv6 classes doesn't exists
      • createSubnet

        String createSubnet​(String poolId,
                            String className,
                            List<StringPair> attributes,
                            String sessionId)
                     throws ServerSideException
        Creates a subnet
        Parameters:
        poolId - The id of the pool that will contain the subnet
        className - The class name of the subnet (e.g. SubnetIPv4, SubnetIPv6)
        attributes - The attributes that will be set on the newly created element as a string-based key-value dictionary
        sessionId - Session token.
        Returns:
        The id of the new subnet.
        Throws:
        ServerSideException - If something goes wrong, can't find the parent id, IPv4 or IPv6 classes doesn't exists, or some problem with attributes, different size between attribute names and attribute values.
      • deleteSubnetPools

        void deleteSubnetPools​(String[] ids,
                               String sessionId)
                        throws ServerSideException
        Deletes a set of subnet pools
        Parameters:
        ids - ids of the pools to be deleted
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • deleteSubnets

        void deleteSubnets​(String className,
                           List<String> oids,
                           boolean releaseRelationships,
                           String sessionId)
                    throws ServerSideException
        Deletes a subnet. All subnets must be instances of the same class
        Parameters:
        oids - The ids of the subnets to be deleted
        className - The subnet class
        releaseRelationships - Should the deletion be forced, deleting all the relationships?
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getSubnet

        RemoteObject getSubnet​(String id,
                               String className,
                               String sessionId)
                        throws ServerSideException
        Gets the complete information about a given subnet (all its attributes)
        Parameters:
        id - Subnet id
        className - Subnet class IPv4 o IPv6
        sessionId - Session token
        Returns:
        a representation of the subnet as a RemoteObject
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getSubnetPool

        RemotePool getSubnetPool​(String subnetPoolId,
                                 String sessionId)
                          throws ServerSideException
        Gets the complete information about a given subnet pool (all its attributes)
        Parameters:
        subnetPoolId - Subnet pool id
        sessionId - Session token
        Returns:
        a representation of the entity as a RemoteObject
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • addIPAddress

        String addIPAddress​(String id,
                            String parentClassName,
                            List<StringPair> attributes,
                            String sessionId)
                     throws ServerSideException
        Adds an IP address to a Subnet
        Parameters:
        id - ipAddres id
        parentClassName - the parent class name
        attributes - IP address attributes as a String based key-value dictionary
        sessionId - The session token
        Returns:
        the id of the new IP Address
        Throws:
        ServerSideException
      • removeIP

        void removeIP​(String[] oids,
                      boolean releaseRelationships,
                      String sessionId)
               throws ServerSideException
        Removes a set of IP Addresses from a subnet. Note that this method must be used only for Subnet objects
        Parameters:
        oids - ids of the IPs to be deleted
        releaseRelationships - Should the deletion be forced, deleting all the relationships?
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getSubnetsInSubnet

        List<RemoteObjectLight> getSubnetsInSubnet​(String id,
                                                   int limit,
                                                   String className,
                                                   String sessionId)
                                            throws ServerSideException
        Retrieves the sub-subnets of a subnet
        Parameters:
        id - subnet id
        limit - limit of returned subnets
        className - the class name if is IPv6 or IPv4
        sessionId - The session token
        Returns:
        a set of subnets
        Throws:
        ServerSideException
      • relateSubnetToVlan

        void relateSubnetToVlan​(String id,
                                String className,
                                String vlanId,
                                String sessionId)
                         throws ServerSideException
        Creates a relation between a Subnet and a VLAN, this method is also using to associate VFRs, and BDIs to a VLAN TODO: check the model, there are redundant relationships
        Parameters:
        id - Subnet id
        className - if the subnet has IPv4 or IPv6 IP addresses
        vlanId - VLAN id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • releaseSubnetFromVlan

        void releaseSubnetFromVlan​(String subnetId,
                                   String vlanId,
                                   String sessionId)
                            throws ServerSideException
        Releases the relation between a subnet and a VLAN, this method is also using to release VFRs, and BDIs from a VLAN TODO: check the model there are redundant relationships
        Parameters:
        subnetId - Subnet id
        vlanId - the VLAN id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • releaseSubnetFromVRF

        void releaseSubnetFromVRF​(String subnetId,
                                  String vrfId,
                                  String sessionId)
                           throws ServerSideException
        Releases the relation between a subnet and a VRF
        Parameters:
        subnetId - Subnet id
        vrfId - the VRF id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • relateSubnetToVrf

        void relateSubnetToVrf​(String id,
                               String className,
                               String vrfId,
                               String sessionId)
                        throws ServerSideException
        Creates a relation between a subnet and a VRF
        Parameters:
        id - Subnet id
        className - if the subnet is IPv4 or IPv6
        vrfId - VRF id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • relateIPtoPort

        void relateIPtoPort​(String id,
                            String portClassName,
                            String portId,
                            String sessionId)
                     throws ServerSideException
        Creates a relation between an IP address and a port
        Parameters:
        id - IP address id
        portClassName - port class
        portId - port id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • itOverlaps

        boolean itOverlaps​(String networkIp,
                           String broadcastIp,
                           String sessionId)
                    throws ServerSideException
        Checks if a new subnet overlaps with an existing one
        Parameters:
        networkIp - the network ip for the subnet
        broadcastIp - the broadcast ip for the subnet
        sessionId - Session token
        Returns:
        true if overlaps
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • releasePortFromIP

        void releasePortFromIP​(String deviceClassName,
                               String deviceId,
                               String id,
                               String sessionId)
                        throws ServerSideException
        Releases the relation between an IP address and a port
        Parameters:
        deviceClassName - port class name
        deviceId - port id
        id - Subnet id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • createContractPool

        String createContractPool​(String poolName,
                                  String poolDescription,
                                  String poolClass,
                                  String sessionId)
                           throws ServerSideException
        Creates a contract pool.
        Parameters:
        poolName - Contract pool name. Must be subclass of GenericContract.
        poolDescription - Contract pool description.
        poolClass - Contract pool class.
        sessionId - Session id token.
        Returns:
        The id of the newly created contract pool.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericContract.
      • getContractPool

        RemotePool getContractPool​(String poolId,
                                   String poolClass,
                                   String sessionId)
                            throws ServerSideException
        Gets the contract pools properties.
        Parameters:
        poolId - Contract pool id.
        poolClass - Contract pool class. Must be subclass of GenericContract.
        sessionId - Session id token.
        Returns:
        The contract pool properties.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericContract.
      • updateContractPool

        void updateContractPool​(String poolId,
                                String poolClass,
                                String poolName,
                                String poolDescription,
                                String sessionId)
                         throws ServerSideException
        Updates the attributes of a contract pool.
        Parameters:
        poolId - The id of the contract pool to be updated.
        poolClass - Contract pool class.
        poolName - Attribute value for pool name.
        poolDescription - Attribute value for pool description.
        sessionId - Session id token.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericContract.
      • deleteContractPool

        void deleteContractPool​(String poolId,
                                String poolClass,
                                String sessionId)
                         throws ServerSideException
        Deletes a contract pool.
        Parameters:
        poolId - The id of the contract pool to be deleted.
        poolClass - Contract pool class.
        sessionId - Session id token.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericContract.
      • getContractPools

        List<RemotePool> getContractPools​(String sessionId)
                                   throws ServerSideException
        Retrieves the contract pool list.
        Parameters:
        sessionId - Session id token.
        Returns:
        The available contract pools.
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • createContract

        String createContract​(String poolId,
                              String contractClass,
                              String[] attributeNames,
                              String[] attributeValues,
                              String sessionId)
                       throws ServerSideException
        Creates a contract.
        Parameters:
        poolId - Contract pool id.
        contractClass - Contract class name.
        attributeNames - Attributes names.
        attributeValues - Attributes values.
        sessionId - Session id token.
        Returns:
        The contract id.
        Throws:
        ServerSideException - If any of the attributes or its type is invalid. If attributeNames and attributeValues have different sizes. If the class name could not be found.
      • getContract

        RemoteObject getContract​(String contractClass,
                                 String contractId,
                                 String sessionId)
                          throws ServerSideException
        Gets the detailed information about a contract.
        Parameters:
        contractClass - Contract class. Must be subclass of GenericContract.
        contractId - Contract id.
        sessionId - Session id token.
        Returns:
        The contract properties.
        Throws:
        ServerSideException - If the object couldn't be found. If the class couldn't be found.
      • updateContract

        void updateContract​(String contractClass,
                            String contractId,
                            List<StringPair> attributes,
                            String sessionId)
                     throws ServerSideException
        Updates one or many contract attributes.
        Parameters:
        contractClass - Contract class. Must be subclass of GenericContract.
        contractId - contract id.
        attributes - The set of initial attributes. If no attribute name is specified, an empty string will be used.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the object couldn't be found. If the class couldn't be found.
      • deleteContract

        void deleteContract​(String contractClass,
                            String contractId,
                            String sessionId)
                     throws ServerSideException
        Deletes a contract and delete its association with the related inventory objects. These objects will remain untouched.
        Parameters:
        contractClass - The contract class.
        contractId - The contract id.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the object couldn't be found. If the class could not be found. If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships.
      • getAllContracts

        List<RemoteObjectLight> getAllContracts​(int page,
                                                int limit,
                                                String sessionId)
                                         throws ServerSideException
        Retrieves the entire list of contracts registered in the Contract Manager module.
        Parameters:
        page - Page number of results to skip. Use -1 to retrieve all
        limit - Max number of results per page. Use -1 to retrieve all
        sessionId - The session token.
        Returns:
        The entire list of contracts created in the Contract Manager module.
        Throws:
        ServerSideException - If something unexpected happens.
      • getContractsInPool

        List<RemoteObjectLight> getContractsInPool​(String poolId,
                                                   int limit,
                                                   String sessionId)
                                            throws ServerSideException
        Gets the contracts inside a contract pool.
        Parameters:
        poolId - Contract pool id.
        limit - the results limit. per page 0 to avoid the limit.
        sessionId - Session id token.
        Returns:
        An array of contracts in a contract pool
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the pool can't be found.
      • relateObjectsToContract

        void relateObjectsToContract​(String[] objectClass,
                                     String[] objectId,
                                     String contractClass,
                                     String contractId,
                                     String sessionId)
                              throws ServerSideException
        Relates a list of objects (instances of a subclass of InventoryObject) to an existing contract (most probably a support contract).
        Parameters:
        objectClass - Object class.
        objectId - Object id.
        contractClass - contract class.
        contractId - contract id.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the objects can't be found If any of the objects involved can't be associated If any of the classes provided can not be found
      • relateObjectToContract

        void relateObjectToContract​(String contractClass,
                                    String contractId,
                                    String objectClass,
                                    String objectId,
                                    String sessionId)
                             throws ServerSideException
        Relates an object to a contract.
        Parameters:
        contractClass - Contract class.
        contractId - Contract id.
        objectClass - Object class.
        objectId - Object id.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the contract is not subclass of GenericContract.
      • releaseObjectFromContract

        void releaseObjectFromContract​(String objectClass,
                                       String objectId,
                                       String contractClass,
                                       String contractId,
                                       String sessionId)
                                throws ServerSideException
        Releases an inventory object from a contract it was related to
        Parameters:
        objectClass - Object class.
        objectId - Object id.
        contractClass - Contract class.
        contractId - Contract id.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If the class can not be found
      • getContractResources

        List<RemoteObjectLight> getContractResources​(String contractClass,
                                                     String contractId,
                                                     String sessionId)
                                              throws ServerSideException
        Gets the resources (objects) related to a contract.
        Parameters:
        contractClass - Contract class.
        contractId - Contract id.
        sessionId - Session id.
        Returns:
        The contract resources list.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the contract is not subclass of GenericContract.
      • associateObjectsToContract

        @Deprecated
        void associateObjectsToContract​(String[] objectClass,
                                        String[] objectId,
                                        String contractClass,
                                        String contractId,
                                        String sessionId)
                                 throws ServerSideException
        Deprecated.
        Associates a list of objects (instances of a subclass of InventoryObject) to an existing contract (most probably a support contract)
        Parameters:
        objectClass - Object class
        objectId - Object id
        contractClass - contract class
        contractId - contract id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the objects can't be found If any of the objects involved can't be associated If any of the classes provided can not be found
      • createMPLSLink

        String createMPLSLink​(String classNameEndpointA,
                              String idEndpointA,
                              String classNameEndpointB,
                              String idEndpointB,
                              List<StringPair> attributesToBeSet,
                              String sessionId)
                       throws ServerSideException
        Creates an MPLS link
        Parameters:
        classNameEndpointA - The class name of the endpoint A (some kind of port)
        idEndpointA - Id of endpoint A
        classNameEndpointB - The class name of the endpoint Z (some kind of port)
        idEndpointB - Id of endpoint Z
        attributesToBeSet - Attributes to be set, e.g. mplsLink's name
        sessionId - Session token
        Returns:
        The id of the newly created transport link
        Throws:
        ServerSideException - If the given linkType is no subclass of GenericLogicalConnection If any of the requested objects can't be found If any of the classes provided can not be found If any of the objects involved can't be connected
      • getMPLSLinkEndpoints

        RemoteMPLSConnectionDetails getMPLSLinkEndpoints​(String connectionId,
                                                         String sessionId)
                                                  throws ServerSideException
        The details of a given mpls link
        Parameters:
        connectionId - the mpls link id
        sessionId - Session token
        Returns:
        An array of two positions: the first is the A endpoint and the second is the B endpoint
        Throws:
        ServerSideException - f the given id class name is not MPLS Link If any of the requested objects can't be found If any of the classes provided can not be found If any of the objects involved can't be connected
      • connectMplsLink

        void connectMplsLink​(String[] sideAClassNames,
                             String[] sideAIds,
                             String[] linksIds,
                             String[] sideBClassNames,
                             String[] sideBIds,
                             String sessionId)
                      throws ServerSideException
        Connect a given mpls links with a given ports for every side
        Parameters:
        sideAClassNames - end point side A class names
        sideAIds - end point side A ids
        linksIds - mpls links ids
        sideBClassNames - end point side B class names
        sideBIds - end point side B ids
        sessionId - session token
        Throws:
        ServerSideException - If the given ports are not subclass of GenericPort If the given link ids are not of the class MPLSLink If any of the requested objects can't be found If any of the classes provided can not be found If any of the objects involved can't be connected
      • disconnectMPLSLink

        void disconnectMPLSLink​(String connectionId,
                                int sideToDisconnect,
                                String sessionId)
                         throws ServerSideException
        disconnect mpls link
        Parameters:
        connectionId - mpls link id
        sideToDisconnect - which side will be disconnect 1 side A, 2 side B, 3 both sides
        sessionId - session token
        Throws:
        ServerSideException - If the given link id is not of the class MPLSLink If any of the requested objects can't be found If any of the classes provided can not be found If any of the objects involved can't be connected
      • deleteMPLSLink

        void deleteMPLSLink​(String linkId,
                            boolean forceDelete,
                            String sessionId)
                     throws ServerSideException
        Deletes a MPLS link
        Parameters:
        linkId - the id of the mpls link
        forceDelete - Ignore the existing relationships
        sessionId - Session token
        Throws:
        ServerSideException - If the object can not be found If either the object class or the attribute can not be found If the class could not be found If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships.
      • relatePortToInterface

        void relatePortToInterface​(String portId,
                                   String portClassName,
                                   String interfaceClassName,
                                   String interfaceId,
                                   String sessionId)
                            throws ServerSideException
        Associates any GenericCommunicationsPort to existing BridgeDomainInterface
        Parameters:
        portId - MPLSTunnel or BridgeDomain or FrameRelay or VRF id
        portClassName - if is a MPLSTunnel or BridgeDomain or FrameRelay or VRF
        interfaceClassName - network element class name
        interfaceId - network element id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • releasePortFromInterface

        void releasePortFromInterface​(String interfaceClassName,
                                      String interfaceId,
                                      String portId,
                                      String sessionId)
                               throws ServerSideException
        Release the association between a network element and a MPLSTunnel or BridgeDomain or FrameRelay or VRF
        Parameters:
        portId - MPLSTunnel or BridgeDomain or FrameRelay or VRF id
        interfaceClassName - network element class name
        interfaceId - network element id
        sessionId - Session token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at runtime
      • getProjectPools

        List<RemotePool> getProjectPools​(String sessionId)
                                  throws ServerSideException
        Retrieves the projects pool list.
        Parameters:
        sessionId - Session id token.
        Returns:
        The available project pools.
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • createProject

        String createProject​(String projectPoolId,
                             String projectClass,
                             String[] attributeNames,
                             String[] attributeValues,
                             String sessionId)
                      throws ServerSideException
        Creates a Project.
        Parameters:
        projectPoolId - Project pool id.
        projectClass - Project class name.
        attributeNames - Attributes names.
        attributeValues - Attributes values.
        sessionId - Session id token.
        Returns:
        The project id.
        Throws:
        ServerSideException - If any of the attributes or its type is invalid. If attributeNames and attributeValues have different sizes. If the class name could not be found.
      • getProject

        RemoteObject getProject​(String projectClass,
                                String projectId,
                                String sessionId)
                         throws ServerSideException
        Gets the detailed information about a project
        Parameters:
        projectClass - Project class. Must be subclass of GenericProject.
        projectId - Project id.
        sessionId - Session id token.
        Returns:
        The project properties.
        Throws:
        ServerSideException - If the object couldn't be found. If the class couldn't be found.
      • updateProject

        void updateProject​(String projectClass,
                           String projectId,
                           List<StringPair> attributes,
                           String sessionId)
                    throws ServerSideException
        Updates one or many project attributes.
        Parameters:
        projectClass - Project class. Must be subclass of GenericProject.
        projectId - Project id.
        attributes - The set of initial attributes. If no attribute name is specified, an empty string will be used.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the object couldn't be found. If the class couldn't be found.
      • deleteProject

        void deleteProject​(String projectClass,
                           String projectId,
                           String sessionId)
                    throws ServerSideException
        Deletes a project and delete its association with the related inventory objects.These objects will remain untouched.
        Parameters:
        projectClass - The project class.
        projectId - The project id.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the object couldn't be found. If the class could not be found. If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships.
      • createActivity

        String createActivity​(String projectId,
                              String projectClass,
                              String activityClass,
                              String[] attributeNames,
                              String[] attributeValues,
                              String sessionId)
                       throws ServerSideException
        Creates an Activity inside a project.
        Parameters:
        projectId - The project id.
        projectClass - The project class.
        activityClass - The activity class. Must be subclass of GenericActivity.
        attributeNames - Attributes names.
        attributeValues - Attributes values.
        sessionId - Session id token.
        Returns:
        The Activity id.
        Throws:
        ServerSideException - If the object's class can't be found. If the parent id is not found. If any of the attribute values has an invalid value or format. If the update can't be performed due to a format issue. If attributeNames and attributeValues have different sizes.
      • getActivity

        RemoteObject getActivity​(String activityClass,
                                 String activityId,
                                 String sessionId)
                          throws ServerSideException
        Gets the detailed information about an activity.
        Parameters:
        activityClass - Activity class. Must be subclass of GenericActivity.
        activityId - Activity id.
        sessionId - Session id token.
        Returns:
        The activity properties.
        Throws:
        ServerSideException - If the object couldn't be found. If the class couldn't be found.
      • updateActivity

        void updateActivity​(String activityClass,
                            String activityId,
                            List<StringPair> attributes,
                            String sessionId)
                     throws ServerSideException
        Updates one or many activity attributes.
        Parameters:
        activityClass - Activity class. Must be subclass of GenericActivity.
        activityId - Activity id.
        attributes - The set of initial attributes. If no attribute name is specified, an empty string will be used.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the object couldn't be found. If the class couldn't be found.
      • deleteActivity

        void deleteActivity​(String activityClass,
                            String activityId,
                            boolean releaseRelationships,
                            String sessionId)
                     throws ServerSideException
        Deletes an activity and delete its association with the related inventory objects. These objects will remain untouched.
        Parameters:
        activityClass - The activity class. Must be subclass of GenericActivity.
        activityId - The activity id.
        releaseRelationships - Release of existing relationships.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the object couldn't be found. If the class could not be found. If the object could not be deleted because there's some business rules that avoids it or it has incoming relationships.
      • getProjectsInPool

        List<RemoteObjectLight> getProjectsInPool​(String poolId,
                                                  int limit,
                                                  String sessionId)
                                           throws ServerSideException
        Gets the projects inside a project pool.
        Parameters:
        poolId - Project pool id.
        limit - the results limit. per page 0 to avoid the limit.
        sessionId - Session id token
        Returns:
        An array of projects in a project pool
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the pool can't be found.
      • getAllProjects

        List<RemoteObjectLight> getAllProjects​(int page,
                                               int limit,
                                               String sessionId)
                                        throws ServerSideException
        Retrieves the entire list of projects registered in the Project Manager module.
        Parameters:
        page - Page number of results to skip. Use -1 to retrieve all
        limit - Max number of results per page. Use -1 to retrieve all
        sessionId - The session token.
        Returns:
        The entire list of projects created in the Project Manager module.
        Throws:
        ServerSideException - If something unexpected happens.
      • getProjectsWithFilter

        List<RemoteObjectLight> getProjectsWithFilter​(List<StringPair> filters,
                                                      int page,
                                                      int limit,
                                                      String sessionId)
                                               throws ServerSideException
        Retrieves the entire list of projects registered in the Project Manager module.
        Parameters:
        filters - Attributes to filter for
        page - Page number of results to skip. Use -1 to retrieve all
        limit - Max number of results per page. Use -1 to retrieve all
        sessionId - The session token.
        Returns:
        The entire list of projects created in the Project Manager module.
        Throws:
        ServerSideException - If something unexpected happens.
      • getProjectResources

        List<RemoteObjectLight> getProjectResources​(String projectClass,
                                                    String projectId,
                                                    String sessionId)
                                             throws ServerSideException
        Gets the resources (objects) related to a project.
        Parameters:
        projectClass - Project class.
        projectId - Project id.
        sessionId - Session id.
        Returns:
        The project resources list.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the project is not subclass of GenericProject.
      • getProjectActivities

        List<RemoteObjectLight> getProjectActivities​(String projectClass,
                                                     String projectId,
                                                     String sessionId)
                                              throws ServerSideException
        Gets the activities inside a project.
        Parameters:
        projectClass - Project class.
        projectId - Project Id.
        sessionId - Session Id.
        Returns:
        The activities list.
        Throws:
        ServerSideException - If the user is not allowed to invoke the method. If the project is not subclass of GenericProject. If the project class is not found. If the project can't be found.
      • relateObjectsToProject

        void relateObjectsToProject​(String projectClass,
                                    String projectId,
                                    String[] objectClass,
                                    String[] objectId,
                                    String sessionId)
                             throws ServerSideException
        Relates a set of objects to a project
        Parameters:
        projectClass - Project class.
        projectId - Project id.
        objectClass - Object class.
        objectId - Object id.
        sessionId - Session id token.
        Throws:
        ServerSideException - Generic If the project is not subclass of GenericProject. If array sizes of objectClass and objectId are not the same.
      • relateObjectToProject

        void relateObjectToProject​(String projectClass,
                                   String projectId,
                                   String objectClass,
                                   String objectId,
                                   String sessionId)
                            throws ServerSideException
        Relates an object to a project.
        Parameters:
        projectClass - Project class.
        projectId - Project id.
        objectClass - Object class.
        objectId - Object id.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the project is not subclass of GenericProject.
      • releaseObjectFromProject

        void releaseObjectFromProject​(String objectClass,
                                      String objectId,
                                      String projectClass,
                                      String projectId,
                                      String sessionId)
                               throws ServerSideException
        Releases an object from project.
        Parameters:
        objectClass - Object class.
        objectId - Object id.
        projectClass - Project class.
        projectId - Project id.
        sessionId - Session id token.
        Throws:
        ServerSideException - If the project is not subclass of GenericProject.
      • getProjectsRelatedToObject

        List<RemoteObjectLight> getProjectsRelatedToObject​(String objectClass,
                                                           String objectId,
                                                           String sessionId)
                                                    throws ServerSideException
        Gets the projects related to an object.
        Parameters:
        objectClass - Object class.
        objectId - Object id.
        sessionId - The session id token.
        Returns:
        The list projects related to an object.
        Throws:
        ServerSideException - If the object can't be found. If the object class provided can't be found.
      • createProjectPool

        String createProjectPool​(String poolName,
                                 String poolDescription,
                                 String poolClass,
                                 String sessionId)
                          throws ServerSideException
        Creates a project pool.
        Parameters:
        poolName - Project pool name. Must be subclass of GenericProject.
        poolDescription - Project pool description.
        poolClass - Project pool class.
        sessionId - Session id token.
        Returns:
        The id of the newly created project pool.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericProject.
      • getProjectPool

        RemotePool getProjectPool​(String poolId,
                                  String poolClass,
                                  String sessionId)
                           throws ServerSideException
        Gets the project pools properties.
        Parameters:
        poolId - Project pool id.
        poolClass - Project pool class. Must be subclass of GenericProject.
        sessionId - Session id token.
        Returns:
        The project pool properties.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericProject.
      • updateProjectPool

        void updateProjectPool​(String poolId,
                               String poolClass,
                               String poolName,
                               String poolDescription,
                               String sessionId)
                        throws ServerSideException
        Updates the attributes of a project pool.
        Parameters:
        poolId - The id of the project pool to be updated.
        poolClass - Project pool class.
        poolName - Attribute value for pool name.
        poolDescription - Attribute value for pool description.
        sessionId - Session id token.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericProject.
      • deleteProjectPool

        void deleteProjectPool​(String poolId,
                               String poolClass,
                               String sessionId)
                        throws ServerSideException
        Deletes a project pool.
        Parameters:
        poolId - The id of the project pool to be deleted.
        poolClass - Project pool class.
        sessionId - Session id token.
        Throws:
        ServerSideException - If poolClass is not a valid subclass of GenericProject.
      • getAffectedServices

        RemoteAssetLevelCorrelatedInformation getAffectedServices​(int resourceType,
                                                                  String resourceDefinition,
                                                                  String sessionId)
                                                           throws ServerSideException
        Retrieves the services affected when a given network resource is alarmed (or down). The services associated directly to the given resource are returned first, but depending on the resource type, the analysis might be more extensive. If the resource is a link (logical or physical), the services associated to the endpoint ports are also returned. If the the resource is a container (physical or logical), the services associated to the contained links are also returned. If the resource is a network equipment, the services associated directly to the ports contained and their connections are also returned.
        Parameters:
        resourceType - Use 1 for hardware and 2 for logical links
        resourceDefinition - A semi-colon (;) separated string. The first segment (mandatory) is the name of the affected element, the second is the number of the slot (optional) and the third is the port (optional). Note that to address a logical connection, the resource definition will contain only the name of such connection.
        sessionId - Session token
        Returns:
        A compact summary with the full information about the device/interface provided, the related services and their customers
        Throws:
        ServerSideException - If the resource could not be found or if the resource definition/resource type is not valid
      • getSynchronizationProviders

        List<RemoteSynchronizationProvider> getSynchronizationProviders​(String sessionId)
                                                                 throws ServerSideException
        Get the set of sync providers defined in the configuration variables pool called -Sync Providers-
        Parameters:
        sessionId - Session token
        Returns:
        The set of sync providers defined in the configuration variables pool called -Sync Providers-
        Throws:
        ServerSideException - If the pool could not be found If the value of the variable could not be successfully translated into a java type variable If no configuration variable with that name could be found
      • createSynchronizationDataSourceConfig

        long createSynchronizationDataSourceConfig​(String objectId,
                                                   long syncGroupId,
                                                   String name,
                                                   List<StringPair> parameters,
                                                   String sessionId)
                                            throws ServerSideException
        Creates a Synchronization Data Source Configuration. A Sync data source configuration is a set of parameters used to connect to a sync data source (usually IPs, paths, etc)
        Parameters:
        objectId - Id of the object that the configuration is attached to
        syncGroupId - Id of the sync group this configuration is related to
        name - The name of the new sync data source configuration
        parameters - The list of parameters to be stored as pairs name/value. Note that the Sync provider provides metadata definition to check if the number and format of the parameters correct, so it can be checked at server side
        sessionId - Session token
        Returns:
        The id of the newly created sync configuration.
        Throws:
        ServerSideException - If the sync group could not be found or if the any of the parameters does not comply with the expected format
      • createSynchronizationGroup

        long createSynchronizationGroup​(String name,
                                        String sessionId)
                                 throws ServerSideException
        Creates a Synchronization Group. A Sync Group is a set of Synchronization Configurations that will be processed by the same Synchronization Provider. Take into account that the schedule for the SG to be executed is not configured here, but in Task Manager's task
        Parameters:
        name - The name of the new sync group
        sessionId - Session token
        Returns:
        The id of the newly created sync group
        Throws:
        ServerSideException - If the name or the sync provider are invalid
      • updateSynchronizationGroup

        void updateSynchronizationGroup​(long syncGroupId,
                                        List<StringPair> syncGroupProperties,
                                        String sessionId)
                                 throws ServerSideException
        Creates a Synchronization Group. A Sync Group is a set of Synchronization Configurations that will be processed by the same Synchronization Provider. Take into account that the schedule for the SG to be executed is not configured here, but in Task Manager's task
        Parameters:
        syncGroupId - The name of the new sync group
        syncGroupProperties - The synchronization group properties
        sessionId - Session token
        Throws:
        ServerSideException - If the name or the sync provider are invalid
      • getSyncDataSourceConfigurations

        List<RemoteSynchronizationConfiguration> getSyncDataSourceConfigurations​(long syncGroupId,
                                                                                 String sessionId)
                                                                          throws ServerSideException
        Gets the synchronization data source configurations for a sync group
        Parameters:
        syncGroupId - the syncGroupId
        sessionId - Session token
        Returns:
        The list of available sync groups
        Throws:
        ServerSideException - If something unexpected goes wrong
      • updateSyncDataSourceConfiguration

        void updateSyncDataSourceConfiguration​(long syncDataSourceConfigId,
                                               List<StringPair> parameters,
                                               String sessionId)
                                        throws ServerSideException
        Updates a sync data source configuration
        Parameters:
        syncDataSourceConfigId - the sync source configuration Id
        parameters - the updated parameters
        sessionId - session token
        Throws:
        ServerSideException - If the sync data source could not be found or if the any of the parameters does not comply with the expected format
      • deleteSynchronizationGroup

        void deleteSynchronizationGroup​(long syncGroupId,
                                        String sessionId)
                                 throws ServerSideException
        Deletes a synchronization group and all the sync configurations associated to it
        Parameters:
        syncGroupId - The id of the group
        sessionId - Session token
        Throws:
        ServerSideException - If the group could not be found
      • deleteSynchronizationDataSourceConfig

        void deleteSynchronizationDataSourceConfig​(long syncDataSourceConfigId,
                                                   String sessionId)
                                            throws ServerSideException
        Deletes a sync data source configuration.
        Parameters:
        syncDataSourceConfigId - The id of the configuration
        sessionId - Session token
        Throws:
        ServerSideException - If the config could not be found
      • copySyncDataSourceConfiguration

        void copySyncDataSourceConfiguration​(long syncGroupId,
                                             long[] syncDataSourceConfigurationIds,
                                             String sessionId)
                                      throws ServerSideException
        Creates "copy" a relation between a set of sync data source configurations and a given sync group
        Parameters:
        syncGroupId - The Sync Group Id target
        syncDataSourceConfigurationIds - Set of sync data source configuration ids
        sessionId - Session Token
        Throws:
        ServerSideException - If the sync group cannot be found, or some sync data source configuration cannot be found If the sync group is malformed, or some sync data source configuration is malformed
      • releaseSyncDataSourceConfigFromSyncGroup

        void releaseSyncDataSourceConfigFromSyncGroup​(long syncGroupId,
                                                      long[] syncDataSourceConfigurationIds,
                                                      String sessionId)
                                               throws ServerSideException
        Release a set of sync data source configuration from a given sync group
        Parameters:
        syncGroupId - The Sync Group Id target
        syncDataSourceConfigurationIds - Set of sync data source configuration ids
        sessionId - Session Token
        Throws:
        ServerSideException - If the sync group cannot be found, or some sync data source configuration cannot be found If the sync group is malformed, or some sync data source configuration is malformed
      • moveSyncDataSourceConfiguration

        void moveSyncDataSourceConfiguration​(long newSyncGroupId,
                                             long[] syncDataSourceConfigurationIds,
                                             String sessionId)
                                      throws ServerSideException
        Moves a sync data source configuration from a sync group to another sync group
        Parameters:
        newSyncGroupId - The Sync Group Id target to release
        syncDataSourceConfigurationIds - Set of sync data source configuration ids
        sessionId - Session token
        Throws:
        ServerSideException - If the sync group cannot be found, or some sync data source configuration cannot be found If the sync group is malformed, or some sync data source configuration is malformed
      • createProcessDefinition

        String createProcessDefinition​(String name,
                                       String description,
                                       String version,
                                       boolean enabled,
                                       byte[] structure,
                                       String sessionId)
                                throws ServerSideException
        Creates a process definition. A process definition is the metadata that defines the steps and constraints of a given project
        Parameters:
        name - The name of the new process definition
        description - The description of the new process definition
        version - The version of the new process definition. This is a three numbers, dot separated string (e.g. 2.4.1)
        enabled - If the project is enabled to create instances from it
        structure - The structure of the process definition. It's an XML document that represents a BPMN process definition
        sessionId - The session token
        Returns:
        The id of the newly created process definition
        Throws:
        ServerSideException - If the process structure defines a malformed process or if the version is invalid
      • updateProcessDefinition

        void updateProcessDefinition​(String processDefinitionId,
                                     List<StringPair> properties,
                                     byte[] structure,
                                     String sessionId)
                              throws ServerSideException
        Updates a process definition, either its standard properties or its structure
        Parameters:
        processDefinitionId - The process definition id
        properties - A key value dictionary with the standard properties to be updated. These properties are: name, description, version and enabled (use 'true' or 'false' for the latter)
        structure - A byte array withe XML process definition body
        sessionId - The session token
        Throws:
        ServerSideException - If the structure is invalid, or the process definition could not be found or one of the properties is malformed or have an unexpected name
      • deleteProcessDefinition

        void deleteProcessDefinition​(String processDefinitionId,
                                     String sessionId)
                              throws ServerSideException
        Deletes a process definition
        Parameters:
        processDefinitionId - The process definition to be deleted
        sessionId - The session token
        Throws:
        ServerSideException - If the process definition could not be found or if there are process instances related to the process definition
      • getProcessDefinition

        RemoteProcessDefinition getProcessDefinition​(String processDefinitionId,
                                                     String sessionId)
                                              throws ServerSideException
        Retrieves a process definition
        Parameters:
        processDefinitionId - The id of the process
        sessionId - The session token
        Returns:
        The process definition. It contains an XML document to be parsed by the consumer
        Throws:
        ServerSideException - If the process could not be found or if it's malformed
      • createProcessInstance

        String createProcessInstance​(String processDefinitionId,
                                     String processInstanceName,
                                     String processInstanceDescription,
                                     String sessionId)
                              throws ServerSideException
        Creates an instance of a process, that is, starts one
        Parameters:
        processDefinitionId - The id of the process to be started
        processInstanceName - The name of the new process
        processInstanceDescription - The description of the new process
        sessionId - The session token
        Returns:
        The id of the newly created process instance
        Throws:
        ServerSideException - If the process definition could not be found or if it's disabled
      • getNextActivityForProcessInstance

        RemoteActivityDefinition getNextActivityForProcessInstance​(String processInstanceId,
                                                                   String sessionId)
                                                            throws ServerSideException
        Requests for the next activity to be executed in a process instance.
        Parameters:
        processInstanceId - The running process to get the next activity from
        sessionId - The session id
        Returns:
        The activity definition
        Throws:
        ServerSideException - If the process instance could not be found, or if the process already ended
      • commitActivity

        void commitActivity​(String processInstanceId,
                            String activityDefinitionId,
                            RemoteArtifact artifact,
                            String sessionId)
                     throws ServerSideException
        Saves the artifact generated once an activity has been completed (for example, the user filled in a form).
        Parameters:
        processInstanceId - The process instance the activity belongs to
        activityDefinitionId - The activity id
        artifact - The artifact to be saved
        sessionId - The session token
        Throws:
        ServerSideException - If the process could not be found, or if the activity had been already executed, or if the activity definition could not be found, or of there's a mismatch in the artifact versions or if the user is not an authorized actor to carry on with the activity
      • getArtifactDefinitionForActivity

        RemoteArtifactDefinition getArtifactDefinitionForActivity​(String processDefinitionId,
                                                                  String activityDefinitionId,
                                                                  String sessionId)
                                                           throws ServerSideException
        Given an activity definition, returns the artifact definition associated to it
        Parameters:
        processDefinitionId - The id of the process the activity is related to
        activityDefinitionId - The id of the activity
        sessionId - The session token
        Returns:
        An object containing the artifact definition
        Throws:
        ServerSideException - If the process or the activity could not be found
      • getArtifactForActivity

        RemoteArtifact getArtifactForActivity​(String processInstanceId,
                                              String activityId,
                                              String sessionId)
                                       throws ServerSideException
        Gets the artifact associated to an activity (for example, a form that was already filled in by a user in a previous, already committed activity)
        Parameters:
        processInstanceId - The id of the process instance. This process may have been ended already.
        activityId - The id of the activity the artifact belongs to
        sessionId - The session token
        Returns:
        The artifact corresponding to the given activity
        Throws:
        ServerSideException - If the process instance or activity couldn't be found.
      • getWarehouseRootPools

        List<RemotePool> getWarehouseRootPools​(String sessionId)
                                        throws ServerSideException
        Gets the warehouse module root pools.
        Parameters:
        sessionId - Session token.
        Returns:
        the warehouse module root pools.
        Throws:
        ServerSideException - If the class GenericWarehouse does not exist.
      • getWarehousesInPool

        List<RemoteObjectLight> getWarehousesInPool​(String poolId,
                                                    int limit,
                                                    String sessionId)
                                             throws ServerSideException
        Get the warehouses list inside the pool
        Parameters:
        poolId - Root pool id
        limit - Result limit. -1 To return all
        sessionId - Session token.
        Returns:
        warehouses list
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the pool can't be found
      • getPoolsInWarehouse

        List<RemotePool> getPoolsInWarehouse​(String objectClassName,
                                             String objectId,
                                             String sessionId)
                                      throws ServerSideException
        Get the spare pool list inside the warehouse
        Parameters:
        objectClassName - Object class name
        objectId - Object id
        sessionId - Session token
        Returns:
        Spare pool list
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the warehouse can't be found If any of the classes provided cannot be found
      • getObjectsInSparePool

        List<RemoteObjectLight> getObjectsInSparePool​(String poolId,
                                                      int limit,
                                                      String sessionId)
                                               throws ServerSideException
        Get the objects list inside the spare pool
        Parameters:
        poolId - Spare pool id
        limit - Result limit. -1 To return all
        sessionId - Session token
        Returns:
        Object list
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the spare pool can't be found
      • createWarehouse

        String createWarehouse​(String poolId,
                               String poolClass,
                               String[] attributeNames,
                               String[] attributeValues,
                               String templateId,
                               String sessionId)
                        throws ServerSideException
        Creates a warehouse
        Parameters:
        poolId - Warehouse pool id
        poolClass - This warehouse is going to be instance of
        attributeNames - Attributes to be set in the new service. Null or empty array for none
        attributeValues - Attributes to be set in the new service (values). Null for none. The size of this array must match attributeNames size
        templateId - Template to be used. Use -1 to not use any template
        sessionId - Session id token
        Returns:
        The id of the newly created warehouse
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the warehouse pool cannot be found If the provided class cannot be found
      • deleteWarehouse

        void deleteWarehouse​(String warehouseClass,
                             String warehouseId,
                             String sessionId)
                      throws ServerSideException
        Deletes a warehouse
        Parameters:
        warehouseClass - Warehouse class name
        warehouseId - Warehouse id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the warehouse cannot be found
      • createPoolInWarehouse

        String createPoolInWarehouse​(String warehouseClass,
                                     String warehouseId,
                                     String poolName,
                                     String poolDescription,
                                     String instancesOfClass,
                                     String sessionId)
                              throws ServerSideException
        Creates a spare pool
        Parameters:
        warehouseClass - The parent(warehouse) class name
        warehouseId - The parent(warehouse) id
        poolName - Service Pool name
        poolDescription - Service Pool description
        instancesOfClass - What kind of objects can this pool contain?
        sessionId - Session id token
        Returns:
        The id of the new spare pool
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the warehouse cannot be found If the provided class cannot be found
      • deleteSparePool

        void deleteSparePool​(String poolId,
                             String poolClass,
                             String sessionId)
                      throws ServerSideException
        Deletes a spare pool
        Parameters:
        poolId - Spare pool id
        poolClass - Spare pool class
        sessionId - Session id token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the provided class cannot be found If the spare pool cannot be found
      • createSparePart

        String createSparePart​(String poolId,
                               String poolClass,
                               String[] attributeNames,
                               String[] attributeValues,
                               String templateId,
                               String sessionId)
                        throws ServerSideException
        Creates a spare part
        Parameters:
        poolId - Spare pool id
        poolClass - This spare part is going to be instance of
        attributeNames - Attributes to be set in the new service. Null or empty array for none
        attributeValues - Attributes to be set in the new service (values). Null for none. The size of this array must match attributeNames size
        templateId - Template to be used. Use -1 to not use any template
        sessionId - Session id token
        Returns:
        The id of the newly created spare part
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the spare pool cannot be found If the provided class cannot be found
      • associatePhysicalNodeToWarehouse

        void associatePhysicalNodeToWarehouse​(String objectClass,
                                              String objectId,
                                              String warehouseClass,
                                              String warehouseId,
                                              String sessionId)
                                       throws ServerSideException
        Associates an object (a resource) to an existing warehouse or virtual warehouse
        Parameters:
        objectClass - Object class
        objectId - Object id
        warehouseClass - Warehouse class
        warehouseId - Warehouse id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found
      • associatesPhysicalNodeToWarehouse

        void associatesPhysicalNodeToWarehouse​(String[] objectClass,
                                               String[] objectId,
                                               String warehouseClass,
                                               String warehouseId,
                                               String sessionId)
                                        throws ServerSideException
        Associates a list of objects (resources) to an existing warehouse or virtual warehouse
        Parameters:
        objectClass - Object class
        objectId - Object id
        warehouseClass - Warehouse class
        warehouseId - Warehouse id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found
      • releasePhysicalNodeFromWarehouse

        void releasePhysicalNodeFromWarehouse​(String warehouseClass,
                                              String warehouseId,
                                              String targetId,
                                              String sessionId)
                                       throws ServerSideException
        Releases an object from a warehouse or virtual warehouse that is using it
        Parameters:
        warehouseClass - Warehouse class
        warehouseId - Warehouse id
        targetId - target object id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If the class can not be found If the object activity log could no be found
      • moveObjectsToWarehousePool

        void moveObjectsToWarehousePool​(String targetClass,
                                        String targetOid,
                                        String[] objectClasses,
                                        String[] objectOids,
                                        String sessionId)
                                 throws ServerSideException
        Moves objects from their current parent to a warehouse pool target object.
        Parameters:
        targetClass - New parent object id
        targetOid - The new parent's oid
        objectClasses - Class names of the objects to be moved
        objectOids - Oids of the objects to be moved
        sessionId - Session token
        Throws:
        ServerSideException - If the object's or new parent's class can't be found If the object or its new parent can't be found If the update can't be performed due to a business rule
      • moveObjectsToWarehouse

        void moveObjectsToWarehouse​(String targetClass,
                                    String targetOid,
                                    String[] objectClasses,
                                    String[] objectOids,
                                    String sessionId)
                             throws ServerSideException
        Moves objects from their current parent to a target object.
        Parameters:
        targetClass - New parent object id
        targetOid - The new parent's oid
        objectClasses - Class names of the objects to be moved
        objectOids - Oids of the objects to be moved
        sessionId - Session token
        Throws:
        ServerSideException - If the object's or new parent's class can't be found If the object or its new parent can't be found If the update can't be performed due to a business rule
      • getBGPMap

        List<RemoteLogicalConnectionDetails> getBGPMap​(List<String> mappedBgpLinksIds,
                                                       String sessionId)
                                                throws ServerSideException
        Creates/updates a map of the BGPLinks
        Parameters:
        mappedBgpLinksIds - BGPLinks that are already mapped, it can be an empty array if nothing is mapped of if the whole map should be generated again.
        sessionId - The session token
        Returns:
        A list of BGPlinks with their endPoints(ports) and the CommunicationsElements parents of the ports
        Throws:
        ServerSideException - If the structure is invalid, or the process definition could not be found or one of the properties is malformed or have an unexpected name
      • createOSPView

        long createOSPView​(String name,
                           String description,
                           byte[] content,
                           String sessionId)
                    throws ServerSideException
        Creates an Outside Plant View
        Parameters:
        name - The name of the new view
        description - The description of the new view
        content - The XML document with the contents of the view. The format of the XML document is consistent with the other views
        sessionId - Session token
        Returns:
        The id of the newly created view
        Throws:
        ServerSideException - If the name is empty.
      • getOSPView

        RemoteViewObject getOSPView​(long viewId,
                                    String sessionId)
                             throws ServerSideException
        Retrieves the specific information about an existing OSP view
        Parameters:
        viewId - The id of the view
        sessionId - The session token
        Returns:
        An object containing the view details and structure
        Throws:
        ServerSideException - If the view could not be found
      • updateOSPView

        void updateOSPView​(long viewId,
                           String name,
                           String description,
                           byte[] content,
                           String sessionId)
                    throws ServerSideException
        Updates an existing OSP view
        Parameters:
        viewId - The id of the view
        name - The new name of the view. Null if to remain unchanged
        description - The new description of the view. Null if to remain unchanged
        content - The new content of the view. Null if to remain unchanged
        sessionId - The session token
        Throws:
        ServerSideException - If the view could not be found or if the new name (if applicable) is empty
      • deleteOSPView

        void deleteOSPView​(long viewId,
                           String sessionId)
                    throws ServerSideException
        Deletes an existing OSP view
        Parameters:
        viewId - The id of the view to be deleted
        sessionId - The session token
        Throws:
        ServerSideException - If the view could not be found
      • getIPAddress

        String getIPAddress()
        Gets the IP address from the client issuing the request
        Returns:
        the IP address as string
      • createCustomerPool

        String createCustomerPool​(String poolName,
                                  String poolDescription,
                                  String sessionId)
                           throws ServerSideException
        Creates a Customer Pool
        Parameters:
        poolName - Customer Pool name
        poolDescription - Customer Pool description
        sessionId - Session id token
        Returns:
        The id of the new Customer Pool
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getCustomerPools

        List<RemotePool> getCustomerPools​(String sessionId)
                                   throws ServerSideException
        Gets the project pools
        Parameters:
        sessionId - Session id token
        Returns:
        The list of customer pools
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getCustomerPool

        RemotePool getCustomerPool​(String poolId,
                                   String poolClass,
                                   String sessionId)
                            throws ServerSideException
        Gets a customer pool
        Parameters:
        poolId - The customer pool id
        poolClass - The customer pool class
        sessionId - Session id token
        Returns:
        A detailed representation of the requested customer pool
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • updateCustomerPool

        void updateCustomerPool​(String poolId,
                                String poolClass,
                                String poolName,
                                String poolDescription,
                                String sessionId)
                         throws ServerSideException
        Updates a customer pool
        Parameters:
        poolId - The customer pool id
        poolClass - The customer pool class
        poolName - The customer pool name
        poolDescription - The customer pool description
        sessionId - Session id token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • deleteCustomerPool

        void deleteCustomerPool​(String poolId,
                                String poolClass,
                                String sessionId)
                         throws ServerSideException
        Deletes a customer pool
        Parameters:
        poolId - The customer pool id
        poolClass - The customer pool class
        sessionId - Session id token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • createCustomer

        String createCustomer​(String poolId,
                              String customerClass,
                              String[] attributeNames,
                              String[] attributeValues,
                              String sessionId)
                       throws ServerSideException
        Creates a customer
        Parameters:
        poolId - Parent pool id
        customerClass - This customer is going to be instance of
        attributeNames - Attributes to be set in the new customer. Null or empty array for none
        attributeValues - Attributes to be set in the new customer (values). Null for none. The size of this array must match attributeNames size
        sessionId - Session id token
        Returns:
        The id of the newly created customer
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getAllCustomers

        List<RemoteObjectLight> getAllCustomers​(List<StringPair> filters,
                                                int page,
                                                int limit,
                                                String sessionId)
                                         throws ServerSideException
        Gets all the customers
        Parameters:
        filters - Attributes to filter for
        page - Page number of results to skip. Use -1 to retrieve all
        limit - Max number of results. Use -1 to retrieve all
        sessionId - Session token
        Returns:
        All customers
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getCustomersInPool

        List<RemoteObjectLight> getCustomersInPool​(String poolId,
                                                   String className,
                                                   int page,
                                                   int limit,
                                                   String sessionId)
                                            throws ServerSideException
        Retrieves the list of customers from a pool
        Parameters:
        poolId - Parent pool id
        className - A given className to retrieve a set of customers of that className form the pool
        page - Page number of results to skip. Use -1 to retrieve all
        limit - Max number of results. Use -1 to retrieve all
        sessionId - Session token
        Returns:
        The list of customers inside the pool
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getCustomer

        RemoteObject getCustomer​(String customerClass,
                                 String customerId,
                                 String sessionId)
                          throws ServerSideException
        Gets the detailed information about a customer
        Parameters:
        customerClass - Customer class name
        customerId - Customer id
        sessionId - Session token
        Returns:
        A detailed representation of the requested customer
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • updateCustomer

        void updateCustomer​(String customerClass,
                            String customerId,
                            List<StringPair> attributes,
                            String sessionId)
                     throws ServerSideException
        Updates a customer
        Parameters:
        customerClass - Customer class name
        customerId - Customer id
        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-).
        sessionId - Session token
        Throws:
        ServerSideException - ServerSideException Generic exception encapsulating any possible error raised at run time
      • deleteCustumer

        void deleteCustumer​(String customerClass,
                            String customerId,
                            String sessionId)
                     throws ServerSideException
        Deletes a customer
        Parameters:
        customerClass - Customer class name
        customerId - Customer id
        sessionId - Session token
        Throws:
        ServerSideException - ServerSideException Generic exception encapsulating any possible error raised at run time
      • createServicePool

        String createServicePool​(String customerClass,
                                 String customerId,
                                 String poolName,
                                 String poolDescription,
                                 String sessionId)
                          throws ServerSideException
        Creates a Service Pool
        Parameters:
        customerClass - The parent class name
        customerId - The parent id
        poolName - Service Pool name
        poolDescription - Service Pool description
        sessionId - Session id token
        Returns:
        The id of the new Service Pool
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getServicePoolsInCostumer

        List<RemotePool> getServicePoolsInCostumer​(String customerClass,
                                                   String customerId,
                                                   String servicePoolClass,
                                                   String sessionId)
                                            throws ServerSideException
        Retrieves the pools associated to a particular customer
        Parameters:
        customerClass - The parent customer class name
        customerId - The parent customer id
        servicePoolClass - The class name used to filter the results. This class should be GenericService
        sessionId - Session id token
        Returns:
        The service pools list
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getServicePool

        RemotePool getServicePool​(String poolId,
                                  String poolClass,
                                  String sessionId)
                           throws ServerSideException
        Gets the detailed information about a service pool
        Parameters:
        poolId - The service pool id
        poolClass - The service pool class name
        sessionId - Session id token
        Returns:
        A detailed representation of the requested service pool
        Throws:
        ServerSideException
      • updateServicePool

        void updateServicePool​(String poolId,
                               String poolClass,
                               String poolName,
                               String poolDescription,
                               String sessionId)
                        throws ServerSideException
        Updates a service pool
        Parameters:
        poolId - The service pool id
        poolClass - The service pool class
        poolName - The service pool name
        poolDescription - The service pool description
        sessionId - Session id token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • deleteServicePool

        void deleteServicePool​(String poolId,
                               String poolClass,
                               String sessionId)
                        throws ServerSideException
        Deletes a service pool
        Parameters:
        poolId - The service pool id
        poolClass - The service pool class
        sessionId - Session id token
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • createService

        String createService​(String poolId,
                             String serviceClass,
                             String[] attributeNames,
                             String[] attributeValues,
                             String sessionId)
                      throws ServerSideException
        Creates a service
        Parameters:
        poolId - Parent pool id
        serviceClass - This service is going to be instance of
        attributeNames - Attributes to be set in the new service. Null or empty array for none
        attributeValues - Attributes to be set in the new service (values). Null for none. The size of this array must match attributeNames size
        sessionId - Session id token
        Returns:
        The id of the newly created service
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getAllServices

        List<RemoteObjectLight> getAllServices​(List<StringPair> filters,
                                               int page,
                                               int limit,
                                               String sessionId)
                                        throws ServerSideException
        Gets all the services
        Parameters:
        filters - Attributes to filter for
        page - Page number of results to skip. Use -1 to retrieve all
        limit - Max number of results. Use -1 to retrieve all
        sessionId - Session token
        Returns:
        All services
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getServicesInPool

        List<RemoteObjectLight> getServicesInPool​(String poolId,
                                                  String className,
                                                  int page,
                                                  int limit,
                                                  String sessionId)
                                           throws ServerSideException
        Retrieves the list of services from a pool
        Parameters:
        poolId - Parent pool id
        className - A given className to retrieve a set of services of that className form the pool
        page - Page number of results to skip. Use -1 to retrieve all
        limit - Max number of results. Use -1 to retrieve all
        sessionId - Session token
        Returns:
        The list of services inside the pool
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • getService

        RemoteObject getService​(String serviceClass,
                                String serviceId,
                                String sessionId)
                         throws ServerSideException
        Gets the detailed information about a service
        Parameters:
        serviceClass - Service class name
        serviceId - Service id
        sessionId - Session token
        Returns:
        A detailed representation of the requested service
        Throws:
        ServerSideException - Generic exception encapsulating any possible error raised at run time
      • updateService

        void updateService​(String serviceClass,
                           String serviceId,
                           List<StringPair> attributes,
                           String sessionId)
                    throws ServerSideException
        Updates a service
        Parameters:
        serviceClass - Service class name
        serviceId - Service id
        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-).
        sessionId - Session token
        Throws:
        ServerSideException - ServerSideException Generic exception encapsulating any possible error raised at run time
      • deleteService

        void deleteService​(String serviceClass,
                           String serviceId,
                           String sessionId)
                    throws ServerSideException
        Deletes a service
        Parameters:
        serviceClass - Service class name
        serviceId - Service id
        sessionId - Session token
        Throws:
        ServerSideException - ServerSideException Generic exception encapsulating any possible error raised at run time
      • relateObjectToService

        void relateObjectToService​(String objectClass,
                                   String objectId,
                                   String serviceClass,
                                   String serviceId,
                                   String sessionId)
                            throws ServerSideException
        Associates an object (a resource) to an existing service
        Parameters:
        objectClass - Object class
        objectId - Object id
        serviceClass - service class
        serviceId - service id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found
      • relateObjectsToService

        void relateObjectsToService​(String[] objectClass,
                                    String[] objectId,
                                    String serviceClass,
                                    String serviceId,
                                    String sessionId)
                             throws ServerSideException
        Associates a list of objects (resources) to an existing service
        Parameters:
        objectClass - Object class
        objectId - Object id
        serviceClass - service class
        serviceId - service id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If any of the objects can't be found If any of the objects involved can't be connected (i.e. if it's not an inventory object) If any of the classes provided can not be found
      • releaseObjectFromService

        void releaseObjectFromService​(String serviceClass,
                                      String serviceId,
                                      String objectId,
                                      String sessionId)
                               throws ServerSideException
        Releases an object from a service that is using it
        Parameters:
        serviceClass - Service class
        serviceId - Service id
        objectId - Target object id
        sessionId - Session token
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If the class can not be found If the object activity log could no be found
      • getObjectsRelatedToService

        List<RemoteObjectLight> getObjectsRelatedToService​(String serviceClass,
                                                           String serviceId,
                                                           String sessionId)
                                                    throws ServerSideException
        Gets the objects (resources) associated to a service
        Parameters:
        serviceClass - Service class
        serviceId - Service id
        sessionId - Session token
        Returns:
        A list of services
        Throws:
        ServerSideException - If the user is not allowed to invoke the method If the object can not be found If either the object class or the attribute can not be found