(Delphi DLL) 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 for Delphi Downloads Chilkat non-ActiveX DLL for Delphi Chilkat ActiveX DLL for Delphi * The examples here use the non-ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, AuthGoogle, CkDateTime, JsonArray, StringArray, Rest, JsonObject, StringBuilder, Cache, Hashtable;

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Boolean;
gAuth: HCkAuthGoogle;
rest: HCkRest;
bAutoReconnect: Boolean;
gdCache: HCkCache;
numCacheFilesDeleted: Integer;
dtExpire: HCkDateTime;
allFields: PWideChar;
jsonMaster: HCkJsonObject;
jsonMasterArr: HCkJsonArray;
jsonMasterPaths: HCkJsonArray;
json: HCkJsonObject;
jsonFileMetadata: HCkJsonObject;
i: Integer;
numFiles: Integer;
jsonResponse: PWideChar;
pageNumber: Integer;
pageToken: PWideChar;
bContinueLoop: Boolean;
bHasMorePages: Boolean;
hashTable: HCkHashtable;
sbPathForFileId: HCkStringBuilder;
saFileInfo: HCkStringArray;
fileId: PWideChar;
sbPath: HCkStringBuilder;
bFinished: Boolean;
strJsonMaster: PWideChar;

begin
success := True;

// 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.

gAuth := CkAuthGoogle_Create();
CkAuthGoogle_putAccessToken(gAuth,'GOOGLE_DRIVE_ACCESS_TOKEN');

rest := CkRest_Create();

// Connect using TLS.
bAutoReconnect := True;
success := CkRest_Connect(rest,'www.googleapis.com',443,True,bAutoReconnect);

// Provide the authentication credentials (i.e. the access token)
CkRest_SetAuthGoogle(rest,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.
gdCache := CkCache_Create();
CkCache_putLevel(gdCache,0);
// Use a root directory that makes sense on your operating system..
CkCache_AddRoot(gdCache,'C:/ckCache/googleDrive');

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

// Create a date/time object with an time 7 days from the current date/time.
dtExpire := CkDateTime_Create();
CkDateTime_SetFromCurrentSystemTime(dtExpire);
CkDateTime_AddDays(dtExpire,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".
jsonMaster := CkJsonObject_Create();
jsonMasterArr := CkJsonObject_AppendArray(jsonMaster,'fileIds');
// Also keep a list of file paths.
jsonMasterPaths := CkJsonObject_AppendArray(jsonMaster,'filePaths');

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

json := CkJsonObject_Create();

// Send the request for the 1st page.
jsonResponse := CkRest__fullRequestNoBody(rest,'GET','/drive/v3/files');

pageNumber := 1;

bContinueLoop := CkRest_getLastMethodSuccess(rest) and (CkRest_getResponseStatusCode(rest) = 200);

while bContinueLoop = True do
  begin

    Memo1.Lines.Add('---- Page ' + IntToStr(pageNumber) + ' ----');
    CkJsonObject_Load(json,jsonResponse);

    numFiles := CkJsonObject_SizeOfArray(json,'files');
    i := 0;
    while i < numFiles do
      begin
        // Add this file ID to the master list.
        CkJsonObject_putI(json,i);
        CkJsonArray_AddStringAt(jsonMasterArr,-1,CkJsonObject__stringOf(json,'files[i].id'));

        i := i + 1;
      end;

    // 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 := CkJsonObject__stringOf(json,'nextPageToken');
    bContinueLoop := False;
    bHasMorePages := CkJsonObject_getLastMethodSuccess(json);
    if (bHasMorePages = True) then
      begin
        CkRest_ClearAllQueryParams(rest);
        CkRest_AddQueryParam(rest,'pageSize','200');
        CkRest_AddQueryParam(rest,'pageToken',pageToken);
        jsonResponse := CkRest__fullRequestNoBody(rest,'GET','/drive/v3/files');
        bContinueLoop := CkRest_getLastMethodSuccess(rest) and (CkRest_getResponseStatusCode(rest) = 200);
        pageNumber := pageNumber + 1;
      end;

  end;

CkJsonArray_Dispose(jsonMasterArr);

// Check to see if the above loop exited with errors...
if (CkRest_getLastMethodSuccess(rest) <> True) then
  begin
    Memo1.Lines.Add(CkRest__lastErrorText(rest));
    Exit;
  end;
// Check to see if the above loop exited with errors...
// A successful response will have a status code equal to 200.
if (CkRest_getResponseStatusCode(rest) <> 200) then
  begin
    Memo1.Lines.Add('response status code = ' + IntToStr(CkRest_getResponseStatusCode(rest)));
    Memo1.Lines.Add('response status text = ' + CkRest__responseStatusText(rest));
    Memo1.Lines.Add('response header: ' + CkRest__responseHeader(rest));
    Memo1.Lines.Add('response JSON: ' + jsonResponse);
    Exit;
  end;

// 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.)
hashTable := CkHashtable_Create();
// Set the capacity of the hash table to something reasonable for the number of files
// to be hashed.
CkHashtable_ClearWithNewCapacity(hashTable,521);

sbPathForFileId := CkStringBuilder_Create();

// Used for storing the file name and parents[0] in the hashTable.
saFileInfo := CkStringArray_Create();
CkStringArray_putUnique(saFileInfo,False);

numFiles := CkJsonObject_SizeOfArray(jsonMaster,'fileIds');
i := 0;
while i < numFiles do
  begin
    CkJsonObject_putI(jsonMaster,i);
    fileId := CkJsonObject__stringOf(jsonMaster,'fileIds[i]');
    CkStringBuilder_SetString(sbPathForFileId,'/drive/v3/files/');
    CkStringBuilder_Append(sbPathForFileId,fileId);

    CkRest_ClearAllQueryParams(rest);
    CkRest_AddQueryParam(rest,'fields',allFields);
    jsonResponse := CkRest__fullRequestNoBody(rest,'GET',CkStringBuilder__getAsString(sbPathForFileId));
    if ((CkRest_getLastMethodSuccess(rest) <> True) or (CkRest_getResponseStatusCode(rest) <> 200)) then
      begin
        // Force an exit of this loop..
        numFiles := 0;
      end;

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

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

    CkStringArray_Clear(saFileInfo);
    CkStringArray_Append(saFileInfo,CkJsonObject__stringOf(json,'name'));
    CkStringArray_Append(saFileInfo,CkJsonObject__stringOf(json,'parents[0]'));
    CkHashtable_AddStr(hashTable,fileId,CkStringArray__serialize(saFileInfo));

    Memo1.Lines.Add(CkJsonObject__stringOf(json,'name') + ', ' + CkJsonObject__stringOf(json,'parents[0]'));

    i := i + 1;
  end;

// Check to see if the above loop exited with errors...
if (CkRest_getLastMethodSuccess(rest) <> True) then
  begin
    Memo1.Lines.Add(CkRest__lastErrorText(rest));
    Exit;
  end;
// Check to see if the above loop exited with errors...
// A successful response will have a status code equal to 200.
if (CkRest_getResponseStatusCode(rest) <> 200) then
  begin
    Memo1.Lines.Add('response status code = ' + IntToStr(CkRest_getResponseStatusCode(rest)));
    Memo1.Lines.Add('response status text = ' + CkRest__responseStatusText(rest));
    Memo1.Lines.Add('response header: ' + CkRest__responseHeader(rest));
    Memo1.Lines.Add('response JSON: ' + jsonResponse);
    Exit;
  end;

// 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"
// 

Memo1.Lines.Add('---- building paths ----');

sbPath := CkStringBuilder_Create();
numFiles := CkJsonObject_SizeOfArray(jsonMaster,'fileIds');
i := 0;
while i < numFiles do
  begin
    CkJsonObject_putI(jsonMaster,i);

    CkStringBuilder_Clear(sbPath);

    fileId := CkJsonObject__stringOf(jsonMaster,'fileIds[i]');
    bFinished := False;
    while (bFinished = False) do
      begin
        CkStringArray_Clear(saFileInfo);
        CkStringArray_AppendSerialized(saFileInfo,CkHashtable__lookupStr(hashTable,fileId));
        // Append this file or directory name.
        CkStringBuilder_Prepend(sbPath,CkStringArray__getString(saFileInfo,0));
        // Get the parent fileId
        fileId := CkStringArray__getString(saFileInfo,1);
        // If this fileId is not in the hashtable, then it's the fileId for "My Drive", and we are finished.
        if (CkHashtable_Contains(hashTable,fileId) = False) then
          begin
            bFinished := True;
          end
        else
          begin
            CkStringBuilder_Prepend(sbPath,'/');
          end;
      end;

    Memo1.Lines.Add(IntToStr(i) + ': ' + CkStringBuilder__getAsString(sbPath));

    // Store the filePath --> fileId mapping in our local cache.
    fileId := CkJsonObject__stringOf(jsonMaster,'fileIds[i]');
    CkCache_SaveTextDt(gdCache,CkStringBuilder__getAsString(sbPath),dtExpire,'',fileId);

    CkJsonArray_AddStringAt(jsonMasterPaths,-1,CkStringBuilder__getAsString(sbPath));

    i := i + 1;
  end;

CkJsonArray_Dispose(jsonMasterPaths);

// Save the master list of file IDs and file paths to the local cache.
CkJsonObject_putEmitCompact(jsonMaster,False);
strJsonMaster := CkJsonObject__emit(jsonMaster);
CkCache_SaveTextNoExpire(gdCache,'AllGoogleDriveFileIds','',strJsonMaster);
Memo1.Lines.Add('JSON Master Record:');
Memo1.Lines.Add(strJsonMaster);

// 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",
//   ]
// }

Memo1.Lines.Add('Entire cache rebuilt...');

CkAuthGoogle_Dispose(gAuth);
CkRest_Dispose(rest);
CkCache_Dispose(gdCache);
CkDateTime_Dispose(dtExpire);
CkJsonObject_Dispose(jsonMaster);
CkJsonObject_Dispose(json);
CkHashtable_Dispose(hashTable);
CkStringBuilder_Dispose(sbPathForFileId);
CkStringArray_Dispose(saFileInfo);
CkStringBuilder_Dispose(sbPath);

end;