Manage shared drives

This guide contains tasks related to managing shared drives, such as creating shared drives and managing members and permissions.

Create shared drives

Drive driveMetadata = new Drive();
driveMetadata.setName("Project Resources");
String requestId = UUID.randomUUID().toString();
Drive drive = driveService.drives().create(requestId,
    driveMetadata)
    .execute();
System.out.println("Drive ID: " + drive.getId());

drive_metadata = {'name': 'Project Resources'}
request_id = str(uuid.uuid4())
drive = drive_service.drives().create(body=drive_metadata,
                                               requestId=request_id,
                                               fields='id').execute()
print 'Drive ID: %s' % drive.get('id')

var driveMetadata = {
  'name': 'Project resources'
};
var requestId = uuid.v4();
driveService.drives.create({
  resource: driveMetadata,
  requestId: requestId,
  fields: 'id'
}, function (err, drive) {
  if (err) {
    // Handle error
    console.error(err);
  } else {
    console.log('Drive Id: ', drive.id);
  }
});

Calls to drives.create are idempotent. The requestId parameter identifies the logical attempt to create the shared drive. If the request times out or returns an indeterminate backend error, the same request may be repeated. The requestId and body of the request must remain the same.

If the shared drive was successfully created on a previous request or as a result of a retry, the normal response is returned. In some cases, such as after a prolonged period of time or if the body of the request has changed, a 409 error may be returned indicating the requestId must be discarded.

Add or remove shared drive members

Add or remove shared drive members using the permissions API.

To add a member, create the permission on the shared drive itself. Permission methods can also be used on individual files within a shared drive to grant members additional privileges or allow non-members to collaborate on specific items.

See Share files and folders for additional details and sample code.

Delete a shared drive

Use the drives.delete method to delete a shared drive. All content in the shared drive must be trashed or deleted prior to deleting the shared drive.

Manage shared drives for domain administrators

Use the useDomainAdminAccess parameter with the drives and permissions resources to manage shared drives across an organization.

Users calling these methods with useDomainAdminAccess=true must have the Drive and Docs administrator privilege. Administrators can search for shared drives or update permissions for shared drives owned by their organization, regardless of the admin's membership in any given shared drive.

Recover a shared drive that doesn't have an organizer

The following example demonstrates how to use these resources to recover shared drives that no longer have an organizer.

// Find all shared drives without an organizer and add one.
// Note: This example does not capture all cases. Shared drives
// that have an empty group as the sole organizer, or an
// organizer outside the organization are not captured. A
// more exhaustive approach would evaluate each shared drive
// and the associated permissions and groups to ensure an active
// organizer is assigned.
String pageToken = null;
Permission newOrganizerPermission = new Permission()
    .setType("user")
    .setRole("organizer")
    .setEmailAddress("user@example.com");

do {
  DriveList result = driveService.drives().list()
      .setQ("organizerCount = 0")
      .setFields("nextPageToken, drives(id, name)")
      .setUseDomainAdminAccess(true)
      .setPageToken(pageToken)
      .execute();
  for (Drive drive : result.getDrives()) {
    System.out.printf("Found drive without organizer: %s (%s)\n",
        drive.getName(), drive.getId());
    // Note: For improved efficiency, consider batching
    // permission insert requests
    Permission permissionResult = driveService.permissions()
        .create(drive.getId(), newOrganizerPermission)
        .setUseDomainAdminAccess(true)
        .setSupportsAllDrives(true)
        .setFields("id")
        .execute();
    System.out.printf("Added organizer permission: %s\n",
        permissionResult.getId());

  }
  pageToken = result.getNextPageToken();
} while (pageToken != null);

# Find all shared drives without an organizer and add one.
# Note: This example does not capture all cases. Shared drives
# that have an empty group as the sole organizer, or an
# organizer outside the organization are not captured. A
# more exhaustive approach would evaluate each shared drive
# and the associated permissions and groups to ensure an active
# organizer is assigned.
page_token = None
new_organizer_permission = {
    'type': 'user',
    'role': 'organizer',
    'emailAddress': 'user@example.com'
}

while True:
    response = drive_service.drives().list(
            q='organizerCount = 0',
            fields='nextPageToken, drives(id, name)',
            useDomainAdminAccess = True,
            pageToken=page_token).execute()
    for drive in response.get('drives', []):
        print 'Found shared drive without organizer: %s (%s)' % (
            drive.get('title'), drive.get('id'))
        permission = drive_service.permissions().create(
                fileId=drive.get('id'),
                body=new_organizer_permission,
                useDomainAdminAccess = True,
                supportsAllDrives = True,
                fields='id').execute()
        print 'Added organizer permission: %s ' % (permission.get('id'))

    page_token = response.get('nextPageToken', None)
    if page_token is None:
        break

var newOrganizerPermission = {
  type: 'user',
  role: 'organizer',
  emailAddress: 'user@example.com'
};

var pageToken;
// Using the npm module 'async'
async.doWhilst(function (callback) {
  driveService.drives.list({
    q: "organizerCount = 0",
    fields: 'nextPageToken, drives(id, name)',
    useDomainAdminAccess: true,
    pageToken: pageToken
  }, function (err, res) {
    if (err) {
      // Handle error
      console.error(err);
      callback(err)
    } else {
      async.eachSeries(res.drives, function (drive, callback) {
        console.log('Found shared drive without organizer:',
            drive.name, drive.id);
        driveService.permissions.create({
          resource: newOrganizerPermission,
          fileId: drive.id,
          useDomainAdminAccess: true,
          supportsAllDrives: true,
          fields: 'id'
        }, callback);
      }, callback);
      pageToken = res.nextPageToken;
    }
  });
}, function () {
  return !!pageToken;
}, function (err) {
  if (err) {
    // Handle error
    console.error(err);
  } else {
    // All pages fetched
  }
});