Zarządzanie blokadami

Blokady służą do przechowywania danych bez ograniczeń czasowych ze względu na zobowiązania prawne i zobowiązania do ochrony danych. Zazwyczaj blokady są nakładane na co najmniej jednego użytkownika, dzięki czemu dane potencjalnie istotne w związku ze sprawą nie mogą zostać usunięte, dopóki sprawa nie stanie się aktywna.

Jeśli użytkownik usunie zablokowane dane objęte blokadą, dane te nie będą już widoczne dla użytkownika, ale pozostaną w Vault. Jeśli blokada jest aktywna, administrator Vault może wyszukiwać i eksportować dane.

Blokady składają się z tych elementów:

• Usługa – aplikacja odpowiedzialna za dane, które mają być przechowywane. Jako usługę możesz ustawić pocztę, Dysk lub Grupy dyskusyjne.
• Zakres – elementy objęte blokadą. Zakres może obejmować jedno lub więcej kont użytkowników albo jednostkę organizacyjną.
• Opcje dodatkowe (opcjonalne) – konkretne informacje (zapytania lub opcje konfiguracji) używane do zawężania danych, które mają być przechowywane w zdefiniowanym zakresie. Dostępne opcje:
  • poczta, Grupy dyskusyjne: zapytanie w celu zawężania blokady
  • Dysk: uwzględnij dyski współdzielone w blokadzie

Aby korzystać z zasobów Vault, konto musi mieć wymagane uprawnienia w Vault i dostęp do sprawy. Aby uzyskać dostęp do sprawy, użytkownik konta musi utworzyć sprawę, udostępnić ją osobie lub mieć uprawnienie do wyświetlania wszystkich spraw.

Tworzenie blokad poczty na określonych kontach użytkowników za pomocą zapytania

Poniższy przykład pokazuje, jak utworzyć blokadę o nazwie „Moja pierwsza blokada kont pocztowych” dla:

• Usługa: poczta
• Jednostka: konta użytkowników „użytkownik1” i „użytkownik2”
• Opcje dodatkowe: wyszukiwane hasło „to:ceo@firma.com”

Pobierz identyfikatory kont użytkowników z AdminSdk. Pamiętaj, że HeldAccount może przyjmować identyfikator lub adres e-mail konta. Jeśli podano oba, używany jest adres e-mail, a identyfikator konta jest ignorowany.

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 Dysku w jednostce organizacyjnej i dołączanie treści z dysków współdzielonych

Poniższy przykład pokazuje, jak utworzyć blokadę o nazwie „Moja pierwsza blokada jednostki organizacyjnej na Dysku” dla:

• Usługa: Dysk
• Jednostka: jednostka organizacyjna „Finance” (identyfikator jednostki organizacyjnej jest rejestrowany w identyfikatorze jednostki organizacyjnej)
• Dodatkowe opcje: uwzględnij dyski współdzielone, do których należą 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 dla Grup dyskusyjnych na określonych kontach grup z zakresem dat

Poniższy przykład pokazuje, jak utworzyć blokadę o nazwie „Moja pierwsza blokada grupy” w przypadku:

• Usługa: grupy
• Jednostka: konta grupy „group1” i „group2”
• Dodatkowe opcje: blokowanie tylko wiadomości z datami wysłania między „startTime” a „endTime”

Pobierz identyfikatory kont grup 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 godziny rozpoczęcia i zakończenia są przeliczane na czas GMT i zaokrąglane w dół do początku określonej daty.

Wysyłanie zapytań i modyfikowanie istniejących blokad

Poniższy przykład pokazuje, jak wyświetlić listę wszystkich kont objętych istniejącą blokadą:

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

Poniższy przykład pokazuje, jak dodać konto do istniejącej blokady i ją z niej 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()
 

Poniższy przykład pokazuje, jak zmodyfikować jednostkę organizacyjną w istniejącej blokady jednostki organizacyjnej:

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ć listę wszystkich blokad związanych z daną sprawą:

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