Administrar conservaciones

Las conservaciones preservan los datos de forma indefinida para satisfacer obligaciones legales o de conservación. Por lo general, se aplican retenciones a uno o más usuarios para garantizar que los datos potencialmente relevantes para un asunto no se puedan borrar hasta que ese asunto ya no esté activo.

Si un usuario sujeto a una retención borra datos retenidos, estos se quitan de su vista, pero se conservan en Vault. Mientras la retención esté vigente, un administrador de Vault podrá buscar y exportar esos datos.

Las retenciones tienen los siguientes componentes:

• Un servicio: Es la aplicación responsable de los datos que se almacenarán. El servicio se puede configurar en Correo, Drive o Grupos.
• Un alcance: Las entidades que cubre la retención. El alcance se puede establecer en una o más cuentas de usuario, o en una unidad organizativa (UO).
• Opciones adicionales (opcional): Son los detalles específicos (consultas de búsqueda o opciones de configuración) que se usan para acotar los datos que se conservarán dentro del alcance definido. Estas son algunas de las opciones disponibles:
  • correo electrónico, Grupos: Búsqueda para acotar la retención
  • Drive: Se incluyen las unidades compartidas en la retención

Para trabajar con los recursos de Vault, la cuenta debe tener los privilegios de Vault necesarios y acceso al asunto. Para acceder a un asunto, la cuenta debe haberlo creado, compartirlo con ella o tener el privilegio Ver todos los asuntos.

Crea una retención de correo en cuentas de usuario específicas con una búsqueda

En el siguiente ejemplo, se muestra cómo se crea una retención llamada "Mi primera retención de cuentas de correo electrónico" para lo siguiente:

• Servicio: correo electrónico
• Entidad: cuentas de usuario "user1" y "user2"
• Opciones adicionales: Búsqueda "to:[email protected]"

Recupera los IDs de las cuentas de usuario de AdminSdk. Ten en cuenta que la cuenta retenida puede tener en cuenta el ID o el correo electrónico. Si se proporcionan ambos, se usa el correo electrónico y se ignora el ID de la cuenta.

HeldMailQuery mailQuery = new HeldMailQuery().setTerms("to:[email protected]");
List accounts = Lists.newArrayList();
accounts.add(new HeldAccount().setAccountId(user1accountId));
accounts.add(new HeldAccount().setEmail(user2Email));
Hold hold = new Hold()
    .setName("My First mail Accounts Hold")
    .setCorpus("MAIL");
    .setQuery(new CorpusQuery().setMailQuery(mailQuery))
    .setAccounts(accounts);
Hold createdHold = client.matters().holds().create(matterId, hold).execute();
  

def create_hold_mail_accounts(service, matter_id, account_id):
    mail_query = {'terms': 'to:[email protected]'}
    accounts = [
        {'accountId': user1_account_id},
        {'email': user2_email}
    ]
    wanted_hold = {
        'name': 'My First mail Accounts Hold',
        'corpus': 'MAIL',
        'query': {
            'mailQuery': mail_query
        },
        'accounts': accounts
    }
    return service.matters().holds().create(
        matterId=matter_id, body=wanted_hold).execute()

Crea una retención para Drive en una UO y, luego, incluye contenido de unidades compartidas

En el siguiente ejemplo, se muestra cómo se crea una retención llamada "Mi primera retención de UO de Drive" para lo siguiente:

• Servicio: Drive
• Entidad: Unidad organizativa “Finanzas” (el ID de la UO se captura en orgUnitId)
• Opciones adicionales: Incluye unidades compartidas de las que sean miembros los usuarios de esta unidad organizativa.

Recupera los IDs de UO de AdminSdk.

HeldOrgUnit orgUnit = new HeldOrgUnit().setOrgUnitId(orgUnitId);
// Include shared drives content.
HeldDriveQuery driveQuery = new HeldDriveQuery().setIncludeSharedDriveFiles(true);
// Create the hold.
Hold hold = new Hold()
    .setName("My First Drive OU Hold")
    .setCorpus("DRIVE")
    .setQuery(new CorpusQuery().setDriveQuery(driveQuery))
    .setOrgUnit(orgUnit);
Hold createdHold = client.matters().holds().create(matterId, hold).execute();
return createdHold;

def create_hold_drive_org(service, matter_id, org_unit_id):
    drive_query = {'includeSharedDriveFiles': True}
    org_unit = {'orgUnitId': org_unit_id}
    wanted_hold = {
        'name': 'My First Drive OU Hold',
        'corpus': 'DRIVE',
        'orgUnit': org_unit,
        'query': {
            'driveQuery': drive_query
        }
    }
    return service.matters().holds().create(
        matterId=matter_id, body=wanted_hold).execute()

Crea una retención para Grupos en cuentas de grupos específicas con un período

En el siguiente ejemplo, se muestra cómo se crea una retención llamada "Mi primera retención de grupo" para lo siguiente:

• Servicio: Grupos
• Entidad: cuentas de grupo "group1" y "group2"
• Opciones adicionales: retiene solo los mensajes con fechas de envío entre "startTime" y "endTime".

Recupera los IDs de las cuentas de grupo de AdminSdk.

String APRIL_2_2017_GMT = "2017-04-02T00:00:00Z"; // See below for format*.
 
List accounts = Lists.newArrayList();
accounts.add(new HeldAccount().setAccountId(accountId));
accounts.add(new HeldAccount().setAccountId(accountId2));
HeldGroupsQuery groupQuery = new HeldGroupsQuery();
// Restrict by sent date.
groupQuery.setStartTime(APRIL_2_2017_GMT);
groupQuery.setEndTime(APRIL_2_2017_GMT);
// create the hold
Hold hold = new Hold()
    .setName("My First Group Hold")
    .setCorpus("GROUPS")
    .setQuery(new CorpusQuery().setGroupsQuery(groupQuery));
    hold.setAccounts(accounts);
Hold createdHold = client.matters().holds().create(matterId, hold).execute();
 

def create_hold_groups_date_range(service, matter_id, group_account_id):
    groups_query = {
        'startTime': '2017-04-02T00:00:00Z', # See below for format*
        'endTime': '2017-04-02T00:00:00Z'
    }
    accounts = [{'accountId': group_account_id}]
    wanted_hold = {
        'name': 'My First Group Hold',
        'corpus': 'GROUPS',
        'query': {
            'groupsQuery': groups_query
        },
        'accounts': accounts
    }
    return service.matters().holds().create(
        matterId=matter_id, body=wanted_hold).execute()
 

• Formato de marca de tiempo: Además, las horas de inicio y finalización se convierten a GMT y se redondean hacia abajo hasta el inicio de la fecha determinada.

Consulta y modifica las retenciones existentes

En el siguiente ejemplo, se muestra cómo enumerar todas las cuentas incluidas en una retención existente:

client.matters().holds().accounts().list(matterId, holdId).execute().getAccounts();

# If no accounts are on hold, ['accounts'] will raise an error.
def list_held_accounts(service, matter_id, hold_id):
    return service.matters().holds().accounts().list(
        matterId=matter_id, holdId=hold_id).execute()['accounts'] 

En el siguiente ejemplo, se muestra cómo agregar una cuenta a una retención existente y quitarla de ella:

// Add an account by id.
client
        .matters()
        .holds()
        .accounts()
        .create(matterId, holdId, new HeldAccount().setAccountId(accountId))
        .execute();
// Remove an account by id.
client.matters().holds().accounts().delete(matterId, holdId, accountId).execute();

String email = "[email protected]";
// Add an account by email.
client
        .matters()
        .holds()
        .accounts()
        .create(matterId, holdId, new HeldAccount().setEmail(email))
        .execute();

 
def add_held_account(service, matter_id, hold_id, account_id):
    held_account = {'accountId': account_id}
    return service.matters().holds().accounts().create(
        matterId=matter_id, holdId=hold_id, body=held_account).execute()

def remove_held_account(service, matter_id, hold_id, account_id):
    return service.matters().holds().accounts().delete(
        matterId=matter_id, holdId=hold_id, accountId=account_id).execute()

def add_held_account(service, matter_id, hold_id, email):
    held_account = {'email': email}
    return service.matters().holds().accounts().create(
        matterId=matter_id, holdId=hold_id, body=held_account).execute()
 

En el siguiente ejemplo, se muestra cómo modificar la UO en una retención de UO existente:

Hold hold = client.matters().holds().get(matterId, holdId).execute();
hold.getOrgUnit().setOrgUnitId(newOrgUnitId);
Hold modifiedHold = client.matters().holds().update(matterId, holdId, hold).execute();
return modifiedHold;
 

def update_hold_ou(service, matter_id, hold_id, org_unit_id):
    current_hold = get_hold(matter_id, hold_id)
    current_hold['orgUnit'] = {'orgUnitId': org_unit_id}
    return service.matters().holds().update(
        matterId=matter_id, holdId=hold_id, body=current_hold).execute() 

En el siguiente ejemplo, se muestra cómo enumerar todas las retenciones de un asunto:

 
String matterId = "Matter Id";


// List all holds.
List holdsList = 
    client.matters().holds().list(matterId).execute().getHolds();

// Paginate on holds.
ListHoldsResponse response = client
        .matters()
        .holds()
        .list(matterId)
        .setPageSize(10)
        .execute();

String nextPageToken = response.getNextPageToken();
if (nextPageToken != null) {
    client
        .matters()
        .holds()
        .list(matterId)
        .setPageSize(10)
        .setPageToken(nextPageToken)
        .execute();
}
  

# This can paginate in the same manner as with matters.
def list_holds(service, matter_id):
    return service.matters().holds().list(matterId=matter_id).execute()