Pass custom metadata to "uploadFile()" function. #1478

Author: EddyVerbruggen

demo/app/main-view-model.ts

@@ -6,6 +6,7 @@ import { Observable } from "tns-core-modules/data/observable";
 import * as fs from "tns-core-modules/file-system";
 import { isAndroid, isIOS } from "tns-core-modules/platform";
 import { alert, prompt } from "tns-core-modules/ui/dialogs";
+import { UploadMetadata } from "../../src/storage/storage";
 import { MessagingViewModel } from "./messaging-view-model";
 
 const firebaseWebApi = require("nativescript-plugin-firebase/app");
@@ -314,7 +315,16 @@ export class HelloWorldModel extends Observable {
     const storageRef = firebaseWebApi.storage().ref();
     const childRef = storageRef.child("uploads/images/telerik-logo-uploaded.png");
 
-    childRef.put(fs.File.fromPath(logoPath)).then(
+    const metadata: UploadMetadata = {
+      contentType: "demo/test",
+      contentLanguage: "fr",
+      customMetadata: {
+        "foo": "bar",
+        "foo2": "bar2"
+      }
+    };
+
+    childRef.put(fs.File.fromPath(logoPath), metadata).then(
         uploadedFile => {
           console.log("Uploaded! " + JSON.stringify(uploadedFile));
           this.set("storageFeedback", "Uploaded!");
@@ -1639,13 +1649,23 @@ export class HelloWorldModel extends Observable {
     const appPath = fs.knownFolders.currentApp().path;
     const logoPath = appPath + "/images/telerik-logo.png";
 
+    const metadata: UploadMetadata = {
+      contentType: "demo/test2",
+      contentLanguage: "de",
+      customMetadata: {
+        "first": "first!",
+        "second": "second!"
+      }
+    };
+
     firebaseStorage.uploadFile({
       remoteFullPath: 'uploads/images/telerik-logo-uploaded.png',
       localFile: fs.File.fromPath(logoPath), // use this (a file-system module File object)
       // localFullPath: logoPath, // or this, a full file path
       onProgress: status => {
         console.log("Uploaded fraction: " + status.fractionCompleted + " (" + status.percentageCompleted + "%)");
-      }
+      },
+      metadata
     }).then(
         uploadedFile => {
           alert({

docs/STORAGE.md

@@ -59,6 +59,15 @@ You can either pass in a full local path to a file, or (as a convenience) use th
   // determine the path to a file in the app/res folder
   var logoPath = appPath + "/res/telerik-logo.png";
 
+  var metadata = {
+    contentType: "demo/test",
+    contentLanguage: "fr",
+    customMetadata: {
+      "foo": "bar",
+       "foo2": "bar2"
+    }
+  };
+
   // now upload the file with either of the options below:
   firebase.storage.uploadFile({
     // optional, can be omitted since 6.5.0, and also be passed during init() as 'storageBucket' param so we can cache it (find it in the Firebase console)
@@ -73,7 +82,8 @@ You can either pass in a full local path to a file, or (as a convenience) use th
     onProgress: function(status) {
       console.log("Uploaded fraction: " + status.fractionCompleted);
       console.log("Percentage complete: " + status.percentageCompleted);
-    }
+    },
+    metadata
   }).then(
       function (uploadedFile) {
         console.log("File uploaded: " + JSON.stringify(uploadedFile));
@@ -100,7 +110,15 @@ You can either pass in a full local path to a file, or (as a convenience) use th
   const storageRef = firebaseWebApi.storage().ref();
   const childRef = storageRef.child("uploads/images/telerik-logo-uploaded.png");
 
-  childRef.put(fs.File.fromPath(logoPath)).then(
+  const metadata = {
+    contentType: "demo/test",
+    contentLanguage: "fr",
+    customMetadata: {
+      "foo": "bar",
+       "foo2": "bar2"
+    }
+  };
+  childRef.put(fs.File.fromPath(logoPath), metadata).then(
       uploadedFile => console.log("Uploaded! " + JSON.stringify(uploadedFile)),
       error => console.log("firebase.doWebUploadFile error: " + error)
   );

src/app/storage/index.ts

@@ -1,6 +1,6 @@
 import { File } from "tns-core-modules/file-system"
 import * as firebaseStorage from "../../storage/storage";
-import { ListResult, UploadFileResult } from "../../storage/storage";
+import { ListResult, UploadFileResult, UploadMetadata } from "../../storage/storage";
 
 export module storage {
 
@@ -9,6 +9,10 @@ export module storage {
     totalBytes: number;
   }
 
+  export interface Metadata {
+    string: string;
+  }
+
   export class Reference {
 
     private path: string;
@@ -43,19 +47,26 @@ export module storage {
       });
     }
 
+    getMetadata(): Promise<string> {
+      return firebaseStorage.getDownloadUrl({
+        remoteFullPath: this.path
+      });
+    }
+
     listAll(): Promise<ListResult> {
       return firebaseStorage.listAll({
         remoteFullPath: this.path
       });
     }
 
-    public put(data: File | string /* path */, metadata?: any /* ignored */): Promise<UploadTaskSnapshot> {
+    public put(data: File | string /* path */, metadata?: UploadMetadata): Promise<UploadTaskSnapshot> {
       return new Promise((resolve, reject) => {
         firebaseStorage.uploadFile({
           localFile: data instanceof File ? data : undefined,
           localFullPath: !(data instanceof File) ? data : undefined,
           remoteFullPath: this.path,
-          onProgress: progress => console.log(`Upload progress: ${progress.percentageCompleted}% completed`)
+          onProgress: progress => console.log(`Upload progress: ${progress.percentageCompleted}% completed`),
+          metadata
         }).then((result: UploadFileResult) => {
           this.getDownloadURL()
               .then(url => {

src/storage/storage.android.ts

@@ -101,6 +101,32 @@ export function uploadFile(arg: UploadFileOptions): Promise<UploadFileResult> {
         }
       });
 
+      let metadata: com.google.firebase.storage.StorageMetadata = null;
+      if (arg.metadata) {
+        const metadataBuilder = new com.google.firebase.storage.StorageMetadata.Builder();
+        if (arg.metadata.cacheControl) {
+          metadataBuilder.setCacheControl(arg.metadata.cacheControl);
+        }
+        if (arg.metadata.contentDisposition) {
+          metadataBuilder.setContentDisposition(arg.metadata.contentDisposition);
+        }
+        if (arg.metadata.contentEncoding) {
+          metadataBuilder.setContentEncoding(arg.metadata.contentEncoding);
+        }
+        if (arg.metadata.contentLanguage) {
+          metadataBuilder.setContentLanguage(arg.metadata.contentLanguage);
+        }
+        if (arg.metadata.contentType) {
+          metadataBuilder.setContentType(arg.metadata.contentType);
+        }
+        if (arg.metadata.customMetadata) {
+          for (let p in arg.metadata.customMetadata) {
+            metadataBuilder.setCustomMetadata(p, arg.metadata.customMetadata[p]);
+          }
+        }
+        metadata = metadataBuilder.build();
+      }
+
       if (arg.localFile) {
         if (typeof (arg.localFile) !== "object") {
           reject("localFile argument must be a File object; use file-system module to create one");
@@ -109,7 +135,7 @@ export function uploadFile(arg: UploadFileOptions): Promise<UploadFileResult> {
 
         // using 'putFile' (not 'putBytes') so Firebase can infer the mimetype
         const localFileUrl = android.net.Uri.fromFile(new java.io.File(arg.localFile.path));
-        storageReference.putFile(localFileUrl)
+        storageReference.putFile(localFileUrl, metadata)
             .addOnFailureListener(onFailureListener)
             .addOnSuccessListener(onSuccessListener)
             .addOnProgressListener(onProgressListener);
@@ -137,7 +163,7 @@ export function uploadFile(arg: UploadFileOptions): Promise<UploadFileResult> {
         }
 
         const localFileUrl = android.net.Uri.fromFile(new java.io.File(arg.localFullPath));
-        storageReference.putFile(localFileUrl)
+        storageReference.putFile(localFileUrl, metadata)
             .addOnFailureListener(onFailureListener)
             .addOnSuccessListener(onSuccessListener)
             .addOnProgressListener(onProgressListener);

src/storage/storage.d.ts

@@ -3,6 +3,19 @@ export interface ProgressStatus {
   percentageCompleted: Number;
 }
 
+interface SettableMetadata {
+  cacheControl?: string | null;
+  contentDisposition?: string | null;
+  contentEncoding?: string | null;
+  contentLanguage?: string | null;
+  contentType?: string | null;
+  customMetadata?: { [key: string]: string; };
+}
+
+interface UploadMetadata extends SettableMetadata {
+  // md5Hash?: string | null;
+}
+
 /**
  * Use either the 'localFile' or 'localFullPath' param to upload a file.
  */
@@ -37,7 +50,12 @@ export interface UploadFileOptions {
    *   console.log("Percentage complete: " + status.percentageCompleted);
    * }
    */
-  onProgress: (data: ProgressStatus) => void;
+  onProgress?: (data: ProgressStatus) => void;
+
+  /**
+   *
+   */
+  metadata?: UploadMetadata;
 }
 
 export interface UploadFileResult {

src/storage/storage.ios.ts

@@ -81,17 +81,34 @@ export function uploadFile(arg: UploadFileOptions): Promise<UploadFileResult> {
       const fIRStorageReference = storageRef.child(arg.remoteFullPath);
       let fIRStorageUploadTask = null;
 
+      let metadata: FIRStorageMetadata = null;
+      if (arg.metadata) {
+        metadata = FIRStorageMetadata.new();
+        metadata.cacheControl = arg.metadata.cacheControl;
+        metadata.contentDisposition = arg.metadata.contentDisposition;
+        metadata.contentEncoding = arg.metadata.contentEncoding;
+        metadata.contentLanguage = arg.metadata.contentLanguage;
+        metadata.contentType = arg.metadata.contentType;
+        if (arg.metadata.customMetadata) {
+          const customMetadata = NSMutableDictionary.new();
+          for (let p in arg.metadata.customMetadata) {
+            customMetadata.setObjectForKey(arg.metadata.customMetadata[p], p);
+          }
+          metadata.customMetadata = <any>customMetadata;
+        }
+      }
+
       if (arg.localFile) {
         if (typeof (arg.localFile) !== "object") {
           reject("localFile argument must be a File object; use file-system module to create one");
           return;
         }
 
         // using 'putFile' (not 'putData') so Firebase can infer the mime-type
-        fIRStorageUploadTask = fIRStorageReference.putFileMetadataCompletion(NSURL.fileURLWithPath(arg.localFile.path), null, onCompletion);
+        fIRStorageUploadTask = fIRStorageReference.putFileMetadataCompletion(NSURL.fileURLWithPath(arg.localFile.path), metadata, onCompletion);
 
       } else if (arg.localFullPath) {
-        fIRStorageUploadTask = fIRStorageReference.putFileMetadataCompletion(NSURL.fileURLWithPath(arg.localFullPath), null, onCompletion);
+        fIRStorageUploadTask = fIRStorageReference.putFileMetadataCompletion(NSURL.fileURLWithPath(arg.localFullPath), metadata, onCompletion);
 
       } else {
         reject("One of localFile or localFullPath is required");