org.odpi.openmetadata.accessservices.subjectarea.server.spring

Class SubjectAreaRelationshipRESTResource

java.lang.Object

org.odpi.openmetadata.accessservices.subjectarea.server.services.SubjectAreaRESTServicesInstance

org.odpi.openmetadata.accessservices.subjectarea.server.spring.SubjectAreaRelationshipRESTResource

@RestController
 @RequestMapping(value="/servers/{serverName}/open-metadata/access-services/subject-area")
public class SubjectAreaRelationshipRESTResource
extends SubjectAreaRESTServicesInstance

The SubjectAreaRESTServicesInstance provides the org.odpi.openmetadata.accessservices.subjectarea.server-side implementation of the SubjectArea Open Metadata Access Service (OMAS). This interface provides relationship authoring interfaces for subject area experts.

Field Summary

Fields inherited from class org.odpi.openmetadata.accessservices.subjectarea.server.services.SubjectAreaRESTServicesInstance

instanceHandler, oMRSAPIHelper

Constructor Summary

Constructors

Constructor and Description
SubjectAreaRelationshipRESTResource() Default constructor

Method Summary

Modifier and Type	Method and Description
SubjectAreaOMASAPIResponse	createAntonym(String serverName, String userId, Antonym antonym) Create an antonym relationship, which is a link between glossary terms that have the opposite meaning.
SubjectAreaOMASAPIResponse	createCategoryAnchor(String serverName, String userId, CategoryAnchorRelationship categoryAnchorRelationship) Create a categoryAnchor Relationship.
SubjectAreaOMASAPIResponse	createiSARelationship(String serverName, String userId, ISARelationship iSARelationship) Create a iSARelationship relationship, which is a link between a more general glossary term and a more specific definition.
SubjectAreaOMASAPIResponse	createpreferredTerm(String serverName, String userId, PreferredTerm preferredTerm) Create a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
SubjectAreaOMASAPIResponse	createProjectScopeRelationship(String serverName, String userId, ProjectScopeRelationship projectScope) Create a project scope relationship, which is a link between the project content and the project.
SubjectAreaOMASAPIResponse	createRelatedTerm(String serverName, String userId, RelatedTerm relatedTermRelationshipRelationship) Create a RelatedTerm.
SubjectAreaOMASAPIResponse	createreplacementTerm(String serverName, String userId, ReplacementTerm replacementTerm) Create a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
SubjectAreaOMASAPIResponse	createSynonym(String serverName, String userId, Synonym synonym) Create a synonym relationship, which is a link between glossary terms that have the same meaning.
SubjectAreaOMASAPIResponse	createTermAnchor(String serverName, String userId, TermAnchorRelationship termAnchorRelationship) Create a termAnchor Relationship.
SubjectAreaOMASAPIResponse	createTermCategorization(String serverName, String userId, TermCategorizationRelationship termCategorizationRelationship) Create a termCategorization Relationship.
SubjectAreaOMASAPIResponse	createTermHASARelationship(String serverName, String userId, TermHASARelationship termHASARelationship) Create a TermHASARelationship is the relationship between a spine object and a spine attribute.
SubjectAreaOMASAPIResponse	createtermISATypeOFRelationship(String serverName, String userId, TermISATypeOFRelationship termISATypeOFRelationship) Create a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
SubjectAreaOMASAPIResponse	createtermTYPEDBYRelationship(String serverName, String userId, TermTYPEDBYRelationship termTYPEDBYRelationship) Create a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
SubjectAreaOMASAPIResponse	createTranslation(String serverName, String userId, Translation translation) Create a translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
SubjectAreaOMASAPIResponse	createusedInContext(String serverName, String userId, UsedInContext usedInContext) Create a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.
SubjectAreaOMASAPIResponse	createvalidValue(String serverName, String userId, ValidValue validValue) Create a validValue relationship, which is a link between glossary terms that have the same meaning.
SubjectAreaOMASAPIResponse	deleteAntonymRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a Antonym relationship
SubjectAreaOMASAPIResponse	deleteCategoryAnchorRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a CategoryAnchor Relationship.
SubjectAreaOMASAPIResponse	deletePreferredTermRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
SubjectAreaOMASAPIResponse	deleteProjectScopeRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a Project scope relationship which is a link between the project content and the project.
SubjectAreaOMASAPIResponse	deleteRelatedTerm(String serverName, String userId, String guid, Boolean isPurge) Delete a Related Term relationship
SubjectAreaOMASAPIResponse	deleteReplacementTermRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
SubjectAreaOMASAPIResponse	deleteSynonymRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a Synonym relationship
SubjectAreaOMASAPIResponse	deleteTermAnchorRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a TermAnchor Relationship.
SubjectAreaOMASAPIResponse	deleteTermCategorizationRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a TermCategorization Relationship.
SubjectAreaOMASAPIResponse	deleteTermHASARelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a Term HAS A relationship
SubjectAreaOMASAPIResponse	deleteTermISARelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.
SubjectAreaOMASAPIResponse	deleteTermIsaTypeOfRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a TermISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
SubjectAreaOMASAPIResponse	deleteTranslationRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a Translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
SubjectAreaOMASAPIResponse	deleteTypedByRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
SubjectAreaOMASAPIResponse	deleteUsedInContextRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.
SubjectAreaOMASAPIResponse	deleteValidValueRelationship(String serverName, String userId, String guid, Boolean isPurge) Delete a ValidValue relationship
SubjectAreaOMASAPIResponse	getAntonymRelationship(String serverName, String userId, String guid) Get a antonym relationship
SubjectAreaOMASAPIResponse	getCategoryAnchorRelationship(String serverName, String userId, String guid) Get a categoryAnchor Relationship.
SubjectAreaOMASAPIResponse	getISARelationship(String serverName, String userId, String guid) Get a iSARelationship relationship, which is a link between a more general glossary term and a more specific definition.
SubjectAreaOMASAPIResponse	getPreferredTermRelationship(String serverName, String userId, String guid) Get a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
SubjectAreaOMASAPIResponse	getProjectScopeRelationship(String serverName, String userId, String guid) Get a project scope relationship, which is a link between the project content and the project.
SubjectAreaOMASAPIResponse	getRelatedTerm(String serverName, String userId, String guid) Get a related Term relationship.
SubjectAreaOMASAPIResponse	getReplacementTermRelationship(String serverName, String userId, String guid) Get a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
SubjectAreaOMASAPIResponse	getSemanticAssignmentRelationship(String serverName, String userId, String guid) Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.
SubjectAreaOMASAPIResponse	getSynonymRelationship(String serverName, String userId, String guid) Get a synonym relationship, which is a link between glossary terms that have the same meaning.
SubjectAreaOMASAPIResponse	getTermAnchorRelationship(String serverName, String userId, String guid) Get a termAnchor Relationship.
SubjectAreaOMASAPIResponse	getTermCategorizationRelationship(String serverName, String userId, String guid) Get a termCategorization Relationship.
SubjectAreaOMASAPIResponse	getTermHASARelationship(String serverName, String userId, String guid) Get a Term HAS A relationship
SubjectAreaOMASAPIResponse	getTermISATypeOFRelationship(String serverName, String userId, String guid) Get a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
SubjectAreaOMASAPIResponse	getTranslationRelationship(String serverName, String userId, String guid) Get a translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
SubjectAreaOMASAPIResponse	getTYPEDBYRelationshipRelationship(String serverName, String userId, String guid) Get a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
SubjectAreaOMASAPIResponse	getUsedInContextRelationship(String serverName, String userId, String guid) Get a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.
SubjectAreaOMASAPIResponse	getValidValueRelationship(String serverName, String userId, String guid) Get a validValue relationship, which is a link between glossary terms that have the same meaning.
SubjectAreaOMASAPIResponse	restoreAntonym(String serverName, String userId, String guid) Restore a Antonym Restore allows the deleted Antonym to be made active again.
SubjectAreaOMASAPIResponse	restoreCategoryAnchorRelationship(String serverName, String userId, String guid) Restore a CategoryAnchor Relationship.
SubjectAreaOMASAPIResponse	restoreIsaRelationship(String serverName, String userId, String guid) Restore a Isa Relationship Restore allows the deleted Isa Relationship to be made active again.
SubjectAreaOMASAPIResponse	restorePreferredTerm(String serverName, String userId, String guid) Restore a PreferredTerm Restore allows the deleted PreferredTerm to be made active again.
SubjectAreaOMASAPIResponse	restoreProjectScoperRelationship(String serverName, String userId, String guid) Restore a ProjectScope, which is a link between the project content and the project.
SubjectAreaOMASAPIResponse	restoreRelatedTerm(String serverName, String userId, String guid) Restore a related Term relationship.
SubjectAreaOMASAPIResponse	restoreReplacementTerm(String serverName, String userId, String guid) Restore a ReplacementTerm Restore allows the deleted ReplacementTerm to be made active again.
SubjectAreaOMASAPIResponse	restoreSynonym(String serverName, String userId, String guid) Restore a Synonym Restore allows the deleted Synonym to be made active again.
SubjectAreaOMASAPIResponse	restoreTermAnchorRelationship(String serverName, String userId, String guid) Restore a TermAnchor Relationship.
SubjectAreaOMASAPIResponse	restoreTermCategorizationRelationship(String serverName, String userId, String guid) Restore a TermCategorization Relationship.
SubjectAreaOMASAPIResponse	restoreTermHASARelationship(String serverName, String userId, String guid) Restore a has a relationship.
SubjectAreaOMASAPIResponse	restoreTermIsaTypeOfRelationship(String serverName, String userId, String guid) Restore a Is a Type Of Relationship Restore allows the deleted Is a Type Of Relationship to be made active again.
SubjectAreaOMASAPIResponse	restoreTermTYPEDBYRelationship(String serverName, String userId, String guid) Restore a Term TYPED BY relationship Restore allows the deleted TermTYPEDBY to be made active again.
SubjectAreaOMASAPIResponse	restoreTranslation(String serverName, String userId, String guid) Restore a Translation Restore allows the deleted Translation to be made active again.
SubjectAreaOMASAPIResponse	restoreUsedInContext(String serverName, String userId, String guid) Restore a UsedInContext Restore allows the deleted UsedInContext to be made active again.
SubjectAreaOMASAPIResponse	restoreValidValue(String serverName, String userId, String guid) Restore a ValidValue Restore allows the deleted ValidValue to be made active again.
SubjectAreaOMASAPIResponse	updateAntonymRelationship(String serverName, String userId, Antonym antonym, Boolean isReplace) Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
SubjectAreaOMASAPIResponse	updateISARelationship(String serverName, String userId, ISARelationship isa, Boolean isReplace) Update a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.
SubjectAreaOMASAPIResponse	updateISARelationship(String serverName, String userId, TermISATypeOFRelationship isatypeof, Boolean isReplace) Update a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.
SubjectAreaOMASAPIResponse	updatePreferredTermRelationship(String serverName, String userId, PreferredTerm preferredTerm, Boolean isReplace) Update a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
SubjectAreaOMASAPIResponse	updateProjectScopeRelationship(String serverName, String userId, ProjectScopeRelationship projectScope, Boolean isReplace) Update a Project scope relationship which is a link between the project content and the project.
SubjectAreaOMASAPIResponse	updateRelatedTerm(String serverName, String userId, RelatedTerm relatedTermRelationship, Boolean isReplace) Update a Related Term relationship.
SubjectAreaOMASAPIResponse	updateReplacementTermRelationship(String serverName, String userId, ReplacementTerm replacementTerm, Boolean isReplace) Update a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
SubjectAreaOMASAPIResponse	updateSynonymRelationship(String serverName, String userId, Synonym synonym, Boolean isReplace) Update a Synonym relationship which is a link between glossary terms that have the same meaning
SubjectAreaOMASAPIResponse	updateTermCategorizationRelationship(String serverName, String userId, TermCategorizationRelationship isatypeof, Boolean isReplace) Update a termCategorization Relationship.
SubjectAreaOMASAPIResponse	updateTermHASARelationship(String serverName, String userId, TermHASARelationship termHASARelationship, Boolean isReplace) Update a TermHASARelationship is the relationship between a spine object and a spine attribute.
SubjectAreaOMASAPIResponse	updateTermTYPEDBYRelationship(String serverName, String userId, TermTYPEDBYRelationship termTYPEDBYRelationship, Boolean isReplace) Update a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
SubjectAreaOMASAPIResponse	updateTranslationRelationship(String serverName, String userId, Translation translation, Boolean isReplace) Update a Translation relationship translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
SubjectAreaOMASAPIResponse	updateUsedInContextRelationship(String serverName, String userId, UsedInContext usedInContext, Boolean isReplace) Update a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.
SubjectAreaOMASAPIResponse	updateValidValueRelationship(String serverName, String userId, ValidValue validValue, Boolean isReplace) Update a ValidValue relationship which is a link between glossary terms that have the same meaning

Methods inherited from class org.odpi.openmetadata.accessservices.subjectarea.server.services.SubjectAreaRESTServicesInstance

createLine, deleteLine, getLine, getRelationshipsFromGuid, initializeAPI, initializeAPI, restoreLine, setOMRSAPIHelper, updateLine

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SubjectAreaRelationshipRESTResource

public SubjectAreaRelationshipRESTResource()

Default constructor

Method Detail

createTermHASARelationship

@PostMapping(path="/users/{userId}/relationships/has-as")
public SubjectAreaOMASAPIResponse createTermHASARelationship(@PathVariable
                                                                                                                       String serverName,
                                                                                                                       @PathVariable
                                                                                                                       String userId,
                                                                                                                       @RequestBody
                                                                                                                       TermHASARelationship termHASARelationship)

Create a TermHASARelationship is the relationship between a spine object and a spine attribute. Note that this method does not error if the relationship ends are not spine objects or spine attributes. This allows the user to create terms then make them spine objects and spine attributes at a later stage.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

termHASARelationship - the HASA relationship

Returns:

response, when successful contains the created TermHASARelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getTermHASARelationship

@GetMapping(path="/users/{userId}/relationships/has-as/{guid}")
public SubjectAreaOMASAPIResponse getTermHASARelationship(@PathVariable
                                                                                                                          String serverName,
                                                                                                                          @PathVariable
                                                                                                                          String userId,
                                                                                                                          @PathVariable
                                                                                                                          String guid)

Get a Term HAS A relationship

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the HAS A relationship to get

Returns:

response which when successful contains the term has a relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateTermHASARelationship

@PutMapping(path="/users/{userId}/relationships/has-as")
public SubjectAreaOMASAPIResponse updateTermHASARelationship(@PathVariable
                                                                                                                      String serverName,
                                                                                                                      @PathVariable
                                                                                                                      String userId,
                                                                                                                      @RequestBody
                                                                                                                      TermHASARelationship termHASARelationship,
                                                                                                                      @RequestParam(value="isReplace",required=false)
                                                                                                                      Boolean isReplace)

Update a TermHASARelationship is the relationship between a spine object and a spine attribute.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

termHASARelationship - the HASA relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created TermHASARelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteTermHASARelationship

@DeleteMapping(path="/users/{userId}/relationships/has-as/{guid}")
public SubjectAreaOMASAPIResponse deleteTermHASARelationship(@PathVariable
                                                                                                                                String serverName,
                                                                                                                                @PathVariable
                                                                                                                                String userId,
                                                                                                                                @PathVariable
                                                                                                                                String guid,
                                                                                                                                @RequestParam(value="isPurge",required=false)
                                                                                                                                Boolean isPurge)

Delete a Term HAS A relationship

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the HAS A relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreTermHASARelationship

@PostMapping(path="/users/{userId}/relationships/has-as/{guid}")
public SubjectAreaOMASAPIResponse restoreTermHASARelationship(@PathVariable
                                                                                                                               String serverName,
                                                                                                                               @PathVariable
                                                                                                                               String userId,
                                                                                                                               @PathVariable
                                                                                                                               String guid)

Restore a has a relationship. Restore allows the deleted relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the relationship to restore

Returns:

response which when successful contains the restored relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

createRelatedTerm

@PostMapping(path="/users/{userId}/relationships/related-terms")
public SubjectAreaOMASAPIResponse createRelatedTerm(@PathVariable
                                                                                                                     String serverName,
                                                                                                                     @PathVariable
                                                                                                                     String userId,
                                                                                                                     @RequestBody
                                                                                                                     RelatedTerm relatedTermRelationshipRelationship)

Create a RelatedTerm. A Related Term is a link between two similar Terms.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

relatedTermRelationshipRelationship - the RelatedTerm relationship

Returns:

response, when successful contains the created Related Term relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getRelatedTerm

@GetMapping(path="/users/{userId}/relationships/related-terms/{guid}")
public SubjectAreaOMASAPIResponse getRelatedTerm(@PathVariable
                                                                                                                        String serverName,
                                                                                                                        @PathVariable
                                                                                                                        String userId,
                                                                                                                        @PathVariable
                                                                                                                        String guid)

Get a related Term relationship.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the related term relationship to get

Returns:

response which when successful contains the related term relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateRelatedTerm

@PutMapping(path="/users/{userId}/relationships/related-terms")
public SubjectAreaOMASAPIResponse updateRelatedTerm(@PathVariable
                                                                                                                    String serverName,
                                                                                                                    @PathVariable
                                                                                                                    String userId,
                                                                                                                    @RequestBody
                                                                                                                    RelatedTerm relatedTermRelationship,
                                                                                                                    @RequestParam(value="isReplace",required=false)
                                                                                                                    Boolean isReplace)

Update a Related Term relationship. A Related Term is a link between two similar Terms.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

relatedTermRelationship - the related term relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created RelatedTerm when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteRelatedTerm

@DeleteMapping(path="/users/{userId}/relationships/related-terms/{guid}")
public SubjectAreaOMASAPIResponse deleteRelatedTerm(@PathVariable
                                                                                                                              String serverName,
                                                                                                                              @PathVariable
                                                                                                                              String userId,
                                                                                                                              @PathVariable
                                                                                                                              String guid,
                                                                                                                              @RequestParam(value="isPurge",required=false)
                                                                                                                              Boolean isPurge)

Delete a Related Term relationship

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Related term relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreRelatedTerm

@PostMapping(path="/users/{userId}/relationships/related-terms/{guid}")
public SubjectAreaOMASAPIResponse restoreRelatedTerm(@PathVariable
                                                                                                                             String serverName,
                                                                                                                             @PathVariable
                                                                                                                             String userId,
                                                                                                                             @PathVariable
                                                                                                                             String guid)

Restore a related Term relationship. Restore allows the deleted relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the relationship to restore

Returns:

response which when successful contains the restored relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

createSynonym

@PostMapping(path="/users/{userId}/relationships/synonyms")
public SubjectAreaOMASAPIResponse createSynonym(@PathVariable
                                                                                                            String serverName,
                                                                                                            @PathVariable
                                                                                                            String userId,
                                                                                                            @RequestBody
                                                                                                            Synonym synonym)

Create a synonym relationship, which is a link between glossary terms that have the same meaning.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

synonym - the Synonym relationship

Returns:

response, when successful contains the created synonym relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getSynonymRelationship

@GetMapping(path="/users/{userId}/relationships/synonyms/{guid}")
public SubjectAreaOMASAPIResponse getSynonymRelationship(@PathVariable
                                                                                                                           String serverName,
                                                                                                                           @PathVariable
                                                                                                                           String userId,
                                                                                                                           @PathVariable
                                                                                                                           String guid)

Get a synonym relationship, which is a link between glossary terms that have the same meaning.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the synonym relationship to get

Returns:

response which when successful contains the synonym relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateSynonymRelationship

@PutMapping(path="/users/{userId}/relationships/synonyms")
public SubjectAreaOMASAPIResponse updateSynonymRelationship(@PathVariable
                                                                                                                       String serverName,
                                                                                                                       @PathVariable
                                                                                                                       String userId,
                                                                                                                       @RequestBody
                                                                                                                       Synonym synonym,
                                                                                                                       @RequestParam(value="isReplace",required=false)
                                                                                                                       Boolean isReplace)

Update a Synonym relationship which is a link between glossary terms that have the same meaning

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

synonym - the synonym relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created SynonymRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteSynonymRelationship

@DeleteMapping(path="/users/{userId}/relationships/synonyms/{guid}")
public SubjectAreaOMASAPIResponse deleteSynonymRelationship(@PathVariable
                                                                                                                                 String serverName,
                                                                                                                                 @PathVariable
                                                                                                                                 String userId,
                                                                                                                                 @PathVariable
                                                                                                                                 String guid,
                                                                                                                                 @RequestParam(value="isPurge",required=false)
                                                                                                                                 Boolean isPurge)

Delete a Synonym relationship

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Synonym relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreSynonym

@PostMapping(path="/users/{userId}/relationships/synonyms/{guid}")
public SubjectAreaOMASAPIResponse restoreSynonym(@PathVariable
                                                                                                                    String serverName,
                                                                                                                    @PathVariable
                                                                                                                    String userId,
                                                                                                                    @PathVariable
                                                                                                                    String guid)

Restore a Synonym Restore allows the deleted Synonym to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Synonym to delete

Returns:

response which when successful contains the restored Synonym when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createAntonym

@PostMapping(path="/users/{userId}/relationships/antonyms")
public SubjectAreaOMASAPIResponse createAntonym(@PathVariable
                                                                                                            String serverName,
                                                                                                            @PathVariable
                                                                                                            String userId,
                                                                                                            @RequestBody
                                                                                                            Antonym antonym)

Create an antonym relationship, which is a link between glossary terms that have the opposite meaning.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

antonym - the Antonym relationship

Returns:

response, when successful contains the created antonym relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getAntonymRelationship

@GetMapping(path="/users/{userId}/relationships/antonyms/{guid}")
public SubjectAreaOMASAPIResponse getAntonymRelationship(@PathVariable
                                                                                                                           String serverName,
                                                                                                                           @PathVariable
                                                                                                                           String userId,
                                                                                                                           @PathVariable
                                                                                                                           String guid)

Get a antonym relationship

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the related term relationship to get

Returns:

response which when successful contains the antonym relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateAntonymRelationship

@PutMapping(path="/users/{userId}/relationships/antonyms")
public SubjectAreaOMASAPIResponse updateAntonymRelationship(@PathVariable
                                                                                                                       String serverName,
                                                                                                                       @PathVariable
                                                                                                                       String userId,
                                                                                                                       @RequestBody
                                                                                                                       Antonym antonym,
                                                                                                                       @RequestParam(value="isReplace",required=false)
                                                                                                                       Boolean isReplace)

Update a Antonym relationship which is a link between glossary terms that have the opposite meaning

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

antonym - the antonym relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created AntonymRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteAntonymRelationship

@DeleteMapping(path="/users/{userId}/relationships/antonyms/{guid}")
public SubjectAreaOMASAPIResponse deleteAntonymRelationship(@PathVariable
                                                                                                                                 String serverName,
                                                                                                                                 @PathVariable
                                                                                                                                 String userId,
                                                                                                                                 @PathVariable
                                                                                                                                 String guid,
                                                                                                                                 @RequestParam(value="isPurge",required=false)
                                                                                                                                 Boolean isPurge)

Delete a Antonym relationship

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Antonym relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreAntonym

@PostMapping(path="/users/{userId}/relationships/antonyms/{guid}")
public SubjectAreaOMASAPIResponse restoreAntonym(@PathVariable
                                                                                                                    String serverName,
                                                                                                                    @PathVariable
                                                                                                                    String userId,
                                                                                                                    @PathVariable
                                                                                                                    String guid)

Restore a Antonym Restore allows the deleted Antonym to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Antonym to delete

Returns:

response which when successful contains the restored Antonym when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createTranslation

@PostMapping(path="/users/{userId}/relationships/translations")
public SubjectAreaOMASAPIResponse createTranslation(@PathVariable
                                                                                                                    String serverName,
                                                                                                                    @PathVariable
                                                                                                                    String userId,
                                                                                                                    @RequestBody
                                                                                                                    Translation translation)

Create a translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

translation - the Translation relationship

Returns:

response, when successful contains the created translation relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getTranslationRelationship

@GetMapping(path="/users/{userId}/relationships/translations/{guid}")
public SubjectAreaOMASAPIResponse getTranslationRelationship(@PathVariable
                                                                                                                                   String serverName,
                                                                                                                                   @PathVariable
                                                                                                                                   String userId,
                                                                                                                                   @PathVariable
                                                                                                                                   String guid)

Get a translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the translation relationship to get

Returns:

response which when successful contains the translation relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateTranslationRelationship

@PutMapping(path="/users/{userId}/relationships/translations")
public SubjectAreaOMASAPIResponse updateTranslationRelationship(@PathVariable
                                                                                                                               String serverName,
                                                                                                                               @PathVariable
                                                                                                                               String userId,
                                                                                                                               @RequestBody
                                                                                                                               Translation translation,
                                                                                                                               @RequestParam(value="isReplace",required=false)
                                                                                                                               Boolean isReplace)

Update a Translation relationship translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

translation - the translation relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created TranslationRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteTranslationRelationship

@DeleteMapping(path="/users/{userId}/relationships/translations/{guid}")
public SubjectAreaOMASAPIResponse deleteTranslationRelationship(@PathVariable
                                                                                                                                         String serverName,
                                                                                                                                         @PathVariable
                                                                                                                                         String userId,
                                                                                                                                         @PathVariable
                                                                                                                                         String guid,
                                                                                                                                         @RequestParam(value="isPurge",required=false)
                                                                                                                                         Boolean isPurge)

Delete a Translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Translation relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreTranslation

@PostMapping(path="/users/{userId}/relationships/translations/{guid}")
public SubjectAreaOMASAPIResponse restoreTranslation(@PathVariable
                                                                                                                            String serverName,
                                                                                                                            @PathVariable
                                                                                                                            String userId,
                                                                                                                            @PathVariable
                                                                                                                            String guid)

Restore a Translation Restore allows the deleted Translation to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Translation to delete

Returns:

response which when successful contains the restored Translation when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createusedInContext

@PostMapping(path="/users/{userId}/relationships/used-in-contexts")
public SubjectAreaOMASAPIResponse createusedInContext(@PathVariable
                                                                                                                          String serverName,
                                                                                                                          @PathVariable
                                                                                                                          String userId,
                                                                                                                          @RequestBody
                                                                                                                          UsedInContext usedInContext)

Create a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

usedInContext - the UsedInContext relationship

Returns:

response, when successful contains the created usedInContext relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getUsedInContextRelationship

@GetMapping(path="/users/{userId}/relationships/used-in-contexts/{guid}")
public SubjectAreaOMASAPIResponse getUsedInContextRelationship(@PathVariable
                                                                                                                                         String serverName,
                                                                                                                                         @PathVariable
                                                                                                                                         String userId,
                                                                                                                                         @PathVariable
                                                                                                                                         String guid)

Get a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the usedInContext relationship to get

Returns:

response which when successful contains the usedInContext relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateUsedInContextRelationship

@PutMapping(path="/users/{userId}/relationships/used-in-contexts")
public SubjectAreaOMASAPIResponse updateUsedInContextRelationship(@PathVariable
                                                                                                                                     String serverName,
                                                                                                                                     @PathVariable
                                                                                                                                     String userId,
                                                                                                                                     @RequestBody
                                                                                                                                     UsedInContext usedInContext,
                                                                                                                                     @RequestParam(value="isReplace",required=false)
                                                                                                                                     Boolean isReplace)

Update a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

usedInContext - the used in context relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created UsedInContextRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteUsedInContextRelationship

@DeleteMapping(path="/users/{userId}/relationships/used-in-contexts/{guid}")
public SubjectAreaOMASAPIResponse deleteUsedInContextRelationship(@PathVariable
                                                                                                                                               String serverName,
                                                                                                                                               @PathVariable
                                                                                                                                               String userId,
                                                                                                                                               @PathVariable
                                                                                                                                               String guid,
                                                                                                                                               @RequestParam(value="isPurge",required=false)
                                                                                                                                               Boolean isPurge)

Delete a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the UsedInContext relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreUsedInContext

@PostMapping(path="/users/{userId}/relationships/used-in-contexts/{guid}")
public SubjectAreaOMASAPIResponse restoreUsedInContext(@PathVariable
                                                                                                                                  String serverName,
                                                                                                                                  @PathVariable
                                                                                                                                  String userId,
                                                                                                                                  @PathVariable
                                                                                                                                  String guid)

Restore a UsedInContext Restore allows the deleted UsedInContext to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the UsedInContext to delete

Returns:

response which when successful contains the restored UsedInContext when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createpreferredTerm

@PostMapping(path="/users/{userId}/relationships/preferred-terms")
public SubjectAreaOMASAPIResponse createpreferredTerm(@PathVariable
                                                                                                                         String serverName,
                                                                                                                         @PathVariable
                                                                                                                         String userId,
                                                                                                                         @RequestBody
                                                                                                                         PreferredTerm preferredTerm)

Create a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

preferredTerm - the preferred term relationship

Returns:

response, when successful contains the created preferredTerm relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getPreferredTermRelationship

@GetMapping(path="/users/{userId}/relationships/preferred-terms/{guid}")
public SubjectAreaOMASAPIResponse getPreferredTermRelationship(@PathVariable
                                                                                                                                        String serverName,
                                                                                                                                        @PathVariable
                                                                                                                                        String userId,
                                                                                                                                        @PathVariable
                                                                                                                                        String guid)

Get a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the preferredTerm relationship to get

Returns:

response which when successful contains the preferredTerm relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updatePreferredTermRelationship

@PutMapping(path="/users/{userId}/relationships/preferred-terms")
public SubjectAreaOMASAPIResponse updatePreferredTermRelationship(@PathVariable
                                                                                                                                    String serverName,
                                                                                                                                    @PathVariable
                                                                                                                                    String userId,
                                                                                                                                    @RequestBody
                                                                                                                                    PreferredTerm preferredTerm,
                                                                                                                                    @RequestParam(value="isReplace",required=false)
                                                                                                                                    Boolean isReplace)

Update a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

preferredTerm - the preferred term relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created PreferredTermRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• FunctionNotSupportedException Function not supported
• StatusNotSupportedException A status value is not supported

deletePreferredTermRelationship

@DeleteMapping(path="/users/{userId}/relationships/preferred-terms/{guid}")
public SubjectAreaOMASAPIResponse deletePreferredTermRelationship(@PathVariable
                                                                                                                                              String serverName,
                                                                                                                                              @PathVariable
                                                                                                                                              String userId,
                                                                                                                                              @PathVariable
                                                                                                                                              String guid,
                                                                                                                                              @RequestParam(value="isPurge",required=false)
                                                                                                                                              Boolean isPurge)

Delete a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the PreferredTerm relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restorePreferredTerm

@PostMapping(path="/users/{userId}/relationships/preferred-terms/{guid}")
public SubjectAreaOMASAPIResponse restorePreferredTerm(@PathVariable
                                                                                                                                 String serverName,
                                                                                                                                 @PathVariable
                                                                                                                                 String userId,
                                                                                                                                 @PathVariable
                                                                                                                                 String guid)

Restore a PreferredTerm Restore allows the deleted PreferredTerm to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the PreferredTerm to delete

Returns:

response which when successful contains the restored PreferredTerm when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createvalidValue

@PostMapping(path="/users/{userId}/relationships/valid-values")
public SubjectAreaOMASAPIResponse createvalidValue(@PathVariable
                                                                                                                   String serverName,
                                                                                                                   @PathVariable
                                                                                                                   String userId,
                                                                                                                   @RequestBody
                                                                                                                   ValidValue validValue)

Create a validValue relationship, which is a link between glossary terms that have the same meaning.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

validValue - the ValidValue relationship

Returns:

response, when successful contains the created validValue relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getValidValueRelationship

@GetMapping(path="/users/{userId}/relationships/valid-values/{guid}")
public SubjectAreaOMASAPIResponse getValidValueRelationship(@PathVariable
                                                                                                                                  String serverName,
                                                                                                                                  @PathVariable
                                                                                                                                  String userId,
                                                                                                                                  @PathVariable
                                                                                                                                  String guid)

Get a validValue relationship, which is a link between glossary terms that have the same meaning.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the validValue relationship to get

Returns:

response which when successful contains the validValue relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateValidValueRelationship

@PutMapping(path="/users/{userId}/relationships/valid-values")
public SubjectAreaOMASAPIResponse updateValidValueRelationship(@PathVariable
                                                                                                                              String serverName,
                                                                                                                              @PathVariable
                                                                                                                              String userId,
                                                                                                                              @RequestBody
                                                                                                                              ValidValue validValue,
                                                                                                                              @RequestParam(value="isReplace",required=false)
                                                                                                                              Boolean isReplace)

Update a ValidValue relationship which is a link between glossary terms that have the same meaning

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

validValue - the valid value relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created ValidValueRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteValidValueRelationship

@DeleteMapping(path="/users/{userId}/relationships/valid-values/{guid}")
public SubjectAreaOMASAPIResponse deleteValidValueRelationship(@PathVariable
                                                                                                                                        String serverName,
                                                                                                                                        @PathVariable
                                                                                                                                        String userId,
                                                                                                                                        @PathVariable
                                                                                                                                        String guid,
                                                                                                                                        @RequestParam(value="isPurge",required=false)
                                                                                                                                        Boolean isPurge)

Delete a ValidValue relationship

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the ValidValue relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreValidValue

@PostMapping(path="/users/{userId}/relationships/valid-values/{guid}")
public SubjectAreaOMASAPIResponse restoreValidValue(@PathVariable
                                                                                                                           String serverName,
                                                                                                                           @PathVariable
                                                                                                                           String userId,
                                                                                                                           @PathVariable
                                                                                                                           String guid)

Restore a ValidValue Restore allows the deleted ValidValue to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the ValidValue to delete

Returns:

response which when successful contains the restored ValidValue when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createreplacementTerm

@PostMapping(path="/users/{userId}/relationships/replacement-terms")
public SubjectAreaOMASAPIResponse createreplacementTerm(@PathVariable
                                                                                                                             String serverName,
                                                                                                                             @PathVariable
                                                                                                                             String userId,
                                                                                                                             @RequestBody
                                                                                                                             ReplacementTerm replacementTerm)

Create a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

replacementTerm - the ReplacementTerm relationship

Returns:

response, when successful contains the created replacementTerm relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getReplacementTermRelationship

@GetMapping(path="/users/{userId}/relationships/replacement-terms/{guid}")
public SubjectAreaOMASAPIResponse getReplacementTermRelationship(@PathVariable
                                                                                                                                            String serverName,
                                                                                                                                            @PathVariable
                                                                                                                                            String userId,
                                                                                                                                            @PathVariable
                                                                                                                                            String guid)

Get a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the replacementTerm relationship to get

Returns:

response which when successful contains the replacementTerm relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateReplacementTermRelationship

@PutMapping(path="/users/{userId}/relationships/replacement-terms")
public SubjectAreaOMASAPIResponse updateReplacementTermRelationship(@PathVariable
                                                                                                                                        String serverName,
                                                                                                                                        @PathVariable
                                                                                                                                        String userId,
                                                                                                                                        @RequestBody
                                                                                                                                        ReplacementTerm replacementTerm,
                                                                                                                                        @RequestParam(value="isReplace",required=false)
                                                                                                                                        Boolean isReplace)

Update a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

replacementTerm - the replacement term relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created ReplacementTermRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteReplacementTermRelationship

@DeleteMapping(path="/users/{userId}/relationships/replacement-terms/{guid}")
public SubjectAreaOMASAPIResponse deleteReplacementTermRelationship(@PathVariable
                                                                                                                                                  String serverName,
                                                                                                                                                  @PathVariable
                                                                                                                                                  String userId,
                                                                                                                                                  @PathVariable
                                                                                                                                                  String guid,
                                                                                                                                                  @RequestParam(value="isPurge",required=false)
                                                                                                                                                  Boolean isPurge)

Delete a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the ReplacementTerm relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreReplacementTerm

@PostMapping(path="/users/{userId}/relationships/replacement-terms/{guid}")
public SubjectAreaOMASAPIResponse restoreReplacementTerm(@PathVariable
                                                                                                                                     String serverName,
                                                                                                                                     @PathVariable
                                                                                                                                     String userId,
                                                                                                                                     @PathVariable
                                                                                                                                     String guid)

Restore a ReplacementTerm Restore allows the deleted ReplacementTerm to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the ReplacementTerm to delete

Returns:

response which when successful contains the restored ReplacementTerm when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createtermTYPEDBYRelationship

@PostMapping(path="/users/{userId}/relationships/typed-bys")
public SubjectAreaOMASAPIResponse createtermTYPEDBYRelationship(@PathVariable
                                                                                                                             String serverName,
                                                                                                                             @PathVariable
                                                                                                                             String userId,
                                                                                                                             @RequestBody
                                                                                                                             TermTYPEDBYRelationship termTYPEDBYRelationship)

Create a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

termTYPEDBYRelationship - the TermTYPEDBYRelationship relationship

Returns:

response, when successful contains the created termTYPEDBYRelationship relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getTYPEDBYRelationshipRelationship

@GetMapping(path="/users/{userId}/relationships/typed-bys/{guid}")
public SubjectAreaOMASAPIResponse getTYPEDBYRelationshipRelationship(@PathVariable
                                                                                                                                        String serverName,
                                                                                                                                        @PathVariable
                                                                                                                                        String userId,
                                                                                                                                        @PathVariable
                                                                                                                                        String guid)

Get a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the termTYPEDBYRelationship relationship to get

Returns:

response which when successful contains the termTYPEDBYRelationship relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateTermTYPEDBYRelationship

@PutMapping(path="/users/{userId}/relationships/typed-bys")
public SubjectAreaOMASAPIResponse updateTermTYPEDBYRelationship(@PathVariable
                                                                                                                            String serverName,
                                                                                                                            @PathVariable
                                                                                                                            String userId,
                                                                                                                            @RequestBody
                                                                                                                            TermTYPEDBYRelationship termTYPEDBYRelationship,
                                                                                                                            @RequestParam(value="isReplace",required=false)
                                                                                                                            Boolean isReplace)

Update a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

termTYPEDBYRelationship - the typed by relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created TermTYPEDBYRelationshipRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteTypedByRelationship

@DeleteMapping(path="/users/{userId}/relationships/typed-bys/{guid}")
public SubjectAreaOMASAPIResponse deleteTypedByRelationship(@PathVariable
                                                                                                                                  String serverName,
                                                                                                                                  @PathVariable
                                                                                                                                  String userId,
                                                                                                                                  @PathVariable
                                                                                                                                  String guid,
                                                                                                                                  @RequestParam(value="isPurge",required=false)
                                                                                                                                  Boolean isPurge)

Delete a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the TermTYPEDBYRelationship relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreTermTYPEDBYRelationship

@PostMapping(path="/users/{userId}/relationships/typed-bys/{guid}")
public SubjectAreaOMASAPIResponse restoreTermTYPEDBYRelationship(@PathVariable
                                                                                                                                     String serverName,
                                                                                                                                     @PathVariable
                                                                                                                                     String userId,
                                                                                                                                     @PathVariable
                                                                                                                                     String guid)

Restore a Term TYPED BY relationship Restore allows the deleted TermTYPEDBY to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the TermTYPEDBY to delete

Returns:

response which when successful contains the restored TermTYPEDBY when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createiSARelationship

@PostMapping(path="/users/{userId}/relationships/is-as")
public SubjectAreaOMASAPIResponse createiSARelationship(@PathVariable
                                                                                                                 String serverName,
                                                                                                                 @PathVariable
                                                                                                                 String userId,
                                                                                                                 @RequestBody
                                                                                                                 ISARelationship iSARelationship)

Create a iSARelationship relationship, which is a link between a more general glossary term and a more specific definition.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

iSARelationship - the ISARelationship relationship

Returns:

response, when successful contains the created iSARelationship relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getISARelationship

@GetMapping(path="/users/{userId}/relationships/is-as/{guid}")
public SubjectAreaOMASAPIResponse getISARelationship(@PathVariable
                                                                                                                    String serverName,
                                                                                                                    @PathVariable
                                                                                                                    String userId,
                                                                                                                    @PathVariable
                                                                                                                    String guid)

Get a iSARelationship relationship, which is a link between a more general glossary term and a more specific definition.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the iSARelationship relationship to get

Returns:

response which when successful contains the iSARelationship relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateISARelationship

@PutMapping(path="/users/{userId}/relationships/is-as")
public SubjectAreaOMASAPIResponse updateISARelationship(@PathVariable
                                                                                                                String serverName,
                                                                                                                @PathVariable
                                                                                                                String userId,
                                                                                                                @RequestBody
                                                                                                                ISARelationship isa,
                                                                                                                @RequestParam(value="isReplace",required=false)
                                                                                                                Boolean isReplace)

Update a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

isa - the is-a relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created ISARelationshipRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteTermISARelationship

@DeleteMapping(path="/users/{userId}/relationships/is-as/{guid}")
public SubjectAreaOMASAPIResponse deleteTermISARelationship(@PathVariable
                                                                                                                              String serverName,
                                                                                                                              @PathVariable
                                                                                                                              String userId,
                                                                                                                              @PathVariable
                                                                                                                              String guid,
                                                                                                                              @RequestParam(value="isPurge",required=false)
                                                                                                                              Boolean isPurge)

Delete a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the ISARelationship relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreIsaRelationship

@PostMapping(path="/users/{userId}/relationships/is-as/{guid}")
public SubjectAreaOMASAPIResponse restoreIsaRelationship(@PathVariable
                                                                                                                         String serverName,
                                                                                                                         @PathVariable
                                                                                                                         String userId,
                                                                                                                         @PathVariable
                                                                                                                         String guid)

Restore a Isa Relationship Restore allows the deleted Isa Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Isa Relationship to delete

Returns:

response which when successful contains the restored IsaRelationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createtermISATypeOFRelationship

@PostMapping(path="/users/{userId}/relationships/is-a-type-ofs")
public SubjectAreaOMASAPIResponse createtermISATypeOFRelationship(@PathVariable
                                                                                                                                   String serverName,
                                                                                                                                   @PathVariable
                                                                                                                                   String userId,
                                                                                                                                   @RequestBody
                                                                                                                                   TermISATypeOFRelationship termISATypeOFRelationship)

Create a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

termISATypeOFRelationship - the TermISATypeOFRelationship relationship

Returns:

response, when successful contains the created termISATypeOFRelationship relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getTermISATypeOFRelationship

@GetMapping(path="/users/{userId}/relationships/is-a-type-ofs/{guid}")
public SubjectAreaOMASAPIResponse getTermISATypeOFRelationship(@PathVariable
                                                                                                                                      String serverName,
                                                                                                                                      @PathVariable
                                                                                                                                      String userId,
                                                                                                                                      @PathVariable
                                                                                                                                      String guid)

Get a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the termISATypeOFRelationship relationship to get

Returns:

response which when successful contains the termISATypeOFRelationship relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateISARelationship

@PutMapping(path="/users/{userId}/relationships/is-a-type-ofs")
public SubjectAreaOMASAPIResponse updateISARelationship(@PathVariable
                                                                                                                        String serverName,
                                                                                                                        @PathVariable
                                                                                                                        String userId,
                                                                                                                        @RequestBody
                                                                                                                        TermISATypeOFRelationship isatypeof,
                                                                                                                        @RequestParam(value="isReplace",required=false)
                                                                                                                        Boolean isReplace)

Update a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

isatypeof - the is-a-type-of relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created ISARelationshipRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteTermIsaTypeOfRelationship

@DeleteMapping(path="/users/{userId}/relationships/is-a-type-ofs/{guid}")
public SubjectAreaOMASAPIResponse deleteTermIsaTypeOfRelationship(@PathVariable
                                                                                                                                            String serverName,
                                                                                                                                            @PathVariable
                                                                                                                                            String userId,
                                                                                                                                            @PathVariable
                                                                                                                                            String guid,
                                                                                                                                            @RequestParam(value="isPurge",required=false)
                                                                                                                                            Boolean isPurge)

Delete a TermISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the TermISATypeOFRelationship relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreTermIsaTypeOfRelationship

@PostMapping(path="/users/{userId}/relationships/is-a-type-ofs/{guid}")
public SubjectAreaOMASAPIResponse restoreTermIsaTypeOfRelationship(@PathVariable
                                                                                                                                           String serverName,
                                                                                                                                           @PathVariable
                                                                                                                                           String userId,
                                                                                                                                           @PathVariable
                                                                                                                                           String guid)

Restore a Is a Type Of Relationship Restore allows the deleted Is a Type Of Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Term Is a Type Of Relationship to delete

Returns:

response which when successful contains the restored TermIsaTypeOfRelationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createTermCategorization

@PostMapping(path="/users/{userId}/relationships/term-categorizations")
public SubjectAreaOMASAPIResponse createTermCategorization(@PathVariable
                                                                                                                                   String serverName,
                                                                                                                                   @PathVariable
                                                                                                                                   String userId,
                                                                                                                                   @RequestBody
                                                                                                                                   TermCategorizationRelationship termCategorizationRelationship)

Create a termCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

termCategorizationRelationship - the TermCategorizationRelationship relationship

Returns:

response, when successful contains the created termCategorizationRelationship relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getTermCategorizationRelationship

@GetMapping(path="/users/{userId}/relationships/term-categorizations/{guid}")
public SubjectAreaOMASAPIResponse getTermCategorizationRelationship(@PathVariable
                                                                                                                                                  String serverName,
                                                                                                                                                  @PathVariable
                                                                                                                                                  String userId,
                                                                                                                                                  @PathVariable
                                                                                                                                                  String guid)

Get a termCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the termCategorizationRelationship relationship to get

Returns:

response which when successful contains the termCategorizationRelationship relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateTermCategorizationRelationship

@PutMapping(path="/users/{userId}/relationships/term-categorizations")
public SubjectAreaOMASAPIResponse updateTermCategorizationRelationship(@PathVariable
                                                                                                                                              String serverName,
                                                                                                                                              @PathVariable
                                                                                                                                              String userId,
                                                                                                                                              @RequestBody
                                                                                                                                              TermCategorizationRelationship isatypeof,
                                                                                                                                              @RequestParam(value="isReplace",required=false)
                                                                                                                                              Boolean isReplace)

Update a termCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

isatypeof - the is-a-type-of relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created termCategorization Relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteTermCategorizationRelationship

@DeleteMapping(path="/users/{userId}/relationships/term-categorizations/{guid}")
public SubjectAreaOMASAPIResponse deleteTermCategorizationRelationship(@PathVariable
                                                                                                                                                        String serverName,
                                                                                                                                                        @PathVariable
                                                                                                                                                        String userId,
                                                                                                                                                        @PathVariable
                                                                                                                                                        String guid,
                                                                                                                                                        @RequestParam(value="isPurge",required=false)
                                                                                                                                                        Boolean isPurge)

Delete a TermCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the TermCategorizationRelationship relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreTermCategorizationRelationship

@PostMapping(path="/users/{userId}/relationships/term-categorizations/{guid}")
public SubjectAreaOMASAPIResponse restoreTermCategorizationRelationship(@PathVariable
                                                                                                                                                       String serverName,
                                                                                                                                                       @PathVariable
                                                                                                                                                       String userId,
                                                                                                                                                       @PathVariable
                                                                                                                                                       String guid)

Restore a TermCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized. Restore allows the deleted TermCategorization Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Term Is a Type Of Relationship to delete

Returns:

response which when successful contains the restored TermCategorization when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createTermAnchor

@PostMapping(path="/users/{userId}/relationships/term-anchor")
public SubjectAreaOMASAPIResponse createTermAnchor(@PathVariable
                                                                                                                  String serverName,
                                                                                                                  @PathVariable
                                                                                                                  String userId,
                                                                                                                  @RequestBody
                                                                                                                  TermAnchorRelationship termAnchorRelationship)

Create a termAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary. Terms created using the Subject Area OMAS cannot be created without a glossary and there can only be one glossary associated with a Term. This method is to allow glossaries to be associated with Terms that have not been created via the Subject Area OMAS or to recreate the TermAnchor relationship if it has been purged.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

termAnchorRelationship - the TermAnchorRelationship relationship

Returns:

response, when successful contains the created termAnchorRelationship relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification.
• StatusNotSupportedException A status value is not supported.
• FunctionNotSupportedException Function not supported.

getTermAnchorRelationship

@GetMapping(path="/users/{userId}/relationships/term-anchor/{guid}")
public SubjectAreaOMASAPIResponse getTermAnchorRelationship(@PathVariable
                                                                                                                                 String serverName,
                                                                                                                                 @PathVariable
                                                                                                                                 String userId,
                                                                                                                                 @PathVariable
                                                                                                                                 String guid)

Get a termAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the termAnchor Relationship to get

Returns:

response which when successful contains the termAnchorRelationship relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

deleteTermAnchorRelationship

@DeleteMapping(path="/users/{userId}/relationships/term-anchor/{guid}")
public SubjectAreaOMASAPIResponse deleteTermAnchorRelationship(@PathVariable
                                                                                                                                       String serverName,
                                                                                                                                       @PathVariable
                                                                                                                                       String userId,
                                                                                                                                       @PathVariable
                                                                                                                                       String guid,
                                                                                                                                       @RequestParam(value="isPurge",required=false)
                                                                                                                                       Boolean isPurge)

Delete a TermAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the TermAnchorRelationship relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreTermAnchorRelationship

@PostMapping(path="/users/{userId}/relationships/term-anchor/{guid}")
public SubjectAreaOMASAPIResponse restoreTermAnchorRelationship(@PathVariable
                                                                                                                                      String serverName,
                                                                                                                                      @PathVariable
                                                                                                                                      String userId,
                                                                                                                                      @PathVariable
                                                                                                                                      String guid)

Restore a TermAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary. Restore allows the deleted TermAnchor Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Term Anchor Relationship to delete

Returns:

response which when successful contains the restored TermAnchor when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createCategoryAnchor

@PostMapping(path="/users/{userId}/relationships/category-anchor")
public SubjectAreaOMASAPIResponse createCategoryAnchor(@PathVariable
                                                                                                                          String serverName,
                                                                                                                          @PathVariable
                                                                                                                          String userId,
                                                                                                                          @RequestBody
                                                                                                                          CategoryAnchorRelationship categoryAnchorRelationship)

Create a categoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows terms to be owned by a Glossary. Categories created using the Subject Area OMAS cannot be created without a glossary and there can only be one glossary associated with a Category. This method is to allow glossaries to be associated with Categories that have not been created via the Subject Area OMAS or to recreate the CategoryAnchor relationship if it has been purged.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

categoryAnchorRelationship - the CategoryAnchorRelationship relationship

Returns:

response, when successful contains the created categoryAnchorRelationship relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification.
• StatusNotSupportedException A status value is not supported.
• FunctionNotSupportedException Function not supported.

getCategoryAnchorRelationship

@GetMapping(path="/users/{userId}/relationships/category-anchor/{guid}")
public SubjectAreaOMASAPIResponse getCategoryAnchorRelationship(@PathVariable
                                                                                                                                         String serverName,
                                                                                                                                         @PathVariable
                                                                                                                                         String userId,
                                                                                                                                         @PathVariable
                                                                                                                                         String guid)

Get a categoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows terms to be owned by a Glossary.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the categoryAnchor Relationship to get

Returns:

response which when successful contains the categoryAnchorRelationship relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

deleteCategoryAnchorRelationship

@DeleteMapping(path="/users/{userId}/relationships/category-anchor/{guid}")
public SubjectAreaOMASAPIResponse deleteCategoryAnchorRelationship(@PathVariable
                                                                                                                                               String serverName,
                                                                                                                                               @PathVariable
                                                                                                                                               String userId,
                                                                                                                                               @PathVariable
                                                                                                                                               String guid,
                                                                                                                                               @RequestParam(value="isPurge",required=false)
                                                                                                                                               Boolean isPurge)

Delete a CategoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows terms to be owned by a Glossary.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the CategoryAnchorRelationship relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreCategoryAnchorRelationship

@PostMapping(path="/users/{userId}/relationships/category-anchor/{guid}")
public SubjectAreaOMASAPIResponse restoreCategoryAnchorRelationship(@PathVariable
                                                                                                                                              String serverName,
                                                                                                                                              @PathVariable
                                                                                                                                              String userId,
                                                                                                                                              @PathVariable
                                                                                                                                              String guid)

Restore a CategoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows terms to be owned by a Glossary. Restore allows the deleted CategoryAnchor Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Category Anchor Relationship to delete

Returns:

response which when successful contains the restored CategoryAnchor when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

createProjectScopeRelationship

@PostMapping(path="/users/{userId}/relationships/project-scopes")
public SubjectAreaOMASAPIResponse createProjectScopeRelationship(@PathVariable
                                                                                                                                   String serverName,
                                                                                                                                   @PathVariable
                                                                                                                                   String userId,
                                                                                                                                   @RequestBody
                                                                                                                                   ProjectScopeRelationship projectScope)

Create a project scope relationship, which is a link between the project content and the project.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

projectScope - the Project scope relationship

Returns:

response, when successful contains the created project scope relationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

getProjectScopeRelationship

@GetMapping(path="/users/{userId}/relationships/project-scopes/{guid}")
public SubjectAreaOMASAPIResponse getProjectScopeRelationship(@PathVariable
                                                                                                                                      String serverName,
                                                                                                                                      @PathVariable
                                                                                                                                      String userId,
                                                                                                                                      @PathVariable
                                                                                                                                      String guid)

Get a project scope relationship, which is a link between the project content and the project.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the project scope relationship to get

Returns:

response which when successful contains the project scope relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised

updateProjectScopeRelationship

@PutMapping(path="/users/{userId}/relationships/project-scopes")
public SubjectAreaOMASAPIResponse updateProjectScopeRelationship(@PathVariable
                                                                                                                                  String serverName,
                                                                                                                                  @PathVariable
                                                                                                                                  String userId,
                                                                                                                                  @RequestBody
                                                                                                                                  ProjectScopeRelationship projectScope,
                                                                                                                                  @RequestParam(value="isReplace",required=false)
                                                                                                                                  Boolean isReplace)

Update a Project scope relationship which is a link between the project content and the project.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - userId under which the request is performed

projectScope - the projectScope relationship

isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.

Returns:

response, when successful contains the created ProjectScopeRelationship when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised
• ClassificationException Error processing a classification
• StatusNotSupportedException A status value is not supported

deleteProjectScopeRelationship

@DeleteMapping(path="/users/{userId}/relationships/project-scopes/{guid}")
public SubjectAreaOMASAPIResponse deleteProjectScopeRelationship(@PathVariable
                                                                                                                                            String serverName,
                                                                                                                                            @PathVariable
                                                                                                                                            String userId,
                                                                                                                                            @PathVariable
                                                                                                                                            String guid,
                                                                                                                                            @RequestParam(value="isPurge",required=false)
                                                                                                                                            Boolean isPurge)

Delete a Project scope relationship which is a link between the project content and the project.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the Project scope relationship to delete

isPurge - true indicates a hard delete, false is a soft delete.

Returns:

response for a soft delete the response contains the deleted relationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
• EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
• GUIDNotPurgedException a hard delete was issued but the relationship was not purged

restoreProjectScoperRelationship

@PostMapping(path="/users/{userId}/relationships/project-scopes/{guid}")
public SubjectAreaOMASAPIResponse restoreProjectScoperRelationship(@PathVariable
                                                                                                                                            String serverName,
                                                                                                                                            @PathVariable
                                                                                                                                            String userId,
                                                                                                                                            @PathVariable
                                                                                                                                            String guid)

Restore a ProjectScope, which is a link between the project content and the project. Restore allows the deleted ProjectScopeRelationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the ProjectScopeRelationship to delete

Returns:

response which when successful contains the restored ProjectScopeRelationship when not successful the following Exception responses can occur

• UnrecognizedGUIDException the supplied guid was not recognised
• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
• InvalidParameterException one of the parameters is null or invalid.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.

getSemanticAssignmentRelationship

@GetMapping(path="/users/{userId}/relationships/semantic-assignments/{guid}")
public SubjectAreaOMASAPIResponse getSemanticAssignmentRelationship(@PathVariable
                                                                                                                                                  String serverName,
                                                                                                                                                  @PathVariable
                                                                                                                                                  String userId,
                                                                                                                                                  @PathVariable
                                                                                                                                                  String guid)

Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.

Parameters:

serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant

userId - unique identifier for requesting user, under which the request is performed

guid - guid of the SemanticAssignment relationship to get

Returns:

response which when successful contains the SemanticAssignment relationship with the requested guid when not successful the following Exception responses can occur

• UserNotAuthorizedException the requesting user is not authorized to issue this request.
• MetadataServerUncontactableException not able to communicate with a Metadata respository service.
• InvalidParameterException one of the parameters is null or invalid.
• UnrecognizedGUIDException the supplied guid was not recognised