Gérer les obligations de conservation

Les obligations de conservation permettent de conserver les données indéfiniment pour répondre à des obligations légales ou de conservation. Les obligations de conservation sont généralement appliquées à un ou plusieurs utilisateurs afin de s'assurer que les données potentiellement pertinentes ne peuvent pas être supprimées tant que ce litige n'est pas inactif.

Si un utilisateur soumis à une obligation de conservation supprime des données sous obligation de conservation, ces données sont supprimées de la vue de l'utilisateur, mais sont conservées dans Vault. Tant que l'obligation de conservation reste en vigueur, un administrateur Vault peut rechercher et exporter ces données.

Les obligations de conservation se composent des éléments suivants:

• Un service : l'application responsable des données devant être conservées. Le service peut être défini sur "Messagerie", "Drive" ou "Groupes".
• Un champ d'application : il s'agit des entités concernées par l'obligation de conservation. Le champ d'application peut être défini sur un ou plusieurs comptes utilisateur, ou sur une unité organisationnelle (UO).
• Options supplémentaires (facultatif) : détails spécifiques (requêtes de recherche ou options de configuration) utilisés pour affiner les données devant être conservées dans le champ d'application défini. Les options sont les suivantes :
  • messagerie, Groupes: requête de recherche pour restreindre l'obligation de conservation
  • Drive: inclure les Drive partagés dans l'obligation de conservation

Pour utiliser les ressources Vault, le compte doit disposer des droits Vault requis et avoir accès au litige. Pour pouvoir accéder à un litige, le compte doit l'avoir créé, avoir partagé le litige avec lui ou disposer du droit Afficher tous les litiges.

Créer une obligation de conservation des messages de comptes utilisateur spécifiques avec une requête de recherche

L'exemple suivant illustre la création d'une obligation de conservation intitulée "Ma première obligation de conservation des comptes de messagerie" :

• Service: messagerie
• Entité: comptes utilisateur "utilisateur1" et "utilisateur2"
• Options supplémentaires: requête de recherche "to:ceo@company.com"

Récupérez les ID de compte utilisateur à partir de AdminSdk. Notez que l'élément HeldAccount peut prendre en compte l'ID de compte ou l'adresse e-mail. Si les deux sont fournis, l'adresse e-mail est utilisée et l'ID de compte est ignoré.

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()

Créer une obligation de conservation pour Drive dans une UO et inclure le contenu de Drive partagés

L'exemple suivant montre comment une obligation de conservation intitulée "Ma première obligation de conservation de l'UO Drive" est créée:

• Service: Drive
• Entité: unité organisationnelle "Finance" (l'ID d'UO est capturé dans orgUnitId)
• Options supplémentaires: inclure les Drive partagés dont les utilisateurs de cette unité organisationnelle sont membres

Récupérez les ID d'UO à partir 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()

Créer une obligation de conservation pour Groupes sur des comptes de groupe spécifiques avec une plage de dates

L'exemple suivant montre comment une obligation de conservation intitulée "Mon première obligation de conservation appliquée au groupe" est créée:

• Service: Groupes
• Entité: comptes de groupe "group1" et "group2"
• Options supplémentaires: conserver uniquement les messages dont la date d'envoi est comprise entre "startTime" et "endTime"

Récupérez les ID de compte de groupe à partir 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()
 

• Format du code temporel. De plus, les heures de début et de fin sont converties au format GMT et arrondies au début de la date donnée.

Interroger et modifier les obligations de conservation existantes

L'exemple suivant montre comment répertorier tous les comptes inclus dans une obligation de conservation existante:

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'] 

L'exemple suivant montre comment ajouter un compte à un blocage existant et en supprimer un:

// 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()
 

L'exemple suivant montre comment modifier l'UO d'une obligation de conservation existante:

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() 

L'exemple suivant montre comment répertorier toutes les obligations de conservation d'un litige:

 
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()