public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            using (var api = AmazonS3Helper.GetApi(_account))
            {
                if (parent.Id == "/")
                {
                    var response = await api.ListBucketsAsync();
                    
                    var items = response.Buckets.Select(_ => new StorageProviderItem
                    {
                        Id = _.BucketName,
                        Name = _.BucketName,
                        Type = StorageProviderItemType.Folder,
                        ParentReferenceId = parent.Id
                    });

                    return items.ToArray();
                }
                else
                {
                    string bucket;
                    string filename;
                    GetBucketAndKey(parent.Id, out bucket, out filename);
                    var filenameLength = string.IsNullOrEmpty(filename) ? 0 : filename.Length;

                    var request = new ListObjectsV2Request
                    {
                        BucketName = bucket,
                        Prefix = filename,
                    };

                    var items = new List<StorageProviderItem>();
                    ListObjectsV2Response response;
                    var finished = false;

                    do
                    {
                        response = await api.ListObjectsV2Async(request);
                        foreach (var o in response.S3Objects)
                        {
                            var normalized = o.Key.Substring(filenameLength);
                            if (string.IsNullOrEmpty(normalized))
                                continue;

                            if (normalized.EndsWith("/"))
                            {
                                normalized = normalized.Remove(normalized.Length - 1);
                            }


                            if (normalized.Contains('/'))
                            {
                                finished = true;
                                break;
                            }

                            items.Add(new StorageProviderItem
                            {
                                Id = bucket + "/" + o.Key,
                                Name = normalized,
                                Type = o.Size > 0 ? StorageProviderItemType.File : StorageProviderItemType.Folder,
                                ParentReferenceId = parent.Id,
                            });
                        }

                        if (finished)
                            break;

                        request.ContinuationToken = response.NextContinuationToken;

                    } while (response.IsTruncated);

                    return items.ToArray();
                }
            }
        }
        private static StorageProviderItem CreateStorageProviderItem(StorageProviderItem parent, Metadata item)
        {
            var result = new StorageProviderItem
            {
                Name = item.Name,
                Id   = item.PathLower,
                //Id = CloudPath.Combine(parent.Id, item.PathLower),
                ParentReferenceId = parent.Id
            };

            if (item.IsFile)
            {
                result.Type = StorageProviderItemType.File;
                //                result.Id = item.AsFile.Id; // Path.Combine(parent.Id, item.PathLower)
                result.LastModifiedDateTime = item.AsFile.ServerModified;
            }
            else if (item.IsFolder)
            {
                result.Type = StorageProviderItemType.Folder;
                //                result.Id = item.AsFolder.Id; // Path.Combine(parent.Id, item.PathLower);
            }
            else
            {
                result.Type = StorageProviderItemType.Unknown;
            }

            return(result);
        }
        private async Task SetProvider(IStorageProvider provider)
        {
            if (m_provider == provider)
            {
                return;
            }

            m_provider = provider;
            m_cache.Clear();
            m_stack.Clear();

            if (m_provider == null)
            {
                await SetSelectedItem(null);
            }
            else
            {
                StorageProviderItem root = null;
                try
                {
                    root = await m_provider.GetRootItem();
                }
                catch (Exception ex)
                {
                    MessageService.ShowWarning("Error getting Root node.\r\nException:", ex);
                }

                await SetSelectedItem(root);
            }
        }
Beispiel #4
0
        private static StorageProviderItem CreateStorageProviderItem(StorageProviderItem parent, AmazonNode item)
        {
            var result = new StorageProviderItem
            {
                Name = item.name,
                Id   = item.id,
                ParentReferenceId    = parent.Id,
                LastModifiedDateTime = item.modifiedDate
            };

            switch (item.kind)
            {
            case AmazonNodeKind.FILE:
                result.Type = StorageProviderItemType.File;
                break;

            case AmazonNodeKind.FOLDER:
                result.Type = StorageProviderItemType.Folder;
                break;

            default:
                result.Type = StorageProviderItemType.Unknown;
                break;
            }

            return(result);
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            var blobContainer = await GetContainer(_account);
            var directory = blobContainer.GetDirectoryReference(parent.Id);
            BlobContinuationToken blobContinuationToken = null;
            var result = new List<StorageProviderItem>();

            do
            {
                var listSegment = await directory.ListBlobsSegmentedAsync(blobContinuationToken);
                result.AddRange(listSegment.Results.OfType<CloudBlobDirectory>().Select(s => new StorageProviderItem
                {
                    Id = s.Prefix,
                    Name = GetName(s.Prefix, s.Parent),
                    Type = StorageProviderItemType.Folder,
                    ParentReferenceId = parent.Id
                }));

                result.AddRange(listSegment.Results.OfType<CloudBlob>().Select(s => new StorageProviderItem
                {
                    Id = s.Uri.ToString(),
                    Name = GetName(s.Name, s.Parent),
                    Type = StorageProviderItemType.File,
                    ParentReferenceId = parent.Id
                }));

                blobContinuationToken = listSegment.ContinuationToken;
            } while (blobContinuationToken != null);

            return result;
        }
Beispiel #6
0
        private async Task <ItemInfo> GetItemInfo(StorageProviderItem item)
        {
            if (m_cache.ContainsKey(item))
            {
                return(m_cache[item]);
            }

            var info   = new ItemInfo();
            var result = await m_provider.GetChildrenByParentItem(item);

            info.Children = result.OrderByDescending(_ => _.Type).ThenBy(_ => _.Name).ToArray();

            if (item.ParentReferenceId != null)
            {
                var parent = m_cache.Keys.SingleOrDefault(_ => _.Id == item.ParentReferenceId);
                if (parent != null)
                {
                    info.Parent = parent;
                }
                else
                {
                    throw new NotImplementedException();
                }
                //await m_provider.GetItem(item.ParentReference.Id);
            }

            m_cache.Add(item, info);

            return(info);
        }
        private static StorageProviderItem CreateStorageProviderItem(StorageProviderItem parent, Metadata item)
        {
            var result = new StorageProviderItem
            {
                Name = item.Name,
                Id = Path.Combine(parent.Id, item.PathLower),
                ParentReferenceId = parent.Id
            };

            if (item.IsFile)
            {
                result.Type = StorageProviderItemType.File;
//                result.Id = item.AsFile.Id; // Path.Combine(parent.Id, item.PathLower)
                result.LastModifiedDateTime = item.AsFile.ServerModified;
            }
            else if (item.IsFolder)
            {
                result.Type = StorageProviderItemType.Folder;
//                result.Id = item.AsFolder.Id; // Path.Combine(parent.Id, item.PathLower);
            }
            else
            {
                result.Type = StorageProviderItemType.Unknown;
            }

            return result;
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            var api = await GetApi();

            var fields = new[]
            {
                DirectoryBaseItem.Fields.Members_Path, DirectoryBaseItem.Fields.Members_Name, DirectoryBaseItem.Fields.Members_Id, DirectoryBaseItem.Fields.Members_Type, DirectoryBaseItem.Fields.Members_IsReadable, DirectoryBaseItem.Fields.Members_IsWritable, DirectoryBaseItem.Fields.Members_ModiefiedDateTime
            };

            var dir = await api
                .Directory
                .Get(null, parent.Id, new [] {DirectoryMember.Directory, DirectoryMember.File }, fields)
                .ExecuteAsync();

            var items = dir.Members.Where(_ => _.IsReadable.Value && _.IsWritable.Value).Select(_ => new StorageProviderItem
            {
                Id = _.Id,
                Name = _.Name,
                Type =
                    _.Type == "file"
                        ? StorageProviderItemType.File
                        : (_.Type == "dir" ? StorageProviderItemType.Folder : StorageProviderItemType.Unknown),
                ParentReferenceId = parent.Id,
                LastModifiedDateTime = _.ModifiedDateTime,
            });

            return items.ToArray();
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null) throw new ArgumentNullException("parent");

            var dbxItems = await Api.Files.ListFolderAsync(parent.Id);
            var items = dbxItems.Entries.Select(_ => CreateStorageProviderItem(parent, _));

            return items.ToArray();
        }
        private async Task SetSelectedItem(StorageProviderItem item)
        {
            if (m_selectedItem == item || (item != null) && item.Type != StorageProviderItemType.Folder)
            {
                return;
            }

            m_selectedItem = item;

            await UpdateListView();

            m_txtUrl.Text = GetResultUri();
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null) throw new ArgumentNullException("parent");

            var api = await OneDriveHelper.GetApi(_account);

            var odChildren = await api.Drive.Items[parent.Id].Children.Request().GetAsync();

            var children =
                odChildren.Select(odItem => CreateStorageProviderItemFromOneDriveItem(odItem)).ToArray();

            return children;
        }
Beispiel #12
0
        protected StorageProviderItem CreateStorageProviderItemFromOneDriveItem(DriveItem item)
        {
            var providerItem = new StorageProviderItem
            {
                Type =
                    item.IsFolder()
                        ? StorageProviderItemType.Folder
                        : (item.IsFile() ? StorageProviderItemType.File : StorageProviderItemType.Unknown),
                Id   = item.Id,
                Name = item.Name,
                LastModifiedDateTime = item.LastModifiedDateTime,
                ParentReferenceId    = item.ParentReference != null && !string.IsNullOrEmpty(item.ParentReference.Path) ? item.ParentReference.Id : null
            };

            return(providerItem);
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            var api = await GetApi();

            var folderItems = await api.FoldersManager.GetFolderItemsAsync(parent.Id, BoxHelper.Limit);

            var items = folderItems.Entries.Select(_ => new StorageProviderItem()
            {
                Id = _.Id,
                Name = _.Name,
                Type = _.Type == "folder" ? StorageProviderItemType.Folder : (_.Type == "file" ? StorageProviderItemType.File : StorageProviderItemType.Unknown),
                LastModifiedDateTime = _.ModifiedAt,
                ParentReferenceId = parent.Id,
            });

            return items.ToArray();
        }
        private async Task <ItemInfo> GetItemInfo(StorageProviderItem item)
        {
            if (m_cache.ContainsKey(item))
            {
                return(m_cache[item]);
            }

            var info = new ItemInfo();

            if (item.ParentReferenceId != null)
            {
                var parent = m_cache.Keys.SingleOrDefault(_ => _.Id == item.ParentReferenceId);
                if (parent != null)
                {
                    info.Parent = parent;
                }
                else
                {
                    throw new InvalidOperationException("Parent of node not found!");
                }
                //await m_provider.GetItem(item.ParentReference.Id);
            }

            IEnumerable <StorageProviderItem> result;

            try
            {
                result = await m_provider.GetChildrenByParentItem(item);

                // For Debugging Only:
                // Clipboard.SetText(string.Join("\r\n", result.Select(_ => _.Id).ToArray()));
            }
            catch (Exception ex)
            {
                MessageService.ShowWarning("Error loading file list.\r\nException:", ex);
                return(info);
            }

            info.Children = result.OrderByDescending(_ => _.Type).ThenBy(_ => _.Name).ToArray();

            m_cache.Add(item, info);

            return(info);
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            var client = await GetClient();
            var container = await GetDefaultContainer();
            var objects = await client.GetObjects(container, parent.Id);

            var ret = objects.Select(_ => new StorageProviderItem
            {
                Type =
                    _.ContentType == "application/directory"
                        ? StorageProviderItemType.Folder
                        : StorageProviderItemType.File,
                Name = NormalizeName(_.Name),
                Id = _.Name,
                ParentReferenceId = parent.Id,
                LastModifiedDateTime = _.LastModified
            });

            return ret.ToArray();
        }
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            var api = await GetApi();

            var query = api.Files.List();

            query.Q = string.Format("'{0}' in parents and trashed = false", parent.Id);
            var items = await query.ExecuteAsync();

            var newItems = items.Files.Select(_ => new StorageProviderItem()
            {
                Id   = _.Id,
                Name = _.Name,
                Type =
                    _.MimeType == "application/vnd.google-apps.folder"
                        ? StorageProviderItemType.Folder
                        : StorageProviderItemType.File,
                LastModifiedDateTime = _.ModifiedTime,
                ParentReferenceId    = parent.Id,
            });

            return(newItems.ToArray());
        }
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            var client = await GetClient();

            var container = await GetDefaultContainer();

            var objects = await client.GetObjects(container, parent.Id);

            var ret = objects.Select(_ => new StorageProviderItem
            {
                Type =
                    _.ContentType == "application/directory"
                        ? StorageProviderItemType.Folder
                        : StorageProviderItemType.File,
                Name = NormalizeName(_.Name),
                Id   = _.Name,
                ParentReferenceId    = parent.Id,
                LastModifiedDateTime = _.LastModified
            });

            return(ret.ToArray());
        }
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            var fileShare = await GetShare(_account);

            var rootDir = fileShare.GetRootDirectoryReference();

            var directory = rootDir;

            if (!String.IsNullOrEmpty(parent.Id))
            {
                directory = rootDir.GetDirectoryReference(parent.Id);
            }

            FileContinuationToken fileContinuationToken = null;
            var result = new List <StorageProviderItem>();

            do
            {
                var listSegment = await directory.ListFilesAndDirectoriesSegmentedAsync(fileContinuationToken);

                result.AddRange(listSegment.Results.OfType <CloudFileDirectory>().Select(s => new StorageProviderItem
                {
                    Id   = GetId(s.Parent, s.Name),
                    Name = s.Name,
                    Type = StorageProviderItemType.Folder,
                    ParentReferenceId = parent.Id
                }));

                result.AddRange(listSegment.Results.OfType <CloudFile>().Select(s => new StorageProviderItem
                {
                    Id   = GetId(s.Parent, s.Name),
                    Name = s.Name,
                    Type = StorageProviderItemType.File,
                    ParentReferenceId = parent.Id
                }));

                fileContinuationToken = listSegment.ContinuationToken;
            } while (fileContinuationToken != null);

            return(result);
        }
Beispiel #19
0
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            var api = await OneDriveHelper.GetApi(_account);

            var odChildren = await api.Drive.Items[parent.Id].Children.Request().GetAsync();

            var children =
                odChildren.Select(odItem => CreateStorageProviderItemFromOneDriveItem(odItem)).ToArray();

            return(children);
        }
Beispiel #20
0
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            var api = await GetApi();

            var folderItems = await api.FoldersManager.GetFolderItemsAsync(parent.Id, BoxHelper.Limit);

            var items = folderItems.Entries.Select(_ => new StorageProviderItem()
            {
                Id   = _.Id,
                Name = _.Name,
                Type = _.Type == "folder" ? StorageProviderItemType.Folder : (_.Type == "file" ? StorageProviderItemType.File : StorageProviderItemType.Unknown),
                LastModifiedDateTime = _.ModifiedAt,
                ParentReferenceId    = parent.Id,
            });

            return(items.ToArray());
        }
Beispiel #21
0
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            var api = await GetApi();

            var fields = new[]
            {
                DirectoryBaseItem.Fields.Members_Path, DirectoryBaseItem.Fields.Members_Name, DirectoryBaseItem.Fields.Members_Id, DirectoryBaseItem.Fields.Members_Type, DirectoryBaseItem.Fields.Members_IsReadable, DirectoryBaseItem.Fields.Members_IsWritable, DirectoryBaseItem.Fields.Members_ModiefiedDateTime
            };

            var dir = await api
                      .Directory
                      .Get(null, parent.Id, new [] { DirectoryMember.Directory, DirectoryMember.File }, fields)
                      .ExecuteAsync();

            var items = dir.Members.Where(_ => _.IsReadable.Value && _.IsWritable.Value).Select(_ => new StorageProviderItem
            {
                Id   = _.Id,
                Name = _.Name,
                Type =
                    _.Type == "file"
                        ? StorageProviderItemType.File
                        : (_.Type == "dir" ? StorageProviderItemType.Folder : StorageProviderItemType.Unknown),
                ParentReferenceId    = parent.Id,
                LastModifiedDateTime = _.ModifiedDateTime,
            });

            return(items.ToArray());
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null) throw new ArgumentNullException("parent");

            var api = await GetApi();

            var driveItems = await api.Nodes.GetChildren(String.IsNullOrEmpty(parent.Id) ? null : parent.Id);
            var items = driveItems.Select(_ => CreateStorageProviderItem(parent, _));

            return items.ToArray();
        }
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            var api = await GetApi();

            var odChildren = await api.GetChildrenByParentItem(new OneDriveItem { Id = parent.Id });

            var children =
                odChildren.Collection.Select(odItem => CreateStorageProviderItemFromOneDriveItem(odItem)).ToArray();

            return(children);
        }
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            var dbxItems = await Api.Files.ListFolderAsync(parent.Id);

            var items = dbxItems.Entries.Select(_ => CreateStorageProviderItem(parent, _));

            while (dbxItems.HasMore)
            {
                dbxItems = await Api.Files.ListFolderContinueAsync(dbxItems.Cursor);

                items = items.Concat(dbxItems.Entries.Select(_ => CreateStorageProviderItem(parent, _)));
            }

            return(items.ToArray());
        }
Beispiel #25
0
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            var api = await GetApi();

            var driveItems = await api.Nodes.GetChildren(string.IsNullOrEmpty(parent.Id)?null : parent.Id);

            var items = driveItems.Select(_ => CreateStorageProviderItem(parent, _));

            return(items.ToArray());
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            var api = await GetApi();
            var query = api.Files.List();
            query.Q = string.Format("'{0}' in parents and trashed = false", parent.Id);
            var items = await query.ExecuteAsync();

            var newItems = items.Files.Select(_ => new StorageProviderItem()
            {
                Id = _.Id,
                Name = _.Name,
                Type =
                    _.MimeType == "application/vnd.google-apps.folder"
                        ? StorageProviderItemType.Folder
                        : StorageProviderItemType.File,
                LastModifiedDateTime = _.ModifiedTime,
                ParentReferenceId = parent.Id,
            });

            return newItems.ToArray();
        }
        private static StorageProviderItem CreateStorageProviderItem(StorageProviderItem parent, AmazonNode item)
        {
            var result = new StorageProviderItem
            {
                Name = item.name,
                Id = item.id,
                ParentReferenceId = parent.Id,
                LastModifiedDateTime = item.modifiedDate
            };

            switch (item.kind)
            {
                case AmazonNodeKind.FILE:
                    result.Type = StorageProviderItemType.File;
                    break;
                case AmazonNodeKind.FOLDER:
                    result.Type = StorageProviderItemType.Folder;
                    break;
                default:
                    result.Type = StorageProviderItemType.Unknown;
                    break;
            }

            return result;
        }
        protected StorageProviderItem CreateStorageProviderItemFromOneDriveItem(Item item)
        {
            var providerItem = new StorageProviderItem
            {
                Type = 
                    item.IsFolder()
                        ? StorageProviderItemType.Folder
                        : (item.IsFile() ? StorageProviderItemType.File : StorageProviderItemType.Unknown),
                Id = item.Id,
                Name = item.Name,
                LastModifiedDateTime = item.LastModifiedDateTime,
                ParentReferenceId = item.ParentReference != null && !string.IsNullOrEmpty(item.ParentReference.Path) ? item.ParentReference.Id : null
            };

            return providerItem;
        }
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            using (var api = AmazonS3Helper.GetApi(_account))
            {
                if (parent.Id == "/")
                {
                    var response = await api.ListBucketsAsync();

                    var items = response.Buckets.Select(_ => new StorageProviderItem
                    {
                        Id   = _.BucketName,
                        Name = _.BucketName,
                        Type = StorageProviderItemType.Folder,
                        ParentReferenceId = parent.Id
                    });

                    return(items.ToArray());
                }
                else
                {
                    string bucket;
                    string filename;
                    GetBucketAndKey(parent.Id, out bucket, out filename);
                    var filenameLength = string.IsNullOrEmpty(filename) ? 0 : filename.Length;

                    var request = new ListObjectsV2Request
                    {
                        BucketName = bucket,
                        Prefix     = filename,
                    };

                    var items = new List <StorageProviderItem>();
                    ListObjectsV2Response response;
                    var finished = false;

                    do
                    {
                        response = await api.ListObjectsV2Async(request);

                        foreach (var o in response.S3Objects)
                        {
                            var normalized = o.Key.Substring(filenameLength);
                            if (string.IsNullOrEmpty(normalized))
                            {
                                continue;
                            }

                            if (normalized.EndsWith("/"))
                            {
                                normalized = normalized.Remove(normalized.Length - 1);
                            }


                            if (normalized.Contains('/'))
                            {
                                finished = true;
                                break;
                            }

                            items.Add(new StorageProviderItem
                            {
                                Id   = bucket + "/" + o.Key,
                                Name = normalized,
                                Type = o.Size > 0 ? StorageProviderItemType.File : StorageProviderItemType.Folder,
                                ParentReferenceId = parent.Id,
                            });
                        }

                        if (finished)
                        {
                            break;
                        }

                        request.ContinuationToken = response.NextContinuationToken;
                    } while (response.IsTruncated);

                    return(items.ToArray());
                }
            }
        }
        public async Task<IEnumerable<StorageProviderItem>> GetChildrenByParentItem(StorageProviderItem parent)
        {
            if (parent == null) throw new ArgumentNullException("parent");

            var api = await GetApi();
            var odChildren = await api.GetChildrenByParentItem(new OneDriveItem {Id = parent.Id});

            var children =
                odChildren.Collection.Select(odItem => CreateStorageProviderItemFromOneDriveItem(odItem)).ToArray();

            return children;
        }
Beispiel #31
0
        public async Task <IEnumerable <StorageProviderItem> > GetChildrenByParentItem(StorageProviderItem parent)
        {
            using (var api = AmazonS3Helper.GetApi(_account))
            {
                if (parent.Id == "/")
                {
                    var response = await api.ListBucketsAsync();

                    var items = response.Buckets.Select(_ => new StorageProviderItem
                    {
                        Id   = _.BucketName,
                        Name = _.BucketName,
                        Type = StorageProviderItemType.Folder,
                        ParentReferenceId = parent.Id
                    });

                    return(items.ToArray());
                }
                else
                {
                    string bucket;
                    string prefix;
                    GetBucketAndKey(parent.Id, out bucket, out prefix);

                    var request = new ListObjectsV2Request
                    {
                        BucketName = bucket,
                        Prefix     = prefix,
                        Delimiter  = "/",
                    };

                    var items = new List <StorageProviderItem>();
                    ListObjectsV2Response response;

                    do
                    {
                        response = await api.ListObjectsV2Async(request);

                        items.AddRange(response.CommonPrefixes.Select(folderName => new StorageProviderItem
                        {
                            Id   = bucket + "/" + folderName,
                            Name = folderName.RemovePrefix(prefix).RemoveTrailingSlash(),
                            Type = StorageProviderItemType.Folder,
                            ParentReferenceId = parent.Id,
                        }));

                        foreach (var o in response.S3Objects)
                        {
                            var normalized = o.Key.RemovePrefix(prefix);

                            if (string.IsNullOrEmpty(normalized) || normalized.EndsWith("/")) // Is Parent Folder (Dummy Item)? => ignore
                            {
                                continue;
                            }

                            items.Add(new StorageProviderItem
                            {
                                Id   = bucket + "/" + o.Key,
                                Name = normalized,
                                Type = StorageProviderItemType.File,
                                ParentReferenceId    = parent.Id,
                                LastModifiedDateTime = o.LastModified
                            });
                        }

                        request.ContinuationToken = response.NextContinuationToken;
                    } while (response.IsTruncated);

                    return(items.ToArray());
                }
            }
        }