Zarządzanie blokadami

Blokady umożliwiają przechowywanie danych bez ograniczeń czasowych ze względu na zobowiązania prawne i zobowiązania do ochrony danych. Blokady są zwykle nakładane na co najmniej 1 użytkownika, aby zapewnić, że dane potencjalnie istotne dla danej sprawy nie zostaną usunięte, dopóki ta sprawa nie przestanie być aktywna.

Jeśli użytkownik objęty blokadą usunie zablokowane dane, zostaną one usunięte z widoku użytkownika, ale zachowane w Vault. Jeśli blokada jest aktywna, administrator Vault może wyszukiwać i eksportować te dane.

Blokady mają te komponenty:

• Usługa – aplikacja odpowiedzialna za przechowywanie danych. Usługa może być ustawiona na pocztę, Dysk lub Grupy dyskusyjne.
• Zakres – jednostki objęte blokadą. Zakres może obejmować jedno lub więcej kont użytkowników albo jednostkę organizacyjną (OU).
• Opcje dodatkowe (opcjonalne) – szczegółowe informacje (zapytania wyszukiwania lub opcje konfiguracji) służące do zawężenia zakresu danych do określonych granic. Dostępne opcje:
  • mail, Groups: search query to narrow down the hold
  • Dysk: uwzględnianie dysków współdzielonych w blokadzie

Aby pracować z zasobami Vault, konto musi mieć wymagane uprawnienia Vault i dostęp do sprawy. Aby uzyskać dostęp do sprawy, konto musi być jej twórcą, sprawa musi być udostępniona temu kontu lub konto musi mieć uprawnienie Wyświetlanie wszystkich spraw.

Utwórz blokadę poczty na określonych kontach użytkowników za pomocą zapytania wyszukiwania

Ten przykład pokazuje, jak utworzyć blokadę o nazwie „Moja pierwsza blokada kont poczty” dla:

• Usługa: poczta
• Element: konta użytkowników „user1” i „user2”
• Opcje dodatkowe: zapytanie „to:ceo@firma.com”

Pobierz identyfikatory kont użytkowników z pakietu AdminSdk. Pamiętaj, że możesz podać identyfikator konta lub adres e-mail. Jeśli podasz oba te parametry, adres e-mail będzie używany, a identyfikator konta zostanie zignorowany.

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

Tworzenie blokady na Dysku w jednostce organizacyjnej i uwzględnianie treści z dysku współdzielonego

Ten przykład pokazuje, jak utworzyć blokadę o nazwie „Moja pierwsza blokada OU na Dysku” dla:

• Usługa: Dysk
• Element: jednostka organizacyjna „Finanse” (identyfikator OU jest zapisany w polu orgUnitId)
• Opcje dodatkowe: uwzględnij dyski współdzielone, których użytkownikami są użytkownicy w tej jednostce organizacyjnej

Pobierz identyfikatory jednostek organizacyjnych z 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()

Tworzenie blokady Grup dyskusyjnych na określonych kontach grupowych z zakresem dat

Ten przykład pokazuje, jak utworzyć blokadę o nazwie „Moja pierwsza blokada grupowa” dla:

• Usługa: Grupy dyskusyjne
• Element: konta grupowe „group1” i „group2”
• Opcje dodatkowe: blokuj tylko wiadomości wysłane między „startTime” i „endTime”

Pobierz identyfikatory grup kont z 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 sygnatury czasowej. Dodatkowo czasy rozpoczęcia i zakończenia są konwertowane na czas GMT i zaokrąglane w dół do początku danej daty.

Przesyłanie zapytań o istniejące blokady i modyfikowanie ich

W tym przykładzie pokazujemy, jak wyświetlić wszystkie konta objęte istniejącym wstrzymaniem:

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

Z tego przykładu dowiesz się, jak dodać konto do istniejącego zawieszenia i z niego je usunąć:

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

Z tego przykładu dowiesz się, jak zmienić jednostkę organizacyjną w przypadku istniejącej jednostki organizacyjnej objętej blokadą:

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

Ten przykład pokazuje, jak wyświetlić wszystkie blokady dotyczące sprawy:

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