Gérer les obligations de conservation

Les obligations de conservation permettent de conserver indéfiniment les données afin de satisfaire aux exigences juridiques ou de conservation. En général, des obligations de conservation sont appliquées à un ou plusieurs utilisateurs pour s'assurer que les données potentiellement pertinentes pour une affaire ne peuvent pas être supprimées tant qu'elle n'est plus active.

Si un utilisateur faisant l'objet d'une obligation de conservation supprime des données conservées, 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 retenues comportent les composants suivants:

• Un service : application responsable des données à conserver. Le service peut être défini sur Mail, Drive ou Groupes.
• Champ d'application : entités concernées par la retenue. Le champ d'application peut être défini sur un ou plusieurs comptes utilisateur, ou sur une unité organisationnelle (UO).
• Options supplémentaires (facultatif) : informations spécifiques (requêtes de recherche ou options de configuration) utilisées pour affiner les données à conserver dans le champ d'application défini. Voici quelques exemples :
  • mail, Groups: search query to narrow down the hold
  • Drive: inclure les Drive partagés dans la retenue

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

Créer une retenue pour le courrier sur des comptes utilisateur spécifiques à l'aide d'une requête de recherche

L'exemple suivant montre comment créer une retenue nommée "My First mail Accounts Hold" (Ma première retenue sur les comptes de messagerie) pour:

• Service: mail
• Entité: comptes utilisateur "user1" et "user2"
• Autres options: requête de recherche "to:[email protected]"

Récupérez les ID de compte utilisateur à partir de AdminSdk. Notez que le compte détenu peut accepter 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:[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()

Créer une retenue pour Drive dans une UO et inclure le contenu de Drive partagé

L'exemple suivant montre comment créer une retenue nommée "My First Drive OU Hold" pour:

• Service: Drive
• Entité: unité organisationnelle "Finance" (l'ID de l'unité organisationnelle 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 d'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 créer une retenue nommée "My First Group Hold" (Ma première retenue de groupe) pour:

• Service: Groupes
• Entité: comptes de groupe "group1" et "group2"
• Options supplémentaires: ne conserver que les messages dont la date d'envoi se situe 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 d'horodatage De plus, les heures de début et de fin sont converties au format GMT et arrondies à la baisse à la date de début donnée.

Interroger et modifier des retenues existantes

L'exemple suivant montre comment lister tous les comptes inclus dans une retenue 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 à une retenue existante 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 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()
 

L'exemple suivant montre comment modifier l'UO d'une retenue d'UO 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 lister toutes les retenues pour une demande:

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