Merge pull request #16 from yifanz0/yifan/track2.1

yifanz0 · web-flow · commit 5ef71ae7fd46 · 2022-06-20T11:31:27.000+08:00
Migrate network rule related cmdlets to Track2 SDK
diff --git a/src/Storage/Storage.Management/Models/PSNetworkRule.cs b/src/Storage/Storage.Management/Models/PSNetworkRule.cs
@@ -12,7 +12,6 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
-using Microsoft.Azure.Management.Storage.Models;
 using System;
 using System.Collections.Generic;
 using Microsoft.WindowsAzure.Commands.Common.Attributes;
diff --git a/src/Storage/Storage.Management/Storage.Management.csproj b/src/Storage/Storage.Management/Storage.Management.csproj
@@ -18,11 +18,7 @@
     <Compile Remove="File\GetAzStorageFileServiceProperty.cs" />
     <Compile Remove="File\UpdateAzAzStorageFileServiceProperty.cs" />
     <Compile Remove="Models\PSFileServiceProperties.cs" />
-    <Compile Remove="StorageAccount\AddAzureStorageAccountNetworkRule.cs" />
-    <Compile Remove="StorageAccount\GetAzureStorageAccountNetworkRuleSet.cs" />
     <Compile Remove="StorageAccount\InvokeAzureStorageAccountHierarchicalNamespaceUpgrade.cs" />
-    <Compile Remove="StorageAccount\RemoveAzureStorageAccountNetworkRule.cs" />
-    <Compile Remove="StorageAccount\UpdateAzureStorageAccountNetworkRuleSet.cs" />
     <Compile Remove="StorageAccount\InvokeAzureStorageAccountFailover.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Storage/Storage.Management/StorageAccount/AddAzureStorageAccountNetworkRule.cs b/src/Storage/Storage.Management/StorageAccount/AddAzureStorageAccountNetworkRule.cs
@@ -12,15 +12,14 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
-using System.Collections;
-using System.Management.Automation;
-using Microsoft.Azure.Commands.ResourceManager.Common.Tags;
-using Microsoft.Azure.Management.Storage;
-using Microsoft.Azure.Management.Storage.Models;
-using StorageModels = Microsoft.Azure.Management.Storage.Models;
 using Microsoft.Azure.Commands.Management.Storage.Models;
-using System.Collections.Generic;
 using Microsoft.Azure.Commands.ResourceManager.Common.ArgumentCompleters;
+using Microsoft.Azure.Commands.ResourceManager.Common.Tags;
+using System.Collections;
+using System.Collections.Generic;
+using System.Management.Automation;
+using Track2 = Azure.ResourceManager.Storage;
+using Track2Models = Azure.ResourceManager.Storage.Models;
 
 namespace Microsoft.Azure.Commands.Management.Storage
 {
@@ -132,26 +131,23 @@ public override void ExecuteCmdlet()
 
             if (ShouldProcess(this.Name, "Add Storage Account NetworkRules"))
             {
-                var storageAccount = this.StorageClient.StorageAccounts.GetProperties(
-                this.ResourceGroupName,
-                this.Name);
-                NetworkRuleSet storageACL = storageAccount.NetworkRuleSet;
+                Track2.StorageAccountResource storageAccount = this.StorageClientTrack2
+                    .GetStorageAccount(this.ResourceGroupName, this.Name).Get();
+                Track2Models.NetworkRuleSet storageACL = storageAccount.Data.NetworkRuleSet;
 
                 if (storageACL == null)
                 {
-                    storageACL = new NetworkRuleSet();
+                    storageACL = new Track2Models.NetworkRuleSet(Track2Models.DefaultAction.Allow);
                 }
                 bool ruleChanged = false;
 
                 switch (ParameterSetName)
                 {
                     case NetWorkRuleStringParameterSet:
-                        if (storageACL.VirtualNetworkRules == null)
-                            storageACL.VirtualNetworkRules = new List<VirtualNetworkRule>();
                         foreach (string s in VirtualNetworkResourceId)
                         {
                             bool ruleExist = false;
-                            foreach (VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)
+                            foreach (Track2Models.VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)
                             {
                                 if (originRule.VirtualNetworkResourceId.Equals(s, System.StringComparison.InvariantCultureIgnoreCase))
                                 {
@@ -162,19 +158,17 @@ public override void ExecuteCmdlet()
                             }
                             if (!ruleExist)
                             {
-                                VirtualNetworkRule rule = new VirtualNetworkRule(s);
+                                Track2Models.VirtualNetworkRule rule = new Track2Models.VirtualNetworkRule(s);
                                 storageACL.VirtualNetworkRules.Add(rule);
                                 ruleChanged = true;
                             }
                         }
                         break;
                     case IpRuleStringParameterSet:
-                        if (storageACL.IpRules == null)
-                            storageACL.IpRules = new List<IPRule>();
                         foreach (string s in IPAddressOrRange)
                         {
                             bool ruleExist = false;
-                            foreach (IPRule originRule in storageACL.IpRules)
+                            foreach (Track2Models.IPRule originRule in storageACL.IPRules)
                             {
                                 if (originRule.IPAddressOrRange.Equals(s, System.StringComparison.InvariantCultureIgnoreCase))
                                 {
@@ -185,19 +179,15 @@ public override void ExecuteCmdlet()
                             }
                             if (!ruleExist)
                             {
-                                IPRule rule = new IPRule(s);
-                                storageACL.IpRules.Add(rule);
+                                Track2Models.IPRule rule = new Track2Models.IPRule(s);
+                                storageACL.IPRules.Add(rule);
                                 ruleChanged = true;
                             }
                         }
                         break;
                     case ResourceAccessRuleStringParameterSet:
-                        if (storageACL.ResourceAccessRules == null)
-                        {
-                            storageACL.ResourceAccessRules = new List<ResourceAccessRule>();
-                        }
                         bool ResourceAccessruleExist = false;
-                        foreach (ResourceAccessRule originRule in storageACL.ResourceAccessRules)
+                        foreach (Track2Models.ResourceAccessRule originRule in storageACL.ResourceAccessRules)
                         {
                             if (originRule.TenantId.Equals(this.TenantId, System.StringComparison.InvariantCultureIgnoreCase)
                             && originRule.ResourceId.Equals(this.ResourceId, System.StringComparison.InvariantCultureIgnoreCase))
@@ -209,18 +199,19 @@ public override void ExecuteCmdlet()
                         }
                         if (!ResourceAccessruleExist)
                         {
-                            ResourceAccessRule rule = new ResourceAccessRule(this.TenantId, this.ResourceId);
+                            Track2Models.ResourceAccessRule rule = new Track2Models.ResourceAccessRule{
+                                TenantId = this.TenantId,
+                                ResourceId = this.ResourceId,
+                            };
                             storageACL.ResourceAccessRules.Add(rule);
                             ruleChanged = true;
                         }
                         break;
                     case NetworkRuleObjectParameterSet:
-                        if (storageACL.VirtualNetworkRules == null)
-                            storageACL.VirtualNetworkRules = new List<VirtualNetworkRule>();
                         foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
                         {
                             bool ruleExist = false;
-                            foreach (VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)
+                            foreach (Track2Models.VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)
                             {
                                 if (originRule.VirtualNetworkResourceId.Equals(rule.VirtualNetworkResourceId, System.StringComparison.InvariantCultureIgnoreCase))
                                 {
@@ -237,14 +228,10 @@ public override void ExecuteCmdlet()
                         }
                         break;
                     case ResourceAccessRuleObjectParameterSet:
-                        if (storageACL.ResourceAccessRules == null)
-                        {
-                            storageACL.ResourceAccessRules = new List<ResourceAccessRule>();
-                        }
                         foreach (PSResourceAccessRule rule in ResourceAccessRule)
                         {
                             bool ruleExist = false;
-                            foreach (ResourceAccessRule originRule in storageACL.ResourceAccessRules)
+                            foreach (Track2Models.ResourceAccessRule originRule in storageACL.ResourceAccessRules)
                             {
                                 if (originRule.TenantId.Equals(rule.TenantId, System.StringComparison.InvariantCultureIgnoreCase)
                                 && originRule.ResourceId.Equals(rule.ResourceId, System.StringComparison.InvariantCultureIgnoreCase))
@@ -263,12 +250,10 @@ public override void ExecuteCmdlet()
                         }
                         break;
                     case IpRuleObjectParameterSet:
-                        if (storageACL.IpRules == null)
-                            storageACL.IpRules = new List<IPRule>();
                         foreach (PSIpRule rule in IPRule)
                         {
                             bool ruleExist = false;
-                            foreach (IPRule originRule in storageACL.IpRules)
+                            foreach (Track2Models.IPRule originRule in storageACL.IPRules)
                             {
                                 if (originRule.IPAddressOrRange.Equals(rule.IPAddressOrRange, System.StringComparison.InvariantCultureIgnoreCase))
                                 {
@@ -279,8 +264,7 @@ public override void ExecuteCmdlet()
                             }
                             if (!ruleExist)
                             {
-
-                                storageACL.IpRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleIPRule(rule));
+                                storageACL.IPRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleIPRule(rule));
                                 ruleChanged = true;
                             }
                         }
@@ -289,30 +273,31 @@ public override void ExecuteCmdlet()
 
                 if (ruleChanged)
                 {
-                    StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
-                    updateParameters.NetworkRuleSet = storageACL;
+                    Track2Models.StorageAccountPatch patch = new Track2Models.StorageAccountPatch();
+                    patch.NetworkRuleSet = storageACL;
 
-                    var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
-                        this.ResourceGroupName,
-                        this.Name,
-                        updateParameters);
+                    Track2.StorageAccountResource updatedStorageAccount = this.StorageClientTrack2
+                        .GetStorageAccount(this.ResourceGroupName, this.Name)
+                        .Update(patch);
 
-                    storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
+                    storageAccount = this.StorageClientTrack2
+                        .GetStorageAccount(this.ResourceGroupName, this.Name)
+                        .Get();
                 }
 
                 switch (ParameterSetName)
                 {
                     case NetWorkRuleStringParameterSet:
                     case NetworkRuleObjectParameterSet:
-                        WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).VirtualNetworkRules);
+                        WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.Data.NetworkRuleSet).VirtualNetworkRules);
                         break;
                     case IpRuleStringParameterSet:
                     case IpRuleObjectParameterSet:
-                        WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).IpRules);
+                        WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.Data.NetworkRuleSet).IpRules);
                         break;
                     case ResourceAccessRuleStringParameterSet:
                     case ResourceAccessRuleObjectParameterSet:
-                        WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).ResourceAccessRules);
+                        WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.Data.NetworkRuleSet).ResourceAccessRules);
                         break;
                 }
             }
diff --git a/src/Storage/Storage.Management/StorageAccount/GetAzureStorageAccountNetworkRuleSet.cs b/src/Storage/Storage.Management/StorageAccount/GetAzureStorageAccountNetworkRuleSet.cs
@@ -12,15 +12,15 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
+using Microsoft.Azure.Commands.Management.Storage.Models;
+using Microsoft.Azure.Commands.ResourceManager.Common.ArgumentCompleters;
+using Microsoft.Azure.Commands.ResourceManager.Common.Tags;
 using System.Collections;
+using System.Collections.Generic;
 using System.Management.Automation;
-using Microsoft.Azure.Commands.ResourceManager.Common.Tags;
-using Microsoft.Azure.Management.Storage;
-using Microsoft.Azure.Management.Storage.Models;
 using StorageModels = Microsoft.Azure.Management.Storage.Models;
-using Microsoft.Azure.Commands.Management.Storage.Models;
-using System.Collections.Generic;
-using Microsoft.Azure.Commands.ResourceManager.Common.ArgumentCompleters;
+using Track2 = Azure.ResourceManager.Storage;
+using Track2Models = Azure.ResourceManager.Storage.Models;
 
 namespace Microsoft.Azure.Commands.Management.Storage
 {
@@ -49,12 +49,12 @@ public override void ExecuteCmdlet()
         {
             base.ExecuteCmdlet();
 
-            var storageAccount = this.StorageClient.StorageAccounts.GetProperties(
-                this.ResourceGroupName,
-                this.Name);
-            if (storageAccount.NetworkRuleSet != null)
+            Track2.StorageAccountResource account = this.StorageClientTrack2.GetStorageAccount(this.ResourceGroupName, this.Name)
+                .Get();
+
+            if (account.Data.NetworkRuleSet != null)
             {
-                WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet));
+                WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(account.Data.NetworkRuleSet));
             }
         }
     }
diff --git a/src/Storage/Storage.Management/StorageAccount/RemoveAzureStorageAccountNetworkRule.cs b/src/Storage/Storage.Management/StorageAccount/RemoveAzureStorageAccountNetworkRule.cs
diff --git a/src/Storage/Storage.Management/StorageAccount/UpdateAzureStorageAccountNetworkRuleSet.cs b/src/Storage/Storage.Management/StorageAccount/UpdateAzureStorageAccountNetworkRuleSet.cs

Original file line number	Diff line number	Diff line change
`@@ -12,15 +12,14 @@`
`12`	`12`	`// limitations under the License.`
`13`	`13`	`// ----------------------------------------------------------------------------------`
`14`	`14`
`15`		`-using System.Collections;`
`16`		`-using System.Management.Automation;`
`17`		`-using Microsoft.Azure.Commands.ResourceManager.Common.Tags;`
`18`		`-using Microsoft.Azure.Management.Storage;`
`19`		`-using Microsoft.Azure.Management.Storage.Models;`
`20`		`-using StorageModels = Microsoft.Azure.Management.Storage.Models;`
`21`	`15`	`using Microsoft.Azure.Commands.Management.Storage.Models;`
`22`		`-using System.Collections.Generic;`
`23`	`16`	`using Microsoft.Azure.Commands.ResourceManager.Common.ArgumentCompleters;`
	`17`	`+using Microsoft.Azure.Commands.ResourceManager.Common.Tags;`
	`18`	`+using System.Collections;`
	`19`	`+using System.Collections.Generic;`
	`20`	`+using System.Management.Automation;`
	`21`	`+using Track2 = Azure.ResourceManager.Storage;`
	`22`	`+using Track2Models = Azure.ResourceManager.Storage.Models;`
`24`	`23`
`25`	`24`	`namespace Microsoft.Azure.Commands.Management.Storage`
`26`	`25`	`{`
`@@ -132,26 +131,23 @@ public override void ExecuteCmdlet()`
`132`	`131`
`133`	`132`	`if (ShouldProcess(this.Name, "Add Storage Account NetworkRules"))`
`134`	`133`	`{`
`135`		`- var storageAccount = this.StorageClient.StorageAccounts.GetProperties(`
`136`		`- this.ResourceGroupName,`
`137`		`- this.Name);`
`138`		`- NetworkRuleSet storageACL = storageAccount.NetworkRuleSet;`
	`134`	`+ Track2.StorageAccountResource storageAccount = this.StorageClientTrack2`
	`135`	`+ .GetStorageAccount(this.ResourceGroupName, this.Name).Get();`
	`136`	`+ Track2Models.NetworkRuleSet storageACL = storageAccount.Data.NetworkRuleSet;`
`139`	`137`
`140`	`138`	`if (storageACL == null)`
`141`	`139`	`{`
`142`		`- storageACL = new NetworkRuleSet();`
	`140`	`+ storageACL = new Track2Models.NetworkRuleSet(Track2Models.DefaultAction.Allow);`
`143`	`141`	`}`
`144`	`142`	`bool ruleChanged = false;`
`145`	`143`
`146`	`144`	`switch (ParameterSetName)`
`147`	`145`	`{`
`148`	`146`	`case NetWorkRuleStringParameterSet:`
`149`		`- if (storageACL.VirtualNetworkRules == null)`
`150`		`- storageACL.VirtualNetworkRules = new List<VirtualNetworkRule>();`
`151`	`147`	`foreach (string s in VirtualNetworkResourceId)`
`152`	`148`	`{`
`153`	`149`	`bool ruleExist = false;`
`154`		`- foreach (VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)`
	`150`	`+ foreach (Track2Models.VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)`
`155`	`151`	`{`
`156`	`152`	`if (originRule.VirtualNetworkResourceId.Equals(s, System.StringComparison.InvariantCultureIgnoreCase))`
`157`	`153`	`{`
`@@ -162,19 +158,17 @@ public override void ExecuteCmdlet()`
`162`	`158`	`}`
`163`	`159`	`if (!ruleExist)`
`164`	`160`	`{`
`165`		`- VirtualNetworkRule rule = new VirtualNetworkRule(s);`
	`161`	`+ Track2Models.VirtualNetworkRule rule = new Track2Models.VirtualNetworkRule(s);`
`166`	`162`	`storageACL.VirtualNetworkRules.Add(rule);`
`167`	`163`	`ruleChanged = true;`
`168`	`164`	`}`
`169`	`165`	`}`
`170`	`166`	`break;`
`171`	`167`	`case IpRuleStringParameterSet:`
`172`		`- if (storageACL.IpRules == null)`
`173`		`- storageACL.IpRules = new List<IPRule>();`
`174`	`168`	`foreach (string s in IPAddressOrRange)`
`175`	`169`	`{`
`176`	`170`	`bool ruleExist = false;`
`177`		`- foreach (IPRule originRule in storageACL.IpRules)`
	`171`	`+ foreach (Track2Models.IPRule originRule in storageACL.IPRules)`
`178`	`172`	`{`
`179`	`173`	`if (originRule.IPAddressOrRange.Equals(s, System.StringComparison.InvariantCultureIgnoreCase))`
`180`	`174`	`{`
`@@ -185,19 +179,15 @@ public override void ExecuteCmdlet()`
`185`	`179`	`}`
`186`	`180`	`if (!ruleExist)`
`187`	`181`	`{`
`188`		`- IPRule rule = new IPRule(s);`
`189`		`- storageACL.IpRules.Add(rule);`
	`182`	`+ Track2Models.IPRule rule = new Track2Models.IPRule(s);`
	`183`	`+ storageACL.IPRules.Add(rule);`
`190`	`184`	`ruleChanged = true;`
`191`	`185`	`}`
`192`	`186`	`}`
`193`	`187`	`break;`
`194`	`188`	`case ResourceAccessRuleStringParameterSet:`
`195`		`- if (storageACL.ResourceAccessRules == null)`
`196`		`- {`
`197`		`- storageACL.ResourceAccessRules = new List<ResourceAccessRule>();`
`198`		`- }`
`199`	`189`	`bool ResourceAccessruleExist = false;`
`200`		`- foreach (ResourceAccessRule originRule in storageACL.ResourceAccessRules)`
	`190`	`+ foreach (Track2Models.ResourceAccessRule originRule in storageACL.ResourceAccessRules)`
`201`	`191`	`{`
`202`	`192`	`if (originRule.TenantId.Equals(this.TenantId, System.StringComparison.InvariantCultureIgnoreCase)`
`203`	`193`	`&& originRule.ResourceId.Equals(this.ResourceId, System.StringComparison.InvariantCultureIgnoreCase))`
`@@ -209,18 +199,19 @@ public override void ExecuteCmdlet()`
`209`	`199`	`}`
`210`	`200`	`if (!ResourceAccessruleExist)`
`211`	`201`	`{`
`212`		`- ResourceAccessRule rule = new ResourceAccessRule(this.TenantId, this.ResourceId);`
	`202`	`+ Track2Models.ResourceAccessRule rule = new Track2Models.ResourceAccessRule{`
	`203`	`+ TenantId = this.TenantId,`
	`204`	`+ ResourceId = this.ResourceId,`
	`205`	`+ };`
`213`	`206`	`storageACL.ResourceAccessRules.Add(rule);`
`214`	`207`	`ruleChanged = true;`
`215`	`208`	`}`
`216`	`209`	`break;`
`217`	`210`	`case NetworkRuleObjectParameterSet:`
`218`		`- if (storageACL.VirtualNetworkRules == null)`
`219`		`- storageACL.VirtualNetworkRules = new List<VirtualNetworkRule>();`
`220`	`211`	`foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)`
`221`	`212`	`{`
`222`	`213`	`bool ruleExist = false;`
`223`		`- foreach (VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)`
	`214`	`+ foreach (Track2Models.VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)`
`224`	`215`	`{`
`225`	`216`	`if (originRule.VirtualNetworkResourceId.Equals(rule.VirtualNetworkResourceId, System.StringComparison.InvariantCultureIgnoreCase))`
`226`	`217`	`{`
`@@ -237,14 +228,10 @@ public override void ExecuteCmdlet()`
`237`	`228`	`}`
`238`	`229`	`break;`
`239`	`230`	`case ResourceAccessRuleObjectParameterSet:`
`240`		`- if (storageACL.ResourceAccessRules == null)`
`241`		`- {`
`242`		`- storageACL.ResourceAccessRules = new List<ResourceAccessRule>();`
`243`		`- }`
`244`	`231`	`foreach (PSResourceAccessRule rule in ResourceAccessRule)`
`245`	`232`	`{`
`246`	`233`	`bool ruleExist = false;`
`247`		`- foreach (ResourceAccessRule originRule in storageACL.ResourceAccessRules)`
	`234`	`+ foreach (Track2Models.ResourceAccessRule originRule in storageACL.ResourceAccessRules)`
`248`	`235`	`{`
`249`	`236`	`if (originRule.TenantId.Equals(rule.TenantId, System.StringComparison.InvariantCultureIgnoreCase)`
`250`	`237`	`&& originRule.ResourceId.Equals(rule.ResourceId, System.StringComparison.InvariantCultureIgnoreCase))`
`@@ -263,12 +250,10 @@ public override void ExecuteCmdlet()`
`263`	`250`	`}`
`264`	`251`	`break;`
`265`	`252`	`case IpRuleObjectParameterSet:`
`266`		`- if (storageACL.IpRules == null)`
`267`		`- storageACL.IpRules = new List<IPRule>();`
`268`	`253`	`foreach (PSIpRule rule in IPRule)`
`269`	`254`	`{`
`270`	`255`	`bool ruleExist = false;`
`271`		`- foreach (IPRule originRule in storageACL.IpRules)`
	`256`	`+ foreach (Track2Models.IPRule originRule in storageACL.IPRules)`
`272`	`257`	`{`
`273`	`258`	`if (originRule.IPAddressOrRange.Equals(rule.IPAddressOrRange, System.StringComparison.InvariantCultureIgnoreCase))`
`274`	`259`	`{`
`@@ -279,8 +264,7 @@ public override void ExecuteCmdlet()`
`279`	`264`	`}`
`280`	`265`	`if (!ruleExist)`
`281`	`266`	`{`
`282`		`-`
`283`		`- storageACL.IpRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleIPRule(rule));`
	`267`	`+ storageACL.IPRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleIPRule(rule));`
`284`	`268`	`ruleChanged = true;`
`285`	`269`	`}`
`286`	`270`	`}`
`@@ -289,30 +273,31 @@ public override void ExecuteCmdlet()`
`289`	`273`
`290`	`274`	`if (ruleChanged)`
`291`	`275`	`{`
`292`		`- StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();`
`293`		`- updateParameters.NetworkRuleSet = storageACL;`
	`276`	`+ Track2Models.StorageAccountPatch patch = new Track2Models.StorageAccountPatch();`
	`277`	`+ patch.NetworkRuleSet = storageACL;`
`294`	`278`
`295`		`- var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(`
`296`		`- this.ResourceGroupName,`
`297`		`- this.Name,`
`298`		`- updateParameters);`
	`279`	`+ Track2.StorageAccountResource updatedStorageAccount = this.StorageClientTrack2`
	`280`	`+ .GetStorageAccount(this.ResourceGroupName, this.Name)`
	`281`	`+ .Update(patch);`
`299`	`282`
`300`		`- storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);`
	`283`	`+ storageAccount = this.StorageClientTrack2`
	`284`	`+ .GetStorageAccount(this.ResourceGroupName, this.Name)`
	`285`	`+ .Get();`
`301`	`286`	`}`
`302`	`287`
`303`	`288`	`switch (ParameterSetName)`
`304`	`289`	`{`
`305`	`290`	`case NetWorkRuleStringParameterSet:`
`306`	`291`	`case NetworkRuleObjectParameterSet:`
`307`		`- WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).VirtualNetworkRules);`
	`292`	`+ WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.Data.NetworkRuleSet).VirtualNetworkRules);`
`308`	`293`	`break;`
`309`	`294`	`case IpRuleStringParameterSet:`
`310`	`295`	`case IpRuleObjectParameterSet:`
`311`		`- WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).IpRules);`
	`296`	`+ WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.Data.NetworkRuleSet).IpRules);`
`312`	`297`	`break;`
`313`	`298`	`case ResourceAccessRuleStringParameterSet:`
`314`	`299`	`case ResourceAccessRuleObjectParameterSet:`
`315`		`- WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).ResourceAccessRules);`
	`300`	`+ WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.Data.NetworkRuleSet).ResourceAccessRules);`
`316`	`301`	`break;`
`317`	`302`	`}`
`318`	`303`	`}`