Java GroupDescription.Basic方法代码示例

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
private Map<AccountGroup.UUID, GroupInfo> buildGroupInfo(List<AccessSection> local) {
  Map<AccountGroup.UUID, GroupInfo> infos = new HashMap<>();
  for (AccessSection section : local) {
    for (Permission permission : section.getPermissions()) {
      for (PermissionRule rule : permission.getRules()) {
        if (rule.getGroup() != null) {
          AccountGroup.UUID uuid = rule.getGroup().getUUID();
          if (uuid != null && !infos.containsKey(uuid)) {
            GroupDescription.Basic group = groupBackend.get(uuid);
            infos.put(uuid, group != null ? new GroupInfo(group) : null);
          }
        }
      }
    }
  }
  return Maps.filterEntries(infos, in -> in.getValue() != null);
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
@Override
public GroupResource parse(TopLevelResource parent, IdString id)
    throws AuthException, ResourceNotFoundException {
  final CurrentUser user = self.get();
  if (user instanceof AnonymousUser) {
    throw new AuthException("Authentication required");
  } else if (!(user.isIdentifiedUser())) {
    throw new ResourceNotFoundException(id);
  }

  GroupDescription.Basic group = parseId(id.get());
  if (group == null) {
    throw new ResourceNotFoundException(id.get());
  }
  GroupControl ctl = groupControlFactory.controlFor(group);
  if (!ctl.isVisible()) {
    throw new ResourceNotFoundException(id);
  }
  return new GroupResource(ctl);
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
/**
 * Check all GroupReferences use current group name, repairing stale ones.
 *
 * @param groupBackend cache to use when looking up group information by UUID.
 * @return true if one or more group names was stale.
 */
public boolean updateGroupNames(GroupBackend groupBackend) {
  boolean dirty = false;
  for (GroupReference ref : groupList.references()) {
    GroupDescription.Basic g = groupBackend.get(ref.getUUID());
    if (g != null && !g.getName().equals(ref.getName())) {
      dirty = true;
      ref.setName(g.getName());
    }
  }
  return dirty;
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
private void deliverToMembers(Watchers.List matching, AccountGroup.UUID startUUID) {
  Set<AccountGroup.UUID> seen = new HashSet<>();
  List<AccountGroup.UUID> q = new ArrayList<>();

  seen.add(startUUID);
  q.add(startUUID);

  while (!q.isEmpty()) {
    AccountGroup.UUID uuid = q.remove(q.size() - 1);
    GroupDescription.Basic group = args.groupBackend.get(uuid);
    if (group == null) {
      continue;
    }
    if (!Strings.isNullOrEmpty(group.getEmailAddress())) {
      // If the group has an email address, do not expand membership.
      matching.emails.add(new Address(group.getEmailAddress()));
      continue;
    }

    if (!(group instanceof GroupDescription.Internal)) {
      // Non-internal groups cannot be expanded by the server.
      continue;
    }

    GroupDescription.Internal ig = (GroupDescription.Internal) group;
    matching.accounts.addAll(ig.getMembers());
    for (AccountGroup.UUID m : ig.getSubgroups()) {
      if (seen.add(m)) {
        q.add(m);
      }
    }
  }
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
public GroupControl controlFor(CurrentUser who, AccountGroup.UUID groupId)
    throws NoSuchGroupException {
  GroupDescription.Basic group = groupBackend.get(groupId);
  if (group == null) {
    throw new NoSuchGroupException(groupId);
  }
  return new GroupControl(who, group, permissionBackend, groupBackend);
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
private GroupInfo createGroupInfo(
    GroupDescription.Basic group, Supplier<GroupControl> groupControlSupplier)
    throws OrmException {
  GroupInfo info = createBasicGroupInfo(group);

  if (group instanceof GroupDescription.Internal) {
    addInternalDetails(info, (GroupDescription.Internal) group, groupControlSupplier);
  }

  return info;
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
private static GroupInfo createBasicGroupInfo(GroupDescription.Basic group) {
  GroupInfo info = new GroupInfo();
  info.id = Url.encode(group.getGroupUUID().get());
  info.name = Strings.emptyToNull(group.getName());
  info.url = Strings.emptyToNull(group.getUrl());
  info.options = createOptions(group);
  return info;
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
private void addInternalDetails(
    GroupInfo info,
    GroupDescription.Internal internalGroup,
    Supplier<GroupControl> groupControlSupplier)
    throws OrmException {
  info.description = Strings.emptyToNull(internalGroup.getDescription());
  info.groupId = internalGroup.getId().get();

  AccountGroup.UUID ownerGroupUUID = internalGroup.getOwnerGroupUUID();
  if (ownerGroupUUID != null) {
    info.ownerId = Url.encode(ownerGroupUUID.get());
    GroupDescription.Basic o = groupBackend.get(ownerGroupUUID);
    if (o != null) {
      info.owner = o.getName();
    }
  }

  info.createdOn = internalGroup.getCreatedOn();

  if (options.contains(MEMBERS)) {
    info.members = listMembers.get().getDirectMembers(internalGroup, groupControlSupplier.get());
  }

  if (options.contains(INCLUDES)) {
    info.includes =
        listSubgroups.get().getDirectSubgroups(internalGroup, groupControlSupplier.get());
  }
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
GroupControl(
    CurrentUser who,
    GroupDescription.Basic gd,
    PermissionBackend permissionBackend,
    GroupBackend gb) {
  user = who;
  group = gd;
  this.perm = permissionBackend.user(user);
  groupBackend = gb;
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
public Optional<GroupDescription.Internal> asInternalGroup() {
  GroupDescription.Basic group = getGroup();
  if (group instanceof GroupDescription.Internal) {
    return Optional.of((GroupDescription.Internal) group);
  }
  return Optional.empty();
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
@Override
public GroupDescription.Basic get(AccountGroup.UUID uuid) {
  final GroupReference ref = uuids.get(uuid);
  if (ref == null) {
    return null;
  }
  return new GroupDescription.Basic() {
    @Override
    public String getName() {
      return ref.getName();
    }

    @Override
    public AccountGroup.UUID getGroupUUID() {
      return ref.getUUID();
    }

    @Override
    public String getUrl() {
      return null;
    }

    @Override
    public String getEmailAddress() {
      return null;
    }
  };
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
List<AccessSection> getAccessSections(Map<String, AccessSectionInfo> sectionInfos)
    throws UnprocessableEntityException {
  if (sectionInfos == null) {
    return Collections.emptyList();
  }

  List<AccessSection> sections = new ArrayList<>(sectionInfos.size());
  for (Map.Entry<String, AccessSectionInfo> entry : sectionInfos.entrySet()) {
    if (entry.getValue().permissions == null) {
      continue;
    }

    AccessSection accessSection = new AccessSection(entry.getKey());
    for (Map.Entry<String, PermissionInfo> permissionEntry :
        entry.getValue().permissions.entrySet()) {
      if (permissionEntry.getValue().rules == null) {
        continue;
      }

      Permission p = new Permission(permissionEntry.getKey());
      if (permissionEntry.getValue().exclusive != null) {
        p.setExclusiveGroup(permissionEntry.getValue().exclusive);
      }

      for (Map.Entry<String, PermissionRuleInfo> permissionRuleInfoEntry :
          permissionEntry.getValue().rules.entrySet()) {
        GroupDescription.Basic group = groupsCollection.parseId(permissionRuleInfoEntry.getKey());
        if (group == null) {
          throw new UnprocessableEntityException(
              permissionRuleInfoEntry.getKey() + " is not a valid group ID");
        }

        PermissionRuleInfo pri = permissionRuleInfoEntry.getValue();
        PermissionRule r = new PermissionRule(GroupReference.forGroup(group));
        if (pri != null) {
          if (pri.max != null) {
            r.setMax(pri.max);
          }
          if (pri.min != null) {
            r.setMin(pri.min);
          }
          r.setAction(GetAccess.ACTION_TYPE.inverse().get(pri.action));
          if (pri.force != null) {
            r.setForce(pri.force);
          }
        }
        p.add(r);
      }
      accessSection.getPermissions().add(p);
    }
    sections.add(accessSection);
  }
  return sections;
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
@Override
public GroupDescription.Basic get(AccountGroup.UUID uuid) {
  if (!handles(uuid)) {
    return null;
  }

  String groupDn = uuid.get().substring(LDAP_UUID.length());
  CurrentUser user = userProvider.get();
  if (!(user.isIdentifiedUser()) || !membershipsOf(user.asIdentifiedUser()).contains(uuid)) {
    try {
      if (!existsCache.get(groupDn)) {
        return null;
      }
    } catch (ExecutionException e) {
      log.warn(String.format("Cannot lookup group %s in LDAP", groupDn), e);
      return null;
    }
  }

  final String name = LDAP_NAME + cnFor(groupDn);
  return new GroupDescription.Basic() {
    @Override
    public AccountGroup.UUID getGroupUUID() {
      return uuid;
    }

    @Override
    public String getName() {
      return name;
    }

    @Override
    @Nullable
    public String getEmailAddress() {
      return null;
    }

    @Override
    @Nullable
    public String getUrl() {
      return null;
    }
  };
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
public GroupDescription.Basic getMemberDescription() {
  return member;
}
 

import com.google.gerrit.common.data.GroupDescription; //导入方法依赖的package包/类
private GroupReference getMyGroup() {
  GroupDescription.Basic g = groupBackend.get(AccountGroup.UUID.parse("user:" + username));
  return projectConfig.resolve(GroupReference.forGroup(g));
}