Le service avancé Cloud Identity Groups (CIG) offre une parité de fonctionnalités avec l'API Groups Service et peut être utilisé à la place.
Consultez les méthodes d'assistance fournies pour découvrir comment obtenir des fonctionnalités équivalentes avec le service avancé CIG.
Configuration
Pour utiliser le service avancé CIG, vous devez d'abord l'activer dans votre projet de script.
Pour raccourcir certaines signatures de méthode dans ce guide, nous avons défini la variable suivante :
const groups = CloudIdentityGroups.Groups;
Méthodes GroupsApp
Les méthodes d'assistance suivantes correspondent à celles du service Groups GroupsApp.
Dans ce guide, le terme groupe fait référence à une ressource de groupe, par opposition à un objet classe de groupe. Les ressources de groupe sont des objets JavaScript qui ne comportent pas de méthodes, mais qui peuvent être utilisés dans CIG Advanced Service pour récupérer des informations semblables à celles des objets Group Class.
getGroupByEmail
/**
* Given a group's email, returns that group's resource
*
* @param {String} email: The email address to lookup a group by
* @return {Group} group: The group resource associated with the email
*/
function groupsAppGetGroupByEmail(email) {
// Retrieve the name ID of the group
const groupName = groups.lookup({
'groupKey.id': email,
'groupKey.namespace': '' // Optional for google groups, dynamic groups, and security groups
// Necessary for identity-mapped groups (see https://developers.google.com/cloud-search/docs/guides/identity-mapping)
}).name;
// Retrieve the group resource
return groups.get(groupName);
}
getGroups
La méthode d'assistance suivante renvoie une liste de ressources pour les membres.
Accédez au champ group d'un élément pour trouver son ID de nom. Cela est utile pour de nombreuses méthodes du service avancé CIG. De même, accédez à groupKey.id d'un élément pour trouver son adresse e-mail.
/**
* Retrieves all the membership relation resources to groups which you are a
* direct member (or a pending member).
*
* @return {Array<MembershipRelation>} groups : List of direct memberships where
* you are the member.
*/
function groupsAppGetGroups() {
const myEmail = Session.getActiveUser().getEmail();
let pageToken = '';
let membershipList = [];
do {
const queryParams = {
query:`member_key_id=='${myEmail}'`,
pageToken:pageToken
};
const searchResult = groups.Memberships.searchDirectGroups('groups/-', queryParams);
membershipList = membershipList.concat(searchResult.memberships);
pageToken = searchResult.nextPageToken;
} while (pageToken);
return membershipList;
}
Méthodes de groupe
Les méthodes d'assistance suivantes correspondent à celles du service Groups Groups Class.
getEmail
/**
* Gets a group's email address
*
* @param {Object} group: A group resource
* @return {String} email: The email associated with the group resource.
*/
function getEmail(group) {
return group.groupKey.id;
}
getGroups
La méthode suivante utilise Memberships.list, qui récupère tous les membres du groupe donné. Cela peut inclure les appartenances des utilisateurs et des groupes.
Pour mieux approximer la méthode getGroups du service Groups, nous pouvons filtrer les abonnements par leur Type.
Nous accédons à ce champ en fournissant un FULL View en tant que paramètre de requête à Memberships.list ou en effectuant un Memberships.lookup individuel pour chaque abonnement donné.
/**
* Fetch a list of memberships with provided group as its parent
*
* @param {Group} group: A group resource
* @return {Array<Membership>} membershipList: The memberships where the parent
* is the provided group and member is a also a group.
*/
function getGroups(group) {
let membershipList = [];
let pageToken = '';
do {
// Fetch a page of memberships
const queryParams = {
view: 'FULL',
pageToken: pageToken
}
const response = groups.Memberships.list(group.name, queryParams);
// Filter non-group memberships
const onlyGroupMemberships = response.memberships.filter(
membership => membership.type == 'GROUP'
);
membershipList = membershipList.concat(onlyGroupMemberships);
// Set up next page
pageToken = response.nextPageToken;
} while(pageToken);
return membershipList;
}
getRole et getRoles
Alors que le service Groupes n'a peut-être renvoyé que le rôle de priorité la plus élevée dans getRole(), le champ roles d'une ressource de membre contient un élément distinct pour chaque rôle auquel le membre est éligible (par exemple, MEMBRE, PROPRIÉTAIRE, ADMINISTRATEUR).
/**
* Retrieve the membership roles of a member to a group.
*
* @param {Group} containingGroup: The group whom the member belongs to
* @param {String} email: The email address associated with a member that
* belongs to the containingGroup
* @return {Array<Role>} roles: List of roles the member holds with respect to
* the containingGroup.
*/
function getRoleWithEmail(containingGroup, email) {
// First fetch the membership
const membershipName = groups.Memberships.lookup(containingGroup.name, { 'memberKey.id': email }).name;
const membership = groups.Memberships.get(membershipName);
// Then retrieve the role
return membership.roles;
}
/**
* Retrieve the membership roles of a member to a group.
*
* @param {Group} containingGroup: The group resource whom the member belongs to
* @param {User} user: The user associated with a member that belongs to the
* containingGroup
* @return {Array<Role>} roles: List of roles the member holds with respect to
* the containingGroup
*/
function getRoleWithUser(containingGroup, user) {
return getRoleWithEmail(containingGroup, user.getEmail());
}
/**
* Retrieve the membership roles of a group of members to a group
*
* @param {Group} containingGroup: The group resource to which roles are
* relevant
* @param {Array<User>} users: List of users to fetch roles from
* @return {Array<Array<Role>>} roles: A list where every element is a list of
* roles of member to the containingGroup
*/
function getRoles(containingGroup, users) {
let roles = [];
for (const user of users) {
roles.push(getRoleWithUser(containingGroup, user));
}
return roles;
}
getUsers
Comme pour getGroups, nous pouvons récupérer les membres d'un groupe avec Memberships.list et filtrer les résultats pour ne conserver que notre Type cible.
/**
* Given a group, retrieve its direct members and banned members of the group
* that have a known corresponding Google Account.
*
* @param {Group} group: The group Resource whom the users being queried belong
* to
* @return {Array<String>} users: A list of emails associated with members of
* the given group
*/
function getUsers(group) {
let userList = [];
let pageToken = '';
do {
// Fetch a page of memberships from the group
const queryParams = {
view: 'FULL',
pageToken: pageToken
}
const listResponse = groups.Memberships.list(group.name, queryParams);
// Filter non-users and keep member emails
const users = listResponse.memberships
.filter(membership => membership.type == 'USER')
.map(membership => membership.preferredMemberKey.id);
userList = userList.concat(users);
// Prepare next page
pageToken = listResponse.nextPageToken;
} while (pageToken);
return userList;
}
hasGroup et hasUser
Les services Groupes hasGroup et hasUser permettent de vérifier si une entité est membre d'un groupe donné. Étant donné qu'un groupe et un utilisateur peuvent être représentés par une adresse e-mail, la méthode suivante peut être utilisée pour confirmer si l'un ou l'autre appartient à un groupe donné.
/**
* Tests if the given email has an associated direct member to the given group.
*
* @param {Group} group: Group resource to which the entity is being checked as
* a member
* @param {String} email: Email that can represent a Group or User entity
* @return {Boolean} isMember: Whether the entity is a direct member to the
* group or not
*/
function checkDirectGroupMembership(group, email) {
try {
groups.Memberships.lookup(group.name, {'memberKey.id': email});
} catch(e) {
// Log failure if exception is not related to membership existence
if (!e.message.includes('Membership does not exist.')) {
console.error(e);
}
return false;
}
return true;
}