TermResource (Glossary View OMAS with Spring 1.2 API)

java.lang.Object
- org.odpi.openmetadata.accessservices.glossaryview.server.spring.TermResource

@RestController
 @Validated
 @RequestMapping(value="/servers/{serverName}/open-metadata/access-services/glossary-view/users/{userId}")
public class TermResource
extends Object

Spring Rest Controller defining 'GlossaryTerm' oriented endpoints

Constructor Summary

Constructors
Constructor and Description

TermResource()
Called by Spring

Constructors
Constructor and Description
`TermResource()` Called by Spring

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`GlossaryViewEntityDetailResponse`	`getAntonyms(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract antonyms
`GlossaryViewEntityDetailResponse`	`getAssignedElements(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract assigned elements
`GlossaryViewEntityDetailResponse`	`getAttributes(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract attributes
`GlossaryViewEntityDetailResponse`	`getExternalGlossaryLinks(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract external glossary link definitions for the given term
`GlossaryViewEntityDetailResponse`	`getIsA(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract "is a"
`GlossaryViewEntityDetailResponse`	`getPreferredTerms(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract preferred terms
`GlossaryViewEntityDetailResponse`	`getRelatedTerms(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract related terms
`GlossaryViewEntityDetailResponse`	`getReplacementTerms(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract replacement terms
`GlossaryViewEntityDetailResponse`	`getSubtypes(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract subtypes
`GlossaryViewEntityDetailResponse`	`getSynonyms(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract synonyms
`GlossaryViewEntityDetailResponse`	`getTerm(String serverName, String userId, @NotBlank String termGUID)` Extract a term definition for the given GUID
`GlossaryViewEntityDetailResponse`	`getTermsViaTermAnchorRelationships(String serverName, String userId, @NotBlank String glossaryGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract term definitions for the given glossary GUID via the 'TermAnchor' type relationships
`GlossaryViewEntityDetailResponse`	`getTermsViaTermCategorizationRelationships(String serverName, String userId, @NotBlank String categoryGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract term definitions for the given GUID via the 'TermCategorization' type relationships
`GlossaryViewEntityDetailResponse`	`getTranslations(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract translations
`GlossaryViewEntityDetailResponse`	`getTypes(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract types
`GlossaryViewEntityDetailResponse`	`getUsedInContexts(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract "used in contexts"
`GlossaryViewEntityDetailResponse`	`getValidValues(String serverName, String userId, @NotBlank String termGUID, @PositiveOrZero Integer from, @PositiveOrZero @Max(value=10000L) Integer size)` Extract valid values

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

Constructor Detail
- TermResource
```
public TermResource()
```
  Called by Spring

Method Detail

getTerm

@RequestMapping(method=GET,
                path="/terms/{termGUID}")
public GlossaryViewEntityDetailResponse getTerm(@PathVariable(value="serverName")
                                                                                                                      String serverName,
                                                                                                                      @PathVariable(value="userId")
                                                                                                                      String userId,
                                                                                                                      @PathVariable(value="termGUID") @NotBlank
                                                                                                                      @NotBlank String termGUID)

Extract a term definition for the given GUID

Parameters:: serverName - instance to call; userId - calling user; termGUID - category GUID
Returns:: term

getTermsViaTermAnchorRelationships

@RequestMapping(method=GET,
                path="/glossaries/{glossaryGUID}/terms")
public GlossaryViewEntityDetailResponse getTermsViaTermAnchorRelationships(@PathVariable(value="serverName")
                                                                                                                                                                String serverName,
                                                                                                                                                                @PathVariable(value="userId")
                                                                                                                                                                String userId,
                                                                                                                                                                @PathVariable(value="glossaryGUID") @NotBlank
                                                                                                                                                                @NotBlank String glossaryGUID,
                                                                                                                                                                @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                                                @PositiveOrZero Integer from,
                                                                                                                                                                @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                                                @PositiveOrZero @Max(value=10000L) Integer size)

Extract term definitions for the given glossary GUID via the 'TermAnchor' type relationships

Parameters:: serverName - instance to call; userId - calling user; glossaryGUID - glossary GUID; from - from; size - size
Returns:: terms

getTermsViaTermCategorizationRelationships

@RequestMapping(method=GET,
                path="/categories/{categoryGUID}/terms")
public GlossaryViewEntityDetailResponse getTermsViaTermCategorizationRelationships(@PathVariable(value="serverName")
                                                                                                                                                                        String serverName,
                                                                                                                                                                        @PathVariable(value="userId")
                                                                                                                                                                        String userId,
                                                                                                                                                                        @PathVariable(value="categoryGUID") @NotBlank
                                                                                                                                                                        @NotBlank String categoryGUID,
                                                                                                                                                                        @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                                                        @PositiveOrZero Integer from,
                                                                                                                                                                        @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                                                        @PositiveOrZero @Max(value=10000L) Integer size)

Extract term definitions for the given GUID via the 'TermCategorization' type relationships

Parameters:: serverName - instance to call; userId - calling user; categoryGUID - category GUID; from - from; size - size
Returns:: subcategories

getExternalGlossaryLinks

@RequestMapping(method=GET,
                path="/terms/{termGUID}/external-glossary-links")
public GlossaryViewEntityDetailResponse getExternalGlossaryLinks(@PathVariable(value="serverName")
                                                                                                                                                               String serverName,
                                                                                                                                                               @PathVariable(value="userId")
                                                                                                                                                               String userId,
                                                                                                                                                               @PathVariable(value="termGUID") @NotBlank
                                                                                                                                                               @NotBlank String termGUID,
                                                                                                                                                               @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                                               @PositiveOrZero Integer from,
                                                                                                                                                               @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                                               @PositiveOrZero @Max(value=10000L) Integer size)

Extract external glossary link definitions for the given term

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: external glossary links

getRelatedTerms

@RequestMapping(method=GET,
                path="/terms/{termGUID}/see-also")
public GlossaryViewEntityDetailResponse getRelatedTerms(@PathVariable(value="serverName")
                                                                                                                                       String serverName,
                                                                                                                                       @PathVariable(value="userId")
                                                                                                                                       String userId,
                                                                                                                                       @PathVariable(value="termGUID") @NotBlank
                                                                                                                                       @NotBlank String termGUID,
                                                                                                                                       @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                       @PositiveOrZero Integer from,
                                                                                                                                       @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                       @PositiveOrZero @Max(value=10000L) Integer size)

Extract related terms

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: related terms

getSynonyms

@RequestMapping(method=GET,
                path="/terms/{termGUID}/synonyms")
public GlossaryViewEntityDetailResponse getSynonyms(@PathVariable(value="serverName")
                                                                                                                                   String serverName,
                                                                                                                                   @PathVariable(value="userId")
                                                                                                                                   String userId,
                                                                                                                                   @PathVariable(value="termGUID") @NotBlank
                                                                                                                                   @NotBlank String termGUID,
                                                                                                                                   @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                   @PositiveOrZero Integer from,
                                                                                                                                   @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                   @PositiveOrZero @Max(value=10000L) Integer size)

Extract synonyms

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: synonyms

getAntonyms

@RequestMapping(method=GET,
                path="/terms/{termGUID}/antonyms")
public GlossaryViewEntityDetailResponse getAntonyms(@PathVariable(value="serverName")
                                                                                                                                   String serverName,
                                                                                                                                   @PathVariable(value="userId")
                                                                                                                                   String userId,
                                                                                                                                   @PathVariable(value="termGUID") @NotBlank
                                                                                                                                   @NotBlank String termGUID,
                                                                                                                                   @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                   @PositiveOrZero Integer from,
                                                                                                                                   @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                   @PositiveOrZero @Max(value=10000L) Integer size)

Extract antonyms

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: antonyms

getPreferredTerms

@RequestMapping(method=GET,
                path="/terms/{termGUID}/preferred-terms")
public GlossaryViewEntityDetailResponse getPreferredTerms(@PathVariable(value="serverName")
                                                                                                                                                String serverName,
                                                                                                                                                @PathVariable(value="userId")
                                                                                                                                                String userId,
                                                                                                                                                @PathVariable(value="termGUID") @NotBlank
                                                                                                                                                @NotBlank String termGUID,
                                                                                                                                                @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                                @PositiveOrZero Integer from,
                                                                                                                                                @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                                @PositiveOrZero @Max(value=10000L) Integer size)

Extract preferred terms

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: preferred terms

getReplacementTerms

@RequestMapping(method=GET,
                path="/terms/{termGUID}/replacement-terms")
public GlossaryViewEntityDetailResponse getReplacementTerms(@PathVariable(value="serverName")
                                                                                                                                                    String serverName,
                                                                                                                                                    @PathVariable(value="userId")
                                                                                                                                                    String userId,
                                                                                                                                                    @PathVariable(value="termGUID") @NotBlank
                                                                                                                                                    @NotBlank String termGUID,
                                                                                                                                                    @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                                    @PositiveOrZero Integer from,
                                                                                                                                                    @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                                    @PositiveOrZero @Max(value=10000L) Integer size)

Extract replacement terms

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: replacement terms

getTranslations

@RequestMapping(method=GET,
                path="/terms/{termGUID}/translations")
public GlossaryViewEntityDetailResponse getTranslations(@PathVariable(value="serverName")
                                                                                                                                           String serverName,
                                                                                                                                           @PathVariable(value="userId")
                                                                                                                                           String userId,
                                                                                                                                           @PathVariable(value="termGUID") @NotBlank
                                                                                                                                           @NotBlank String termGUID,
                                                                                                                                           @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                           @PositiveOrZero Integer from,
                                                                                                                                           @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                           @PositiveOrZero @Max(value=10000L) Integer size)

Extract translations

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: translations

getIsA

@RequestMapping(method=GET,
                path="/terms/{termGUID}/is-a")
public GlossaryViewEntityDetailResponse getIsA(@PathVariable(value="serverName")
                                                                                                                          String serverName,
                                                                                                                          @PathVariable(value="userId")
                                                                                                                          String userId,
                                                                                                                          @PathVariable(value="termGUID") @NotBlank
                                                                                                                          @NotBlank String termGUID,
                                                                                                                          @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                          @PositiveOrZero Integer from,
                                                                                                                          @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                          @PositiveOrZero @Max(value=10000L) Integer size)

Extract "is a"

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: "is a"

getValidValues

@RequestMapping(method=GET,
                path="/terms/{termGUID}/valid-values")
public GlossaryViewEntityDetailResponse getValidValues(@PathVariable(value="serverName")
                                                                                                                                          String serverName,
                                                                                                                                          @PathVariable(value="userId")
                                                                                                                                          String userId,
                                                                                                                                          @PathVariable(value="termGUID") @NotBlank
                                                                                                                                          @NotBlank String termGUID,
                                                                                                                                          @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                          @PositiveOrZero Integer from,
                                                                                                                                          @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                          @PositiveOrZero @Max(value=10000L) Integer size)

Extract valid values

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: valid values

getUsedInContexts

@RequestMapping(method=GET,
                path="/terms/{termGUID}/used-in-contexts")
public GlossaryViewEntityDetailResponse getUsedInContexts(@PathVariable(value="serverName")
                                                                                                                                                 String serverName,
                                                                                                                                                 @PathVariable(value="userId")
                                                                                                                                                 String userId,
                                                                                                                                                 @PathVariable(value="termGUID") @NotBlank
                                                                                                                                                 @NotBlank String termGUID,
                                                                                                                                                 @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                                 @PositiveOrZero Integer from,
                                                                                                                                                 @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                                 @PositiveOrZero @Max(value=10000L) Integer size)

Extract "used in contexts"

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: "used in contexts"

getAssignedElements

@RequestMapping(method=GET,
                path="/terms/{termGUID}/assigned-elements")
public GlossaryViewEntityDetailResponse getAssignedElements(@PathVariable(value="serverName")
                                                                                                                                                    String serverName,
                                                                                                                                                    @PathVariable(value="userId")
                                                                                                                                                    String userId,
                                                                                                                                                    @PathVariable(value="termGUID") @NotBlank
                                                                                                                                                    @NotBlank String termGUID,
                                                                                                                                                    @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                                    @PositiveOrZero Integer from,
                                                                                                                                                    @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                                    @PositiveOrZero @Max(value=10000L) Integer size)

Extract assigned elements

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: assigned elements

getAttributes

@RequestMapping(method=GET,
                path="/terms/{termGUID}/attributes")
public GlossaryViewEntityDetailResponse getAttributes(@PathVariable(value="serverName")
                                                                                                                                       String serverName,
                                                                                                                                       @PathVariable(value="userId")
                                                                                                                                       String userId,
                                                                                                                                       @PathVariable(value="termGUID") @NotBlank
                                                                                                                                       @NotBlank String termGUID,
                                                                                                                                       @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                       @PositiveOrZero Integer from,
                                                                                                                                       @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                       @PositiveOrZero @Max(value=10000L) Integer size)

Extract attributes

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: attributes

getSubtypes

@RequestMapping(method=GET,
                path="/terms/{termGUID}/subtypes")
public GlossaryViewEntityDetailResponse getSubtypes(@PathVariable(value="serverName")
                                                                                                                                   String serverName,
                                                                                                                                   @PathVariable(value="userId")
                                                                                                                                   String userId,
                                                                                                                                   @PathVariable(value="termGUID") @NotBlank
                                                                                                                                   @NotBlank String termGUID,
                                                                                                                                   @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                                   @PositiveOrZero Integer from,
                                                                                                                                   @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                                   @PositiveOrZero @Max(value=10000L) Integer size)

Extract subtypes

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: subtypes

getTypes

@RequestMapping(method=GET,
                path="/terms/{termGUID}/types")
public GlossaryViewEntityDetailResponse getTypes(@PathVariable(value="serverName")
                                                                                                                             String serverName,
                                                                                                                             @PathVariable(value="userId")
                                                                                                                             String userId,
                                                                                                                             @PathVariable(value="termGUID") @NotBlank
                                                                                                                             @NotBlank String termGUID,
                                                                                                                             @RequestParam(name="from",defaultValue="0") @PositiveOrZero
                                                                                                                             @PositiveOrZero Integer from,
                                                                                                                             @RequestParam(name="size",defaultValue="1000") @PositiveOrZero @Max(value=10000L)
                                                                                                                             @PositiveOrZero @Max(value=10000L) Integer size)

Extract types

Parameters:: serverName - instance to call; userId - calling user; termGUID - term GUID; from - from; size - size
Returns:: types

Class TermResource

Constructor Summary