content: /**
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   * <p>
   * http://www.apache.org/licenses/LICENSE-2.0
   * <p>
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.atlas.web.rest;
  
  import org.apache.atlas.AtlasClient;
  import org.apache.atlas.AtlasConfiguration;
  import org.apache.atlas.AtlasErrorCode;
  import org.apache.atlas.RequestContext;
  import org.apache.atlas.SortOrder;
  import org.apache.atlas.annotation.Timed;
  import org.apache.atlas.authorize.AtlasAuthorizationUtils;
  import org.apache.atlas.discovery.AtlasDiscoveryService;
  import org.apache.atlas.discovery.EntityDiscoveryService;
  import org.apache.atlas.exception.AtlasBaseException;
  import org.apache.atlas.model.discovery.AtlasQuickSearchResult;
  import org.apache.atlas.model.discovery.AtlasSearchResult;
  import org.apache.atlas.model.discovery.AtlasSearchResultDownloadStatus;
  import org.apache.atlas.model.discovery.AtlasSuggestionsResult;
  import org.apache.atlas.model.discovery.QuickSearchParameters;
  import org.apache.atlas.model.discovery.RelationshipSearchParameters;
  import org.apache.atlas.model.discovery.SearchParameters;
  import org.apache.atlas.model.discovery.SearchParameters.FilterCriteria;
  import org.apache.atlas.model.profile.AtlasUserSavedSearch;
  import org.apache.atlas.repository.Constants;
  import org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask;
  import org.apache.atlas.type.AtlasEntityType;
  import org.apache.atlas.type.AtlasStructType;
  import org.apache.atlas.type.AtlasTypeRegistry;
  import org.apache.atlas.utils.AtlasJson;
  import org.apache.atlas.utils.AtlasPerfTracer;
  import org.apache.atlas.web.util.Servlets;
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.configuration.Configuration;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.springframework.stereotype.Service;
  
  import javax.inject.Inject;
  import javax.inject.Singleton;
  import javax.servlet.http.HttpServletRequest;
  import javax.ws.rs.Consumes;
  import javax.ws.rs.DELETE;
  import javax.ws.rs.GET;
  import javax.ws.rs.POST;
  import javax.ws.rs.PUT;
  import javax.ws.rs.Path;
  import javax.ws.rs.PathParam;
  import javax.ws.rs.Produces;
  import javax.ws.rs.QueryParam;
  import javax.ws.rs.core.Context;
  import javax.ws.rs.core.MediaType;
  import javax.ws.rs.core.Response;
  
  import java.io.File;
  import java.io.IOException;
  import java.time.LocalDateTime;
  import java.time.format.DateTimeFormatter;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import static org.apache.atlas.model.discovery.AtlasSearchResult.AtlasQueryType.BASIC;
  import static org.apache.atlas.model.discovery.AtlasSearchResult.AtlasQueryType.DSL;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.ATTRIBUTE_LABEL_MAP_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.CLASSIFICATION_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.CSV_FILE_EXTENSION;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.CSV_FILE_NAME_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.LIMIT_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.OFFSET_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.QUERY_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.SEARCH_PARAMETERS_JSON_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.SEARCH_TYPE_KEY;
  import static org.apache.atlas.repository.store.graph.v2.tasks.searchdownload.SearchResultDownloadTask.TYPE_NAME_KEY;
  
  /**
   * REST interface for data discovery using dsl or full text search
   */
  @Path("v2/search")
  @Singleton
  @Service
  @Consumes({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
  @Produces({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
  public class DiscoveryREST {
      private static final Logger PERF_LOG = AtlasPerfTracer.getPerfLogger("rest.DiscoveryREST");
  
      private final int                    maxFullTextQueryLength;
      private final int                    maxDslQueryLength;
      private final AtlasTypeRegistry     typeRegistry;
      private final AtlasDiscoveryService discoveryService;
  
      @Context
      private HttpServletRequest httpServletRequest;
  
      @Inject
      public DiscoveryREST(AtlasTypeRegistry typeRegistry, AtlasDiscoveryService discoveryService, Configuration configuration) {
          this.typeRegistry           = typeRegistry;
          this.discoveryService       = discoveryService;
          this.maxFullTextQueryLength = configuration.getInt(Constants.MAX_FULLTEXT_QUERY_STR_LENGTH, 4096);
          this.maxDslQueryLength      = configuration.getInt(Constants.MAX_DSL_QUERY_STR_LENGTH, 4096);
      }
  
      /**
       * Retrieve data for the specified DSL
       *
       * @param query DSL query
       * @param typeName limit the result to only entities of specified type or its sub-types
       * @param classification limit the result to only entities tagged with the given classification or or its sub-types
       * @param limit limit the result set to only include the specified number of entries
       * @param offset start offset of the result set (useful for pagination)
       * @return Search results
       * @throws AtlasBaseException
       * @HTTP 200 On successful DSL execution with some results, might return an empty list if execution succeeded
       * without any results
       * @HTTP 400 Invalid DSL or query parameters
       */
      @GET
      @Path("/dsl")
      @Timed
      public AtlasSearchResult searchUsingDSL(@QueryParam("query") String query,
              @QueryParam("typeName") String typeName,
              @QueryParam("classification") String classification,
              @QueryParam("limit") int limit,
              @QueryParam("offset") int offset) throws AtlasBaseException {
          validateDSLSearchParameters(query, typeName, classification);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.searchUsingDSL(" + query + "," + typeName + "," + classification + "," + limit + "," + offset + ")");
              }
  
              String queryStr = discoveryService.getDslQueryUsingTypeNameClassification(query, typeName, classification);
  
              return discoveryService.searchUsingDslQuery(queryStr, limit, offset);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * @param parameterMap
       * @throws AtlasBaseException
       */
      @POST
      @Timed
      @Path("dsl/download/create_file")
      public void dslSearchCreateFile(Map<String, Object> parameterMap) throws AtlasBaseException {
          SearchParameters parameters = AtlasJson.fromLinkedHashMap(parameterMap.get("searchParameters"), SearchParameters.class);
  
          validateDSLSearchParameters(parameters.getQuery(), parameters.getTypeName(), parameters.getClassification());
  
          Map<String, Object> taskParams = populateTaskParams(parameters.getQuery(), parameters.getTypeName(), parameters.getClassification(), parameters.getLimit(), parameters.getOffset());
  
          discoveryService.createAndQueueSearchResultDownloadTask(taskParams);
      }
  
      /**
       * Retrieve data for the specified fulltext query
       *
       * @param query Fulltext query
       * @param limit limit the result set to only include the specified number of entries
       * @param offset start offset of the result set (useful for pagination)
       * @return Search results
       * @throws AtlasBaseException
       * @HTTP 200 On successful FullText lookup with some results, might return an empty list if execution succeeded
       * without any results
       * @HTTP 400 Invalid fulltext or query parameters
       */
      @GET
      @Path("/fulltext")
      @Timed
      public AtlasSearchResult searchUsingFullText(@QueryParam("query") String query, @QueryParam("excludeDeletedEntities") boolean excludeDeletedEntities, @QueryParam("limit") int limit, @QueryParam("offset") int offset) throws AtlasBaseException {
          // Validate FullText query for max allowed length
          if (StringUtils.isNotEmpty(query) && query.length() > maxFullTextQueryLength) {
              throw new AtlasBaseException(AtlasErrorCode.INVALID_QUERY_LENGTH, Constants.MAX_FULLTEXT_QUERY_STR_LENGTH);
          }
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.searchUsingFullText(" + query + "," + limit + "," + offset + ")");
              }
  
              return discoveryService.searchUsingFullTextQuery(query, excludeDeletedEntities, limit, offset);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Retrieve data for the specified fulltext query
       *
       * @param query Fulltext query
       * @param typeName limit the result to only entities of specified type or its sub-types
       * @param classification limit the result to only entities tagged with the given classification or or its sub-types
       * @param limit limit the result set to only include the specified number of entries
       * @param offset start offset of the result set (useful for pagination)
       * @return Search results
       * @throws AtlasBaseException
       * @HTTP 200 On successful FullText lookup with some results, might return an empty list if execution succeeded
       * without any results
       * @HTTP 400 Invalid fulltext or query parameters
       */
      @GET
      @Path("/basic")
      @Timed
      public AtlasSearchResult searchUsingBasic(@QueryParam("query") String query,
              @QueryParam("typeName") String typeName,
              @QueryParam("classification") String classification,
              @QueryParam("sortBy") String sortByAttribute,
              @QueryParam("sortOrder") SortOrder sortOrder,
              @QueryParam("excludeDeletedEntities") boolean excludeDeletedEntities,
              @QueryParam("limit") int limit,
              @QueryParam("offset") int offset,
              @QueryParam("marker") String marker) throws AtlasBaseException {
          Servlets.validateQueryParamLength("typeName", typeName);
          Servlets.validateQueryParamLength("classification", classification);
          Servlets.validateQueryParamLength("sortBy", sortByAttribute);
  
          if (StringUtils.isNotEmpty(query) && query.length() > maxFullTextQueryLength) {
              throw new AtlasBaseException(AtlasErrorCode.INVALID_QUERY_LENGTH, Constants.MAX_FULLTEXT_QUERY_STR_LENGTH);
          }
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.searchUsingBasic(" + query + "," + typeName + "," + classification + "," + limit + "," + offset + ")");
              }
  
              SearchParameters searchParameters = new SearchParameters();
              searchParameters.setTypeName(typeName);
              searchParameters.setClassification(classification);
              searchParameters.setQuery(query);
              searchParameters.setExcludeDeletedEntities(excludeDeletedEntities);
              searchParameters.setLimit(limit);
              searchParameters.setOffset(offset);
              searchParameters.setMarker(marker);
              searchParameters.setSortBy(sortByAttribute);
              searchParameters.setSortOrder(sortOrder);
  
              return discoveryService.searchWithParameters(searchParameters);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Retrieve data for the specified attribute search query
       *
       * @param attrName Attribute name
       * @param attrValuePrefix Attibute value to search on
       * @param typeName limit the result to only entities of specified type or its sub-types
       * @param limit limit the result set to only include the specified number of entries
       * @param offset start offset of the result set (useful for pagination)
       * @return Search results
       * @throws AtlasBaseException
       * @HTTP 200 On successful FullText lookup with some results, might return an empty list if execution succeeded
       * without any results
       * @HTTP 400 Invalid wildcard or query parameters
       */
      @GET
      @Path("/attribute")
      @Timed
      public AtlasSearchResult searchUsingAttribute(@QueryParam("attrName") String attrName,
              @QueryParam("attrValuePrefix") String attrValuePrefix,
              @QueryParam("typeName") String typeName,
              @QueryParam("limit") int limit,
              @QueryParam("offset") int offset) throws AtlasBaseException {
          Servlets.validateQueryParamLength("attrName", attrName);
          Servlets.validateQueryParamLength("attrValuePrefix", attrValuePrefix);
          Servlets.validateQueryParamLength("typeName", typeName);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.searchUsingAttribute(" + attrName + "," + attrValuePrefix + "," + typeName + "," + limit + "," + offset + ")");
              }
  
              if (StringUtils.isEmpty(attrName) && StringUtils.isEmpty(attrValuePrefix)) {
                  throw new AtlasBaseException(AtlasErrorCode.INVALID_PARAMETERS, String.format("attrName : %s, attrValue: %s for attribute search.", attrName, attrValuePrefix));
              }
  
              if (StringUtils.isEmpty(attrName)) {
                  AtlasEntityType entityType = typeRegistry.getEntityTypeByName(typeName);
  
                  if (entityType != null) {
                      String[] defaultAttrNames = new String[] {AtlasClient.QUALIFIED_NAME, AtlasClient.NAME};
  
                      for (String defaultAttrName : defaultAttrNames) {
                          AtlasStructType.AtlasAttribute attribute = entityType.getAttribute(defaultAttrName);
  
                          if (attribute != null) {
                              attrName = defaultAttrName;
  
                              break;
                          }
                      }
                  }
  
                  if (StringUtils.isEmpty(attrName)) {
                      attrName = AtlasClient.QUALIFIED_NAME;
                  }
              }
  
              SearchParameters searchParams = new SearchParameters();
              FilterCriteria   attrFilter   = new FilterCriteria();
  
              attrFilter.setAttributeName(StringUtils.isEmpty(attrName) ? AtlasClient.QUALIFIED_NAME : attrName);
              attrFilter.setOperator(SearchParameters.Operator.STARTS_WITH);
              attrFilter.setAttributeValue(attrValuePrefix);
  
              searchParams.setTypeName(typeName);
              searchParams.setEntityFilters(attrFilter);
              searchParams.setOffset(offset);
              searchParams.setLimit(limit);
  
              return searchWithParameters(searchParams);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Attribute based search for entities satisfying the search parameters
       *
       * @param parameters Search parameters
       * @return Atlas search result
       * @throws AtlasBaseException
       * @HTTP 200 On successful search
       * @HTTP 400 Tag/Entity doesn't exist or Tag/entity filter is present without tag/type name
       */
      @Path("basic")
      @POST
      @Timed
      public AtlasSearchResult searchWithParameters(SearchParameters parameters) throws AtlasBaseException {
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.searchWithParameters(" + parameters + ")");
              }
  
              validateBasicSearchParameters(parameters);
  
              return discoveryService.searchWithParameters(parameters);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * @param parameterMap
       * @throws AtlasBaseException
       */
      @POST
      @Timed
      @Path("basic/download/create_file")
      public void basicSearchCreateFile(Map<String, Object> parameterMap) throws AtlasBaseException {
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.basicSearchCreateFile(" + parameterMap + ")");
              }
  
              Map<String, String> attributeLabelMap = (Map<String, String>) parameterMap.get("attributeLabelMap");
              SearchParameters    parameters        = AtlasJson.fromLinkedHashMap(parameterMap.get("searchParameters"), SearchParameters.class);
  
              validateBasicSearchParameters(parameters);
  
              Map<String, Object> taskParams = populateTaskParams(parameters, attributeLabelMap);
  
              discoveryService.createAndQueueSearchResultDownloadTask(taskParams);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      @GET
      @Timed
      @Path("download/status")
      public AtlasSearchResultDownloadStatus getSearchResultDownloadStatus() throws IOException {
          return discoveryService.getSearchResultDownloadStatus();
      }
  
      /**
       * @param fileName
       * @return
       */
      @GET
      @Timed
      @Path("download/{filename}")
      @Produces(MediaType.APPLICATION_OCTET_STREAM)
      public Response downloadSearchResultFile(@PathParam("filename") String fileName) {
          File dir     = new File(SearchResultDownloadTask.DOWNLOAD_DIR_PATH, RequestContext.getCurrentUser());
          File csvFile = new File(dir, fileName);
  
          if (!csvFile.exists()) {
              return Response.noContent().build();
          }
  
          Response.ResponseBuilder response = Response.ok(csvFile);
  
          response.header("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
  
          return response.build();
      }
  
      /**
       * Relationship search to search for relations(edges)
       *
       * @param parameters RelationshipSearchParameters
       * @return Atlas search result
       * @throws AtlasBaseException
       * @HTTP 200 On successful search
       */
      @Path("relations")
      @POST
      @Timed
      public AtlasSearchResult relationSearch(RelationshipSearchParameters parameters) throws AtlasBaseException {
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.relationSearch(" + parameters + ")");
              }
  
              if (parameters.getLimit() < 0 || parameters.getOffset() < 0) {
                  throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "Limit/offset should be non-negative");
              }
  
              if (StringUtils.isEmpty(parameters.getRelationshipName()) && !isEmpty(parameters.getRelationshipFilters())) {
                  throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "RelationshipFilters specified without Type name");
              }
  
              if (!AtlasConfiguration.RELATIONSHIP_SEARCH_ENABLED.getBoolean()) {
                  throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "Relationship search is currently disabled, set property " + AtlasConfiguration.RELATIONSHIP_SEARCH_ENABLED.getPropertyName() + " = true to enable");
              }
  
              return discoveryService.searchRelationsWithParameters(parameters);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Relationship search to search for relations(edges)
       *
       * @param relationshipName AtlasRelationshipType name
       * @param sortByAttribute sort the result using this attribute name, default value is 'name'
       * @param sortOrder sorting order
       * @param limit limit the result set to only include the specified number of entries
       * @param offset start offset of the result set (useful for pagination)
       * @return Atlas search result
       * @throws AtlasBaseException
       * @HTTP 200 On successful search
       */
  
      @Path("/relations")
      @GET
      @Timed
      public AtlasSearchResult relationSearch(@QueryParam("relationshipName") String relationshipName,
              @QueryParam("offset") int offset,
              @QueryParam("limit") int limit,
              @QueryParam("sortBy") String sortByAttribute,
              @QueryParam("sortOrder") SortOrder sortOrder,
              @QueryParam("marker") String marker) throws AtlasBaseException {
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.relationSearch(" + relationshipName + ", " + sortByAttribute + ", " + sortOrder + ", " + limit + ", " + offset + ", " + marker + ")");
              }
  
              if (!AtlasConfiguration.RELATIONSHIP_SEARCH_ENABLED.getBoolean()) {
                  throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "Relationship search is currently disabled, set property " + AtlasConfiguration.RELATIONSHIP_SEARCH_ENABLED.getPropertyName() + " = true to enable");
              }
  
              RelationshipSearchParameters parameters = new RelationshipSearchParameters();
  
              parameters.setRelationshipName(relationshipName);
              parameters.setSortBy(sortByAttribute);
              parameters.setSortOrder(sortOrder);
              parameters.setLimit(limit);
              parameters.setOffset(offset);
              parameters.setMarker(marker);
  
              return discoveryService.searchRelationsWithParameters(parameters);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Relationship search to search for related entities satisfying the search parameters
       *
       * @param guid Attribute name
       * @param relation relationName
       * @param attributes set of attributes in search result.
       * @param sortByAttribute sort the result using this attribute name, default value is 'name'
       * @param sortOrder sorting order
       * @param limit limit the result set to only include the specified number of entries
       * @param offset start offset of the result set (useful for pagination)
       * @return Atlas search result
       * @throws AtlasBaseException
       * @HTTP 200 On successful search
       * @HTTP 400 guid is not a valid entity type or attributeName is not a valid relationship attribute
       */
      @GET
      @Path("relationship")
      @Timed
      public AtlasSearchResult searchRelatedEntities(@QueryParam("guid") String guid,
              @QueryParam("relation") String relation,
              @QueryParam("attributes") Set<String> attributes,
              @QueryParam("sortBy") String sortByAttribute,
              @QueryParam("sortOrder") SortOrder sortOrder,
              @QueryParam("excludeDeletedEntities") boolean excludeDeletedEntities,
              @QueryParam("includeClassificationAttributes") boolean includeClassificationAttributes,
              @QueryParam("getApproximateCount") boolean getApproximateCount,
              @QueryParam("limit") int limit,
              @QueryParam("offset") int offset) throws AtlasBaseException {
          Servlets.validateQueryParamLength("guid", guid);
          Servlets.validateQueryParamLength("relation", relation);
          Servlets.validateQueryParamLength("sortBy", sortByAttribute);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.relatedEntitiesSearch(" + guid + ", " + relation + ", " + sortByAttribute + ", " + sortOrder + ", " + excludeDeletedEntities + ", " + getApproximateCount + ", " + limit + ", " + offset + ")");
              }
  
              SearchParameters parameters = new SearchParameters();
  
              parameters.setAttributes(attributes);
              parameters.setSortBy(sortByAttribute);
              parameters.setSortOrder(sortOrder);
              parameters.setExcludeDeletedEntities(excludeDeletedEntities);
              parameters.setLimit(limit);
              parameters.setOffset(offset);
              parameters.setIncludeClassificationAttributes(includeClassificationAttributes);
  
              return discoveryService.searchRelatedEntities(guid, relation, getApproximateCount, parameters);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * @param savedSearch
       * @return the saved search-object
       * @throws AtlasBaseException
       */
      @POST
      @Path("saved")
      @Timed
      public AtlasUserSavedSearch addSavedSearch(AtlasUserSavedSearch savedSearch) throws AtlasBaseException {
          validateUserSavedSearch(savedSearch);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.addSavedSearch(userName=" + savedSearch.getOwnerName() + ", name=" + savedSearch.getName() + ", searchType=" + savedSearch.getSearchType() + ")");
              }
  
              return discoveryService.addSavedSearch(AtlasAuthorizationUtils.getCurrentUserName(), savedSearch);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /***
       *
       * @param savedSearch
       * @return the updated search-object
       * @throws AtlasBaseException
       */
      @PUT
      @Path("saved")
      @Timed
      public AtlasUserSavedSearch updateSavedSearch(AtlasUserSavedSearch savedSearch) throws AtlasBaseException {
          validateUserSavedSearch(savedSearch);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.updateSavedSearch(userName=" + savedSearch.getOwnerName() + ", name=" + savedSearch.getName() + ", searchType=" + savedSearch.getSearchType() + ")");
              }
  
              return discoveryService.updateSavedSearch(AtlasAuthorizationUtils.getCurrentUserName(), savedSearch);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * @param searchName Name of the saved search
       * @param userName User for whom the search is retrieved
       * @return
       * @throws AtlasBaseException
       */
      @GET
      @Path("saved/{name}")
      @Timed
      public AtlasUserSavedSearch getSavedSearch(@PathParam("name") String searchName, @QueryParam("user") String userName) throws AtlasBaseException {
          Servlets.validateQueryParamLength("name", searchName);
          Servlets.validateQueryParamLength("user", userName);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.getSavedSearch(userName=" + userName + ", name=" + searchName + ")");
              }
  
              return discoveryService.getSavedSearchByName(AtlasAuthorizationUtils.getCurrentUserName(), userName, searchName);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * @param userName User for whom the search is retrieved
       * @return list of all saved searches for given user
       * @throws AtlasBaseException
       */
      @GET
      @Path("saved")
      @Timed
      public List<AtlasUserSavedSearch> getSavedSearches(@QueryParam("user") String userName) throws AtlasBaseException {
          Servlets.validateQueryParamLength("user", userName);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.getSavedSearches(userName=" + userName + ")");
              }
  
              return discoveryService.getSavedSearches(AtlasAuthorizationUtils.getCurrentUserName(), userName);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * @param guid Name of the saved search
       */
      @DELETE
      @Path("saved/{guid}")
      @Timed
      public void deleteSavedSearch(@PathParam("guid") String guid) throws AtlasBaseException {
          Servlets.validateQueryParamLength("guid", guid);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.deleteSavedSearch(guid=" + guid + ")");
              }
  
              discoveryService.deleteSavedSearch(AtlasAuthorizationUtils.getCurrentUserName(), guid);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Attribute based search for entities satisfying the search parameters
       *
       * @param searchName name of saved-search
       * @param userName saved-search owner
       * @return Atlas search result
       * @throws AtlasBaseException
       */
      @Path("saved/execute/{name}")
      @GET
      @Timed
      public AtlasSearchResult executeSavedSearchByName(@PathParam("name") String searchName, @QueryParam("user") String userName) throws AtlasBaseException {
          Servlets.validateQueryParamLength("name", searchName);
          Servlets.validateQueryParamLength("user", userName);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.executeSavedSearchByName(userName=" + userName + ", " + "name=" + searchName + ")");
              }
  
              AtlasUserSavedSearch savedSearch = discoveryService.getSavedSearchByName(AtlasAuthorizationUtils.getCurrentUserName(), userName, searchName);
  
              return executeSavedSearch(savedSearch);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Attribute based search for entities satisfying the search parameters
       *
       * @param searchGuid Guid identifying saved search
       * @return Atlas search result
       * @throws AtlasBaseException
       */
      @Path("saved/execute/guid/{guid}")
      @GET
      @Timed
      public AtlasSearchResult executeSavedSearchByGuid(@PathParam("guid") String searchGuid) throws AtlasBaseException {
          Servlets.validateQueryParamLength("guid", searchGuid);
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.executeSavedSearchByGuid(" + searchGuid + ")");
              }
  
              AtlasUserSavedSearch savedSearch = discoveryService.getSavedSearchByGuid(AtlasAuthorizationUtils.getCurrentUserName(), searchGuid);
  
              return executeSavedSearch(savedSearch);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Attribute based search for entities satisfying the search parameters
       *
       * @return Atlas search result
       * @throws AtlasBaseException
       * @HTTP 200 On successful search
       * @HTTP 400 Tag/Entity doesn't exist or Tag/entity filter is present without tag/type name
       */
      @Path("/quick")
      @GET
      @Timed
      public AtlasQuickSearchResult quickSearch(@QueryParam("query") String query,
              @QueryParam("typeName") String typeName,
              @QueryParam("excludeDeletedEntities") boolean excludeDeletedEntities,
              @QueryParam("offset") int offset,
              @QueryParam("limit") int limit,
              @QueryParam("sortBy") String sortByAttribute,
              @QueryParam("sortOrder") SortOrder sortOrder) throws AtlasBaseException {
          if (StringUtils.isNotEmpty(query) && query.length() > maxFullTextQueryLength) {
              throw new AtlasBaseException(AtlasErrorCode.INVALID_QUERY_LENGTH, Constants.MAX_FULLTEXT_QUERY_STR_LENGTH);
          }
  
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.quick(" + query + "," + "excludeDeletedEntities:" + excludeDeletedEntities + "," + limit + "," + offset + ")");
              }
  
              QuickSearchParameters quickSearchParameters = new QuickSearchParameters(query, typeName,
                      null,  // entityFilters
                      false, // includeSubTypes
                      excludeDeletedEntities,
                      offset,
                      limit,
                      null, // attributes
                      sortByAttribute,
                      sortOrder);
  
              return discoveryService.quickSearch(quickSearchParameters);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      /**
       * Attribute based search for entities satisfying the search parameters
       *
       * @return Atlas search result
       * @throws AtlasBaseException
       * @HTTP 200 On successful search
       * @HTTP 400 Entity/attribute doesn't exist or entity filter is present without type name
       */
      @Path("/quick")
      @POST
      @Timed
      public AtlasQuickSearchResult quickSearch(QuickSearchParameters quickSearchParameters) throws AtlasBaseException {
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.searchWithParameters(" + quickSearchParameters + ")");
              }
  
              if (quickSearchParameters.getLimit() < 0 || quickSearchParameters.getOffset() < 0) {
                  throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "Limit/offset should be non-negative");
              }
  
              if (StringUtils.isEmpty(quickSearchParameters.getTypeName()) && !isEmpty(quickSearchParameters.getEntityFilters())) {
                  throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "EntityFilters specified without Type name");
              }
  
              if (StringUtils.isEmpty(quickSearchParameters.getTypeName()) && StringUtils.isEmpty(quickSearchParameters.getQuery())) {
                  throw new AtlasBaseException(AtlasErrorCode.INVALID_SEARCH_PARAMS);
              }
  
              if (StringUtils.isEmpty(quickSearchParameters.getTypeName()) && (StringUtils.isNotEmpty(quickSearchParameters.getSortBy()))) {
                  throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "SortBy specified without Type name");
              }
  
              validateSearchParameters(quickSearchParameters);
  
              return discoveryService.quickSearch(quickSearchParameters);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      @Path("suggestions")
      @GET
      @Timed
      public AtlasSuggestionsResult getSuggestions(@QueryParam("prefixString") String prefixString, @QueryParam("fieldName") String fieldName) {
          AtlasPerfTracer perf = null;
  
          try {
              if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                  perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "DiscoveryREST.getSuggestions(" + prefixString + "," + fieldName + ")");
              }
  
              return discoveryService.getSuggestions(prefixString, fieldName);
          } finally {
              AtlasPerfTracer.log(perf);
          }
      }
  
      private boolean isEmpty(SearchParameters.FilterCriteria filterCriteria) {
          return filterCriteria == null || (StringUtils.isEmpty(filterCriteria.getAttributeName()) && CollectionUtils.isEmpty(filterCriteria.getCriterion()));
      }
  
      private AtlasSearchResult executeSavedSearch(AtlasUserSavedSearch savedSearch) throws AtlasBaseException {
          SearchParameters sp = savedSearch.getSearchParameters();
  
          if (savedSearch.getSearchType() == AtlasUserSavedSearch.SavedSearchType.ADVANCED) {
              String dslQuery = discoveryService.getDslQueryUsingTypeNameClassification(sp.getQuery(), sp.getTypeName(), sp.getClassification());
  
              return discoveryService.searchUsingDslQuery(dslQuery, sp.getLimit(), sp.getOffset());
          } else {
              return discoveryService.searchWithParameters(sp);
          }
      }
  
      private void validateUserSavedSearch(AtlasUserSavedSearch savedSearch) throws AtlasBaseException {
          if (savedSearch != null) {
              Servlets.validateQueryParamLength("name", savedSearch.getName());
              Servlets.validateQueryParamLength("ownerName", savedSearch.getOwnerName());
              Servlets.validateQueryParamLength("guid", savedSearch.getGuid());
  
              validateSearchParameters(savedSearch.getSearchParameters());
          }
      }
  
      private void validateSearchParameters(SearchParameters parameters) throws AtlasBaseException {
          if (parameters != null) {
              Servlets.validateQueryParamLength("typeName", parameters.getTypeName());
              Servlets.validateQueryParamLength("classification", parameters.getClassification());
              Servlets.validateQueryParamLength("sortBy", parameters.getSortBy());
  
              if (StringUtils.isNotEmpty(parameters.getQuery()) && parameters.getQuery().length() > maxFullTextQueryLength) {
                  throw new AtlasBaseException(AtlasErrorCode.INVALID_QUERY_LENGTH, Constants.MAX_FULLTEXT_QUERY_STR_LENGTH);
              }
  
              validateEntityFilter(parameters);
          }
      }
  
      private void validateEntityFilter(SearchParameters parameters) throws AtlasBaseException {
          validateNestedCriteria(parameters.getEntityFilters());
          validateNestedCriteria(parameters.getTagFilters());
      }
  
      private void validateNestedCriteria(SearchParameters.FilterCriteria criteria) throws AtlasBaseException {
          if (criteria == null) {
              return; // Nothing to validate
          }
  
          boolean hasComposite = criteria.getCriterion() != null && !criteria.getCriterion().isEmpty();
          boolean hasLeaf = StringUtils.isNotEmpty(criteria.getAttributeName())
                  || criteria.getOperator() != null
                  || StringUtils.isNotEmpty(criteria.getAttributeValue());
  
          if (!hasComposite && !hasLeaf) {
              // It's an empty filter object — skip (backward compatibility)
              return;
          }
  
          if (hasComposite) {
              if (criteria.getCondition() == null || StringUtils.isEmpty(criteria.getCondition().toString())) {
                  throw new AtlasBaseException("Condition (AND/OR) must be specified when using multiple filters.");
              }
  
              for (FilterCriteria filterCriteria : criteria.getCriterion()) {
                  if (filterCriteria != null) {
                      validateNestedCriteria(filterCriteria); // Recursive check
                  }
              }
          }
  
          if (hasLeaf) {
              validateLeafFilterCriteria(criteria);
          }
      }
  
      private void validateLeafFilterCriteria(SearchParameters.FilterCriteria criteria) throws AtlasBaseException {
          if (criteria.getOperator() == null) {
              throw new AtlasBaseException(AtlasErrorCode.INVALID_OPERATOR, criteria.getAttributeName());
          }
  
          if (StringUtils.isBlank(criteria.getAttributeName())) {
              throw new AtlasBaseException(AtlasErrorCode.BLANK_NAME_ATTRIBUTE);
          }
  
          if (requiresValue(criteria.getOperator()) && StringUtils.isBlank(criteria.getAttributeValue())) {
              throw new AtlasBaseException(AtlasErrorCode.BLANK_VALUE_ATTRIBUTE);
          }
      }
  
      private boolean requiresValue(SearchParameters.Operator operator) {
          return operator != SearchParameters.Operator.IS_NULL
                  && operator != SearchParameters.Operator.NOT_NULL;
      }
  
      private void validateSearchParameters(QuickSearchParameters parameters) throws AtlasBaseException {
          if (parameters != null) {
              validateSearchParameters(EntityDiscoveryService.createSearchParameters(parameters));
          }
      }
  
      private void validateBasicSearchParameters(SearchParameters parameters) throws AtlasBaseException {
          if (parameters.getLimit() < 0 || parameters.getOffset() < 0) {
              throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "Limit/offset should be non-negative");
          }
  
          if (StringUtils.isEmpty(parameters.getTypeName()) && !isEmpty(parameters.getEntityFilters())) {
              throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "EntityFilters specified without Type name");
          }
  
          if (StringUtils.isEmpty(parameters.getClassification()) && !isEmpty(parameters.getTagFilters())) {
              throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "TagFilters specified without tag name");
          }
  
          if (StringUtils.isEmpty(parameters.getTypeName()) && StringUtils.isEmpty(parameters.getClassification()) && StringUtils.isEmpty(parameters.getQuery()) && StringUtils.isEmpty(parameters.getTermName())) {
              throw new AtlasBaseException(AtlasErrorCode.INVALID_SEARCH_PARAMS);
          }
  
          validateSearchParameters(parameters);
      }
  
      private void validateDSLSearchParameters(String query, String typeName, String classification) throws AtlasBaseException {
          Servlets.validateQueryParamLength("typeName", typeName);
          Servlets.validateQueryParamLength("classification", classification);
  
          if (StringUtils.isNotEmpty(query)) {
              if (query.length() > maxDslQueryLength) {
                  throw new AtlasBaseException(AtlasErrorCode.INVALID_QUERY_LENGTH, Constants.MAX_DSL_QUERY_STR_LENGTH);
              }
  
              Servlets.decodeQueryString(query);
          }
      }
  
      private Map<String, Object> populateTaskParams(SearchParameters parameters, Map<String, String> attributeLabelMap) {
          String searchParametersJson = AtlasJson.toJson(parameters);
          String attrLabelMapJson     = AtlasJson.toJson(attributeLabelMap);
  
          Map<String, Object> taskParams = new HashMap<>();
  
          taskParams.put(SEARCH_TYPE_KEY, BASIC);
          taskParams.put(SEARCH_PARAMETERS_JSON_KEY, searchParametersJson);
          taskParams.put(ATTRIBUTE_LABEL_MAP_KEY, attrLabelMapJson);
  
          String csvFileName = RequestContext.getCurrentUser() + "_" + BASIC + "_" + getDateTimeString() + CSV_FILE_EXTENSION;
  
          taskParams.put(CSV_FILE_NAME_KEY, csvFileName);
  
          return taskParams;
      }
  
      private Map<String, Object> populateTaskParams(String query, String typeName, String classification, int limit, int offset) {
          Map<String, Object> taskParams = new HashMap<>();
  
          taskParams.put(SEARCH_TYPE_KEY, DSL);
          taskParams.put(QUERY_KEY, query);
          taskParams.put(TYPE_NAME_KEY, typeName);
          taskParams.put(CLASSIFICATION_KEY, classification);
          taskParams.put(LIMIT_KEY, limit);
          taskParams.put(OFFSET_KEY, offset);
  
          String csvFileName = RequestContext.getCurrentUser() + "_" + DSL + "_" + getDateTimeString() + CSV_FILE_EXTENSION;
  
          taskParams.put(CSV_FILE_NAME_KEY, csvFileName);
  
          return taskParams;
      }
  
      private String getDateTimeString() {
          LocalDateTime     localDateTime = LocalDateTime.now();
          DateTimeFormatter formatter     = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss.SSS");
  
          return formatter.format(localDateTime);
      }
  }
  