public async Task<QueryResult<FileSystemMetadata>> GetFiles(string[] pathParts, string rootFolderId, GoogleCredentials googleCredentials,
         CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService = fullDriveService.Item1;

            var result = new QueryResult<FileSystemMetadata>();

            if (pathParts != null && pathParts.Length > 0)
            {
                var name = pathParts.Last();
                pathParts = pathParts.Take(pathParts.Length - 1).ToArray();

                try
                {
                    var parentId = await FindOrCreateParent(driveService, false, pathParts, rootFolderId, cancellationToken)
                                .ConfigureAwait(false);

                    var file = await FindFileId(name, parentId, driveService, cancellationToken).ConfigureAwait(false);

                    result.TotalRecordCount = 1;
                    result.Items = new[] { file }.Select(GetFileMetadata).ToArray();
                }
                catch (FileNotFoundException)
                {

                }

                return result;
            }

            return result;
        }
        private DriveService CreateDriveService(GoogleCredentials googleCredentials)
        {
            var authorizationCodeFlowInitializer = new GoogleAuthorizationCodeFlow.Initializer
            {
                ClientSecrets = new ClientSecrets
                {
                    ClientId     = googleCredentials.ClientId,
                    ClientSecret = googleCredentials.ClientSecret
                }
            };
            var googleAuthorizationCodeFlow = new GoogleAuthorizationCodeFlow(authorizationCodeFlowInitializer);
            var token = new TokenResponse {
                RefreshToken = googleCredentials.RefreshToken
            };
            var credentials = new UserCredential(googleAuthorizationCodeFlow, "user", token);

            var initializer = new BaseClientService.Initializer
            {
                ApplicationName       = "Emby",
                HttpClientInitializer = credentials
            };

            return(new DriveService(initializer)
            {
                HttpClient = { Timeout = TimeSpan.FromHours(1) }
            });
        }
        public async Task<QueryResult<FileMetadata>> GetFiles(FileQuery query, string rootFolderId, GoogleCredentials googleCredentials,
            CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService = fullDriveService.Item1;

            var result = new QueryResult<FileMetadata>();

            if (!string.IsNullOrWhiteSpace(query.Id))
            {
                try
                {
                    var file = await GetFile(query.Id, driveService, cancellationToken).ConfigureAwait(false);

                    result.TotalRecordCount = 1;
                    result.Items = new[] { file }.Select(GetFileMetadata).ToArray();
                }
                catch (FileNotFoundException)
                {
                    
                }

                return result;
            }

            if (query.FullPath != null && query.FullPath.Length > 0)
            {
                var name = query.FullPath.Last();
                var pathParts = query.FullPath.Take(query.FullPath.Length - 1).ToArray();

                try
                {
                    var parentId = await FindOrCreateParent(driveService, false, pathParts, rootFolderId, cancellationToken)
                                .ConfigureAwait(false);

                    var file = await FindFileId(name, parentId, driveService, cancellationToken).ConfigureAwait(false);

                    result.TotalRecordCount = 1;
                    result.Items = new[] { file }.Select(GetFileMetadata).ToArray();
                }
                catch (FileNotFoundException)
                {

                }

                return result;
            }

            var queryResult = await GetFiles(null, driveService, cancellationToken).ConfigureAwait(false);
            var files = queryResult
                .Select(GetFileMetadata)
                .ToArray();

            result.Items = files;
            result.TotalRecordCount = files.Length;

            return result;
        }
Example #4
0
        public async Task <string> CreateDownloadUrl(string fileId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var uploadedFile = await GetFile(fileId, driveService, cancellationToken);

            return(uploadedFile.DownloadUrl + "&access_token=" + fullDriveService.Item2.Token.AccessToken);
        }
Example #5
0
        public async Task DeleteFile(string fileId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var file = await GetFile(fileId, driveService, cancellationToken);

            var request = driveService.Files.Delete(file.Id);
            await request.ExecuteAsync(cancellationToken);
        }
Example #6
0
        public async Task <string> GetOrCreateFolder(string name, string parentId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var driveService = CreateDriveService(googleCredentials);

            var folder = await FindFolder(name, parentId, driveService, cancellationToken);

            if (folder != null)
            {
                return(folder.Id);
            }

            return(await CreateFolder(name, parentId, cancellationToken, driveService));
        }
        public async Task<QueryResult<FileSystemMetadata>> GetFiles(string rootFolderId, GoogleCredentials googleCredentials,
            CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService = fullDriveService.Item1;

            var result = new QueryResult<FileSystemMetadata>();

            var queryResult = await GetFiles(null, driveService, cancellationToken).ConfigureAwait(false);
            var files = queryResult
                .Select(GetFileMetadata)
                .ToArray();

            result.Items = files;
            result.TotalRecordCount = files.Length;

            return result;
        }
        public async Task<QueryResult<FileSystemMetadata>> GetFiles(string id, string rootFolderId, GoogleCredentials googleCredentials,
            CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService = fullDriveService.Item1;

            var result = new QueryResult<FileSystemMetadata>();

            try
            {
                var file = await GetFile(id, driveService, cancellationToken).ConfigureAwait(false);

                result.TotalRecordCount = 1;
                result.Items = new[] { file }.Select(GetFileMetadata).ToArray();
            }
            catch (FileNotFoundException)
            {

            }

            return result;
        }
        public async Task<string> GetOrCreateFolder(string name, string parentId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var driveService = CreateDriveService(googleCredentials);

            var folder = await FindFolder(name, parentId, driveService, cancellationToken);

            if (folder != null)
            {
                return folder.Id;
            }

            return await CreateFolder(name, parentId, cancellationToken, driveService);
        }
        public async Task DeleteFile(string fileId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService = fullDriveService.Item1;

            var file = await GetFile(fileId, driveService, cancellationToken);

            var request = driveService.Files.Delete(file.Id);
            await request.ExecuteAsync(cancellationToken);
        }
        public async Task<Tuple<string,string>> UploadFile(Stream stream, string[] pathParts, string folderId, GoogleCredentials googleCredentials, IProgress<double> progress, CancellationToken cancellationToken)
        {
            var name = pathParts.Last();
            pathParts = pathParts.Take(pathParts.Length - 1).ToArray();

            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService = fullDriveService.Item1;

            var parentId = await FindOrCreateParent(driveService, true, pathParts, folderId, cancellationToken);
            await TryDeleteFile(parentId, name, driveService, cancellationToken);

            var googleDriveFile = CreateGoogleDriveFile(pathParts, name, folderId);
            googleDriveFile.GoogleDriveFolderId = parentId;

            var file = CreateFileToUpload(googleDriveFile);
            await ExecuteUpload(driveService, stream, file, progress, cancellationToken);

            var uploadedFile = await FindFileId(name, parentId, driveService, cancellationToken);
            return new Tuple<string, string>(uploadedFile.Id, uploadedFile.DownloadUrl + "&access_token=" + fullDriveService.Item2.Token.AccessToken);
        }
        public async Task<string> CreateDownloadUrl(string fileId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService = fullDriveService.Item1;

            var uploadedFile = await GetFile(fileId, driveService, cancellationToken);
            return uploadedFile.DownloadUrl + "&access_token=" + fullDriveService.Item2.Token.AccessToken;
        }
        public async Task <QueryResult <FileMetadata> > GetFiles(FileQuery query, string rootFolderId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var result = new QueryResult <FileMetadata>();

            if (!string.IsNullOrWhiteSpace(query.Id))
            {
                try
                {
                    _logger.Debug("Getting files with id {0}", query.Id);

                    var file = await GetFile(query.Id, driveService, cancellationToken).ConfigureAwait(false);

                    result.TotalRecordCount = 1;
                    result.Items            = new[] { file }.Select(GetFileMetadata).ToArray();
                }
                catch (FileNotFoundException)
                { }

                return(result);
            }

            if (query.FullPath != null && query.FullPath.Length > 0)
            {
                _logger.Debug("Getting files with path {0}", string.Join("/", query.FullPath));

                var name      = query.FullPath.Last();
                var pathParts = query.FullPath.Take(query.FullPath.Length - 1).ToArray();

                try
                {
                    var parentId = await FindOrCreateParent(driveService, pathParts, rootFolderId, cancellationToken)
                                   .ConfigureAwait(false);

                    var file = await FindFileId(name, parentId, driveService, cancellationToken).ConfigureAwait(false);

                    result.TotalRecordCount = 1;
                    result.Items            = new[] { file }.Select(GetFileMetadata).ToArray();
                }
                catch (FileNotFoundException)
                { }

                return(result);
            }

            _logger.Debug("Getting all files");

            var queryResult = await GetFiles(null, driveService, cancellationToken).ConfigureAwait(false);

            var files = queryResult
                        .Select(GetFileMetadata)
                        .ToArray();

            result.Items            = files;
            result.TotalRecordCount = files.Length;

            return(result);
        }
Example #14
0
        public async Task <QueryResult <FileSystemMetadata> > GetFiles(string rootFolderId, GoogleCredentials googleCredentials,
                                                                       CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var result = new QueryResult <FileSystemMetadata>();

            var queryResult = await GetFiles(null, driveService, cancellationToken).ConfigureAwait(false);

            var files = queryResult
                        .Select(GetFileMetadata)
                        .ToArray();

            result.Items            = files;
            result.TotalRecordCount = files.Length;

            return(result);
        }
Example #15
0
        public async Task <QueryResult <FileSystemMetadata> > GetFiles(string[] pathParts, string rootFolderId, GoogleCredentials googleCredentials,
                                                                       CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var result = new QueryResult <FileSystemMetadata>();

            if (pathParts != null && pathParts.Length > 0)
            {
                var name = pathParts.Last();
                pathParts = pathParts.Take(pathParts.Length - 1).ToArray();

                try
                {
                    var parentId = await FindOrCreateParent(driveService, false, pathParts, rootFolderId, cancellationToken)
                                   .ConfigureAwait(false);

                    var file = await FindFileId(name, parentId, driveService, cancellationToken).ConfigureAwait(false);

                    result.TotalRecordCount = 1;
                    result.Items            = new[] { file }.Select(GetFileMetadata).ToArray();
                }
                catch (FileNotFoundException)
                {
                }

                return(result);
            }

            return(result);
        }
        public async Task <string> GetOrCreateFolder(string name, string parentId, GoogleCredentials googleCredentials, CancellationToken cancellationToken)
        {
            var driveService = CreateDriveService(googleCredentials);

            return(await GetOrCreateFolder(name, parentId, driveService, cancellationToken));
        }
Example #17
0
        public Task <string> GetChildFolder(string name, string parentId, GoogleCredentials googleCredentials, bool createIfNotExists, CancellationToken cancellationToken)
        {
            var driveService = CreateDriveServiceAndCredentials(googleCredentials).Item1;

            return(GetChildFolder(name, parentId, driveService, createIfNotExists, cancellationToken));
        }
Example #18
0
        public async Task <QueryResult <FileSystemMetadata> > GetFilesInFolder(string folderId, GoogleCredentials googleCredentials,
                                                                               DriveService driveService, CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(folderId))
            {
                throw new ArgumentNullException(nameof(folderId));
            }

            var query = string.Format("'{0}' in parents", folderId);

            var matchingFiles = await GetFiles(query, driveService, cancellationToken).ConfigureAwait(false);

            var result = new QueryResult <FileSystemMetadata>();

            if (matchingFiles != null)
            {
                result.Items            = matchingFiles.Select(GetFileMetadata).ToArray();
                result.TotalRecordCount = result.Items.Length;
            }

            return(result);
        }
Example #19
0
        public async Task <QueryResult <FileSystemMetadata> > GetFiles(string[] pathParts, string rootFolderId, GoogleCredentials googleCredentials,
                                                                       CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var result = new QueryResult <FileSystemMetadata>();

            if (pathParts != null && pathParts.Length > 0)
            {
                try
                {
                    var parentId = await GetFolderFromPath(driveService, pathParts, rootFolderId, false, cancellationToken).ConfigureAwait(false);

                    if (!string.IsNullOrEmpty(parentId))
                    {
                        result = await this.GetFilesInFolder(parentId, googleCredentials, driveService, cancellationToken).ConfigureAwait(false);
                    }
                }
                catch (FileNotFoundException)
                {
                }

                return(result);
            }

            return(result);
        }
        public async Task <Tuple <string, string> > UploadFile(Stream stream, string[] pathParts, string folderId, GoogleCredentials googleCredentials, IProgress <double> progress, CancellationToken cancellationToken)
        {
            var name = pathParts.Last();

            pathParts = pathParts.Take(pathParts.Length - 1).ToArray();

            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var parentId = await FindOrCreateParent(driveService, pathParts, folderId, cancellationToken);

            await TryDeleteFile(parentId, name, driveService, cancellationToken);

            var googleDriveFile = CreateGoogleDriveFile(pathParts, name, folderId);

            googleDriveFile.GoogleDriveFolderId = parentId;

            var file = CreateFileToUpload(googleDriveFile);

            await ExecuteUpload(driveService, stream, file, progress, cancellationToken);

            var uploadedFile = await FindFileId(name, parentId, driveService, cancellationToken);

            return(new Tuple <string, string>(uploadedFile.Id, uploadedFile.DownloadUrl + "&access_token=" + fullDriveService.Item2.Token.AccessToken));
        }
Example #21
0
        public async Task <QueryResult <FileSystemMetadata> > GetFiles(string id, string rootFolderId, GoogleCredentials googleCredentials,
                                                                       CancellationToken cancellationToken)
        {
            var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
            var driveService     = fullDriveService.Item1;

            var result = new QueryResult <FileSystemMetadata>();

            try
            {
                var file = await GetFile(id, driveService, cancellationToken).ConfigureAwait(false);

                result.TotalRecordCount = 1;
                result.Items            = new[] { file }.Select(GetFileMetadata).ToArray();
            }
            catch (FileNotFoundException)
            {
            }

            return(result);
        }
        private DriveService CreateDriveService(GoogleCredentials googleCredentials)
        {
            var authorizationCodeFlowInitializer = new GoogleAuthorizationCodeFlow.Initializer
            {
                ClientSecrets = new ClientSecrets
                {
                    ClientId = googleCredentials.ClientId,
                    ClientSecret = googleCredentials.ClientSecret
                }
            };
            var googleAuthorizationCodeFlow = new GoogleAuthorizationCodeFlow(authorizationCodeFlowInitializer);
            var token = new TokenResponse { RefreshToken = googleCredentials.RefreshToken };
            var credentials = new UserCredential(googleAuthorizationCodeFlow, "user", token);

            var initializer = new BaseClientService.Initializer
            {
                ApplicationName = "Emby",
                HttpClientInitializer = credentials
            };

            return new DriveService(initializer)
            {
                HttpClient = { Timeout = TimeSpan.FromHours(1) }
            };
        }