コード例 #1
0
ファイル: DriveManager.cs プロジェクト: TheCrafter/GooDPal
        public void InitService()
        {
            // Auth id and secret from google developers console
            string clientId = "354424347588-6bb4q1o8ufba3fu32tknk8elep233s4g.apps.googleusercontent.com";
            string clientSecret = "NOSdJs3FPwfyoI62A6sCrfjg";

            //Scopes for use with the Google Drive API
            string[] scopes = new string[]
            {
                DriveService.Scope.Drive
            //  ,DriveService.Scope.DriveFile
            };

            // here is where we Request the user to give us access, or use the Refresh Token that was previously stored in %AppData%
            UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                new ClientSecrets
                {
                    ClientId = clientId,
                    ClientSecret = clientSecret
                },
                scopes,
                Environment.UserName,
                CancellationToken.None,
                new FileDataStore(CredentialSavePath, true)).Result;

            mDriveService = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = AppName,
            });
        }
コード例 #2
0
ファイル: API.aspx.cs プロジェクト: addiaz/demo
        public void subirArchivo()
        {
            string ruta = @"C:\Users\addiaz\Desktop\DocumentosDrive\";
            string nombre = FileUpload1.PostedFile.FileName;
            string sExtension = ObtenerTipoArchivo(FileUpload1.FileName);

            UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                   new ClientSecrets
                   {
                       ClientId = "704651064787-6l6ce8uiculoenaqera0fa40kd53t6sn.apps.googleusercontent.com",
                       ClientSecret = "uonquuVkIoLXGWjhLSicKpUL",
                   },
                   new[] { DriveService.Scope.Drive }, "user", CancellationToken.None).Result;

            // Servicio para realizar peticiones al google drive.
            var service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = "Drive API Sample",
            });

            File body = new File();
            body.Title = nombre;
            body.Description = "A test document";
            body.MimeType = sExtension;

            // byte[] byteArray = System.IO.File.ReadAllBytes(Server.MapPath(nombre));
            byte[] byteArray = System.IO.File.ReadAllBytes("C:/Users/Adrian/Desktop/DcomuentosDrive/" + nombre);
            System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);

            FilesResource.InsertMediaUpload request = service.Files.Insert(body, stream, sExtension);
            request.Upload();
            File file = request.ResponseBody;
        }
コード例 #3
0
    public void Connect()
    {
        string[] Scopes = new string[] { DriveService.Scope.Drive,
                                     DriveService.Scope.DriveFile};
        string ApplicationName = "Drive API Quickstart";
        UserCredential credential;
        using (var stream =
                    new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
        {
            string credPath = System.Environment.GetFolderPath(
                System.Environment.SpecialFolder.Personal);
            credPath = Path.Combine(credPath, ".credentials");

            credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                GoogleClientSecrets.Load(stream).Secrets,
                Scopes,
                "user",
                CancellationToken.None,
                new FileDataStore(credPath, true)).Result;
            //Console.WriteLine("Credential file saved to: " + credPath);
        }

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

        listRequest.MaxResults = 1000;

        firstPageToken = listRequest.PageToken;
    }
コード例 #4
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 _parent, string Description)
        {

            if (System.IO.File.Exists(_uploadFile))
            {
                File body = new File();
                body.Name = System.IO.Path.GetFileName(_uploadFile);
                body.Description = Description;
                body.MimeType = GetMimeType(_uploadFile);
                body.Parents = new List<string> { _parent };

                // File's content.
                byte[] byteArray = System.IO.File.ReadAllBytes(_uploadFile);
                System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
                try
                {
                    var 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)
                {
                    return null;
                    throw;
                }
            }
            else {
                Console.WriteLine("File does not exist: " + _uploadFile);
                return null;
            }

        }
コード例 #5
0
        public static String /*File*/ uploadFile(DriveService service, string localFilePath)
        {
            if (System.IO.File.Exists(localFilePath))
            {
                //File's body
                File body = new File();
                body.Title = System.IO.Path.GetFileName(localFilePath);
                body.Description = "Uploaded by Popcorn-GDrive";
                body.MimeType = GetMimeType(localFilePath);

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

                try
                {
                    FilesResource.InsertMediaUpload request = service.Files.Insert(body, stream, GetMimeType(localFilePath));
                    request.Upload();

                    //String fileID = request.ResponseBody.Id;
                    return request.ResponseBody.Id;
                }

                catch(Exception e)
                {
                    throw;
                }
            }

            else
            {
                return null;
            }
        }
コード例 #6
0
        public static DriveService AuthenticateOauth(string clientID, string clientSecret, string userName)
        {
            //Google Drive scopes Documentation: https://developers.google.com/drive/web/scopes
            string[] scopes = new string[] {  DriveService.Scope.Drive, //View and manage files and documents
                                            DriveService.Scope.DriveAppdata, //View and manage its own configuration data
                                            DriveService.Scope.DriveAppsReadonly, //View and manage drive apps
                                            DriveService.Scope.DriveFile, //View and manage files created by Popcorn-GDrive
                                            DriveService.Scope.DriveMetadataReadonly, //View metadata for files
                                            DriveService.Scope.DriveReadonly, //View (only) files and documents on your drive
                                            /*DriveService.Scope.DriveScripts,*/ //View your app scripts
            };

            try
            {
                UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets { ClientId = clientID, ClientSecret = clientSecret }
                                                                                            , scopes
                                                                                            , userName
                                                                                            , CancellationToken.None
                                                                                            , new FileDataStore("Popcorn-GDrive.Auth.Store")).Result;

                DriveService service = new DriveService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Popcorn-GDrive",
                });
                return service;
            }

            catch (Exception e)
            {
                throw e;
                //Console.WriteLine(e.InnerException);
            }
        }
コード例 #7
0
        public static DriveService AuthenticateServiceAccount(string serviceAccountEmail, string keyFilePath, string applicationName)
        {
            if (!File.Exists(keyFilePath))
            {
                throw new FileNotFoundException("Given key file is not found", keyFilePath);
            }

            // Google Drive scopes Documentation:   https://developers.google.com/drive/web/scopes
            string[] scopes = new string[] { DriveService.Scope.Drive,  // view and manage your files and documents
                                             DriveService.Scope.DriveAppdata,  // view and manage its own configuration data
                                             DriveService.Scope.DriveAppsReadonly,   // view your drive apps
                                             DriveService.Scope.DriveFile,   // view and manage files created by this app
                                             DriveService.Scope.DriveMetadataReadonly,   // view metadata for files
                                             DriveService.Scope.DriveReadonly,   // view files and documents on your drive
                                             DriveService.Scope.DriveScripts };  // modify your app scripts

            var certificate = new X509Certificate2(keyFilePath, "notasecret", X509KeyStorageFlags.Exportable);

            var credential =
                new ServiceAccountCredential(new ServiceAccountCredential.Initializer(serviceAccountEmail)
                {
                    Scopes = scopes
                }.FromCertificate(certificate));

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

            return service;
        }
コード例 #8
0
        public DriveDataService(DriveService connectionService)
        {
            if (connectionService == null)
                throw new ArgumentNullException("connectionService == null");

            ConnectionService = connectionService;
        }
コード例 #9
0
        public static File InsertFile(DriveService service, string mimeType, string filename, System.IO.Stream stream)
        {
            // File's metadata.
            File body = new File();
            body.Title = filename;
            body.MimeType = mimeType;
            body.Parents = new List<ParentReference>() { new ParentReference() { Id = "0BySX8GhV2wf8enhxSU56N25Rbnc" } };

            try
            {
                FilesResource.InsertMediaUpload request = service.Files.Insert(body, stream, mimeType);
                request.Upload();

                File file = request.ResponseBody;
                // Uncomment the following line to print the File ID.
                // Console.WriteLine("File ID: " + file.Id);

                return file;
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: " + e.Message);
                return null;
            }
        }
コード例 #10
0
        public async Task Run(DriveService service)
        {
            
            GoogleAPIAuthorization googleApiAuthorization = GoogleAPIAuthorization.Instance;
            
            //File file = null;
            //Boolean exists = await IsApplicationDirectoryExist(service);
            //if (exists)
            //{
            //    //OK
            //}
            //else
            //{
                //await CreateApplicationDirectory(service);
                await googleApiAuthorization.Deauthorize(service);
                
                
                //await CreateApplicationDirectory(service);
                    
                //await googleApiAuthorization.Deauthorize(service);
                     
            //}

            
           // await googleApiAuthorization.Deauthorize(service);
            
        }
コード例 #11
0
        /// <summary>
        /// Create a service connection to google.
        /// </summary>
        /// <param name="userEmail">The API email to use for authentication.</param>
        /// <param name="gService">The type of service to connect to.</param>
        /// <returns>Returns an open connection to the google api service, or null.</returns>
        private static BaseClientService BuildService(string userEmail, GoogleServices gService = GoogleServices.Directory)
        {
            X509Certificate2 certificate = new X509Certificate2(Properties.Resources.gsd_api,"notasecret", X509KeyStorageFlags.Exportable);

            ServiceAccountCredential credential = new ServiceAccountCredential(
                new ServiceAccountCredential.Initializer(SERVICE_ACCOUNT_EMAIL)
                {
                    Scopes = Scopes,
                    User = userEmail
                }.FromCertificate(certificate));

            switch (gService)
            {
                case GoogleServices.Directory:
                    DirectoryService directoryService = new DirectoryService(new BaseClientService.Initializer()
                        {
                            HttpClientInitializer = credential,
                            ApplicationName = "GSD GAMS",
                        });
                    return directoryService;
                case GoogleServices.Drive:
                    DriveService driveService = new DriveService(new BaseClientService.Initializer()
                        {
                            HttpClientInitializer = credential,
                            ApplicationName = "GSD GAMS",
                        });
                    return driveService;
            }
            return null;
        }
コード例 #12
0
ファイル: HomeController.cs プロジェクト: Vethro/Learning
        public async Task<ActionResult> ListDrive(CancellationToken cancellationToken)
        {
            UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
            new ClientSecrets
            {
                ClientId = "904595749350-0m2f89cjfmhq8a9pplo62njot4pk977a.apps.googleusercontent.com",
                ClientSecret = "l6Inr8ki5h95x8QElYWxiwHS"
            },
            new[] { DriveService.Scope.Drive },
            "user",
            CancellationToken.None).Result;

            //var ctx = Request.GetOwinContext();
            //var result = ctx.Authentication.AuthenticateAsync("ExternalCookie").Result;
            
            var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = result,
                    ApplicationName = "ASP.NET MVC Sample"
                });

            var list = await service.Files.List().ExecuteAsync();
            ViewBag.Message = "Files from google drive";
            return View(list);
        }
コード例 #13
0
        public static DriveService GetDriveService()
        {
            UserCredential credential;

            using (var stream =
                new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
            {
                var credPath = Environment.GetFolderPath(
                    Environment.SpecialFolder.Personal);
                credPath = Path.Combine(credPath, ".credentials/drive-dotnet-quickstart");

                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets,
                    Scopes,
                    "user",
                    CancellationToken.None,
                    new FileDataStore(credPath, true)).Result;
                Console.WriteLine("Credential file saved to: " + credPath);
            }

            // Create Drive API service.
            var service = new DriveService(new BaseClientService.Initializer
            {
                HttpClientInitializer = credential,
                ApplicationName = ApplicationName
            });
            return service;
        }
コード例 #14
0
 public static List<File> GetChildrenFiles(DriveService service, string idParent)
 {
     List<File> result = new List<File>();
     FilesResource.ListRequest request = service.Files.List();
     request.MaxResults = 1000;
     request.Q = ("'" + idParent + "'" + " IN parents");
     int i = 0;
     do
     {
         try
         {
             using (var client = new WebClient())
             {
                 FileList files = request.Execute();
                 result.AddRange(files.Items);
                 request.PageToken = files.NextPageToken;
                 i++;
             }
         }
         catch (Exception e)
         {
             Console.WriteLine("An error occurred: " + e.Message);
             request.PageToken = null;
         }
     } while (!String.IsNullOrEmpty(request.PageToken));
     return result;
 }
コード例 #15
0
        /// <summary>
        /// 구글의 Oauth 2.0을 사용하여 유저 정보를 가져온다.
        /// </summary>
        /// <param name="clientId">Developer console에서 발급받은 userid</param>
        /// <param name="clientSecret">Developer console에서 발급받은 보안 번호</param>
        /// <param name="userName">사용자를 구별하기 위한 유저 이름 (닉네임)</param>
        /// <returns></returns>
        public static DriveService AuthenticateOauth(string clientId, string clientSecret, string userName)
        {

            //Google Drive scopes Documentation:   https://developers.google.com/drive/web/scopes
            string[] scopes = new string[] { DriveService.Scope.Drive,  //Google 드라이브에서 파일 보기 및 관리
                                             DriveService.Scope.DriveAppdata,  //Google 드라이브에서 설정 데이터 조회 및 관리
                                             DriveService.Scope.DriveAppsReadonly,   // Google 드라이브 앱 조회
                                             DriveService.Scope.DriveFile,   // 이 앱으로 열거나 만든 Google 드라이브 파일과 폴더 조회 및 관리
                                             DriveService.Scope.DriveMetadataReadonly,   // Google 드라이브에서 파일의 메타데이터 보기
                                             DriveService.Scope.DriveReadonly,   // Google 드라이브에서 파일 보기
                                             DriveService.Scope.DriveScripts };  // Google Apps Script 스크립트의 행동 변경
            try
            {
                // 신규 유저 접근 권한을 받아오거나 혹은 저장되어 있는 (기본 위치 C:\Users\bit-user\AppData\Roaming\)에 토큰을 가지고 유저정보를 가져온다.
                UserCredential credential = GoogleWebAuthorization.LoginAuthorizationCodeFlowAsync(new ClientSecrets { ClientId = clientId, ClientSecret = clientSecret }
                                                                                             , scopes
                                                                                             , userName
                                                                                             , CancellationToken.None
                                                                                             , new FileDataStore("Daimto.Drive.Auth.Store")).Result;
                // 받아온 유저의 정보를 이용하여 google drive 에 연결한다.
                DriveService service = new DriveService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "GoogleCloude Sample",
                });
                return service;
            }
            catch (Exception ex)
            {
                return null;
            }

        }
コード例 #16
0
ファイル: GoogleDrive.cs プロジェクト: dance2die/DriveGallery
 private File GetFileByID(string fileID, DriveService service)
 {
     File file = service.Files.Get(fileID).Execute();
     if (file.ExplicitlyTrashed == null)
         return file;
     return null;
 }
コード例 #17
0
ファイル: Updater.cs プロジェクト: Cryofox/Launcher_OD
        /*      public Boolean DownloadFile(DriveService service, GFile _fileResource, string _saveTo)
        {
            try {
                  //File file = service.Files.Get(fileId).Execute();
                FilesResource.GetRequest request = service.Files.Get(_fileResource.Id);
                request.url
                  return true;
                }
            catch (Exception e) {
                return false;
                }
        }*/
        public Boolean DownloadFile(DriveService service, GFile _fileResource, string _saveTo)
        {
            GFile newFile = service.Files.Get(_fileResource.Id).Execute();
            if (!String.IsNullOrEmpty(_fileResource.DownloadUrl))
            {
                using (FileStream fs = System.IO.File.Create(_saveTo))
                {
                    //Byte[] info = new UTF8Encoding(true).GetBytes("This is some text in the file.");
                    // Add some information to the file.

                    var x = service.HttpClient.GetByteArrayAsync(newFile.DownloadUrl);
                    byte[] arrBytes = x.Result;
                    //fs.WriteAllBytes(_saveTo, arrBytes);
                    fs.Write(arrBytes, 0, arrBytes.Length);
                    //fs.WriteAsync()
                    //fs.Write(arrBytes, 0, arrBytes.Length);
                    return true;
                }
            }
            else
            {
                // The file doesn't have any content stored on Drive.
                //winform.AddText("Error2");
                return false;
            }
            return false;
        }
コード例 #18
0
ファイル: HomeController.cs プロジェクト: peleyal/peleyal
        public async Task<ActionResult> DriveAsync(CancellationToken cancellationToken)
        {
            ViewBag.Message = "Your drive page.";

            var result = await new AuthorizationCodeMvcApp(this, new AppAuthFlowMetadata()).
                AuthorizeAsync(cancellationToken);

            if (result.Credential == null)
                return new RedirectResult(result.RedirectUri);

            var driveService = new DriveService(new BaseClientService.Initializer
            {
                HttpClientInitializer = result.Credential,
                ApplicationName = "ASP.NET Google APIs MVC Sample"
            });

            var listReq = driveService.Files.List();
            listReq.Fields = "items/title,items/id,items/createdDate,items/downloadUrl,items/exportLinks";
            var list = await listReq.ExecuteAsync();
            var items = 
                (from file in list.Items
                         select new FileModel
                         {
                             Title = file.Title,
                             Id = file.Id,
                             CreatedDate = file.CreatedDate,
                             DownloadUrl = file.DownloadUrl ?? 
                                           (file.ExportLinks != null ? file.ExportLinks["application/pdf"] : null),
                         }).OrderBy(f => f.Title).ToList();

            return View(items);
        }
コード例 #19
0
        public IDriveService Create()
        {
            const string applicationName = "GoogleDriveOfflineBackup";
            var scopes = new[] { DriveService.Scope.DriveReadonly };
            UserCredential credential;
            Console.WriteLine("Searching for settings file");
            CredentialsProvider credentialsProvider = new CredentialsProvider();
            string secretFile = credentialsProvider.LocateSettingsFile();
            using (var stream = new FileStream(secretFile, FileMode.Open, FileAccess.Read))
            {
                string personalPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
                string credentialsPath = Path.Combine(personalPath, ".credentials");
                string appCredentialsPath = Path.Combine(credentialsPath, "GoogleDriveOfflineBackup");
                Console.WriteLine("Authorizing {0}", appCredentialsPath);
                var secrets = GoogleClientSecrets.Load(stream).Secrets;
                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    secrets,
                    scopes,
                    "user",
                    CancellationToken.None,
                    new FileDataStore(appCredentialsPath, fullPath: true)).Result; // blocking!

                Console.WriteLine("Credentials written to {0}", appCredentialsPath);
            }

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

            return new DriveServiceWrapper(service);
        }
コード例 #20
0
        /// <summary>
        /// Authenticate to Google Using Oauth2
        /// Documentation https://developers.google.com/accounts/docs/OAuth2
        /// </summary>
        /// <param name="clientId">From Google Developer console https://console.developers.google.com</param>
        /// <param name="clientSecret">From Google Developer console https://console.developers.google.com</param>
        /// <param name="userName">A string used to identify a user.</param>
        /// <returns></returns>
        public static DriveService AuthenticateOauth(string clientId, string clientSecret, string userName)
        {
            //Google Drive scopes Documentation:   https://developers.google.com/drive/web/scopes
            string[] scopes = new string[] { DriveService.Scope.Drive,  // view and manage your files and documents
                                             DriveService.Scope.DriveAppdata,  // view and manage its own configuration data
                                             DriveService.Scope.DriveAppsReadonly,   // view your drive apps
                                             DriveService.Scope.DriveFile,   // view and manage files created by this app
                                             DriveService.Scope.DriveMetadataReadonly,   // view metadata for files
                                             DriveService.Scope.DriveReadonly,   // view files and documents on your drive
                                             DriveService.Scope.DriveScripts };  // modify your app scripts

            try
            {
                // here is where we Request the user to give us access, or use the Refresh Token that was previously stored in %AppData%
                UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets { ClientId = clientId, ClientSecret = clientSecret }
                                                                                             , scopes
                                                                                             , userName
                                                                                             , CancellationToken.None
                                                                                             , new FileDataStore("Pet.Store")).Result;

                DriveService service = new DriveService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Pet Store Api",
                });

                return service;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.InnerException);
                return null;
            }
        }
コード例 #21
0
        /// <summary>
        /// Updates a file
        /// Documentation: https://developers.google.com/drive/v2/reference/files/update
        /// </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>
        /// <param name="_fileId">the resource id for the file we would like to update</param>                      
        /// <returns>If upload succeeded returns the File resource of the uploaded file 
        ///          If the upload fails returns null</returns>
        public static File updateFile(DriveService _service, string _uploadFile, string _parent,string _fileId)
        {

            if (System.IO.File.Exists(_uploadFile))
            {
                File body = new File();
                body.Title = System.IO.Path.GetFileName(_uploadFile);
                body.Description = "File updated 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.UpdateMediaUpload request = _service.Files.Update(body, _fileId, 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;
            }

        }
コード例 #22
0
        public MainWindow()
        {
            string[] scopes = new string[] { DriveService.Scope.Drive };
            InitializeComponent();
            var keyFilePath = @"c:\file.p12";    // Downloaded from https://console.developers.google.com
            var serviceAccountEmail = "*****@*****.**";  // found https://console.developers.google.com

            //loading the Key file
            var certificate = new X509Certificate2(keyFilePath, "notasecret", X509KeyStorageFlags.Exportable);
            var credential = new ServiceAccountCredential(new ServiceAccountCredential.Initializer(serviceAccountEmail)
            {
                Scopes = scopes
            }.FromCertificate(certificate));
            var service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = "Drive API Sample",
            });
            FilesResource.ListRequest request = service.Files.List();
            FileList files = request.Execute();
            foreach (var file in files.Items)
            {
                Console.WriteLine(file.Title);
            }
        }
コード例 #23
0
 public static void ValidHttpClientInitializer(DriveService service)
 {
     if (service.HttpClientInitializer == null)
     {
         throw new AuthenticationException("Authentication error! Please use the Authentication class to initialize the Google Drive service!");
     }
 }
コード例 #24
0
ファイル: Program.cs プロジェクト: LDibiase/PepitoTW
        public static DriveService AuthenticateServiceAccount(string serviceAccountEmail, string keyFilePath)
        {
            if (!System.IO.File.Exists(keyFilePath))
            {
                //Console.WriteLine("Key File does not exist");
                return null;
            }

            string[] scopes = new string[] { DriveService.Scope.Drive };
            var certificate = new X509Certificate2(keyFilePath, "notasecret", X509KeyStorageFlags.Exportable);

            try
            {
                ServiceAccountCredential credential = new ServiceAccountCredential(
                    new ServiceAccountCredential.Initializer(serviceAccountEmail)
                    {
                        Scopes = scopes
                    }.FromCertificate(certificate));

                DriveService service = new DriveService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "PepitoTW"
                });
                //Console.WriteLine("Authenticate Success");
                return service;
            }
            catch (Exception ex)
            {
                //Console.WriteLine(ex.InnerException);
                return null;
            }
        }
コード例 #25
0
        public static IList<File> GetFiles(DriveService service, string search)
        {
            IList<File> Files = new List<File>();

            try
            {
                FilesResource.ListRequest list = service.Files.List();
                list.MaxResults = 1000;
                if (search != null)
                {
                    list.Q = search;
                }
                FileList filesFeed = list.Execute();

                while (filesFeed.Items != null)
                {
                    foreach (File item in filesFeed.Items)
                    {
                        Files.Add(item);
                    }

                    if (filesFeed.NextPageToken == null)
                    {
                        break;
                    }
                    list.PageToken = filesFeed.NextPageToken;
                    filesFeed = list.Execute();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return Files;
        }
        public void UploadUnauthenticatedServiceShouldThrowTest()
        {
            var unauthenticated = new DriveService();

            var fileName = TestFile;
            DaimtoGoogleDriveHelper.UploadFile(unauthenticated, fileName, rootDirectoryID);
        }
コード例 #27
0
        public static async Task<ConnectionResult> ConnectToGoogleDrive(Controller controller, CancellationToken token)
        {
            string userId = controller.User.Identity.GetUserId();

            GoogleDriveService service = null;
            if (ServiceCache.TryGetValue(userId, out service))
                return new ConnectionResult(service, null);

            var result = await new AuthorizationCodeMvcApp(controller, new AppFlowMetadata()).AuthorizeAsync(token);

            if (result.Credential == null)
            {
                return new ConnectionResult(null, result.RedirectUri);
            }

            var Service = new DriveService(new BaseClientService.Initializer
            {
                HttpClientInitializer = result.Credential,
                ApplicationName = GoogleDriveSettings.APP_NAME
            });

            service = new GoogleDriveService(new DriveDataService(Service));

            ServiceCache[userId] = service;

            return new ConnectionResult(service, null);
        }
コード例 #28
0
        public void Login()
        {
            
            

           // creeaza si stocheaza obiectul credentiale
            using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
            {
                string credPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
                credPath = Path.Combine(credPath, ".credentials/drive-dotnet-quickstart");
                Credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets,
                    new[] { DriveService.Scope.Drive},
                    "user",
                    CancellationToken.None,
                    new FileDataStore(credPath, true)).Result;
            //    Directory.Delete(credPath, true);
            }

            //creeaza serviciul 
            Service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = Credential,
                ApplicationName = "Sorin Drive API",
            });

           

            
        }
コード例 #29
0
        public static string DeleteFileById(DriveService service, string id)
        {
            Validator.IsStringNullOrEmpty(id, "File id");
            Validator.ValidHttpClientInitializer(service);

            string request = service.Files.Delete(id).Execute();
            return request;
        }
        public void Init()
        {
            clientID = "122586258718-lbpu876ap5o81fib62egce3aiqa87bpu.apps.googleusercontent.com";
            clientSecret = "JxjLSk0O0tYNjAeoW39qBGbH";
            rootDirectoryID = "0B9-BhHxB4VqLcmh1TXZYV1NkZGc";

            service = Authentication.AuthenticateOauth(clientID, clientSecret, Environment.UserName);
        }
コード例 #31
0
        public string SaveToDrive(HttpPostedFileBase file1)
        {
            try
            {
                UserCredential credential;

                using (var stream =
                           new FileStream(Server.MapPath("~/Documents/credentials.json"), FileMode.Open, FileAccess.ReadWrite))
                {
                    // The file token.json stores the user's access and refresh tokens, and is created
                    // automatically when the authorization flow completes for the first time.
                    string credPath = Server.MapPath("~/Documents/token.json");
                    credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                        GoogleClientSecrets.Load(stream).Secrets,
                        Scopes,
                        "admin",
                        CancellationToken.None,
                        new FileDataStore(credPath, true)).Result;
                    Console.WriteLine("Credential file saved to: " + credPath);
                }
                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName       = ApplicationName,
                });

                string _parent = "1licsmd8Lz5OZ2ROE9wEcW1sw1IiY4uGi";
                Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
                body.Name        = System.IO.Path.GetFileName(file1.FileName);
                body.Description = "Inward Entry Doc";
                body.MimeType    = GetMimeType(file1.FileName);
                if (!string.IsNullOrEmpty(_parent))
                {
                    body.Parents = new List <string>()
                    {
                        _parent
                    };
                }


                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name    = file1.FileName,
                    Parents = new List <string>
                    {
                        _parent
                    }
                };

                // File's content.
                System.IO.BinaryReader b       = new System.IO.BinaryReader(file1.InputStream);
                byte[] byteArray               = b.ReadBytes(file1.ContentLength);
                System.IO.MemoryStream _stream = new System.IO.MemoryStream(byteArray);

                FilesResource.CreateMediaUpload request = service.Files.Create(body, _stream, GetMimeType(file1.FileName));
                request.Alt    = FilesResource.CreateMediaUpload.AltEnum.Json;
                request.Fields = "id";

                request.Upload();
                var d = request.ResponseBody;
                return(d.Id);
            }
            catch (Exception e)
            {
                return("Error " + e.InnerException.ToString());
            }
        }
コード例 #32
0
        static void Main(string[] args)
        {
            TCPServer <TCPData> server = new TCPServer <TCPData>();

            server.Start();
            server.OnDataReceived += Server_OnDataReceived;
            Console.ReadLine();
            return;

            if (!Directory.Exists(billPath))
            {
                Directory.CreateDirectory(billPath);
            }

            TesseractEngine engine = new TesseractEngine(Directory.GetCurrentDirectory(), "ces");

            Pix img = Pix.LoadFromFile("unnamed1.jpg");

            Page   p = engine.Process(img, PageSegMode.Auto);
            string s = p.GetText();

            Console.WriteLine(s);

            Console.ReadLine();

            UserCredential credential;

            using (FileStream stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read)) {
                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets,
                    new string[1] {
                    DriveService.Scope.Drive
                },
                    "user",
                    CancellationToken.None,
                    new FileDataStore(folderPath, true)).Result;
            }

            // Create Drive API service.
            DriveService service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential, ApplicationName = "Bill Scanner"
            });

            FilesResource.ListRequest listRequest = service.Files.List();

            //TODO: if other ways are found, this has to be edited
            listRequest.Q = "mimeType != 'application/vnd.google-apps.folder' and name contains 'Dokument aplikace' and name contains 'Google Keep'";


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

            Console.WriteLine("Files to download ({0}):", files.Count);

            if (files.Count == 0)
            {
                Console.WriteLine("No Files found in the drive!");
                End();
                return;
            }

            ShopsDefinition def = new ShopsDefinition();

            foreach (Google.Apis.Drive.v3.Data.File file in files)
            {
                Console.WriteLine("{0} ({1})", file.Name, file.Id);
                if (file.Name.Contains("Google") || file.Name.Contains("Keep"))
                {
                    Stream fs;
                    string fileName = billPath + file.Name + "-" + file.Id.Replace("-", "") + ".txt";
                    try {
                        fs = new FileStream(fileName, FileMode.CreateNew);
                    }
                    catch (IOException e) {
                        Console.WriteLine(e.Message);
                        continue;
                    }
                    service.Files.Export(file.Id, "text/plain").DownloadWithStatus(fs);
                    fs.Close();
                    fs.Dispose();
                    //TODO delete file from drive
                    string content            = File.ReadAllText(fileName);
                    ShopsDefinition.Shop shop = def.GetShopType(content);
                    switch (shop)
                    {
                    case ShopsDefinition.Shop.LIDL: {
                        Shops.Lidl l = new Shops.Lidl();
                        //l.Parse(content);
                        break;
                    }

                    case ShopsDefinition.Shop.MC_DONALDS: {
                        Shops.McDonalds m = new Shops.McDonalds();
                        //m.Parse(content);
                        break;
                    }

                    case ShopsDefinition.Shop.ŠMAK: {
                        Shops.BilboSmak bs = new Shops.BilboSmak();
                        //bs.Parse(content);
                        break;
                    }

                    case ShopsDefinition.Shop.ALBERT: {
                        Shops.Albert a = new Shops.Albert();
                        //a.Parse(content);
                        break;
                    }
                    }
                }
            }
            End();
        }
コード例 #33
0
ファイル: DriveRepository.cs プロジェクト: adisadi/wotget
 public DriveRepository(string keyFile)
 {
     driveService = DriveHelper.Authenticate(keyFile);
     GetOrCreateModPackDirectory();
 }
コード例 #34
0
ファイル: Program.cs プロジェクト: DenisiaBianca/datc2020
        static void Main(string[] args)
        {
            UserCredential credential;

            using (var stream =
                       new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
            {
                // The file token.json stores the user's access and refresh tokens, and is created
                // automatically when the authorization flow completes for the first time.
                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);
            }

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

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

            // List files.
            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.WriteLine("/n Add a file");
            Console.WriteLine("File name: ");

            string folderName = Console.ReadLine();

            var fileMetadata = new Google.Apis.Drive.v3.Data.File()
            {
                Name     = folderName,
                MimeType = "application/pdf"
            };
            var request = service.Files.Create(fileMetadata);

            request.Fields = "id";
            var filee = request.Execute();

            Console.WriteLine("Folder ID: " + filee.Id);
        }
コード例 #35
0
        //220680762635-qg38qgp1g1bbmkdjma1o50df199sbsjm.apps.googleusercontent.com
        //3Iub0pwzrs3-tCB4UyP4dgig
        //220680762635-qg38qgp1g1bbmkdjma1o50df199sbsjm.apps.googleusercontent.com
        public static void DownloadGrids()
        {
            FileStream fileStream = null;

            try
            {
                UserCredential credential;

                using (var stream = new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
                {
                    // The file token.json stores the user's access and refresh tokens, and is created
                    // automatically when the authorization flow completes for the first time.
                    string credPath = "token.json";
                    credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                        GoogleClientSecrets.Load(stream).Secrets,
                        Scopes,
                        "user",
                        CancellationToken.None,
                        new FileDataStore(credPath, true)).Result;
                }

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName       = "miqocrafter",
                });

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

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

                if (files != null && files.Count > 0)
                {
                    foreach (var file in files)
                    {
                        if (file.Name == "Release.zip")
                        {
                            //Delete old zip if any
                            FileInfo zipPath = new FileInfo(Path.Combine(Service_Misc.GetExecutionPath(), "Release.zip"));
                            if (zipPath.Exists)
                            {
                                zipPath.Delete();
                            }

                            //Download new zip
                            String fileId = file.Id;
                            fileStream = File.Create(zipPath.FullName);
                            Stream stream = fileStream;
                            service.Files.Get(fileId).Download(stream);
                            fileStream.Close();
                            fileStream = null;

                            //Unzip
                            fileStream = File.OpenRead(zipPath.FullName);
                            using (ZipArchive archive = new ZipArchive(fileStream))
                            {
                                archive.ExtractToDirectory(Service_Misc.GetExecutionPath(), true);
                            }
                            fileStream.Close();
                            fileStream = null;
                        }
                    }
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc.Message);
            }
            if (null != fileStream)
            {
                fileStream.Close();
            }
        }
コード例 #36
0
 /// <summary>
 /// Gets the root folder identifier.
 /// </summary>
 /// <param name="service">The service.</param>
 /// <returns>The root folder identifier as <see cref="string"/>.</returns>
 private string GetRootFolderId(DriveService service)
 {
     return(this.customGDriveService.GetRootFolderId(service));
 }
コード例 #37
0
 /// <summary>
 /// Gets the total quota.
 /// </summary>
 /// <param name="service">The service.</param>
 /// <returns>The total quota as <see cref="long"/>.</returns>
 private long GetQuotaTotal(DriveService service)
 {
     return(this.customGDriveService.GetQuotaTotal(service));
 }
コード例 #38
0
        public void getauthorization()
        {
            UserCredential credential;

            using (var stream =
                       new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
            {
                string credPath = System.Environment.GetFolderPath(
                    System.Environment.SpecialFolder.Personal);
                credPath = Path.Combine(credPath, ".credentials111/drive-dotnet-quickstart.json");

                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets, new[] { DriveService.Scope.Drive }
                    ,
                    "user",
                    CancellationToken.None,
                    new FileDataStore(credPath, true)).Result;
                Console.WriteLine("Credential file saved to: " + credPath);
            }

            // Create Drive API service.
            service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = "MIM Project",
            });

            /*      string pageToken = null;
             *    string fileId = "";
             *    do
             *    {
             *        var request = service.Files.List();
             *        // request.Q = "mimeType = 'application/vnd.google-apps.folder' ";
             *       // string parent_id = "0B1auUUiGcbbBOEIyNjg0alkwc3c";
             *        request.Q = "name contains 'Disposition Table for MIM 10/07/19' ";
             *        request.Spaces = "Drive";
             *        request.Fields = "nextPageToken, files(id, name)";
             *        request.PageToken = pageToken;
             *
             *        var result = request.Execute();
             *        foreach (var file in result.Files)
             *        {
             *           // if (file.Name == "Rack Delivery Plan [go/rackdeliveryplan]")
             *           // {
             *                fileId = file.Id;
             *                break;
             *           // }
             *        }
             *        pageToken = result.NextPageToken;
             *    } while (pageToken != null);
             */
            //  string message = fileId;
            string fileId   = "1ZnnRVMvx0Ma4GUih2wq3hcJK1vg0LbxoXmKCzwlz1j4";//1Y4hdHIkkVv5SmGtj8QWM-jAccZdEOhhV6Ofx_kb3IBs"; //"1OSr1IqrUjqo3RdAn1WwoNpTf2v64jzY3rKgJ8SS3hf4";//"11emBYnY-_tLQ43TFEAWIsMEtVgwyXEaAmVCPxcnp6Ag";// "1Y4hdHIkkVv5SmGtj8QWM-jAccZdEOhhV6Ofx_kb3IBs";//
            string fileName = "\\\\mimsftp\\e$\\sftp\\msgGoogle\\MDS\\PROD\\inbound\\DISPOSITION\\INBOUND\\Decom Disposition Table For MIM.xlsx";

            if (downloadFile(service, fileId, fileName))
            {
                runJob();
                //  RunPackage();
            }
        }
コード例 #39
0
 private static IList <File> GetFiles(DriveService service)
 {
     return(service.Files.List().Execute().Files);
 }
コード例 #40
0
 public FileList GetAllFiles(DriveService service)
 {
     return(getFileMetadata(null, service).Result);
 }
コード例 #41
0
 public GoogleDriveFolderController(IEnumerable <string> grantedUsers, IGoogleAccountProvider accountProvider)
 {
     _grantedUsers = grantedUsers.ToList();
     _service      = accountProvider.CreateDriveService();
 }
コード例 #42
0
 /// <summary>
 /// Initializes module with drive service
 /// </summary>
 /// <param name="service"></param>
 public ServiceModule(DriveService service)
 {
     driveService = service;
 }
コード例 #43
0
        public async Task <ActionResult <Product> > PostProduct([FromBody] InsertProductViewModel model)
        {
            if (String.IsNullOrEmpty(model.productId))
            {
                return(Ok("Mã sản phẩm không được để trống."));
            }

            if (!CategoryExists(model.categoryId))
            {
                return(NotFound());
            }
            foreach (var item in model.supplies)
            {
                if (!SupplierExists(item))
                {
                    return(NotFound());
                }
            }
            if (string.IsNullOrEmpty(model.images))
            {
                return(Ok("Vui lòng chọn hình ảnh đính kèm."));
            }

            if (model.images.Length > 1048576)
            {
                return(Ok("Kích thước không vượt quá 1mb"));
            }

            string path = _webhostEnvieronment.WebRootPath + "\\uploads\\";

            string filename = model.productId + ".png";

            try
            {
                Base64ToImage(model.images, path + filename);
                //if (model.images.Length > 0)
                //{

                //    if (!Directory.Exists(path))
                //    {
                //        Directory.CreateDirectory(path);
                //    }
                //    using (FileStream file = System.IO.File.Create(path + model.images.FileName))
                //    {
                //        model.Image.CopyTo(file);
                //        file.Flush();
                //    }
                //}
            }
            catch (Exception e)
            {
                return(Ok(e.Message));
            }

            UserCredential credential;

            credential = GetCredentials();

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

            //Id của folder muốn upload
            string folderid = "1iCNelsHCSLGKQL9XRJwMu9nUHZURFgR8";

            var filePath = path + filename;

            string fileId = "1paIUZyOqIW5ZllHXE0b6r-kZWJHQMQYR";

            try
            {
                fileId       = UploadImage(filePath, service, folderid);
                model.images = fileId;
            }
            catch (Exception e)
            {
                return(Ok(e.Message));
            }

            var product = model.ToProduct();

            WareHouse ware = new WareHouse();

            ware.Date      = DateTime.Now;
            ware.ProductId = product.ProductId;
            ware.Quantity  = 0;

            product.WareHouses.Add(ware);

            _context.Products.Add(product);

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (ProductExists(product.ProductId))
                {
                    return(Conflict());
                }
                else
                {
                    throw;
                }
            }

            return(CreatedAtAction("GetProductDetails", new { productId = product.ProductId }, product));
        }
コード例 #44
0
        public void UploadDoc()
        {
            UserCredential credential;

            using (var stream =
                       new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
            {
                string credPath = System.Environment.GetFolderPath(
                    System.Environment.SpecialFolder.Personal);
                credPath = Path.Combine(credPath, ".credentials/drive-dotnet-quickstart.json");

                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets, new[] { DriveService.Scope.Drive }
                    ,
                    "user",
                    CancellationToken.None,
                    new FileDataStore(credPath, true)).Result;
                Console.WriteLine("Credential file saved to: " + credPath);
            }

            // Create Drive API service.
            service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = "MIM Project",
            });

            string ArchiveParentid = "";
            string MainParentid    = "";

            string pageToken = null;
            string fileId    = "";

            do
            {
                var request = service.Files.List();
                // request.Q = "mimeType = 'application/vnd.google-apps.folder' ";

                request.Q         = "mimeType = 'application/vnd.google-apps.folder'";
                request.Spaces    = "Drive";
                request.Fields    = "nextPageToken, files(id, name)";
                request.PageToken = pageToken;

                var result = request.Execute();
                foreach (var file in result.Files)
                {
                    if (file.Name == "MIM First Article Folder")
                    {
                        MainParentid = file.Id;
                        break;
                    }
                }



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



            do
            {
                var request = service.Files.List();
                // request.Q = "mimeType = 'application/vnd.google-apps.folder' ";
                string parent_id = MainParentid;
                request.Q         = "'" + parent_id + "' in parents";
                request.Spaces    = "Drive";
                request.Fields    = "nextPageToken, files(id, name)";
                request.PageToken = pageToken;

                var result = request.Execute();
                foreach (var file in result.Files)
                {
                    if (file.Name == "First Article Sheet (2015W34)")
                    {
                        fileId = file.Id;
                        break;
                    }
                }
                pageToken = result.NextPageToken;
            } while (pageToken != null);


            try
            {
                Google.Apis.Drive.v3.Data.File body = new Google.Apis.Drive.v3.Data.File();
                body.Name        = "TEST CSV DOC";
                body.Description = "TEST CSV DOC";
                body.MimeType    = "text/csv";

                filename1 = filename1.Replace("file:\\", " ");
                filename1 = "e:\\ACCPurchaseOrderDetail.csv";
                // MessageBox.Show("filename=" + filename);
                System.IO.Stream fileStream = System.IO.File.Open(filename1, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                byte[]           byteArray  = new byte[fileStream.Length];
                fileStream.Read(byteArray, 0, (int)fileStream.Length);
                System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
                // FilesResource.UpdateMediaUpload request = service.Files.Update(body, fileId, stream, "text/csv");//application/x-vnd.oasis.opendocument.spreadsheet");
                FilesResource.CreateMediaUpload request1 = service.Files.Create(body, stream, "application/x-vnd.oasis.opendocument.spreadsheet");

                request1.Upload();
                MessageBox.Show("File has been uploaded in shared doc");
                fileStream.Close();
                fileStream.Dispose();
            }
            catch (Exception exp)
            {
                MessageBox.Show("Exception to upload file");
            }
            finally
            {
            }
        }
コード例 #45
0
 public GDriveFile()
 {
     service       = GDriveHelper.GetService();
     this.Children = new List <GDriveFile>();
 }
コード例 #46
0
ファイル: DriveUtils.cs プロジェクト: croissantderp/geckobot
        // Gets path from cache or downloads image to cache from drive
        public static string ImagePath(int num, bool isAlt, bool refresh = false)
        {
            Commands.Gec.RefreshGec();
            FileUtils.checkForCacheExistance();

            string name = addZeros(num);

            if (isAlt)
            {
                name = "b" + name;
            }

            // If image already exists in cache, use it
            string cached = CheckCache(name);

            if (cached != null && Commands.Gec.geckos.ContainsKey(EmoteUtils.escapeforbidden(name)))
            {
                if (!refresh)
                {
                    return(cached);
                }

                File.Delete(cached);
                cached = null;
            }

            if (refresh && Commands.Gec.geckos.ContainsKey(EmoteUtils.escapeforbidden(name)))
            {
                Commands.Gec.geckos.Remove(EmoteUtils.escapeforbidden(name));
            }

            // Otherwise, fetch it from google drive
            DriveService driveService = AuthenticateServiceAccount(
                "*****@*****.**",
                "../../../GeckoBot-af43fa71833e.json");
            var listRequest = driveService.Files.List();

            listRequest.PageSize = 1;                          // Only fetch one
            listRequest.Q        = $"name contains '{name}_'"; // Search for the image via the given number

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

            if (files != null && files.Count > 0)
            {
                // Use the first result
                var file = files[0];

                //adds name of gecko to list
                if (!Commands.Gec.geckos.ContainsKey(name))
                {
                    Commands.Gec.geckos.TryAdd(EmoteUtils.escapeforbidden(name), EmoteUtils.escapeforbidden(file.Name));

                    FileUtils.Save(Globals.DictToString(Commands.Gec.geckos, "{0} ⁊ {1} ҩ "), @"..\..\Cache\gecko7.gek");

                    if (cached != null)
                    {
                        return(cached);
                    }
                }

                //Console.WriteLine(file.MimeType);
                string type = file.MimeType.Replace("image/", ""); // sorta hacky solution to get file type

                for (int i = 0; i < 1000; i++)
                {
                    try
                    {
                        using (var fileStream = new FileStream($"../../Cache/{name}_icon.{type}", FileMode.Create, FileAccess.Write))
                        {
                            driveService.Files.Get(file.Id).Download(fileStream);
                        }
                        break;
                    }
                    catch
                    {
                        continue;
                    }
                }

                return(CheckCache(name) ?? throw new Exception("Drive download failed!"));
            }

            throw new Exception("File " + name + " not found!");
        }
コード例 #47
0
ファイル: DriveUtils.cs プロジェクト: croissantderp/geckobot
        // Gets path from cache or downloads image to cache from drive
        public static int saveAll(int highest)
        {
            Commands.Gec.RefreshGec();
            FileUtils.checkForCacheExistance();

            DriveService driveService = AuthenticateServiceAccount(
                "*****@*****.**",
                "../../../GeckoBot-af43fa71833e.json");
            var listRequest = driveService.Files.List();

            listRequest.PageSize = 1000;                        // Only fetch one thousand
            listRequest.Q        = "mimeType contains 'image'"; // Filter out folders or other non image types

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

            int totalAmount = 0;
            int amount      = 0;

            while (totalAmount < highest)
            {
                foreach (Google.Apis.Drive.v3.Data.File file in files)
                {
                    string name = file.Name.Remove(3);

                    if (name.Contains("b"))
                    {
                        name = file.Name.Remove(4);
                    }
                    if (CheckCache(name) == null)
                    {
                        string type = file.MimeType.Replace("image/", ""); // sorta hacky solution to get file type

                        using var fileStream = new FileStream(
                                  $"../../Cache/{name}_icon.{type}",
                                  FileMode.Create,
                                  FileAccess.Write);
                        driveService.Files.Get(file.Id).Download(fileStream);

                        amount++;
                    }

                    if (!Commands.Gec.geckos.ContainsKey(EmoteUtils.escapeforbidden(name)))
                    {
                        Commands.Gec.geckos.Add(EmoteUtils.escapeforbidden(name), EmoteUtils.escapeforbidden(file.Name));

                        if (CheckCache(name) != null)
                        {
                            continue;
                        }
                    }
                    else if (!Commands.Gec.geckos.ContainsValue(EmoteUtils.escapeforbidden(file.Name)))
                    {
                        Commands.Gec.geckos.Remove(EmoteUtils.escapeforbidden(name));
                        Commands.Gec.geckos.Add(EmoteUtils.escapeforbidden(name), EmoteUtils.escapeforbidden(file.Name));
                    }

                    totalAmount++;
                }
                listRequest.PageToken = files2.NextPageToken;
            }

            FileUtils.Save(Globals.DictToString(Commands.Gec.geckos, "{0} ⁊ {1} ҩ "), @"..\..\Cache\gecko7.gek");

            return(amount);
        }
コード例 #48
0
        private async Task <string> UploadFile(string path, string contentType, string fileName, string folderID, DriveService service)
        {
            var fileMetadata = new Google.Apis.Drive.v3.Data.File
            {
                Name     = fileName,
                MimeType = contentType
            };

            fileMetadata.Parents = new List <string> {
                folderID
            };

            FilesResource.CreateMediaUpload request;
            using (var stream = new System.IO.FileStream(path, System.IO.FileMode.Open))
            {
                request        = service.Files.Create(fileMetadata, stream, contentType);
                request.Fields = "id";
                await request.UploadAsync();
            }

            var file = request.ResponseBody;

            return(file.Id);
        }
コード例 #49
0
 public GoogleDriveRootNode(DriveService service) : base(service)
 {
     _service = service;
 }
コード例 #50
0
 /// <summary>
 /// Constructor which forwards drive service instance to base class.
 /// </summary>
 public GoogleDriveReader(DriveService driveService, IFileReader fileReader)
     : base(driveService)
 {
     _localFileReader = new LocalFileReader(fileReader);
 }
コード例 #51
0
        public List <string> Invoke(List <string> fileIds)
        {
            try
            {
                using (DriveService driveService = DriveService.Create())
                {
                    var untrashStreams = new List <API.DriveService.UntrashStream>();

                    foreach (string fileId in fileIds)
                    {
                        FileInfo fileInfo = driveService.GetFile(fileId);

                        if (fileInfo == null)
                        {
                            throw new Exception("File no longer exists.");
                        }

                        var untrashStream = new API.DriveService.UntrashStream();

                        untrashStream.Init(fileInfo);

                        untrashStream.Visible = false;

                        untrashStreams.Add(untrashStream);
                    }

                    driveService.UntrashFiles(untrashStreams);

                    while (true)
                    {
                        bool finished = true;

                        for (int i = 0; i < untrashStreams.Count; i++)
                        {
                            API.DriveService.UntrashStream untrashStream = untrashStreams[i];

                            if (!untrashStream.Finished)
                            {
                                finished = false;
                                break;
                            }
                        }

                        if (finished)
                        {
                            break;
                        }

                        System.Threading.Thread.Sleep(250);
                    }

                    var untrashedFileIds = new List <string>();

                    foreach (DriveService.UntrashStream untrashStream in untrashStreams)
                    {
                        if (untrashStream.Completed)
                        {
                            untrashedFileIds.Add(untrashStream.FileId);
                        }
                        else if (untrashStream.Cancelled)
                        {
                        }
                        else if (untrashStream.Failed)
                        {
                            throw new LogException("Untrash could not complete - " + untrashStream.ExceptionMessage, true, true);
                        }
                    }

                    return(untrashedFileIds);
                }
            }
            catch (Exception exception)
            {
                Log.Error(exception);

                return(null);
            }
        }
コード例 #52
0
        private async Task Run()
        {
            string[]       Scopes = new[] { DriveService.Scope.DriveReadonly };
            UserCredential credential;

            ClientSecrets secrets = new ClientSecrets
            {
                ClientId     = "703137161297-kcdmjcjk5caa9ampgvraqa4ktt5nsqit.apps.googleusercontent.com",
                ClientSecret = "2XXbusAQkVUsY7MvoxXQRlIi"
            };

            credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(secrets, Scopes, "user", CancellationToken.None);

            // Create the service.
            var service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = "hitfit.app",
            });

            FilesResource.ListRequest request = service.Files.List();
            //request.PageSize = pageSize;
            request.Q      = "mimeType = 'application/vnd.google-apps.document'";
            request.Fields = "nextPageToken, files(id, name, mimeType, starred)";

            var result = await request.ExecuteAsync();

            var articles = new List <Article>();

            foreach (var file in result.Files)
            {
                var docHtml = await service.Files.Export(file.Id, "text/html").ExecuteAsync();

                var article = ParseGoogleDoc(docHtml);

                article.DocumentId = file.Id;
                article.Title      = file.Name;
                if (file.Starred.HasValue)
                {
                    article.Published = file.Starred.Value;
                }

                articles.Add(article);
            }

            //NpgsqlConnection connection = new NpgsqlConnection("Server=hitfitdbserver.postgres.database.azure.com;Database=hitfitdb;Port=5432;User Id=postgres@hitfitdbserver;Password=Tsunami9;");
            NpgsqlConnection connection = new NpgsqlConnection("User ID=postgres;Password=Tsunami9;Host=localhost;Port=5432;Database=hitfitdb;Pooling=true;");
            await connection.OpenAsync();

            NpgsqlCommand command = new NpgsqlCommand();

            command.Connection = connection;
            foreach (var article in articles)
            {
                command.Parameters.Clear();

                command.CommandText = string.Format("SELECT content FROM articles WHERE documentid = '{0}'",
                                                    article.DocumentId);

                NpgsqlDataReader reader = command.ExecuteReader();
                if (reader.HasRows)
                {
                    await reader.CloseAsync();

                    command.CommandText =
                        string.Format(
                            "UPDATE articles SET title = @title, headerimage = @headerimage, content = @content, published = @published WHERE documentid = @documentid",
                            article.Title, article.HeaderImage, article.Content, article.Published, article.DocumentId);
                    command.Parameters.AddWithValue("@documentid", article.DocumentId);
                    command.Parameters.AddWithValue("@title", article.Title);
                    command.Parameters.AddWithValue("@headerimage", article.HeaderImage);
                    command.Parameters.AddWithValue("@content", article.Content);
                    command.Parameters.AddWithValue("@published", article.Published);
                    await command.ExecuteNonQueryAsync();
                }
                else
                {
                    await reader.CloseAsync();

                    command.CommandText =
                        string.Format(
                            "INSERT INTO articles (documentid, title, headerimage, content, published) SELECT @documentid, @title, @headerimage, @content, @published",
                            article.DocumentId, article.Title, article.HeaderImage, article.Content, article.Published ? "true" : "false");
                    command.Parameters.AddWithValue("@documentid", article.DocumentId);
                    command.Parameters.AddWithValue("@title", article.Title);
                    command.Parameters.AddWithValue("@headerimage", article.HeaderImage);
                    command.Parameters.AddWithValue("@content", article.Content);
                    command.Parameters.AddWithValue("@published", article.Published);
                    await command.ExecuteNonQueryAsync();
                }
            }

            connection.Close();
        }
コード例 #53
0
ファイル: Main.cs プロジェクト: lucastagnitta/GDTSC
        private void button1_Click_1(object sender, EventArgs e)
        {
            System.Windows.Forms.Cursor.Current = Cursors.WaitCursor;

            table = new DataTable();
            g.AutoGenerateColumns = false;
            //g.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.None;
            table.Columns.Add("Name", typeof(string));
            table.Columns.Add("Modified", typeof(DateTime));
            table.Columns.Add("Size", typeof(double));
            table.Columns.Add("Parent", typeof(string));
            table.Columns.Add("Id", typeof(string));
            g.DataSource = table;

            stat.Text = "Connecting";

            System.IO.FileStream stream = new System.IO.FileStream(
                "client_secret.json",
                System.IO.FileMode.Open,
                System.IO.FileAccess.Read
                );

            // credential.Token
            // https://developers.google.com/accounts/docs/OAuth2InstalledApp
            // http://stackoverflow.com/questions/7367449/google-api-how-to-authenticate-without-redirection
            // http://stackoverflow.com/questions/9809742/how-to-automate-login-to-google-api-to-get-oauth-2-0-token-to-access-known-user
            // token is stored here: %AppData%\Roaming\Drive.Auth.Store\Google.Apis.Auth.OAuth2.Responses.TokenResponse-user
            // http://www.daimto.com/google-oauth2-csharp/#Loading_Stored_refresh-Token
            UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                GoogleClientSecrets.Load(stream).Secrets,
                new[] { DriveService.Scope.Drive },
                "user",
                CancellationToken.None
                ).Result;

            stream.Close();

            // Create the service.
            service = new DriveService(
                new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = "Google Drive Trash Selective Cleaner",
            }
                );

            // first request
            FilesResource.ListRequest request = service.Files.List();
            request.MaxResults = 1000;
            request.Fields     = "items(id,fileSize,labels/trashed,modifiedDate,title,parents/id),nextPageToken";
            // RFC 3339 format, default timezone is UTC, e.g., 2012-06-04T12:00:00-08:00.
            string d1 = XmlConvert.ToString(fromdate.Value, XmlDateTimeSerializationMode.Utc);
            string d2 = XmlConvert.ToString(todate.Value.AddDays(1), XmlDateTimeSerializationMode.Utc);

            string fname;
            string fext;
            int    ind = filetitle.Text.LastIndexOf('.');

            if (ind >= 0)
            {
                fname = filetitle.Text.Substring(0, ind);
                fext  = filetitle.Text.Substring(ind);
            }
            else
            {
                fname = filetitle.Text;
                fext  = "";
            }
            request.Q =
                "trashed=true " +
                "and modifiedDate >= '" + d1 + "' " +
                "and modifiedDate < '" + d2 + "' " +
                "and title contains '" + fname + "' ";

            double savedmb  = 0;
            int    count    = 0;
            long   fromsize = (long)(double.Parse(minsize.Text, culture.NumberFormat) * 1024 * 1024);
            long   tosize   = (long)(double.Parse(maxsize.Text, culture.NumberFormat) * 1024 * 1024);

            stat.Text = "Searching";
            do
            {
                FileList files = request.Execute();
                request.PageToken = files.NextPageToken;
                foreach (File f in files.Items)
                {
                    // since filesize and fileextension are not queryable
                    // (and mimeType is not reliable)
                    long filesize = f.FileSize ?? 0;
                    if (filesize >= fromsize && filesize <= tosize && f.Title.EndsWith(fext))
                    {
                        DataRow r = table.NewRow();
                        r["Id"]       = f.Id;
                        r["Name"]     = f.Title;
                        r["Modified"] = f.ModifiedDate;
                        double kb = (double)(filesize) / 1024;
                        savedmb  += kb / 1024;
                        r["Size"] = kb;
                        // filling the first rows will be slower because of an empty cache
                        if (f.Parents.Count > 0)
                        {
                            r["Parent"] = GetFullPath(f.Parents[0].Id);
                        }
                        table.Rows.Add(r);
                        count++;
                        l1.Text = "Items: " + count;
                        l2.Text = "MB: " + Math.Round(savedmb, 2);
                        Application.DoEvents();
                    }
                }
            } while (!String.IsNullOrEmpty(request.PageToken));

            System.Windows.Forms.Cursor.Current = Cursors.Default;
            button2.Enabled = count > 0;
            stat.Text       = "";
            MessageBox.Show("Done searching");
        }
コード例 #54
0
ファイル: Skeleton.cs プロジェクト: ucsb/y-drive-accelerator
        static void Main(string[] args)
        {
            //refer to https://developers.google.com/drive/api/v3/quickstart/dotnet to get this json file
            string           credPath = @"c:\orbit-y-drive-service.json";
            GoogleCredential credential;

            using (var stream = new FileStream(credPath, FileMode.Open, FileAccess.Read))
            {
                credential = GoogleCredential.FromStream(stream).CreateScoped(Scopes);
            }

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

            string teamDrivePageToken = null;
            string teamDriveID        = null;

            do
            {
                TeamdrivesResource.ListRequest teamDriveList = service.Teamdrives.List();
                teamDriveList.Fields    = "nextPageToken, teamDrives(kind, id, name)";
                teamDriveList.PageToken = teamDrivePageToken;
                var result     = teamDriveList.Execute();
                var teamDrives = result.TeamDrives;

                if (teamDrives != null && teamDrives.Count > 0)
                {
                    foreach (TeamDrive drive in teamDrives)
                    {
                        if (drive.Name == TeamDriveName)
                        {
                            teamDriveID = drive.Id;
                            break;
                        }
                    }
                }
                teamDrivePageToken = result.NextPageToken;
            } while (teamDrivePageToken != null && teamDriveID == null);

            if (teamDriveID == null)
            {
                WriteLogEntry("Team drive not found", null);
                StopService();
                return;
            }

            string rootFolderPageToken = null;
            string rootFolderId        = "";

            do
            {
                FilesResource.ListRequest rootFolderRequest = service.Files.List();
                rootFolderRequest.Fields                = "nextPageToken, files(id, name, parents, mimeType)";
                rootFolderRequest.PageToken             = rootFolderPageToken;
                rootFolderRequest.SupportsTeamDrives    = true;
                rootFolderRequest.IncludeTeamDriveItems = true;
                rootFolderRequest.Corpora               = "teamDrive";
                rootFolderRequest.TeamDriveId           = teamDriveID;
                rootFolderRequest.Q = "parents='" + teamDriveID + "' and trashed=false and name='" + RootFolderName + "'";

                var result = rootFolderRequest.Execute();
                var files  = result.Files;
                if (files != null && files.Count == 1)
                {
                    var file = files[0];
                    if (file.MimeType == "application/vnd.google-apps.folder")
                    {
                        rootFolderId = file.Id;
                        break;
                    }
                }
                rootFolderPageToken = result.NextPageToken;
            } while (rootFolderPageToken != null && rootFolderId == null);

            if (rootFolderId == "")
            {
                WriteLogEntry("Error finding Root Folder. This can be caused by a duplicate folder, no folder, or execution error etc.", null);
                StopService();
                return;
            }

            string recordFolderPageToken = null;
            List <Google.Apis.Drive.v3.Data.File> recordFolders = new List <Google.Apis.Drive.v3.Data.File>();

            do
            {
                FilesResource.ListRequest recordFoldersRequest = service.Files.List();
                recordFoldersRequest.Fields                = "nextPageToken, files(id, name, parents, mimeType)";
                recordFoldersRequest.PageToken             = recordFolderPageToken;
                recordFoldersRequest.SupportsTeamDrives    = true;
                recordFoldersRequest.IncludeTeamDriveItems = true;
                recordFoldersRequest.Corpora               = "teamDrive";
                recordFoldersRequest.TeamDriveId           = teamDriveID;
                recordFoldersRequest.Q = "parents='" + rootFolderId + "' and trashed=false";

                var result = recordFoldersRequest.Execute();
                var files  = result.Files;

                if (files != null && files.Count > 0)
                {
                    foreach (Google.Apis.Drive.v3.Data.File file in files)
                    {
                        if (file.MimeType == "application/vnd.google-apps.folder")
                        {
                            recordFolders.Add(file);
                        }
                        else
                        {
                            //file found. shouldnt happen - delete
                            TrashDriveObject(service, file.Id);
                        }
                    }
                }
                recordFolderPageToken = result.NextPageToken;
            } while (recordFolderPageToken != null);

            if (recordFolders.Count != 0)
            {
                foreach (Google.Apis.Drive.v3.Data.File recordFolder in recordFolders)
                {
                    string addOnEmail = "";
                    if (isAddOnFinished(service, teamDriveID, recordFolder.Id, ref addOnEmail))
                    {
                        string recordNumber = recordFolder.Name;
                        if (isValidRecordNumber(recordNumber) == false && isValidSubawardNumber(recordNumber) == false)
                        {
                            SendErrorEmail(addOnEmail, "Record number " + recordNumber + " does not exist in ORBiT.");
                            TrashDriveObject(service, recordFolder.Id);
                            continue;
                        }

                        string EFilesFolder = GetEFilesFolder(recordNumber);
                        if (EFilesFolder == "")
                        {
                            SendErrorEmail(addOnEmail, "Could not find an EFiles folder. Record number is " + recordNumber);
                            TrashDriveObject(service, recordFolder.Id);
                            continue;
                        }

                        string        filePageToken = null;
                        List <string> lstSavedFiles = new List <string>();
                        do
                        {
                            FilesResource.ListRequest filesRequest = service.Files.List();
                            filesRequest.Fields                = "nextPageToken, files(id, name, parents, mimeType)";
                            filesRequest.PageToken             = filePageToken;
                            filesRequest.SupportsTeamDrives    = true;
                            filesRequest.IncludeTeamDriveItems = true;
                            filesRequest.Corpora               = "teamDrive";
                            filesRequest.TeamDriveId           = teamDriveID;
                            filesRequest.Q = "parents='" + recordFolder.Id + "' and trashed=false";

                            var  result   = filesRequest.Execute();
                            var  files    = result.Files;
                            bool stopFlag = false;

                            foreach (Google.Apis.Drive.v3.Data.File file in files)
                            {
                                var fileInfo = service.Files.Get(file.Id);
                                if (file.MimeType == "application/vnd.google-apps.folder")
                                {
                                    //folder found - shouldnt happen - trash folder
                                    TrashDriveObject(service, file.Id);
                                }
                                else
                                {
                                    if (file.Name == FlagFileName || file.Name == TempFileName)
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        using (MemoryStream ms = new MemoryStream())
                                        {
                                            fileInfo.Download(ms);
                                            string filenameToSave = getUniqueFilename(EFilesFolder, file.Name);
                                            try
                                            {
                                                using (FileStream fs = new FileStream(EFilesFolder + filenameToSave, FileMode.Create, System.IO.FileAccess.Write))
                                                {
                                                    try
                                                    {
                                                        fs.Write(ms.GetBuffer(), 0, ms.GetBuffer().Length);
                                                    }
                                                    catch (Exception e)
                                                    {
                                                        string message = "Error saving file to Y Drive. Record Number: " + recordNumber + ", file name: " +
                                                                         file.Name;
                                                        WriteLogEntry(message, e);

                                                        if (lstSavedFiles.Count > 0)
                                                        {
                                                            message += "<br /><br />";
                                                            message += "The following files were saved successfully:<br /><ul>";
                                                            for (int i = 0; i < lstSavedFiles.Count; i++)
                                                            {
                                                                message += "<li>" + lstSavedFiles[i] + "</li>";
                                                            }
                                                            message += "</ul>";
                                                        }

                                                        SendErrorEmail(addOnEmail, message);

                                                        stopFlag = true;
                                                        ms.Close();
                                                        break;
                                                    }

                                                    lstSavedFiles.Add(filenameToSave);
                                                }
                                                ms.Close();
                                            }
                                            catch (Exception e)
                                            {
                                                WriteLogEntry("Error writing to filestream. File name is " + filenameToSave, e);

                                                string message = "Error saving file to Y Drive. Record Number: " + recordNumber + ", file name: " +
                                                                 file.Name;
                                                if (lstSavedFiles.Count > 0)
                                                {
                                                    message += "<br /><br />";
                                                    message += "The following files were saved successfully:<br /><ul>";
                                                    for (int i = 0; i < lstSavedFiles.Count; i++)
                                                    {
                                                        message += "<li>" + lstSavedFiles[i] + "</li>";
                                                    }
                                                    message += "</ul>";
                                                }

                                                SendErrorEmail(addOnEmail, message);

                                                stopFlag = true;
                                                break;
                                            }
                                        }
                                    }
                                }
                            }

                            if (stopFlag == true)
                            {
                                break;
                            }

                            filePageToken = result.NextPageToken;
                        } while (filePageToken != null);

                        TrashDriveObject(service, recordFolder.Id);
                    }
                }
            }
        }
コード例 #55
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Judul,Path,FImage,PenulisBuku,Terbitan,ISBN,Deskripsi,Tebal,Tanggal,Kategori,Tag,Penulis,Status,DriveId,Parents")] Buku buku, IFormFile file)
        {
            if (id != buku.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    DriveService service      = driveService.GetService();
                    var          folderId     = "1aB_0pJ9qsHjP3DhOERmWacA2Mn1jDW7H";
                    string       path         = Path.GetTempFileName();
                    var          fileMetadata = new Google.Apis.Drive.v3.Data.File()
                    {
                        Name    = Path.GetFileName(file.FileName),
                        Parents = new List <string>
                        {
                            folderId
                        }
                    };
                    FilesResource.CreateMediaUpload request;

                    using (var stream = new System.IO.FileStream(path, System.IO.FileMode.Open))
                    {
                        await file.CopyToAsync(stream);

                        request = service.Files.Create(
                            fileMetadata, stream, "image/jpeg");
                        request.Fields = "id";
                        request.Upload();
                    }
                    var fileUploaded = request.ResponseBody;
                    buku.FImage = "https://drive.google.com/uc?id=" + fileUploaded.Id;

                    if (buku.FImage != null)
                    {
                        buku.FImage = buku.FImage.Replace("file/d/", "uc?id=");
                        buku.FImage = buku.FImage.Replace("/view?usp=sharing", "");
                    }
                    if (buku.Penulis == null)
                    {
                        buku.Penulis = "admin";
                    }
                    buku.Tanggal = DateTime.Now;
                    _context.Update(buku);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!BukuExists(buku.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(List)));
            }
            return(View(buku));
        }
コード例 #56
0
ファイル: Files.cs プロジェクト: R1kNk/PGDrive
 public Files(DriveService service) : base(service)
 {
     DefaultGetFieldsOnResponse  = "nextPageToken, files(id, name, mimeType, owners, parents, permissions, shared, trashed, webContentLink, webViewLink)";
     DefaultFileFieldsOnResponse = "id, name, mimeType, owners, parents, permissions, shared, trashed, webContentLink, webViewLink";
     DefaultPageSizePerRequest   = 1000;
 }
コード例 #57
0
        static void Main(string[] args)
        {
            // ************************************************************
            // ASSUMPTION: Unit test has been run on Google Drive first
            // ************************************************************

            var googleDriveManager = new GoogleDriveManager();
            var googleSheetManager = new GoogleSheetManager();

            GoogleCredential credentialReadOnly   = null;
            GoogleCredential credentialFullAccess = null;

            DriveService driveServiceReadOnly   = null;
            DriveService driveServiceFullAccess = null;

            SheetsService sheetsServiceReadOnly   = null;
            SheetsService sheetsServiceFullAccess = null;

            #region STEP 0: Pre-test validation

            if (System.IO.File.Exists("client-secret.json") == false)
            {
                Console.WriteLine("******* ERROR: Please ensure you have downloaded your Google API .JSON file and copied into same folder as the .EXE *******");
                Console.ReadKey();
                return;
            }

            // Get the readonly drive credentials. (If it fails here run UnitTestGoogleDriveViaConsole to troubleshoot)
            credentialReadOnly = googleDriveManager.GetUserCredential("client-secret.json", googleDriveManager.ReadOnlyScope);
            if (credentialReadOnly == null)
            {
                Console.WriteLine("******* PRE-TEST VALIDATION FAILED - Credentials returned null when getting Read Only Scope permissions");
                Console.WriteLine("*******");
                Console.ReadKey();
                return;
            }

            // Get the full access drive credentials. (If it fails here run UnitTestGoogleDriveViaConsole to troubleshoot)
            credentialFullAccess = googleDriveManager.GetUserCredential("client-secret.json", googleDriveManager.FullAccessScope);
            if (credentialFullAccess == null)
            {
                Console.WriteLine("******* PRE-TEST VALIDATION FAILED - Credentials returned null when getting Full Access Scope permissions");
                Console.WriteLine("*******");
                Console.ReadKey();
                return;
            }

            // Get Drive Service Instance as Read-Only
            driveServiceReadOnly = googleDriveManager.CreateDriveServiceInstance(credentialReadOnly, "UnitTest Google Sheet Library");
            if (driveServiceReadOnly == null)
            {
                Console.WriteLine("******* STEP 2.2.1 - FAILED - drive service returned null getting it with Read Only credentials. ");
                Console.WriteLine("*******");
                Console.ReadKey();
                return;
            }

            // Get Drive Service Instance as Full Access
            driveServiceFullAccess = googleDriveManager.CreateDriveServiceInstance(credentialFullAccess, "UnitTest Google Sheet Library");
            if (driveServiceFullAccess == null)
            {
                Console.WriteLine("******* STEP 2.2.2 - FAILED - drive service returned null getting it with Full Access credentials. ");
                Console.WriteLine("*******");
                Console.ReadKey();
                return;
            }

            var t1Folder = googleDriveManager.GetFolderByName(driveServiceReadOnly, "T1");
            if (t1Folder == null)
            {
                Console.WriteLine("******* ERROR: T1 folder should already exist. Please ensure you ran UnitTestGoogleDriveViaConsole first. *******");
                Console.ReadKey();
                return;
            }

            // Check if sheet exists and so delete it
            var sheetFile = googleDriveManager.GetSheetFileInChildFolderByName(driveServiceReadOnly, "TestSheet", t1Folder.Id);
            if (sheetFile != null)
            {
                googleDriveManager.DeleteFile(driveServiceFullAccess, sheetFile.Id);
            }

            #endregion

            #region STEP 1: Create the test sheet

            #region STEP 1.1: Negative Testing

            // STEP 1.1.1 - Test no drive service
            try { var expectedFailure = googleDriveManager.CreateGoogleSheet(null, string.Empty, string.Empty, null); }
            catch (Exception exception)
            {
                Console.WriteLine("******* STEP 1.1.1 - PASSED : EXPECTED FAILURE with no drive service passed: ");
                Console.WriteLine(exception.ToString());
                Console.WriteLine("*******");
                Console.ReadKey();
            }

            // STEP 3.1.2 - Test drive service, no sheet name
            try { var expectedFailure = googleDriveManager.CreateGoogleSheet(driveServiceFullAccess, string.Empty, string.Empty, new List <string> {
                    t1Folder.Id
                }); }
            catch (Exception exception)
            {
                Console.WriteLine("******* STEP 3.1.2 - PASSED : EXPECTED FAILURE with drive service but no sheet name: ");
                Console.WriteLine(exception.ToString());
                Console.WriteLine("*******");
                Console.ReadKey();
            }

            #endregion

            #region STEP 1.2 Positive Testing

            var sheetFileId = googleDriveManager.CreateGoogleSheet(driveServiceFullAccess, "TestSheet", "Sheet used to Unit test CSHARP Sheet Library.", new List <string> {
                t1Folder.Id
            });
            if (string.IsNullOrEmpty(sheetFileId))
            {
                Console.WriteLine("******* ERROR: Failed to create test sheet *******");
                Console.ReadKey();
                return;
            }

            #endregion

            #endregion

            #region STEP 2: Assign Read Permissions to [email protected]

            // Get the permission object so we can use it to assign permission to the sheet
            var permission = googleDriveManager.CreateUserPermission("reader", "*****@*****.**");
            if (permission == null)
            {
                Console.WriteLine("******* ERROR: Failed to create user permission object for [email protected] *******");
                Console.ReadKey();
                return;
            }

            // Assign the permission to the sheet
            if (googleDriveManager.AssignPermissionToFile(driveServiceFullAccess, sheetFileId, permission) == false)
            {
                Console.WriteLine("******* ERROR: Failed to set reader permission for user [email protected] for spreadsheet *******");
                Console.ReadKey();
                return;
            }

            // Get the permission object so we can use it to assign permission to the sheet
            permission = googleDriveManager.CreateUserPermission("writer", "*****@*****.**");
            if (permission == null)
            {
                Console.WriteLine("******* ERROR: Failed to create user permission object for [email protected] *******");
                Console.ReadKey();
                return;
            }

            // Assign the permission to the sheet
            if (googleDriveManager.AssignPermissionToFile(driveServiceFullAccess, sheetFileId, permission) == false)
            {
                Console.WriteLine("******* ERROR: Failed to set write permission for user [email protected] for spreadsheet *******");
                Console.ReadKey();
                return;
            }

            #endregion

            #region STEP 3: Get Sheets Service Instance

            #region STEP 3.1: Negative Testing

            // STEP 3.1.1 - Test no credentials passed in and no application name
            try { var expectedFailure = googleSheetManager.CreateSheetServiceInstance(null, string.Empty); }
            catch (Exception exception)
            {
                Console.WriteLine("******* STEP 3.1.1 - PASSED : EXPECTED FAILURE with no credentials passed: ");
                Console.WriteLine(exception.ToString());
                Console.WriteLine("*******");
                Console.ReadKey();
            }

            // STEP 2.1.2 - Test credentials passed in but no application name
            try { var expectedFailure = googleSheetManager.CreateSheetServiceInstance(credentialReadOnly, string.Empty); }
            catch (Exception exception)
            {
                Console.WriteLine("******* STEP 3.1.2 - PASSED : EXPECTED FAILURE with no application name passed: ");
                Console.WriteLine(exception.ToString());
                Console.WriteLine("*******");
                Console.ReadKey();
            }

            #endregion

            #region STEP 3.2: Positive Testing

            // STEP 3.2.1 - Test getting sheet service with ReadOnly Scope
            try
            {
                sheetsServiceReadOnly = googleSheetManager.CreateSheetServiceInstance(credentialReadOnly, "UnitTest Google Sheet Library");
                if (sheetsServiceReadOnly == null)
                {
                    Console.WriteLine("******* STEP 3.2.1 - FAILED - sheets service returned null getting it with Read Only credentials. ");
                    Console.WriteLine("*******");
                    Console.ReadKey();
                    return;
                }
            }
            catch (Exception exception)
            {
                Console.WriteLine("******* STEP 3.2.1 - FAILED - Exception thrown getting sheets service using Read Only credentials.");
                Console.WriteLine(exception.ToString());
                Console.WriteLine("*******");
                Console.ReadKey();
                return;
            }

            // STEP 3.2.2 - Test getting sheet service with Full Access Scope
            try
            {
                sheetsServiceFullAccess = googleSheetManager.CreateSheetServiceInstance(credentialFullAccess, "UnitTest Google Sheet Library");
                if (sheetsServiceFullAccess == null)
                {
                    Console.WriteLine("******* STEP 3.2.2 - FAILED - sheets service returned null getting it with Full Access credentials. ");
                    Console.WriteLine("*******");
                    Console.ReadKey();
                    return;
                }
            }
            catch (Exception exception)
            {
                Console.WriteLine("******* STEP 3.2.2 - FAILED - Exception thrown getting sheets service using Full Access credentials.");
                Console.WriteLine(exception.ToString());
                Console.WriteLine("*******");
                Console.ReadKey();
                return;
            }

            Console.WriteLine("******* STEP 3.2 - PASSED");
            Console.WriteLine("*******");
            Console.ReadKey();

            #endregion

            #endregion

            #region STEP 4: Read and Write Values from test sheet

            #region STEP 4.1 - Read range (should be blank)

            var testRange    = "Sheet1!A2:E2";
            var valueResults = googleSheetManager.GetSheetDataRange(sheetsServiceReadOnly, sheetFileId, testRange);

            if (valueResults == null)
            {
                Console.WriteLine("******* ERROR: Failed to get range in sheet *******");
                Console.ReadKey();
                return;
            }

            // Review the cells are empty. The Values are stored in an array of arrays
            IList <IList <Object> > values = valueResults.Values;
            if (values == null || values.Count == 0)
            {
                Console.WriteLine("******* PASSED: Expected range in sheet to be empty as we just created it *******");
                Console.ReadKey();
            }
            else
            {
                Console.WriteLine("******* ERROR: Failed as sheet range should have no data *******");
                Console.ReadKey();
                return;
            }

            #endregion

            #region STEP 4.2 - Write a single value and confirm it got written

            var singleCellTestRange = "Sheet1!A2";
            googleSheetManager.UpdateSheetCellValue(sheetsServiceFullAccess, sheetFileId, singleCellTestRange, "New Text In A2");
            var singleCellValueResult = googleSheetManager.GetSheetDataRange(sheetsServiceReadOnly, sheetFileId, singleCellTestRange);
            if (singleCellValueResult == null || singleCellValueResult.Values.Count == 0)
            {
                Console.WriteLine("******* ERROR: Failed to read back single cell value *******");
                Console.ReadKey();
                return;
            }

            if (singleCellValueResult.Values[0].Count == 0)
            {
                Console.WriteLine("******* ERROR: Failed to read back single cell value *******");
                Console.ReadKey();
                return;
            }

            if (singleCellValueResult.Values[0][0].ToString() != "New Text In A2")
            {
                Console.WriteLine("******* ERROR: Failed as single text value was not updated in the sheet *******");
                Console.ReadKey();
                return;
            }
            #endregion

            #region STEP 5: Bulk Write data to test sheet

            // Getting the range again as we did update a cell in the range.
            valueResults = googleSheetManager.GetSheetDataRange(sheetsServiceReadOnly, sheetFileId, testRange);

            // Fill in values in the results
            for (int rowIndex = 0; rowIndex < valueResults.Values.Count; rowIndex++)
            {
                for (int colIndex = 0; colIndex < valueResults.Values[rowIndex].Count; colIndex++)
                {
                    valueResults.Values[rowIndex][colIndex] = rowIndex.ToString() + ":" + colIndex.ToString();
                }
            }

            // Write the values
            googleSheetManager.UpdateSheetDataRange(sheetsServiceFullAccess, sheetFileId, testRange, valueResults);

            // Getting the range again to confirm updates.
            valueResults = googleSheetManager.GetSheetDataRange(sheetsServiceReadOnly, sheetFileId, testRange);

            // Check the expected values in the results
            for (int rowIndex = 0; rowIndex < valueResults.Values.Count; rowIndex++)
            {
                for (int colIndex = 0; colIndex < valueResults.Values[rowIndex].Count; colIndex++)
                {
                    if (valueResults.Values[rowIndex][colIndex].ToString() != rowIndex.ToString() + ":" + colIndex.ToString())
                    {
                        Console.WriteLine("******* ERROR: Failed as the value we expected to be updated was not: " + rowIndex.ToString() + ":" + colIndex.ToString() + " * ******");
                        Console.ReadKey();
                        return;
                    }
                }
            }

            #endregion

            #endregion
        }
コード例 #58
0
        public void UploadFile()
        {
            UserCredential credential;

            credential = GetCredentials();

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

            string folderid;
            var    requestFolder = service.Files.List();

            requestFolder.Q      = "mimeType = 'application/vnd.google-apps.folder' and name contains 'EBOOK'";
            requestFolder.Spaces = "drive";
            requestFolder.Fields = "nextPageToken, files(id, name)";
            var result = requestFolder.Execute();

            OpenFileDialog openFileDialog1 = new OpenFileDialog();

            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                foreach (string filename in openFileDialog1.FileNames)
                {
                    //Thread thread = new Thread(() =>
                    //{
                    //UploadImage(filename, service, folderid);
                    //var a = requests.Resp;
                    IList <string> folders = new List <string>();
                    folders.Add(result.Files.FirstOrDefault().Id);
                    var fileMetadatas = new Google.Apis.Drive.v3.Data.File()
                    {
                        Name    = filename.Split('\\').Last().ToString(),
                        Parents = folders,
                    };
                    FilesResource.CreateMediaUpload request;
                    using (var stream = new System.IO.FileStream(filename,
                                                                 System.IO.FileMode.Open))
                    {
                        request = service.Files.Create(
                            fileMetadatas, stream, "image/jpeg");

                        request.Fields = "id";
                        request.Upload();
                        var file = request.ResponseBody;
                        var a    = fileMetadatas;
                        this.FileId = file.Id;
                    }
                    //});
                    //thread.IsBackground = true;
                    //thread.Start();
                }
            }

            //string pageToken = null;

            //do
            //{
            //    ListFiles(service, ref pageToken);

            //} while (pageToken != null);
        }
コード例 #59
0
        public async Task UploadBackupToDriveAsync()
        {
            bool result = _model.DoBackupToFile();

            if (!result)
            {
                return;
            }

            //UserCredential credential;
            string credentialsFilePath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "./credentials.json");

            using (var stream = new FileStream(credentialsFilePath, FileMode.Open, FileAccess.Read))
            {
                string credPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "/token.json");

                Thread thread = new Thread(() => {
                    credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                        GoogleClientSecrets.Load(stream).Secrets,
                        scopes,
                        "user",
                        CancellationToken.None,
                        new FileDataStore(credPath, true)
                        ).Result;
                });

                thread.Start();
                if (!thread.Join(60000))
                {
                    MessageBox.Show("Error en iniciar sesión!");
                    return;
                }
            }

            // Create Drive API service.
            var service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = "MejiaDrive",
            });

            //File info
            var FileMetadata = new Google.Apis.Drive.v3.Data.File();

            FileMetadata.Name     = "MejiaBackup";
            FileMetadata.MimeType = "application/octet-stream";

            //Request
            FilesResource.CreateMediaUpload request;
            string fileToUploadPath = @"C:\Users\Public\Documents\SqlBackups\MejiaBackup.bak";

            //Take fileStream and Execute request
            using (var stream = new FileStream(fileToUploadPath, FileMode.Open))
            {
                fileSize       = stream.Length;
                request        = service.Files.Create(FileMetadata, stream, "application/octet-stream");
                request.Fields = "id";

                request.ProgressChanged += UploadProgressEvent;
                //await request.UploadAsync();
                //Google.Apis.Upload.IUploadProgress x = await request.UploadAsync();

                await request.UploadAsync();
            }
        }
コード例 #60
0
 public bool InitService()
 {
     driverservice  = createService();
     serviceStarted = true;
     return(true);
 }