org.odpi.openmetadata.accessservices.digitalarchitecture.client.LocationManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of digital-architecture-client Show documentation
Show all versions of digital-architecture-client Show documentation
Client library for the Digital Architecture Open Metadata Access Service (OMAS).
/* SPDX-License-Identifier: Apache 2.0 */
/* Copyright Contributors to the ODPi Egeria project. */
package org.odpi.openmetadata.accessservices.digitalarchitecture.client;
import org.odpi.openmetadata.accessservices.digitalarchitecture.api.ManageLocations;
import org.odpi.openmetadata.accessservices.digitalarchitecture.client.rest.DigitalArchitectureRESTClient;
import org.odpi.openmetadata.accessservices.digitalarchitecture.metadataelements.*;
import org.odpi.openmetadata.accessservices.digitalarchitecture.properties.*;
import org.odpi.openmetadata.accessservices.digitalarchitecture.rest.*;
import org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse;
import org.odpi.openmetadata.commonservices.ffdc.rest.NameRequestBody;
import org.odpi.openmetadata.commonservices.ffdc.rest.SearchStringRequestBody;
import org.odpi.openmetadata.frameworks.auditlog.AuditLog;
import org.odpi.openmetadata.frameworks.connectors.ffdc.InvalidParameterException;
import org.odpi.openmetadata.frameworks.connectors.ffdc.PropertyServerException;
import org.odpi.openmetadata.frameworks.connectors.ffdc.UserNotAuthorizedException;
import java.util.List;
/**
* LocationManager provides the API operations to create and maintain location definitions.
*
*/
public class LocationManager extends DigitalArchitectureClientBase implements ManageLocations
{
/**
* Create a new client with no authentication embedded in the HTTP request and an audit log.
*
* @param serverName name of the server to connect to
* @param serverPlatformURLRoot the network address of the server running the OMAS REST servers
* @param auditLog logging destination
* @throws InvalidParameterException there is a problem creating the client-side components to issue any
* REST API calls.
*/
public LocationManager(String serverName,
String serverPlatformURLRoot,
AuditLog auditLog) throws InvalidParameterException
{
super(serverName, serverPlatformURLRoot, auditLog);
}
/**
* Create a new client with no authentication embedded in the HTTP request.
*
* @param serverName name of the server to connect to
* @param serverPlatformURLRoot the network address of the server running the OMAS REST servers
* @throws InvalidParameterException there is a problem creating the client-side components to issue any
* REST API calls.
*/
public LocationManager(String serverName,
String serverPlatformURLRoot) throws InvalidParameterException
{
super(serverName, serverPlatformURLRoot);
}
/**
* Create a new client that passes userId and password in each HTTP request. This is the
* userId/password of the calling server. The end user's userId is sent on each request.
* There is also an audit log destination.
*
* @param serverName name of the server to connect to
* @param serverPlatformURLRoot the network address of the server running the OMAS REST servers
* @param userId caller's userId embedded in all HTTP requests
* @param password caller's userId embedded in all HTTP requests
* @param auditLog logging destination
* @throws InvalidParameterException there is a problem creating the client-side components to issue any
* REST API calls.
*/
public LocationManager(String serverName,
String serverPlatformURLRoot,
String userId,
String password,
AuditLog auditLog) throws InvalidParameterException
{
super(serverName, serverPlatformURLRoot, userId, password, auditLog);
}
/**
* Create a new client that passes userId and password in each HTTP request. This is the
* userId/password of the calling server. The end user's userId is sent on each request.
*
* @param serverName name of the server to connect to
* @param serverPlatformURLRoot the network address of the server running the OMAS REST servers
* @param userId caller's userId embedded in all HTTP requests
* @param password caller's userId embedded in all HTTP requests
* @throws InvalidParameterException there is a problem creating the client-side components to issue any
* REST API calls.
*/
public LocationManager(String serverName,
String serverPlatformURLRoot,
String userId,
String password) throws InvalidParameterException
{
super(serverName, serverPlatformURLRoot, userId, password);
}
/**
* Create a new client that is going to be used in an OMAG Server (view service or integration service typically).
*
* @param serverName name of the server to connect to
* @param serverPlatformURLRoot the network address of the server running the OMAS REST servers
* @param restClient client that issues the REST API calls
* @param maxPageSize maximum number of results supported by this server
* @param auditLog logging destination
* @throws InvalidParameterException there is a problem creating the client-side components to issue any
* REST API calls.
*/
public LocationManager(String serverName,
String serverPlatformURLRoot,
DigitalArchitectureRESTClient restClient,
int maxPageSize,
AuditLog auditLog) throws InvalidParameterException
{
super(serverName, serverPlatformURLRoot, restClient, maxPageSize, auditLog);
}
/*
* ==============================================
* ManageLocations
* ==============================================
*/
/**
* Create a new metadata element to represent a location. Classifications can be added later to define the
* type of location.
*
* @param userId calling user
* @param locationProperties properties to store
* @return unique identifier of the new metadata element
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public String createLocation(String userId,
LocationProperties locationProperties) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "createLocation";
final String nameParameter = "qualifiedName";
final String propertiesParameter = "locationProperties";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateObject(locationProperties, propertiesParameter, methodName);
invalidParameterHandler.validateName(locationProperties.getQualifiedName(), nameParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations";
GUIDResponse restResult = restClient.callGUIDPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
locationProperties,
serverName,
userId);
return restResult.getGUID();
}
/**
* Create a new metadata element to represent a location using an existing metadata element as a template.
* The template defines additional classifications and relationships that should be added to the new location.
*
* @param userId calling user
* @param templateGUID unique identifier of the metadata element to copy
* @param templateProperties properties that override the template
* @return unique identifier of the new metadata element
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public String createLocationFromTemplate(String userId,
String templateGUID,
TemplateProperties templateProperties) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "createLocationFromTemplate";
final String nameParameter = "qualifiedName";
final String propertiesParameter = "templateProperties";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateObject(templateProperties, propertiesParameter, methodName);
invalidParameterHandler.validateName(templateProperties.getQualifiedName(), nameParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/from-template/{2}";
GUIDResponse restResult = restClient.callGUIDPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
templateProperties,
serverName,
userId,
templateGUID);
return restResult.getGUID();
}
/**
* Update the metadata element representing a location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to update
* @param locationProperties new properties for this element
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void updateLocation(String userId,
String locationGUID,
LocationProperties locationProperties) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "updateLocation";
final String guidParameter = "locationGUID";
final String propertiesParameter = "templateProperties";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, guidParameter, methodName);
invalidParameterHandler.validateObject(locationProperties, propertiesParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}/update";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
locationProperties,
serverName,
userId,
locationGUID);
}
/**
* Classify the location to indicate that it represents a fixed physical location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to classify
* @param coordinates position of the location
* @param mapProjection map projection used to define the coordinates
* @param postalAddress postal address of the location (if appropriate)
* @param timeZone time zone for the location
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void setLocationAsFixedPhysical(String userId,
String locationGUID,
String coordinates,
String mapProjection,
String postalAddress,
String timeZone) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "setLocationAsFixedPhysical";
final String locationGUIDParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, locationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}/classify-as-fixed-location";
FixedLocationRequestBody requestBody = new FixedLocationRequestBody();
requestBody.setCoordinates(coordinates);
requestBody.setMapProjection(mapProjection);
requestBody.setPostalAddress(postalAddress);
requestBody.setTimeZone(timeZone);
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
requestBody,
serverName,
userId,
locationGUID);
}
/**
* Remove the fixed physical location designation from the location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to unclassify
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void clearLocationAsFixedPhysical(String userId,
String locationGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "clearLocationAsFixedPhysical";
final String locationGUIDParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, locationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/classify-as-fixed-location/delete";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
locationGUID);
}
/**
* Classify the location to indicate that it represents a secure location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to classify
* @param description description of security at the site
* @param level level of security
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void setLocationAsSecure(String userId,
String locationGUID,
String description,
String level) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "setLocationAsSecure";
final String locationGUIDParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, locationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/classify-as-secure-location";
SecureLocationRequestBody requestBody = new SecureLocationRequestBody();
requestBody.setDescription(description);
requestBody.setLevel(level);
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
requestBody,
serverName,
userId,
locationGUID);
}
/**
* Remove the secure location designation from the location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to unclassify
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void clearLocationAsSecure(String userId,
String locationGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "clearLocationAsSecure";
final String locationGUIDParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, locationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/classify-as-secure-location/delete";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
locationGUID);
}
/**
* Classify the location to indicate that it represents a digital/cyber location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to classify
* @param networkAddress position of the location
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void setLocationAsDigital(String userId,
String locationGUID,
String networkAddress) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "setLocationAsDigital";
final String locationGUIDParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, locationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/classify-as-digital-location";
DigitalLocationRequestBody requestBody = new DigitalLocationRequestBody();
requestBody.setNetworkAddress(networkAddress);
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
requestBody,
serverName,
userId,
locationGUID);
}
/**
* Remove the digital/cyber location designation from the location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to unclassify
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void clearLocationAsDigital(String userId,
String locationGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "clearLocationAsDigital";
final String locationGUIDParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, locationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/classify-as-digital-location/delete";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
locationGUID);
}
/**
* Remove the metadata element representing a location.
*
* @param userId calling user
* @param locationGUID unique identifier of the metadata element to remove
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void removeLocation(String userId,
String locationGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "removeLocation";
final String guidParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, guidParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}/delete";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
locationGUID);
}
/**
* Create a parent-child relationship between two locations.
*
* @param userId calling user
* @param parentLocationGUID unique identifier of the location that is the broader location
* @param childLocationGUID unique identifier of the location that is the smaller, nested location
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void setupNestedLocation(String userId,
String parentLocationGUID,
String childLocationGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "setupNestedLocation";
final String parentLocationGUIDParameter = "parentLocationGUID";
final String childLocationGUIDParameter = "childLocationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(parentLocationGUID, parentLocationGUIDParameter, methodName);
invalidParameterHandler.validateGUID(childLocationGUID, childLocationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}/has-nested-location/{3}";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
parentLocationGUID,
childLocationGUID);
}
/**
* Remove a parent-child relationship between two locations.
*
* @param userId calling user
* @param parentLocationGUID unique identifier of the location that is the broader location
* @param childLocationGUID unique identifier of the location that is the smaller, nested location
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void clearNestedLocation(String userId,
String parentLocationGUID,
String childLocationGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "clearNestedLocation";
final String parentLocationGUIDParameter = "parentLocationGUID";
final String childLocationGUIDParameter = "childLocationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(parentLocationGUID, parentLocationGUIDParameter, methodName);
invalidParameterHandler.validateGUID(childLocationGUID, childLocationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}/has-nested-location/{3}/delete";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
parentLocationGUID,
childLocationGUID);
}
/**
* Create a peer-to-peer relationship between two locations.
*
* @param userId calling user
* @param locationOneGUID unique identifier of the first location
* @param locationTwoGUID unique identifier of the second location
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void setupAdjacentLocation(String userId,
String locationOneGUID,
String locationTwoGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "setupAdjacentLocation";
final String locationOneGUIDParameter = "locationOneGUID";
final String locationTwoGUIDParameter = "locationTwoGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationOneGUID, locationOneGUIDParameter, methodName);
invalidParameterHandler.validateGUID(locationTwoGUID, locationTwoGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}/linked-to-peer-location/{3}";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
locationOneGUID,
locationTwoGUID);
}
/**
* Remove a peer-to-peer relationship between two locations.
*
* @param userId calling user
* @param locationOneGUID unique identifier of the first location
* @param locationTwoGUID unique identifier of the second location
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public void clearAdjacentLocation(String userId,
String locationOneGUID,
String locationTwoGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "clearAdjacentLocation";
final String locationOneGUIDParameter = "locationOneGUID";
final String locationTwoGUIDParameter = "locationTwoGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationOneGUID, locationOneGUIDParameter, methodName);
invalidParameterHandler.validateGUID(locationTwoGUID, locationTwoGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}/linked-to-peer-location/{3}/delete";
restClient.callVoidPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
nullRequestBody,
serverName,
userId,
locationOneGUID,
locationTwoGUID);
}
/**
* Retrieve the list of location metadata elements that contain the search string.
* The search string is treated as a regular expression.
*
* @param userId calling user
* @param searchString string to find in the properties
* @param startFrom paging start point
* @param pageSize maximum results that can be returned
*
* @return list of matching metadata elements
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public List findLocations(String userId,
String searchString,
int startFrom,
int pageSize) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "findLocations";
final String parameterName = "searchString";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateSearchString(searchString, parameterName, methodName);
invalidParameterHandler.validatePaging(startFrom, pageSize, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/by-search-string" +
"?startFrom={2}&pageSize={3}";
SearchStringRequestBody requestBody = new SearchStringRequestBody();
requestBody.setSearchString(searchString);
requestBody.setSearchStringParameterName(parameterName);
LocationsResponse restResult = restClient.callLocationsPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
requestBody,
serverName,
userId,
startFrom,
pageSize);
return restResult.getElementList();
}
/**
* Retrieve the list of location metadata elements with a matching qualified or display name.
* There are no wildcards supported on this request.
*
* @param userId calling user
* @param name name to search for
* @param startFrom paging start point
* @param pageSize maximum results that can be returned
*
* @return list of matching metadata elements
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public List getLocationsByName(String userId,
String name,
int startFrom,
int pageSize) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "getLocationsByName";
final String nameParameter = "name";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateName(name, nameParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/by-name?startFrom={2}&pageSize={3}";
NameRequestBody requestBody = new NameRequestBody();
requestBody.setName(name);
requestBody.setNamePropertyName(nameParameter);
LocationsResponse restResult = restClient.callLocationsPostRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
requestBody,
serverName,
userId,
startFrom,
pageSize);
return restResult.getElementList();
}
/**
* Retrieve the location metadata element with the supplied unique identifier.
*
* @param userId calling user
* @param locationGUID unique identifier of the requested metadata element
*
* @return matching metadata element
*
* @throws InvalidParameterException one of the parameters is invalid
* @throws UserNotAuthorizedException the user is not authorized to issue this request
* @throws PropertyServerException there is a problem reported in the open metadata server(s)
*/
@Override
public LocationElement getLocationByGUID(String userId,
String locationGUID) throws InvalidParameterException,
UserNotAuthorizedException,
PropertyServerException
{
final String methodName = "getLocationByGUID";
final String locationGUIDParameter = "locationGUID";
invalidParameterHandler.validateUserId(userId, methodName);
invalidParameterHandler.validateGUID(locationGUID, locationGUIDParameter, methodName);
final String urlTemplate = "/servers/{0}/open-metadata/access-services/digital-architecture/users/{1}/locations/{2}";
LocationResponse restResult = restClient.callLocationGetRESTCall(methodName,
serverPlatformURLRoot + urlTemplate,
serverName,
userId,
locationGUID);
return restResult.getElement();
}
}