Gestisci i blocchi

Le conservazioni conservano i dati a tempo indeterminato per adempiere a obbligazioni di legge o di conservazione. Di solito, i blocchi vengono applicati a uno o più utenti per garantire che i dati potenzialmente pertinenti a una pratica non possano essere eliminati finché la pratica non è più attiva.

Se un utente soggetto a un blocco elimina dati sottoposti a blocco, questi vengono rimossi dalla sua visualizzazione, ma vengono conservati in Vault. Finché l'archiviazione a fini legali è in vigore, un amministratore di Vault può cercare ed esportare questi dati.

Le archiviazioni a fini legali hanno i seguenti componenti:

• Un servizio: l'applicazione responsabile della conservazione dei dati. Il servizio può essere impostato su Posta, Drive o Gruppi.
• Un ambito: le entità coperte dalla conservazione. L'ambito può essere impostato su uno o più account utente o su un'unità organizzativa (UO).
• Opzioni aggiuntive (facoltativo): i dettagli specifici (query di ricerca o opzioni di configurazione) utilizzati per limitare i dati da includere nell'ambito definito. Le opzioni disponibili sono le seguenti:
  • mail, Gruppi: query di ricerca per restringere il blocco
  • Drive: includi i Drive condivisi nella conservazione

Per utilizzare le risorse Vault, l'account deve disporre del servizio Vault richiesto privilegiati e l'accesso sono importanti. Per accedere a una pratica, l'account deve aver creato la pratica, disporre delle pratica condivisa con loro o disporre del privilegio Visualizzazione di tutte le pratiche.

Creare un blocco per la posta su account utente specifici mediante una query di ricerca

L'esempio seguente mostra come una conservazione denominata "I miei primi account di posta" è creato per:

• Servizio: posta
• Entità: account utente "user1" e "utente2"
• Opzioni aggiuntive: query di ricerca "to:ceo@azienda.com"

Recupera gli ID account utente da AdminSdk. Tieni presente che L'account Held Account può includere l'ID account o l'indirizzo email. Se vengono forniti entrambi, viene utilizzato l'indirizzo email mentre l'ID account viene ignorato.

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 un blocco per Drive in una UO e includi i contenuti dei Drive condivisi

L'esempio seguente mostra come una conservazione denominata "Blocco UO Il mio primo Drive" è creato per:

• Servizio: Drive
• Entità: unità organizzativa "Finanza" (L'ID UO viene acquisito in orgUnitId)
• Opzioni aggiuntive: includi i Drive condivisi di cui gli utenti di questa unità organizzativa sono membri

Recupera gli ID UO da 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()

Creare un blocco per Gruppi su account di gruppo specifici con un intervallo di date

L'esempio seguente mostra come una conservazione denominata "Primo gruppo" è creato per:

• Servizio: Gruppi
• Entità: account di gruppo "group1" e "group2"
• Opzioni aggiuntive: archivia solo i messaggi con date di invio comprese tra "startTime" ed "endTime"

Recupera gli ID degli account del gruppo da 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 del timestamp. Inoltre, gli orari di inizio/fine vengono convertiti in GMT e arrotondati per difetto all'inizio della data specificata.

Query e modifica di archiviazioni a fini legali esistenti

Nell'esempio seguente viene illustrato come elencare tutti gli account inclusi in una conservazione esistente:

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'esempio seguente mostra come aggiungere e rimuovere un account da una sospensione esistente:

// 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'esempio seguente mostra come modificare l'UO in una conservazione dell'UO esistente:

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'esempio seguente mostra come elencare tutte le conservazioni per una pratica:

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