Exemplo n.º 1
0
        /// <summary>
        /// Create a new customer
        /// </summary>
        /// <param name="defaultDomain">default domain of the reseller</param>
        /// <param name="appId">appid that is registered for this application in Azure Active Directory (AAD)</param>
        /// <param name="key">Key for this application in Azure Active Directory</param>
        /// <param name="resellerMicrosoftId">Microsoft Id of the reseller</param>
        /// <returns></returns>
        internal static string CreateCustomer(string defaultDomain, string appId, string key,
                                              string resellerMicrosoftId)
        {
            // Get Active Directory token first
            AuthorizationToken adAuthorizationToken = Reseller.GetAD_Token(defaultDomain, appId, key);

            // Using the ADToken get the sales agent token
            AuthorizationToken saAuthorizationToken = Reseller.GetSA_Token(adAuthorizationToken);

            // Get the Reseller Cid, you can cache this value
            string resellerCid = Reseller.GetCid(resellerMicrosoftId, saAuthorizationToken.AccessToken);
            // Get input from the console application for creating a new customer
            var customer = Customer.PopulateCustomerFromConsole();

            // This is the created customer object that contains the cid, the microsoft tenant id etc
            var createdCustomer = Customer.CreateCustomer(customer, resellerCid, saAuthorizationToken.AccessToken);

            if (createdCustomer == null)
            {
                throw new Exception("Error creating customer");
            }
            string newCustomerMicrosoftId = createdCustomer.customer.identity.data.tid;

            // Populate a multi line item order
            var newCustomerOrder = Order.PopulateOrderWithMultipleLineItems(createdCustomer.customer.id);

            // Place the order and subscription uri and entitlement uri are returned per each line item
            var newCustomerPlacedOrder = Order.PlaceOrder(newCustomerOrder, resellerCid, saAuthorizationToken.AccessToken);

            foreach (var line_Item in newCustomerPlacedOrder.line_items)
            {
                var subscription = Subscription.GetSubscriptionByUri(line_Item.resulting_subscription_uri, saAuthorizationToken.AccessToken);
                Console.WriteLine("Subscription: {0}", subscription.Id);
            }

            return(newCustomerMicrosoftId);
        }
Exemplo n.º 2
0
        static void Main()
        {
            Console.Write("\nHave you updated the app.config, with the settings from https://partnercenter.microsoft.com (y/n)? ");
            string response = Console.ReadLine().Trim().ToUpperInvariant();

            if (response != "Y" && response != "YES")
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\nUpdate AppId, Key, MicrosoftId, DefaultDomain in the app.config and run the app again");

                Console.ResetColor();
                Console.Write("\n\n\nHit enter to exit the app now");
                Console.ReadLine();
                return;
            }

            // This is the Microsoft ID of the reseller
            // Please work with your Admin Agent to get it from https://partnercenter.microsoft.com/en-us/pc/AccountSettings/TenantProfile
            string microsoftId = ConfigurationManager.AppSettings["MicrosoftId"];

            // This is the default domain of the reseller
            // Please work with your Admin Agent to get it from https://partnercenter.microsoft.com/en-us/pc/AccountSettings/TenantProfile
            string defaultDomain = ConfigurationManager.AppSettings["DefaultDomain"];

            // This is the appid that is registered for this application in Azure Active Directory (AAD)
            // Please work with your Admin Agent to get it from  https://partnercenter.microsoft.com/en-us/pc/ApiIntegration/Overview
            string appId = ConfigurationManager.AppSettings["AppId"];

            // This is the key for this application in Azure Active Directory
            // This is only available at the time your admin agent has created a new app at https://partnercenter.microsoft.com/en-us/pc/ApiIntegration/Overview
            // You could alternatively goto Azure Active Directory and generate a new key, and use that.
            string key = ConfigurationManager.AppSettings["Key"];

            try
            {
                // Get Active Directory token first
                adAuthorizationToken = Reseller.GetAD_Token(defaultDomain, appId, key);

                // Using the ADToken get the sales agent token
                saAuthorizationToken = Reseller.GetSA_Token(adAuthorizationToken);

                // Get the Reseller Cid, you can cache this value
                string resellerCid = Reseller.GetCid(microsoftId, saAuthorizationToken.AccessToken);

#if CREATE_CUSTOMER_SCENARIO
                // Get input from the console application for creating a new customer
                var customer = Customer.PopulateCustomerFromConsole();

                // This is the created customer object that contains the cid, the microsoft tenant id etc
                var createdCustomer = Customer.CreateCustomer(customer, resellerCid, saAuthorizationToken.AccessToken);

                // Populate a multi line item order
                var newCustomerOrder = Order.PopulateOrderWithMultipleLineItems(createdCustomer.customer.id);

                // Place the order and subscription uri and entitlement uri are returned per each line item
                var newCustomerPlacedOrder = Order.PlaceOrder(newCustomerOrder, resellerCid, saAuthorizationToken.AccessToken);

                foreach (var line_Item in newCustomerPlacedOrder.line_items)
                {
                    var subscription = Subscription.GetSubscriptionByUri(line_Item.resulting_subscription_uri, saAuthorizationToken.AccessToken);
                    Console.WriteLine("Subscription: {0}", subscription.Id);
                }
#endif
#if true
                string ExistingCustomerMicrosoftId = ConfigurationManager.AppSettings["ExistingCustomerMicrosoftId"];

                // You can cache this value too
                var existingCustomerCid = Customer.GetCustomerCid(ExistingCustomerMicrosoftId, microsoftId, saAuthorizationToken.AccessToken);

                customerAuthorizationToken = Customer.GetCustomer_Token(existingCustomerCid, adAuthorizationToken);

                // get the customer entity
                var customer = Customer.GetCustomer(existingCustomerCid, customerAuthorizationToken.AccessToken);

                // Get all subscriptions placed by the reseller for the customer
                var subscriptions = Subscription.GetSubscriptions(existingCustomerCid, resellerCid, saAuthorizationToken.AccessToken);

                // Get all orders placed by the reseller for this customer
                var orders = Order.GetOrders(existingCustomerCid, resellerCid, saAuthorizationToken.AccessToken);

                // Populate a multi line item order
                var existingCustomerOrder = Order.PopulateOrderFromConsole(existingCustomerCid);

                // Place the order and subscription uri and entitlement uri are returned per each line item
                var existingCustomerPlacedOrder = Order.PlaceOrder(existingCustomerOrder, resellerCid, saAuthorizationToken.AccessToken);

                foreach (var line_Item in existingCustomerPlacedOrder.line_items)
                {
                    var subscription = Subscription.GetSubscriptionByUri(line_Item.resulting_subscription_uri, saAuthorizationToken.AccessToken);
                    Console.WriteLine("Subscription: {0}", subscription.Id);
                }
#endif
            }
            catch (System.FieldAccessException)
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\n\n\n Looks like you are debugging the application.  Inorder to fix this exception: "
                                  + "\n 1. In Visual Studio, Right Click on the Project Microsoft.CSP.Api.V1.Samples"
                                  + "\n 2. Select the Debug Tab"
                                  + "\n 3. Uncheck the option \"Enable the Visual Studio hosting process\" (it is at the bottom of the page)"
                                  + "\n 4. Save the changes (File -> Save Selected Items)"
                                  + "\n 5. Debug the app now.");
                Console.Write("Make sure you copy/remember the above steps before exiting the app.");
            }
            catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException)
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\n Make sure the app.config has all the right settings.  The defaults in the app.config won't work."
                                  + "\n If the settings are correct, its possible you are hitting a service error.  Try again."
                                  + "\n If the error persists, contact support");
            }


            Console.ResetColor();
            Console.Write("\n\n\nHit enter to exit the app...");
            Console.ReadLine();
        }
Exemplo n.º 3
0
        /// <summary>
        /// Creates a virtual machine in Azure.
        /// Creates all the required resources before creating VM.
        /// </summary>
        /// <param name="subscriptionId">Subscription Id</param>
        /// <param name="credentialName">Internet name/address used to identify entry in Credential Manager</param>
        /// <param name="appId">appid that is registered for this application in Azure Active Directory (AAD)</param>
        /// <param name="customerTenantId">Id or Domain of the customer Azure tenant</param>
        private static void CreateAzureVirtualMachine(string appId, string credentialName, string customerTenantId, string subscriptionId)
        {
            // Get Azure Authentication Token
            string azureToken = Reseller.GetAzureAuthTokenForCustomerTenant(appId, credentialName, customerTenantId);
            // Correlation Id to be used for this scenaario
            var correlationId = Guid.NewGuid().ToString();

            var resourceGroupName = Guid.NewGuid().ToString();

            // Appending suffix to resource group name to build names of other resources

            // Storage account names must be between 3 and 24 characters in length and use numbers and lower-case letters only.
            // So removing hyphen and truncating.
            var storageAccountName = String.Format("{0}sa", resourceGroupName.Replace("-", "").Remove(20));

            var networkSecurityGroupName = String.Format("{0}_nsg", resourceGroupName);
            var networkSecurityGroupId   =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/networkSecurityGroups/{2}",
                    subscriptionId, resourceGroupName, networkSecurityGroupName);

            var virtualNetworkName = String.Format("{0}_vn", resourceGroupName);
            var subnetName         = String.Format("{0}_sn", resourceGroupName);
            var subNetId           =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/microsoft.network/virtualNetworks/{2}/subnets/{3}",
                    subscriptionId, resourceGroupName, virtualNetworkName, subnetName);

            var publicIpName = String.Format("{0}_pip", resourceGroupName);
            var publicIpId   =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/publicIPAddresses/{2}",
                    subscriptionId, resourceGroupName, publicIpName);

            var networkInterfaceName = String.Format("{0}_nic", resourceGroupName);
            var networkInterfaceId   =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/networkInterfaces/{2}",
                    subscriptionId, resourceGroupName, networkInterfaceName);

            var ipName            = String.Format("{0}_ip", resourceGroupName);
            var vitualMachineName = String.Format("{0}_vm", resourceGroupName);

            // Waiting Time (in seconds) For Resource to be Provisioned
            var retryAfter = 5;
            // Retry attempts for resource provisioning errors
            var retryAttempts = 5;
            var attempts      = 0;

            // The following resources are to be created in order before creating a virtual machine.

            // #1 Create Resource Group
            do
            {
                var createResourceGroupResponse = AzureResourceManager.CreateResourceGroup(subscriptionId, resourceGroupName,
                                                                                           azureToken, correlationId);
                if (createResourceGroupResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;

                    // Waiting for the resource group to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(createResourceGroupResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForResourceGroupProvisioning(subscriptionId, resourceGroupName, retryAfter,
                                                                              azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #2 Create Storage Account
            // Register the subscription with Storage Resource Provider, for creating Storage Account
            // Storage Resource Provider
            const string storageProviderName = "Microsoft.Storage";

            AzureResourceManager.RegisterProvider(subscriptionId, storageProviderName, azureToken, correlationId);

            attempts = 0;
            do
            {
                var storageAccountResponse = AzureResourceManager.CreateStorageAccount(subscriptionId, resourceGroupName,
                                                                                       storageAccountName, azureToken, correlationId);
                if (storageAccountResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the storage account to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(storageAccountResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        var location = storageAccountResponse.Headers.Get("Location");
                        retryAfter = Int32.Parse(storageAccountResponse.Headers.Get("Retry-After"));
                        AzureResourceManager.WaitForStorageAccountProvisioning(location, resourceGroupName, retryAfter,
                                                                               azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // Register the subscription with Network Resource Provider for creating Network Resources - Netowrk Securtiy Group, Virtual Network, Subnet, Public IP and Network Interface
            // Network Resource Provider
            const string networkProviderName = "Microsoft.Network";

            AzureResourceManager.RegisterProvider(subscriptionId, networkProviderName, azureToken, correlationId);

            // #3 Create Network Security Group
            attempts = 0;
            do
            {
                var networkSecurityGroupResponse = AzureResourceManager.CreateNetworkSecurityGroup(subscriptionId,
                                                                                                   resourceGroupName, networkSecurityGroupName, azureToken, correlationId);
                if (networkSecurityGroupResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the network security group to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(networkSecurityGroupResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForNetworkSecurityGroupProvisioning(subscriptionId, resourceGroupName,
                                                                                     networkSecurityGroupName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);


            // #4 Create Virtual Network
            attempts = 0;
            do
            {
                var virtualNetworkResponse = AzureResourceManager.CreateVirtualNetwork(subscriptionId, resourceGroupName,
                                                                                       virtualNetworkName, azureToken, correlationId);
                if (virtualNetworkResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the virtual network to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(virtualNetworkResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForVirtualNetworkProvisioning(subscriptionId, resourceGroupName,
                                                                               virtualNetworkName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #5 Create Subnet
            attempts = 0;
            do
            {
                var subNetResponse = AzureResourceManager.CreateSubNet(subscriptionId, resourceGroupName, virtualNetworkName,
                                                                       networkSecurityGroupId, subnetName, azureToken, correlationId);
                if (subNetResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the subnet to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(subNetResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForSubNetProvisioning(subscriptionId, resourceGroupName, virtualNetworkName,
                                                                       subnetName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #6 Create Public IP Address
            attempts = 0;
            do
            {
                var publicIpResponse = AzureResourceManager.CreatePublicIpAddress(subscriptionId, resourceGroupName,
                                                                                  publicIpName, azureToken, correlationId);
                if (publicIpResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the public IP to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(publicIpResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForPublicIpProvisioning(subscriptionId, resourceGroupName, publicIpName,
                                                                         retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #7 Create Network Interface
            attempts = 0;
            do
            {
                var networkInterfaceResponse = AzureResourceManager.CreateNetworkInterface(subscriptionId, resourceGroupName,
                                                                                           networkInterfaceName, networkSecurityGroupId, ipName, publicIpId, subNetId, azureToken, correlationId);
                if (networkInterfaceResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the network interface to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(networkInterfaceResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForNetworkInterfaceProvisioning(subscriptionId, resourceGroupName,
                                                                                 networkInterfaceName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #8 Create Azure Virtual Machine
            // Compute Resource Provider
            const string computeProviderName = "Microsoft.Compute";

            AzureResourceManager.RegisterProvider(subscriptionId, computeProviderName, azureToken, correlationId);
            var virtualMachineResponse = AzureResourceManager.CreateVirtualMachine(subscriptionId, resourceGroupName,
                                                                                   networkInterfaceId, storageAccountName, vitualMachineName, azureToken, correlationId);

            if (virtualMachineResponse == null)
            {
                return;
            }

            // #9  Create a New User
            var newUserInfo = User.PopulateUserFromConsole();
            var newUser     = AzureResourceManager.CreateUser(newUserInfo.displayName, newUserInfo.mailNickname,
                                                              newUserInfo.userPrincipalName, newUserInfo.password,
                                                              azureToken, correlationId);
            // #10 Add user to Owner role
            // Register the subscription with Authorization Provider
            const string authorizationProviderName = "Microsoft.Authorization";
            var          registrationResult        = AzureResourceManager.RegisterProvider(subscriptionId, authorizationProviderName, azureToken, correlationId);

            // Role Id for Role 'Owner'
            const string roleIdForOwner = "8e3af657-a8ff-443c-a75c-2fe8c4bcb635";
            var          scope          = String.Format("/subscriptions/{0}", subscriptionId);
            // Assigning 'Owner' role to the new user
            var roleAssignment = AzureResourceManager.CreateRoleAssignment(azureToken, scope, newUser.objectId, roleIdForOwner,
                                                                           correlationId);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Get a customer's usage information for the last 1 month, calculates the total cost using RateCard API
        /// and Suspends the subscription if the total cost is more than the credit limit.
        /// </summary>
        /// <param name="defaultDomain">default domain of the reseller</param>
        /// <param name="appId">appid that is registered for this application in Azure Active Directory (AAD)</param>
        /// <param name="key">Key for this application in Azure Active Directory</param>
        /// <param name="customerMicrosoftId">Microsoft Id of the customer</param>
        /// <param name="resellerMicrosoftId">Microsoft Id of the reseller</param>
        public static void GetRateCardAndUsage(string defaultDomain, string appId, string key,
                                               string customerMicrosoftId, string resellerMicrosoftId)
        {
            var correlationId = Guid.NewGuid().ToString();
            // Get Active Directory token first
            AuthorizationToken adAuthorizationToken = Reseller.GetAD_Token(defaultDomain, appId, key);

            // Using the ADToken get the sales agent token
            AuthorizationToken saAuthorizationToken = Reseller.GetSA_Token(adAuthorizationToken);

            // Get the Reseller Cid, you can cache this value
            string resellerCid = Reseller.GetCid(resellerMicrosoftId, saAuthorizationToken.AccessToken);

            // You can cache this value too
            var customerCid = Customer.GetCustomerCid(customerMicrosoftId, resellerMicrosoftId,
                                                      saAuthorizationToken.AccessToken);

            // Get Customer token
            AuthorizationToken customerAuthorizationToken = Customer.GetCustomer_Token(customerCid, adAuthorizationToken);

            // Gets the RateCard to get the prices
            var rateCard = RateCard.GetRateCard(resellerCid, saAuthorizationToken.AccessToken);

            var startTime = String.Format("{0:u}", DateTime.Today.AddDays(-30));
            var endTime   = String.Format("{0:u}", DateTime.Today.AddDays(-1));

            // Get all of a Customer's entitlements
            var entitlements = Usage.GetEntitlements(customerCid, customerAuthorizationToken.AccessToken);

            try
            {
                foreach (var entitlement in entitlements.items)
                {
                    // Get the usage for the given entitlement for the last 1 month
                    var usageRecords = Usage.GetUsageRecords(resellerCid, entitlement.id, saAuthorizationToken.AccessToken,
                                                             startTime, endTime);

                    if (usageRecords.items.Count > 0)
                    {
                        Console.ForegroundColor = ConsoleColor.DarkGreen;
                        Console.WriteLine("================================================================================");
                        Console.WriteLine("\nPrices for Entitlement: {0}", entitlement.id);
                        Console.WriteLine("================================================================================");

                        double totalCost = 0;
                        // Looping through the usage records to calculate the cost of each item
                        foreach (UsageType usageRecord in usageRecords.items)
                        {
                            string meterId = usageRecord.meter_id;

                            // Gets the price corresponding to the given meterId from the ratecard.
                            Console.WriteLine("\nMeter Name\t\t: {0}", usageRecord.meter_name);
                            double includedQty = Usage.GetIncludedQuantityByMeterID(rateCard, meterId);
                            Console.WriteLine("Included Quantity\t\t: {0}", includedQty);
                            double consumedQty = (double)usageRecord.quantity;
                            Console.WriteLine("Consumed Quantity\t\t: {0}", consumedQty);
                            double ratableUsage = Usage.GetRatableUsage(consumedQty, includedQty);
                            double cost         = Usage.computeRatedUsagePerMeter(Usage.GetRatesForMeterID(rateCard, meterId), ratableUsage);
                            Console.WriteLine("Cost\t\t: {0}", cost);
                            totalCost += cost;
                        }
                        Console.WriteLine("\nTOTAL COST:  {0}", totalCost);
                        // Setting the credit limit below the total cost for testing this scenario
                        double creditLimit = 100;
                        // Suspends the subscription if the total cost is above the credit limit.
                        if (totalCost > creditLimit)
                        {
                            var subscription = Subscription.GetSubscriptionByUri(entitlement.billing_subscription_uri,
                                                                                 saAuthorizationToken.AccessToken);
                            Subscription.SuspendSubscription(subscription.id, resellerCid, saAuthorizationToken.AccessToken);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }