FlashlineRegistry (Oracle© Fusion Middleware Extensibility Framework (REX) for Oracle Enterprise Repository)

Class

Tree

Help

Oracle© Fusion Middleware Extensibility Framework (REX) for Oracle Enterprise Repository
11g Release 1 (11.1.1)
E16598-01

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.flashline.registry.openapi.service.v300
Interface FlashlineRegistry

All Superinterfaces:: java.rmi.Remote

All Known Implementing Classes:: FlashlineRegistrySoapBindingStub

public interface FlashlineRegistry

extends java.rmi.Remote

Provides a user accessible interface to various subsystems within Oracle Enterprise Repository.

Method Summary
`AcceptableValueList`	`acceptableValueListCreate(AuthToken pAuthToken, java.lang.String pListName, AcceptableValue[] pValues)` Creates a new acceptable value list.
`AcceptableValueList[]`	`acceptableValueListQuery(AuthToken pAuthToken, AcceptableValueListCriteria pCriteria)` Searches for all acceptable value lists that contains the specified string (ignoring case)
`AcceptableValueList`	`acceptableValueListRead(AuthToken pAuthToken, long pId)` Read an acceptable value list.
`AcceptableValueList`	`acceptableValueListUpdate(AuthToken pAuthToken, AcceptableValueList pList)` Updates an acceptable value list, modifying both the name of the list and the acceptable values.
`ArtifactStoreBean[]`	`artifactStoreQuery(AuthToken pAuthTokenBean, ArtifactStoreCriteria pArtifactStoreCritera, boolean pCreateIfMissing)` Find an ArtifactStore that matches the criteria.
`void`	`assetAccept(AuthToken pAuthToken, long pID)` Accept an Asset.
`void`	`assetAcceptFiles(AuthToken pAuthToken, long pId, java.lang.String[] pFilenames)`
`void`	`assetActivate(AuthToken pAuthToken, long pAssetID)` Set an Asset's active-status to Active.
`void`	`assetAddRegistrarNote(AuthToken pAuthToken, long pId, java.lang.String pNotes)` Adds a registrar note to the log on the Administration tab
`void`	`assetApplyToProjects(AuthToken pAuthToken, java.lang.String[] pProjectIDs, Asset pAsset)` Apply templates to projects
`Asset`	`assetCreate(AuthToken pAuthToken, java.lang.String pName, java.lang.String pVersion, long pAssetTypeID)` Initial creation of a NEW asset.
`Asset`	`assetCreateFromXML(AuthToken pAuthToken, java.lang.String assetXML)` Initial creation of a NEW asset from an XML representation.
`void`	`assetDeactivate(AuthToken pAuthToken, long pAssetID)` Set an Asset's active-status to Inactive.
`void`	`assetDelete(AuthToken pAuthToken, long pAssetID)` Set an Asset's active-status to Deleted.
`KeyValuePair`	`assetEvaluate(AuthToken pAuthToken, AssetCriteria pCriteria, java.lang.String pEvaluationName)` Evaluate Asset attributes.
`java.lang.String`	`assetEvaluateAgainstAllPolicies(AuthToken pAuthToken, long pAssetID)` Evaluate an asset against all applied policies.
`java.lang.String`	`assetEvaluateAgainstPolicy(AuthToken pAuthToken, long pAssetID, long pPolicyID)` Evaluate an asset against a single applied policy.
`SubmissionFileInfo[]`	`assetGetUnacceptedFiles(AuthToken pAuthToken, long pId)`
`void`	`assetMetadataAccept(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)`
`void`	`assetMetadataCreateDIME(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Creates the metadata entry specified and associates it with the specified asset.
`void`	`assetMetadataCreateSwA(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Creates the metadata entry specified and associates it with the specified asset.
`void`	`assetMetadataEntryDelete(AuthToken pAuthToken, long pMetadataEntryID)` Deletes the specified metadata entry and disassociates it from its parent Asset.
`MetadataEntrySummary[]`	`assetMetadataRead(AuthToken pAuthToken, long pAssetID)` Reads metadata entries associated with the given Asset.
`MetadataEntrySummary[]`	`assetMetadataReadDIME(AuthToken pAuthToken, long pAssetID)` Reads metadata entries associated with the given Asset.
`MetadataEntrySummary[]`	`assetMetadataReadSwA(AuthToken pAuthToken, long pAssetID)` Reads metadata entries associated with the given Asset.
`void`	`assetMetadataUpdate(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Updates metadata entry specified.
`void`	`assetMetadataUpdateDIME(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Updates metadata entry specified.
`void`	`assetMetadataUpdateSwA(AuthToken pAuthToken, long pAssetID, MetadataEntrySummary pMetadataEntrySummary)` Updates metadata entry specified.
`Asset[]`	`assetQuery(AuthToken pAuthtoken, AssetCriteria pCriteria)` Search for Assets.
`int`	`assetQueryCount(AuthToken pAuthToken, AssetCriteria pCriteria)` Count the number of assets that would match a query on a specific criteria.
`AssetSummary[]`	`assetQuerySummary(AuthToken pAuthtoken, AssetCriteria pCriteria)` Search for Assets Summaries.
`Asset`	`assetRead(AuthToken pAuthToken, long pId)` Get an Asset object by Id.
`Asset[]`	`assetReadAppliedPolicies(AuthToken pAuthToken, long pAssetID)` Search for policies which are assigned to the specified asset
`Project[]`	`assetReadAppliedToProjects(AuthToken pAuthToken, Asset pAsset)` Search for projects which compliance template is applied to.
`Asset[]`	`assetReadArray(AuthToken pAuthToken, long[] pIds)` Get an array of Asset objects from an array of Ids.
`Asset[]`	`assetReadArrayFromSummary(AuthToken pAuthToken, AssetSummary[] pAssetSummaries)` Get an array of Asset objects from an array of AssetSummary objects.
`java.lang.String`	`assetReadCustomDataNode(AuthToken pAuthToken, long pId, java.lang.String pPath)` Get an Asset custom data node's XML by path
`java.lang.String`	`assetReadCustomDataString(AuthToken pAuthToken, long pId, java.lang.String pPath)` Get an Asset custom data node by path
`LogEntry[]`	`assetReadRegistrarNotes(AuthToken pAuthToken, long pId)` Reads the log of registrar notes
`java.lang.String`	`assetReadXml(AuthToken pAuthToken, long pId)` Retrieve the xml representation for an asset.
`void`	`assetRegister(AuthToken pAuthToken, long pID)` Registers an Asset.
`void`	`assetRemoveAppliedToProjects(AuthToken pAuthToken, java.lang.String[] pProjectIDs, Asset pAsset)` Removes templates from projects.
`void`	`assetRetire(AuthToken pAuthToken, long pAssetID)` Set an Asset's active-status to Retired.
`void`	`assetSubmit(AuthToken pAuthToken, long pID)` Submit an Asset.
`void`	`assetTabApprove(AuthToken pAuthTokenBean, long pAssetId, long pTabId)` Approve an asset's tab.
`TabBean`	`assetTabRead(AuthToken pAuthTokenBean, long pAssetId, long pTabTypeBeanId)` Read an asset's tab for a specific TabType.
`TabBean[]`	`assetTabsRead(AuthToken pAuthTokenBean, long pAssetId)` Retrieve all of the Tabs available for an asset.
`void`	`assetTabUnapprove(AuthToken pAuthTokeBean, long pAssetId, long pTabId)` Unapprove an asset's tab.
`AssetType`	`assetTypeCreate(AuthToken pAuthToken, java.lang.String pName)` Creates a new asset type that contains minimal metadata elements.
`AssetType`	`assetTypeCreateClone(AuthToken pAuthToken, long pBaseAssetTypeID, java.lang.String pName)` Creates a new asset type based on an existing asset type.
`AssetType`	`assetTypeCreateComplianceTemplate(AuthToken pAuthToken, java.lang.String pName)` Creates a new compliance template that contains minimal metadata elements.
`void`	`assetTypeDelete(AuthToken pAuthToken, long pId)` Deletes an existing asset type based on an ID.
`com.oracle.registry.openapi.entity.EntityArtifactRule[]`	`assetTypeGetEntityArtifactRules(AuthToken pAuthTokenBean, long pAssetTypeId)` Returns an array of EntityArtifactRule for the given Asset Type ID.
`AssetType[]`	`assetTypeQuery(AuthToken pAuthToken, AssetTypeCriteria pCriteria)` Searches for all asset types whose names contain the specified string (ignoring case)
`AssetType`	`assetTypeRead(AuthToken pAuthToken, long pId)` Creates a new compliance template that contains minimal metadata elements.
`java.lang.String`	`assetTypeSchemaRead(AuthToken pAuthToken, long pId)` Get the xml schema for an asset type.
`TabTypeBean[]`	`assetTypeTabsRead(AuthToken pAuthTokenBean, long pAssetTypeId)` Read an assettype's tabs.
`AssetType`	`assetTypeUpdate(AuthToken pAuthToken, AssetType pAssetType)` Updates an existing asset type.
`void`	`assetUnAccept(AuthToken pAuthToken, long pID)` Unaccept an Asset.
`void`	`assetUnRegister(AuthToken pAuthToken, long pID)` Unregister an Asset.
`void`	`assetUnSubmit(AuthToken pAuthToken, long pID)` Unsubmit an Asset.
`Asset`	`assetUpdate(AuthToken pAuthToken, Asset pAsset)` Updates an Asset, saving any modifications that were made to it.
`Asset`	`assetUpdateAppliedPolicies(AuthToken pAuthToken, long pAssetID, long[] pAppliedPolicies)` Specifies which policies are associated with this asset.
`Asset`	`assetUpdateCustomDataNode(AuthToken pAuthToken, long pAssetID, java.lang.String pPath, java.lang.String pValue)` Updates an Asset with a specified custom-data node modification.
`Asset`	`assetUpdateCustomDataNodeFromStringArray(AuthToken pAuthToken, long pAssetID, java.lang.String[] pPath, java.lang.String[] pValue)` Updates an Asset with a specified list of custom-data value modifications.
`Asset`	`assetUpdateCustomDataString(AuthToken pAuthToken, long pAssetID, java.lang.String pPath, java.lang.String pValue)` Updates an Asset with a specified custom-data value modification.
`Asset`	`assetUpdateCustomDataStringArray(AuthToken pAuthToken, long pAssetID, java.lang.String[] pPath, java.lang.String[] pValue)` Updates an Asset with a specified list of custom-data value modifications.
`void`	`assetUploadFiles(AuthToken pAuthToken, long pAssetID, java.lang.String[] pFilenames)` Upload files into the Flashline Registry UPLOAD repository.
`AuthToken`	`authTokenCreate(java.lang.String userName, java.lang.String credential)` Authenticates a user, creating an AuthToken that is used to prove who the user is.
`AuthToken`	`authTokenCreateWithLicense(java.lang.String userName, java.lang.String credential, java.lang.String license)` Authenticates a user, creating an AuthToken that is used to prove who the user is.
`void`	`authTokenDelete(AuthToken authToken)` Invalidates the OER authentication for a user.
`void`	`authTokenValidate(AuthToken authToken)` Tests the OER authentication token for a user.
`Categorization`	`categorizationChildCreate(AuthToken pAuthToken, java.lang.String pCategorizationName, CategorizationType pCategorizationType, Categorization pSuper)` Create a child categorization.
`Categorization[]`	`categorizationChildRead(AuthToken pAuthToken, CategorizationType pCategorizationType, Categorization pCategorization, boolean active)` Retrieve all child categorizations for a given categorization.
`Categorization`	`categorizationCreate(AuthToken pAuthToken, java.lang.String pCategorizationName, CategorizationType pCategorizationType)` Create a categorization
`Categorization`	`categorizationDeactivate(AuthToken pAuthToken, Categorization pCategorization, CategorizationType pCategorizationType)` Deactivate Categorization
`Categorization`	`categorizationReactivate(AuthToken pAuthToken, Categorization pCategorization, CategorizationType pCategorizationType)` Reactivate Categorization
`Categorization`	`categorizationRead(AuthToken pAuthToken, long pCategorizationID)` Retrieve categorization
`Categorization[]`	`categorizationReadByType(AuthToken pAuthToken, CategorizationType pCategorizationType, boolean active, boolean fullTree)` Retrieve all categorizations for a categorization types active set to true returns active categorizations fullTree set to true returns categories and their children
`CategorizationType`	`categorizationTypeCreate(AuthToken pAuthToken, java.lang.String pName, java.lang.String pSingularDisplay, java.lang.String pPluralDisplay, boolean pExclusiveAssign, boolean pProjectAssign)` Creates a categorization type
`void`	`categorizationTypeDelete(AuthToken pAuthToken, CategorizationType pCategorizationType)` Delete Categorization Type.
`CategorizationType[]`	`categorizationTypeQuery(AuthToken pAuthToken, CategorizationTypeCriteria pCriteria)` Retrieve categorization types for a given set of query criteria.
`CategorizationType`	`categorizationTypeRead(AuthToken pAuthToken, long pCategorizationTypeID)` Read categorization type.
`CategorizationType`	`categorizationTypeUpdate(AuthToken pAuthToken, CategorizationType pType)` This only updates the categorization Type, not all of the sub categorizations
`Categorization`	`categorizationUpdate(AuthToken pAuthToken, Categorization pCategorization, CategorizationType pCategorizationType)` Update a single categorization
`Categorization[]`	`categorizationUpdateArray(AuthToken pAuthToken, Categorization[] pCategorizations, CategorizationType pCategorizationType)` Update a list of categorizations within a categorization type.
`java.lang.String`	`configGetWebResourcePath()` Gets the Web server path to the location where Web resources are stored.
`Contact`	`contactCreate(AuthToken pAuthToken, java.lang.String pName)` Creates a new contact.
`void`	`contactDelete(AuthToken pAuthToken, long pID)` Deletes a contact.
`Contact[]`	`contactQuery(AuthToken pAuthToken, ContactCriteria pQuery)` Searches for all contacts whose names contain the specified criteria.
`Contact`	`contactRead(AuthToken pAuthToken, long pID)` Reads a contact by ID.
`Contact`	`contactUpdate(AuthToken pAuthToken, Contact pContact)` Updates a contact.
`java.lang.String[]`	`customAccessSettingDefaultNamesGet(AuthToken pAuthToken, java.lang.String pType)` Retrieve an array of the default custom access setting names of a particular type.
`java.lang.String[]`	`customAccessSettingNamesGet(AuthToken pAuthToken, java.lang.String pType)` Retrieve an array of existing cutom access setting names.
`java.lang.String[]`	`customAccessSettingTypesGet(AuthToken pAuthToken)` Retrieve an array of custom access setting types.
`Department`	`departmentCreate(AuthToken pAuthToken, java.lang.String pName, java.lang.String pDescription)` Creates a new Department.
`Department[]`	`departmentQuery(AuthToken pAuthToken, DepartmentCriteria pCriteria)` Search for a department.
`Department`	`departmentRead(AuthToken pAuthToken, java.lang.String pKey)` Gets a department by name.
`Department`	`departmentUpdate(AuthToken pAuthToken, Department pDepartment)` Update a department.
`void`	`exportCheckPermission(AuthToken pAuthToken)` Checks the permission level of the user represented by OER authentication credentials contained in pAuthToken to determine if they are allowed to perform an export.
`void`	`exportCleanup(AuthToken pAuthToken, ImpExpJob pJob)` Cleans up a COMPLETED, FAILED, or CANCELLED export job.
`ImpExpJob`	`exportExecute(AuthToken pAuthToken, java.lang.String pExportFormat, java.lang.String[] pExportFormatQualifiers, java.lang.String pDesc, java.lang.String pQueryFormat, java.lang.String pQuery)` Starts an export job running on the server.
`byte[]`	`exportGetAuditB64(AuthToken pAuthToken, ImpExpJob pJobBean, java.lang.String pAuditFormat)` Returns the Audit results of the export operation specified by pJobBean.
`void`	`exportGetAuditDIME(AuthToken pAuthToken, ImpExpJob pJobBean, java.lang.String pAuditFormat)` Returns the Audit results of the export operation specified by pJobBean.
`void`	`exportGetAuditSwA(AuthToken pAuthToken, ImpExpJob pJobBean, java.lang.String pAuditFormat)` Returns the Audit results of the export operation specified by pJobBean.
`AuditMsg`	`exportGetLatestAuditMsg(AuthToken pAuthToken, ImpExpJob pJobBean)` Returns the most recently added Audit message for the given export job.
`byte[]`	`exportGetResultsB64(AuthToken pAuthToken, ImpExpJob pJob)` Returns the results of the export operation (i.e., the "payload") specified by pJobBean.
`void`	`exportGetResultsDIME(AuthToken pAuthToken, ImpExpJob pJob)` Returns the results of the export operation (i.e., the "payload") specified by pJobBean.
`void`	`exportGetResultsSwA(AuthToken pAuthToken, ImpExpJob pJob)` Returns the results of the export operation (i.e., the "payload") specified by pJobBean.
`void`	`exportKill(AuthToken pAuthToken, ImpExpJob pJob)` Terminates a running export job.
`ImpExpJob[]`	`exportListJobs(AuthToken pAuthToken)` Returns a list of export jobs currently defined in the system.
`ImpExpJob`	`exportStatus(AuthToken pAuthToken, ImpExpJob pJob)` Retrieves an updated description of the current status of the export job.
`ExtractionDownload[]`	`extractionCreate(AuthToken pAuthToken, long pProjectId, long[] pAssetIDs)` Create Extraction
`ExtractionDownload[]`	`extractionCreateForUser(AuthToken pAuthToken, long pProjectID, long[] pAssetIDs, RegistryUser pRbacRegistrySecUserBean)` Create Extraction
`RegistryUser[]`	`extractionGetHiddenAssetUsers(AuthToken pAuthToken, long pProjectID)` Returns an array of users who can view assets consumed by a project that the owner of the AuthTokenBean cannot.
`Extraction`	`extractionRead(AuthToken pAuthToken, long pExtractionID)` Read Extraction
`Extraction[]`	`extractionReadAssetExtractions(AuthToken pAuthToken, long pProjectID, long pAssetID, boolean pActive)` Read Extractions
`Extraction`	`extractionReadByProjectAndAsset(AuthToken pAuthToken, long pProjectID, long pAssetID)` Read Extraction
`ExtractionDownload[]`	`extractionReadExtractionDownloads(AuthToken pAuthToken, Extraction pExtraction)` Read extractable files
`IExtraction`	`extractionReadExtractionStates(AuthToken pAuthToken)` Read Extraction States
`FileInfo[]`	`extractionReadFileInfos(AuthToken pAuthToken, Extraction pExtraction)` Read file info
`Extraction[]`	`extractionReadProjectExtractions(AuthToken pAuthToken, long pProjectID, boolean pActive)` Read Extractions
`Categorization[]`	`extractionReadRejectionReasons(AuthToken pAuthToken)` Read rejection reasons
`Asset[]`	`extractionReadRelatedAssets(AuthToken pAuthToken, long pAssetID)` Read related Assets
`Extraction[]`	`extractionReadUserExtractions(AuthToken pAuthToken, boolean pActive)` Read Extractions
`Extraction`	`extractionReject(AuthToken pAuthToken, Extraction pExtraction, Categorization pCategorization, java.lang.String pComments)` Reject an extraction.
`void`	`extractionResetDatabase()`
`Extraction`	`extractionStillEvaluating(AuthToken pAuthToken, Extraction pExtraction)` Update Extraction state
`Extraction`	`extractionTentativelyAccept(AuthToken pAuthToken, Extraction pExtraction)` Update Extraction state
`Extraction`	`extractionUpdateSurvey(AuthToken pAuthToken, Extraction pExtraction, SurveyTaken pSurveyTaken)` Update Extraction status
`Extraction`	`extractionUpdateSurveyForUser(AuthToken pAuthToken, Extraction pExtraction, SurveyTaken pSurveyTaken, RegistryUser pRbacRegistrySecUserBean)` Update Extraction status
`long`	`getAssetMaxID()`
`FileInfo[]`	`getLatestArtifacts(AuthToken pAuthToken, long pAbstractAssetId, boolean pIsService)` This is a convenience method to ease retrieving artifacts associated with abstract assets in the post-3.0 ALER model.
`void`	`importCheckPermission(AuthToken pAuthToken)` Checks the permission level of the user represented by OER authentication credentials contained in pAuthToken to determine if they are allowed to perform an import.
`void`	`importCleanup(AuthToken pAuthToken, ImpExpJob pJob)` Cleans up a COMPLETED, FAILED, or CANCELLED import job.
`ImpExpJob`	`importExecute(AuthToken pAuthToken, java.lang.String pImportFormat, java.lang.String[] pImportFormatQualifiers, java.lang.String pDesc, byte[] pPayload)` Import a file.
`byte[]`	`importGetAuditB64(AuthToken pAuthToken, ImpExpJob pJobBean, java.lang.String pAuditFormat)` Returns the Audit results of the import operation specified by pJobBean.
`void`	`importGetAuditDIME(AuthToken pAuthToken, ImpExpJob pJobBean, java.lang.String pAuditFormat)` Returns the Audit results of the import operation specified by pJobBean.
`void`	`importGetAuditSwA(AuthToken pAuthToken, ImpExpJob pJobBean, java.lang.String pAuditFormat)` Returns the Audit results of the import operation specified by pJobBean.
`AuditMsg`	`importGetLatestAuditMsg(AuthToken pAuthToken, ImpExpJob pJobBean)` Returns the most recently added Audit message for the given import job.
`void`	`importKill(AuthToken pAuthToken, ImpExpJob pJob)` Terminates a running import job.
`ImpExpJob[]`	`importListJobs(AuthToken pAuthToken)` Returns a list of import jobs currently defined in the system.
`ImpExpJob`	`importStatus(AuthToken pAuthToken, ImpExpJob pJob)` Retrieves an updated description of the current status of the import job.
`MetadataEntrySummary`	`metadataEntryCreateDIME(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Creates a new metadata entry.
`MetadataEntrySummary`	`metadataEntryCreateSwA(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Creates a new metadata entry.
`void`	`metadataEntryDelete(AuthToken pAuthToken, EntityUUID pEntityUUID)` Deletes a metadata-entry.
`MetadataEntrySummary[]`	`metadataEntryQuery(AuthToken pAuthToken, MetadataEntryCriteria pQuery)` Searches for metadata-entries by entry type or associated entity.
`MetadataEntrySummary`	`metadataEntryReadDIME(AuthToken pAuthToken, EntityUUID pEntityUUID)` Reads a metadata-entry by UUID.
`MetadataEntrySummary`	`metadataEntryReadDIME(AuthToken pAuthToken, long pID)` Reads a metadata-entry by ID.
`MetadataEntrySummary`	`metadataEntryReadSwA(AuthToken pAuthToken, EntityUUID pEntityUUID)` Reads a metadata-entry by UUID.
`MetadataEntrySummary`	`metadataEntryReadSwA(AuthToken pAuthToken, long pID)` Reads a metadata-entry by ID.
`MetadataEntryTypeSummary`	`metadataEntryTypeCreate(AuthToken pAuthToken, java.lang.String pName)` Creates a new metadata entry type.
`void`	`metadataEntryTypeDelete(AuthToken pAuthToken, long pID)` Deletes a metadata entry type.
`MetadataEntryTypeSummary[]`	`metadataEntryTypeQuery(AuthToken pAuthToken, MetadataEntryTypeCriteria pQuery)` Searches for all metadata entry types whose names contain the specified criteria.
`MetadataEntryTypeSummary`	`metadataEntryTypeRead(AuthToken pAuthToken, long pID)` Reads a metadata entry type by ID.
`MetadataEntryTypeSummary`	`metadataEntryTypeUpdate(AuthToken pAuthToken, MetadataEntryTypeSummary pMetadataEntryType)` Updates a metadata entry type.
`MetadataEntrySummary`	`metadataEntryUpdateDIME(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Updates a metadata-entry.
`MetadataEntrySummary`	`metadataEntryUpdateSwA(AuthToken pAuthToken, MetadataEntrySummary pMetadataEntrySummary)` Updates a metadata-entry.
`void`	`notificationCreate(AuthToken pAuthTokenBean, java.lang.String pTemplateType, java.lang.String[] pRecipients, NameValue[] pSubstitutions)` Create a new notification.
`java.lang.String[]`	`notificationSubstitutionsRead(AuthToken pAuthTokenBean, java.lang.String pTemplateType)` Retrieve the substitution names available for a notification template type.
`ProjectAssetValue[]`	`projectAssetValueRead(AuthToken pAuthToken, long pProjectID, long pAssetID)` Read ProjectAssetValues
`ProjectAssetValue`	`projectAssetValueReadForUser(AuthToken pAuthToken, long pProjectID, long pAssetID, RegistryUser pRbacRegistrySecUserBean)` Read ProjectAssetValue
`ProjectAssetValueSummary`	`projectAssetValueReadSummary(AuthToken pAuthToken, long pProjectID, long pAssetID)` Read ProjectAssetValueSummary
`AssetUsageType[]`	`projectAssetValueReadTypes(AuthToken pAuthToken)` Read AssetUsageTypes
`ProjectAssetValue`	`projectAssetValueUpdate(AuthToken pAuthToken, ProjectAssetValue pProjectAssetValue, java.lang.String pSelection)` Update ProjectAssetValue
`Project`	`projectCreate(AuthToken pAuthToken, Project pProject, ProjectEntities pProjectEntities)` Create a project.
`Project[]`	`projectQuery(AuthToken pAuthToken, ProjectCriteria pQuery)` Search for a project and return an array of Projects
`ProjectSummary[]`	`projectQuerySummary(AuthToken pAuthToken, ProjectCriteria pQuery)` Search for a project and return an array of ProjectSummaries
`Project`	`projectRead(AuthToken pAuthToken, long pId)` Read a project
`RelatedEntity[]`	`projectReadAppliedComplianceTemplates(AuthToken pAuthToken, Project pProject)` Read applied Compliance Templates
`Project[]`	`projectReadArray(AuthToken pAuthToken, long[] pIds)` Get an array of Project objects from an array of Ids.
`Project[]`	`projectReadArrayFromSummary(AuthToken pAuthToken, ProjectSummary[] pProjectSummaries)` Get an array of Project objects from an array of ProjectSummary objects.
`ProjectAsset[]`	`projectReadAssets(AuthToken pAuthToken, Project pProject)` Read extraction Asset IDs of a project
`java.lang.String[]`	`projectReadChildProjectIDs(AuthToken pAuthToken, Project pProject)` Read related child project IDs.
`Project[]`	`projectReadChildProjects(AuthToken pAuthToken, Project pProject)` Read related child projects.
`java.lang.String[]`	`projectReadExtractionAssetIDs(AuthToken pAuthToken, Project pProject)` Read extraction Asset IDs of a project
`Extraction[]`	`projectReadExtractions(AuthToken pAuthToken, Project pProject)` Read extractions of a project
`java.lang.String[]`	`projectReadLeaderIDs(AuthToken pAuthToken, Project pProject)` Read leader IDs assigned to a project
`RegistryUser[]`	`projectReadLeaders(AuthToken pAuthToken, Project pProject)` Read leaders assigned to a project
`java.lang.String[]`	`projectReadMemberIDs(AuthToken pAuthToken, Project pProject)` Read user IDs assigned to a project
`RegistryUser[]`	`projectReadMembers(AuthToken pAuthToken, Project pProject)` Read users assigned to a project
`java.lang.String[]`	`projectReadParentProjectIDs(AuthToken pAuthToken, Project pProject)` Read related parent project IDs.
`Project[]`	`projectReadParentProjects(AuthToken pAuthToken, Project pProject)` Read related parent projects.
`Asset[]`	`projectReadPrescribedAssets(AuthToken pAuthToken, Project pProject)` Method projectReadPrescribedAssets.
`java.lang.String[]`	`projectReadProducedAssetIDs(AuthToken pAuthToken, Project pProject)` Read produced asset IDs of a project
`Asset[]`	`projectReadProducedAssets(AuthToken pAuthToken, Project pProject)` Read produced assets of a project
`ProjectUserType`	`projectReadUserTypes(AuthToken pAuthToken)` Reads project user types
`void`	`projectReassignExtractions(AuthToken pAuthToken, Project pProject, ExtractionReassignmentDecision[] pReassignIDs)` Assign extractions from one user of a project to another user on the same or different project.
`void`	`projectReassignUsers(AuthToken pAuthToken, Project pProject, ExtractionReassignmentDecision[] pReassignIDs)` Reassigns user and their extractions from one project to another
`Project`	`projectUpdate(AuthToken pAuthToken, Project pProject, ProjectEntities pProjectEntities)` Get an array of Project objects from an array of ProjectSummary objects.
`Results`	`projectValidate(AuthToken pAuthToken, Project pProject, ProjectEntities pProjectEntities)` Validate project.
`boolean`	`rbacHasPermission(AuthToken pAuthToken, long pUserID, java.lang.String[] pRoleContextNames, java.lang.String pPermissionName)` Determine if a user has permission for a given set of rolecontexts, and a permission name.
`RelationshipType`	`relationshipTypeCreate(AuthToken pAuthToken, java.lang.String pName)` Creates a new relationship type.
`void`	`relationshipTypeDelete(AuthToken pAuthToken, long pID)` Deletes a relationship type.
`RelationshipType[]`	`relationshipTypeQuery(AuthToken pAuthToken, RelationshipTypeCriteria pQuery)` Searches for all relationship types that match the specified criteria.
`RelationshipType`	`relationshipTypeRead(AuthToken pAuthToken, long pID)` Reads a relationship type based on a unique ID.
`RelationshipType`	`relationshipTypeUpdate(AuthToken pAuthToken, RelationshipType pRelationshipType)` Updates a relationship type object.
`java.lang.String`	`repositoryFileTranslator(AuthToken pAuthToken, FileInfo pFileInfo)` Given a FileInfo object it returns the download path for the file.
`void`	`retrieveAndRecordUsageOfArtifactCollectionAsDIME(AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId)` This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root.
`void`	`retrieveAndRecordUsageOfArtifactCollectionAsDIME(AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId, RegistryUser pRbacRegistrySecUserBean)` This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root.
`void`	`retrieveAndRecordUsageOfArtifactCollectionAsSwa(AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId)` This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root.
`void`	`retrieveAndRecordUsageOfArtifactCollectionAsSwa(AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId, RegistryUser pRbacRegistrySecUserBean)` This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root.
`void`	`retrieveArtifactCollectionAsDIME(AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId)` This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root.
`void`	`retrieveArtifactCollectionAsSwa(AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId)` This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root.
`Asset`	`retrieveLatestRootArtifact(AuthToken pAuthToken, long pAbstractAssetId)` This method retrieves a the Asset corresponding to the latest introspected root of collections of related artifact assets which are directly connected to the passed abstract asset (i.e.
`Asset[]`	`retrieveRootArtifacts(AuthToken pAuthToken, long pAbstractAssetId)` This method retrieves a set of Assets corresponding to roots of collections of related artifact assets which are directly connected to the passed abstract asset (i.e.
`ReuseDTO`	`reuseDTORead()` This method returns a composite object containing all the information required to display the reuse portlet.
`Role`	`roleCreate(AuthToken pAuthToken, java.lang.String pName, java.lang.String pDesc, boolean pDefaultForNewUser)` Create a new role.
`void`	`roleDelete(AuthToken pAuthToken, java.lang.String pName)` Delete an existing role.
`Role[]`	`roleQuery(AuthToken pAuthToken, RoleCriteria pCriteria)` Serach for roles.
`Role`	`roleRead(AuthToken pAuthToken, java.lang.String pName)` Retrieve an existing role.
`Role`	`roleUpdate(AuthToken pAuthToken, Role pRoleType)` Update an existing role.
`void`	`sfidAddToAsset(AuthToken pAuthToken, SFIDInfo pSFID, long assetID)` Associates a new SFIDInfo object to the asset specified in the SFIDInfo
`SFIDCandidate[]`	`sfidCandidateQuery(AuthToken pAuthToken, SFIDCriteria pCrit)` Deprecated. Not implemented.
`SFIDCandidate[]`	`sfidCandidateSubmit(AuthToken pAuthToken, SFIDCandidate[] pCandidates)` This method submits a set of SFIDCandidates.
`SFIDInfo[]`	`sfidGenerate(AuthToken pAuthToken, int pMethod)` Deprecated. Use `com.oracle.artifact.fingerprint.ArtifactFingerprinter` instead.
`SFIDInfo[]`	`sfidQuery(AuthToken pAuthToken, SFIDCriteria pCrit)` Get all of the SFID values from all of the assets extracted to the specified project
`java.lang.String[]`	`sfidReadValuesByProject(AuthToken pAuthToken, long projectid)` Get all of the SFID values from all of the assets extracted to the specified project
`java.lang.String[]`	`sfidReadValuesForAsset(AuthToken pAuthToken, long assetID)` Get all of the hash values associated with the specified asset
`AssetSummary[]`	`sfidRegisterExtractionBySFIDCandidates(AuthToken pAuthToken, long projectid, SFIDCandidate[] pSFIDCandidates)` Extract all assets with any of the following hash values to the specified project and return an array of asset summaries for the extracted assets.
`void`	`sfidRegisterExtractionBySFIDCandidatesLite(AuthToken pAuthToken, long projectid, SFIDCandidate[] pSFIDCandidates)` Extract all assets with any of the following hash values to the specified project without returning asset summaries for the extracted assets.
`void`	`sfidRegisterExtractionBySFIDValue(AuthToken pAuthToken, long projectid, java.lang.String pSFID)` Extract all assets with the following hash value to the specified project.
`void`	`sfidRegisterExtractionBySFIDValues(AuthToken pAuthToken, long projectid, java.lang.String[] pSFIDs)` Extract all assets with any of the following hash values to the specified project
`AssetSummary[]`	`sfidRegisterExtractionBySFIDValuesResults(AuthToken pAuthToken, long projectid, java.lang.String[] pSFIDs)` Extract all assets with any of the following hash values to the specified project
`void`	`sfidRegisterExtractions(AuthToken pAuthToken, long pProjectID, SFIDCandidate[] pSFIDCandidates, boolean pHarvest)` Register usage of assets to a specified project by matching SFIDs to files that are associated with assets.
`void`	`sfidRemoveAllFromAsset(AuthToken pAuthToken, long assetID)` Remove all of the SFIDInfos associated with the specified asset
`void`	`sfidUpdateAsset(AuthToken pAuthToken, SFIDInfo[] pSFIDs, long assetID)` Remove all of the existing SFIDInfos associated with an asset, and replace them with the new list
`void`	`subscriptionCreate(AuthToken pAuthToken, long[] pAssetIDs, boolean pFailOnAnyError)` Create a subscription for the user identified by pAuthToken to the assets listed in pAssetIDs.
`void`	`subscriptionDelete(AuthToken pAuthToken, long[] pAssetIDs)` Delete an existing subscription for the user identified by pAuthToken to the assets listed in pAssetIDs.
`long[]`	`subscriptionReadSubscribedAssets(AuthToken pAuthToken)` Retrieve the list of assets to which the user identified by pAuthToken is subscribed.
`RegistryUser[]`	`subscriptionReadUsersSubscribedToAsset(AuthToken pAuthTokenBean, long pAssetID)` Return all of the users subscribed to an asset.
`Question[]`	`surveyReadQuestions(AuthToken pAuthToken)` Read Questions
`SurveyTaken`	`surveyTakenRead(AuthToken pAuthToken, Extraction pExtraction)` Read SurveyTaken
`SurveyTaken`	`surveyTakenUpdate(AuthToken pAuthToken, SurveyTaken pSurveyTaken)` Update SurveyTaken
`void`	`systemSettingsAddBundle(AuthToken pAuthToken, java.lang.String pXml)` Adds a XML bundle to the system.
`SettingValue[]`	`systemSettingsQuery(AuthToken pAuthToken, SystemSettingsCriteria pCriteria)` Queries for a system setting
`void`	`testAcceptableValueListDelete(AuthToken pAuthToken, long pID)`
`void`	`testCasCreate(AuthToken pAuthToken, java.lang.String pCasName, java.lang.String pCasType)`
`void`	`testCasDelete(AuthToken pAuthToken, java.lang.String pCasName)`
`void`	`testCleanupNonRunningJobs()`
`void`	`testClearCache(AuthToken pAuthToken, java.lang.String pCacheName)`
`void`	`testClearDatabase()`
`void`	`testCreateCustomAccessSetting(AuthToken pAuthToken, java.lang.String pType, java.lang.String pRoleContextName, boolean pIsDefault)`
`void`	`testDeleteAsset(AuthToken pAuthToken, long pAssetId)`
`void`	`testDeleteAssetType(AuthToken pAuthToken, long pAssetId)`
`void`	`testDeleteProject(AuthToken pAuthToken, long pProjectId)`
`void`	`testDeleteUser(AuthToken pAuthToken, long pUserId)`
`java.lang.String`	`testDetermineDBPlatform()`
`java.lang.String[]`	`testDoSimpleQuery(java.lang.String[] pArgs, java.lang.String pColumnName, java.lang.String pQuery)` Create a subscription for the user identified by pAuthToken to the assets listed in pAssetIDs.
`int`	`testDoSQL(java.lang.String pSQL)`
`void`	`testExtractionResetDatabaseForProject(long pProjectID)`
`boolean`	`testGetLicenseState()`
`java.lang.String`	`testGetSettingValue(java.lang.String pSettingName)`
`boolean`	`testHasSufficientAssets()`
`void`	`testLogMessage(java.lang.String pMessage)`
`void`	`testRestartJobMonitor()`
`void`	`testRoleContextAddRole(AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator)`
`void`	`testRoleContextApplySecuritySettingToExisting(AuthToken pAuthToken, java.lang.String pRoleContextName)`
`void`	`testRoleContextClearRoles(AuthToken pAuthToken, java.lang.String pRoleContextName)`
`java.lang.String[]`	`testRoleContextGetAllRoles(AuthToken pAuthToken, java.lang.String pRoleContextName)`
`java.lang.String`	`testRoleContextGetPermissionFromRole(AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pPermissionName, java.lang.String pRoleName, java.lang.String pRoleOperator)`
`void`	`testRoleContextRemoveRole(AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator)`
`void`	`testRoleContextSetPermission(AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator, PermissionValue pPermissionValueBean)`
`void`	`testRoleContextSetPermissions(AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator, PermissionValue[] pPermssionValueBeans)`
`void`	`testSetLicenseState(boolean pLicensed)`
`void`	`testSetProperty(java.lang.String pPropName, java.lang.String pPropValue)`
`void`	`testSetSetting(java.lang.String pSettingName, java.lang.String pSettingValue)`
`void`	`testThrowImportExportException(boolean pImpExp)`
`void`	`testThrowOpenAPIException()`
`void`	`testUpdateAssetDate(AuthToken pAuthToken, long pAssetID, java.lang.String pDateField, java.util.Calendar pNewDate)`
`void`	`testUpdateProjectAdminRole(long pUserID, boolean pRemove)`
`void`	`testUpdateTabStatus(AuthToken pAuthToken, boolean pApproved, long pUserID, java.lang.String pTab, long pAssetID, java.util.Calendar pDate)`
`void`	`testUpdateUserRole(long pUserID, boolean pRemove)`
`void`	`testUpdateViewAssetSetting(boolean pRemove)`
`void`	`unitTestUserResetDatabase()`
`RegistryUser`	`userActivate(AuthToken pAuthToken, long pId)` Set a user's active status to active.
`RegistryUser`	`userAddRole(AuthToken pAuthToken, long pId, java.lang.String pRoleName)` Add a role to an existing user.
`RegistryUser`	`userCreate(AuthToken pAuthToken, java.lang.String pUserName, java.lang.String pFirstName, java.lang.String pLastName, java.lang.String pEmail, java.lang.String pPassword, boolean pMustChangePassword, boolean pPasswordNeverExpires, boolean pAssignDefaultRoles)` Create a new user.
`RegistryUser`	`userDeactivate(AuthToken pAuthToken, long pId)` Set a user's active status to inactive.
`RegistryUser`	`userLockout(AuthToken pAuthToken, long pId)` Set a user's active status to locked out.
`RegistryUser[]`	`userQuery(AuthToken pAuthToken, UserCriteria pCriteria)` Search for users.
`RegistryUser`	`userRead(AuthToken pAuthToken, long pId)` Retrieve an existing user.
`RegistryUser`	`userReadByAuthToken(AuthToken pAuthToken)` Retrieve an existing user.
`RegistryUser`	`userRemoveRole(AuthToken pAuthToken, long pId, java.lang.String pRoleName)` Removes a role from a user.
`RegistryUser`	`userUnapprove(AuthToken pAuthToken, long pId)` Set a user's active status to unapproved.
`RegistryUser`	`userUpdate(AuthToken pAuthToken, RegistryUser pRbacRegistrySecUserBean)` Update a user.
`Vendor`	`vendorCreate(AuthToken pAuthToken, java.lang.String pName)` Creates a new vendor
`void`	`vendorDelete(AuthToken pAuthToken, long pID)` Deletes a vendor.
`Vendor[]`	`vendorQuery(AuthToken pAuthToken, VendorCriteria pQuery)` Searches for all vendors whose names contain the specified string (ignoring case)
`Vendor`	`vendorRead(AuthToken pAuthToken, long pID)` Reads a vendor
`Vendor`	`vendorUpdate(AuthToken pAuthToken, Vendor pVendor)` Updates a vendor

Method Detail

assetTypeTabsRead

TabTypeBean[] assetTypeTabsRead(AuthToken pAuthTokenBean,
                                long pAssetTypeId)
                                throws java.rmi.RemoteException,
                                       OpenAPIException

Read an assettype's tabs.

Parameters:: pAuthTokenBean - The authtoken of the user.; pAssetTypeId - The assettype id.
Returns:: An Array of TabTypeBeans.
Throws:: OpenAPIException; java.rmi.RemoteException

assetTabApprove

void assetTabApprove(AuthToken pAuthTokenBean,
                     long pAssetId,
                     long pTabId)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Approve an asset's tab.

Parameters:: pAuthTokeBean - The authtoken of the user.; pAssetId - The asset id.; pTabId - The tab id to approve.
Throws:: OpenAPIException; java.rmi.RemoteException

assetTabUnapprove

void assetTabUnapprove(AuthToken pAuthTokeBean,
                       long pAssetId,
                       long pTabId)
                       throws java.rmi.RemoteException,
                              OpenAPIException

Unapprove an asset's tab.

Parameters:: pAuthTokeBean - The authtoken of the user.; pAssetId - The asset id.; pTabId - The tab id to unapprove.
Throws:: OpenAPIException; java.rmi.RemoteException

notificationCreate

void notificationCreate(AuthToken pAuthTokenBean,
                        java.lang.String pTemplateType,
                        java.lang.String[] pRecipients,
                        NameValue[] pSubstitutions)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Create a new notification.

Parameters:: pAuthTokenBean - The authtoken of the user.; pTemplateType - The template type.; pRecipients - Array of email addresses of who are to receive this notification.; pSubstitutions - Array of NameValue objects to replace placeholders/
Throws:: OpenAPIException; java.rmi.RemoteException

notificationSubstitutionsRead

java.lang.String[] notificationSubstitutionsRead(AuthToken pAuthTokenBean,
                                                 java.lang.String pTemplateType)
                                                 throws java.rmi.RemoteException,
                                                        OpenAPIException

Retrieve the substitution names available for a notification template type.

Parameters:: pAuthTokenBean - The authtoken of the user.; pTemplateType - The template type.
Returns:: Array of substitution names.
Throws:: OpenAPIException; java.rmi.RemoteException

artifactStoreQuery

ArtifactStoreBean[] artifactStoreQuery(AuthToken pAuthTokenBean,
                                       ArtifactStoreCriteria pArtifactStoreCritera,
                                       boolean pCreateIfMissing)
                                       throws java.rmi.RemoteException,
                                              OpenAPIException

Find an ArtifactStore that matches the criteria. If an ArtifactStore is not found and pCreateIfMissing is true, then attempt to create a new ArtifactStore and return it.

Parameters:: pAuthTokenBean - The authtoken of the user requesting this operation.; pArtifactStoreCritera - Criteria to find an ArtifactStore or info to create a missing.; pCreateIfMissing - Create a new ArtifactStore if one is not found based on the criteria (host and basepath criteria must be provided).
Returns:: Array of matching ArtifactStoreBeans
Throws:: OpenAPIException; java.rmi.RemoteException

authTokenCreate

AuthToken authTokenCreate(java.lang.String userName,
                          java.lang.String credential)
                          throws java.rmi.RemoteException,
                                 OpenAPIException

Authenticates a user, creating an AuthToken that is used to prove who the user is. Requires the OpenAPI to be licensed on the target system.

Parameters:: userName - The username; credential - The credentials/password that authenticates the user
Returns:: The AuthToken that is used to prove who the user is.
Throws:: OpenAPIException - When the user could not be authenticated or the user's account is flagged to change their password; java.rmi.RemoteException

authTokenCreateWithLicense

AuthToken authTokenCreateWithLicense(java.lang.String userName,
                                     java.lang.String credential,
                                     java.lang.String license)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

Authenticates a user, creating an AuthToken that is used to prove who the user is. Allows OER authored tools to utilize the OpenAPI on a system which is not licensed to utilitize the OpenAPI in general.

Parameters:: userName - The username; credential - The credentials/password that authenticates the user; license - OER license key
Returns:: The AuthToken that is used to prove who the user is.
Throws:: OpenAPIException - When the user could not be authenticated or the user's account is flagged to change their password; java.rmi.RemoteException

authTokenDelete

void authTokenDelete(AuthToken authToken)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Invalidates the OER authentication for a user. After this method is called, the AuthToken is no longer valid and the user must reauthenticate before they can make method calls again.

Parameters:: authToken - The AuthToken that was used to prove who the user is.
Throws:: OpenAPIException - When the user's OER authentication could not be invalidated; java.rmi.RemoteException

authTokenValidate

void authTokenValidate(AuthToken authToken)
                       throws java.rmi.RemoteException,
                              OpenAPIException

Tests the OER authentication token for a user. Returns if the token is still valid, throws an exception otherwise.

Parameters:: authToken - The AuthToken that was used to prove who the user is.
Throws:: OpenAPIException - When the user's OER authentication could not be validated; java.rmi.RemoteException

assetCreate

Asset assetCreate(AuthToken pAuthToken,
                  java.lang.String pName,
                  java.lang.String pVersion,
                  long pAssetTypeID)
                  throws java.rmi.RemoteException,
                         OpenAPIException

Initial creation of a NEW asset. Normally, the asset will be immediately editted to set categorizations, relationships, and acceptable values.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit permission.; pName - Name of the new asset; pVersion - version of the new asset; pAssetType - The assetType that this asset complies with
Returns:: Asset The newly created asset object
Throws:: OpenAPIException - When the asset could not be created; java.rmi.RemoteException

assetCreateFromXML

Asset assetCreateFromXML(AuthToken pAuthToken,
                         java.lang.String assetXML)
                         throws java.rmi.RemoteException,
                                OpenAPIException

Initial creation of a NEW asset from an XML representation. The XML must validate with a schema based on the asset type of the asset. The schema can be retrieved through the method assetTypeSchemaRead. Normally, after creation, the asset will be immediately editted to set categorizations, relationships, and acceptable values.

Parameters:: pAuthToken - authtoken against which to validate the user.; assetXML - The XML from which the asset is created.
Returns:: The Asset
Throws:: OpenAPIException; java.rmi.RemoteException

assetRead

Asset assetRead(AuthToken pAuthToken,
                long pId)
                throws java.rmi.RemoteException,
                       OpenAPIException

Get an Asset object by Id.

Parameters:: pAuthToken - authtoken against which to validate the user. View permission required.; pId - ID of the asset to retrieve
Returns:: Asset The requested Asset
Throws:: OpenAPIException - When the asset could not be read; java.rmi.RemoteException

assetReadXml

java.lang.String assetReadXml(AuthToken pAuthToken,
                              long pId)
                              throws java.rmi.RemoteException,
                                     OpenAPIException

Retrieve the xml representation for an asset.

Parameters:: pAuthToken - the auth token used to validate access; pId - the id of the asset for which to read xml
Returns:: the xml for an asset
Throws:: OpenAPIException - for invalid id; java.rmi.RemoteException

assetReadCustomDataString

java.lang.String assetReadCustomDataString(AuthToken pAuthToken,
                                           long pId,
                                           java.lang.String pPath)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Get an Asset custom data node by path

Parameters:

pAuthToken - authtoken against which to validate the user. View permission required.

pId - ID of the asset to retrieve

pPath - Path of the node to read relative to custom-data. Examples:

endpoint-uri
users/user/firstname

Returns:

String The value of the requested custom-data field

Throws:

OpenAPIException - When the asset could not be read

java.rmi.RemoteException

assetReadCustomDataNode

java.lang.String assetReadCustomDataNode(AuthToken pAuthToken,
                                         long pId,
                                         java.lang.String pPath)
                                         throws java.rmi.RemoteException,
                                                OpenAPIException

Get an Asset custom data node's XML by path

Parameters:

pAuthToken - authtoken against which to validate the user. View permission required.

pId - ID of the asset to retrieve

pPath - Path of the node to read relative to custom-data

Returns:

String The requested custom-data node in XML format, for example:

<endpoint-uri>http://myservice:8080</endpoint-uri>

Throws:

OpenAPIException - When the asset could not be read

java.rmi.RemoteException

assetReadArray

Asset[] assetReadArray(AuthToken pAuthToken,
                       long[] pIds)
                       throws java.rmi.RemoteException,
                              OpenAPIException

Get an array of Asset objects from an array of Ids.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission.; pIds - Array of IDs of the assets to retrieve
Returns:: The requested Assets
Throws:: OpenAPIException - When the assets could not be read or the maximum number allowed in one call is exceeded.; java.rmi.RemoteException

assetReadArrayFromSummary

Asset[] assetReadArrayFromSummary(AuthToken pAuthToken,
                                  AssetSummary[] pAssetSummaries)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Get an array of Asset objects from an array of AssetSummary objects. This is a helper method that is useful when searching for assets, then selectively loading some of the search results.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission.; pAssetSummaries - Array of AssetSummary objects for the assets to retrieve
Returns:: The requested Assets
Throws:: OpenAPIException - When the assets could not be read or the maximum number allowed in one call is exceeded.; java.rmi.RemoteException

assetUpdate

Asset assetUpdate(AuthToken pAuthToken,
                  Asset pAsset)
                  throws java.rmi.RemoteException,
                         OpenAPIException

Updates an Asset, saving any modifications that were made to it.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit permission.; pAsset - The modified asset to save
Returns:: Asset The asset after the modifications have been saved
Throws:: OpenAPIException - When the asset could not be modified; java.rmi.RemoteException

assetGetUnacceptedFiles

SubmissionFileInfo[] assetGetUnacceptedFiles(AuthToken pAuthToken,
                                             long pId)
                                             throws java.rmi.RemoteException,
                                                    OpenAPIException

Parameters:: pAuthToken -; pId - Asset unique identifier
Returns:
Throws:: OpenAPIException; java.rmi.RemoteException

assetAcceptFiles

void assetAcceptFiles(AuthToken pAuthToken,
                      long pId,
                      java.lang.String[] pFilenames)
                      throws java.rmi.RemoteException,
                             OpenAPIException

Parameters:: pAuthToken -; pId - Asset unique identifier; pFilenames - Array of strings containing names of files to be accepted
Throws:: OpenAPIException; java.rmi.RemoteException

assetUpdateCustomDataString

Asset assetUpdateCustomDataString(AuthToken pAuthToken,
                                  long pAssetID,
                                  java.lang.String pPath,
                                  java.lang.String pValue)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Updates an Asset with a specified custom-data value modification. This method updates only the string contents of the last node in the specified xpath. E.g. supplying path foo/bar/baz and value "some new content" results in:

 <foo>
   <bar>
     <baz>some new content</baz>
   </bar>
 </foo>

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit permission.; pAssetID - The ID of the asset to modify; pPath - The xpath relative to the custom-data node to save the data, e.g. foo/bar/baz; pValue - The data value to set on the specified xpath node, e.g. "some new content"
Returns:: Asset The asset after the modifications have been saved
Throws:: OpenAPIException - When the asset could not be modified; java.rmi.RemoteException

assetUpdateCustomDataStringArray

Asset assetUpdateCustomDataStringArray(AuthToken pAuthToken,
                                       long pAssetID,
                                       java.lang.String[] pPath,
                                       java.lang.String[] pValue)
                                       throws java.rmi.RemoteException,
                                              OpenAPIException

Updates an Asset with a specified list of custom-data value modifications. Updates multiple xpath statements at once. This method updates only the string contents of the last node in the specified path. E.g. supplying path foo/bar/baz and value "some new content" results in:

 <foo>
   <bar>
     <baz>some new content</baz>
   </bar>
 </foo>

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit permission.; pAssetID - The ID of the asset to modify; pPath - The xpath(s) relative to the custom-data node to save the data, e.g. foo/bar/baz; pValue - The data value(s) to set on the specified xpath node, e.g. "some new content"
Returns:: Asset The asset after the modifications have been saved
Throws:: OpenAPIException - When the asset could not be modified; java.rmi.RemoteException

assetUpdateCustomDataNode

Asset assetUpdateCustomDataNode(AuthToken pAuthToken,
                                long pAssetID,
                                java.lang.String pPath,
                                java.lang.String pValue)
                                throws java.rmi.RemoteException,
                                       OpenAPIException

Updates an Asset with a specified custom-data node modification. This method overwrites the last node in the specified xpath. E.g. supplying path foo/bar/baz and value "<bazchanged>some new content</bazchanged>" results in:

 <foo>
   <bar>
     <bazchanged>some new content</bazchanged>
   </bar>
 </foo>

*Note: pValue completely overwrites the node pointed to by pPath, as shown in the example above.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit permission.; pAssetID - The ID of the asset to modify; pPath - The xpath relative to the custom-data node to save the data, e.g. foo/bar/baz; pValue - The data to set on the specified xpath, e.g. <bazchanged>some new content</bazchanged>
Returns:: Asset The asset after the modifications have been saved
Throws:: OpenAPIException - When the asset could not be modified; java.rmi.RemoteException

assetUpdateCustomDataNodeFromStringArray

Asset assetUpdateCustomDataNodeFromStringArray(AuthToken pAuthToken,
                                               long pAssetID,
                                               java.lang.String[] pPath,
                                               java.lang.String[] pValue)
                                               throws java.rmi.RemoteException,
                                                      OpenAPIException

Updates an Asset with a specified list of custom-data value modifications. Updates multiple xpath statements at once. This method overwrites the last node in the specified xpath. E.g. supplying path foo/bar/baz and value "<bazchanged>some new content</bazchanged>" results in:

 <foo>
   <bar>
     <bazchanged>some new content</bazchanged>
   </bar>
 </foo>

*Note: pValue completely overwrites the node pointed to by pPath, as shown in the example above.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit permission.; pAssetID - The ID of the asset to modify; pPath - The xpath(s) relative to the custom-data node to save the data, e.g. foo/bar/baz; pValue - The data value(s) to set on the specified xpath, e.g. <bazchanged>some new content</bazchanged>
Returns:: Asset The asset after the modifications have been saved
Throws:: OpenAPIException - When the asset could not be modified; java.rmi.RemoteException

assetUploadFiles

void assetUploadFiles(AuthToken pAuthToken,
                      long pAssetID,
                      java.lang.String[] pFilenames)
                      throws java.rmi.RemoteException,
                             OpenAPIException

Upload files into the Flashline Registry UPLOAD repository. Files may be attached using either SOAP with Attachments or DIME. Filenames should be indicated in the pFilenames String array, and should be ordered the same as the attachments.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit permission for assets.; pAssetID - the asset id to which the files should be uploaded; pFilenames - the names of the files in the same order as the attachments
Throws:: OpenAPIException; java.rmi.RemoteException

assetAddRegistrarNote

void assetAddRegistrarNote(AuthToken pAuthToken,
                           long pId,
                           java.lang.String pNotes)
                           throws java.rmi.RemoteException,
                                  OpenAPIException

Adds a registrar note to the log on the Administration tab

Parameters:: pAuthToken -; pId -; pNotes -
Throws:: OpenAPIException; java.rmi.RemoteException

assetReadRegistrarNotes

LogEntry[] assetReadRegistrarNotes(AuthToken pAuthToken,
                                   long pId)
                                   throws java.rmi.RemoteException,
                                          OpenAPIException

Reads the log of registrar notes

Parameters:: pAuthToken -; pId -
Returns:
Throws:: OpenAPIException; java.rmi.RemoteException

assetRegister

void assetRegister(AuthToken pAuthToken,
                   long pID)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Registers an Asset.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Register Permission.; pId - ID of the asset to register
Throws:: java.rmi.RemoteException; OpenAPIException

assetUnRegister

void assetUnRegister(AuthToken pAuthToken,
                     long pID)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Unregister an Asset.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Register permission.; pId -
Throws:: java.rmi.RemoteException; OpenAPIException

assetAccept

void assetAccept(AuthToken pAuthToken,
                 long pID)
                 throws java.rmi.RemoteException,
                        OpenAPIException

Accept an Asset.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Accept permission.; pId - The ID of the asset to accept.
Throws:: java.rmi.RemoteException; OpenAPIException

assetUnAccept

void assetUnAccept(AuthToken pAuthToken,
                   long pID)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Unaccept an Asset.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Accept permission.; pId - The ID of the asset to unaccept.
Throws:: java.rmi.RemoteException; OpenAPIException

assetSubmit

void assetSubmit(AuthToken pAuthToken,
                 long pID)
                 throws java.rmi.RemoteException,
                        OpenAPIException

Submit an Asset.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Submit permission.; pId -
Throws:: java.rmi.RemoteException; OpenAPIException

assetUnSubmit

void assetUnSubmit(AuthToken pAuthToken,
                   long pID)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Unsubmit an Asset.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Submit permission.; pId -
Throws:: java.rmi.RemoteException; OpenAPIException

assetActivate

void assetActivate(AuthToken pAuthToken,
                   long pAssetID)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Set an Asset's active-status to Active.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have register permission.; pId - The ID of the asset to activate.
Throws:: java.rmi.RemoteException; OpenAPIException

assetDeactivate

void assetDeactivate(AuthToken pAuthToken,
                     long pAssetID)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Set an Asset's active-status to Inactive.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Register permission.; pId - The ID of the asset to be deactivated.
Throws:: java.rmi.RemoteException; OpenAPIException

assetRetire

void assetRetire(AuthToken pAuthToken,
                 long pAssetID)
                 throws java.rmi.RemoteException,
                        OpenAPIException

Set an Asset's active-status to Retired.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Register permission.; pId - The ID of the asset to be retired.
Throws:: java.rmi.RemoteException; OpenAPIException

assetDelete

void assetDelete(AuthToken pAuthToken,
                 long pAssetID)
                 throws java.rmi.RemoteException,
                        OpenAPIException

Set an Asset's active-status to Deleted.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Register permission.; pId - The ID of the asset to be deleted.
Throws:: java.rmi.RemoteException; OpenAPIException

assetTabsRead

TabBean[] assetTabsRead(AuthToken pAuthTokenBean,
                        long pAssetId)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Retrieve all of the Tabs available for an asset.

Parameters:: pAuthTokenBean - authtoken against which to validate the user.; pAssetId - The asset id.
Returns:: An array of AssetTabs.
Throws:: OpenAPIException; java.rmi.RemoteException

assetTabRead

TabBean assetTabRead(AuthToken pAuthTokenBean,
                     long pAssetId,
                     long pTabTypeBeanId)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Read an asset's tab for a specific TabType.

Parameters:: pAuthTokenBean - authtoken against which to validate the user.; pAssetId - The asset id.; pTabTypeBeanId -
Returns:: An AssetTab.
Throws:: OpenAPIException; java.rmi.RemoteException

assetQuerySummary

AssetSummary[] assetQuerySummary(AuthToken pAuthtoken,
                                 AssetCriteria pCriteria)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException

Search for Assets Summaries.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission.; pCriteria - The criteria to search for.
Returns:: AssetSummary[] An array of the asset summary objects that match the criteria.
Throws:: java.rmi.RemoteException; OpenAPIException

assetQuery

Asset[] assetQuery(AuthToken pAuthtoken,
                   AssetCriteria pCriteria)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Search for Assets.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission; pCriteria - The criteria to search for.
Returns:: Asset[] An array of the asset objects that match the criteria.
Throws:: java.rmi.RemoteException; OpenAPIException

assetQueryCount

int assetQueryCount(AuthToken pAuthToken,
                    AssetCriteria pCriteria)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Count the number of assets that would match a query on a specific criteria.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission; pCriteria - The criteria to search for.
Returns:: the number of assets that would match the query
Throws:: java.rmi.RemoteException; OpenAPIException

assetReadAppliedToProjects

Project[] assetReadAppliedToProjects(AuthToken pAuthToken,
                                     Asset pAsset)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

Search for projects which compliance template is applied to.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission; pAsset - Asset being read from
Returns:: RelatedEntity[] An array of RelatedEntities that stores which projects this template is applied to.
Throws:: OpenAPIException; java.rmi.RemoteException

assetReadAppliedPolicies

Asset[] assetReadAppliedPolicies(AuthToken pAuthToken,
                                 long pAssetID)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException

Search for policies which are assigned to the specified asset

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission; pAsset - Asset being read from
Returns:: Asset[] An array of Asset Policies which are applied to the specified asset
Throws:: OpenAPIException; java.rmi.RemoteException

assetUpdateAppliedPolicies

Asset assetUpdateAppliedPolicies(AuthToken pAuthToken,
                                 long pAssetID,
                                 long[] pAppliedPolicies)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException

Specifies which policies are associated with this asset.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have View permission; pAsset - Asset being updated; pAppliedPolicies - Policies to apply
Returns:: Asset Updated asset
Throws:: OpenAPIException; java.rmi.RemoteException

assetEvaluate

KeyValuePair assetEvaluate(AuthToken pAuthToken,
                           AssetCriteria pCriteria,
                           java.lang.String pEvaluationName)
                           throws java.rmi.RemoteException,
                                  OpenAPIException

Evaluate Asset attributes.

Parameters:: pAuthToken -; pCriteria -; pEvaluationName - The name of what we wish to evaluate
Returns:
Throws:: OpenAPIException; java.rmi.RemoteException

assetEvaluateAgainstAllPolicies

java.lang.String assetEvaluateAgainstAllPolicies(AuthToken pAuthToken,
                                                 long pAssetID)
                                                 throws java.rmi.RemoteException,
                                                        OpenAPIException

Evaluate an asset against all applied policies. Result "True" indicates that the asset has passed all assertions in all applied policies. Result "False" indicates that the asset has failed at least one assertion in at least one applied policy. Result "Null" indicates that at least one assertion in at least one applied policy has no set result value.

Parameters:: pAuthToken - authtoken against which the user is validated. Must have View permission; pAssetID - ID of asset being evaluated
Returns:: Evaluation result - one of: true for "pass", false for "fail" or null for "unknown"
Throws:: OpenAPIException; java.rmi.RemoteException

assetEvaluateAgainstPolicy

java.lang.String assetEvaluateAgainstPolicy(AuthToken pAuthToken,
                                            long pAssetID,
                                            long pPolicyID)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Evaluate an asset against a single applied policy. Result "True" indicates that the asset has passed all assertions for the applied policy. Result "False" indicates that the asset has failed at least one assertion in the applied policy. Result "Null" null indicates that at least one assertion in the applied policy has no set result value.

Parameters:: pAuthToken - authtoken against which the user is validated. Must have View permission; pAssetID - ID of asset being evaluated; pPolicyID - ID of policy being evaluated
Returns:: Evaluation result - one of: true for "pass", false for "fail" or null for "unknown"
Throws:: OpenAPIException; java.rmi.RemoteException

assetApplyToProjects

void assetApplyToProjects(AuthToken pAuthToken,
                          java.lang.String[] pProjectIDs,
                          Asset pAsset)
                          throws java.rmi.RemoteException,
                                 OpenAPIException

Apply templates to projects

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectIDs - Projects that the template will be applied to; pAsset - Asset being read from
Throws:: OpenAPIException; java.rmi.RemoteException

assetRemoveAppliedToProjects

void assetRemoveAppliedToProjects(AuthToken pAuthToken,
                                  java.lang.String[] pProjectIDs,
                                  Asset pAsset)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Removes templates from projects.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectIDs - Projects that the template will be removed from; pAsset - Asset being read from
Throws:: OpenAPIException; java.rmi.RemoteException

repositoryFileTranslator

java.lang.String repositoryFileTranslator(AuthToken pAuthToken,
                                          FileInfo pFileInfo)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Given a FileInfo object it returns the download path for the file.

Parameters:: pAuthToken - authtoken against which to validate the user.; pFileInfo - FileInfo object required for the File translator
Returns:: String representing the translation.
Throws:: OpenAPIException; java.rmi.RemoteException

categorizationTypeCreate

CategorizationType categorizationTypeCreate(AuthToken pAuthToken,
                                            java.lang.String pName,
                                            java.lang.String pSingularDisplay,
                                            java.lang.String pPluralDisplay,
                                            boolean pExclusiveAssign,
                                            boolean pProjectAssign)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Creates a categorization type

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit Asset Type permission.; pName - The name of the new type.; pSingularDisplay - Singular version of the name for display purposes.; pPluralDisplay - Plural version of the name for display purposes.; pExclusiveAssign - If true only one categorization of this type can be applied to an asset.; pProjectAssign - If true then categorizations of this type can be applied to projects.
Returns:: The created categorization type.
Throws:: OpenAPIException; java.rmi.RemoteException

categorizationTypeRead

CategorizationType categorizationTypeRead(AuthToken pAuthToken,
                                          long pCategorizationTypeID)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Read categorization type.

Parameters:: pAuthToken - authtoken against which to validate the user.; pCategorizationTypeID - The ID of the categorization type.
Returns:: CategorizationType The categorization that matches the ID.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationTypeUpdate

CategorizationType categorizationTypeUpdate(AuthToken pAuthToken,
                                            CategorizationType pType)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

This only updates the categorization Type, not all of the sub categorizations

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit Asset Type permission.; pCategorizationType - The categorization type object with the new values.
Returns:: CategorizationType The updated CategorizationType.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationTypeDelete

void categorizationTypeDelete(AuthToken pAuthToken,
                              CategorizationType pCategorizationType)
                              throws java.rmi.RemoteException,
                                     OpenAPIException

Delete Categorization Type. Also deletes the categorizations of this type.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit Asset Type permission; pCategorizationType - The categorization type to delete.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationTypeQuery

CategorizationType[] categorizationTypeQuery(AuthToken pAuthToken,
                                             CategorizationTypeCriteria pCriteria)
                                             throws java.rmi.RemoteException,
                                                    OpenAPIException

Retrieve categorization types for a given set of query criteria.

Parameters:: pAuthToken - authtoken against which to validate the user.; pQueryCriteria - The categorization type criteria to search for
Returns:: CategorizationType[] An array of matching categorization types.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationCreate

Categorization categorizationCreate(AuthToken pAuthToken,
                                    java.lang.String pCategorizationName,
                                    CategorizationType pCategorizationType)
                                    throws java.rmi.RemoteException,
                                           OpenAPIException

Create a categorization

Parameters:: pAuthToken - authtoken against which to validate the user. Must have EditAsset Type permission; pCategorizationName - The name of the new Categorization. It must be unique within the categorization type.; pCategorizationType - The categorization type.
Returns:: Categorization the new categorization
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationChildCreate

Categorization categorizationChildCreate(AuthToken pAuthToken,
                                         java.lang.String pCategorizationName,
                                         CategorizationType pCategorizationType,
                                         Categorization pSuper)
                                         throws java.rmi.RemoteException,
                                                OpenAPIException

Create a child categorization.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit Asset Type permission.; pCategorizationName - The name of the new child categorization.; pCategorizationType - The type of the new child categorization.; pSuper - The parent Categorization.
Returns:: Categorization the child categorization.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationRead

Categorization categorizationRead(AuthToken pAuthToken,
                                  long pCategorizationID)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Retrieve categorization

Parameters:: pAuthToken - authtoken against which to validate the user.; pCategorizationID - The id of the categorization to return.
Returns:: Categorization The matching categorization.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationReadByType

Categorization[] categorizationReadByType(AuthToken pAuthToken,
                                          CategorizationType pCategorizationType,
                                          boolean active,
                                          boolean fullTree)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Retrieve all categorizations for a categorization types active set to true returns active categorizations fullTree set to true returns categories and their children

Parameters:: pAuthToken - authtoken against which to validate the user.; pCategorizationType - The type of the categorizations to get.; active - True to limit array to active categorizations.; fullTree - True to return children of categorizations as well.
Returns:: Categorization[] An array of the matching categorizations.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationChildRead

Categorization[] categorizationChildRead(AuthToken pAuthToken,
                                         CategorizationType pCategorizationType,
                                         Categorization pCategorization,
                                         boolean active)
                                         throws java.rmi.RemoteException,
                                                OpenAPIException

Retrieve all child categorizations for a given categorization.

Parameters:: pAuthToken - authtoken against which to validate the user.; pCategorizationType - The type of the parent Categorization; pCategorization - The parent Categorization.; active - True if you want only active Categorizations.
Returns:: Categorization[] An array of Chile Categorizations
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationUpdate

Categorization categorizationUpdate(AuthToken pAuthToken,
                                    Categorization pCategorization,
                                    CategorizationType pCategorizationType)
                                    throws java.rmi.RemoteException,
                                           OpenAPIException

Update a single categorization

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit Asset Type permission; pCategorization - A Categorization object containing the values to update.; pCategorizationType - The CategorizationType that contains the categorization to update.
Returns:: Categorization The updated categorization.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationUpdateArray

Categorization[] categorizationUpdateArray(AuthToken pAuthToken,
                                           Categorization[] pCategorizations,
                                           CategorizationType pCategorizationType)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Update a list of categorizations within a categorization type.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have the Edit Asset Type permission.; pCategorization - An array of Categorization objects updated with new values.; pCategorizationType - The categorization type of the categorizations to update.
Returns:: Categorization[] An array of the updated categorizations
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationDeactivate

Categorization categorizationDeactivate(AuthToken pAuthToken,
                                        Categorization pCategorization,
                                        CategorizationType pCategorizationType)
                                        throws java.rmi.RemoteException,
                                               OpenAPIException

Deactivate Categorization

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit Asset Type permission; pCategorization - Categorization to deactivate.; pCategorizationType - Type of the categorization to deactivate.
Returns:: Categorization The deactivated categorization.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

categorizationReactivate

Categorization categorizationReactivate(AuthToken pAuthToken,
                                        Categorization pCategorization,
                                        CategorizationType pCategorizationType)
                                        throws java.rmi.RemoteException,
                                               OpenAPIException

Reactivate Categorization

Parameters:: pAuthToken - authtoken against which to validate the user. Must have Edit Asset Type permission.; pCategorization - The categorization to be reactivated.; pCategorizationType - The categorization type of the categorization to be reactivated.
Returns:: Categorization The reactivated categorization.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

contactCreate

Contact contactCreate(AuthToken pAuthToken,
                      java.lang.String pName)
                      throws java.rmi.RemoteException,
                             OpenAPIException

Creates a new contact.

Parameters:: pAuthToken - authtoken against which to validate the user; pName - the name of the new contact
Returns:: the newly created contact object
Throws:: OpenAPIException - when there is a problem creating the contact; java.rmi.RemoteException

contactRead

Contact contactRead(AuthToken pAuthToken,
                    long pID)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Reads a contact by ID.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the ID of the contact to read
Returns:: the requested contact object
Throws:: OpenAPIException - when there is a problem reading the contact; java.rmi.RemoteException

contactUpdate

Contact contactUpdate(AuthToken pAuthToken,
                      Contact pContact)
                      throws java.rmi.RemoteException,
                             OpenAPIException

Updates a contact.

Parameters:: pAuthToken - authtoken against which to validate the user; pContact - the modified contact object to be saved
Returns:: the contact object after the modifications have been saved
Throws:: OpenAPIException - when there is a problem updating the contact; java.rmi.RemoteException

contactDelete

void contactDelete(AuthToken pAuthToken,
                   long pID)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Deletes a contact.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the unique ID of the contact to be deleted
Throws:: OpenAPIException - when there is a problem deleting the vendor; java.rmi.RemoteException

contactQuery

Contact[] contactQuery(AuthToken pAuthToken,
                       ContactCriteria pQuery)
                       throws java.rmi.RemoteException,
                              OpenAPIException

Searches for all contacts whose names contain the specified criteria. Valid criteria includes the contact name as a String. Case is ignored.

Parameters:: pAuthToken - authtoken against which to validate the user; pQuery - a criteria object containing the name of the contact for which to search
Returns:: an array of contact objects matching the criteria, or an empty array if no contacts match
Throws:: OpenAPIException - when there is a problem finding contacts. Note that finding no results will not cause an exception to be thrown.; java.rmi.RemoteException

extractionCreate

ExtractionDownload[] extractionCreate(AuthToken pAuthToken,
                                      long pProjectId,
                                      long[] pAssetIDs)
                                      throws java.rmi.RemoteException,
                                             OpenAPIException

Create Extraction

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Unique Identifier of the project this asset is being extracted to.; pAssetIDs - array of asset IDs that are being extracted.
Returns:: An array of extractions.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionGetHiddenAssetUsers

RegistryUser[] extractionGetHiddenAssetUsers(AuthToken pAuthToken,
                                             long pProjectID)
                                             throws java.rmi.RemoteException,
                                                    OpenAPIException

Returns an array of users who can view assets consumed by a project that the owner of the AuthTokenBean cannot.

Parameters:: pAuthToken - authToken against which to validate the user.; pProjectID - Unique Identifier of the project this asset is being consumed by.
Returns:: An array of RbacRegistrySecUserBean objects
Throws:: OpenAPIException; java.rmi.RemoteException

extractionCreateForUser

ExtractionDownload[] extractionCreateForUser(AuthToken pAuthToken,
                                             long pProjectID,
                                             long[] pAssetIDs,
                                             RegistryUser pRbacRegistrySecUserBean)
                                             throws java.rmi.RemoteException,
                                                    OpenAPIException

Create Extraction

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Unique Identifier of the project this asset is being extracted to.; pAssetIDs - array of asset IDs that are being extracted.; pRbacRegistrySecUserBean - Object of the user extracting this asset.
Returns:: An array of extractions.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionTentativelyAccept

Extraction extractionTentativelyAccept(AuthToken pAuthToken,
                                       Extraction pExtraction)
                                       throws java.rmi.RemoteException,
                                              OpenAPIException

Update Extraction state

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtraction - Object of the extraction being updated.
Returns:: An extraction.
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionStillEvaluating

Extraction extractionStillEvaluating(AuthToken pAuthToken,
                                     Extraction pExtraction)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

Update Extraction state

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtraction - Object of the extraction being updated.
Returns:: An extraction
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReject

Extraction extractionReject(AuthToken pAuthToken,
                            Extraction pExtraction,
                            Categorization pCategorization,
                            java.lang.String pComments)
                            throws java.rmi.RemoteException,
                                   OpenAPIException

Reject an extraction.

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtraction - Extraction being rejected.; pCategorization - Reason the asset is being rejected.; pComments - Comments regarding the rejection.
Returns:: An extraction
Throws:: OpenAPIException; java.rmi.RemoteException

extractionUpdateSurvey

Extraction extractionUpdateSurvey(AuthToken pAuthToken,
                                  Extraction pExtraction,
                                  SurveyTaken pSurveyTaken)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Update Extraction status

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtraction - Extraction being updated.; pSurveyTaken - Survey Taken being updated or created.
Returns:: An extraction
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionUpdateSurveyForUser

Extraction extractionUpdateSurveyForUser(AuthToken pAuthToken,
                                         Extraction pExtraction,
                                         SurveyTaken pSurveyTaken,
                                         RegistryUser pRbacRegistrySecUserBean)
                                         throws java.rmi.RemoteException,
                                                OpenAPIException

Update Extraction status

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtraction - Extraction being updated.; pSurveyTaken - Survey Taken being updated or created.; pRbacRegistrySecUserBean - User who took the survey and extracted this asset.
Returns:: An extraction
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionRead

Extraction extractionRead(AuthToken pAuthToken,
                          long pExtractionID)
                          throws java.rmi.RemoteException,
                                 OpenAPIException

Read Extraction

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtractionID - Unique identifier of the Extraction being requested.
Returns:: An extraction
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadByProjectAndAsset

Extraction extractionReadByProjectAndAsset(AuthToken pAuthToken,
                                           long pProjectID,
                                           long pAssetID)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Read Extraction

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Read any extractions assigned to this project.; pAssetID - Read any extractions for this asset.
Returns:: An extraction
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadUserExtractions

Extraction[] extractionReadUserExtractions(AuthToken pAuthToken,
                                           boolean pActive)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Read Extractions

Parameters:: pAuthToken - authtoken against which to validate the user.; pActive - Read any extractions with this active status.
Returns:: An array of extractions
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadAssetExtractions

Extraction[] extractionReadAssetExtractions(AuthToken pAuthToken,
                                            long pProjectID,
                                            long pAssetID,
                                            boolean pActive)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Read Extractions

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Read any extractions belonging to this project.; pAssetID - Read any extractions for this asset.; pActive - Read any extractions with this active status.
Returns:: An array of extractions
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadProjectExtractions

Extraction[] extractionReadProjectExtractions(AuthToken pAuthToken,
                                              long pProjectID,
                                              boolean pActive)
                                              throws java.rmi.RemoteException,
                                                     OpenAPIException

Read Extractions

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Read any extractions belonging to this project.; pActive - Read any extractions with this active status.
Returns:: An array of extraction
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadExtractionDownloads

ExtractionDownload[] extractionReadExtractionDownloads(AuthToken pAuthToken,
                                                       Extraction pExtraction)
                                                       throws java.rmi.RemoteException,
                                                              OpenAPIException

Read extractable files

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtraction - Read ExtractableDownload array for this extraction.
Returns:: An array of extraction downloads
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadFileInfos

FileInfo[] extractionReadFileInfos(AuthToken pAuthToken,
                                   Extraction pExtraction)
                                   throws java.rmi.RemoteException,
                                          OpenAPIException

Read file info

Parameters:: pAuthToken - authtoken against which to validate the user.; pExtraction - Read FileInfo array for this extraction.
Returns:: An array of fileInfos
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadRelatedAssets

Asset[] extractionReadRelatedAssets(AuthToken pAuthToken,
                                    long pAssetID)
                                    throws java.rmi.RemoteException,
                                           OpenAPIException

Read related Assets

Parameters:: pAuthToken - authtoken against which to validate the user.; pAssetID - Read related assets of this asset.
Returns:: An array of asset
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadRejectionReasons

Categorization[] extractionReadRejectionReasons(AuthToken pAuthToken)
                                                throws java.rmi.RemoteException,
                                                       OpenAPIException

Read rejection reasons

Parameters:: pAuthToken - authtoken against which to validate the user.
Returns:: An array of categorizations
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionReadExtractionStates

IExtraction extractionReadExtractionStates(AuthToken pAuthToken)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Read Extraction States

Parameters:: pAuthToken - authtoken against which to validate the user.
Returns:: An IExtractionBean
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

extractionResetDatabase

void extractionResetDatabase()
                             throws java.rmi.RemoteException,
                                    OpenAPIException

Throws:: OpenAPIException; java.rmi.RemoteException

projectAssetValueReadForUser

ProjectAssetValue projectAssetValueReadForUser(AuthToken pAuthToken,
                                               long pProjectID,
                                               long pAssetID,
                                               RegistryUser pRbacRegistrySecUserBean)
                                               throws java.rmi.RemoteException,
                                                      OpenAPIException

Read ProjectAssetValue

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Read ProjectAssetValue for this project.; pAssetID - Read ProjectAssetValue for this asset.; pRbacRegistrySecUserBean - Read ProjectAssetValue for this user.
Returns:: A ProjectAssetValue
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

projectAssetValueRead

ProjectAssetValue[] projectAssetValueRead(AuthToken pAuthToken,
                                          long pProjectID,
                                          long pAssetID)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Read ProjectAssetValues

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Read ProjectAssetValue for this project.; pAssetID - Read ProjectAssetValue for this asset.
Returns:: An array of ProjectAssetValues
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

projectAssetValueReadSummary

ProjectAssetValueSummary projectAssetValueReadSummary(AuthToken pAuthToken,
                                                      long pProjectID,
                                                      long pAssetID)
                                                      throws java.rmi.RemoteException,
                                                             OpenAPIException

Read ProjectAssetValueSummary

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectID - Read ProjectAssetValueSummary for this project.; pAssetID - Read ProjectAssetValueSummary for this asset.
Returns:: A ProjectAssetValueSummary object
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

projectAssetValueReadTypes

AssetUsageType[] projectAssetValueReadTypes(AuthToken pAuthToken)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Read AssetUsageTypes

Parameters:: pAuthToken - authtoken against which to validate the user.
Returns:: An array of AssetUsageType objects
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

projectAssetValueUpdate

ProjectAssetValue projectAssetValueUpdate(AuthToken pAuthToken,
                                          ProjectAssetValue pProjectAssetValue,
                                          java.lang.String pSelection)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Update ProjectAssetValue

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectAssetValue - ProjectAssetValue being updated.; pSelection - Certified Source selected by the project leader (predicted, consumer, project lead).
Returns:: An ProjectAssetValue Object
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

projectCreate

Project projectCreate(AuthToken pAuthToken,
                      Project pProject,
                      ProjectEntities pProjectEntities)
                      throws java.rmi.RemoteException,
                             com.flashline.registry.openapi.base.APIValidationException,
                             OpenAPIException

Create a project.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being created.; pProjectEntities - This stores any linked entities of a project (related projects, users)
Returns:: A Project Object
Throws:: APIValidationException; OpenAPIException; java.rmi.RemoteException

projectRead

Project projectRead(AuthToken pAuthToken,
                    long pId)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Read a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pId - Read this project ID.
Returns:: A Project object
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadArray

Project[] projectReadArray(AuthToken pAuthToken,
                           long[] pIds)
                           throws java.rmi.RemoteException,
                                  OpenAPIException

Get an array of Project objects from an array of Ids.

Parameters:: pAuthToken - authtoken against which to validate the user.; pIds - Array of project IDs being read.
Returns:: An array of Project objects.
Throws:: java.rmi.RemoteException; OpenAPIException

projectReadArrayFromSummary

Project[] projectReadArrayFromSummary(AuthToken pAuthToken,
                                      ProjectSummary[] pProjectSummaries)
                                      throws java.rmi.RemoteException,
                                             OpenAPIException

Get an array of Project objects from an array of ProjectSummary objects. This is a helper method that is useful when searching for projects, then selectively loading some of the search results.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectSummaries - Array of ProjectSummaries being searched for.
Returns:: An array of Project objects
Throws:: java.rmi.RemoteException; OpenAPIException

projectUpdate

Project projectUpdate(AuthToken pAuthToken,
                      Project pProject,
                      ProjectEntities pProjectEntities)
                      throws java.rmi.RemoteException,
                             com.flashline.registry.openapi.base.APIValidationException,
                             OpenAPIException

Get an array of Project objects from an array of ProjectSummary objects. This is a helper method that is useful when searching for projects, then selectively loading some of the search results.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProjectSummaries - Array of ProjectSummaries being searched for.
Returns:: An array of Project objects
Throws:: java.rmi.RemoteException; com.flashline.registry.openapi.base.APIValidationException; OpenAPIException

projectReadMembers

RegistryUser[] projectReadMembers(AuthToken pAuthToken,
                                  Project pProject)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Read users assigned to a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being read from.
Returns:: An array of RbacRegistrySecUserBean objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadMemberIDs

java.lang.String[] projectReadMemberIDs(AuthToken pAuthToken,
                                        Project pProject)
                                        throws java.rmi.RemoteException,
                                               OpenAPIException

Read user IDs assigned to a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being read from.
Returns:: An array of Strings representing the Member IDs
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadLeaders

RegistryUser[] projectReadLeaders(AuthToken pAuthToken,
                                  Project pProject)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Read leaders assigned to a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being read from.
Returns:: An array of RbacRegistrySecUserBean objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadLeaderIDs

java.lang.String[] projectReadLeaderIDs(AuthToken pAuthToken,
                                        Project pProject)
                                        throws java.rmi.RemoteException,
                                               OpenAPIException

Read leader IDs assigned to a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being read from.
Returns:: An array of Strings
Throws:: OpenAPIException; java.rmi.RemoteException

projectReassignExtractions

void projectReassignExtractions(AuthToken pAuthToken,
                                Project pProject,
                                ExtractionReassignmentDecision[] pReassignIDs)
                                throws java.rmi.RemoteException,
                                       OpenAPIException

Assign extractions from one user of a project to another user on the same or different project.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being updated.; pReassignIDs - This stores an array of ExtractionReassignmentDecision objects. The property, setReassignUserID, stores the ID of the user RECEIVING the extractions. If the ID is set to 0, the extractions will be marked as REJECTED. The property, setProjectID can be set to: 0; the same id as the current project; the id of a different project.
Throws:: OpenAPIException; java.rmi.RemoteException

projectReassignUsers

void projectReassignUsers(AuthToken pAuthToken,
                          Project pProject,
                          ExtractionReassignmentDecision[] pReassignIDs)
                          throws java.rmi.RemoteException,
                                 OpenAPIException

Reassigns user and their extractions from one project to another

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being updated.; pReassignIDs - This stores an array of ExtractionReassignmentDecision objects. The property, setReassignUserID, stores the ID of the user being reassigned. The property, setProjectID stores the id of the project to which the user and their extractions are being reassigned.
Throws:: java.rmi.RemoteException; OpenAPIException

projectReadUserTypes

ProjectUserType projectReadUserTypes(AuthToken pAuthToken)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

Reads project user types

Parameters:: pAuthToken - authtoken against which to validate the user.
Returns:: A ProjectUserTypeBean object
Throws:: java.rmi.RemoteException; OpenAPIException

projectReadParentProjects

Project[] projectReadParentProjects(AuthToken pAuthToken,
                                    Project pProject)
                                    throws java.rmi.RemoteException,
                                           OpenAPIException

Read related parent projects.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of Project objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadParentProjectIDs

java.lang.String[] projectReadParentProjectIDs(AuthToken pAuthToken,
                                               Project pProject)
                                               throws java.rmi.RemoteException,
                                                      OpenAPIException

Read related parent project IDs.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of String objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadChildProjects

Project[] projectReadChildProjects(AuthToken pAuthToken,
                                   Project pProject)
                                   throws java.rmi.RemoteException,
                                          OpenAPIException

Read related child projects.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of Project objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadChildProjectIDs

java.lang.String[] projectReadChildProjectIDs(AuthToken pAuthToken,
                                              Project pProject)
                                              throws java.rmi.RemoteException,
                                                     OpenAPIException

Read related child project IDs.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of String objects representing the Project IDs
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadExtractions

Extraction[] projectReadExtractions(AuthToken pAuthToken,
                                    Project pProject)
                                    throws java.rmi.RemoteException,
                                           OpenAPIException

Read extractions of a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: Array of Extraction objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadExtractionAssetIDs

java.lang.String[] projectReadExtractionAssetIDs(AuthToken pAuthToken,
                                                 Project pProject)
                                                 throws java.rmi.RemoteException,
                                                        OpenAPIException

Read extraction Asset IDs of a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of String objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadAssets

ProjectAsset[] projectReadAssets(AuthToken pAuthToken,
                                 Project pProject)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException

Read extraction Asset IDs of a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of ProjectAsset objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadPrescribedAssets

Asset[] projectReadPrescribedAssets(AuthToken pAuthToken,
                                    Project pProject)
                                    throws java.rmi.RemoteException,
                                           OpenAPIException

Method projectReadPrescribedAssets.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of Assets
Throws:: java.rmi.RemoteException; OpenAPIException

projectReadAppliedComplianceTemplates

RelatedEntity[] projectReadAppliedComplianceTemplates(AuthToken pAuthToken,
                                                      Project pProject)
                                                      throws java.rmi.RemoteException,
                                                             OpenAPIException

Read applied Compliance Templates

Parameters:: pAuthToken - authtoken agains which to validate the user.; pProject - project being read from.
Returns:: An array of RelatedEntity objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadProducedAssets

Asset[] projectReadProducedAssets(AuthToken pAuthToken,
                                  Project pProject)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Read produced assets of a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of Asset objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectReadProducedAssetIDs

java.lang.String[] projectReadProducedAssetIDs(AuthToken pAuthToken,
                                               Project pProject)
                                               throws java.rmi.RemoteException,
                                                      OpenAPIException

Read produced asset IDs of a project

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - project being read from.
Returns:: An array of String objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectQuery

Project[] projectQuery(AuthToken pAuthToken,
                       ProjectCriteria pQuery)
                       throws java.rmi.RemoteException,
                              OpenAPIException

Search for a project and return an array of Projects

Parameters:: pAuthToken - authtoken against which to validate the user.; pQuery - ProjectCriteria object that stores the search criteria.
Returns:: An array of Project Objects
Throws:: OpenAPIException; java.rmi.RemoteException

projectQuerySummary

ProjectSummary[] projectQuerySummary(AuthToken pAuthToken,
                                     ProjectCriteria pQuery)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

Search for a project and return an array of ProjectSummaries

Parameters:: pAuthToken - authtoken against which to validate the user.; pQuery - ProjectCriteria object that stores the search criteria.
Returns:: ProjectSummary[]
Throws:: OpenAPIException; java.rmi.RemoteException

projectValidate

Results projectValidate(AuthToken pAuthToken,
                        Project pProject,
                        ProjectEntities pProjectEntities)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Validate project. Returns a Results object that contains any validation errors.

Parameters:: pAuthToken - authtoken against which to validate the user.; pProject - Project being validated.; pProjectEntities - This stores any linked entities of a project (related projects, users)
Returns:: Results
Throws:: java.rmi.RemoteException; OpenAPIException

departmentCreate

Department departmentCreate(AuthToken pAuthToken,
                            java.lang.String pName,
                            java.lang.String pDescription)
                            throws java.rmi.RemoteException,
                                   com.flashline.registry.openapi.base.APIValidationException,
                                   OpenAPIException

Creates a new Department. A department with that name cannot already exist.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; pName - The name of the new department. Required.; pDescription - The description of the new department. Optional.
Returns:: Returns the created department.
Throws:: APIValidationException; OpenAPIException; java.rmi.RemoteException

departmentRead

Department departmentRead(AuthToken pAuthToken,
                          java.lang.String pKey)
                          throws java.rmi.RemoteException,
                                 com.flashline.registry.openapi.base.APIValidationException,
                                 OpenAPIException

Gets a department by name.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have view permission.; pKey - The name of the department
Returns:: Returns the department if found.
Throws:: APIValidationException; OpenAPIException; java.rmi.RemoteException

departmentUpdate

Department departmentUpdate(AuthToken pAuthToken,
                            Department pDepartment)
                            throws java.rmi.RemoteException,
                                   com.flashline.registry.openapi.base.APIValidationException,
                                   OpenAPIException

Update a department.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; pDepartment - A department object holding the new values.
Returns:: Returns the updated department.
Throws:: APIValidationException; OpenAPIException; java.rmi.RemoteException

departmentQuery

Department[] departmentQuery(AuthToken pAuthToken,
                             DepartmentCriteria pCriteria)
                             throws java.rmi.RemoteException,
                                    com.flashline.registry.openapi.base.APIValidationException,
                                    OpenAPIException

Search for a department.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have view permission.; pCriteria - The criteria of the search.
Returns:: returns an array of Department objects.
Throws:: APIValidationException; OpenAPIException; java.rmi.RemoteException

acceptableValueListCreate

AcceptableValueList acceptableValueListCreate(AuthToken pAuthToken,
                                              java.lang.String pListName,
                                              AcceptableValue[] pValues)
                                              throws java.rmi.RemoteException,
                                                     OpenAPIException

Creates a new acceptable value list. Acceptable value lists constist of a name and a list of values that make up the list. The name must be unique in the system. If it is not unique, an OpenAPIException will be thrown.

Parameters:: pAuthToken - authtoken against which to validate the user; pListName - The name of the acceptable value list - this must be unique; pValues - The list of values that are acceptable for this list
Returns:: The acceptable value list that was just created
Throws:: OpenAPIException - When there is a problem creating the acceptable value list; java.rmi.RemoteException

acceptableValueListRead

AcceptableValueList acceptableValueListRead(AuthToken pAuthToken,
                                            long pId)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Read an acceptable value list. This acceptable value list contains the list of the valid values for drop-down boxes and multiple selection lists elements that used in asset custom metadata.

Parameters:: pAuthToken - authtoken against which to validate the user; pId - ID of the AcceptableValueList to read
Returns:: AcceptableValueList the AcceptableValueList corresponding to ID pID
Throws:: OpenAPIException - When there is a problem reading the acceptable value list; java.rmi.RemoteException

acceptableValueListUpdate

AcceptableValueList acceptableValueListUpdate(AuthToken pAuthToken,
                                              AcceptableValueList pList)
                                              throws java.rmi.RemoteException,
                                                     OpenAPIException

Updates an acceptable value list, modifying both the name of the list and the acceptable values.

Parameters:: pAuthToken - authtoken against which to validate the user; pList - The acceptable value list to save
Returns:: The acceptable value list after it has been saved
Throws:: OpenAPIException - When there is a problem updating the acceptable value list; java.rmi.RemoteException

acceptableValueListQuery

AcceptableValueList[] acceptableValueListQuery(AuthToken pAuthToken,
                                               AcceptableValueListCriteria pCriteria)
                                               throws java.rmi.RemoteException,
                                                      OpenAPIException

Searches for all acceptable value lists that contains the specified string (ignoring case)

Parameters:: pAuthToken - authtoken against which to validate the user; pCriteria - A criteria object containing the name of the list for which to search
Returns:: AcceptableValueList[] The lists matching the name, or an empty array if no lists match the name
Throws:: OpenAPIException - When there is a problem finding the acceptable value lists. Note that finding no results will not cause an exception to be thrown.; java.rmi.RemoteException

assetTypeCreateClone

AssetType assetTypeCreateClone(AuthToken pAuthToken,
                               long pBaseAssetTypeID,
                               java.lang.String pName)
                               throws java.rmi.RemoteException,
                                      OpenAPIException

Creates a new asset type based on an existing asset type. The new asset type will be exactly like the old asset type, except for its name and id. After you have created this new asset type, you may update this new asset type without affecting the original asset type.

Parameters:: pAuthToken - authtoken against which to validate the user; pBaseAssetTypeID - The ID of the asset type to base the new asset type on.; pName - The name of the new asset type. This name must be unique.
Returns:: The new asset type
Throws:: OpenAPIException - When there is a problem creating the new asset type.; java.rmi.RemoteException

assetTypeCreate

AssetType assetTypeCreate(AuthToken pAuthToken,
                          java.lang.String pName)
                          throws java.rmi.RemoteException,
                                 OpenAPIException

Creates a new asset type that contains minimal metadata elements.

Parameters:: pAuthToken - authtoken against which to validate the user; pName - The name of the new asset type. This name must be unique.
Returns:: The new asset type
Throws:: OpenAPIException - When there is a problem creating the new asset type.; java.rmi.RemoteException

assetTypeCreateComplianceTemplate

AssetType assetTypeCreateComplianceTemplate(AuthToken pAuthToken,
                                            java.lang.String pName)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Creates a new compliance template that contains minimal metadata elements.

Parameters:: pAuthToken - authtoken against which to validate the user; pName - The name of the new asset type. This name must be unique.; pArcheType - the ArcheType of the type being created.
Returns:: The new asset type
Throws:: OpenAPIException - When there is a problem creating the new asset type.; java.rmi.RemoteException

assetTypeRead

AssetType assetTypeRead(AuthToken pAuthToken,
                        long pId)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Creates a new compliance template that contains minimal metadata elements.

Parameters:: pAuthToken - authtoken against which to validate the user; pName - The name of the new asset type. This name must be unique.; pArcheType - the ArcheType of the type being created.
Returns:: The new asset type
Throws:: OpenAPIException - When there is a problem creating the new asset type.; java.rmi.RemoteException

assetTypeGetEntityArtifactRules

com.oracle.registry.openapi.entity.EntityArtifactRule[] assetTypeGetEntityArtifactRules(AuthToken pAuthTokenBean,
                                                                                        long pAssetTypeId)
                                                                                        throws java.rmi.RemoteException,
                                                                                               OpenAPIException

Returns an array of EntityArtifactRule for the given Asset Type ID.

Parameters:: pAuthTokenBean - authtoken against which to validate the user; pAssetTypeId - The ID of the asset type to retrieve
Returns:: array of EntityArtifactRules
Throws:: OpenAPIException - When there is a problem retrieving the EntityArtifactRules.; java.rmi.RemoteException

assetTypeUpdate

AssetType assetTypeUpdate(AuthToken pAuthToken,
                          AssetType pAssetType)
                          throws java.rmi.RemoteException,
                                 OpenAPIException

Updates an existing asset type.

Parameters:: pAuthToken - authtoken against which to validate the user; pAssetType - The updated asset type to save
Returns:: The asset type after it has been updated and saved
Throws:: OpenAPIException - When there is a problem reading the asset type.; java.rmi.RemoteException

assetTypeDelete

void assetTypeDelete(AuthToken pAuthToken,
                     long pId)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Deletes an existing asset type based on an ID.

Parameters:: pAuthToken - authtoken against which to validate the user; pId - The ID of the asset type to be deleted
Throws:: OpenAPIException - When there is a problem deleting the asset type.; java.rmi.RemoteException

assetTypeQuery

AssetType[] assetTypeQuery(AuthToken pAuthToken,
                           AssetTypeCriteria pCriteria)
                           throws java.rmi.RemoteException,
                                  OpenAPIException

Searches for all asset types whose names contain the specified string (ignoring case)

Parameters:: pAuthToken - authtoken against which to validate the user; pCriteria - The search criteria that specify the name to search for
Returns:: The array of asset types matching the name, or an empty array if no asset types match the name
Throws:: OpenAPIException - When there is a problem finding the asset types. Note that finding no results will not cause an exception to be thrown.; java.rmi.RemoteException

assetTypeSchemaRead

java.lang.String assetTypeSchemaRead(AuthToken pAuthToken,
                                     long pId)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

Get the xml schema for an asset type. The schema can be used to evaluate the XML of an asset that can then be used in the method assetCreateFromXML.

Parameters:: pAuthToken - Authtoken against which to validate the user; pId - The ID of the asset type to get the schema.
Returns:: The xml schema for an asset type.
Throws:: OpenAPIException; java.rmi.RemoteException

configGetWebResourcePath

java.lang.String configGetWebResourcePath()
                                          throws java.rmi.RemoteException

Gets the Web server path to the location where Web resources are stored.

Returns:: The setting value
Throws:: java.rmi.RemoteException

systemSettingsAddBundle

void systemSettingsAddBundle(AuthToken pAuthToken,
                             java.lang.String pXml)
                             throws java.rmi.RemoteException,
                                    OpenAPIException

Adds a XML bundle to the system.

Parameters:: pAuthToken -; pXml -
Throws:: OpenAPIException; java.rmi.RemoteException

systemSettingsQuery

SettingValue[] systemSettingsQuery(AuthToken pAuthToken,
                                   SystemSettingsCriteria pCriteria)
                                   throws java.rmi.RemoteException,
                                          OpenAPIException

Queries for a system setting

Parameters:: pAuthToken -; pCriteria -
Returns:: SettingValue object
Throws:: OpenAPIException; java.rmi.RemoteException

userCreate

RegistryUser userCreate(AuthToken pAuthToken,
                        java.lang.String pUserName,
                        java.lang.String pFirstName,
                        java.lang.String pLastName,
                        java.lang.String pEmail,
                        java.lang.String pPassword,
                        boolean pMustChangePassword,
                        boolean pPasswordNeverExpires,
                        boolean pAssignDefaultRoles)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Create a new user.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have create permission.; pUserName - The username of the new user.; pFirstName - The first name of the new user.; pLastName - The last name of the new user.; pEmail - The email address of the new user.; pPassword - The password of the new user.; pMustChangePassword - True if the user must change password upon next login.; pPasswordNeverExpires - True if the user's password never expires.; pAssignDefaultRoles - True if user is to be automatically assigned default roles.
Returns:: The newly created user.
Throws:: OpenAPIException; java.rmi.RemoteException

userRead

RegistryUser userRead(AuthToken pAuthToken,
                      long pId)
                      throws java.rmi.RemoteException,
                             OpenAPIException

Retrieve an existing user.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have view permission.; pId - The id of the user to retrieve.
Returns:: The existing user.
Throws:: OpenAPIException; java.rmi.RemoteException

userReadByAuthToken

RegistryUser userReadByAuthToken(AuthToken pAuthToken)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException

Retrieve an existing user.

Parameters:: pAuthToken - Authtoken for the user to retrieve.
Returns:: The existing user.
Throws:: OpenAPIException; java.rmi.RemoteException

userUpdate

RegistryUser userUpdate(AuthToken pAuthToken,
                        RegistryUser pRbacRegistrySecUserBean)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Update a user.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pRbacRegistrySecUserBean - The user to update.
Returns:: The updated user.
Throws:: OpenAPIException; java.rmi.RemoteException

userActivate

RegistryUser userActivate(AuthToken pAuthToken,
                          long pId)
                          throws java.rmi.RemoteException,
                                 OpenAPIException

Set a user's active status to active.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pId - The id of the user.
Returns:: The updated user.
Throws:: OpenAPIException; java.rmi.RemoteException

userDeactivate

RegistryUser userDeactivate(AuthToken pAuthToken,
                            long pId)
                            throws java.rmi.RemoteException,
                                   OpenAPIException

Set a user's active status to inactive.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pId - The id of the user.
Returns:: The updated user.
Throws:: OpenAPIException; java.rmi.RemoteException

userLockout

RegistryUser userLockout(AuthToken pAuthToken,
                         long pId)
                         throws java.rmi.RemoteException,
                                OpenAPIException

Set a user's active status to locked out.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pId - The id of the user.
Returns:: The locked out user.
Throws:: OpenAPIException; java.rmi.RemoteException

userUnapprove

RegistryUser userUnapprove(AuthToken pAuthToken,
                           long pId)
                           throws java.rmi.RemoteException,
                                  OpenAPIException

Set a user's active status to unapproved.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pId - The id of the user.
Returns:: The unapproved user.
Throws:: OpenAPIException; java.rmi.RemoteException

userQuery

RegistryUser[] userQuery(AuthToken pAuthToken,
                         UserCriteria pCriteria)
                         throws java.rmi.RemoteException,
                                OpenAPIException

Search for users.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have view permission.; pCriteria - The criteria to search for.
Returns:: Array of users that match search criteria.
Throws:: OpenAPIException; java.rmi.RemoteException

userAddRole

RegistryUser userAddRole(AuthToken pAuthToken,
                         long pId,
                         java.lang.String pRoleName)
                         throws java.rmi.RemoteException,
                                OpenAPIException

Add a role to an existing user.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pId - The id of the user.; pRoleName - The name of the role to add to the user.
Returns:: The updated user.
Throws:: OpenAPIException; java.rmi.RemoteException

userRemoveRole

RegistryUser userRemoveRole(AuthToken pAuthToken,
                            long pId,
                            java.lang.String pRoleName)
                            throws java.rmi.RemoteException,
                                   OpenAPIException

Removes a role from a user.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pId - The id of the user.; pRoleName - The name of the role to remove from the user.
Returns:: An RbacRegistrySecUserBean object
Throws:: OpenAPIException; java.rmi.RemoteException

unitTestUserResetDatabase

void unitTestUserResetDatabase()
                               throws java.rmi.RemoteException,
                                      OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

customAccessSettingNamesGet

java.lang.String[] customAccessSettingNamesGet(AuthToken pAuthToken,
                                               java.lang.String pType)
                                               throws java.rmi.RemoteException,
                                                      OpenAPIException

Retrieve an array of existing cutom access setting names.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have view permission.; pType - The of custom access setting to retrieve (all, asset, file). See customAccessSettingTypesGet.
Returns:: The custom access setting names of specified type.
Throws:: OpenAPIException; java.rmi.RemoteException

customAccessSettingDefaultNamesGet

java.lang.String[] customAccessSettingDefaultNamesGet(AuthToken pAuthToken,
                                                      java.lang.String pType)
                                                      throws java.rmi.RemoteException,
                                                             OpenAPIException

Retrieve an array of the default custom access setting names of a particular type.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have view permission.; pType - The of default custom access setting to retrieve (all, asset, file) See customAccessSettingTypesGet.
Returns:: The default custom access names of specified type.
Throws:: OpenAPIException; java.rmi.RemoteException

customAccessSettingTypesGet

java.lang.String[] customAccessSettingTypesGet(AuthToken pAuthToken)
                                               throws java.rmi.RemoteException,
                                                      OpenAPIException

Retrieve an array of custom access setting types.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have view permission.
Returns:: Custom access setting types.
Throws:: OpenAPIException; java.rmi.RemoteException

rbacHasPermission

boolean rbacHasPermission(AuthToken pAuthToken,
                          long pUserID,
                          java.lang.String[] pRoleContextNames,
                          java.lang.String pPermissionName)
                          throws java.rmi.RemoteException

Determine if a user has permission for a given set of rolecontexts, and a permission name. Note that this method will throw an exception if the user does not have permission to view access control information (view permission on the Basic Access Settings role context).

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have view permission in the BAS role context.; pUserID - user for which to evaluate permissions; pRoleContextNames - names of role contexts to include in evaluation; pPermissionName - the permission name to evaluate
Returns:
Throws:: java.rmi.RemoteException

roleCreate

Role roleCreate(AuthToken pAuthToken,
                java.lang.String pName,
                java.lang.String pDesc,
                boolean pDefaultForNewUser)
                throws java.rmi.RemoteException,
                       OpenAPIException

Create a new role.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have create permission.; pName - The name of the the new role.; pDesc - The description of the new role.; pDefaultForNewUser - True if this new role is to be assigned by default to new users.
Returns:: The new role.
Throws:: OpenAPIException; java.rmi.RemoteException

roleRead

Role roleRead(AuthToken pAuthToken,
              java.lang.String pName)
              throws java.rmi.RemoteException,
                     OpenAPIException

Retrieve an existing role.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have create permission.; pName - The name of the role to retrieve.
Returns:: The specified role.
Throws:: OpenAPIException; java.rmi.RemoteException

roleUpdate

Role roleUpdate(AuthToken pAuthToken,
                Role pRoleType)
                throws java.rmi.RemoteException,
                       OpenAPIException

Update an existing role.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have edit permission.; pRoleType - The role to update.
Returns:: The updated role.
Throws:: OpenAPIException; java.rmi.RemoteException

roleDelete

void roleDelete(AuthToken pAuthToken,
                java.lang.String pName)
                throws java.rmi.RemoteException,
                       OpenAPIException

Delete an existing role.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have delete permission.; pName - The name of the role to delete.
Throws:: OpenAPIException; java.rmi.RemoteException

roleQuery

Role[] roleQuery(AuthToken pAuthToken,
                 RoleCriteria pCriteria)
                 throws java.rmi.RemoteException,
                        OpenAPIException

Serach for roles.

Parameters:: pAuthToken - Authtoken against which to validate the user. Must have view permission.; pCriteria - The criteria to search for.
Returns:: The roles that match the search criteria.
Throws:: OpenAPIException; java.rmi.RemoteException

relationshipTypeCreate

RelationshipType relationshipTypeCreate(AuthToken pAuthToken,
                                        java.lang.String pName)
                                        throws java.rmi.RemoteException,
                                               OpenAPIException

Creates a new relationship type.

Parameters:: pAuthToken - authtoken against which to validate the user; pName - name of the new relationship type
Returns:: the new relationship type
Throws:: OpenAPIException - when there is a problem creating the relationship type; java.rmi.RemoteException

relationshipTypeRead

RelationshipType relationshipTypeRead(AuthToken pAuthToken,
                                      long pID)
                                      throws java.rmi.RemoteException,
                                             OpenAPIException

Reads a relationship type based on a unique ID.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the ID of the relationship type to retrieve
Returns:: the requested relationship type
Throws:: OpenAPIException - when there is a problem reading the relationship type; java.rmi.RemoteException

relationshipTypeUpdate

RelationshipType relationshipTypeUpdate(AuthToken pAuthToken,
                                        RelationshipType pRelationshipType)
                                        throws java.rmi.RemoteException,
                                               OpenAPIException

Updates a relationship type object.

Parameters:: pAuthToken - authtoken against which to validate the user; pRelationshipType - the updated relationship type
Returns:: the updated relationship type after it has been saved
Throws:: OpenAPIException - when there is a problem reading the relationship type; java.rmi.RemoteException

relationshipTypeDelete

void relationshipTypeDelete(AuthToken pAuthToken,
                            long pID)
                            throws java.rmi.RemoteException,
                                   OpenAPIException

Deletes a relationship type.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the ID of the relationship type to delete
Throws:: OpenAPIException - when there is a problem deleting the relationship type; java.rmi.RemoteException

relationshipTypeQuery

RelationshipType[] relationshipTypeQuery(AuthToken pAuthToken,
                                         RelationshipTypeCriteria pQuery)
                                         throws java.rmi.RemoteException,
                                                OpenAPIException

Searches for all relationship types that match the specified criteria. Valid criteria includes the relationship type name as a String. Case is ignored.

Parameters:: pAuthToken - authtoken against which to validate the user; pQuery - a criteria object containing the name of the relationship type for which to search
Returns:: an array of relationship types matching the criteria, or an empty array if no relationship types match
Throws:: OpenAPIException - when there is a problem finding relationship types. Note that finding no results will not cause an exception to be thrown.; java.rmi.RemoteException

surveyTakenRead

SurveyTaken surveyTakenRead(AuthToken pAuthToken,
                            Extraction pExtraction)
                            throws java.rmi.RemoteException,
                                   OpenAPIException

Read SurveyTaken

Parameters:: pAuthToken - authtoken against which to validate the user; pExtraction - Object of the extraction being updated.
Returns:: An SurveyTaken Object
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

surveyReadQuestions

Question[] surveyReadQuestions(AuthToken pAuthToken)
                               throws java.rmi.RemoteException,
                                      OpenAPIException

Read Questions

Parameters:: pAuthToken - pAuthToken authtoken against which to validate the user
Returns:: An array of Question objects
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

surveyTakenUpdate

SurveyTaken surveyTakenUpdate(AuthToken pAuthToken,
                              SurveyTaken pSurveyTaken)
                              throws java.rmi.RemoteException,
                                     OpenAPIException

Update SurveyTaken

Parameters:: pAuthToken - pAuthToken authtoken against which to validate the user; pSurveyTaken - Survey Taken being updated or created.
Returns:: A SurveyTaken object
Throws:: OpenAPIException - if anything goes wrong; java.rmi.RemoteException

vendorCreate

Vendor vendorCreate(AuthToken pAuthToken,
                    java.lang.String pName)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Creates a new vendor

Parameters:: pAuthToken - authtoken against which to validate the user; pName - Name of the new vendor. Maximum length = 250.
Returns:: The new vendor
Throws:: OpenAPIException - When there is a problem creating the vendor; java.rmi.RemoteException

vendorRead

Vendor vendorRead(AuthToken pAuthToken,
                  long pID)
                  throws java.rmi.RemoteException,
                         OpenAPIException

Reads a vendor

Parameters:: pAuthToken - authtoken against which to validate the user; pID - The ID of the vendor to read
Returns:: the requested vendor
Throws:: OpenAPIException - When there is a problem reading the vendor; java.rmi.RemoteException

vendorUpdate

Vendor vendorUpdate(AuthToken pAuthToken,
                    Vendor pVendor)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Updates a vendor

Parameters:: pAuthToken - authtoken against which to validate the user; pVendor - the updated vendor
Returns:: the vendor after it has been updated
Throws:: OpenAPIException - When there is a problem updating the vendor; java.rmi.RemoteException

vendorDelete

void vendorDelete(AuthToken pAuthToken,
                  long pID)
                  throws java.rmi.RemoteException,
                         OpenAPIException

Deletes a vendor.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - The ID of the vendor to delete
Throws:: OpenAPIException - When there is a problem deleting the vendor; java.rmi.RemoteException

vendorQuery

Vendor[] vendorQuery(AuthToken pAuthToken,
                     VendorCriteria pQuery)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Searches for all vendors whose names contain the specified string (ignoring case)

Parameters:: pAuthToken - authtoken against which to validate the user; pQuery - A criteria object containing the name of the vendor for which to search
Returns:: The vendors matching the name, or an empty array if no vendors match the name
Throws:: OpenAPIException - When there is a problem finding vendors. Note that finding no results will not cause an exception to be thrown.; java.rmi.RemoteException

exportListJobs

ImpExpJob[] exportListJobs(AuthToken pAuthToken)
                           throws java.rmi.RemoteException,
                                  OpenAPIException,
                                  ImportExportException

Returns a list of export jobs currently defined in the system. The jobs may or may not be currently running.

Parameters:: pAuthToken - the credentials of the user performing the export
Returns:: an array of ImpExpJob beans describing the currently defined jobs
Throws:: ImportExportException; OpenAPIException; java.rmi.RemoteException

exportExecute

ImpExpJob exportExecute(AuthToken pAuthToken,
                        java.lang.String pExportFormat,
                        java.lang.String[] pExportFormatQualifiers,
                        java.lang.String pDesc,
                        java.lang.String pQueryFormat,
                        java.lang.String pQuery)
                        throws java.rmi.RemoteException,
                               OpenAPIException,
                               ImportExportException

Starts an export job running on the server. This method is NON-BLOCKING. That is, if the job is successfully started, this method immediately returns a JobBean that represents the state of the started export job. The caller is then expected to make subsequent calls to the exportStatus method to determine the status of the running export job. The returned JobBean is the "handle" to the export job, and should be retained so that it can be passed in future calls to other methods in the ImportExport subsystem.

Parameters:: pAuthToken - the credentials of the user performing the export; pFormat - the format to use for the export. The only currently supported format is "flashline".; pParams - parameters to customize the format. Currently not used.; pDesc - a description of the export job.
Returns:: a JobBean describing the current state of the export job.
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException

exportGetAuditB64

byte[] exportGetAuditB64(AuthToken pAuthToken,
                         ImpExpJob pJobBean,
                         java.lang.String pAuditFormat)
                         throws java.rmi.RemoteException,
                                OpenAPIException,
                                ImportExportException

Returns the Audit results of the export operation specified by pJobBean. The results are delivered as a Base64 encoded payload. Note that this method can cause HUGE memory consumption on the application server (roughly three times the size of the delivered payload will be used from the heap). Note that other delivery mechanisms are availalbe (DIME and Soap with Attachments).

Parameters:: pAuthToken - the credentials of the user performing the export; pJobBean - the handle of the job for which to retrieve results; pAuditFormat - currently, the only supported format is "plaintext".
Returns:: a Base64 encoded representation of the export audit results.
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetAuditDIME(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String), exportGetAuditSwA(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String)

exportGetAuditDIME

void exportGetAuditDIME(AuthToken pAuthToken,
                        ImpExpJob pJobBean,
                        java.lang.String pAuditFormat)
                        throws java.rmi.RemoteException,
                               OpenAPIException,
                               ImportExportException

Returns the Audit results of the export operation specified by pJobBean. The results are delivered as a DIME encoded attachement. Note that other delivery mechanisms are availalbe (Base64 and Soap with Attachments).

Parameters:: pAuthToken - the credentials of the user performing the export; pJobBean - the handle of the job for which to retrieve results; pAuditFormat - currently, the only supported format is "plaintext".
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetAuditB64(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String), exportGetAuditSwA(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String)

exportGetAuditSwA

void exportGetAuditSwA(AuthToken pAuthToken,
                       ImpExpJob pJobBean,
                       java.lang.String pAuditFormat)
                       throws java.rmi.RemoteException,
                              OpenAPIException,
                              ImportExportException

Returns the Audit results of the export operation specified by pJobBean. The results are delivered as a Soap with Attachments encoded attachement. Note that other delivery mechanisms are available (Base64 and DIME).

Parameters:: pAuthToken - the credentials of the user performing the export; pJobBean - the handle of the job for which to retrieve results; pAuditFormat - currently, the only supported format is "plaintext".
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetAuditB64(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String), exportGetAuditDIME(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String)

exportGetLatestAuditMsg

AuditMsg exportGetLatestAuditMsg(AuthToken pAuthToken,
                                 ImpExpJob pJobBean)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException,
                                        ImportExportException

Returns the most recently added Audit message for the given export job. Suitable for status displays during export operations.

Parameters:: pAuthToken - the credentials of the user performing the export; pJobBean - the handle of the job for which to retrieve the latest audit message
Returns:: on object encapsulating the most recent audit message.
Throws:: ImportExportException; OpenAPIException; java.rmi.RemoteException

importGetAuditB64

byte[] importGetAuditB64(AuthToken pAuthToken,
                         ImpExpJob pJobBean,
                         java.lang.String pAuditFormat)
                         throws java.rmi.RemoteException,
                                OpenAPIException,
                                ImportExportException

Returns the Audit results of the import operation specified by pJobBean. The results are delivered as a Base64 encoded payload. Note that this method can cause HUGE memory consumption on the application server (roughly three times the size of the delivered payload will be used from the heap). Note that other delivery mechanisms are availalbe (DIME and Soap with Attachments).

Parameters:: pAuthToken - the credentials of the user performing the import; pJobBean - the handle of the job for which to retrieve results; pAuditFormat - currently, the only supported format is "plaintext".
Returns:: a Base64 encoded representation of the import audit results.
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetAuditDIME(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String), exportGetAuditSwA(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String)

importGetAuditDIME

void importGetAuditDIME(AuthToken pAuthToken,
                        ImpExpJob pJobBean,
                        java.lang.String pAuditFormat)
                        throws java.rmi.RemoteException,
                               OpenAPIException,
                               ImportExportException

Returns the Audit results of the import operation specified by pJobBean. The results are delivered as a DIME encoded attachment. Note that other delivery mechanisms are availalbe (Base64 and Soap with Attachments).

Parameters:: pAuthToken - the credentials of the user performing the import; pJobBean - the handle of the job for which to retrieve results; pAuditFormat - currently, the only supported format is "plaintext".
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetAuditB64(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String), exportGetAuditSwA(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String)

importGetAuditSwA

void importGetAuditSwA(AuthToken pAuthToken,
                       ImpExpJob pJobBean,
                       java.lang.String pAuditFormat)
                       throws java.rmi.RemoteException,
                              OpenAPIException,
                              ImportExportException

Returns the Audit results of the import operation specified by pJobBean. The results are delivered as a Soap with Attachments encoded attachment. Note that other delivery mechanisms are availalbe (Base64 and DIME).

Parameters:: pAuthToken - the credentials of the user performing the import; pJobBean - the handle of the job for which to retrieve results; pAuditFormat - currently, the only supported format is "plaintext".
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetAuditB64(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String), exportGetAuditDIME(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob, java.lang.String)

importGetLatestAuditMsg

AuditMsg importGetLatestAuditMsg(AuthToken pAuthToken,
                                 ImpExpJob pJobBean)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException,
                                        ImportExportException

Returns the most recently added Audit message for the given import job. Suitable for status displays during long-running import operations.

Parameters:: pAuthToken - the credentials of the user performing the import; pJobBean - the handle of the job for which to retrieve the latest audit message
Returns:: on object encapsulating the most recent audit message.
Throws:: ImportExportException; OpenAPIException; java.rmi.RemoteException

exportStatus

ImpExpJob exportStatus(AuthToken pAuthToken,
                       ImpExpJob pJob)
                       throws java.rmi.RemoteException,
                              OpenAPIException,
                              ImportExportException

Retrieves an updated description of the current status of the export job. This method is typically called repetitively to monitor the status of a running job, and inform the end user of the job's progress.

Parameters:: pAuthToken - the credentials of the user performing the export; pJob - the handle of the job for which to retrieve updated status
Returns:: an updated JobBean, containing status information for the running job.
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException

exportKill

void exportKill(AuthToken pAuthToken,
                ImpExpJob pJob)
                throws java.rmi.RemoteException,
                       OpenAPIException,
                       ImportExportException

Terminates a running export job. The terminated job is left in tact (i.e., the audit, payload, etc. is not disturbed). To completely remove the job, a call to exportCleanup must be made.

Parameters:: pAuthToken - the credentials of the user performing the export; pJob - the handle of the job to kill
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException

exportGetResultsB64

byte[] exportGetResultsB64(AuthToken pAuthToken,
                           ImpExpJob pJob)
                           throws java.rmi.RemoteException,
                                  OpenAPIException,
                                  ImportExportException

Returns the results of the export operation (i.e., the "payload") specified by pJobBean. The results are delivered as a Base64 encoded payload. Note that this method can cause HUGE memory consumption on the application server (roughly three times the size of the delivered payload will be used from the heap). Note that other delivery mechanisms are availalbe (DIME and Soap with Attachments).

Parameters:: pAuthToken - the credentials of the user performing the export; pJobBean - the handle of the job for which to retrieve results
Returns:: a Base64 encoded representation of the export results.
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetResultsDIME(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob), exportGetResultsSwA(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob)

exportGetResultsDIME

void exportGetResultsDIME(AuthToken pAuthToken,
                          ImpExpJob pJob)
                          throws java.rmi.RemoteException,
                                 OpenAPIException,
                                 ImportExportException

Returns the results of the export operation (i.e., the "payload") specified by pJobBean. The results are delivered as a DIME encoded attachment. Note that other delivery mechanisms are availalbe (Base64 and Soap with Attachments).

Parameters:: pAuthToken - the credentials of the user performing the export; pJobBean - the handle of the job for which to retrieve results
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetResultsB64(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob), exportGetResultsSwA(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob)

exportGetResultsSwA

void exportGetResultsSwA(AuthToken pAuthToken,
                         ImpExpJob pJob)
                         throws java.rmi.RemoteException,
                                OpenAPIException,
                                ImportExportException

Returns the results of the export operation (i.e., the "payload") specified by pJobBean. The results are delivered as a Soap with Attachments encoded attachment. Note that other delivery mechanisms are availalbe (Base64 and DIME).

Parameters:: pAuthToken - the credentials of the user performing the export; pJobBean - the handle of the job for which to retrieve results
Throws:: ImportExportException; java.rmi.RemoteException; OpenAPIException
See Also:: exportGetResultsB64(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob), exportGetResultsDIME(com.flashline.registry.openapi.entity.AuthToken, com.flashline.registry.openapi.entity.ImpExpJob)

exportCleanup

void exportCleanup(AuthToken pAuthToken,
                   ImpExpJob pJob)
                   throws java.rmi.RemoteException,
                          OpenAPIException,
                          ImportExportException

Cleans up a COMPLETED, FAILED, or CANCELLED export job. If a job is currently running, an ImportExportException is thrown. Performs the following cleanup tasks:

Removes the job from the job registry. That is, the job id will no longer be defined.
Deletes the audit trail for the job.
Deletes the results of the export from the export cache (i.e., the databse).

Parameters:: pAuthToken - the credentials of the user performing the export; pJob - the handle of the job for which to retrieve results
Throws:: ImportExportException; OpenAPIException; java.rmi.RemoteException

importListJobs

ImpExpJob[] importListJobs(AuthToken pAuthToken)
                           throws java.rmi.RemoteException,
                                  OpenAPIException,
                                  ImportExportException

Returns a list of import jobs currently defined in the system. The jobs may or may not be currently running.

Parameters:: pAuthToken - the credentials of the user performing the import
Returns:: an array of ImpExpJob beans describing the currently defined jobs
Throws:: ImportExportException; OpenAPIException; java.rmi.RemoteException

importExecute

ImpExpJob importExecute(AuthToken pAuthToken,
                        java.lang.String pImportFormat,
                        java.lang.String[] pImportFormatQualifiers,
                        java.lang.String pDesc,
                        byte[] pPayload)
                        throws java.rmi.RemoteException,
                               OpenAPIException,
                               ImportExportException

Import a file. If pPayload is present, will use the Base64-encoded file passed in that parameter. If pPayload is null, checks for SwA or DIME based attachments, and uses those as the payload. Note that this method is non-blocking. It returns a job handle immediatedly (assuming that the import starts successfully). The job handle should then be used to monitor status of the running job.

Parameters:: pAuthToken - the credentials of the user performing the export; pFormat - specifies the format of the attached import payload. Currently only "flashline" is supported.; pParams - parameters for the import format. NOT CURRENTLY USED.; pDesc - a descripton of the import job.; pPayload - the Base64-encoded payload. DO NOT included this parameter (i.e., leave it null) if you are planning on using DIME or SwA for passing the payload.
Returns:: a handle to the running job.
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException

importStatus

ImpExpJob importStatus(AuthToken pAuthToken,
                       ImpExpJob pJob)
                       throws java.rmi.RemoteException,
                              OpenAPIException,
                              ImportExportException

Retrieves an updated description of the current status of the import job. This method is typically called repetitively to monitor the status of a running job, and inform the end user of the job's progress.

Parameters:: pAuthToken - the credentials of the user performing the import; pJob - the handle of the job for which to retrieve updated status
Returns:: an updated JobBean, containing status information for the running job.
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException

importKill

void importKill(AuthToken pAuthToken,
                ImpExpJob pJob)
                throws java.rmi.RemoteException,
                       OpenAPIException,
                       ImportExportException

Terminates a running import job. The terminated job is left in tact (i.e., the audit, payload, etc. is not disturbed). To completely remove the job, a call to importCleanup must be made.

Parameters:: pAuthToken - the credentials of the user performing the import; pJob - the handle of the job to kill
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException

importCheckPermission

void importCheckPermission(AuthToken pAuthToken)
                           throws java.rmi.RemoteException,
                                  OpenAPIException,
                                  ImportExportException

Checks the permission level of the user represented by OER authentication credentials contained in pAuthToken to determine if they are allowed to perform an import. If the user does NOT have appropriate privileges, an ImportExportException will be thrown.

Parameters:: pAuthToken - the user for which to check permissions.
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException
See Also:: authTokenCreate(java.lang.String, java.lang.String)

exportCheckPermission

void exportCheckPermission(AuthToken pAuthToken)
                           throws java.rmi.RemoteException,
                                  OpenAPIException,
                                  ImportExportException

Checks the permission level of the user represented by OER authentication credentials contained in pAuthToken to determine if they are allowed to perform an export. If the user does NOT have appropriate privileges, an ImportExportException will be thrown.

Parameters:: pAuthToken - the user for which to check permissions.
Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException
See Also:: authTokenCreate(java.lang.String, java.lang.String)

importCleanup

void importCleanup(AuthToken pAuthToken,
                   ImpExpJob pJob)
                   throws java.rmi.RemoteException,
                          OpenAPIException,
                          ImportExportException

Cleans up a COMPLETED, FAILED, or CANCELLED import job. If a job is currently running, an ImportExportException is thrown. Performs the following cleanup tasks:

Removes the job from the job registry. That is, the job id will no longer be defined.
Deletes the audit trail for the job.

Parameters:: pAuthToken - the user for which to check permissions.; pJob - the handle of the job to cleanup
Throws:: ImportExportException; OpenAPIException; java.rmi.RemoteException

testClearCache

void testClearCache(AuthToken pAuthToken,
                    java.lang.String pCacheName)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testUpdateAssetDate

void testUpdateAssetDate(AuthToken pAuthToken,
                         long pAssetID,
                         java.lang.String pDateField,
                         java.util.Calendar pNewDate)
                         throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testUpdateTabStatus

void testUpdateTabStatus(AuthToken pAuthToken,
                         boolean pApproved,
                         long pUserID,
                         java.lang.String pTab,
                         long pAssetID,
                         java.util.Calendar pDate)
                         throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testCreateCustomAccessSetting

void testCreateCustomAccessSetting(AuthToken pAuthToken,
                                   java.lang.String pType,
                                   java.lang.String pRoleContextName,
                                   boolean pIsDefault)
                                   throws java.rmi.RemoteException,
                                          OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

getAssetMaxID

long getAssetMaxID()
                   throws java.rmi.RemoteException,
                          OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testThrowOpenAPIException

void testThrowOpenAPIException()
                               throws java.rmi.RemoteException,
                                      OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testSetSetting

void testSetSetting(java.lang.String pSettingName,
                    java.lang.String pSettingValue)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testGetSettingValue

java.lang.String testGetSettingValue(java.lang.String pSettingName)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testSetProperty

void testSetProperty(java.lang.String pPropName,
                     java.lang.String pPropValue)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testDeleteAsset

void testDeleteAsset(AuthToken pAuthToken,
                     long pAssetId)
                     throws java.rmi.RemoteException,
                            OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testDeleteUser

void testDeleteUser(AuthToken pAuthToken,
                    long pUserId)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testDeleteProject

void testDeleteProject(AuthToken pAuthToken,
                       long pProjectId)
                       throws java.rmi.RemoteException,
                              OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testDeleteAssetType

void testDeleteAssetType(AuthToken pAuthToken,
                         long pAssetId)
                         throws java.rmi.RemoteException,
                                OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testRestartJobMonitor

void testRestartJobMonitor()
                           throws java.rmi.RemoteException,
                                  OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testThrowImportExportException

void testThrowImportExportException(boolean pImpExp)
                                    throws java.rmi.RemoteException,
                                           OpenAPIException,
                                           ImportExportException

Throws:: java.rmi.RemoteException; OpenAPIException; ImportExportException

testGetLicenseState

boolean testGetLicenseState()
                            throws java.rmi.RemoteException,
                                   OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testDetermineDBPlatform

java.lang.String testDetermineDBPlatform()
                                         throws java.rmi.RemoteException,
                                                OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testSetLicenseState

void testSetLicenseState(boolean pLicensed)
                         throws java.rmi.RemoteException,
                                OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testAcceptableValueListDelete

void testAcceptableValueListDelete(AuthToken pAuthToken,
                                   long pID)
                                   throws java.rmi.RemoteException,
                                          OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testLogMessage

void testLogMessage(java.lang.String pMessage)
                    throws java.rmi.RemoteException,
                           OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testExtractionResetDatabaseForProject

void testExtractionResetDatabaseForProject(long pProjectID)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testUpdateViewAssetSetting

void testUpdateViewAssetSetting(boolean pRemove)
                                throws java.rmi.RemoteException,
                                       OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testCleanupNonRunningJobs

void testCleanupNonRunningJobs()
                               throws java.rmi.RemoteException,
                                      OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testUpdateUserRole

void testUpdateUserRole(long pUserID,
                        boolean pRemove)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testUpdateProjectAdminRole

void testUpdateProjectAdminRole(long pUserID,
                                boolean pRemove)
                                throws java.rmi.RemoteException,
                                       OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testClearDatabase

void testClearDatabase()
                       throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

sfidAddToAsset

void sfidAddToAsset(AuthToken pAuthToken,
                    SFIDInfo pSFID,
                    long assetID)
                    throws java.rmi.RemoteException

Associates a new SFIDInfo object to the asset specified in the SFIDInfo

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; SFID - SFIDInfo to add to the asset
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidRemoveAllFromAsset

void sfidRemoveAllFromAsset(AuthToken pAuthToken,
                            long assetID)
                            throws java.rmi.RemoteException

Remove all of the SFIDInfos associated with the specified asset

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; assetID - id of the asset from which to remove all of the SFIDInfos
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidUpdateAsset

void sfidUpdateAsset(AuthToken pAuthToken,
                     SFIDInfo[] pSFIDs,
                     long assetID)
                     throws java.rmi.RemoteException

Remove all of the existing SFIDInfos associated with an asset, and replace them with the new list

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; pSFIDs - list of HashInfo objects to update
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidReadValuesByProject

java.lang.String[] sfidReadValuesByProject(AuthToken pAuthToken,
                                           long projectid)
                                           throws java.rmi.RemoteException

Get all of the SFID values from all of the assets extracted to the specified project

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; projectid - id of the project
Returns:: String list of SFID values
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidQuery

SFIDInfo[] sfidQuery(AuthToken pAuthToken,
                     SFIDCriteria pCrit)
                     throws java.rmi.RemoteException

Get all of the SFID values from all of the assets extracted to the specified project

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; projectid - id of the project
Returns:: String list of SFID values
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidCandidateQuery

SFIDCandidate[] sfidCandidateQuery(AuthToken pAuthToken,
                                   SFIDCriteria pCrit)
                                   throws java.rmi.RemoteException

Deprecated. Not implemented.

Throws:: java.rmi.RemoteException

sfidGenerate

SFIDInfo[] sfidGenerate(AuthToken pAuthToken,
                        int pMethod)
                        throws java.rmi.RemoteException

Deprecated. Use com.oracle.artifact.fingerprint.ArtifactFingerprinter instead.

Throws:: java.rmi.RemoteException

sfidCandidateSubmit

SFIDCandidate[] sfidCandidateSubmit(AuthToken pAuthToken,
                                    SFIDCandidate[] pCandidates)
                                    throws java.rmi.RemoteException

This method submits a set of SFIDCandidates. The candidates will be stored for review and possible harvesting by a registrar. Note that NEW candidate records will only be created if candidate record does not already exist with the same:

sfid value
sfid algorithm
source (e.g., eclipse 3.0)
hostname
hostip
generating user

If a candidate is found in the system with the same attributes as one being submitted, the numSeen property will simply be incremented for the already existing record.

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; pCandidates -
Returns:: An array of SFIDCandidate array.
Throws:: java.rmi.RemoteException

sfidReadValuesForAsset

java.lang.String[] sfidReadValuesForAsset(AuthToken pAuthToken,
                                          long assetID)
                                          throws java.rmi.RemoteException

Get all of the hash values associated with the specified asset

Parameters:: pAuthToken - authtoken against which to validate the user. Must have edit permission.; assetID - id of the asset used to query the hash values
Returns:: String list of SFID values
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidRegisterExtractionBySFIDValue

void sfidRegisterExtractionBySFIDValue(AuthToken pAuthToken,
                                       long projectid,
                                       java.lang.String pSFID)
                                       throws java.rmi.RemoteException

Extract all assets with the following hash value to the specified project.

Parameters:: pAuthToken - authtoken against which to validate the user.; projectid - id of the project to extract to; pSFID - SFID value used to find assets
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidRegisterExtractionBySFIDValues

void sfidRegisterExtractionBySFIDValues(AuthToken pAuthToken,
                                        long projectid,
                                        java.lang.String[] pSFIDs)
                                        throws java.rmi.RemoteException

Extract all assets with any of the following hash values to the specified project

Parameters:: pAuthToken - authtoken against which to validate the user.; projectid - id of the project to extract to; pSFIDs - list of hash values used to find assets
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidRegisterExtractionBySFIDCandidates

AssetSummary[] sfidRegisterExtractionBySFIDCandidates(AuthToken pAuthToken,
                                                      long projectid,
                                                      SFIDCandidate[] pSFIDCandidates)
                                                      throws java.rmi.RemoteException

Extract all assets with any of the following hash values to the specified project and return an array of asset summaries for the extracted assets.

Parameters:: pAuthToken - authtoken against which to validate the user.; projectid - id of the project to extract to; pSFIDCandidates - list of SFID Candidates
Returns:: list of asset summaries showing which assets were extracted
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidRegisterExtractionBySFIDCandidatesLite

void sfidRegisterExtractionBySFIDCandidatesLite(AuthToken pAuthToken,
                                                long projectid,
                                                SFIDCandidate[] pSFIDCandidates)
                                                throws java.rmi.RemoteException

Extract all assets with any of the following hash values to the specified project without returning asset summaries for the extracted assets.

Parameters:: pAuthToken - authtoken against which to validate the user.; projectid - id of the project to extract to; pSFIDCandidates - list of SFID Candidates
Throws:: java.lang.Exception; java.rmi.RemoteException

sfidRegisterExtractions

void sfidRegisterExtractions(AuthToken pAuthToken,
                             long pProjectID,
                             SFIDCandidate[] pSFIDCandidates,
                             boolean pHarvest)
                             throws java.rmi.RemoteException

Register usage of assets to a specified project by matching SFIDs to files that are associated with assets. If the parameter pHarvest is set to true, SFIDs that are NOT matched will be retained for harvesting operations by a registrar.

Parameters:: pAuthToken - authtoken against which to validate the user; pProjectID - the id of the project to which extraction should occur; pSFIDCandidates - list of SFID values for matching; pHarvest - if true, retain unmatched SFID candidates for harvesting operations by a registrar
Throws:: java.rmi.RemoteException

sfidRegisterExtractionBySFIDValuesResults

AssetSummary[] sfidRegisterExtractionBySFIDValuesResults(AuthToken pAuthToken,
                                                         long projectid,
                                                         java.lang.String[] pSFIDs)
                                                         throws java.rmi.RemoteException

Extract all assets with any of the following hash values to the specified project

Parameters:: pAuthToken - authtoken against which to validate the user.; projectid - id of the project to extract to; pSFIDs - list of hash values used to find assets
Returns:: AssetSummary list of asset summaries showing which assets were extracted
Throws:: java.lang.Exception; java.rmi.RemoteException

reuseDTORead

ReuseDTO reuseDTORead()
                      throws java.rmi.RemoteException

This method returns a composite object containing all the information required to display the reuse portlet.

Returns:: A ReuseDTO object
Throws:: java.rmi.RemoteException

assetMetadataCreateDIME

void assetMetadataCreateDIME(AuthToken pAuthToken,
                             MetadataEntrySummary pMetadataEntrySummary)
                             throws java.rmi.RemoteException

Creates the metadata entry specified and associates it with the specified asset. Actual payload is expected to be attached as a DIME attachment, the associated tags and descriptive text for the entry are also saved.

Parameters:: pAuthToken - authtoken against which to validate the user.; pMetadataEntrySummary - metadata entry summary object to update
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataCreateSwA

void assetMetadataCreateSwA(AuthToken pAuthToken,
                            MetadataEntrySummary pMetadataEntrySummary)
                            throws java.rmi.RemoteException

Creates the metadata entry specified and associates it with the specified asset. Actual payload is expected to be attached as an SwA attachment, the associated tags and descriptive text for the entry are also saved.

Parameters:: pAuthToken - authtoken against which to validate the user.; pMetadataEntrySummary - metadata entry summary object to update
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataRead

MetadataEntrySummary[] assetMetadataRead(AuthToken pAuthToken,
                                         long pAssetID)
                                         throws java.rmi.RemoteException

Reads metadata entries associated with the given Asset. Actual payload is not included in the read, just associated tags and descriptive text.

Parameters:: pAuthToken - authtoken against which to validate the user.; pAssetID - id of Asset to load metadata for.
Returns:: array of MetadataEntrySummary objects for given asset
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataReadDIME

MetadataEntrySummary[] assetMetadataReadDIME(AuthToken pAuthToken,
                                             long pAssetID)
                                             throws java.rmi.RemoteException

Reads metadata entries associated with the given Asset. Actual payload is included as a DIME attachment, as well as associated tags and descriptive text.

Parameters:: pAuthToken - authtoken against which to validate the user.; pAssetID - id of Asset to load metadata for.
Returns:: array of MetadataEntrySummary objects for given asset, attachment(s) containing actual data
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataReadSwA

MetadataEntrySummary[] assetMetadataReadSwA(AuthToken pAuthToken,
                                            long pAssetID)
                                            throws java.rmi.RemoteException

Reads metadata entries associated with the given Asset. Actual payload is included as an SwA attachment, as well as associated tags and descriptive text.

Parameters:: pAuthToken - authtoken against which to validate the user.; pAssetID - id of Asset to load metadata for.
Returns:: array of MetadataEntrySummary objects for given asset, attachment(s) containing actual data
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataUpdate

void assetMetadataUpdate(AuthToken pAuthToken,
                         MetadataEntrySummary pMetadataEntrySummary)
                         throws java.rmi.RemoteException

Updates metadata entry specified. Actual payload is not expected to be attached, this just updates the just associated tags and descriptive text for the entry.

Parameters:: pAuthToken - authtoken against which to validate the user.; pMetadataEntrySummary - metadata entry summary object to update
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataUpdateDIME

void assetMetadataUpdateDIME(AuthToken pAuthToken,
                             MetadataEntrySummary pMetadataEntrySummary)
                             throws java.rmi.RemoteException

Updates metadata entry specified. Actual payload is expected to be attached as a DIME attachment, the associated tags and descriptive text for the entry are also updated.

Parameters:: pAuthToken - authtoken against which to validate the user.; pMetadataEntrySummary - metadata entry summary object to update
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataUpdateSwA

void assetMetadataUpdateSwA(AuthToken pAuthToken,
                            long pAssetID,
                            MetadataEntrySummary pMetadataEntrySummary)
                            throws java.rmi.RemoteException

Updates metadata entry specified. Actual payload is expected to be attached as an SwA attachment, the associated tags and descriptive text for the entry are also updated.

Parameters:: pAuthToken - authtoken against which to validate the user.; pMetadataEntrySummary - metadata entry summary object to update
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataEntryDelete

void assetMetadataEntryDelete(AuthToken pAuthToken,
                              long pMetadataEntryID)
                              throws java.rmi.RemoteException

Deletes the specified metadata entry and disassociates it from its parent Asset.

Parameters:: pAuthToken - authtoken against which to validate the user.; pMetadataEntryID - metadata entry id to delete
Throws:: java.lang.Exception; java.rmi.RemoteException

assetMetadataAccept

void assetMetadataAccept(AuthToken pAuthToken,
                         MetadataEntrySummary pMetadataEntrySummary)
                         throws java.rmi.RemoteException

Parameters:: pAuthToken -; pMetadataEntrySummary - Metadata Entry Summary
Throws:: java.lang.Exception; java.rmi.RemoteException

metadataEntryTypeCreate

MetadataEntryTypeSummary metadataEntryTypeCreate(AuthToken pAuthToken,
                                                 java.lang.String pName)
                                                 throws java.rmi.RemoteException

Creates a new metadata entry type.

Parameters:: pAuthToken - authtoken against which to validate the user; pName - the name of the new MetadataEntryType
Returns:: the newly created MetadataEntryType object
Throws:: OpenAPIException - when there is a problem creating the MetadataEntryType; java.rmi.RemoteException

metadataEntryTypeRead

MetadataEntryTypeSummary metadataEntryTypeRead(AuthToken pAuthToken,
                                               long pID)
                                               throws java.rmi.RemoteException

Reads a metadata entry type by ID.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the ID of the metadata entry type to read
Returns:: the requested metadata entry type object
Throws:: OpenAPIException - when there is a problem reading the metadata entry type; java.rmi.RemoteException

metadataEntryTypeUpdate

MetadataEntryTypeSummary metadataEntryTypeUpdate(AuthToken pAuthToken,
                                                 MetadataEntryTypeSummary pMetadataEntryType)
                                                 throws java.rmi.RemoteException

Updates a metadata entry type.

Parameters:: pAuthToken - authtoken against which to validate the user; pMetadataEntryType - the modified metadata entry type object to be saved
Returns:: the metadata entry type object after the modifications have been saved
Throws:: OpenAPIException - when there is a problem updating the metadata entry type; java.rmi.RemoteException

metadataEntryTypeDelete

void metadataEntryTypeDelete(AuthToken pAuthToken,
                             long pID)
                             throws java.rmi.RemoteException

Deletes a metadata entry type.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the unique ID of the metadata entry type to be deleted
Throws:: OpenAPIException - when there is a problem deleting the vendor; java.rmi.RemoteException

metadataEntryTypeQuery

MetadataEntryTypeSummary[] metadataEntryTypeQuery(AuthToken pAuthToken,
                                                  MetadataEntryTypeCriteria pQuery)
                                                  throws java.rmi.RemoteException

Searches for all metadata entry types whose names contain the specified criteria. Valid criteria includes the metadata entry type name as a String. Case is ignored.

Parameters:: pAuthToken - authtoken against which to validate the user; pQuery - a criteria object containing the name of the metadata entry type for which to search
Returns:: an array of metadata entry type objects matching the criteria, or an empty array if no metadata entry types match
Throws:: OpenAPIException - when there is a problem finding metadata entry types. Note that finding no results will not cause an exception to be thrown.; java.rmi.RemoteException

metadataEntryCreateDIME

MetadataEntrySummary metadataEntryCreateDIME(AuthToken pAuthToken,
                                             MetadataEntrySummary pMetadataEntrySummary)
                                             throws java.rmi.RemoteException,
                                                    OpenAPIException

Creates a new metadata entry. Actual payload is expected to be attached as a DIME attachment, the associated tags and descriptive text for the entry are also saved.

Parameters:: pAuthToken - authtoken against which to validate the user; pMetadataEntrySummary - the new metadata-entry object to create
Returns:: the newly created metadata-entry object
Throws:: OpenAPIException - when there is a problem creating the MetadataEntry; java.rmi.RemoteException

metadataEntryCreateSwA

MetadataEntrySummary metadataEntryCreateSwA(AuthToken pAuthToken,
                                            MetadataEntrySummary pMetadataEntrySummary)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Creates a new metadata entry. Actual payload is expected to be attached as an SwA attachment, the associated tags and descriptive text for the entry are also saved.

Parameters:: pAuthToken - authtoken against which to validate the user; pMetadataEntrySummary - the new metadata-entry object to create
Returns:: the newly created metadata-entry object
Throws:: OpenAPIException - when there is a problem creating the MetadataEntry; java.rmi.RemoteException

metadataEntryReadDIME

MetadataEntrySummary metadataEntryReadDIME(AuthToken pAuthToken,
                                           EntityUUID pEntityUUID)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Reads a metadata-entry by UUID. Actual payload is included as a DIME attachment, as well as associated tags and descriptive text.

Parameters:: pAuthToken - authtoken against which to validate the user; pEntityUUID - the UUID of the metadata-entry to read
Returns:: the requested metadata-entry object
Throws:: OpenAPIException - when there is a problem reading the MetadataEntry; java.rmi.RemoteException

metadataEntryReadDIME

MetadataEntrySummary metadataEntryReadDIME(AuthToken pAuthToken,
                                           long pID)
                                           throws java.rmi.RemoteException,
                                                  OpenAPIException

Reads a metadata-entry by ID. Actual payload is included as an SwA attachment, as well as associated tags and descriptive text.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the ID of the metadata-entry to read
Returns:: the requested metadata-entry object
Throws:: OpenAPIException - when there is a problem reading the MetadataEntry; java.rmi.RemoteException

metadataEntryReadSwA

MetadataEntrySummary metadataEntryReadSwA(AuthToken pAuthToken,
                                          EntityUUID pEntityUUID)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Reads a metadata-entry by UUID. Actual payload is included as an SwA attachment, as well as associated tags and descriptive text.

Parameters:: pAuthToken - authtoken against which to validate the user; pEntityUUID - the UUID of the metadata-entry to read
Returns:: the requested metadata-entry object
Throws:: OpenAPIException - when there is a problem reading the MetadataEntry; java.rmi.RemoteException

metadataEntryReadSwA

MetadataEntrySummary metadataEntryReadSwA(AuthToken pAuthToken,
                                          long pID)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Reads a metadata-entry by ID. Actual payload is included as an SwA attachment, as well as associated tags and descriptive text.

Parameters:: pAuthToken - authtoken against which to validate the user; pID - the ID of the metadata-entry to read
Returns:: the requested metadata-entry object
Throws:: OpenAPIException - when there is a problem reading the MetadataEntry; java.rmi.RemoteException

metadataEntryUpdateDIME

MetadataEntrySummary metadataEntryUpdateDIME(AuthToken pAuthToken,
                                             MetadataEntrySummary pMetadataEntrySummary)
                                             throws java.rmi.RemoteException,
                                                    OpenAPIException

Updates a metadata-entry. Actual payload is expected to be attached as a DIME attachment, the associated tags and descriptive text for the entry are also saved.

Parameters:: pAuthToken - authtoken against which to validate the user; pMetadataEntrySummary - the modified metadata-entry object to be saved
Returns:: the metadata-entry object after the modifications have been saved
Throws:: OpenAPIException - when there is a problem updating the MetadataEntry; java.rmi.RemoteException

metadataEntryUpdateSwA

MetadataEntrySummary metadataEntryUpdateSwA(AuthToken pAuthToken,
                                            MetadataEntrySummary pMetadataEntrySummary)
                                            throws java.rmi.RemoteException,
                                                   OpenAPIException

Updates a metadata-entry. Actual payload is expected to be attached as an SwA attachment, the associated tags and descriptive text for the entry are also saved.

Parameters:: pAuthToken - authtoken against which to validate the user; pMetadataEntrySummary - the modified metadata-entry object to be saved
Returns:: the metadata-entry object after the modifications have been saved
Throws:: OpenAPIException - when there is a problem updating the MetadataEntry; java.rmi.RemoteException

metadataEntryDelete

void metadataEntryDelete(AuthToken pAuthToken,
                         EntityUUID pEntityUUID)
                         throws java.rmi.RemoteException,
                                OpenAPIException

Deletes a metadata-entry.

Parameters:: pAuthToken - authtoken against which to validate the user; pEntityUUID - the UUID of the metadata-entry to be deleted
Throws:: OpenAPIException - when there is a problem deleting the MetadataEntry; java.rmi.RemoteException

metadataEntryQuery

MetadataEntrySummary[] metadataEntryQuery(AuthToken pAuthToken,
                                          MetadataEntryCriteria pQuery)
                                          throws java.rmi.RemoteException,
                                                 OpenAPIException

Searches for metadata-entries by entry type or associated entity.

Parameters:: pAuthToken - authtoken against which to validate the user; pQuery - a criteria object containing the terms of the metadata-entry for which to search
Returns:: an array of metadata-entry objects matching the criteria, or an empty array if no metadata-entries match
Throws:: OpenAPIException - when there is a problem finding MetadataEntries; java.rmi.RemoteException

testCasDelete

void testCasDelete(AuthToken pAuthToken,
                   java.lang.String pCasName)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testCasCreate

void testCasCreate(AuthToken pAuthToken,
                   java.lang.String pCasName,
                   java.lang.String pCasType)
                   throws java.rmi.RemoteException,
                          OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testRoleContextAddRole

void testRoleContextAddRole(AuthToken pAuthToken,
                            java.lang.String pRoleContextName,
                            java.lang.String pRoleName,
                            java.lang.String pRoleOperator)
                            throws java.rmi.RemoteException,
                                   OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testRoleContextSetPermission

void testRoleContextSetPermission(AuthToken pAuthToken,
                                  java.lang.String pRoleContextName,
                                  java.lang.String pRoleName,
                                  java.lang.String pRoleOperator,
                                  PermissionValue pPermissionValueBean)
                                  throws java.rmi.RemoteException,
                                         OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testRoleContextSetPermissions

void testRoleContextSetPermissions(AuthToken pAuthToken,
                                   java.lang.String pRoleContextName,
                                   java.lang.String pRoleName,
                                   java.lang.String pRoleOperator,
                                   PermissionValue[] pPermssionValueBeans)
                                   throws java.rmi.RemoteException,
                                          OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testRoleContextApplySecuritySettingToExisting

void testRoleContextApplySecuritySettingToExisting(AuthToken pAuthToken,
                                                   java.lang.String pRoleContextName)
                                                   throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testRoleContextGetAllRoles

java.lang.String[] testRoleContextGetAllRoles(AuthToken pAuthToken,
                                              java.lang.String pRoleContextName)
                                              throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testRoleContextGetPermissionFromRole

java.lang.String testRoleContextGetPermissionFromRole(AuthToken pAuthToken,
                                                      java.lang.String pRoleContextName,
                                                      java.lang.String pPermissionName,
                                                      java.lang.String pRoleName,
                                                      java.lang.String pRoleOperator)
                                                      throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testRoleContextClearRoles

void testRoleContextClearRoles(AuthToken pAuthToken,
                               java.lang.String pRoleContextName)
                               throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testRoleContextRemoveRole

void testRoleContextRemoveRole(AuthToken pAuthToken,
                               java.lang.String pRoleContextName,
                               java.lang.String pRoleName,
                               java.lang.String pRoleOperator)
                               throws java.rmi.RemoteException,
                                      OpenAPIException

Throws:: java.rmi.RemoteException; OpenAPIException

testDoSQL

int testDoSQL(java.lang.String pSQL)
              throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testHasSufficientAssets

boolean testHasSufficientAssets()
                                throws java.rmi.RemoteException

Throws:: java.rmi.RemoteException

testDoSimpleQuery

java.lang.String[] testDoSimpleQuery(java.lang.String[] pArgs,
                                     java.lang.String pColumnName,
                                     java.lang.String pQuery)
                                     throws java.rmi.RemoteException

Create a subscription for the user identified by pAuthToken to the assets listed in pAssetIDs. User will be added to the subscription list for emails sent as a result of raised system events. If pFailOnAnyError is true, then the entire subscription request will fail if for any reason any asset fails in its subscription request. These failures could include RBAC access restrictions for assets listed in pAssetIDs.

Parameters:: pAuthToken - authtoken against which to validate the user; pAssetIDs - the list of asset IDs for which to subscribe the user; pFailOnAnyError - if true, fail the entire subscription request if ANY error occurs on any asset listed in pAssetIDs
Throws:: java.rmi.RemoteException

subscriptionCreate

void subscriptionCreate(AuthToken pAuthToken,
                        long[] pAssetIDs,
                        boolean pFailOnAnyError)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Parameters:: pAuthToken - authtoken against which to validate the user; pAssetIDs - the list of asset IDs for which to subscribe the user; pFailOnAnyError - if true, fail the entire subscription request if ANY error occurs on any asset listed in pAssetIDs
Throws:: java.rmi.RemoteException; OpenAPIException

subscriptionDelete

void subscriptionDelete(AuthToken pAuthToken,
                        long[] pAssetIDs)
                        throws java.rmi.RemoteException,
                               OpenAPIException

Delete an existing subscription for the user identified by pAuthToken to the assets listed in pAssetIDs. If the user does not currently have subscriptions to assets listed in pAssetIDs, no subscription will be removed for that asset, and no error will be thrown.

Parameters:: pAuthToken - authtoken against which to validate the user; pAssetIDs - the list of asset IDs for which to unsubscribe the user
Throws:: java.rmi.RemoteException; OpenAPIException

subscriptionReadSubscribedAssets

long[] subscriptionReadSubscribedAssets(AuthToken pAuthToken)
                                        throws java.rmi.RemoteException,
                                               OpenAPIException

Retrieve the list of assets to which the user identified by pAuthToken is subscribed.

Parameters:: pAuthToken - authtoken against which to validate the user
Returns:: list of assets to which the user identified by pAuthToken is subscribed.
Throws:: OpenAPIException; java.rmi.RemoteException

subscriptionReadUsersSubscribedToAsset

RegistryUser[] subscriptionReadUsersSubscribedToAsset(AuthToken pAuthTokenBean,
                                                      long pAssetID)
                                                      throws java.rmi.RemoteException,
                                                             OpenAPIException

Return all of the users subscribed to an asset. The user must have the privilege to VIEW user information in order to see users other than themself.

Parameters:: pAuthToken - AuthToken against which to authenticate the user; pAssetID - the asset id for which to determine subscribed users
Returns:: an array of subscribed users
Throws:: OpenAPIException - if something goes wrong; java.rmi.RemoteException

retrieveRootArtifacts

Asset[] retrieveRootArtifacts(AuthToken pAuthToken,
                              long pAbstractAssetId)
                              throws java.rmi.RemoteException,
                                     OpenAPIException

This method retrieves a set of Assets corresponding to roots of collections of related artifact assets which are directly connected to the passed abstract asset (i.e. asset representing a service, bpel, interface, endpoint or xslt). The assets are ordered by date of introspection in descending order (i.e. the most recent introspection is at position 0). Also, root assets for which the user does not have access to the entire subgraph are automatically filtered out.

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above
Returns:: A list of assets, sorted inverse chronologically by introspection date
Throws:: OpenAPIException; java.rmi.RemoteException

retrieveLatestRootArtifact

Asset retrieveLatestRootArtifact(AuthToken pAuthToken,
                                 long pAbstractAssetId)
                                 throws java.rmi.RemoteException,
                                        OpenAPIException

This method retrieves a the Asset corresponding to the latest introspected root of collections of related artifact assets which are directly connected to the passed abstract asset (i.e. asset representing a service, bpel, interface, endpoint or xslt).

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above
Returns:: An asset associated with the latest introspection chronologically which created an artifact graph or null, if none exist (or can be seen).
Throws:: OpenAPIException; java.rmi.RemoteException

retrieveArtifactCollectionAsDIME

void retrieveArtifactCollectionAsDIME(AuthToken pAuthToken,
                                      long pAbstractAssetId,
                                      long pArtifactRootId)
                                      throws java.rmi.RemoteException,
                                             OpenAPIException

This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root. It uses DIME for the attachment.

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above; pArtifactRootId - The ID of the root of the artifact graph .
Throws:: OpenAPIException; java.rmi.RemoteException

retrieveAndRecordUsageOfArtifactCollectionAsDIME

void retrieveAndRecordUsageOfArtifactCollectionAsDIME(AuthToken pAuthToken,
                                                      long pAbstractAssetId,
                                                      long pArtifactRootId,
                                                      long pProjectId,
                                                      RegistryUser pRbacRegistrySecUserBean)
                                                      throws java.rmi.RemoteException,
                                                             OpenAPIException

This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root. It uses DIME for the attachment. It will record usage for all assets in the zip bundle. Usage will be assigned to the user associated with the auth token.

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above; pArtifactRootId - The ID of the root of the artifact graph .; pProjectId - The ID of the project to record usage to.
Throws:: OpenAPIException; java.rmi.RemoteException

retrieveAndRecordUsageOfArtifactCollectionAsDIME

void retrieveAndRecordUsageOfArtifactCollectionAsDIME(AuthToken pAuthToken,
                                                      long pAbstractAssetId,
                                                      long pArtifactRootId,
                                                      long pProjectId)
                                                      throws java.rmi.RemoteException,
                                                             OpenAPIException

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above; pArtifactRootId - The ID of the root of the artifact graph .; pProjectId - The ID of the project to record usage to.; pRbacRegistrySecUserBean - Object of the user recording usage for this asset.
Throws:: OpenAPIException; java.rmi.RemoteException

retrieveArtifactCollectionAsSwa

void retrieveArtifactCollectionAsSwa(AuthToken pAuthToken,
                                     long pAbstractAssetId,
                                     long pArtifactRootId)
                                     throws java.rmi.RemoteException,
                                            OpenAPIException

This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root. It uses SWA for the attachment.

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above; pArtifactRootId - The ID of the root of the artifact graph .
Throws:: OpenAPIException; java.rmi.RemoteException

retrieveAndRecordUsageOfArtifactCollectionAsSwa

void retrieveAndRecordUsageOfArtifactCollectionAsSwa(AuthToken pAuthToken,
                                                     long pAbstractAssetId,
                                                     long pArtifactRootId,
                                                     long pProjectId,
                                                     RegistryUser pRbacRegistrySecUserBean)
                                                     throws java.rmi.RemoteException,
                                                            OpenAPIException

This method attaches the payload of the associated zip bundle of the artifact collection associated with the given abstract asset and artifact root. It uses SWA for the attachment. It will record usage for all assets in the zip bundle. Usage will be assigned to the user associated with the auth token.

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above; pArtifactRootId - The ID of the root of the artifact graph .; pProjectId - The ID of the project to record usage to.
Throws:: OpenAPIException; java.rmi.RemoteException

retrieveAndRecordUsageOfArtifactCollectionAsSwa

void retrieveAndRecordUsageOfArtifactCollectionAsSwa(AuthToken pAuthToken,
                                                     long pAbstractAssetId,
                                                     long pArtifactRootId,
                                                     long pProjectId)
                                                     throws java.rmi.RemoteException,
                                                            OpenAPIException

Parameters:: pAuthToken - The auth token associated with the user login; pAbstractAssetId - The ID of the "abstract" asset described above; pArtifactRootId - The ID of the root of the artifact graph .; pProjectId - The ID of the project to record usage to.; pRbacRegistrySecUserBean - Object of the user recording usage for this asset.
Throws:: OpenAPIException; java.rmi.RemoteException

getLatestArtifacts

FileInfo[] getLatestArtifacts(AuthToken pAuthToken,
                              long pAbstractAssetId,
                              boolean pIsService)
                              throws java.rmi.RemoteException,
                                     OpenAPIException

This is a convenience method to ease retrieving artifacts associated with abstract assets in the post-3.0 ALER model. Specifically, this method will return an array of FileInfos which correspond to artifacts (e.g. an Artifact:WSDL) at the root of the artifact graph associated with an abstract asset (e.g. an Interface). In most cases, this will return an array of one item. The exception to this is for the case where the abstract asset ID corresponds to a service (and, consequently, pIsService is set to true). In this case, we follow the relationship between the service to each of its endpoints and, for each endpoint, return the FileInfo associated with the artifact WSDL which was most recently introspected.

Parameters:: pAuthToken -; pAbstractAssetId -; pIsService - If set to true, traverse the relationship between the Service to the Endpoint first and, for each endpoint, return the latest FileInfo at the root of the artifact graph.
Returns:
Throws:: OpenAPIException; java.rmi.RemoteException

Overview

Package

Class

Tree

Deprecated

Index

Help

Oracle© Fusion Middleware Extensibility Framework (REX) for Oracle Enterprise Repository
11g Release 1 (11.1.1)
E16598-01

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.flashline.registry.openapi.service.v300 Interface FlashlineRegistry

assetTypeTabsRead

assetTabApprove

assetTabUnapprove

notificationCreate

notificationSubstitutionsRead

artifactStoreQuery

authTokenCreate

authTokenCreateWithLicense

authTokenDelete

authTokenValidate

assetCreate

assetCreateFromXML

assetRead

assetReadXml

assetReadCustomDataString

assetReadCustomDataNode

assetReadArray

assetReadArrayFromSummary

assetUpdate

assetGetUnacceptedFiles

assetAcceptFiles

assetUpdateCustomDataString

assetUpdateCustomDataStringArray

assetUpdateCustomDataNode

assetUpdateCustomDataNodeFromStringArray

assetUploadFiles

assetAddRegistrarNote

assetReadRegistrarNotes

assetRegister

assetUnRegister

assetAccept

assetUnAccept

assetSubmit

assetUnSubmit

assetActivate

assetDeactivate

assetRetire

assetDelete

assetTabsRead

assetTabRead

assetQuerySummary

assetQuery

assetQueryCount

assetReadAppliedToProjects

assetReadAppliedPolicies

assetUpdateAppliedPolicies

assetEvaluate

assetEvaluateAgainstAllPolicies

assetEvaluateAgainstPolicy

assetApplyToProjects

assetRemoveAppliedToProjects

repositoryFileTranslator

categorizationTypeCreate

categorizationTypeRead

categorizationTypeUpdate

categorizationTypeDelete

categorizationTypeQuery

categorizationCreate

categorizationChildCreate

categorizationRead

categorizationReadByType

categorizationChildRead

categorizationUpdate

categorizationUpdateArray

categorizationDeactivate

categorizationReactivate

contactCreate

contactRead

contactUpdate

contactDelete

contactQuery

extractionCreate

extractionGetHiddenAssetUsers

extractionCreateForUser

extractionTentativelyAccept

extractionStillEvaluating

extractionReject

extractionUpdateSurvey

extractionUpdateSurveyForUser

com.flashline.registry.openapi.service.v300
Interface FlashlineRegistry