(PHP ActiveX) Google Drive - Build a Local Cache of Metadata

This example demonstrates how to download the metadata for all files in a Google Drive account to create a local filesystem cache with the information. The cache can be used to fetch information without having to query Google Drive.

Chilkat ActiveX Downloads ActiveX for 32-bit and 64-bit Windows Note: The php_com_dotnet.dll may need to be enabled inside of php.ini.

<?php

$success = 1;

// It requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

// This example uses a previously obtained access token having permission for the 
// Google Drive scope.

// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.AuthGoogle')
$gAuth = new COM("Chilkat.AuthGoogle");
$gAuth->AccessToken = 'GOOGLE_DRIVE_ACCESS_TOKEN';

// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.Rest')
$rest = new COM("Chilkat.Rest");

// Connect using TLS.
$bAutoReconnect = 1;
$success = $rest->Connect('www.googleapis.com',443,1,$bAutoReconnect);

// Provide the authentication credentials (i.e. the access token)
$rest->SetAuthGoogle($gAuth);

// -------------------------------------------------------------------
// Initialize our cache object.  Indicate the location of the root cache directory, and how many cache levels are to exist.
// For small caches (level 0) all cache files are in the root directory.
// For medium caches (level 1) cache files are located in 256 sub-directories from the root.
// For large caches (level 2) cache files are located in 256x256 sub-directories two levels down from the root.
// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.Cache')
$gdCache = new COM("Chilkat.Cache");
$gdCache->Level = 0;
// Use a root directory that makes sense on your operating system..
$gdCache->AddRoot('C:/ckCache/googleDrive');

// If we are re-building the cache, we can first delete the entire contents of the cache.
$numCacheFilesDeleted = $gdCache->DeleteAll();

// Create a date/time object with an time 7 days from the current date/time.
// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.CkDateTime')
$dtExpire = new COM("Chilkat.CkDateTime");
$dtExpire->SetFromCurrentSystemTime();
$dtExpire->AddDays(7);

// Indicate that we want ALL possible fields.
// If no fields are indicated, then only the basic fields are returned.
$allFields = 'appProperties,capabilities,contentHints,createdTime,description,explicitlyTrashed,fileExtension,folderColorRgb,fullFileExtension,headRevisionId,iconLink,id,imageMediaMetadata,isAppAuthorized,kind,lastModifyingUser,md5Checksum,mimeType,modifiedByMeTime,modifiedTime,name,originalFilename,ownedByMe,owners,parents,permissions,properties,quotaBytesUsed,shared,sharedWithMeTime,sharingUser,size,spaces,starred,thumbnailLink,trashed,version,videoMediaMetadata,viewedByMe,viewedByMeTime,viewersCanCopyContent,webContentLink,webViewLink,writersCanShare';

// We're going to keep a master list of fileId's as we iterate over all the files in this Google Drive account.
// This master list will also be saved to the cache under the key "AllGoogleDriveFileIds".
// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.JsonObject')
$jsonMaster = new COM("Chilkat.JsonObject");
// jsonMasterArr is a Chilkat.JsonArray
$jsonMasterArr = $jsonMaster->AppendArray('fileIds');
// Also keep a list of file paths.
// jsonMasterPaths is a Chilkat.JsonArray
$jsonMasterPaths = $jsonMaster->AppendArray('filePaths');

// The default page size is 100, with a max of 1000.
$rest->AddQueryParam('pageSize','200');

// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.JsonObject')
$json = new COM("Chilkat.JsonObject");

// Send the request for the 1st page.
$jsonResponse = $rest->fullRequestNoBody('GET','/drive/v3/files');

$pageNumber = 1;

$bContinueLoop = $rest->LastMethodSuccess and ($rest->ResponseStatusCode == 200);

while ($bContinueLoop == 1) {

    print '---- Page ' . $pageNumber . ' ----' . "\n";
    $json->Load($jsonResponse);

    $numFiles = $json->SizeOfArray('files');
    $i = 0;
    while ($i < $numFiles) {
        // Add this file ID to the master list.
        $json->I = $i;
        $jsonMasterArr->AddStringAt(-1,$json->stringOf('files[i].id'));

        $i = $i + 1;
    }

    // Get the next page of files.
    // If the "nextPageToken" is present in the JSON response, then use it in the "pageToken" parameter
    // for the next request.   If no "nextPageToken" was present, then this was the last page of files.
    $pageToken = $json->stringOf('nextPageToken');
    $bContinueLoop = 0;
    $bHasMorePages = $json->LastMethodSuccess;
    if ($bHasMorePages == 1) {
        $rest->ClearAllQueryParams();
        $rest->AddQueryParam('pageSize','200');
        $rest->AddQueryParam('pageToken',$pageToken);
        $jsonResponse = $rest->fullRequestNoBody('GET','/drive/v3/files');
        $bContinueLoop = $rest->LastMethodSuccess and ($rest->ResponseStatusCode == 200);
        $pageNumber = $pageNumber + 1;
    }

}

// Check to see if the above loop exited with errors...
if ($rest->LastMethodSuccess != 1) {
    print $rest->LastErrorText . "\n";
    exit;
}

// Check to see if the above loop exited with errors...
// A successful response will have a status code equal to 200.
if ($rest->ResponseStatusCode != 200) {
    print 'response status code = ' . $rest->ResponseStatusCode . "\n";
    print 'response status text = ' . $rest->ResponseStatusText . "\n";
    print 'response header: ' . $rest->ResponseHeader . "\n";
    print 'response JSON: ' . $jsonResponse . "\n";
    exit;
}

// Iterate over the file IDs and download the metadata for each, saving each to the cache...
// Also, keep in-memory hash entries of the name and parent[0] so we can quickly 
// build the path-->fileId cache entries. (Given that the Google Drive REST API uses
// fileIds, this gives us an easy way to lookup a fileId based on a filePath.)
// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.Hashtable')
$hashTable = new COM("Chilkat.Hashtable");
// Set the capacity of the hash table to something reasonable for the number of files
// to be hashed.
$hashTable->ClearWithNewCapacity(521);

// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.StringBuilder')
$sbPathForFileId = new COM("Chilkat.StringBuilder");

// Used for storing the file name and parents[0] in the hashTable.
// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.StringArray')
$saFileInfo = new COM("Chilkat.StringArray");
$saFileInfo->Unique = 0;

$numFiles = $jsonMaster->SizeOfArray('fileIds');
$i = 0;
while ($i < $numFiles) {
    $jsonMaster->I = $i;
    $fileId = $jsonMaster->stringOf('fileIds[i]');
    $sbPathForFileId->SetString('/drive/v3/files/');
    $sbPathForFileId->Append($fileId);

    $rest->ClearAllQueryParams();
    $rest->AddQueryParam('fields',$allFields);
    $jsonResponse = $rest->fullRequestNoBody('GET',$sbPathForFileId->getAsString());
    if (($rest->LastMethodSuccess != 1) or ($rest->ResponseStatusCode != 200)) {
        // Force an exit of this loop..
        $numFiles = 0;
    }

    // Save this file's metadata to the local cache.
    // The lookup key is the fileId.
    $gdCache->SaveTextDt($fileId,$dtExpire,'',$jsonResponse);

    // Get this file's name and parent[0], and put this information
    // in our in-memory hashtable to be used below..
    $json->Load($jsonResponse);

    $saFileInfo->Clear();
    $saFileInfo->Append($json->stringOf('name'));
    $saFileInfo->Append($json->stringOf('parents[0]'));
    $hashTable->AddStr($fileId,$saFileInfo->serialize());

    print $json->stringOf('name') . ', ' . $json->stringOf('parents[0]') . "\n";

    $i = $i + 1;
}

// Check to see if the above loop exited with errors...
if ($rest->LastMethodSuccess != 1) {
    print $rest->LastErrorText . "\n";
    exit;
}

// Check to see if the above loop exited with errors...
// A successful response will have a status code equal to 200.
if ($rest->ResponseStatusCode != 200) {
    print 'response status code = ' . $rest->ResponseStatusCode . "\n";
    print 'response status text = ' . $rest->ResponseStatusText . "\n";
    print 'response header: ' . $rest->ResponseHeader . "\n";
    print 'response JSON: ' . $jsonResponse . "\n";
    exit;
}

// Now that all the fileId's are in the cache, let's build the directory path
// for each fileID.  

// (Technically, a fileId can have multiple parents, which means it can be in multiple directories
// at once.  This is only going to build directory paths following the 0'th parent ID in the parents list.)

// The directory path for files in "My Drive" will be just the filename.
// For files in sub-directories, the path will be relative, such as "subdir1/subdir2/something.pdf"
// 

print '---- building paths ----' . "\n";

// For versions of Chilkat < 10.0.0, use new COM('Chilkat_9_5_0.Chilkat.StringBuilder')
$sbPath = new COM("Chilkat.StringBuilder");
$numFiles = $jsonMaster->SizeOfArray('fileIds');
$i = 0;
while ($i < $numFiles) {
    $jsonMaster->I = $i;

    $sbPath->Clear();

    $fileId = $jsonMaster->stringOf('fileIds[i]');
    $bFinished = 0;
    while (($bFinished == 0)) {
        $saFileInfo->Clear();
        $saFileInfo->AppendSerialized($hashTable->lookupStr($fileId));
        // Append this file or directory name.
        $sbPath->Prepend($saFileInfo->getString(0));
        // Get the parent fileId
        $fileId = $saFileInfo->getString(1);
        // If this fileId is not in the hashtable, then it's the fileId for "My Drive", and we are finished.
        if ($hashTable->Contains($fileId) == 0) {
            $bFinished = 1;
        }
        else {
            $sbPath->Prepend('/');
        }

    }

    print $i . ': ' . $sbPath->getAsString() . "\n";

    // Store the filePath --> fileId mapping in our local cache.
    $fileId = $jsonMaster->stringOf('fileIds[i]');
    $gdCache->SaveTextDt($sbPath->getAsString(),$dtExpire,'',$fileId);

    $jsonMasterPaths->AddStringAt(-1,$sbPath->getAsString());

    $i = $i + 1;
}

// Save the master list of file IDs and file paths to the local cache.
$jsonMaster->EmitCompact = 0;
$strJsonMaster = $jsonMaster->emit();
$gdCache->SaveTextNoExpire('AllGoogleDriveFileIds','',$strJsonMaster);
print 'JSON Master Record:' . "\n";
print $strJsonMaster . "\n";

// The JSON Master Cache Record looks something like this:
// An application can load the JSON master record and iterate over all the files
// in Google Drive by file ID, or by path.  
// {
//   "fileIds": [
//     "0B53Q6OSTWYolQlExSlBQT1phZXM",
//     "0B53Q6OSTWYolVHRPVkxtYWFtZkk",
//     "0B53Q6OSTWYolRGZEV3ZGUTZfNFk",
//     "0B53Q6OSTWYolS2FXSjliMXQxSU0",
//     "0B53Q6OSTWYolZUhxckMzb0dRMzg",
//     "0B53Q6OSTWYolbUF6WS1Gei1oalk",
//     "0B53Q6OSTWYola296ODZUSm5GYU0",
//     "0B53Q6OSTWYolbTE3c3J5RHBUcHM",
//     "0B53Q6OSTWYolTmhybWJSUGd5Q2c",
//     "0B53Q6OSTWYolY2tPU1BnYW02T2c",
//     "0B53Q6OSTWYolTTBBR2NvUE81Zzg",
//   ],
//   "filePaths": [
//     "testFolder/abc/123/pigs.json",
//     "testFolder/starfish20.jpg",
//     "testFolder/penguins2.jpg",
//     "testFolder/starfish.jpg",
//     "testFolder/abc/123/starfish.jpg",
//     "testFolder/abc/123/penguins.jpg",
//     "testFolder/abc/123",
//     "testFolder/abc",
//     "testFolder/testHello.txt",
//     "testFolder",
//     "helloWorld.txt",
//   ]
// }

print 'Entire cache rebuilt...' . "\n";

?>