Пример #1
0
        public static void Upload(string source, string dest)
        {
            if (!inited)
            {
                return;
            }

            var body = new Google.Apis.Drive.v3.Data.File();

            body.Name     = dest;
            body.MimeType = getMimeType(source);
            body.Parents  = new List <string>()
            {
                createDirectory("sdfsd").Id
            };

            byte[]       byteArray = File.ReadAllBytes(source);
            MemoryStream stream    = new MemoryStream(byteArray);

            FilesResource.CreateMediaUpload request = driveService.Files.Create(body, stream, body.MimeType);

            if (request.Upload().Exception != null)
            {
                Logger.Log(Logger.Module.Core, Logger.Type.Error, request.Upload().Exception.Message);
            }
            else
            {
                Logger.Log(Logger.Module.Core, Logger.Type.Debug, $"File '{Path.GetFileName(source)}' successfully uploaded");
            }
        }
Пример #2
0
        /// <summary>
        /// Сохраняет в облаке файл
        /// </summary>
        /// <param name="fileId">Id файла</param>
        /// <param name="folderId">Id папки</param>
        /// <param name="localFilePath">Файл на диске который нужно залить</param>
        /// <returns></returns>
        public bool UploadFile(string localFilePath)
        {
            if (Service == null)
            {
                return(false);
            }

            byte[]       byteArray = File.ReadAllBytes(localFilePath);
            MemoryStream mStream   = new MemoryStream(byteArray);

            // Файл для записи
            Google.Apis.Drive.v3.Data.File file = new Google.Apis.Drive.v3.Data.File()
            {
                Name        = "TizTabooDataFile",
                MimeType    = "application/octet-stream",
                Description = "Файл данных программы TizTaboo",
            };

            // Проверяем существует наш файл в облаке, если нет - создаем
            if (!FileExists())
            {
                file.Parents = new List <string> {
                    CreateFolder("TizTabooData")
                };
                FilesResource.CreateMediaUpload createRequest = Service.Files.Create(file, mStream, file.MimeType);
                if (createRequest.Upload().Exception != null)
                {
                    Log.Error(createRequest.Upload().Exception.Message);
                    return(false);
                }
                else
                {
                    fileId = createRequest.ResponseBody.Id;
                    return(true);
                }
            }
            // Если есть, обновляем
            else
            {
                FilesResource.UpdateMediaUpload updateRequest = Service.Files.Update(file, fileId, mStream, file.MimeType);
                if (updateRequest.Upload().Exception != null)
                {
                    Log.Error(updateRequest.Upload().Exception.Message);
                    return(false);
                }
                else
                {
                    return(true);
                }
            }
        }
Пример #3
0
        /// <summary>
        /// Загрузка файла на Google
        /// </summary>
        /// <param name="service">Сервис</param>
        /// <param name="localfilePath">Локальный путь к файлу</param>
        /// <param name="parentGoogleDriveId">Идентификатор папки в Google Drive</param>
        /// <returns></returns>
        public File UploadFileByParentId(DriveService service, string localfilePath, string parentGoogleDriveId)
        {
            if (!System.IO.File.Exists(localfilePath))
            {
                throw new Exception($"File '{localfilePath}' does not exist and can not be uploaded to Google Drive");
            }

            string mimeType = GetMimeType(localfilePath);

            File body = new File
            {
                Name        = Path.GetFileName(localfilePath),
                Description = "Created by ScanImage",
                MimeType    = mimeType
            };

            if (!string.IsNullOrEmpty(parentGoogleDriveId))
            {
                body.Parents = new List <string> {
                    parentGoogleDriveId
                }
            }
            ;

            byte[] byteArray = System.IO.File.ReadAllBytes(localfilePath);
            using (MemoryStream stream = new MemoryStream(byteArray))
            {
                FilesResource.CreateMediaUpload request = service.Files.Create(body, stream, mimeType);
                request.Upload();
                return(request.ResponseBody);
            }
        }
Пример #4
0
 public Google.Apis.Drive.v3.Data.File uploadFile(DriveService _service, string _uploadFile)
 {
     if (System.IO.File.Exists(_uploadFile))
     {
         Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
         body.Name        = System.IO.Path.GetFileName(_uploadFile);
         body.Description = "Assignment";
         byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
         System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
         try
         {
             FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, "");
             request.SupportsTeamDrives = true;
             request.Upload();
             return(request.ResponseBody);
         }
         catch (Exception)
         {
             return(null);
         }
     }
     else
     {
         return(null);
     }
 }
Пример #5
0
            public AttemptResult CreateStreamToFile(string name, string parent_id, string mime_type, Stream stream, out string id, out string hash, out DateTime last_write_time)
            {
                FilesResource.CreateMediaUpload request = drive_service.Files.Create(
                    new Google.Apis.Drive.v3.Data.File()
                {
                    Name    = name,
                    Parents = new string[] { parent_id }
                },
                    stream,
                    mime_type
                    );

                request.Fields = "id, name, md5Checksum, modifiedTime, parents";

                try
                {
                    request.Upload();

                    id              = request.ResponseBody.Id;
                    hash            = request.ResponseBody.Md5Checksum;
                    last_write_time = request.ResponseBody.ModifiedTime.Solidify();
                }
                catch (Google.GoogleApiException exception)
                {
                    id              = null;
                    hash            = null;
                    last_write_time = default(DateTime);
                    return(exception.Error.GetAttemptResult());
                }

                return(AttemptResult.Succeeded);
            }
 /**
  * The function will take in the file and the parent directory in which you want the file to be in within the
  * google drive and upload it. The mime and other mota data is collected using the private function
  * GetMimeType(string fileName).
  *
  * @param _service The initialized google drive service that will be querired.
  * @param _uploadFile The file you wish to upload to the google drive.
  * @param _parent The parent dierctory that the file should be placed in within the google drive.
  * @param _descrp each file being uploaded needs a description. This is filled in by default.
  * @return Return the response message from the server.
  */
 public File UploadFile(DriveService _service, string _uploadFile, string _parent, string _descrp = "Updated APK for Lesion Scanner")
 {
     if (System.IO.File.Exists(_uploadFile))
     {
         File body = new File();
         body.Name        = Path.GetFileName(_uploadFile);
         body.Description = _descrp;
         body.MimeType    = GetMimeType(_uploadFile);
         body.Parents     = new List <string> {
             _parent
         };
         byte[]       byteArray = System.IO.File.ReadAllBytes(_uploadFile);
         MemoryStream stream    = new System.IO.MemoryStream(byteArray);
         try
         {
             FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, GetMimeType(_uploadFile));
             request.SupportsTeamDrives = true;
             // You can bind event handler with progress changed event and response recieved(completed event)
             request.Upload();
             return(request.ResponseBody);
         }
         catch (Exception e)
         {
             Console.WriteLine(e.Message, "Error Occured");
             return(null);
         }
     }
     else
     {
         Console.WriteLine("The file does not exist.", "404");
         return(null);
     }
 }
Пример #7
0
 public static Google.Apis.Drive.v3.Data.File uploadFile(DriveService _service, string _uploadFile, string _parent, string _descrp = "")
 {
     if (System.IO.File.Exists(_uploadFile))
     {
         Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
         body.Name = System.IO.Path.GetFileName(_uploadFile);
         body.Description = _descrp;
         body.MimeType = GetMimeType(_uploadFile);
       
         body.Parents = new List<string> { _parent };// UN comment if you want to upload to a folder(ID of parent folder need to be send as paramter in above method)
         byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
         System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
         try
         {
             FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, GetMimeType(_uploadFile));
             request.SupportsTeamDrives = true;
             request.Upload();
             return request.ResponseBody;
         }
         catch (Exception e)
         {
             Console.WriteLine(e.Message, "Error Occured");
             return null;
         }
     }
     else
     {
         Console.WriteLine("The file does not exist.", "404");
         return null;
     }
 }
Пример #8
0
 /// <summary>
 /// Uploads a file to Google Drive under a specific folder, if parent is specified.
 /// </summary>
 /// <param name="_service"></param>
 /// <param name="_uploadFile"></param>
 /// <param name="_parent"></param>
 /// <returns></returns>
 private Google.Apis.Drive.v3.Data.File UploadToGoogleDrive(DriveService _service, string _uploadFile, string _parent)
 {
     if (System.IO.File.Exists(_uploadFile))
     {
         Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
         body.Name     = System.IO.Path.GetFileName(_uploadFile);
         body.MimeType = "text/plain";
         body.Parents  = new List <string> {
             _parent
         };
         byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
         System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
         try
         {
             FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, "text/plain");
             request.SupportsTeamDrives = true;
             // You can bind event handler with progress changed event and response recieved(completed event)
             request.Upload();
             return(request.ResponseBody);
         }
         catch (Exception e)
         {
             MessageBox.Show(e.Message, "Error Occured");
             return(null);
         }
     }
     else
     {
         MessageBox.Show("The file does not exist.", "404");
         return(null);
     }
 }
Пример #9
0
 public override bool Write(string fileName, byte[] data)
 {
     try
     {
         if ((!FileExists(fileName)) || Overwrite)
         {
             string contentType = "image/jpeg";
             using (MemoryStream memoryStream = new MemoryStream(data))
             {
                 Google.Apis.Drive.v3.Data.File file = new Google.Apis.Drive.v3.Data.File()
                 {
                     Name = fileName
                 };
                 FilesResource.CreateMediaUpload request = GoogleDriveService.Files.Create(file, memoryStream, contentType);
                 request.Fields = "id";
                 request.Upload();
             }
         }
     }
     catch
     {
         return(false);
     }
     return(true);
 }
        //file Upload to the Google Drive.
        public static string FileUploadInFolder(string folderId, HttpPostedFileBase file)
        {
            FilesResource.CreateMediaUpload request = null;
            if (file != null && file.ContentLength > 0)
            {
                Google.Apis.Drive.v3.DriveService service = GetService();

                string path = Path.Combine(HttpContext.Current.Server.MapPath("~/GoogleDriveFiles"),
                                           Path.GetFileName(file.FileName));
                file.SaveAs(path);

                var FileMetaData = new Google.Apis.Drive.v3.Data.File()
                {
                    Name     = Path.GetFileName(file.FileName),
                    MimeType = MimeMapping.GetMimeMapping(path),
                    Parents  = new List <string>
                    {
                        folderId
                    }
                };

                using (var stream = new System.IO.FileStream(path, System.IO.FileMode.Open))
                {
                    request        = service.Files.Create(FileMetaData, stream, FileMetaData.MimeType);
                    request.Fields = "id";

                    request.Upload();
                }
            }
            return(request.ResponseBody.Id.ToString());
        }
Пример #11
0
        private static void CreateFile(DriveService driveService,
                                       string targetFolderId,
                                       string targetName,
                                       string sourcePath,
                                       string contentType)
        {
            File fileMetadata = new File
            {
                Name    = targetName,
                Parents = new List <string> {
                    targetFolderId
                }
            };
            string?uploadedFileId = null;

            using FileStream fs = System.IO.File.OpenRead(sourcePath);
            FilesResource.CreateMediaUpload createRequest = driveService.Files.Create(fileMetadata, fs, contentType);
            createRequest.Fields           = "id, parents";
            createRequest.ProgressChanged += progress =>
                                             Console.WriteLine($"Upload status: {progress.Status} Bytes sent: {progress.BytesSent}");
            createRequest.ResponseReceived += file =>
            {
                uploadedFileId = file.Id;
                Console.WriteLine($"Created: {file.Id} parents: {file.Parents}");
            };
            var uploadProgress = createRequest.Upload();

            Console.WriteLine($"Final status: {uploadProgress.Status} {uploadedFileId}");
        }
Пример #12
0
        // chunkSize is in MB!
        public Task UploadFile(Stream stream, string filename, int chunkSize)
        {
            File body = new File
            {
                Name     = Path.GetFileName(filename),
                MimeType = "application/unknown"
            };

            try
            {
                FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, body.MimeType);
                if (chunkSize != 0)
                {
                    request.ChunkSize = chunkSize * 4 * Google.Apis.Upload.ResumableUpload.MinimumChunkSize;
                }
                request.Upload();
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: " + e.Message);
            }

            Console.WriteLine("Done uploading");
            return(Task.FromResult(0));
        }
Пример #13
0
        private File CreateNewFile(string filename, string content, string directoryId)
        {
            File body = new File();

            body.Name    = filename;
            body.Parents = new List <string>()
            {
                directoryId
            };

            // File's content.
            var stream = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(content));

            try
            {
                FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, String.Empty);
                request.Fields = "id,modifiedTime,name,version";
                request.Upload();
                return(request.ResponseBody);
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: " + e.Message);
                return(null);
            }
        }
Пример #14
0
        /// <summary>
        /// Uploads a file
        /// Documentation: https://developers.google.com/drive/v2/reference/files/insert
        /// </summary>
        /// <param name="service">a Valid authenticated DriveService</param>
        /// <param name="uploadFile">path to the file to upload</param>
        /// <param name="parent">
        /// Collection of parent folders which contain this file.
        /// Setting this field will put the file in all of the provided folders. root folder.
        /// </param>
        /// <returns>
        /// If upload succeeded returns the File resource of the uploaded file
        /// If the upload fails returns null
        /// </returns>
        public static File UploadFile(DriveService service, string uploadFile, string content, string parent)
        {
            File body = new File();

            body.Name        = System.IO.Path.GetFileName(uploadFile);
            body.Description = "Test File 1";
            body.Parents     = new List <string>()
            {
                parent
            };

            // File's content.
            var stream = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(content ?? ""));

            try
            {
                FilesResource.CreateMediaUpload request = service.Files.Create(body, stream, String.Empty);
                request.Upload();
                return(request.ResponseBody);
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: " + e.Message);
                return(null);
            }
        }
Пример #15
0
        private static void UploadFile(string fileName, List <string> parents, string _descrp = "Uploaded with .NET!")
        {
            if (System.IO.File.Exists(fileName))
            {
                Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
                body.Name        = System.IO.Path.GetFileName(fileName);
                body.Description = _descrp;
                body.MimeType    = GetMimeType(fileName);
                body.Parents     = parents;

                byte[] byteArray = System.IO.File.ReadAllBytes(fileName);
                System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
                try
                {
                    FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, GetMimeType(fileName));
                    request.Upload();
                    var winik = request.ResponseBody;
                }
                catch (Exception e)
                {
                    var a = e.Message;
                }
            }
            else
            {
                var b = "nie ma pliku";
            }
        }
Пример #16
0
 public static string SaveImage(Stream image, string name)
 {
     try
     {
         const string Type     = "image/jpeg";
         string       folderId = WebConfigurationManager.AppSettings["GoogleDriveFolderId"];
         Google.Apis.Drive.v3.Data.File fileMetadata = new Google.Apis.Drive.v3.Data.File
         {
             Name     = name,
             MimeType = Type,
             Parents  = new List <string> {
                 folderId
             }
         };
         UserCredential credential = GetCredentials();
         DriveService   service    = new DriveService(new BaseClientService.Initializer
         {
             HttpClientInitializer = credential,
             ApplicationName       = WebConfigurationManager.AppSettings["GoogleDriveApplicationName"]
         });
         FilesResource.CreateMediaUpload request = service.Files.Create(fileMetadata, image, Type);
         request.Fields = "id";
         request.Upload();
         Google.Apis.Drive.v3.Data.File file = request.ResponseBody;
         string googleDriveUrl = "https://drive.google.com/uc?id=" + file.Id + "&export=stream";
         return(googleDriveUrl);
     }
     catch (Exception exception)
     {
         LogException(exception, new Dictionary <string, string>(), ErrorSource.ServiceHelper);
         return(String.Empty);
     }
 }
Пример #17
0
 public Google.Apis.Drive.v3.Data.File UploadFile(string uploadFilePath, string description)
 {
     if (File.Exists(uploadFilePath))
     {
         Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
         string mimeType = GetMimeType(uploadFilePath);
         body.Name        = Path.GetFileName(uploadFilePath);
         body.Description = description;
         body.MimeType    = mimeType;
         byte[]       byteArray = System.IO.File.ReadAllBytes(uploadFilePath);
         MemoryStream stream    = new MemoryStream(byteArray);
         try
         {
             FilesResource.CreateMediaUpload request = Service.Files.Create(body, stream, mimeType);
             request.SupportsTeamDrives = true;
             request.Upload();
             return(request.ResponseBody);
         }
         catch
         {
             return(new Google.Apis.Drive.v3.Data.File());
         }
     }
     else
     {
         return(new Google.Apis.Drive.v3.Data.File());
     }
 }
Пример #18
0
        ///

        /// Uploads a file
        /// Documentation: https://developers.google.com/drive/v2/reference/files/insert
        ///

        /// a Valid authenticated DriveService
        /// path to the file to upload
        /// Collection of parent folders which contain this file.
        ///                       Setting this field will put the file in all of the provided folders. root folder.
        /// If upload succeeded returns the File resource of the uploaded file
        ///          If the upload fails returns null
        public static File UploadFile(DriveService _service, string _uploadFile, string _parent)
        {
            if (System.IO.File.Exists(_uploadFile))
            {
                File body = new File();
                body.Name        = System.IO.Path.GetFileName(_uploadFile);
                body.Description = "File uploaded by FileSync";
                body.MimeType    = GetMimeType(_uploadFile);
                body.Parents     = new List <string> {
                    _parent
                };
                body.WritersCanShare = true;

                // File's content.
                byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
                System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
                try
                {
                    FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, GetMimeType(_uploadFile));
                    request.Upload();

                    return(request.ResponseBody);
                }
                catch (Exception e)
                {
                    Console.WriteLine("An error occurred: " + e.Message);
                    return(null);
                }
            }
            else
            {
                Console.WriteLine("File does not exist: " + _uploadFile);
                return(null);
            }
        }
Пример #19
0
        // Calling webservice Google.Apis.Drive.v3
        public Google.Apis.Drive.v3.Data.File FileUploadtoGD(DriveService objService, string strUploadFile, string strDescription = "Uploaded with .NET!")
        {
            if (System.IO.File.Exists(strUploadFile))
            {
                string strMIMEType = GetMIMEType(strUploadFile);

                Google.Apis.Drive.v3.Data.File objFileBody = new Google.Apis.Drive.v3.Data.File();
                objFileBody.Name        = System.IO.Path.GetFileName(strUploadFile);
                objFileBody.Description = strDescription;
                objFileBody.MimeType    = strMIMEType;
                byte[] byteArray = System.IO.File.ReadAllBytes(strUploadFile);
                System.IO.MemoryStream objStream = new System.IO.MemoryStream(byteArray);
                try
                {
                    FilesResource.CreateMediaUpload objFileUpload = objService.Files.Create(objFileBody, objStream, strMIMEType);
                    objFileUpload.SupportsTeamDrives = true;
                    objFileUpload.Upload();
                    return(objFileUpload.ResponseBody);
                }
                catch (Exception e)
                {
                    {
                        MessageBox.Show(e.Message, "Error Occured");
                        return(null);
                    }
                }
            }
            else
            {
                MessageBox.Show("The file does not exist.", "404");
                return(null);
            }
        }
Пример #20
0
        static void Main(string[] args)
        {
            UserCredential credential;
            string         filePath1 = "C:/Users/Sorin/Desktop/Orar.txt";

            using (var stream =
                       new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
            {
                string credPath = "token.json";
                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets,
                    Scopes,
                    "user",
                    CancellationToken.None,
                    new FileDataStore(credPath, true)).Result;
                Console.WriteLine("Credential file saved to: " + credPath);
            }

            var service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = ApplicationName,
            });

            FilesResource.ListRequest listRequest = service.Files.List();
            listRequest.PageSize = 10;
            listRequest.Fields   = "nextPageToken, files(id, name)";

            IList <Google.Apis.Drive.v3.Data.File> files = listRequest.Execute().Files;

            Console.WriteLine("Files:");
            if (files != null && files.Count > 0)
            {
                foreach (var file in files)
                {
                    Console.WriteLine("{0} ({1})", file.Name, file.Id);
                }
            }
            else
            {
                Console.WriteLine("No files found.");
            }
            Console.Read();

            if (System.IO.File.Exists(filePath1))
            {
                Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
                body.Name = System.IO.Path.GetFileName(filePath1);
                byte[] byteArray = System.IO.File.ReadAllBytes(filePath1);
                System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);

                FilesResource.CreateMediaUpload request = service.Files.Create(body, stream, filePath1);
                request.SupportsTeamDrives = true;
                request.Upload();
            }
            else
            {
                System.Console.WriteLine("The file does not exist.");
            }
        }
 public Google.Apis.Drive.v3.Data.File uploadFile(DriveService _service, string _uploadFile, string _parent, string _descrp = "Uploaded with .NET!")
 {
     if (System.IO.File.Exists(_uploadFile))
     {
         Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
         body.Name        = System.IO.Path.GetFileName(_uploadFile);
         body.Description = _descrp;
         body.MimeType    = GetMimeType(_uploadFile);
         byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
         System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
         try
         {
             FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, GetMimeType(_uploadFile));
             request.SupportsTeamDrives = true;
             request.ProgressChanged   += Request_ProgressChanged;
             request.ResponseReceived  += Request_ResponseReceived;
             request.Upload();
             return(request.ResponseBody);
         }
         catch (Exception e)
         {
             MessageBox.Show(e.Message, "Error Occured");
             return(null);
         }
     }
     else
     {
         MessageBox.Show("The file does not exist.");
         return(null);
     }
 }
        /// <summary>
        /// Uploads a file
        /// Documentation: https://developers.google.com/drive/v2/reference/files/insert
        /// </summary>
        /// <param name="_service">a Valid authenticated DriveService</param>
        /// <param name="_uploadFile">path to the file to upload</param>
        /// <param name="_parent">Collection of parent folders which contain this file.
        ///                       Setting this field will put the file in all of the provided folders. root folder.</param>
        /// <returns>If upload succeeded returns the File resource of the uploaded file
        ///          If the upload fails returns null</returns>
        public static File uploadFile(DriveService _service, string _uploadFile, string _parent)
        {
            if (System.IO.File.Exists(_uploadFile))
            {
                File body = new File();
                body.Name        = System.IO.Path.GetFileName(_uploadFile);
                body.Description = "File uploaded by Diamto Drive Sample";
                body.MimeType    = GetMimeType(_uploadFile);
                //body.Parents = new List<ParentReference>() { new ParentReference() { Id = _parent } };

                // File's content.
                byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
                System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
                try
                {
                    FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, GetMimeType(_uploadFile));
                    //request.Convert = true;   // uncomment this line if you want files to be converted to Drive format
                    request.Upload();
                    return(request.ResponseBody);
                }
                catch (Exception e)
                {
                    Console.WriteLine("An error occurred: " + e.Message);
                    return(null);
                }
            }
            else
            {
                Console.WriteLine("File does not exist: " + _uploadFile);
                return(null);
            }
        }
 public Google.Apis.Drive.v3.Data.File uploadFile(DriveService _service, string _uploadFile, string _parent, string _descrp = "Uploaded with .NET!")
 {
     if (System.IO.File.Exists(_uploadFile))
     {
         Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
         body.Name        = System.IO.Path.GetFileName(_uploadFile);
         body.Description = _descrp;
         body.MimeType    = "image/jpeg";//GetMimeType(_uploadFile);
         // body.Parents = new List<string> { _parent };// UN comment if you want to upload to a folder(ID of parent folder need to be send as paramter in above method)
         byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
         System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
         try
         {
             FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, "image/jpeg");//GetMimeType(_uploadFile)
             request.SupportsTeamDrives = true;
             // You can bind event handler with progress changed event and response recieved(completed event)
             request.ProgressChanged  += Request_ProgressChanged;
             request.ResponseReceived += Request_ResponseReceived;
             request.Upload();
             return(request.ResponseBody);
         }
         catch (Exception e)
         {
             //MessageBox.Show(e.Message, "Error Occured");
             return(null);
         }
     }
     else
     {
         //MessageBox.Show("The file does not exist.", "404");
         return(null);
     }
 }
Пример #24
0
        /// <summary>
        /// Upload a new file to Google Drive
        /// </summary>
        /// <param name="service">DriveService</param>
        /// <param name="description">File description</param>
        /// <param name="fileName">File name</param>
        /// <param name="contentType">File content type</param>
        /// <param name="filepath">Full path of the current database file</param>
        /// <returns>Return status of the upload</returns>
        private string uploadFile(DriveService service, string description, string fileName, string contentType, string filePath)
        {
            File temp = new File();

            if (string.IsNullOrEmpty(fileName))
            {
                temp.Name = System.IO.Path.GetFileName(filePath);
            }
            else
            {
                temp.Name = fileName;
            }
            temp.Description = description;
            temp.MimeType    = contentType;

            byte[] byteArray = System.IO.File.ReadAllBytes(filePath);
            System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);

            FilesResource.CreateMediaUpload request = service.Files.Create(temp, stream, contentType);
            IUploadProgress progress = request.Upload();

            if (progress.Exception != null)
            {
                throw progress.Exception;
            }

            File file = request.ResponseBody;

            return(string.Format("Google Drive 文件已更新,文件名:{0},ID:{1}", file.Name, file.Id));
        }
Пример #25
0
        public static File createFile(DriveService _service, string _name, string _description, string _parent, MarkedFileData markedFile)
        {
            File NewFile = null;

            // Create metaData for a new Directory
            var fileMetadata = new File()
            {
                Name    = _name,
                Parents = new List <string>()
                {
                    _parent
                },
                //MimeType = "application/vnd.google-apps.folder",
                Description = _description
            };

            try
            {
                using System.IO.StreamReader reader = new System.IO.StreamReader(markedFile.fullPath);
                FilesResource.CreateMediaUpload request = _service.Files.Create(fileMetadata, reader.BaseStream, GetMimeType(markedFile.fullPath));
                request.Fields = "id";
                request.Upload();
                NewFile = request.ResponseBody;
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: " + e.Message);
            }

            return(NewFile);
        }
        internal bool UploadFile(string name, string mimeType, string parentId, Stream fileStream,
                                 IProgress <long> progress, Func <int, bool> shouldAbort)
        {
            var fileMetadata = new File
            {
                Name     = name,
                MimeType = mimeType,
                Parents  = new List <string> {
                    parentId
                }
            };

            FilesResource.CreateMediaUpload request =
                _driveService.Files.Create(fileMetadata, fileStream, fileMetadata.MimeType);
            request.Fields = "id";
            if (progress != null)
            {
                request.ProgressChanged += u => progress.Report(u.BytesSent);
            }

            IUploadProgress uploadProgress = request.Upload();

            int currentTry = 0;

            while (uploadProgress.Status != UploadStatus.Completed)
            {
                if (!shouldAbort(currentTry))
                {
                    return(false);
                }
                ++currentTry;
                request.Resume();
            }
            return(true);
        }
Пример #27
0
        public static File createFile(DriveService _service, string _title, string _description, string _parent, byte[] bytes)
        {
            var  watchi  = System.Diagnostics.Stopwatch.StartNew();
            File NewFile = null;
            File body    = new File();

            body.Name        = _title;
            body.Description = _description;
            body.Parents     = new List <string>()
            {
                _parent
            };
            try
            {
                System.IO.MemoryStream          stream = new System.IO.MemoryStream(bytes);
                FilesResource.CreateMediaUpload req    = _service.Files.Create(body, stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
                req.Upload();
                NewFile = req.ResponseBody;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message, "Error Occured2");
            }
            var elapsedMs = watchi.ElapsedMilliseconds;

            Console.WriteLine("time create file = " + elapsedMs / 1000 + " sec " + elapsedMs % 1000 + "msec");
            return(NewFile);
        }
Пример #28
0
        // https://stackoverflow.com/questions/45663027/resuming-interrupted-upload-using-google-drive-v3-c-sharp-sdk
        private string Test(Stream stream, string parent, string name, string originalFileName, string mimeType)
        {
            Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
            body.Name             = name;
            body.OriginalFilename = originalFileName;
            body.Parents          = new List <string>()
            {
                parent
            };
            body.MimeType = mimeType;

            FilesResource.CreateMediaUpload    createRequest = Service.Files.Create(body, stream, mimeType);
            Google.Apis.Upload.IUploadProgress progress      = createRequest.Upload();
            //createRequest.ContentStream
            if (progress.Status == Google.Apis.Upload.UploadStatus.Uploading)
            {
                // stream 이 seekable "해야할듯..
            }
            //createRequest.

            //createRequest.Resume()
            //Google.Apis.Upload.IUploadProgress progress = createRequest.Upload();
            //Google.Apis.Drive.v3.Data.File response = createRequest.ResponseBody;

            //return response.Id;

            return("");
        }
Пример #29
0
        /// <summary>
        /// This is manual approach for creating Fr8 trigger for some document, mainly used as backup plan for automatic apps script run
        /// </summary>
        /// <param name="authDTO"></param>
        /// <param name="formId"></param>
        /// <param name="desription"></param>
        /// <returns></returns>
        public async Task <string> CreateManualFr8TriggerForDocument(GoogleAuthDTO authDTO, string formId, string desription = "Script uploaded from Fr8 application")
        {
            string response = "";

            try
            {
                var driveService = await _googleDrive.CreateDriveService(authDTO);

                var formFilename = FormFilename(driveService, formId);

                Google.Apis.Drive.v3.Data.File scriptFile = new Google.Apis.Drive.v3.Data.File();
                scriptFile.Name        = "Script for: " + formFilename;
                scriptFile.Description = desription;
                scriptFile.MimeType    = "application/vnd.google-apps.script+json";

                // Create a memory stream
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    //load template file and replace specific formID
                    var    assembly     = Assembly.GetExecutingAssembly();
                    var    resourceName = "terminalGoogle.Template.googleAppScriptFormResponse.json";
                    string content;

                    using (Stream stream = assembly.GetManifestResourceStream(resourceName))
                        using (StreamReader reader = new StreamReader(stream))
                        {
                            content = reader.ReadToEnd();
                        }

                    content = content.Replace("@ID", formId);
                    content = content.Replace("@ENDPOINT", CloudConfigurationManager.GetSetting("GoogleFormEventWebServerUrl"));
                    byte[] contentAsBytes = Encoding.UTF8.GetBytes(content);
                    memoryStream.Write(contentAsBytes, 0, contentAsBytes.Length);

                    // Set the position to the beginning of the stream.
                    memoryStream.Seek(0, SeekOrigin.Begin);

                    //upload file to google drive
                    string existingFileLink = "";
                    if (!_googleDrive.FileExist(driveService, scriptFile.Name, out existingFileLink))
                    {
                        FilesResource.CreateMediaUpload request = driveService.Files.Create(scriptFile, memoryStream, "application/vnd.google-apps.script+json");
                        request.Upload();
                        response = request.ResponseBody.WebViewLink;
                    }
                    else
                    {
                        response = existingFileLink;
                    }
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }

            return(await Task.FromResult(response));
        }
        public static bool UploadFile(DriveService _service, string _uploadFile)
        {
            if (System.IO.File.Exists(_uploadFile))
            {
                Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
                body.Name     = System.IO.Path.GetFileName(_uploadFile);
                body.MimeType = MimeMapping.GetMimeMapping(_uploadFile);
                // note: convert to bytes if direct reading of database backup file does not work
                //byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
                //using (var stream = new System.IO.MemoryStream(byteArray))
                using (var stream = new System.IO.FileStream(_uploadFile, System.IO.FileMode.Open))
                {
                    try
                    {
                        //TODO: Create a logging mechanism and insert the error message (exception) in it

                        FilesResource.CreateMediaUpload request = _service.Files.Create(body, stream, body.MimeType);
                        request.SupportsAllDrives = true;
                        //note: below code can be used to show upload progression bar
                        // You can bind event handler with progress changed event and response recieved(completed event)
                        //request.ProgressChanged += Request_ProgressChanged;
                        //request.ResponseReceived += Request_ResponseReceived;
                        var result = request.Upload();

                        if (result.Status == UploadStatus.Completed)
                        {
                            return(true);
                        }

                        if (result.Status != UploadStatus.Completed || request == null || request.ResponseBody == null) //check status, now it's throwing here sometimes
                        {
                            return(false);
                        }

                        //if (request == null)
                        //    throw new Exception("Error! Sending The Request");

                        //if (request.ResponseBody == null)
                        //    throw new Exception("Error! Response body is null");

                        //var fileUploaded = request.ResponseBody;
                        //Npte:  A link for downloading a file in the browser if we use WebContentLink
                        //return fileUploaded.WebContentLink;
                        return(false);
                    }
                    catch (Exception ex)
                    {
                        //MessageBox.Show(ex.Message, "Error While Uploading The Database Backup To GoogleDrive");
                        return(false);
                    }
                }
            }
            else
            {
                //MessageBox.Show("The file does not exist.");
                return(false);
            }
        }