Java AccountGroupMember类代码示例

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
private AccountExternalId createNewUser(ReviewDb db) throws OrmException, UnprocessableEntityException {
	Account.Id id = new Account.Id(db.nextAccountId());
	AccountExternalId extUser =
		new AccountExternalId(id, new AccountExternalId.Key(
			AccountExternalId.SCHEME_USERNAME, username));

	/*
	if (input.httpPassword != null) {
		extUser.setPassword(input.httpPassword);
	}
	*/
	db.accountExternalIds().insert(Collections.singleton(extUser));
	Account a = new Account(id, TimeUtil.nowTs());
	a.setFullName(name);
	//a.setPreferredEmail(input.email);
	db.accounts().insert(Collections.singleton(a));

	Set<AccountGroup.Id> groups = parseGroups(Lists.newArrayList("2"));

	for (AccountGroup.Id groupId : groups) {
		AccountGroupMember m =
			new AccountGroupMember(new AccountGroupMember.Key(id, groupId));
		db.accountGroupMembers().insert(Collections.singleton(m));
	}

	accountCache.evictByUsername(username);

	return extUser;
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
private static void addGroupMemberInReviewDb(
    ReviewDb db, AccountGroup.UUID groupUuid, Account.Id accountId)
    throws OrmException, NoSuchGroupException {
  AccountGroup group = getExistingGroup(db, groupUuid);
  AccountGroup.Id groupId = group.getId();

  if (isMember(db, groupId, accountId)) {
    return;
  }

  db.accountGroupMembers()
      .insert(
          ImmutableList.of(
              new AccountGroupMember(new AccountGroupMember.Key(accountId, groupId))));
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
private void addGroupMembersInReviewDb(
    ReviewDb db, AccountGroup.Id groupId, Set<Account.Id> newMemberIds) throws OrmException {
  Set<AccountGroupMember> newMembers =
      newMemberIds
          .stream()
          .map(accountId -> new AccountGroupMember.Key(accountId, groupId))
          .map(AccountGroupMember::new)
          .collect(toImmutableSet());

  if (currentUser != null) {
    auditService.dispatchAddAccountsToGroup(currentUser.getAccountId(), newMembers);
  }
  db.accountGroupMembers().insert(newMembers);
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
private void removeGroupMembersInReviewDb(
    ReviewDb db, AccountGroup.Id groupId, Set<Account.Id> accountIds) throws OrmException {
  Set<AccountGroupMember> membersToRemove =
      accountIds
          .stream()
          .map(accountId -> new AccountGroupMember.Key(accountId, groupId))
          .map(AccountGroupMember::new)
          .collect(toImmutableSet());

  if (currentUser != null) {
    auditService.dispatchDeleteAccountsFromGroup(currentUser.getAccountId(), membersToRemove);
  }
  db.accountGroupMembers().delete(membersToRemove);
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
@Override
public void onAddAccountsToGroup(Account.Id me, Collection<AccountGroupMember> added) {
  List<AccountGroupMemberAudit> auditInserts = new ArrayList<>();
  for (AccountGroupMember m : added) {
    AccountGroupMemberAudit audit = new AccountGroupMemberAudit(m, me, TimeUtil.nowTs());
    auditInserts.add(audit);
  }
  try (ReviewDb db = schema.open()) {
    db.accountGroupMembersAudit().insert(auditInserts);
  } catch (OrmException e) {
    logOrmExceptionForAccounts(
        "Cannot log add accounts to group event performed by user", me, added, e);
  }
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
@Override
public void onDeleteAccountsFromGroup(Account.Id me, Collection<AccountGroupMember> removed) {
  List<AccountGroupMemberAudit> auditInserts = new ArrayList<>();
  List<AccountGroupMemberAudit> auditUpdates = new ArrayList<>();
  try (ReviewDb db = schema.open()) {
    for (AccountGroupMember m : removed) {
      AccountGroupMemberAudit audit = null;
      for (AccountGroupMemberAudit a :
          db.accountGroupMembersAudit().byGroupAccount(m.getAccountGroupId(), m.getAccountId())) {
        if (a.isActive()) {
          audit = a;
          break;
        }
      }

      if (audit != null) {
        audit.removed(me, TimeUtil.nowTs());
        auditUpdates.add(audit);
      } else {
        audit = new AccountGroupMemberAudit(m, me, TimeUtil.nowTs());
        audit.removedLegacy();
        auditInserts.add(audit);
      }
    }
    db.accountGroupMembersAudit().update(auditUpdates);
    db.accountGroupMembersAudit().insert(auditInserts);
  } catch (OrmException e) {
    logOrmExceptionForAccounts(
        "Cannot log delete accounts from group event performed by user", me, removed, e);
  }
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
private void logOrmExceptionForAccounts(
    String header, Account.Id me, Collection<AccountGroupMember> values, OrmException e) {
  List<String> descriptions = new ArrayList<>();
  for (AccountGroupMember m : values) {
    Account.Id accountId = m.getAccountId();
    String userName = accountCache.get(accountId).getUserName();
    AccountGroup.Id groupId = m.getAccountGroupId();
    String groupName = getGroupName(groupId);

    descriptions.add(
        MessageFormat.format(
            "account {0}/{1}, group {2}/{3}", accountId, userName, groupId, groupName));
  }
  logOrmException(header, me, descriptions, e);
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
public void dispatchAddAccountsToGroup(Account.Id actor, Collection<AccountGroupMember> added) {
  for (GroupMemberAuditListener auditListener : groupMemberAuditListeners) {
    try {
      auditListener.onAddAccountsToGroup(actor, added);
    } catch (RuntimeException e) {
      log.error("failed to log add accounts to group event", e);
    }
  }
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
public void dispatchDeleteAccountsFromGroup(
    Account.Id actor, Collection<AccountGroupMember> removed) {
  for (GroupMemberAuditListener auditListener : groupMemberAuditListeners) {
    try {
      auditListener.onDeleteAccountsFromGroup(actor, removed);
    } catch (RuntimeException e) {
      log.error("failed to log delete accounts from group event", e);
    }
  }
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
@Override
@PrimaryKey("key")
AccountGroupMember get(AccountGroupMember.Key key) throws OrmException;
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
@Query("WHERE key.accountId = ?")
ResultSet<AccountGroupMember> byAccount(Account.Id id) throws OrmException;
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
@Query("WHERE key.groupId = ?")
ResultSet<AccountGroupMember> byGroup(AccountGroup.Id id) throws OrmException;
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
private static boolean isMember(ReviewDb db, AccountGroup.Id groupId, Account.Id accountId)
    throws OrmException {
  AccountGroupMember.Key key = new AccountGroupMember.Key(accountId, groupId);
  return db.accountGroupMembers().get(key) != null;
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
/**
 * Returns the groups of which the specified account is a member.
 *
 * <p><strong>Note</strong>: This method returns an empty stream if the account doesn't exist.
 * This method doesn't check whether the groups exist.
 *
 * @param db the {@code ReviewDb} instance to use for lookups
 * @param accountId the ID of the account
 * @return a stream of the IDs of the groups of which the account is a member
 * @throws OrmException if an error occurs while reading from ReviewDb
 */
public static Stream<AccountGroup.Id> getGroupsWithMemberFromReviewDb(
    ReviewDb db, Account.Id accountId) throws OrmException {
  ResultSet<AccountGroupMember> accountGroupMembers =
      db.accountGroupMembers().byAccount(accountId);
  return Streams.stream(accountGroupMembers).map(AccountGroupMember::getAccountGroupId);
}
 

import com.google.gerrit.reviewdb.client.AccountGroupMember; //导入依赖的package包/类
/**
 * Returns the members (accounts) of a group.
 *
 * <p><strong>Note</strong>: This method doesn't check whether the accounts exist!
 *
 * @param db the {@code ReviewDb} instance to use for lookups
 * @param groupId the ID of the group
 * @return a stream of the IDs of the members
 * @throws OrmException if an error occurs while reading from ReviewDb
 */
public static Stream<Account.Id> getMembersFromReviewDb(ReviewDb db, AccountGroup.Id groupId)
    throws OrmException {
  ResultSet<AccountGroupMember> accountGroupMembers = db.accountGroupMembers().byGroup(groupId);
  return Streams.stream(accountGroupMembers).map(AccountGroupMember::getAccountId);
}