Wait for token device code / new Sample for Authentication

[tehho]

I have tried to get the device code to work and have now managed a manuall way to do it and would like to have an automated way.

What i've done is to write the device message and then waiting with a readline and the returning true.

What i would like to do is to peek at the token to see if it's ready to fetch.
When i try to do this I automaticly fetch the token and then i get an error saying the token is already claimed.

Tried to refresh token as a work around but that to fetched the token directly.
Good to have for some systems but not nice when you want a smoot signin process in your application.

`
using System;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;
using System.Threading.Tasks;
using System.Net.Http;
using System.Net.Http.Headers;
using Microsoft.Azure.Management.Compute.Fluent;
using Microsoft.Azure.Management.Fluent;
using Microsoft.Azure.Management.Network.Fluent;
using Microsoft.Azure.Management.Network.Fluent.Models;
using Microsoft.Azure.Management.ResourceManager.Fluent;
using Microsoft.Azure.Management.ResourceManager.Fluent.Core;
using Microsoft.Azure.Management.ResourceManager.Fluent.Authentication;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace azure_check_subnet_without_nsg
{
class Program
{
private const string TenantId = "YOUR-TENANT-HERE";

    static async Task Main(string[] args)
    {

        var deviceInfo = new DeviceCredentialInformation();
        deviceInfo.ClientId = "YOUR-NATIVE-APP-ID-HERE";
        deviceInfo.DeviceCodeFlowHandler = d => ConnectToAzureAsync(d).Result;

        var userCred = new AzureCredentials(deviceInfo, TenantId, AzureEnvironment.AzureGlobalCloud);

        var azure = Azure
            .Configure()
            .Authenticate(userCred);
        
        var subs = await azure.Subscriptions.ListAsync();




        subs.Select(sub => azure.WithSubscription(sub.SubscriptionId))
            .SelectMany(sub => sub.Networks.ListAsync().Result)
            .SelectMany(vnet => vnet.Subnets)
            .Where(subnet => (subnet.Value.NetworkSecurityGroupId == null))
            .ToList()
            .ForEach(subnet =>
            {
                var vnet = subnet.Value.Parent;
                var subscriptionId = vnet.Manager.SubscriptionId;
                var subscription = azure.Subscriptions.GetById(subscriptionId);

                Console.WriteLine($"Subscription: {subscription.DisplayName} Vnet: {vnet.Name} Subnet: {subnet.Value.Name}");
            });
    }

    static async Task<IEnumerable<INetwork>> GetAllVnet(Azure.IAuthenticated azure, ISubscription subscription)
    {
        return await azure.WithSubscription(subscription.SubscriptionId).Networks.ListAsync();
    }

    static async Task<IEnumerable<ISubnet>> GetAllSubnetWithoutNsgAsync(INetwork vnet)
    {
        return await new Task<IEnumerable<ISubnet>>(() => vnet.Subnets.Select(vn => vn.Value).Where(subnet => subnet.NetworkSecurityGroupId == null));
    }

    static void PrintSubscriptionVnetSubnet(ISubscription subscription, INetwork vnet, ISubnet subnet)
    {   
        Console.WriteLine($"Subscription: {subscription.DisplayName} Vnet: {vnet.Name} Subnet: {subnet.Name}");
    }

    static async Task<bool> ConnectToAzureAsync(DeviceCodeResult device)
    {
        Console.WriteLine(device.Message);

        //Console.ReadLine();

        //return true;

        var pollingInterval = TimeSpan.FromSeconds(device.Interval);
        var codeExpiresOn = device.ExpiresOn;
        
        var timeRemaining = codeExpiresOn - DateTimeOffset.UtcNow;

        string tokenUri = string.Format(CultureInfo.InvariantCulture, "https://login.microsoftonline.com/{1}/oauth2/token", device.Resource, TenantId);

        while(timeRemaining.TotalSeconds > 0)
        {
            var tokenRequest = new HttpRequestMessage(HttpMethod.Post, tokenUri)
            {
                Content = new FormUrlEncodedContent(
                    new Dictionary<string, string>()
                    {
                        ["grant_type"] = "device_code",
                        ["resource"] = device.Resource,
                        ["code"] = device.DeviceCode,
                        ["client_id"] = device.ClientId
                    }
              )
            };

            using (var client = new HttpClient())
            {
                var tokenRes = await client.SendAsync(tokenRequest);

                if (tokenRes.IsSuccessStatusCode)
                {
                    var tokenJson = await tokenRes.Content.ReadAsStringAsync();

                    var tokenData = JObject.Parse(tokenJson);

                    var token = tokenData["refresh_token"];

                    tokenRequest = new HttpRequestMessage(HttpMethod.Post, tokenUri)
                    {
                        Content = new FormUrlEncodedContent(
                            new Dictionary<string, string>()
                            {
                                ["grant_type"] = "refresh_token",
                                ["resource"] = device.Resource,
                                ["refresh_token"] = token.ToString(),
                                ["client_id"] = device.ClientId
                            }
                        )
                    };

                    tokenRes = await client.SendAsync(tokenRequest);

                    return true;
                }
            }

            await Task.Delay((int)pollingInterval.TotalMilliseconds);
        }

        return false;
    }
}

}

`