import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public ConsistencyCheckInfo apply(ConfigResource resource, ConsistencyCheckInput input)
    throws RestApiException, IOException, OrmException, PermissionBackendException {
  permissionBackend.user(user).check(GlobalPermission.ACCESS_DATABASE);

  if (input == null || (input.checkAccounts == null && input.checkAccountExternalIds == null)) {
    throw new BadRequestException("input required");
  }

  ConsistencyCheckInfo consistencyCheckInfo = new ConsistencyCheckInfo();
  if (input.checkAccounts != null) {
    consistencyCheckInfo.checkAccountsResult =
        new CheckAccountsResultInfo(accountsConsistencyChecker.check());
  }
  if (input.checkAccountExternalIds != null) {
    consistencyCheckInfo.checkAccountExternalIdsResult =
        new CheckAccountExternalIdsResultInfo(externalIdsConsistencyChecker.check());
  }

  return consistencyCheckInfo;
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
private HashSet<Integer> getOpenChanges(Changes.QueryRequest changeQuery)
    throws RestApiException {
  HashSet<Integer> openChanges = new HashSet<>();

  for (ChangeInfo change : changeQuery.get()) {
    openChanges.add(new Integer(change._number));
  }

  return openChanges;
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public ChangeInfo accessChange(ProjectAccessInput p) throws RestApiException {
  try {
    return createAccessChange.apply(checkExists(), p).value();
  } catch (Exception e) {
    throw asRestApiException("Cannot put access right change", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public AccountApi self() throws RestApiException {
  if (!self.get().isIdentifiedUser()) {
    throw new AuthException("Authentication required");
  }
  return api.create(new AccountResource(self.get().asIdentifiedUser()));
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
public List<PluginInfo> get() throws RestApiException {
  Map<String, PluginInfo> map = getAsMap();
  List<PluginInfo> result = new ArrayList<>(map.size());
  for (Map.Entry<String, PluginInfo> e : map.entrySet()) {
    result.add(e.getValue());
  }
  return result;
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public ChildProjectApi child(String name) throws RestApiException {
  try {
    return childApi.create(children.parse(checkExists(), IdString.fromDecoded(name)));
  } catch (Exception e) {
    throw asRestApiException("Cannot parse child project", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public QueryRequest query() throws RestApiException {
  return new QueryRequest() {
    @Override
    public List<AccountInfo> get() throws RestApiException {
      return AccountsImpl.this.query(this);
    }
  };
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public CommentInfo delete(DeleteCommentInput input) throws RestApiException {
  try {
    return deleteComment.apply(comment, input);
  } catch (Exception e) {
    throw asRestApiException("Cannot delete comment", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public List<ProjectWatchInfo> apply(AccountResource rsrc, List<ProjectWatchInfo> input)
    throws OrmException, RestApiException, IOException, ConfigInvalidException,
        PermissionBackendException {
  if (self.get() != rsrc.getUser()) {
    permissionBackend.user(self).check(GlobalPermission.ADMINISTRATE_SERVER);
  }

  Account.Id accountId = rsrc.getUser().getAccountId();
  watchConfig.upsertProjectWatches(accountId, asMap(input));
  accountCache.evict(accountId);
  return getWatchedProjects.apply(rsrc);
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
protected Response<?> applyImpl(
    BatchUpdate.Factory updateFactory, VoteResource rsrc, DeleteVoteInput input)
    throws RestApiException, UpdateException, IOException {
  if (input == null) {
    input = new DeleteVoteInput();
  }
  if (input.label != null && !rsrc.getLabel().equals(input.label)) {
    throw new BadRequestException("label must match URL");
  }
  if (input.notify == null) {
    input.notify = NotifyHandling.ALL;
  }
  ReviewerResource r = rsrc.getReviewer();
  Change change = r.getChange();

  if (r.getRevisionResource() != null && !r.getRevisionResource().isCurrent()) {
    throw new MethodNotAllowedException("Cannot delete vote on non-current patch set");
  }

  try (BatchUpdate bu =
      updateFactory.create(
          db.get(), change.getProject(), r.getChangeResource().getUser(), TimeUtil.nowTs())) {
    bu.addOp(
        change.getId(),
        new Op(
            projectCache.checkedGet(r.getChange().getProject()),
            r.getReviewerUser().getAccount(),
            rsrc.getLabel(),
            input));
    bu.execute();
  }

  return Response.none();
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public Map<String, List<RobotCommentInfo>> robotComments() throws RestApiException {
  try {
    return listRobotComments.apply(revision);
  } catch (Exception e) {
    throw asRestApiException("Cannot retrieve robot comments", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public ChangeInfo check(FixInput fix) throws RestApiException {
  try {
    // TODO(dborowitz): Convert to RetryingRestModifyView. Needs to plumb BatchUpdate.Factory into
    // ConsistencyChecker.
    return check.apply(change, fix).value();
  } catch (Exception e) {
    throw asRestApiException("Cannot check change", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Map<String, FileInfo> files() throws RestApiException {
  try {
    return (Map<String, FileInfo>) listFiles.apply(revision).value();
  } catch (Exception e) {
    throw asRestApiException("Cannot retrieve files", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public DraftApi createDraft(DraftInput in) throws RestApiException {
  try {
    String id = createDraft.apply(revision, in).value().id;
    // Reread change to pick up new notes refs.
    return changes
        .id(revision.getChange().getId().get())
        .revision(revision.getPatchSet().getId().get())
        .draft(id);
  } catch (Exception e) {
    throw asRestApiException("Cannot create draft", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
private void verifyOne(PatchSet patchSet) throws UnloggedFailure {
  VerifyInput verify = new VerifyInput();
  verify.verifications = jobResult;
  try {
    applyVerification(patchSet, verify);
  } catch (RestApiException | NoSuchChangeException | OrmException
      | IOException e) {
    throw PatchSetParser.error(e.getMessage());
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public Map<String, GpgKeyInfo> listGpgKeys(AccountResource account)
    throws RestApiException, GpgException {
  try {
    return gpgKeys.get().list().apply(account);
  } catch (OrmException | PGPException | IOException e) {
    throw new GpgException(e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public Map<String, GpgKeyInfo> putGpgKeys(
    AccountResource account, List<String> add, List<String> delete)
    throws RestApiException, GpgException {
  GpgKeysInput in = new GpgKeysInput();
  in.add = add;
  in.delete = delete;
  try {
    return postGpgKeys.get().apply(account, in);
  } catch (PGPException | OrmException | IOException | ConfigInvalidException e) {
    throw new GpgException(e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
private SortedMap<String, ProjectInfo> list(ListRequest request)
    throws RestApiException, PermissionBackendException {
  ListProjects lp = listProvider.get();
  lp.setShowDescription(request.getDescription());
  lp.setLimit(request.getLimit());
  lp.setStart(request.getStart());
  lp.setMatchPrefix(request.getPrefix());

  lp.setMatchSubstring(request.getSubstring());
  lp.setMatchRegex(request.getRegex());
  lp.setShowTree(request.getShowTree());
  for (String branch : request.getBranches()) {
    lp.addShowBranch(branch);
  }

  FilterType type;
  switch (request.getFilterType()) {
    case ALL:
      type = FilterType.ALL;
      break;
    case CODE:
      type = FilterType.CODE;
      break;
    case PARENT_CANDIDATES:
      type = FilterType.PARENT_CANDIDATES;
      break;
    case PERMISSIONS:
      type = FilterType.PERMISSIONS;
      break;
    default:
      throw new BadRequestException("Unknown filter type: " + request.getFilterType());
  }
  lp.setFilterType(type);

  return lp.apply();
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public ReviewResult review(ReviewInput in) throws RestApiException {
  try {
    return review.apply(revision, in).value();
  } catch (Exception e) {
    throw asRestApiException("Cannot post review", e);
  }
}
 

import com.google.gerrit.extensions.restapi.RestApiException; //导入依赖的package包/类
@Override
public List<ChangeInfo> submittedTogether() throws RestApiException {
  SubmittedTogetherInfo info =
      submittedTogether(
          EnumSet.noneOf(ListChangesOption.class), EnumSet.noneOf(SubmittedTogetherOption.class));
  return info.changes;
}