Cleanup (#11)

* - Cleaning-up the code and aligning the code with the active-directory-dotnet-webapi-onbehalfof sample
- Updating the AppCreation scripts
- Adding

* - Updating NuGet packages

* Improving the readme and adding diagrams and pictures.

* Improving the topology diagram

* - Fixing a few http => https://
- moving from using the AAD Graph to the Microsoft Graph
- Fixing license

* Fixing links to images

* Fixing the script

* Improving the readme based on feedback on other samples.

* Improving the readme.md
- adding details on how to get the tenantId/name
- removing an unnecessary step in the client
- fixing the markdown structure

* Changes made during code review and testing

AppCreationScripts/AppCreationScripts.md

@@ -0,0 +1,107 @@
+# Registering the Azure Active Directory applications and updating the configuration files for this sample using PowerShell scripts
+
+## Goal of the scripts
+
+### Presentation of the scripts
+
+This sample comes with two PowerShell scripts, which automate the creation of applications in the Azure Active Directory, and also configure the code for this sample. Once you run them, you will only need to build the solution and you are good to test.
+
+These scripts are:
+
+- `Configure.ps1` which:
+  - creates Azure AD applications and their related objects (permissions, dependencies, secrets),
+  - changes the configuration files in the C# and JavaScript projects.
+  - creates a summary file named `createdApps.html` in the folder from which you ran the script, and containing, for each Azure AD application it created:
+    - the identifier of the application
+    - the AppId of the application
+    - the url of its registration in the [Azure portal](https://portal.azure.com).
+
+- `Cleanup.ps1` which cleans-up the Azure AD objects created by `Configure.ps1`. Note that this script does not revert the changes done in the configuration files, though. You will need to undo the change from source control (from Visual Studio, or from the command line using, for instance, git reset).
+
+### Usage pattern for tests and DevOps scenarios
+
+The `Configure.ps1` will stop if it tries to create an Azure AD application which already exists in the tenant. For this, if you are using the script to try/test the sample, or in DevOps scenarios, you might want to run `Cleanup.ps1` just before `Configure.ps1`. This is what is shown in the steps below.
+
+## How to use the app creation scripts?
+
+### Pre-requisites
+
+To use the app creation scripts:
+
+1. Open PowerShell (On Windows, press  `Windows-R` and type `PowerShell` in the search window)
+2. Navigate to the root directory of the project.
+3. Until you change it, the default Execution Policy for scripts is usually `Restricted`. In order to run the PowerShell script you need to set the Execution Policy to `Unrestricted`. You can set this just for the current PowerShell process by running the command:
+    ```PowerShell
+    Set-ExecutionPolicy -Scope Process -ExecutionPolicy Unrestricted
+    ```
+4. If you have never done it already, in the PowerShell window, install the AzureAD PowerShell modules. For this, type:
+    ```PowerShell
+    Install-Module AzureAD
+    ```
+5. Go to the `AppCreationScripts` sub-folder. From the folder where you cloned the repo,
+    ```PowerShell
+    cd AppCreationScripts
+    ```
+6. Run the scripts. See below for the [four options](#four-ways-to-run-the-script) to do that.
+7. Open the Visual Studio solution, and in the solution's context menu, choose **Set Startup Projects**.
+8. select **Start** for the projects
+
+You're done. this just works!
+
+### Four ways to run the script
+
+We advise four ways of running the script:
+
+- Interactive: you will be prompted for credentials, and the scripts decide in which tenant to create the objects,
+- non-interactive: you will provide crendentials, and the scripts decide in which tenant to create the objects,
+- Interactive in specific tenant: you will be prompted for credentials, and the scripts decide in which tenant to create the objects,
+- non-interactive in specific tenant: you will provide crendentials, and the scripts decide in which tenant to create the objects.
+
+Here are the details on how to do this.
+
+#### Option 1 (interactive)
+
+- Just run ``. .\Configure.ps1``, and you will be prompted to sign-in (email address, password, and if needed MFA).
+- The script will be run as the signed-in user and will use the tenant in which the user is defined.
+
+Note that the script will choose the tenant in which to create the applications, based on the user. Also to run the `Cleanup.ps1` script, you will need to re-sign-in.
+
+#### Option 2 (non-interactive)
+
+When you know the indentity and credentials of the user in the name of whom you want to create the applications, you can use the non-interactive approach. It's more adapted to DevOps. Here is an example of script you'd want to run in a PowerShell Window
+
+```PowerShell
+$secpasswd = ConvertTo-SecureString "[Password here]" -AsPlainText -Force
+$mycreds = New-Object System.Management.Automation.PSCredential ("[login@tenantName here]", $secpasswd)
+. .\Cleanup.ps1 -Credential $mycreds
+. .\Configure.ps1 -Credential $mycreds
+```
+
+Of course, in real life, you might already get the password as a `SecureString`. You might also want to get the password from KeyVault.
+
+#### Option 3 (Interactive, but create apps in a specified tenant)
+
+  if you want to create the apps in a particular tenant, you can use the following option:
+- open the [Azure portal](https://portal.azure.com)
+- Select the Azure Active directory you are interested in (in the combo-box below your name on the top right of the browser window)
+- Find the "Active Directory" object in this tenant
+- Go to **Properties** and copy the content of the **Directory Id** property
+- Then use the full syntax to run the scripts:
+
+```PowerShell
+$tenantId = "yourTenantIdGuid"
+. .\Cleanup.ps1 -TenantId $tenantId
+. .\Configure.ps1 -TenantId $tenantId
+```
+
+#### Option 4 (non-interactive, and create apps in a specified tenant)
+
+This option combines option 2 and option 3: it creates the application in a specific tenant. See option 3 for the way to get the tenant Id. Then run:
+
+```PowerShell
+$secpasswd = ConvertTo-SecureString "[Password here]" -AsPlainText -Force
+$mycreds = New-Object System.Management.Automation.PSCredential ("[login@tenantName here]", $secpasswd)
+$tenantId = "yourTenantIdGuid"
+. .\Cleanup.ps1 -Credential $mycreds -TenantId $tenantId
+. .\Configure.ps1 -Credential $mycreds -TenantId $tenantId
+```

AppCreationScripts/Cleanup.ps1

@@ -1,25 +1,14 @@
-param([PSCredential]$Credential, [string]$TenantId)
+param([Parameter(Mandatory=$false)][PSCredential]$Credential=$null, [Parameter(Mandatory=$false)][string]$TenantId)
 Import-Module AzureAD
 $ErrorActionPreference = 'Stop'
 
-Function RemoveUser([string]$alias)
-{
-    $userPrincipal = "$appName-$alias@$tenantName"
-    $user = Get-AzureADUser -Filter "UserPrincipalName eq '$userPrincipal'"
-    if ($user)
-    {
-        Write-Host "Removing User '($userPrincipal)'"
-        Remove-AzureADUser -ObjectId $user.ObjectId
-    }
-}
-
 Function Cleanup
 {
 <#
 .Description
 This function removes the Azure AD applications for the sample. These applications were created by the Configure.ps1 script
 #>
-    [CmdletBinding()]
+   [CmdletBinding()]
     param(
         [Parameter(HelpMessage='Tenant ID (This is a GUID which represents the "Directory ID" of the AzureAD tenant into which you want to create the apps')]
         [PSCredential] $Credential,
@@ -31,23 +20,15 @@ This function removes the Azure AD applications for the sample. These applicatio
     # $tenantId is the Active Directory Tenant. This is a GUID which represents the "Directory ID" of the AzureAD tenant 
     # into which you want to create the apps. Look it up in the Azure portal in the "Properties" of the Azure AD. 
 
-    # Login to Azure PowerShell (interactive if credentials are not already provided: 
+    # Login to Azure PowerShell (interactive if credentials are not already provided:
     # you'll need to sign-in with creds enabling your to create apps in the tenant)
-    if (!$Credential)
+    if (!$Credential -and $TenantId)
     {
-        if (!$tenantId)
-        {
-            $creds = Connect-AzureAD
-        }
-        else
-        {
-          $creds = Connect-AzureAD -TenantId $tenantId
-        }
-
+        $creds = Connect-AzureAD -TenantId $tenantId
     }
     else
     {
-        if (!$tenantId)
+        if (!$TenantId)
         {
             $creds = Connect-AzureAD -Credential $Credential
         }
@@ -62,41 +43,43 @@ This function removes the Azure AD applications for the sample. These applicatio
         $tenantId = $creds.Tenant.Id
     }
     $tenant = Get-AzureADTenantDetail
-    $tenantName =  $tenant.VerifiedDomains[0].Name
-
-    . .\Config.ps1
-
+    $tenantName =  ($tenant.VerifiedDomains | Where { $_._Default -eq $True }).Name
+
     # Removes the applications
-    Write-Host "Removing Applications"
-    $app=Get-AzureADApplication -Filter "identifierUris/any(uri:uri eq '$downstreamWebApiAppIdURI')"  
+    Write-Host "Cleaning-up applications from tenant '$tenantName'"
+
+    Write-Host "Removing 'downstreamService' (DownstreamService-OBO-CA) if needed"
+    $app=Get-AzureADApplication -Filter "identifierUris/any(uri:uri eq 'https://$tenantName/DownstreamService-OBO-CA')"  
     if ($app)
     {
-        Write-Host "Removing Application '$downstreamWebApiAppIdURI'"
         Remove-AzureADApplication -ObjectId $app.ObjectId
+        Write-Host "Removed."
     }
-
-	$app=Get-AzureADApplication -Filter "identifierUris/any(uri:uri eq '$todoListServiceWebApiAppIdURI')"  
+
+    Write-Host "Removing 'service' (TodoListService-OBO-CA) if needed"
+    $app=Get-AzureADApplication -Filter "identifierUris/any(uri:uri eq 'https://$tenantName/TodoListService-OBO-CA')"  
     if ($app)
     {
-        Write-Host "Removing Application '$todoListServiceWebApiAppIdURI'"
         Remove-AzureADApplication -ObjectId $app.ObjectId
+        Write-Host "Removed."
     }
 
-	$app=Get-AzureADApplication -Filter "DisplayName eq '$todoListClientName'"  
+    Write-Host "Removing 'client' (TodoListClient-DotNet-OBO-CA) if needed"
+    $app=Get-AzureADApplication -Filter "DisplayName eq 'TodoListClient-DotNet-OBO-CA'"  
     if ($app)
     {
-        Write-Host "Removing Application '$todoListClientName'"
         Remove-AzureADApplication -ObjectId $app.ObjectId
+        Write-Host "Removed."
     }
 
-	$app=Get-AzureADApplication -Filter "DisplayName eq '$todoListSPAClientName'"  
+    Write-Host "Removing 'spa' (TodoListSPA-OBO-CA) if needed"
+    $app=Get-AzureADApplication -Filter "identifierUris/any(uri:uri eq 'https://$tenantName/TodoListSPA-OBO-CA')"  
     if ($app)
     {
-        Write-Host "Removing Application '$todoListSPAClientName'"
         Remove-AzureADApplication -ObjectId $app.ObjectId
+        Write-Host "Removed."
     }
 
-    Write-Host "Done."
    }
 }