public AdalConfiguration(WindowsAzureSubscription subscription)
     : this()
 {
     AdEndpoint = subscription.ActiveDirectoryEndpoint != null ? subscription.ActiveDirectoryEndpoint.TrimEnd('/') + '/' : null;
     AdDomain = subscription.ActiveDirectoryTenantId;
     ResourceClientUri = subscription.ActiveDirectoryServiceEndpointResourceId;
 }

        public static IJobSubmissionClientCredential GetJobSubmissionClientCredentials(this IAzureHDInsightJobCommandCredentialsBase command, WindowsAzureSubscription currentSubscription, string cluster)
        {
            IJobSubmissionClientCredential clientCredential = null;
            if (command.Credential != null)
            {
                clientCredential = new BasicAuthCredential
                {
                    Server = GatewayUriResolver.GetGatewayUri(cluster),
                    UserName = command.Credential.UserName,
                    Password = command.Credential.GetCleartextPassword()
                };
            }
            else if (currentSubscription.IsNotNull())
            {
                var subscriptionCredentials = GetSubscriptionCredentials(command, currentSubscription);
                var asCertificateCredentials = subscriptionCredentials as HDInsightCertificateCredential;
                var asTokenCredentials = subscriptionCredentials as HDInsightAccessTokenCredential;
                if (asCertificateCredentials.IsNotNull())
                {
                    clientCredential = new JobSubmissionCertificateCredential(asCertificateCredentials, cluster);
                }
                else if (asTokenCredentials.IsNotNull())
                {
                    clientCredential = new JobSubmissionAccessTokenCredential(asTokenCredentials, cluster);
                }
            }

            return clientCredential;
        }

 public void Initialize()
 {
     var azureSub = new WindowsAzureSubscription();
     azureSub.ServiceEndpoint = new Uri("https://localhost:8090/");
     azureSub.SubscriptionId = Guid.NewGuid().ToString();
     this.subscription = new Subscription(azureSub);
 }

 /// <summary>
 /// Creates new WebsitesClient
 /// </summary>
 /// <param name="subscription">Subscription containing websites to manipulate</param>
 /// <param name="logger">The logger action</param>
 public WebsitesClient(WindowsAzureSubscription subscription, Action<string> logger)
 {
     Logger = logger;
     cloudServiceClient = new CloudServiceClient(subscription, debugStream: logger);
     WebsiteManagementClient = subscription.CreateClient<WebSiteManagementClient>();
     this.subscription = subscription;
 }

 public bool IsStorageServiceAvailable(WindowsAzureSubscription subscription, string name)
 {
     EnsureCloudServiceClientInitialized(subscription);
     bool available = this.CloudServiceClient.CheckStorageServiceAvailability(name);
     WriteObject(!available);
     return available;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ServerDataServicesCertAuth"/> class
 /// </summary>
 /// <param name="subscription">The subscription used to connect and authenticate.</param>
 /// <param name="serverName">The name of the server to connect to.</param>
 private ServerDataServiceCertAuth(
     WindowsAzureSubscription subscription,
     string serverName)
 {
     this.serverName = serverName;
     this.subscription = subscription;
 }

 public static IHDInsightSubscriptionCredentials GetSubscriptionCertificateCredentials(this IAzureHDInsightCommonCommandBase command, WindowsAzureSubscription currentSubscription)
 {
     return new HDInsightCertificateCredential
     {
         SubscriptionId = ResolveSubscriptionId(currentSubscription.SubscriptionId),
         Certificate = currentSubscription.Certificate,
         Endpoint = currentSubscription.ServiceEndpoint,
     };
 }

        public AutomationClient(
            WindowsAzureSubscription subscription,
            IAutomationManagementClient automationManagementClient)
        {
            Requires.Argument("automationManagementClient", automationManagementClient).NotNull();

            this.Subscription = subscription;
            this.automationManagementClient = automationManagementClient;
        }

        /// <summary>
        /// Creates new ResourceManagementClient
        /// </summary>
        /// <param name="subscription">Subscription containing resources to manipulate</param>
        public ResourcesClient(WindowsAzureSubscription subscription)
            : this(
                subscription.CreateClientFromResourceManagerEndpoint<ResourceManagementClient>(),
                new StorageClientWrapper(subscription.CreateClient<StorageManagementClient>()),
                new GalleryTemplatesClient(subscription),
                subscription.CreateClientFromResourceManagerEndpoint<EventsClient>())
        {

        }

 private void EnsureCloudServiceClientInitialized(WindowsAzureSubscription subscription)
 {
     this.CloudServiceClient = this.CloudServiceClient ?? new CloudServiceClient(
         subscription,
         SessionState.Path.CurrentLocation.Path,
         WriteDebug,
         WriteVerbose,
         WriteWarning);
 }

 public static IHDInsightSubscriptionCredentials GetAccessTokenCredentials(this IAzureHDInsightCommonCommandBase command, WindowsAzureSubscription currentSubscription)
 {
     var accessToken = currentSubscription.TokenProvider.GetCachedToken(currentSubscription,
                                                                currentSubscription.ActiveDirectoryUserId);
     return new HDInsightAccessTokenCredential()
     {
         SubscriptionId = ResolveSubscriptionId(currentSubscription.SubscriptionId),
         AccessToken = accessToken.AccessToken
     };
 }

        public IAccessToken GetCachedToken(WindowsAzureSubscription subscription, string userId)
        {
            var key = tokenCache.Keys.FirstOrDefault(k => k.UserId == userId && k.TenantId == subscription.ActiveDirectoryTenantId);
            if (key == null)
            {
                throw new AadAuthenticationFailedException(string.Format(Resources.NoCachedToken,
                    subscription.SubscriptionName, userId));
            }

            return new AdalAccessToken(DecodeCachedAuthResult(key), this, new AdalConfiguration(subscription));
        }

        internal Subscription(WindowsAzureSubscription azureSubscription)
        {
            if (azureSubscription == null)
            {
                throw new ArgumentNullException();
            }

            this.SubscriptionName = azureSubscription.SubscriptionName;
            this.SubscriptionId = azureSubscription.SubscriptionId;
            this.ServiceEndpoint = new Uri(String.Format("{0}/{1}/services/systemcenter/vmm", azureSubscription.ServiceEndpoint.ToString().TrimEnd(new[]{'/'}), SubscriptionId));
            this.Certificate = azureSubscription.Certificate;
            this.CredentialType = CredentialType.UseCertificate;
        }

        public static IHDInsightSubscriptionCredentials GetSubscriptionCredentials(this IAzureHDInsightCommonCommandBase command, WindowsAzureSubscription currentSubscription)
        {
            if (currentSubscription.Certificate.IsNotNull())
            {
                return GetSubscriptionCertificateCredentials(command, currentSubscription);
            }
            else if (currentSubscription.ActiveDirectoryUserId.IsNotNull())
            {
                return GetAccessTokenCredentials(command, currentSubscription);
            }

            throw new NotSupportedException();
        }

        /// <summary>
        /// Validates that the given subscription is valid.
        /// </summary>
        /// <param name="subscription">The <see cref="WindowsAzureSubscription"/> to validate.</param>
        public static void ValidateSubscription(WindowsAzureSubscription subscription)
        {
            if (subscription == null)
            {
                throw new ArgumentException(
                    Common.Properties.Resources.InvalidCurrentSubscription);
            }

            if (string.IsNullOrEmpty(subscription.SubscriptionId))
            {
                throw new ArgumentException(
                    Common.Properties.Resources.InvalidCurrentSubscriptionId);
            }
        }

        private void CreateNewSubscription()
        {
            var subscription = new WindowsAzureSubscription
            {
                SubscriptionName = SubscriptionName,
                SubscriptionId = SubscriptionId,
                Certificate = Certificate,
                CurrentStorageAccountName = CurrentStorageAccountName
            };

            if (string.IsNullOrEmpty(ServiceEndpoint))
            {
                subscription.ServiceEndpoint = new Uri(Profile.CurrentEnvironment.ServiceEndpoint);
            }
            else
            {
                subscription.ServiceEndpoint = new Uri(ServiceEndpoint);
            }

            Profile.AddSubscription(subscription);
        }

        /// <summary>
        /// Creates new Scheduler Management Convenience Client
        /// </summary>
        /// <param name="subscription">Subscription containing websites to manipulate</param>
        public SchedulerMgmntClient(WindowsAzureSubscription subscription)
        {
            currentSubscription = subscription;
            csmClient = subscription.CreateClient<CloudServiceManagementClient>();
            schedulerManagementClient = subscription.CreateClient<SchedulerManagementClient>();

            //Get RP properties
            IDictionary<string, string> dict = schedulerManagementClient.GetResourceProviderProperties().Properties;

            //Get available regions
            string val = string.Empty;
            if(dict.TryGetValue(SupportedRegionsKey, out val))
            {
                AvailableRegions = new List<string>();
                val.Split(',').ToList().ForEach(s => AvailableRegions.Add(s));
            }            

            //Store global counts for max jobs and min recurrence for each plan     
            if(dict.TryGetValue(FreeMaxJobCountKey, out val))
                FreeMaxJobCountValue = Convert.ToInt32(dict[FreeMaxJobCountKey]);

            if (dict.TryGetValue(FreeMinRecurrenceKey, out val))
                FreeMinRecurrenceValue = TimeSpan.Parse(dict[FreeMinRecurrenceKey]);

            if (dict.TryGetValue(StandardMaxJobCountKey, out val))
                StandardMaxJobCountValue = Convert.ToInt32(dict[StandardMaxJobCountKey]);

            if (dict.TryGetValue(StandardMinRecurrenceKey, out val))
                StandardMinRecurrenceValue = TimeSpan.Parse(dict[StandardMinRecurrenceKey]);

            if (dict.TryGetValue(PremiumMaxJobCountKey, out val))
                PremiumMaxJobCountValue = Convert.ToInt32(dict[PremiumMaxJobCountKey]);

            if (dict.TryGetValue(PremiumMinRecurrenceKey, out val))
                PremiumMinRecurrenceValue = TimeSpan.Parse(dict[PremiumMinRecurrenceKey]);
        }

 public PSCacheClient(WindowsAzureSubscription currentSubscription)
 {
     client = currentSubscription.CreateClient<ManagedCacheClient>();
 }

        private void SetupAzureEnvironmentFromEnvironmentVariables()
        {
            ServiceManagementTestEnvironmentFactory serviceManagementTestEnvironmentFactory = new ServiceManagementTestEnvironmentFactory();
            TestEnvironment rdfeEnvironment = serviceManagementTestEnvironmentFactory.GetTestEnvironment();
            ResourceManagerTestEnvironmentFactory resourceManagerTestEnvironmentFactory = new ResourceManagerTestEnvironmentFactory();
            TestEnvironment csmEnvironment = resourceManagerTestEnvironmentFactory.GetTestEnvironment();
            string jwtToken = csmEnvironment.Credentials != null ? 
                ((TokenCloudCredentials)csmEnvironment.Credentials).Token : null;

            WindowsAzureProfile.Instance.TokenProvider = new FakeAccessTokenProvider(jwtToken, csmEnvironment.UserName);
            
            WindowsAzureProfile.Instance.CurrentEnvironment = WindowsAzureProfile.Instance.Environments[testEnvironmentName];

            WindowsAzureProfile.Instance.CurrentEnvironment.ActiveDirectoryEndpoint =
                csmEnvironment.ActiveDirectoryEndpoint.AbsoluteUri;
            WindowsAzureProfile.Instance.CurrentEnvironment.GalleryEndpoint =
                csmEnvironment.GalleryUri.AbsoluteUri;
            WindowsAzureProfile.Instance.CurrentEnvironment.ResourceManagerEndpoint =
                csmEnvironment.BaseUri.AbsoluteUri;
            WindowsAzureProfile.Instance.CurrentEnvironment.ServiceEndpoint =
                rdfeEnvironment.BaseUri.AbsoluteUri;

            var newSubscription = new WindowsAzureSubscription(false, false)
            {
                SubscriptionId = csmEnvironment.SubscriptionId,
                ActiveDirectoryEndpoint =
                    WindowsAzureProfile.Instance.CurrentEnvironment.ActiveDirectoryEndpoint,
                ActiveDirectoryUserId = csmEnvironment.UserName,
                SubscriptionName = csmEnvironment.SubscriptionId,
                ServiceEndpoint = new Uri(WindowsAzureProfile.Instance.CurrentEnvironment.ServiceEndpoint),
                ResourceManagerEndpoint = new Uri(WindowsAzureProfile.Instance.CurrentEnvironment.ResourceManagerEndpoint),
                TokenProvider = WindowsAzureProfile.Instance.TokenProvider,
                GalleryEndpoint = new Uri(WindowsAzureProfile.Instance.CurrentEnvironment.GalleryEndpoint),
                SqlDatabaseDnsSuffix = WindowsAzureProfile.Instance.CurrentEnvironment.SqlDatabaseDnsSuffix,
                CurrentStorageAccountName = csmEnvironment.StorageAccount,
                IsDefault = true
            };
            if (HttpMockServer.Mode == HttpRecorderMode.Playback)
            {
                newSubscription.SetAccessToken(new FakeAccessToken
                    {
                        AccessToken = "123",
                        UserId = csmEnvironment.UserName
                    });
            }
            else
            {
                newSubscription.SetAccessToken(WindowsAzureProfile.Instance.TokenProvider.GetNewToken(WindowsAzureProfile.Instance.CurrentEnvironment));
            }

            WindowsAzureProfile.Instance.AddSubscription(newSubscription);
            WindowsAzureProfile.Instance.Save();
        }

 private static WindowsAzureSubscription GetWindowsAzureSubscription()
 {
     WindowsAzureSubscription windowsAzureSubscription = new WindowsAzureSubscription
     {
         SubscriptionId = SubscriptionId,
         Certificate = new X509Certificate2(new byte[] {}),
         ServiceEndpoint = new Uri("http://someValue")
     };
     return windowsAzureSubscription;
 }