public new async Task <FileSystemResult <FileSystemSizes> > QuotaAsync()
        {
            FileSystemResult <ExpandoObject> cl = await FS.OAuth.CreateMetadataStream <ExpandoObject>(GoogleQuota);

            if (!cl.IsOk)
            {
                return(new FileSystemResult <FileSystemSizes>(cl.Error));
            }
            IDictionary <string, object> dic = cl.Result;

            Sizes = new FileSystemSizes();
            if (dic.ContainsKey("quotaBytesTotal"))
            {
                Sizes.TotalSize = ParseLong(dic["quotaBytesTotal"]);
            }
            if (dic.ContainsKey("quotaBytesUsed"))
            {
                Sizes.UsedSize = ParseLong(dic["quotaBytesUsed"]);
            }
            if (dic.ContainsKey("quotaBytesUsedAggregate"))
            {
                Sizes.AvailableSize = Sizes.TotalSize - ParseLong(dic["quotaBytesUsedAggregate"]);
            }
            return(new FileSystemResult <FileSystemSizes>(Sizes));
        }
        public override async Task <FileSystemResult <FileSystemSizes> > QuotaAsync()
        {
            FileSystemSizes Sizes = new FileSystemSizes();

            Sizes.AvailableSize += Drive.AvailableFreeSpace;
            Sizes.UsedSize      += Drive.TotalSize - Drive.AvailableFreeSpace;
            Sizes.TotalSize     += Drive.TotalSize;
            return(await Task.FromResult(new FileSystemResult <FileSystemSizes>(Sizes)));
        }
Beispiel #3
0
        public new async Task <FileSystemResult <FileSystemSizes> > QuotaAsync() // In fact we read the drive
        {
            string url = OneDriveRoot.FormatRest(OneDriveUrl);
            FileSystemResult <dynamic> cl = await FS.OAuth.CreateMetadataStream <dynamic>(url);

            if (!cl.IsOk)
            {
                return(new FileSystemResult <FileSystemSizes>(cl.Error));
            }
            Sizes = new FileSystemSizes
            {
                AvailableSize = cl.Result.quota.remaining ?? 0,
                TotalSize     = cl.Result.quota.total ?? 0,
                UsedSize      = cl.Result.quota.used ?? 0
            };
            return(new FileSystemResult <FileSystemSizes>(Sizes));
        }
        public async Task <FileSystemResult <FileSystemSizes> > QuotaAsync()
        {
            string url = AmazonQuota.FormatRest(OAuth.EndPoint.MetadataUrl);
            FileSystemResult <Json.Quota> cl = await FS.OAuth.CreateMetadataStream <Json.Quota>(url);

            if (!cl.IsOk)
            {
                return(new FileSystemResult <FileSystemSizes>(cl.Error));
            }
            Sizes = new FileSystemSizes
            {
                AvailableSize = cl.Result.available,
                TotalSize     = cl.Result.quota,
                UsedSize      = cl.Result.quota - cl.Result.available
            };
            return(new FileSystemResult <FileSystemSizes>(Sizes));
        }
 public async Task <FileSystemResult <FileSystemSizes> > QuotaAsync()
 {
     Sizes = new FileSystemSizes();
     // ReSharper disable once PossibleInvalidCastExceptionInForeachLoop
     foreach (LocalDrive ld in IntDirectories)
     {
         try
         {
             Sizes.AvailableSize += ld.Drive.AvailableFreeSpace;
             Sizes.UsedSize      += ld.Drive.TotalSize - ld.Drive.AvailableFreeSpace;
             Sizes.TotalSize     += ld.Drive.TotalSize;
         }
         catch (Exception) //Cdrom and others
         {
             //ignored
         }
     }
     return(await Task.FromResult(new FileSystemResult <FileSystemSizes>(Sizes)));
 }
        //TODO locking?
        public override async Task <FileSystemResult <FileSystemSizes> > QuotaAsync()
        {
            Sizes = new FileSystemSizes();
            // ReSharper disable once PossibleInvalidCastExceptionInForeachLoop
            foreach (DirectoryImplementation ld in IntDirectories)
            {
                try
                {
                    FileSystemResult <FileSystemSizes> z = await ld.QuotaAsync();

                    if (z.IsOk)
                    {
                        Sizes.AvailableSize += z.Result.AvailableSize;
                        Sizes.UsedSize      += z.Result.UsedSize;
                        Sizes.TotalSize     += z.Result.TotalSize;
                    }
                }
                catch (Exception) //Cdrom and others
                {
                    //ignored
                }
            }
            return(await Task.FromResult(new FileSystemResult <FileSystemSizes>(Sizes)));
        }