El servicio avanzado de Cloud Identity Groups (CIG) proporciona paridad de funciones con la API de Groups Service y se puede usar en su lugar.
Consulta los métodos auxiliares proporcionados para obtener información sobre cómo lograr capacidades equivalentes a través del servicio avanzado de CIG.
Configuración
Para usar el servicio avanzado de CIG, primero habilítalo en tu proyecto de secuencia de comandos.
Para abreviar algunas de las firmas de métodos en esta guía, definimos la siguiente variable:
const groups = CloudIdentityGroups.Groups;
Métodos de GroupsApp
Los siguientes métodos auxiliares corresponden a los del servicio de Groups GroupsApp.
En esta guía, el término grupo hace referencia a un recurso de grupo, a diferencia de un objeto de clase de grupo. Los recursos de grupo son objetos de JavaScript que no tienen métodos, pero se pueden usar en el servicio avanzado de CIG para recuperar información similar a la de los objetos de la clase Group.
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
El siguiente método auxiliar devuelve una lista de recursos de membresía.
Accede al campo group de un elemento para encontrar su ID de nombre. Esto es útil para muchos métodos del Servicio avanzado de CIG. Del mismo modo, accede a groupKey.id de un elemento para encontrar su correo electrónico.
/**
* 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étodos de grupo
Los siguientes métodos auxiliares corresponden a los del servicio de 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
El siguiente método usa Memberships.list, que recuperará todas las membresías del grupo determinado. Esto puede incluir las membresías de usuarios y grupos.
Para aproximarnos mejor al método getGroups del servicio de Groups, podemos filtrar las membresías por su Type.
Accedemos a este campo proporcionando un FULL View como parámetro de consulta a Memberships.list o realizando un Memberships.lookup individual para cada membresía determinada.
/**
* 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 y getRoles
Si bien es posible que el servicio de Groups solo haya devuelto el rol de mayor prioridad en getRole(), el campo roles en un recurso de membresía contiene un elemento independiente para cada rol para el que el miembro cumple con los requisitos (por ejemplo, MIEMBRO, PROPIETARIO, ADMINISTRADOR).
/**
* 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
De manera similar a nuestro enfoque en getGroups, podemos recuperar las membresías de un grupo con Memberships.list y filtrar los resultados para conservar solo nuestro Type objetivo.
/**
* 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 y hasUser
Los servicios de Groups hasGroup y hasUser confirman si una entidad es miembro de un grupo determinado. Dado que tanto un grupo como un usuario pueden representarse con una dirección de correo electrónico, se puede usar el siguiente método para confirmar si alguno de ellos pertenece a un grupo determinado.
/**
* 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;
}