import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Returns the identity id.
 *
 * @param identity the identity
 * @return the identity id
 * @throws Exception the exception
 */
public long getIdentityId(Identity identity) throws Exception {

  // Set up the "full text query"
  final List<Long> results = handler.getIdResults(null, null,
      Branch.ROOT, "identityCode:\""
          + QueryParserBase.escape(identity.getIdentityCode()) + "\"",
      null, identity.getClass(), null, new int[1], manager);

  if (results.isEmpty()) {
    return -1L;
  }

  if (results.size() > 1) {
    throw new Exception("Error: identity code returned more than one id: "
        + identity.getIdentityCode());
  }

  return results.get(0);
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@Override
public WorkflowConfig getWorkflowConfig(Project project, String type)
  throws Exception {
  Logger.getLogger(getClass())
      .debug("Workflow Service - get project workflow config "
          + project.getId() + ", " + type);
  final SearchHandler searchHandler = getSearchHandler(null);
  final int[] totalCt = new int[1];

  final List<WorkflowConfigJpa> results =
      searchHandler.getQueryResults(null, null, "",
          composeQuery(project, "") + " AND type:\""
              + QueryParserBase.escape(type) + "\"",
          "", WorkflowConfigJpa.class, null, totalCt, manager);

  if (results.size() == 0) {
    return null;
  } else if (results.size() == 1) {
    return results.get(0);
  } else {
    throw new Exception(
        "Unexpected number of workflow configs for project and type "
            + project.getId() + "," + type);
  }

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@SuppressWarnings({
    "rawtypes", "unchecked"
})
@Override
public SubsetMemberList findAtomSubsetMembers(String subsetId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs) throws Exception {
  Logger.getLogger(getClass())
      .debug("Content Service - find atom subset members " + subsetId + "/"
          + terminology + "/" + version + ", query=" + query);
  // Prepare the query string

  final StringBuilder finalQuery = new StringBuilder();
  finalQuery.append(query == null ? "" : query);
  if (subsetId != null && !subsetId.isEmpty()) {
    if (finalQuery.length() > 0) {
      finalQuery.append(" AND ");
    }
    finalQuery
        .append("subsetTerminologyId:" + QueryParserBase.escape(subsetId));
  }
  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  final SubsetMemberList list = new SubsetMemberListJpa();
  list.setObjects((List) searchHandler.getQueryResults(terminology, version,
      branch, finalQuery.toString(), "memberNameSort",
      AtomSubsetMemberJpa.class, pfs, totalCt, manager));
  list.setTotalCount(totalCt[0]);
  return list;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@SuppressWarnings({
    "unchecked", "rawtypes"
})
@Override
public SubsetMemberList findConceptSubsetMembers(String subsetId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs) throws Exception {
  Logger.getLogger(getClass())
      .debug("Content Service - find concept subset members " + subsetId + "/"
          + terminology + "/" + version + ", query=" + query);
  // Prepare the query string

  final StringBuilder finalQuery = new StringBuilder();
  finalQuery.append(query == null ? "" : query);
  if (subsetId != null && !subsetId.isEmpty()) {
    if (finalQuery.length() > 0) {
      finalQuery.append(" AND ");
    }
    finalQuery
        .append("subsetTerminologyId:" + QueryParserBase.escape(subsetId));
  }

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  final SubsetMemberList list = new SubsetMemberListJpa();
  list.setObjects((List) searchHandler.getQueryResults(terminology, version,
      branch, finalQuery.toString(), "memberNameSort",
      ConceptSubsetMemberJpa.class, pfs, totalCt, manager));
  list.setTotalCount(totalCt[0]);

  return list;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Find mappings for component helper.
 *
 * @param terminologyId the terminology id
 * @param terminology the terminology
 * @param version the version
 * @param branch the branch
 * @param query the query
 * @param pfs the pfs
 * @return the mapping list
 * @throws Exception the exception
 */
@SuppressWarnings({
    "unchecked", "rawtypes"
})
private MappingList findMappingsForComponentHelper(String terminologyId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs) throws Exception {

  if (terminologyId == null || terminologyId.isEmpty()) {
    throw new Exception("Terminology id is required");
  }

  final MappingList results = new MappingListJpa();

  // Prepare the query string
  final StringBuilder finalQuery = new StringBuilder();
  finalQuery.append(query == null ? "" : query);
  if (!finalQuery.toString().isEmpty()) {
    finalQuery.append(" AND ");
  }

  finalQuery.append("fromTerminologyId:"
      + QueryParserBase.escape(terminologyId) + " AND fromTerminology:"
      + terminology + " AND fromVersion:" + version);

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  // pass empty terminology/version because it's handled above
  results.setObjects((List) searchHandler.getQueryResults("", "", branch,
      finalQuery.toString(), "fromNameSort", MappingJpa.class, pfs, totalCt,
      manager));
  results.setTotalCount(totalCt[0]);

  for (final Mapping mapping : results.getObjects()) {
    getGraphResolutionHandler(terminology).resolve(mapping);
  }
  return results;

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Returns the query results.
 *
 * @param <T> the
 * @param query the query
 * @param clazz the clazz
 * @param pfs the pfs
 * @param totalCt the total ct
 * @return the query results
 * @throws Exception the exception
 */
// TODO This should no longer exist, use search handlers from RootServiceJpa
public <T> List<?> getQueryResults(final String query, final Class<T> clazz,
  final PfsParameter pfs, int[] totalCt) throws Exception {

  if (query == null || query.isEmpty()) {
    throw new Exception("Unexpected empty query.");
  }

  FullTextQuery fullTextQuery = null;
  try {
    fullTextQuery =
        IndexUtility.applyPfsToLuceneQuery(clazz, query, pfs, manager);
  } catch (ParseException e) {
    // If parse exception, try a literal query
    final StringBuilder escapedQuery = new StringBuilder();
    if (query != null && !query.isEmpty()) {
      escapedQuery.append(QueryParserBase.escape(query));
    }
    fullTextQuery = IndexUtility.applyPfsToLuceneQuery(clazz,
        escapedQuery.toString(), pfs, manager);
  }

  totalCt[0] = fullTextQuery.getResultSize();
  return fullTextQuery.getResultList();

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Compose clause.
 *
 * @param fieldName the field name
 * @param fieldValue the field value
 * @param escapeValue - whether the value can have characters that need to be
 *          escaped
 * @return the string
 * @throws Exception the exception
 */
public static String composeClause(String fieldName, String fieldValue,
  boolean escapeValue) throws Exception {

  if (!ConfigUtility.isEmpty(fieldValue)) {
    if (escapeValue) {
      return fieldName + ":\"" + QueryParserBase.escape(fieldValue) + "\"";
    } else {
      return fieldName + ":" + fieldValue;
    }
  } else {
    return "NOT " + fieldName + ":[* TO *]";
  }
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public void assertEscapedQueryEquals(String query, Analyzer a, String result)
  throws Exception {
  String escapedQuery = QueryParserBase.escape(query);
  if (!escapedQuery.equals(result)) {
    fail("Query /" + query + "/ yielded /" + escapedQuery
        + "/, expecting /" + result + "/");
  }
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public QueryParser getParser(Analyzer a, Extensions extensions)
    throws Exception {
  if (a == null)
    a = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true);
  QueryParser qp = extensions == null ? new ExtendableQueryParser(
      TEST_VERSION_CURRENT, getDefaultField(), a) : new ExtendableQueryParser(
      TEST_VERSION_CURRENT, getDefaultField(), a, extensions);
  qp.setDefaultOperator(QueryParserBase.OR_OPERATOR);
  return qp;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@Override
public void testDefaultOperator() throws Exception {
  SQPTestingConfig qp = (SQPTestingConfig)getParserConfig(new MockAnalyzer(random()));
  // make sure OR is the default:
  assertEquals(QueryParserBase.OR_OPERATOR, qp.getDefaultOperator());
  setDefaultOperatorAND(qp);
  assertEquals(QueryParserBase.AND_OPERATOR, qp.getDefaultOperator());
  setDefaultOperatorOR(qp);
  assertEquals(QueryParserBase.OR_OPERATOR, qp.getDefaultOperator());
  
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public CommonQueryParserConfiguration getParserConfig(Analyzer a, Analyzer mtAnalyzer)
    throws Exception {
  if (a == null) {
    a = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true);
  }
  if (mtAnalyzer == null) {
    mtAnalyzer = new MockAnalyzer(random(), MockTokenizer.KEYWORD, true);
  }

  SQPTestingConfig qp = new SQPTestingConfig(getDefaultField(), a, mtAnalyzer);
  qp.setDefaultOperator(QueryParserBase.OR_OPERATOR);
  qp.setAnalyzeRangeTerms(true);
  return qp;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public void assertEscapedQueryEquals(String query, Analyzer a, String result)
    throws Exception {
  String escapedQuery = QueryParserBase.escape(query);
  if (!escapedQuery.equals(result)) {
    fail("Query /" + query + "/ yielded /" + escapedQuery
        + "/, expecting /" + result + "/");
  }
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@Override
public Query parse(QualityQuery qq) throws ParseException {
  QueryParser qp = queryParser.get();
  if (qp==null) {
    qp = new QueryParser(Version.LUCENE_CURRENT, indexField, new StandardAnalyzer(Version.LUCENE_CURRENT));
    queryParser.set(qp);
  }
  BooleanQuery bq = new BooleanQuery();
  for (int i = 0; i < qqNames.length; i++)
    bq.add(qp.parse(QueryParserBase.escape(qq.getValue(qqNames[i]))), BooleanClause.Occur.SHOULD);
  
  return bq;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Find relationships for component helper.
 *
 * @param terminologyId the terminology id
 * @param terminology the terminology
 * @param version the version
 * @param branch the branch
 * @param query the query
 * @param inverseFlag the inverse flag
 * @param pfs the pfs
 * @param clazz the clazz
 * @return the relationship list
 * @throws Exception the exception
 */
@SuppressWarnings({
    "unchecked", "rawtypes"
})
private RelationshipList findRelationshipsForComponentHelper(
  String terminologyId, String terminology, String version, String branch,
  String query, boolean inverseFlag, PfsParameter pfs,
  Class<? extends Relationship> clazz) throws Exception {

  final RelationshipList results = new RelationshipListJpa();

  final List<String> clauses = new ArrayList<>();
  // Parts to combine
  // 1. query
  clauses.add(query);

  // escape special chars
  // 2. to/fromTerminologyId
  if (inverseFlag && !ConfigUtility.isEmpty(terminologyId)) {
    clauses.add("toTerminologyId:" + QueryParserBase.escape(terminologyId));
  }
  if (!inverseFlag && !ConfigUtility.isEmpty(terminologyId)) {
    clauses.add("fromTerminologyId:" + QueryParserBase.escape(terminologyId));
  }

  // 3. to/fromTerminology
  if (inverseFlag && !ConfigUtility.isEmpty(terminology)) {
    clauses.add("toTerminology:" + terminology);
  }
  if (!inverseFlag && !ConfigUtility.isEmpty(terminology)) {
    clauses.add("fromTerminology:" + terminology);
  }

  // r. to/fromVersion clause
  if (inverseFlag && !ConfigUtility.isEmpty(version)) {
    clauses.add("toVersion:" + version);
  }
  if (!inverseFlag && !ConfigUtility.isEmpty(version)) {
    clauses.add("fromVersion:" + version);
  }

  final String finalQuery = ConfigUtility.composeQuery("AND", clauses);

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  // pass empty terminology/version because it's handled above
  results.setObjects((List) searchHandler.getQueryResults("", "", branch,
      finalQuery, "toNameSort", clazz, pfs, totalCt, manager));
  results.setTotalCount(totalCt[0]);

  for (final Relationship<? extends ComponentInfo, ? extends ComponentInfo> rel : results
      .getObjects()) {
    getGraphResolutionHandler(terminology).resolve(rel);
  }
  return results;

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Find tree positions helper.
 *
 * @param terminologyId the terminology id
 * @param terminology the terminology
 * @param version the version
 * @param branch the branch
 * @param query the query
 * @param pfs the pfs
 * @param clazz the clazz
 * @return the tree position list
 * @throws Exception the exception
 */
@SuppressWarnings({
    "unchecked", "rawtypes"
})
private TreePositionList findTreePositionsHelper(String terminologyId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs, Class<? extends TreePosition> clazz) throws Exception {

  // Prepare the query string
  final StringBuilder finalQuery = new StringBuilder();

  // add the query, if not null and not empty
  finalQuery.append(query == null || query.isEmpty() ? "" : query);
  if (terminologyId != null) {
    if (finalQuery.length() > 0) {
      finalQuery.append(" AND ");
    }
    finalQuery
        .append("nodeTerminologyId:" + QueryParserBase.escape(terminologyId));
  }

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  final TreePositionList list = new TreePositionListJpa();
  list.setObjects((List) searchHandler.getQueryResults(terminology, version,
      branch, finalQuery.toString(), "nodeNameSort", clazz, pfs, totalCt,
      manager));
  list.setTotalCount(totalCt[0]);

  // If the list has <30 entries and all are roman numerals
  // and the sortField is "nodeTerminologyId" then use a roman numeral sort
  // This is a hack for roman numeral sorted top-level hierarchies
  if (list.size() < 30 && pfs != null && pfs.getSortField() != null
      && pfs.getSortField().equals("nodeTerminologyId")) {
    boolean nonRomanFound = false;
    for (final TreePosition treepos : list.getObjects()) {
      if (!ConfigUtility
          .isRomanNumeral(treepos.getNode().getTerminologyId())) {
        nonRomanFound = true;
        break;
      }
    }
    if (!nonRomanFound) {
      Collections.sort(list.getObjects(), new Comparator<TreePosition>() {
        @Override
        public int compare(TreePosition o1, TreePosition o2) {
          try {
            return ConfigUtility.toArabic(o1.getNode().getTerminologyId())
                - ConfigUtility.toArabic(o2.getNode().getTerminologyId());
          } catch (Exception e) {
            // just return zero, don't worry about handling the error
            e.printStackTrace();
            return 0;
          }
        }

      });
    }
  }
  return list;

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@POST
@Override
@Path("/config/import")
@Consumes(MediaType.MULTIPART_FORM_DATA)
@ApiOperation(value = "Import workflow config", notes = "Imports a workflow config", response = WorkflowConfigJpa.class)
public WorkflowConfig importWorkflowConfig(
  @ApiParam(value = "Form data header", required = true) @FormDataParam("file") FormDataContentDisposition contentDispositionHeader,
  @ApiParam(value = "Content of members file", required = true) @FormDataParam("file") InputStream in,
  @ApiParam(value = "Project id, e.g. 12345", required = true) @QueryParam("projectId") Long projectId,
  @ApiParam(value = "Authorization token, e.g. 'guest'", required = true) @HeaderParam("Authorization") String authToken)
  throws Exception {
  Logger.getLogger(getClass())
      .info("RESTful call (Workflow): /config/import?projectId=" + projectId);

  final WorkflowService workflowService = new WorkflowServiceJpa();
  try {
    final String userName =
        authorizeProject(workflowService, projectId, securityService,
            authToken, "adding a process config", UserRole.ADMINISTRATOR);
    workflowService.setLastModifiedBy(userName);
    // This should be atomic
    workflowService.setTransactionPerOperation(false);
    workflowService.beginTransaction();

    // Load project
    final Project project = workflowService.getProject(projectId);

    // Convert to a String
    final String json = IOUtils.toString(in, "UTF-8");

    // Convert to an object
    final WorkflowConfigJpa workflow =
        ConfigUtility.getGraphForJson(json, WorkflowConfigJpa.class);

    // Clean up the imported process
    workflow.setProject(project);
    // Verify that passed projectId matches ID of the processConfig's project
    verifyProject(workflow, projectId);

    // Save steps
    final List<WorkflowBinDefinition> binDefinitions =
        new ArrayList<>(workflow.getWorkflowBinDefinitions());

    // Prep workflow config
    workflow.setId(null);
    workflow.getWorkflowBinDefinitions().clear();
    final WorkflowConfigList list = workflowService.findWorkflowConfigs(
        projectId,
        "type:\"" + QueryParserBase.escape(workflow.getType()) + "\"", null);
    if (list.size() > 0) {
      workflow.setType(workflow.getType() + " - "
          + ConfigUtility.DATE_YYYYMMDDHHMMSS.format(new Date()));
    }
    final WorkflowConfig newWorkflowConfig =
        workflowService.addWorkflowConfig(workflow);

    // Add bin definitions
    for (final WorkflowBinDefinition binDefinition : binDefinitions) {
      binDefinition.setId(null);
      binDefinition.setWorkflowConfig(newWorkflowConfig);
      newWorkflowConfig.getWorkflowBinDefinitions()
          .add(workflowService.addWorkflowBinDefinition(binDefinition));
    }

    workflowService.updateWorkflowConfig(newWorkflowConfig);
    workflowService.addLogEntry(userName, projectId,
        newWorkflowConfig.getId(), null, null,
        "IMPORT workflow config - " + newWorkflowConfig);

    workflowService.commit();
    return newWorkflowConfig;
  } catch (Exception e) {
    handleException(e, "trying to add a process config");
    return null;
  } finally {
    workflowService.close();
    securityService.close();
  }

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@GET
@Path("/log")
@Produces("text/plain")
@ApiOperation(value = "Get log entries", notes = "Returns log entries for specified query parameters", response = String.class)
@Override
public String getLog(
  @ApiParam(value = "Project id, e.g. 5", required = true) @QueryParam("projectId") Long projectId,
  @ApiParam(value = "Object id, e.g. 5", required = false) @QueryParam("objectId") Long objectId,
  @ApiParam(value = "Message, e.g. Action", required = false) @QueryParam("message") String message,
  @ApiParam(value = "Lines, e.g. 5", required = true) @QueryParam("lines") int lines,
  @ApiParam(value = "Authorization token, e.g. 'author1'", required = true) @HeaderParam("Authorization") String authToken)
  throws Exception {
  Logger.getLogger(getClass()).info("RESTful call (Project): /log/"
      + projectId + ", " + objectId + ", " + message + ", " + lines);

  final ProjectService projectService = new ProjectServiceJpa();
  try {
    authorizeProject(projectService, projectId, securityService, authToken,
        "get log entries", UserRole.AUTHOR);

    // Precondition checking -- must have projectId and objectId set
    if (projectId == null) {
      throw new LocalException("Project id and Object id must be set");
    }

    final PfsParameter pfs = new PfsParameterJpa();
    pfs.setStartIndex(0);
    pfs.setMaxResults(lines);
    pfs.setAscending(false);
    pfs.setSortField("lastModified");

    String query = "";

    // projectId and objectId must be set
    if (projectId != null) {
      query += "projectId:" + projectId;
    }
    if (objectId != null) {
      query += " AND objectId:" + objectId;
    }
    if (message != null) {
      query += " AND message:\"" + QueryParserBase.escape(message) + "\"";
    }

    if (query.isEmpty()) {
      throw new Exception(
          "Must specify at least one parameter for querying log entries");
    }

    final List<LogEntry> entries = projectService.findLogEntries(query, pfs);

    final StringBuilder log = new StringBuilder();
    for (int i = entries.size() - 1; i >= 0; i--) {
      final LogEntry entry = entries.get(i);
      final StringBuilder msg = new StringBuilder();
      msg.append("[")
          .append(ConfigUtility.DATE_FORMAT4.format(entry.getLastModified()));
      msg.append("] ");
      msg.append(entry.getLastModifiedBy()).append(" ");
      msg.append(entry.getMessage()).append("\n");
      log.append(msg);
    }

    return log.toString();

  } catch (Exception e) {
    handleException(e, "trying to get log");
  } finally {
    projectService.close();
    securityService.close();
  }
  return null;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@Override
@PUT
@Path("/config")
@ApiOperation(value = "Add new process config", notes = "Creates a new process config", response = ProcessConfigJpa.class)
public ProcessConfig addProcessConfig(
  @ApiParam(value = "Project id, e.g. 12345", required = true) @QueryParam("projectId") Long projectId,
  @ApiParam(value = "ProcessConfig, as POST data", required = true) ProcessConfigJpa process,
  @ApiParam(value = "Authorization token, e.g. 'guest'", required = true) @HeaderParam("Authorization") String authToken)
  throws Exception {
  Logger.getLogger(getClass())
      .info("RESTful call (Process): /config?projectId=" + projectId
          + " for user " + authToken + ", " + process);

  final ProcessService processService = new ProcessServiceJpa();
  try {
    final String userName =
        authorizeProject(processService, projectId, securityService,
            authToken, "adding a process config", UserRole.ADMINISTRATOR);
    processService.setLastModifiedBy(userName);

    // Make sure processConfig was passed in
    if (process == null) {
      throw new LocalException("Error: trying to add null process config");
    }

    // Load project
    final Project project = processService.getProject(projectId);
    project.setLastModifiedBy(userName);

    // Re-add project to processConfig (it does not make it intact through
    // XML)
    process.setProject(project);

    final ProcessConfigList list =
        processService.findProcessConfigs(projectId,
            "nameSort:\"" + QueryParserBase.escape(process.getName()) + "\"",
            null);
    if (list.size() > 0) {
      process.setName(process.getName() + " - "
          + ConfigUtility.DATE_YYYYMMDDHHMMSS.format(new Date()));

    }

    // Verify that passed projectId matches ID of the processConfig's project
    verifyProject(process, projectId);

    // check to see if processConfig already exists
    if (processService.findProcessConfigs(projectId,
        "name:\"" + process.getName() + "\"", null).size() > 0) {
      throw new LocalException(
          "A processConfig with this name and description already exists for this project");
    }

    // Add processConfig
    final ProcessConfig newProcess = processService.addProcessConfig(process);

    processService.addLogEntry(userName, projectId, process.getId(), null,
        null, "ADD processConfig - " + process);

    return newProcess;
  } catch (Exception e) {
    handleException(e, "trying to add a process config");
    return null;
  } finally {
    processService.close();
    securityService.close();
  }

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@POST
@Override
@Path("/config/import")
@Consumes(MediaType.MULTIPART_FORM_DATA)
@ApiOperation(value = "Import process config", notes = "Imports a process config", response = ProcessConfigJpa.class)
public ProcessConfig importProcessConfig(
  @ApiParam(value = "Form data header", required = true) @FormDataParam("file") FormDataContentDisposition contentDispositionHeader,
  @ApiParam(value = "Content of members file", required = true) @FormDataParam("file") InputStream in,
  @ApiParam(value = "Project id, e.g. 12345", required = true) @QueryParam("projectId") Long projectId,
  @ApiParam(value = "Authorization token, e.g. 'guest'", required = true) @HeaderParam("Authorization") String authToken)
  throws Exception {
  Logger.getLogger(getClass())
      .info("RESTful call (Process): /config/import?projectId=" + projectId);

  final ProcessService processService = new ProcessServiceJpa();
  try {
    final String userName =
        authorizeProject(processService, projectId, securityService,
            authToken, "adding a process config", UserRole.ADMINISTRATOR);
    processService.setLastModifiedBy(userName);
    // This should be atomic
    processService.setTransactionPerOperation(false);
    processService.beginTransaction();

    // Load project
    final Project project = processService.getProject(projectId);

    // Convert to a String
    final String json = IOUtils.toString(in, "UTF-8");

    // Convert to an object
    final ProcessConfigJpa process =
        ConfigUtility.getGraphForJson(json, ProcessConfigJpa.class);

    // Clean up the imported process
    process.setProject(project);
    // Verify that passed projectId matches ID of the processConfig's project
    verifyProject(process, projectId);

    // Save steps
    final List<AlgorithmConfig> configs = new ArrayList<>(process.getSteps());

    // Prep process
    process.setId(null);
    process.getSteps().clear();
    final ProcessConfigList list = processService.findProcessConfigs(
        projectId,
        "name:\"" + QueryParserBase.escape(process.getName()) + "\"", null);
    if (list.size() > 0) {
      process.setName(process.getName() + " - "
          + ConfigUtility.DATE_YYYYMMDDHHMMSS.format(new Date()));
    }
    final ProcessConfig newProcess = processService.addProcessConfig(process);

    // Add steps
    for (final AlgorithmConfig config : configs) {
      config.setId(null);
      config.setProcess(newProcess);
      newProcess.getSteps().add(processService.addAlgorithmConfig(config));
    }

    processService.updateProcessConfig(newProcess);
    processService.addLogEntry(userName, projectId, newProcess.getId(), null,
        null, "IMPORT process config - " + newProcess);

    processService.commit();
    return newProcess;
  } catch (Exception e) {
    handleException(e, "trying to add a process config");
    return null;
  } finally {
    processService.close();
    securityService.close();
  }

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public void assertEscapedQueryEquals(String query, Analyzer a, String result) throws Exception {
  assertEquals(result, QueryParserBase.escape(query));
}