Gestisci i blocchi

I blocchi conservano i dati per un periodo di tempo indefinito al fine di adempiere a obblighi di legge o di conservazione a fini legali. In genere, le sospensioni vengono applicate a uno o più utenti per garantire che i dati potenzialmente pertinenti a una questione non possano essere eliminati finché la questione non è più attiva.

Se un utente a cui viene applicato un blocco elimina i dati bloccati, questi vengono rimossi dalla visualizzazione dell'utente, ma vengono conservati in Vault. Fintanto che il blocco sarà in vigore, un amministratore di Vault potrà cercare ed esportare i dati.

Le sospensioni hanno i seguenti componenti:

• Un servizio: l'applicazione responsabile dei dati da conservare. 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 (OU).
• Opzioni aggiuntive (facoltative): i dettagli specifici (query di ricerca o opzioni di configurazione) utilizzati per restringere i dati da conservare nell'ambito definito. Le opzioni includono:
  • mail, gruppi: query di ricerca per restringere la sospensione
  • Drive: includi i Drive condivisi nella sospensione

Per utilizzare le risorse di Vault, l'account deve disporre dei privilegi di Vault obbligatori e dell'accesso alla questione. Per accedere a una pratica, l'account deve averla creata, deve averla condivisa con l'account o disporre del privilegio Visualizzazione di tutte le pratiche.

Creare una sospensione della posta su account utente specifici con una query di ricerca

L'esempio seguente mostra come viene creata una sospensione denominata "La mia prima sospensione degli account email" per:

• Servizio: mail
• Entità: account utente "utente1" e "utente2"
• Opzioni aggiuntive: query di ricerca "to:ceo@company.com"

Recupera gli ID account utente da AdminSdk. Tieni presente che HeldAccount può accettare l'ID account o l'email. Se vengono forniti entrambi, viene utilizzato l'indirizzo email e 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()

Creare una sospensione per Drive in un'OU e includere i contenuti dei Drive condivisi

L'esempio seguente mostra come viene creata una sospensione denominata "My First Drive OU Hold" per:

• Servizio: Drive
• Entità: unità organizzativa "Finanza" (l'ID OU viene acquisito in orgUnitId)
• Opzioni aggiuntive: includi i Drive condivisi di cui fanno parte gli utenti di questa unità organizzativa

Recupera gli ID OU 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 una sospensione per i gruppi in account di gruppo specifici con un intervallo di date

L'esempio seguente mostra come viene creata una prenotazione denominata "La mia prima prenotazione di gruppo" per:

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

Recupera gli ID gruppo dall'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 intervalli di tempo start/end vengono convertiti in GMT e arrotondati per difetto all'inizio della data specificata.

Esegui query e modifica le sospensioni esistenti

L'esempio seguente mostra come elencare tutti gli account inclusi in una sospensione 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 un account a una sospensione esistente e rimuoverlo:

// 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'OU in una sospensione dell'OU 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 sospensioni per una richiesta:

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