/// <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);
}
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();
}
/// <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);
}
/// <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());
}
}
