Eseguire la migrazione dal servizio Gruppi al servizio avanzato Gruppi di Cloud Identity

Il servizio avanzato Cloud Identity Groups (CIG) offre parità di funzionalità con l'API Groups Service e può essere utilizzato al suo posto.

Consulta i metodi helper forniti per scoprire come ottenere funzionalità equivalenti tramite CIG Advanced Service.

Configurazione

Per utilizzare il servizio avanzato CIG, devi prima abilitarlo nel progetto dello script.

Per abbreviare alcune delle firme dei metodi in questa guida, abbiamo definito la seguente variabile:

const groups = CloudIdentityGroups.Groups;

Metodi GroupsApp

I seguenti metodi helper corrispondono a quelli del servizio Groups GroupsApp.

In questa guida, il termine gruppo si riferisce a una risorsa gruppo, anziché a un oggetto classe gruppo. Risorse di gruppo sono oggetti JavaScript che non hanno metodi, ma possono essere utilizzati in CIG Advanced Service per recuperare informazioni simili a quelle degli oggetti Classe di gruppo.

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

Il seguente metodo helper restituisce un elenco di risorse per gli abbonati. Accedi al campo group di un elemento per trovare il relativo ID nome. Ciò è utile per molti metodi di CIG Advanced Service. Allo stesso modo, accedi a groupKey.id di un elemento per trovare la sua email.

/**
 * 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;
}

Metodi di gruppo

I seguenti metodi helper corrispondono a quelli del servizio 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

Il seguente metodo utilizza Memberships.list, che recupererà ogni iscrizione al gruppo specificato. che possono includere le iscrizioni di utenti e gruppi.

Per approssimare meglio il metodo getGroups del servizio Gruppi, possiamo filtrare le iscrizioni in base al relativo Type. Accediamo a questo campo fornendo un FULL View come parametro di query a Memberships.list o eseguendo un Memberships.lookup individuale per ogni abbonamento specificato.

/**
 * 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 e getRoles

Mentre il servizio Gruppi potrebbe aver restituito solo il ruolo con la priorità più alta in getRole(), il campo roles in una risorsa di appartenenza contiene un elemento separato per ogni ruolo per cui il membro è idoneo (ad esempio MEMBRO, PROPRIETARIO, AMMINISTRATORE).

/**
 * 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

Analogamente al nostro approccio in getGroups, possiamo recuperare le iscrizioni di un gruppo con Memberships.list e filtrare i risultati per conservare solo il nostro Type di destinazione.

/**
 * 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 e hasUser

Sia il servizio Gruppi hasGroup sia hasUser confermano se un'entità è membro di un determinato gruppo. Poiché sia un gruppo che un utente possono essere rappresentati da un indirizzo email, il seguente metodo può essere utilizzato per verificare se uno dei due appartiene a un determinato gruppo.

/**
 * 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;
}