Java PermissionRule.getAction方法代码示例

import com.google.gerrit.common.data.PermissionRule; //导入方法依赖的package包/类
/** @return which priority queue the user's tasks should be submitted to. */
public QueueProvider.QueueType getQueueType() {
  // If a non-generic group (that is not Anonymous Users or Registered Users)
  // grants us INTERACTIVE permission, use the INTERACTIVE queue even if
  // BATCH was otherwise granted. This allows site administrators to grant
  // INTERACTIVE to Registered Users, and BATCH to 'CI Servers' and have
  // the 'CI Servers' actually use the BATCH queue while everyone else gets
  // to use the INTERACTIVE queue without additional grants.
  //
  GroupMembership groups = user.getEffectiveGroups();
  boolean batch = false;
  for (PermissionRule r : capabilities.priority) {
    if (match(groups, r)) {
      switch (r.getAction()) {
        case INTERACTIVE:
          if (!SystemGroupBackend.isAnonymousOrRegistered(r.getGroup())) {
            return QueueProvider.QueueType.INTERACTIVE;
          }
          break;

        case BATCH:
          batch = true;
          break;

        case ALLOW:
        case BLOCK:
        case DENY:
          break;
      }
    }
  }

  if (batch) {
    // If any of our groups matched to the BATCH queue, use it.
    return QueueProvider.QueueType.BATCH;
  }
  return QueueProvider.QueueType.INTERACTIVE;
}
 

import com.google.gerrit.common.data.PermissionRule; //导入方法依赖的package包/类
/**
 * Checks if the user has signed a contributor agreement for the project.
 *
 * @throws AuthException if the user has not signed a contributor agreement for the project
 * @throws IOException if project states could not be loaded
 */
public void check(Project.NameKey project, CurrentUser user) throws IOException, AuthException {
  metrics.claCheckCount.increment();

  ProjectState projectState = projectCache.checkedGet(project);
  if (projectState == null) {
    throw new IOException("Can't load All-Projects");
  }

  if (!projectState.isUseContributorAgreements()) {
    return;
  }

  if (!user.isIdentifiedUser()) {
    throw new AuthException("Must be logged in to verify Contributor Agreement");
  }

  IdentifiedUser iUser = user.asIdentifiedUser();
  Collection<ContributorAgreement> contributorAgreements =
      projectCache.getAllProjects().getConfig().getContributorAgreements();
  List<UUID> okGroupIds = new ArrayList<>();
  for (ContributorAgreement ca : contributorAgreements) {
    List<AccountGroup.UUID> groupIds;
    groupIds = okGroupIds;

    for (PermissionRule rule : ca.getAccepted()) {
      if ((rule.getAction() == Action.ALLOW)
          && (rule.getGroup() != null)
          && (rule.getGroup().getUUID() != null)) {
        groupIds.add(new AccountGroup.UUID(rule.getGroup().getUUID().get()));
      }
    }
  }

  if (!iUser.getEffectiveGroups().containsAnyOf(okGroupIds)) {
    final StringBuilder msg = new StringBuilder();
    msg.append("A Contributor Agreement must be completed before uploading");
    if (canonicalWebUrl != null) {
      msg.append(":\n\n  ");
      msg.append(canonicalWebUrl);
      msg.append("#");
      msg.append(PageLinks.SETTINGS_AGREEMENTS);
      msg.append("\n");
    } else {
      msg.append(".");
    }
    throw new AuthException(msg.toString());
  }
}
 

import com.google.gerrit.common.data.PermissionRule; //导入方法依赖的package包/类
@Inject
public ProjectState(
    final SitePaths sitePaths,
    final ProjectCache projectCache,
    final AllProjectsName allProjectsName,
    final AllUsersName allUsersName,
    final ProjectControl.AssistedFactory projectControlFactory,
    final PrologEnvironment.Factory envFactory,
    final GitRepositoryManager gitMgr,
    final RulesCache rulesCache,
    final List<CommentLinkInfo> commentLinks,
    final CapabilityCollection.Factory limitsFactory,
    @Assisted final ProjectConfig config) {
  this.sitePaths = sitePaths;
  this.projectCache = projectCache;
  this.isAllProjects = config.getProject().getNameKey().equals(allProjectsName);
  this.isAllUsers = config.getProject().getNameKey().equals(allUsersName);
  this.allProjectsName = allProjectsName;
  this.projectControlFactory = projectControlFactory;
  this.envFactory = envFactory;
  this.gitMgr = gitMgr;
  this.rulesCache = rulesCache;
  this.commentLinks = commentLinks;
  this.config = config;
  this.configs = new HashMap<>();
  this.capabilities =
      isAllProjects
          ? limitsFactory.create(config.getAccessSection(AccessSection.GLOBAL_CAPABILITIES))
          : null;

  if (isAllProjects && !Permission.canBeOnAllProjects(AccessSection.ALL, Permission.OWNER)) {
    localOwners = Collections.emptySet();
  } else {
    HashSet<AccountGroup.UUID> groups = new HashSet<>();
    AccessSection all = config.getAccessSection(AccessSection.ALL);
    if (all != null) {
      Permission owner = all.getPermission(Permission.OWNER);
      if (owner != null) {
        for (PermissionRule rule : owner.getRules()) {
          GroupReference ref = rule.getGroup();
          if (rule.getAction() == ALLOW && ref.getUUID() != null) {
            groups.add(ref.getUUID());
          }
        }
      }
    }
    localOwners = Collections.unmodifiableSet(groups);
  }
}
 

import com.google.gerrit.common.data.PermissionRule; //导入方法依赖的package包/类
@Override
public List<AgreementInfo> apply(AccountResource resource) throws RestApiException {
  if (!agreementsEnabled) {
    throw new MethodNotAllowedException("contributor agreements disabled");
  }

  if (!self.get().isIdentifiedUser()) {
    throw new AuthException("not allowed to get contributor agreements");
  }

  IdentifiedUser user = self.get().asIdentifiedUser();
  if (user != resource.getUser()) {
    throw new AuthException("not allowed to get contributor agreements");
  }

  List<AgreementInfo> results = new ArrayList<>();
  Collection<ContributorAgreement> cas =
      projectCache.getAllProjects().getConfig().getContributorAgreements();
  for (ContributorAgreement ca : cas) {
    List<AccountGroup.UUID> groupIds = new ArrayList<>();
    for (PermissionRule rule : ca.getAccepted()) {
      if ((rule.getAction() == Action.ALLOW) && (rule.getGroup() != null)) {
        if (rule.getGroup().getUUID() != null) {
          groupIds.add(rule.getGroup().getUUID());
        } else {
          log.warn(
              "group \""
                  + rule.getGroup().getName()
                  + "\" does not "
                  + "exist, referenced in CLA \""
                  + ca.getName()
                  + "\"");
        }
      }
    }

    if (user.getEffectiveGroups().containsAnyOf(groupIds)) {
      results.add(agreementJson.format(ca));
    }
  }
  return results;
}