Administrar conservaciones

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

Si un usuario sujeto a una conservación borra los datos conservados, estos se quitan de la vista del usuario, pero se conservan en Vault. Siempre que la conservación esté vigente, un administrador de Vault puede buscar y exportar esos datos.

Las conservaciones tienen los siguientes componentes:

• Un servicio: La aplicación responsable de los datos que se conservarán. El servicio se puede configurar como correo, Drive o Grupos.
• Un alcance: Las entidades que abarca la conservación. El permiso 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 (búsquedas o opciones de configuración) que se utilizan para limitar los datos que deben conservarse dentro del alcance definido. Estas son algunas opciones:
  • correo, Grupos: búsqueda para reducir la conservación
  • Drive: Incluye las unidades compartidas en la conservación.

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

Crea una conservación para el correo electrónico de cuentas de usuario específicas con una búsqueda

En el siguiente ejemplo, se muestra cómo se crea una conservación denominada "Suspensión de mis primeras cuentas de correo" para lo siguiente:

• Servicio: mail
• Entidad: Cuentas de usuario "usuario1" y "usuario2"
• Opciones adicionales: consulta de búsqueda "to:ceo@empresa.com"

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

HeldMailQuery mailQuery = new HeldMailQuery().setTerms("to:ceo@company.com");
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:ceo@company.com'}
    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 conservación para Drive en una UO y, además, incluye contenido de la unidad compartida

En el siguiente ejemplo, se muestra cómo se crea una conservación denominada “Mi primera conservación de UO de Drive” para:

• Servicio: Drive
• Entidad: unidad organizativa "Finance" (el ID de la UO se capturó en orgUnitId)
• Opciones adicionales: Incluye unidades compartidas a las que son 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 conservación para los grupos en cuentas de grupo específicas con un período

En el siguiente ejemplo, se muestra cómo se crea una conservación denominada “Mi primera conservación de grupo” para:

• Servicio: Grupos
• Entidad: cuentas de grupo “group1” y “group2”
• Opciones adicionales: Retener solo los mensajes con fechas enviadas entre "startTime" y "endTime"

Recupera IDs de 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, los horarios de inicio y finalización se convierten a GMT y se redondean hacia abajo al inicio de la fecha especificada.

Consulta y modifica conservaciones existentes

En el siguiente ejemplo, se muestra cómo enumerar todas las cuentas incluidas en una conservació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 conservació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@email.com";
// 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 conservació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 conservaciones 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()