< Summary

Class:Azure.Storage.Files.Shares.ShareExtensions
Assembly:Azure.Storage.Files.Shares
File(s):C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Models\CloseHandlesResult.cs
C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Models\GetSharesAsyncCollection.cs
C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Models\NtfsFileAttributes.cs
C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Sas\ShareAccountSasPermissions.cs
C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Sas\ShareFileSasPermissions.cs
C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Sas\ShareSasPermissions.cs
C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\ShareExtensions.cs
Covered lines:80
Uncovered lines:42
Coverable lines:122
Total lines:696
Line coverage:65.5% (80 of 122)
Covered branches:63
Total branches:100
Branch coverage:63% (63 of 100)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
ToCloseHandlesResult(...)-0%0%
AsIncludeItems(...)-87.5%87.5%
ToAttributesString(...)-70.83%68.18%
AppendAttribute(...)-100%100%
ToFileAttributes(...)-56.67%50%
ToPermissionsString(...)-0%0%
ToPermissionsString(...)-100%100%
ToPermissionsString(...)-100%100%
AssertValidFilePermissionAndKey(...)-100%100%
ToLease(...)-100%100%
ToFileDateTimeString(...)-100%100%
ToFileDateTimeString(...)-100%100%

File(s)

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Models\CloseHandlesResult.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4#pragma warning disable SA1402  // File may only contain a single type
 5
 6using Azure.Storage.Files.Shares.Models;
 7
 8namespace Azure.Storage.Files.Shares.Models
 9{
 10    /// <summary>
 11    /// The result of a force close handle or force close all handles operation.
 12    /// </summary>
 13    public class CloseHandlesResult
 14    {
 15        /// <summary>
 16        /// The number of file handles that were closed.
 17        /// </summary>
 18        public int ClosedHandlesCount { get; internal set; }
 19
 20        /// <summary>
 21        /// The number of file handles that fialed to close.
 22        /// </summary>
 23        public int FailedHandlesCount { get; internal set; }
 24
 25        /// <summary>
 26        /// Prevent direct instantiation of ClosedHandlesInfo instances.
 27        /// You can use FileModelFactory.ClosedHandlesInfo instead.
 28        /// </summary>
 29        internal CloseHandlesResult() { }
 30    }
 31
 32    /// <summary>
 33    /// FilesModelFactory provides utilities for mocking.
 34    /// </summary>
 35    public static partial class FileModelFactory
 36    {
 37        /// <summary>
 38        /// Creates a new ClosedHandlesInfo instance for mocking.
 39        /// </summary>
 40        public static CloseHandlesResult ClosedHandlesInfo(
 41            int closedHandlesCount)
 42            => ClosedHandlesInfo(
 43                closedHandlesCount: closedHandlesCount,
 44                failedHandlesCount: 0);
 45
 46        /// <summary>
 47        /// Creates a new ClosedHandlesInfo instance for mocking.
 48        /// </summary>
 49        public static CloseHandlesResult ClosedHandlesInfo(
 50            int closedHandlesCount,
 51            int failedHandlesCount)
 52            => new CloseHandlesResult()
 53            {
 54                ClosedHandlesCount = closedHandlesCount,
 55                FailedHandlesCount = failedHandlesCount
 56            };
 57    }
 58}
 59
 60namespace Azure.Storage.Files.Shares
 61{
 62    internal static partial class ShareExtensions
 63    {
 64        internal static CloseHandlesResult ToCloseHandlesResult(this Response<StorageClosedHandlesSegment> storageClosed
 65        {
 066            if (storageClosedHandlesSegment == null || storageClosedHandlesSegment.Value == null)
 67            {
 068                return null;
 69            }
 70
 071            return new CloseHandlesResult
 072            {
 073                ClosedHandlesCount = storageClosedHandlesSegment.Value.NumberOfHandlesClosed,
 074                FailedHandlesCount = storageClosedHandlesSegment.Value.NumberOfHandlesFailedToClose
 075            };
 76        }
 77    }
 78}

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Models\GetSharesAsyncCollection.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System.Collections.Generic;
 5using System.Linq;
 6using System.Threading;
 7using System.Threading.Tasks;
 8using Azure.Storage.Files.Shares.Models;
 9
 10#pragma warning disable SA1402  // File may only contain a single type
 11
 12namespace Azure.Storage.Files.Shares.Models
 13{
 14    internal class GetSharesAsyncCollection : StorageCollectionEnumerator<ShareItem>
 15    {
 16        private readonly ShareServiceClient _client;
 17        private readonly ShareTraits _traits;
 18        private readonly ShareStates _states;
 19        private readonly string _prefix;
 20
 21        public GetSharesAsyncCollection(
 22            ShareServiceClient client,
 23            ShareTraits traits = ShareTraits.None,
 24            ShareStates states = ShareStates.None,
 25            string prefix = default)
 26        {
 27            _client = client;
 28            _traits = traits;
 29            _states = states;
 30            _prefix = prefix;
 31        }
 32
 33        public override async ValueTask<Page<ShareItem>> GetNextPageAsync(
 34            string continuationToken,
 35            int? pageSizeHint,
 36            bool async,
 37            CancellationToken cancellationToken)
 38        {
 39            Response<SharesSegment> response = await _client.GetSharesInternal(
 40                continuationToken,
 41                _traits,
 42                _states,
 43                _prefix,
 44                pageSizeHint,
 45                async,
 46                cancellationToken).ConfigureAwait(false);
 47
 48            return Page<ShareItem>.FromValues(
 49                response.Value.ShareItems.ToArray(),
 50                response.Value.NextMarker,
 51                response.GetRawResponse());
 52        }
 53    }
 54}
 55
 56namespace Azure.Storage.Files.Shares
 57{
 58    /// <summary>
 59    /// File service helpers.
 60    /// </summary>
 61    internal static partial class ShareExtensions
 62    {
 63        /// <summary>
 64        /// Convert the details into ListSharesIncludeType values.
 65        /// </summary>
 66        /// <returns>ListSharesIncludeType values</returns>
 67        internal static IEnumerable<ListSharesIncludeType> AsIncludeItems(ShareTraits traits, ShareStates states)
 68        {
 69            // NOTE: Multiple strings MUST be appended in alphabetic order or signing the string for authentication fail
 70            // TODO: Remove this requirement by pushing it closer to header generation.
 1071            var items = new List<ListSharesIncludeType>();
 1072            if ((states & ShareStates.Deleted) == ShareStates.Deleted)
 73            {
 474                items.Add(ListSharesIncludeType.Deleted);
 75            }
 1076            if ((traits & ShareTraits.Metadata) == ShareTraits.Metadata)
 77            {
 278                items.Add(ListSharesIncludeType.Metadata);
 79            }
 1080            if ((states & ShareStates.Snapshots) == ShareStates.Snapshots)
 81            {
 082                items.Add(ListSharesIncludeType.Snapshots);
 83            }
 1084            return items.Count > 0 ? items : null;
 85        }
 86    }
 87}

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Models\NtfsFileAttributes.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Text;
 6using Azure.Storage.Files.Shares.Models;
 7
 8namespace Azure.Storage.Files.Shares.Models
 9{
 10    /// <summary>
 11    /// NTFS file attributes for Files and Directories.
 12    /// </summary>
 13    [Flags]
 14    public enum NtfsFileAttributes
 15    {
 16        /// <summary>
 17        /// The File or Directory is read-only.
 18        /// </summary>
 19        ReadOnly = 1,
 20
 21        /// <summary>
 22        /// The File or Directory is hidden, and thus is not included in an ordinary directory listing.
 23        /// </summary>
 24        Hidden = 2,
 25
 26        /// <summary>
 27        /// The File or Directory is a systemfile.  That is, the file is part of the operating system
 28        /// or is used exclusively by the operating system.
 29        /// </summary>
 30        System = 4,
 31
 32        /// <summary>
 33        /// The file  or directory is a standard file that has no special attributes. This attribute is
 34        /// valid only if it is used alone.
 35        /// </summary>
 36        None = 8,
 37
 38        /// <summary>
 39        /// The file is a directory.
 40        /// </summary>
 41        Directory = 16,
 42
 43        /// <summary>
 44        /// The file is a candidate for backup or removal.
 45        /// </summary>
 46        Archive = 32,
 47
 48        /// <summary>
 49        /// The file or directory is temporary. A temporary file contains data that is needed while an
 50        /// application is executing but is not needed after the application is finished.
 51        /// File systems try to keep all the data in memory for quicker access rather than
 52        /// flushing the data back to mass storage. A temporary file should be deleted by
 53        /// the application as soon as it is no longer needed.
 54        /// </summary>
 55        Temporary = 64,
 56
 57        /// <summary>
 58        /// The file or directory is offline. The data of the file is not immediately available.
 59        /// </summary>
 60        Offline = 128,
 61
 62        /// <summary>
 63        /// The file or directory will not be indexed by the operating system's content indexing service.
 64        /// </summary>
 65        NotContentIndexed = 256,
 66
 67        /// <summary>
 68        /// The file or directory is excluded from the data integrity scan. When this value
 69        /// is applied to a directory, by default, all new files and subdirectories within
 70        /// that directory are excluded from data integrity.
 71        /// </summary>
 72        NoScrubData = 512
 73    }
 74}
 75
 76namespace Azure.Storage.Files.Shares
 77{
 78    /// <summary>
 79    /// File enum extensions.
 80    /// </summary>
 81    internal static partial class ShareExtensions
 82    {
 83        /// <summary>
 84        /// ToString
 85        /// </summary>
 86        /// <returns>string</returns>
 87        public static string ToAttributesString(this NtfsFileAttributes attributes)
 88        {
 1289            var stringBuilder = new StringBuilder();
 90
 1291            if ((attributes & NtfsFileAttributes.ReadOnly) == NtfsFileAttributes.ReadOnly)
 92            {
 1293                AppendAttribute(nameof(NtfsFileAttributes.ReadOnly), stringBuilder);
 94            }
 1295            if ((attributes & NtfsFileAttributes.Hidden) == NtfsFileAttributes.Hidden)
 96            {
 097                AppendAttribute(nameof(NtfsFileAttributes.Hidden), stringBuilder);
 98            }
 1299            if ((attributes & NtfsFileAttributes.System) == NtfsFileAttributes.System)
 100            {
 0101                AppendAttribute(nameof(NtfsFileAttributes.System), stringBuilder);
 102            }
 12103            if ((attributes & NtfsFileAttributes.None) == NtfsFileAttributes.None)
 104            {
 0105                AppendAttribute(nameof(NtfsFileAttributes.None), stringBuilder);
 106            }
 12107            if ((attributes & NtfsFileAttributes.Directory) == NtfsFileAttributes.Directory)
 108            {
 4109                AppendAttribute(nameof(NtfsFileAttributes.Directory), stringBuilder);
 110            }
 12111            if ((attributes & NtfsFileAttributes.Archive) == NtfsFileAttributes.Archive)
 112            {
 8113                AppendAttribute(nameof(NtfsFileAttributes.Archive), stringBuilder);
 114            }
 12115            if ((attributes & NtfsFileAttributes.Temporary) == NtfsFileAttributes.Temporary)
 116            {
 0117                AppendAttribute(nameof(NtfsFileAttributes.Temporary), stringBuilder);
 118            }
 12119            if ((attributes & NtfsFileAttributes.Offline) == NtfsFileAttributes.Offline)
 120            {
 0121                AppendAttribute(nameof(NtfsFileAttributes.Offline), stringBuilder);
 122            }
 12123            if ((attributes & NtfsFileAttributes.NotContentIndexed) == NtfsFileAttributes.NotContentIndexed)
 124            {
 0125                AppendAttribute(nameof(NtfsFileAttributes.NotContentIndexed), stringBuilder);
 126            }
 12127            if ((attributes & NtfsFileAttributes.NoScrubData) == NtfsFileAttributes.NoScrubData)
 128            {
 0129                AppendAttribute(nameof(NtfsFileAttributes.NoScrubData), stringBuilder);
 130            }
 12131            if (stringBuilder[stringBuilder.Length - 1] == '|')
 132            {
 12133                stringBuilder.Remove(stringBuilder.Length - 1, 1);
 134            }
 12135            return stringBuilder.ToString();
 136        }
 137
 138        /// <summary>
 139        /// Helper method to append attribute name to stringbuilder.
 140        /// </summary>
 141        /// <param name="attributeName">name of attribute</param>
 142        /// <param name="stringBuilder">stringbuilder reference</param>
 143        private static void AppendAttribute(string attributeName, StringBuilder stringBuilder)
 144        {
 24145            stringBuilder.Append(attributeName);
 24146            stringBuilder.Append("|");
 24147        }
 148
 149        /// <summary>
 150        /// Parses a NTFS attributes string to a nullable FileNtfsAttributes.
 151        /// </summary>
 152        /// <param name="attributesString">string to parse</param>
 153        /// <returns></returns>
 154        public static NtfsFileAttributes? ToFileAttributes(string attributesString)
 155        {
 780156            if (attributesString == null)
 157            {
 7158                return null;
 159            }
 773160            var splitString = attributesString.Split('|');
 161
 773162            if (splitString.Length == 0)
 163            {
 0164                throw Errors.InvalidArgument(attributesString);
 165            }
 166
 773167            NtfsFileAttributes attributes = default;
 3140168            foreach (var s in splitString)
 169            {
 797170                var trimmed = s.Trim();
 171
 797172                if (trimmed.Equals(nameof(NtfsFileAttributes.ReadOnly), StringComparison.InvariantCultureIgnoreCase))
 173                {
 24174                    attributes |= NtfsFileAttributes.ReadOnly;
 175                }
 773176                else if (trimmed.Equals(nameof(NtfsFileAttributes.Hidden), StringComparison.InvariantCultureIgnoreCase))
 177                {
 0178                    attributes |= NtfsFileAttributes.Hidden;
 179                }
 773180                else if (trimmed.Equals(nameof(NtfsFileAttributes.System), StringComparison.InvariantCultureIgnoreCase))
 181                {
 0182                    attributes |= NtfsFileAttributes.System;
 183                }
 773184                else if (trimmed.Equals(nameof(NtfsFileAttributes.None), StringComparison.InvariantCultureIgnoreCase))
 185                {
 0186                    attributes |= NtfsFileAttributes.None;
 187                }
 773188                else if (trimmed.Equals(nameof(NtfsFileAttributes.Directory), StringComparison.InvariantCultureIgnoreCas
 189                {
 381190                    attributes |= NtfsFileAttributes.Directory;
 191                }
 392192                else if (trimmed.Equals(nameof(NtfsFileAttributes.Archive), StringComparison.InvariantCultureIgnoreCase)
 193                {
 392194                    attributes |= NtfsFileAttributes.Archive;
 195                }
 0196                else if (trimmed.Equals(nameof(NtfsFileAttributes.Temporary), StringComparison.InvariantCultureIgnoreCas
 197                {
 0198                    attributes |= NtfsFileAttributes.Temporary;
 199                }
 0200                else if (trimmed.Equals(nameof(NtfsFileAttributes.Offline), StringComparison.InvariantCultureIgnoreCase)
 201                {
 0202                    attributes |= NtfsFileAttributes.Offline;
 203                }
 0204                else if (trimmed.Equals(nameof(NtfsFileAttributes.NotContentIndexed), StringComparison.InvariantCultureI
 205                {
 0206                    attributes |= NtfsFileAttributes.NotContentIndexed;
 207                }
 0208                else if (trimmed.Equals(nameof(NtfsFileAttributes.NoScrubData), StringComparison.InvariantCultureIgnoreC
 209                {
 0210                    attributes |= NtfsFileAttributes.NoScrubData;
 211                }
 212                else
 213                {
 0214                    throw Errors.InvalidArgument(trimmed);
 215                }
 216            }
 773217            return attributes;
 218        }
 219    }
 220}

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Sas\ShareAccountSasPermissions.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Text;
 6using Azure.Storage.Sas;
 7
 8namespace Azure.Storage.Sas
 9{
 10    /// <summary>
 11    /// <see cref="ShareAccountSasPermissions"/> contains the list of
 12    /// permissions that can be set for a file account's access policy.  Use
 13    /// <see cref="ShareSasBuilder.SetPermissions(ShareAccountSasPermissions)"/>
 14    /// to set the permissions on the <see cref="ShareSasBuilder"/>.
 15    /// </summary>
 16    [Flags]
 17    public enum ShareAccountSasPermissions
 18    {
 19        /// <summary>
 20        /// Indicates that Read is permitted.
 21        /// </summary>
 22        Read = 1,
 23
 24        /// <summary>
 25        /// Indicates that Add is permitted.
 26        /// </summary>
 27        Add = 2,
 28
 29        /// <summary>
 30        /// Indicates that Create is permitted.
 31        /// </summary>
 32        Create = 4,
 33
 34        /// <summary>
 35        /// Indicates that Write is permitted.
 36        /// </summary>
 37        Write = 8,
 38
 39        /// <summary>
 40        /// Indicates that Delete is permitted.
 41        /// </summary>
 42        Delete = 16,
 43
 44        /// <summary>
 45        /// Indicates that List is permitted.
 46        /// </summary>
 47        List = 32,
 48
 49        /// <summary>
 50        /// Indicates that all permissions are set.
 51        /// </summary>
 52        All = ~0
 53    }
 54}
 55
 56namespace Azure.Storage.Files.Shares
 57{
 58    /// <summary>
 59    /// File enum extensions.
 60    /// </summary>
 61    internal static partial class ShareExtensions
 62    {
 63
 64        /// <summary>
 65        /// Create a permissions string to provide
 66        /// <see cref="ShareSasBuilder.Permissions"/>.
 67        /// </summary>
 68        /// <returns>A permissions string.</returns>
 69        internal static string ToPermissionsString(this ShareAccountSasPermissions permissions)
 70        {
 071            var sb = new StringBuilder();
 072            if ((permissions & ShareAccountSasPermissions.Read) == ShareAccountSasPermissions.Read)
 73            {
 074                sb.Append(Constants.Sas.Permissions.Read);
 75            }
 076            if ((permissions & ShareAccountSasPermissions.Add) == ShareAccountSasPermissions.Add)
 77            {
 078                sb.Append(Constants.Sas.Permissions.Add);
 79            }
 080            if ((permissions & ShareAccountSasPermissions.Create) == ShareAccountSasPermissions.Create)
 81            {
 082                sb.Append(Constants.Sas.Permissions.Create);
 83            }
 084            if ((permissions & ShareAccountSasPermissions.Write) == ShareAccountSasPermissions.Write)
 85            {
 086                sb.Append(Constants.Sas.Permissions.Write);
 87            }
 088            if ((permissions & ShareAccountSasPermissions.Delete) == ShareAccountSasPermissions.Delete)
 89            {
 090                sb.Append(Constants.Sas.Permissions.Delete);
 91            }
 092            if ((permissions & ShareAccountSasPermissions.List) == ShareAccountSasPermissions.List)
 93            {
 094                sb.Append(Constants.Sas.Permissions.List);
 95            }
 096            return sb.ToString();
 97        }
 98    }
 99}

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Sas\ShareFileSasPermissions.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Text;
 6using Azure.Storage.Sas;
 7
 8namespace Azure.Storage.Sas
 9{
 10    /// <summary>
 11    /// <see cref="ShareFileSasPermissions"/> contains the list of
 12    /// permissions that can be set for a file's access policy.  Use
 13    /// <see cref="ShareSasBuilder.SetPermissions(ShareFileSasPermissions)"/>
 14    /// to set the permissions on the <see cref="ShareSasBuilder"/>.
 15    /// </summary>
 16    [Flags]
 17    public enum ShareFileSasPermissions
 18    {
 19        /// <summary>
 20        /// Indicates that Read is permitted.
 21        /// </summary>
 22        Read = 1,
 23
 24        /// <summary>
 25        /// Indicates that Create is permitted.
 26        /// </summary>
 27        Create = 2,
 28
 29        /// <summary>
 30        /// Indicates that Write is permitted.
 31        /// </summary>
 32        Write = 4,
 33
 34        /// <summary>
 35        /// Indicates that Delete is permitted.
 36        /// </summary>
 37        Delete = 8,
 38
 39        /// <summary>
 40        /// Indicates that all permissions are set.
 41        /// </summary>
 42        All = ~0
 43    }
 44}
 45
 46namespace Azure.Storage.Files.Shares
 47{
 48    /// <summary>
 49    /// File enum extensions.
 50    /// </summary>
 51    internal static partial class ShareExtensions
 52    {
 53
 54        /// <summary>
 55        /// Create a permissions string to provide
 56        /// <see cref="ShareSasBuilder.Permissions"/>.
 57        /// </summary>
 58        /// <returns>A permissions string.</returns>
 59        internal static string ToPermissionsString(this ShareFileSasPermissions permissions)
 60        {
 2661            var sb = new StringBuilder();
 2662            if ((permissions & ShareFileSasPermissions.Read) == ShareFileSasPermissions.Read)
 63            {
 2664                sb.Append(Constants.Sas.Permissions.Read);
 65            }
 2666            if ((permissions & ShareFileSasPermissions.Create) == ShareFileSasPermissions.Create)
 67            {
 2468                sb.Append(Constants.Sas.Permissions.Create);
 69            }
 2670            if ((permissions & ShareFileSasPermissions.Write) == ShareFileSasPermissions.Write)
 71            {
 2472                sb.Append(Constants.Sas.Permissions.Write);
 73            }
 2674            if ((permissions & ShareFileSasPermissions.Delete) == ShareFileSasPermissions.Delete)
 75            {
 2476                sb.Append(Constants.Sas.Permissions.Delete);
 77            }
 2678            return sb.ToString();
 79        }
 80    }
 81}

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\Sas\ShareSasPermissions.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Text;
 6using Azure.Storage.Sas;
 7
 8namespace Azure.Storage.Sas
 9{
 10    /// <summary>
 11    /// <see cref="ShareSasPermissions"/> contains the list of
 12    /// permissions that can be set for a file's access policy.  Use
 13    /// <see cref="ShareSasBuilder.SetPermissions(ShareSasPermissions)"/>
 14    /// to set the permissions on the <see cref="ShareSasBuilder"/>.
 15    /// </summary>
 16    [Flags]
 17    public enum ShareSasPermissions
 18    {
 19        /// <summary>
 20        /// Indicates that Read is permitted.
 21        /// </summary>
 22        Read = 1,
 23
 24        /// <summary>
 25        /// Indicates that Create is permitted.
 26        /// </summary>
 27        Create = 2,
 28
 29        /// <summary>
 30        /// Indicates that Write is permitted.
 31        /// </summary>
 32        Write = 4,
 33
 34        /// <summary>
 35        /// Indicates that Delete is permitted.
 36        /// </summary>
 37        Delete = 8,
 38
 39        /// <summary>
 40        /// Indicates that List is permitted.
 41        /// </summary>
 42        List = 16,
 43
 44        /// <summary>
 45        /// Indicates that all permissions are set.
 46        /// </summary>
 47        All = ~0
 48    }
 49}
 50
 51namespace Azure.Storage.Files.Shares
 52{
 53    /// <summary>
 54    /// File enum extensions.
 55    /// </summary>
 56    internal static partial class ShareExtensions
 57    {
 58
 59        /// <summary>
 60        /// Create a permissions string to provide
 61        /// <see cref="ShareSasBuilder.Permissions"/>.
 62        /// </summary>
 63        /// <returns>A permissions string.</returns>
 64        internal static string ToPermissionsString(this ShareSasPermissions permissions)
 65        {
 466            var sb = new StringBuilder();
 467            if ((permissions & ShareSasPermissions.Read) == ShareSasPermissions.Read)
 68            {
 469                sb.Append(Constants.Sas.Permissions.Read);
 70            }
 471            if ((permissions & ShareSasPermissions.Create) == ShareSasPermissions.Create)
 72            {
 473                sb.Append(Constants.Sas.Permissions.Create);
 74            }
 475            if ((permissions & ShareSasPermissions.Write) == ShareSasPermissions.Write)
 76            {
 477                sb.Append(Constants.Sas.Permissions.Write);
 78            }
 479            if ((permissions & ShareSasPermissions.Delete) == ShareSasPermissions.Delete)
 80            {
 481                sb.Append(Constants.Sas.Permissions.Delete);
 82            }
 483            if ((permissions & ShareSasPermissions.List) == ShareSasPermissions.List)
 84            {
 485                sb.Append(Constants.Sas.Permissions.List);
 86            }
 487            return sb.ToString();
 88        }
 89    }
 90}

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.Shares\src\ShareExtensions.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Globalization;
 6using System.Text;
 7using Azure.Storage.Files.Shares.Models;
 8
 9namespace Azure.Storage.Files.Shares
 10{
 11    internal static partial class ShareExtensions
 12    {
 13        internal static void AssertValidFilePermissionAndKey(string filePermission, string filePermissionKey)
 14        {
 61715            if (filePermission != null && filePermissionKey != null)
 16            {
 817                throw Errors.CannotBothBeNotNull(nameof(filePermission), nameof(filePermissionKey));
 18            }
 19
 60920            if (filePermission != null && Encoding.UTF8.GetByteCount(filePermission) > Constants.File.MaxFilePermissionH
 21            {
 822                throw Errors.MustBeLessThanOrEqualTo(nameof(filePermission), Constants.File.MaxFilePermissionHeaderSize)
 23            }
 60124        }
 25
 26        internal static Response<ShareFileLease> ToLease(this Response<BrokenLease> response)
 227            => Response.FromValue(
 228                new ShareFileLease
 229                {
 230                    ETag = response.Value.ETag,
 231                    LastModified = response.Value.LastModified,
 232                    LeaseId = response.Value.LeaseId
 233                }, response.GetRawResponse());
 34
 35        internal static string ToFileDateTimeString(this DateTimeOffset? dateTimeOffset)
 121036            => dateTimeOffset.HasValue ? ToFileDateTimeString(dateTimeOffset.Value) : null;
 37
 38        private static string ToFileDateTimeString(this DateTimeOffset dateTimeOffset)
 2439            => dateTimeOffset.UtcDateTime.ToString(Constants.File.FileTimeFormat, CultureInfo.InvariantCulture);
 40    }
 41}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:09 PM
GitHub | www.palmmedia.de

Methods/Properties

ToCloseHandlesResult(...)
AsIncludeItems(...)
ToAttributesString(...)
AppendAttribute(...)
ToFileAttributes(...)
ToPermissionsString(...)
ToPermissionsString(...)
ToPermissionsString(...)
AssertValidFilePermissionAndKey(...)
ToLease(...)
ToFileDateTimeString(...)
ToFileDateTimeString(...)