Exporte verwalten

Mit der Vault API können Sie Vault-Exporte verwalten. Sie haben folgende Optionen:

• Exporte erstellen: Senden Sie eine Anfrage an Vault, die die Nachrichten oder Dateien, die Ihrer Abfrage entsprechen, findet und nach Google Cloud exportiert.

  Hinweis:Innerhalb Ihrer Organisation können maximal 20 Exporte laufen. Teilen Sie große Exporte in kleinere Exporte auf, um die Leistung zu verbessern. So können Sie beispielsweise den Export nach Monaten aufteilen, anstatt alles auf einmal zu exportieren. Ein weiteres Beispiel ist, weniger Entitäten (z. B. Nutzer und spezielle Entitäten wie Gruppen, Chatbereiche usw.) in jeden Export aufzunehmen.

  Beispiele:

  • Nachrichten in Gmail und im klassischen Hangouts
  • Drive-Elemente
  • Meet-Aufzeichnungen
  • Aus einer gespeicherten Abfrage exportieren

• Exporte auflisten: Rufen Sie den Status aller Exporte ab, die mit einer Rechtsangelegenheit verknüpft sind.

• Exporte abrufen: Informationen zu einem Export abrufen

• Exporte herunterladen: Laden Sie einen Export aus Google Cloud herunter.

• Exporte löschen: Hiermit werden Exporte aus einer Rechtsangelegenheit entfernt, wenn sie nicht mehr benötigt werden.

Hinweis

Gehen Sie die Kurzanleitung für Ihre Programmiersprache durch, um die erforderlichen Bibliotheken und die Authentifizierung einzurichten.

Damit Sie mit Vault-Ressourcen arbeiten können, muss das Konto die erforderlichen Vault-Berechtigungen und Zugriff auf die Rechtsangelegenheit haben. Um auf eine Rechtsangelegenheit zuzugreifen, muss das Konto diese erstellt haben, die Rechtsangelegenheit für sie freigegeben haben oder die Berechtigung Alle Rechtsangelegenheiten abrufen haben.

Gmail-Export erstellen

Das folgende Beispiel zeigt, wie ein Gmail-Export erstellt wird. Mit dieser Anfrage werden alle Nachrichten aus Gmail und dem klassischen Hangouts exportiert, die die folgenden Kriterien erfüllen:

• Nachrichten der Konten email1 und email2
• schließt Nachrichtenentwürfe aus.
• an ceo@solarmora.com gesendete Nachrichten.

Tipp:In diesen Beispielen wird das klassische Gmail-Exportsystem verwendet. Für den Export mit dem neuen Exportsystem müssen Sie in MailExportOptions für useNewExport den Wert "true" festlegen.

public Export createMailAccountHeldDataExports(Vault client, String matterId) {
  AccountInfo emailsToSearch = new AccountInfo().setEmails(ImmutableList.of("email1", "email2"));
  MailOptions mailQueryOptions = new MailOptions().setExportFormat("PST");
  String queryTerms = "to:ceo@solarmora.com";
  Query mailQuery =
      new Query()
          .setCorpus("MAIL")
          .setDataScope("HELD_DATA")
          .setSearchMethod("ACCOUNT")
          .setAccountInfo(emailsToSearch)
          .setTerms(queryTerms)
          .setMailOptions(mailQueryOptions);
  MailExportOptions mailExportOptions =
      new MailExportOptions()
          .setExportFormat("MBOX")
          .showConfidentialModeContent(true);
  Export wantedExport =
      new Export()
          .setMatterId(matterId)
          .setName("My first mail accounts export")
          .setQuery(mailQuery)
          .setExportOptions(new ExportOptions().setMailOptions(mailExportOptions));
  return client.matters().exports().create(matter, wantedExport).execute();
}

def create_mail_account_held_data_export(service, matter_id):
  emails_to_search = ['email1', 'email2']
  mail_query_options = {'excludeDrafts': True}
  query_terms = 'to:ceo@solarmora.com'
  mail_query = {
      'corpus': 'MAIL',
      'dataScope': 'HELD_DATA',
      'searchMethod': 'ACCOUNT',
      'accountInfo': {
          'emails': emails_to_search
      },
      'terms': query_terms,
      'mailOptions': mail_query_options,
  }
  mail_export_options = {
      'exportFormat': 'MBOX',
      'showConfidentialModeContent': True
      }
  wanted_export = {
      'name': 'My first mail accounts export',
      'query': mail_query,
      'exportOptions': {
          'mailOptions': mail_export_options
  }
}
return service.matters().exports().create(
  matterId=matter_id, body=wanted_export).execute()

Drive-Export erstellen

Das folgende Beispiel zeigt, wie Sie einen Drive-Export erstellen. Mit dieser Anfrage werden alle Dateien exportiert, einschließlich der Dateien in geteilten Ablagen, die die folgenden Kriterien erfüllen:

• zur angegebenen Organisationseinheit gehören (über das Admin SDK abgerufen).

• wurden zwischen den angegebenen Zeiten erstellt.

public Export createDriveOuAllDataExport(Vault client, String matterId) {
  OrgUnitInfo ouToSearch = new OrgUnitInfo().setOrgUnitId("ou id retrieved from admin sdk");
  DriveOptions driveQueryOptions = new DriveOptions().setIncludeSharedDrives(true);
  Query driveQuery =
      new Query()
          .setCorpus("DRIVE")
          .setDataScope("ALL_DATA")
          .setSearchMethod("ORG_UNIT")
          .setOrgUnitInfo(ouToSearch)
          .setDriveOptions(driveQueryOptions)
          .setStartTime("2017-03-16T00:00:00Z")
          .setEndTime("2017-03-16T00:00:00Z")
          .setTimeZone("Etc/GMT+2");
  DriveExportOptions driveExportOptions = new DriveExportOptions().setIncludeAccessInfo(false);
  Export wantedExport =
      new Export()
          .setName("My first drive ou export")
          .setQuery(driveQuery)
          .setExportOptions(new ExportOptions().setDriveOptions(driveExportOptions));
  return client.matters().exports().create(matter, wantedExport).execute();
}

def create_drive_ou_all_data_export(service, matter_id):
  ou_to_search = 'ou id retrieved from admin sdk'
  drive_query_options = {'includeSharedDrives': True}
  drive_query = {
    'corpus': 'DRIVE',
    'dataScope': 'ALL_DATA',
    'searchMethod': 'ORG_UNIT',
    'orgUnitInfo': {
        'org_unit_id': ou_to_search
    },
    'driveOptions': drive_query_options,
    'startTime': '2017-03-16T00:00:00Z',
    'endTime': '2017-09-23T00:00:00Z',
    'timeZone': 'Etc/GMT+2'
  }
  drive_export_options = {'includeAccessInfo': False}
  wanted_export = {
    'name': 'My first drive ou export',
    'query': drive_query,
    'exportOptions': {
        'driveOptions': drive_export_options
    }
  }
return service.matters().exports().create(
  matterId=matter_id, body=wanted_export).execute()

Meet-Export erstellen

Das folgende Beispiel zeigt, wie Sie einen Meet-Export erstellen. In dieser Anfrage werden Dateien exportiert, die mit Konten in der angegebenen Organisationseinheit verknüpft sind, deren Dateinamen dem Muster für Meet-Aufzeichnungen entsprechen.

def create_meet_export(service, matter_id, ou_to_search, export_name):
  export = {
    'name': export_name,
    'query': {
        'corpus': 'DRIVE',
        'dataScope': 'ALL_DATA',
        'searchMethod': 'ORG_UNIT',
        'terms': 'title:"...-...-... \\(....-..-.. at ..:.. *\\)"',
        'orgUnitInfo': {
            'orgUnitId': 'id:'+ou_to_search
        },
        'driveOptions': {
            'includeTeamDrives': True,
            'includeSharedDrives': True
        },
        'timeZone': 'Etc/GMT',
        'method': 'ORG_UNIT'
    },
    'exportOptions': {
        'driveOptions': {},
        'region': 'ANY'
    },
  }

  return service.matters().exports().create(
    matterId=matter_id, body=export).execute()

Aus einer gespeicherten Abfrage exportieren

Das folgende Beispiel zeigt, wie Sie einen Export aus einer gespeicherten Abfrage erstellen.

def create_mail_export_from_saved_query(service, matter_id, saved_query_id, export_name):
  export = {
    'name': export_name,
    'exportOptions': {
      'mailOptions': {
        'exportFormat': 'PST',
        'showConfidentialModeContent': True
      },
    'region': 'ANY'
    }
  }

  export['query'] = service.matters().savedQueries().get(
    savedQueryId=saved_query_id, matterId=matter_id).execute()['query']
  return service.matters().exports().create(
    matterId=matter_id, body=export).execute()

Exporte auflisten

Das folgende Beispiel zeigt, wie Sie eine Liste der Exporte abrufen, die mit einer Rechtsangelegenheit verknüpft sind.

public class exports {
  public ListExportsResponse listExports(Vault client, String matterId) {
    return client.matters().exports().list(matterId).execute();
}

def list_exports(service, matter_id):
 return service.matters().exports().list(matterId=matter_id).execute()

Informationen zu einem Export abrufen

Das folgende Beispiel zeigt, wie Sie Informationen zu einem bestimmten Export abrufen. Hinweis: Zum Herunterladen exportierter Dateien und Nachrichten verwenden Sie Cloud APIs (im nächsten Beispiel).

public Export getExportById(Vault client, String matterId, String exportId) {
  return client.matters().exports().get(matterId, exportId).execute();
}

def get_export_by_id(service, matter_id, export_id):
  return service.matters().exports().get(
    matterId=matter_id, exportId=export_id).execute()

Export aus Google Cloud herunterladen

Das folgende Beispiel zeigt, wie Sie alle abgeschlossenen Exporte in einer Rechtsangelegenheit von Google Cloud herunterladen können. Diese Anfrage verwendet Vault und Cloud APIs.

Hinweis:Zum Herunterladen eines Exports benötigt ein Konto die Berechtigung „Exporte verwalten“ und die für ihn freigegebene Rechtsangelegenheit.

def download_exports(service, matter_id):
"""Google Cloud storage service is authenticated by running
`gcloud auth application-default login` and expects a billing enabled project
in ENV variable `GOOGLE_CLOUD_PROJECT` """
gcpClient = storage.Client()
matter_id = os.environ['MATTERID']
  for export in vaultService.matters().exports().list(
      matterId=matter_id).execute()['exports']:
    if 'cloudStorageSink' in export:
      directory = export['name']
      if not os.path.exists(directory):
        os.makedirs(directory)
      print(export['id'])
      for sinkFile in export['cloudStorageSink']['files']:
        filename = '%s/%s' % (directory, sinkFile['objectName'].split('/')[-1])
        objectURI = 'gs://%s/%s' % (sinkFile['bucketName'],
                                    sinkFile['objectName'])
        print('get %s to %s' % (objectURI, filename))
        gcpClient.download_blob_to_file(objectURI, open(filename, 'wb+'))

Export löschen

Das folgende Beispiel zeigt, wie ein Export gelöscht wird.

public void deleteExportById(Vault client, String matterId, String exportId) {
   client.matters().exports().delete(matterId, exportId).execute();

def delete_export_by_id(service, matter_id, export_id):
  return service.matters().exports().delete(
    matterId=matter_id, exportId=export_id).execute()

App-spezifische Informationen zum Suchen und Exportieren, einschließlich Suchbeschränkungen, finden Sie im Hilfeartikel Einstieg in die Such- und Exportfunktionen in Vault.