ASP.NET Core – MVC Web Application – Azure

# [Choice] .NET version: 6.0-focal, 3.1-focal
ARG VARIANT="6.0-focal"
FROM mcr.microsoft.com/vscode/devcontainers/dotnet:0-${VARIANT}

# [Choice] Node.js version: none, lts/*, 18, 16, 14
ARG NODE_VERSION="lts/*"
RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi

# [Optional] Uncomment this section to install additional OS packages.
# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
#     && apt-get -y install --no-install-recommends <your-package-list-here>

# [Optional] Uncomment this line to install global node packages.
RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g azure-functions-core-tools@4 --unsafe-perm true" 2>&1

version: '3'

services:
  app:
    build: 
      context: .
      dockerfile: Dockerfile
      args:
        # Update 'VARIANT' to pick a version of .NET: 3.1-focal, 6.0-focal
        VARIANT: "6.0-focal"
        # Optional version of Node.js
        NODE_VERSION: "lts/*"

    volumes:
      - ..:/workspace:cached

    # Overrides default command so things don't shut down after the process ends.
    command: sleep infinity

    # Runs app on the same network as the database container, allows "forwardPorts" in devcontainer.json function.
    network_mode: service:azurite

    # Uncomment the next line to use a non-root user for all processes.
    # user: vscode

    # Use "forwardPorts" in **devcontainer.json** to forward an app port locally. 
    # (Adding the "ports" property to this file will not forward from a Codespace.)

  azurite:
    image: mcr.microsoft.com/azure-storage/azurite
    restart: unless-stopped
    command: "azurite -d /opt/azurite/azurite_logs.txt"

    # Add "forwardPorts": ["1433"] to **devcontainer.json** to forward MSSQL locally.
    # (Adding the "ports" property to this file will not forward from a Codespace.)

// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
// https://github.com/microsoft/vscode-dev-containers/tree/v0.238.0/containers/dotnet-mssql
{
    "name": "C# (.NET) and Azurite",
    "dockerComposeFile": "docker-compose.yml",
    "service": "app",
    "workspaceFolder": "/workspace",

    // Configure tool-specific properties.
    "customizations": {
        // Configure properties specific to VS Code.
        "vscode": {
            // Set *default* container specific settings.json values on container create.
            "settings": {},
            
            // Add the IDs of extensions you want installed when the container is created.
            "extensions": [
                "ms-dotnettools.csharp",
                "ms-azuretools.vscode-azurefunctions"
            ]
        }
    },

    // Use 'forwardPorts' to make a list of ports inside the container available locally.
    "forwardPorts": [10000, 10001, 10002],

    // [Optional] To reuse of your local HTTPS dev cert:
    //
    // 1. Export it locally using this command:
    //    * Windows PowerShell:
    //        dotnet dev-certs https --trust; dotnet dev-certs https -ep "$env:USERPROFILE/.aspnet/https/aspnetapp.pfx" -p "SecurePwdGoesHere"
    //    * macOS/Linux terminal:
    //        dotnet dev-certs https --trust; dotnet dev-certs https -ep "${HOME}/.aspnet/https/aspnetapp.pfx" -p "SecurePwdGoesHere"
    // 
    // 2. Uncomment these 'remoteEnv' lines:
    //    "remoteEnv": {
    //        "ASPNETCORE_Kestrel__Certificates__Default__Password": "SecurePwdGoesHere",
    //        "ASPNETCORE_Kestrel__Certificates__Default__Path": "/home/vscode/.aspnet/https/aspnetapp.pfx",
    //    },
    //
    // 3. Next, copy your certificate into the container:
    //      1. Start the container
    //      2. Drag ~/.aspnet/https/aspnetapp.pfx into the root of the file explorer
    //      3. Open a terminal in VS Code and run "mkdir -p /home/vscode/.aspnet/https && mv aspnetapp.pfx /home/vscode/.aspnet/https"

    // postCreateCommand.sh parameters: $1=SA password, $2=dacpac path, $3=sql script(s) path
    
    "features": {
        "github-cli": "latest",
        "azure-cli": "latest"
    }

}

DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;QueueEndpoint=http://127.0.0.1:10001/devstoreaccount1;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1;

dotnet new sln
mv workspace.sln azure-storage-todos-demo.sln

dotnet new mvc --auth SingleOrg --calls-graph -o AzureStorageTodos.Web
dotnet sln add ./AzureStorageTodos.Web/
dotnet dev-certs https --trust

dotnet new classlib -o AzureStorageTodos.Models
dotnet new classlib -o AzureStorageTodos.Repository
dotnet new classlib -o AzureStorageTodos.Service

dotnet sln add ./AzureStorageTodos.Models
dotnet sln add ./AzureStorageTodos.Repository
dotnet sln add ./AzureStorageTodos.Service

cd AzureStorageTodos.Repository
dotnet add reference ../AzureStorageTodos.Models/

cd ..

cd AzureStorageTodos.Service
dotnet add reference ../AzureStorageTodos.Models/
dotnet add reference ../AzureStorageTodos.Repository/

cd ..

cd AzureStorageTodos.Web
dotnet add reference ../AzureStorageTodos.Models/
dotnet add reference ../AzureStorageTodos.Repository/
dotnet add reference ../AzureStorageTodos.Service/

cd ..

cd AzureStorageTodos.Repository
dotnet add package Azure.Storage.Blobs
dotnet add package Azure.Data.Tables
dotnet add package Azure.Storage.Queues

cd ..

cd AzureStorageTodos.Web
dotnet add package Azure.Storage.Blobs
dotnet add package Azure.Data.Tables
dotnet add package Azure.Storage.Queues
dotnet add package Microsoft.Extensions.Azure

cd ..

mkdir AzureStorageTodos.AzureFunctions
cd AzureStorageTodos.AzureFunctions
func init (select options 1, and 1)

func new (select option 1, and then give it the name of TodoUpdated)

dotnet add package Microsoft.Azure.Functions.Extensions
dotnet add package Microsoft.Extensions.DependencyInjection
dotnet add package Microsoft.Extensions.Azure
dotnet add package Azure.Identity
dotnet add package Azure.Storage.Blobs
dotnet add reference ../AzureStorageTodos.Models/
dotnet add reference ../AzureStorageTodos.Repository/
dotnet add reference ../AzureStorageTodos.Service/

dotnet sln add /workspace/AzureStorageTodos.AzureFunctions/

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "command": "dotnet",
            "type": "process",
            "args": [
                "build",
                "${workspaceFolder}/AzureStorageTodos.Web/AzureStorageTodos.Web.csproj",
                "/property:GenerateFullPaths=true",
                "/consoleloggerparameters:NoSummary"
            ],
            "problemMatcher": "$msCompile"
        },
        {
            "label": "publish",
            "command": "dotnet",
            "type": "process",
            "args": [
                "publish",
                "${workspaceFolder}/AzureStorageTodos.Web/AzureStorageTodos.Web.csproj",
                "/property:GenerateFullPaths=true",
                "/consoleloggerparameters:NoSummary"
            ],
            "problemMatcher": "$msCompile"
        },
        {
            "label": "watch",
            "command": "dotnet",
            "type": "process",
            "args": [
                "watch",
                "run",
                "--project",
                "${workspaceFolder}/AzureStorageTodos.Web/AzureStorageTodos.Web.csproj"
            ],
            "problemMatcher": "$msCompile"
        },
        {
            "label": "clean (functions)",
            "options": {
                "cwd": "${workspaceFolder}/AzureStorageTodos.AzureFunctions"
            },
            "command": "dotnet",
            "args": [
              "clean",
              "/property:GenerateFullPaths=true",
              "/consoleloggerparameters:NoSummary"
            ],
            "type": "process",
            "problemMatcher": "$msCompile"
          },
          {
            "label": "build (functions)",
            "options": {
                "cwd": "${workspaceFolder}/AzureStorageTodos.AzureFunctions"
            },
            "command": "dotnet",
            "args": [
              "build",
              "/property:GenerateFullPaths=true",
              "/consoleloggerparameters:NoSummary"
            ],
            "type": "process",
            "dependsOn": "clean (functions)",
            "group": {
              "kind": "build",
              "isDefault": true
            },
            "problemMatcher": "$msCompile"
          },
          {
            "type": "func",
            "dependsOn": "build (functions)",
            "options": {
              "cwd": "${workspaceFolder}/AzureStorageTodos.AzureFunctions/bin/Debug/net6.0"
            },
            "command": "host start",
            "isBackground": true,
            "problemMatcher": "$func-dotnet-watch"
          }
    ]
}

{
    "version": "0.2.0",
    "configurations": [
        {
            // Use IntelliSense to find out which attributes exist for C# debugging
            // Use hover for the description of the existing attributes
            // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
            "name": ".NET Core Launch (web)",
            "type": "coreclr",
            "request": "launch",
            "preLaunchTask": "build",
            // If you have changed target frameworks, make sure to update the program path.
            "program": "${workspaceFolder}/AzureStorageTodos.Web/bin/Debug/net6.0/AzureStorageTodos.Web.dll",
            "args": [],
            "cwd": "${workspaceFolder}/AzureStorageTodos.Web",
            "stopAtEntry": false,
            // Enable launching a web browser when ASP.NET Core starts. For more information: https://aka.ms/VSCode-CS-LaunchJson-WebBrowser
            "serverReadyAction": {
                "action": "openExternally",
                "pattern": "\\bNow listening on:\\s+(https?://\\S+)"
            },
            "env": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            },
            "sourceFileMap": {
                "/Views": "${workspaceFolder}/Views"
            }
        },
        {
            "name": ".NET Core Attach",
            "type": "coreclr",
            "request": "attach"
        },
        {
            "name": "Attach to .NET Functions",
            "type": "coreclr",
            "request": "attach",
            "processId": "${command:azureFunctions.pickProcess}"
        },
    ],
    "compounds": [
        {
            "name": "Attach to functions and launch web app",
            "configurations": [".NET Core Launch (web)", "Attach to .NET Functions"],
            "stopAll": true
        }
    ]
}

namespace AzureStorageTodos.Models.Interface;

public interface IBaseAzureStorageEntityModel
{
    public string Id {get; set;}
}

using AzureStorageTodos.Models.Interface;

namespace AzureStorageTodos.Models;

public class BaseAzureStorageEntityModel : IBaseAzureStorageEntityModel
{
    public BaseAzureStorageEntityModel()
    {
        this.Id = Guid.NewGuid().ToString();        
    }

    public BaseAzureStorageEntityModel(string id)
    {
        this.Id = id;        
    }

    public string Id {get; set;}
}

namespace AzureStorageTodos.Models;

public class UserEntityModel : BaseAzureStorageEntityModel
{    
    public string DisplayName {get; set;} = null!;
    public string EmailAddress {get; set;} = null!;    
}

namespace AzureStorageTodos.Models;

public class TodoEntityModel : BaseAzureStorageEntityModel
{
    public string OwnerUserId {get; set;} = null!;
    public string? Title { get; set; }
    public string? Description { get; set; }
    public bool Completed { get; set; } = false;    
}

namespace AzureStorageTodos.Models;

public class TodoListEntityModel : BaseAzureStorageEntityModel
{
    public TodoListEntityModel(string ownerUserId, string listType)
    {
        this.Id = $"{ownerUserId}-{listType}";
        this.OwnerUserId = ownerUserId;
        this.Results = new List<TodoEntityModel>();
    }

    public string OwnerUserId {get; set;} = null!;
    public IEnumerable<TodoEntityModel> Results {get; set;} = null!;
}

using AzureStorageTodos.Models.Interface;

namespace AzureStorageTodos.Repository.Interface;

public interface IAzureStorageRepository<T> where T : IBaseAzureStorageEntityModel
{
    Task<T?> UpsertAsync(T entityDetails);
    Task<T?> GetOneAsync(string id);
    Task<List<T>?> GetAllAsync();
    Task DeleteAsync(string id);
}

using Azure;
using Azure.Data.Tables;
using System.Reflection;
using AzureStorageTodos.Models.Interface;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Repository.BaseRepositories;

public abstract class AzureTableStorageRepository<T> : IAzureStorageRepository<T> where T : IBaseAzureStorageEntityModel
{
    private readonly TableServiceClient _tableServiceClient;
    private readonly string _tableName;
    private readonly string _partitionKey;

    public AzureTableStorageRepository(TableServiceClient tableServiceClient, string tableName, string partitionKey)
    {
        _tableServiceClient = tableServiceClient;
        _tableName = tableName;
        _partitionKey = partitionKey;
    }

    public async Task DeleteAsync(string id)
    {
        var tableClient = await GetTableClientAsync();

        await tableClient.DeleteEntityAsync(_partitionKey, id);
    }

    public async Task<List<T>?> GetAllAsync()
    {
        var tableClient = await GetTableClientAsync();

        var results = new List<T>();

        Pageable<TableEntity> queryResults = tableClient.Query<TableEntity>(w => w.PartitionKey == _partitionKey);

        foreach (var qEntity in queryResults)
        {
            if (qEntity is not null)
            {
                var result = TableEntityToEntity(qEntity);
                if (result is not null)
                {
                    results.Add(result);
                }
            }
        }

        return results;
    }

    public async Task<T?> GetOneAsync(string id)
    {
        var tableClient = await GetTableClientAsync();

        var tableEntity = await tableClient.GetEntityAsync<TableEntity>(_partitionKey, id);

        if (tableEntity is not null)
        {
            var result = TableEntityToEntity(tableEntity);

            if (result is not null)
            {
                return result;
            }
        }

        return default(T);
    }

    public async Task<T?> UpsertAsync(T entityDetails)
    {
        var tableClient = await GetTableClientAsync();

        var tableEntity = EntityToTableEntity(entityDetails);

        await tableClient.UpsertEntityAsync(tableEntity);

        return entityDetails;
    }

    private TableEntity EntityToTableEntity(T entity)
    {
        var result = new TableEntity();
        result.PartitionKey = _partitionKey;

        Type t = typeof(T);
        PropertyInfo[] entityProperties = t.GetProperties();

        foreach (var entityProperty in entityProperties)
        {

            var propertyName = entityProperty.Name;

            if (propertyName == "Id")
            {
                result.RowKey = entity.Id;
            }
            else
            {
                var propertyValue = entityProperty.GetValue(entity);

                result[propertyName] = propertyValue;
            }

        }

        return result;
    }    

    private T TableEntityToEntity(TableEntity tableEntity)
    {
        var result = (T)Activator.CreateInstance<T>();

        Type t = typeof(T);
        PropertyInfo[] entityProperties = t.GetProperties();

        foreach (var entityProperty in entityProperties)
        {

            var propertyName = entityProperty.Name;

            if (propertyName == "Id")
            {
                result.Id = tableEntity.RowKey;
            }
            else
            {

                var propertyValue = tableEntity[propertyName];

                entityProperty.SetValue(result, propertyValue);
            }
        }

        return result;
    }

    private async Task<TableClient> GetTableClientAsync()
    {
        var tableClient = _tableServiceClient.GetTableClient(_tableName);
        await tableClient.CreateIfNotExistsAsync();

        return tableClient;
    }
}

using Azure.Storage.Blobs;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Repository.BaseRepositories;

public class BlobStorageService : IBlobStorageService
{
    private readonly BlobServiceClient _blobServiceClient;
    private readonly string _containerName;

    public BlobStorageService(BlobServiceClient blobServiceClient, string containerName)
    {
        _blobServiceClient = blobServiceClient;
        _containerName = containerName;
    }

    public async Task DeleteDocumentAsync(string blobName)
    {
        var containerClient = await GetContainerClientAsync();

        var blobClient = containerClient.GetBlobClient(blobName);

        await blobClient.DeleteAsync();
    }

    public async Task<Stream> GetBlobContentAsync(string blobName)
    {
        var containerClient = await GetContainerClientAsync();

        var blobClient = containerClient.GetBlobClient(blobName);

        return await blobClient.OpenReadAsync();
    }

    public async Task<List<string>?> GetListOfBlobsInFolderAsync(string folderName)
    {
        var results = new List<string>();

        var containerClient = await GetContainerClientAsync();

        var blobsInFolder = containerClient.GetBlobs(prefix: folderName);

        if(blobsInFolder is not null) {
            foreach(var blob in blobsInFolder) {
                results.Add(blob.Name);
            }

            return results;
        }

        return null;
    }

    public async Task UpdateBlobContentAsync(string blobName, Stream content)
    {
        var containerClient = await GetContainerClientAsync();

        var blobClient = containerClient.GetBlobClient(blobName);

        await blobClient.UploadAsync(content, true);
    }

    private async Task<BlobContainerClient> GetContainerClientAsync()
    {
        var blobContainerClient = _blobServiceClient.GetBlobContainerClient(_containerName);

        await blobContainerClient.CreateIfNotExistsAsync();

        return blobContainerClient;
    }
}

using System.Text.Json;
using Azure.Storage.Blobs;
using AzureStorageTodos.Models.Interface;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Repository.BaseRepositories;

public abstract class AzureBlobStorageRepository<T> : IAzureStorageRepository<T> where T : IBaseAzureStorageEntityModel
{
    private readonly IBlobStorageService _blobStorageService;    
    private readonly string _folderName;

    public AzureBlobStorageRepository(BlobServiceClient blobServiceClient, string containerName, string folderName)
    {
        _blobStorageService = new BlobStorageService(blobServiceClient, containerName);
        _folderName = folderName;
    }

    public async Task DeleteAsync(string id)
    {
        string filePath = GetFilePath(id);

        await _blobStorageService.DeleteDocumentAsync(filePath);
    }

    public async Task<List<T>?> GetAllAsync()
    {
        try {
            List<string>? filesInFolder = await _blobStorageService.GetListOfBlobsInFolderAsync(_folderName);

            if(filesInFolder is not null) {
                var results = new List<T>();

                foreach(var file in filesInFolder) {
                    var id = GetIdFromFilePath(file);
                    try {
                        var result = await this.GetOneAsync(id);
                        if(result is not null) {
                            results.Add(result);
                        }
                    }
                    catch {
                        // Do nothing, try to get the next one
                    }
                }

                return results;
            }
        }
        catch {
            // Do nothing, will return null
        }

        return null;
    }

    public async Task<T?> GetOneAsync(string id)
    {
        try {
            string filePath = GetFilePath(id);

            var blobContent = await _blobStorageService.GetBlobContentAsync(filePath);

            var contentAsObject = JsonSerializer.Deserialize<T>(blobContent);

            return contentAsObject;
        }
        catch {
            // Do nothing, will return null
        }

        return default(T);
    }

    public async Task<T?> UpsertAsync(T entityDetails)
    {
        try {
            string filePath = GetFilePath(entityDetails.Id);

            var entityDetailsAsString = JsonSerializer.Serialize(entityDetails, new JsonSerializerOptions { WriteIndented = true });

            if(entityDetails is not null) {
                var entityDetailsAsStream = new MemoryStream();
                var streamWriter = new StreamWriter(entityDetailsAsStream);
                streamWriter.Write(entityDetailsAsString);
                streamWriter.Flush();
                entityDetailsAsStream.Position = 0;

                await _blobStorageService.UpdateBlobContentAsync(filePath, entityDetailsAsStream);

                return entityDetails;
            }
        }
        catch {
            // Do nothing, return null
        }

        return default(T);
    }

    private string GetFilePath(string id)
    {
        string filePath = string.Join('/', _folderName, $"{id}.json");

        return filePath;
    }

    private string GetIdFromFilePath(string filePath)
    {
        string[] fileParts = filePath.Split('/');
        string lastPart = fileParts.Last();
        string[] fileNameParts = lastPart.Split('.');
        string idPart = fileNameParts.First();

        return idPart;
    }
}

using AzureStorageTodos.Models;

namespace AzureStorageTodos.Repository.Interface;

public interface IUsersRepository : IAzureStorageRepository<UserEntityModel>
{
}

using AzureStorageTodos.Models;

namespace AzureStorageTodos.Repository.Interface;

public interface ITodosRepository : IAzureStorageRepository<TodoEntityModel>
{
}

using AzureStorageTodos.Models;

namespace AzureStorageTodos.Repository.Interface;

public interface ITodoListRepository : IAzureStorageRepository<TodoListEntityModel>
{    
}

namespace AzureStorageTodos.Repository;

public static class StaticBlobContainerNames
{
    public const string TodoLists = "todo-lists";
}

namespace AzureStorageTodos.Repository;

public static class StaticBlobFolderNames
{
    public const string TodoListItems = "todolist-items";
}

namespace AzureStorageTodos.Repository;

public static class StaticTableNames
{
    public const string TodoUsers = "TodoUsers";
    public const string Todos = "Todos";
}

namespace AzureStorageTodos.Repository;

public static class StaticTableRowKeys
{
    public const string UserItems = "UserItems";
    public const string TodoItems = "TodoItems";
}

namespace AzureStorageTodos.Repository;

public static class StaticQueueNames
{
    public const string TodoUpdated = "TodoUpdated";
}

namespace AzureStorageTodos.Repository;

public static class StaticTodoListIds
{
    public const string All = "All";
    public const string Complete = "Complete";
    public const string Incomplete = "Incomplete";
}

using Azure.Data.Tables;
using AzureStorageTodos.Models;
using AzureStorageTodos.Repository.BaseRepositories;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Repository.Repositories;

public class UsersRepository : AzureTableStorageRepository<UserEntityModel>, IUsersRepository
{
    public UsersRepository(TableServiceClient tableServiceClient) : base(tableServiceClient, StaticTableNames.TodoUsers, StaticTableRowKeys.UserItems)
    {        
    }
}

using Azure.Data.Tables;
using AzureStorageTodos.Models;
using AzureStorageTodos.Repository.BaseRepositories;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Repository.Repositories;

public class TodosRepository : AzureTableStorageRepository<TodoEntityModel>, ITodosRepository
{
    public TodosRepository(TableServiceClient tableServiceClient) : base(tableServiceClient, StaticTableNames.Todos, StaticTableRowKeys.TodoItems)
    {        
    }
}

using Azure.Storage.Blobs;
using AzureStorageTodos.Models;
using AzureStorageTodos.Repository.BaseRepositories;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Repository.Repositories;

public class TodoListRepository : AzureBlobStorageRepository<TodoListEntityModel>, ITodoListRepository
{
    public TodoListRepository(BlobServiceClient blobServiceClient) : base(blobServiceClient, StaticBlobContainerNames.TodoLists, StaticBlobFolderNames.TodoListItems)
    {        
    }
}

namespace AzureStorageTodos.Repository.Interface;

public interface IAzureQueueStorageService
{
    public Task SendMessageAsync(string message);
}

using Azure.Storage.Queues;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Repository.BaseRepositories;

public abstract class AzureQueueStorageService : IAzureQueueStorageService
{
    private readonly QueueServiceClient _queueServiceClient;
    private readonly string _queueName;

    public AzureQueueStorageService(QueueServiceClient queueServiceClient, string queueName)
    {
        _queueServiceClient = queueServiceClient;
        _queueName = queueName;
    }

    public async Task SendMessageAsync(string message)
    {
        var queueClient = await GetQueueClientAsync();        
        await queueClient.SendMessageAsync(message);
    }

    private async Task<QueueClient> GetQueueClientAsync()
    {
        var queueClient = _queueServiceClient.GetQueueClient(_queueName);        
        await queueClient.CreateIfNotExistsAsync();

        return queueClient;                
    }
}

namespace AzureStorageTodos.Repository.Interface;

public interface ITodoUpdatedQueue : IAzureQueueStorageService
{
}

using Azure.Storage.Queues;
using AzureStorageTodos.Repository.Interface;
using AzureStorageTodos.Repository.BaseRepositories;

namespace AzureStorageTodos.Repository.Repositories;

public class TodoUpdatedQueue : AzureQueueStorageService, ITodoUpdatedQueue
{
    public TodoUpdatedQueue(QueueServiceClient queueServiceClient) : base (queueServiceClient, StaticQueueNames.TodoUpdated)
    {        
    }
}

using AzureStorageTodos.Models.Interface;

namespace AzureStorageTodos.Service.Interface;

public interface IAzureStorageRepositoryClient<T> where T : IBaseAzureStorageEntityModel
{
    Task<T?> UpsertAsync(T entityDetails);
    Task<T?> GetOneAsync(string id);
    Task<List<T>?> GetAllAsync();
    Task DeleteAsync(string id);
}

using AzureStorageTodos.Models.Interface;
using AzureStorageTodos.Repository.Interface;
using AzureStorageTodos.Service.Interface;

namespace AzureStorageTodos.Service.BaseRepositoryClients;

public abstract class AzureStorageRepsoitoryClient<T> : IAzureStorageRepositoryClient<T> where T : IBaseAzureStorageEntityModel
{
    private readonly IAzureStorageRepository<T> _repository;

    public AzureStorageRepsoitoryClient(IAzureStorageRepository<T> repository)
    {
        _repository = repository;
    }

    public virtual Task DeleteAsync(string id)
    {
        try {
            return _repository.DeleteAsync(id);
        }
        catch {
            // Do nothing
        }
        
        return Task.CompletedTask;
    }

    public virtual async Task<List<T>?> GetAllAsync()
    {
        try {
            return await _repository.GetAllAsync();
        }
        catch {
            // Do nothing, return null
        }

        return null;
    }

    public virtual async Task<T?> GetOneAsync(string id)
    {
        try {
            return await _repository.GetOneAsync(id);
        }
        catch {
            // Do nothing, return null
        }

        return default(T);
    }

    public virtual async Task<T?> UpsertAsync(T entityDetails)
    {
        try {
            var results = await _repository.UpsertAsync(entityDetails);

            return results;
        }
        catch {
            // Do nothing, return null
        }

        return default(T);
    }
}

using AzureStorageTodos.Models;

namespace AzureStorageTodos.Service.Interface;

public interface IUsersRepositoryClient : IAzureStorageRepositoryClient<UserEntityModel>
{
}

using AzureStorageTodos.Models;

namespace AzureStorageTodos.Service.Interface;

public interface ITodosRepositoryClient : IAzureStorageRepositoryClient<TodoEntityModel>
{    
}

using AzureStorageTodos.Models;

namespace AzureStorageTodos.Service.Interface;

public interface ITodoListRepositoryClient : IAzureStorageRepositoryClient<TodoListEntityModel>
{
}

using AzureStorageTodos.Models;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.BaseRepositoryClients;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Service.RepositoryClients;

public class UsersRepositoryClient : AzureStorageRepsoitoryClient<UserEntityModel>, IUsersRepositoryClient
{
    public UsersRepositoryClient(IUsersRepository usersRepository) : base(usersRepository)
    {        
    }
}

using AzureStorageTodos.Models;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.BaseRepositoryClients;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Service.RepositoryClients;

public class TodosRepositoryClient : AzureStorageRepsoitoryClient<TodoEntityModel>, ITodosRepositoryClient
{
    public TodosRepositoryClient(ITodosRepository todosRepository) : base(todosRepository)
    {        
    }
}

using AzureStorageTodos.Models;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.BaseRepositoryClients;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Service.RepositoryClients;

public class TodoListRepositoryClient : AzureStorageRepsoitoryClient<TodoListEntityModel>, ITodoListRepositoryClient
{
    public TodoListRepositoryClient(ITodoListRepository todoListRepository) : base(todoListRepository)
    {
    }
}

namespace AzureStorageTodos.Service.Interface;

public interface ITodoListManager
{
    public Task RefreshTodoListsForUserAsync(string userId);
}

using AzureStorageTodos.Models;
using AzureStorageTodos.Repository;
using AzureStorageTodos.Service.Interface;

namespace AzureStorageTodos.Service.Services;

public class TodoListManager : ITodoListManager
{
    private readonly ITodosRepositoryClient _todosRepositoryClient;
    private readonly ITodoListRepositoryClient _todoListRepositoryClient;

    public TodoListManager(ITodosRepositoryClient todosRepositoryClient, ITodoListRepositoryClient todoListRepositoryClient)
    {
        _todosRepositoryClient = todosRepositoryClient;
        _todoListRepositoryClient = todoListRepositoryClient;
    }

    public async Task RefreshTodoListsForUserAsync(string userId)
    {
        var allTodosInRepository = await _todosRepositoryClient.GetAllAsync();

        if(allTodosInRepository is not null) 
        {
            var allTodosForUser = allTodosInRepository.Where(w => w.OwnerUserId == userId).ToList();

            var allTodosListEntity = new TodoListEntityModel(userId, StaticTodoListIds.All);
            var completedTodosListEntity = new TodoListEntityModel(userId, StaticTodoListIds.Complete);
            var incompleteTodosListEntity = new TodoListEntityModel(userId, StaticTodoListIds.Incomplete);

            if(allTodosForUser is not null)
            {
                allTodosListEntity.Results = allTodosForUser;
                completedTodosListEntity.Results = allTodosForUser.Where(w => w.Completed == true).ToList();
                incompleteTodosListEntity.Results = allTodosForUser.Where(w => w.Completed == false).ToList();

                await _todoListRepositoryClient.UpsertAsync(allTodosListEntity);
                await _todoListRepositoryClient.UpsertAsync(completedTodosListEntity);
                await _todoListRepositoryClient.UpsertAsync(incompleteTodosListEntity);
            }
        }        
    }
}

using AzureStorageTodos.Models;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.BaseRepositoryClients;
using AzureStorageTodos.Repository.Interface;

namespace AzureStorageTodos.Service.RepositoryClients;

public class TodosRepositoryClient : AzureStorageRepsoitoryClient<TodoEntityModel>, ITodosRepositoryClient
{
    private readonly ITodosRepository _todosRepository;
    private readonly ITodoUpdatedQueue _todoUpdatedQueue;

    public TodosRepositoryClient(ITodosRepository todosRepository, ITodoUpdatedQueue todoUpdatedQueue) : base(todosRepository)
    {
        _todosRepository = todosRepository;
        _todoUpdatedQueue = todoUpdatedQueue;
    }

    public override async Task<TodoEntityModel?> UpsertAsync(TodoEntityModel entityDetails)
    {
        var results = await base.UpsertAsync(entityDetails);

        await _todoUpdatedQueue.SendMessageAsync($"Todo Updated For User: {entityDetails.OwnerUserId}");

        return results;
    }

    public override async Task DeleteAsync(string id)
    {
        var currentDetails = await this.GetOneAsync(id);

        if(currentDetails is not null) 
        {
            await base.DeleteAsync(id);

            await _todoUpdatedQueue.SendMessageAsync($"Todo Updated For User: {currentDetails.OwnerUserId}");
        }        
    }
}

using Azure.Identity;
using Microsoft.Extensions.Azure;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;
using AzureStorageTodos.Repository.Interface;
using AzureStorageTodos.Repository.Repositories;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.RepositoryClients;
using AzureStorageTodos.Service.Services;

[assembly: FunctionsStartup(typeof(AzureStorageTodos.AzureFunctions.Startup))]

namespace AzureStorageTodos.AzureFunctions;

public class Startup : FunctionsStartup
{
    public override void Configure(IFunctionsHostBuilder builder)
    {
        var config = builder.GetContext().Configuration;

        string azureWebJobsStorage = config.GetValue<string>("AzureWebJobsStorage");

        // Register Azure Clients
        builder.Services.AddAzureClients(azureClientsBuilder => {
            azureClientsBuilder.AddTableServiceClient(azureWebJobsStorage);
            azureClientsBuilder.AddBlobServiceClient(azureWebJobsStorage);
            
            azureClientsBuilder.UseCredential(new DefaultAzureCredential());
        });

        // Register Repositories
        builder.Services.AddTransient<ITodosRepository, TodosRepository>();
        builder.Services.AddTransient<ITodoListRepository, TodoListRepository>();

        // Register Services
        builder.Services.AddTransient<ITodosRepositoryClient, TodosRepositoryClient>();
        builder.Services.AddTransient<ITodoListRepositoryClient, TodoListRepositoryClient>();
        builder.Services.AddTransient<ITodoListManager, TodoListManager>();
    }
}

using System;
using System.Linq;
using System.Threading.Tasks;
using AzureStorageTodos.Repository;
using AzureStorageTodos.Service.Interface;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace AzureStorageTodos.AzureFunctions
{
    public class TodoUpdated
    {
        private readonly ITodoListManager _todoListManager;

        public TodoUpdated(ITodoListManager todoListManager)
        {
            _todoListManager = todoListManager;
        }

        [FunctionName("TodoUpdated")]
        public async Task Run([QueueTrigger(StaticQueueNames.TodoUpdated, Connection = "AzureWebJobsStorage")]string queueMessage, ILogger log)
        {
            string[] queueMessageParts = queueMessage.Split(": ");
            string updatedOwnerUserId = queueMessageParts.Last();

            await _todoListManager.RefreshTodoListsForUserAsync(updatedOwnerUserId);
        }
    }
}

using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using AzureStorageTodos.Models;
using AzureStorageTodos.Service.Interface;

public class WebAppOpenIdConnectEvents : OpenIdConnectEvents
{
    public WebAppOpenIdConnectEvents()
    {
        this.OnTicketReceived = async ctx => {
            if(ctx.Principal is not null) 
            {
                var myPrincipal = ctx.Principal;

                var uidClaim = myPrincipal.Claims.FirstOrDefault(w => w.Type == "uid");
                var nameClaim = myPrincipal.Claims.FirstOrDefault(w => w.Type == "name");
                var emailClaim = myPrincipal.Claims.FirstOrDefault(w => w.Type == "preferred_username");

                if (uidClaim is not null && nameClaim is not null && emailClaim is not null)
                {
                    var usersRepositoryClient = ctx.HttpContext.RequestServices.GetRequiredService<IUsersRepositoryClient>();

                    var userEntity = new UserEntityModel
                    {
                        Id = uidClaim.Value,
                        DisplayName = nameClaim.Value,
                        EmailAddress = emailClaim.Value
                    };

                    await usersRepositoryClient.UpsertAsync(userEntity);
                }
            }

            await Task.Yield();
        };     
    }
}

using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.AspNetCore.Mvc.Authorization;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.UI;
using Graph = Microsoft.Graph;
using Microsoft.Extensions.Azure;
using Azure.Identity;
using AzureStorageTodos.Repository.Interface;
using AzureStorageTodos.Repository.BaseRepositories;
using AzureStorageTodos.Repository.Repositories;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.RepositoryClients;
using AzureStorageTodos.Service.Services;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
var initialScopes = builder.Configuration["DownstreamApi:Scopes"]?.Split(' ');

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(options => {
        options.Instance = builder.Configuration["AzureAd:Instance"];
        options.Domain = builder.Configuration["AzureAd:Domain"];
        options.TenantId = builder.Configuration["AzureAd:TenantId"];
        options.ClientId = builder.Configuration["AzureAd:ClientId"];
        options.ClientSecret = builder.Configuration["AzureAd:ClientSecret"];
        options.CallbackPath = builder.Configuration["AzureAd:CallbackPath"];

        options.Events = new WebAppOpenIdConnectEvents();
    })
    .EnableTokenAcquisitionToCallDownstreamApi(initialScopes)
        .AddMicrosoftGraph(builder.Configuration.GetSection("DownstreamApi"))
        .AddInMemoryTokenCaches();

builder.Services.AddControllersWithViews(options =>
{
    var policy = new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build();
    options.Filters.Add(new AuthorizeFilter(policy));
});
builder.Services.AddRazorPages()
    .AddMicrosoftIdentityUI();

// Register Azure Clients
builder.Services.AddAzureClients(azureClientsBuilder => {
    string azureStorageConnectionString = builder.Configuration.GetConnectionString("AzureStorage");

    azureClientsBuilder.AddTableServiceClient(azureStorageConnectionString);
    azureClientsBuilder.AddBlobServiceClient(azureStorageConnectionString);
    azureClientsBuilder.AddQueueServiceClient(azureStorageConnectionString);
    
    azureClientsBuilder.UseCredential(new DefaultAzureCredential());
});

// Register Repositories
builder.Services.AddTransient<IUsersRepository, UsersRepository>();
builder.Services.AddTransient<ITodosRepository, TodosRepository>();
builder.Services.AddTransient<ITodoListRepository, TodoListRepository>();
builder.Services.AddTransient<ITodoUpdatedQueue, TodoUpdatedQueue>();

// Register Services
builder.Services.AddTransient<IUsersRepositoryClient, UsersRepositoryClient>();
builder.Services.AddTransient<ITodosRepositoryClient, TodosRepositoryClient>();
builder.Services.AddTransient<ITodoListRepositoryClient, TodoListRepositoryClient>();
builder.Services.AddTransient<ITodoListManager, TodoListManager>();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.MapRazorPages();

app.Run();

using AzureStorageTodos.Models;

namespace AzureStorageTodos.Web.Models;

public class TodosHomePageViewModel
{
    public IEnumerable<TodoEntityModel>? AllTodos {get; set;}
    public IEnumerable<TodoEntityModel>? CompletedTodos {get; set;}
    public IEnumerable<TodoEntityModel>? IncompleteTodos {get; set;}
}

using AzureStorageTodos.Models;
using AzureStorageTodos.Repository;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Web.Models;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace AzureStorageTodos.Web.Controllers;

[Authorize]
public class TodosController : Controller
{
    private readonly ITodoListRepositoryClient _todoListRepositoryClient;
    private readonly ITodosRepositoryClient _todosRepositoryClient;

    public TodosController(ITodoListRepositoryClient todoListRepositoryClient, ITodosRepositoryClient todosRepositoryClient)
    {
        _todoListRepositoryClient = todoListRepositoryClient;
        _todosRepositoryClient = todosRepositoryClient;
    }

    [HttpGet]
    public async Task<IActionResult> Index()
    {
        TodosHomePageViewModel todosHomePageViewModel = new TodosHomePageViewModel();

        
        var currentUser = this.HttpContext.User;

        var currentUserUserIdClaim = currentUser.Claims.Where(w => w.Type == "uid").FirstOrDefault();

        if(currentUserUserIdClaim is not null) 
        {
            var currentUserUserIdValue = currentUserUserIdClaim.Value;

            var allFileId = $"{currentUserUserIdValue}-{StaticTodoListIds.All}";
            var completedFileId = $"{currentUserUserIdValue}-{StaticTodoListIds.Complete}";
            var incompleteFileId = $"{currentUserUserIdValue}-{StaticTodoListIds.Incomplete}";

            var allTodos = await _todoListRepositoryClient.GetOneAsync(allFileId);
            var completedTods = await _todoListRepositoryClient.GetOneAsync(completedFileId);
            var incompleteTodos = await _todoListRepositoryClient.GetOneAsync(incompleteFileId);

            if(allTodos is not null) 
            {
                todosHomePageViewModel.AllTodos = allTodos.Results;                
            }

            if(completedTods is not null) 
            {
                todosHomePageViewModel.CompletedTodos = completedTods.Results;
            }

            if(incompleteTodos is not null) 
            {
                todosHomePageViewModel.IncompleteTodos = incompleteTodos.Results;
            }
        }        

        return View(todosHomePageViewModel);
    }

    [HttpGet]
    public async Task<IActionResult> Details(string id)
    {
        var currentDetails = await _todosRepositoryClient.GetOneAsync(id);

        if(currentDetails is null)
        {
            return NotFound();
        }

        return View(currentDetails);
    }

    [HttpGet]
    public IActionResult Create()
    {
        TodoEntityModel newTodoEntityModel = new TodoEntityModel();

        var currentUser = this.HttpContext.User;

        var currentUserUserIdClaim = currentUser.Claims.Where(w => w.Type == "uid").FirstOrDefault();

        if(currentUserUserIdClaim is not null) 
        {
            var currentUserUserIdValue = currentUserUserIdClaim.Value;

            newTodoEntityModel.OwnerUserId = currentUserUserIdValue;            
        }

        return View(newTodoEntityModel);
    }

    [HttpPost]
    public async Task<IActionResult> Create(TodoEntityModel todoEntityModel)
    {
        if(ModelState.IsValid)
        {
            await _todosRepositoryClient.UpsertAsync(todoEntityModel);

            return RedirectToAction(nameof(Index));
        }

        return View(todoEntityModel);
    }

    [HttpGet]
    public async Task<IActionResult> Edit([FromRoute] string id)
    {
        var currentDetails = await _todosRepositoryClient.GetOneAsync(id);

        if(currentDetails is null)
        {
            return NotFound();            
        }

        return View(currentDetails);
    }

    [HttpPost]
    public async Task<IActionResult> Edit([FromForm] TodoEntityModel todoEntityModel)
    {
        if(ModelState.IsValid)
        {
            await _todosRepositoryClient.UpsertAsync(todoEntityModel);

            return RedirectToAction(nameof(Index));
        }

        return View(todoEntityModel);
    }

    [HttpGet]
    public async Task<IActionResult> Delete([FromRoute] string id)
    {
        var currentDetails = await _todosRepositoryClient.GetOneAsync(id);

        if(currentDetails is null)
        {
            return NotFound();            
        }

        return View(currentDetails);                
    }

    [HttpPost]
    public async Task<IActionResult> Delete([FromForm] TodoEntityModel todoEntityModel)
    {
        await _todosRepositoryClient.DeleteAsync(todoEntityModel.Id);

        return RedirectToAction(nameof(Index));
    }
}

@model AzureStorageTodos.Models.TodoEntityModel

<tr>
    <td>@Html.DisplayFor(m => m.Title)</td>
    <td>@Html.DisplayFor(m => m.Description)</td>
    <td>@Html.DisplayFor(m => m.Completed)</td>
    <td>
        <a asp-action="Details" asp-controller="Todos" asp-route-id="@Model.Id">Details</a> | 
        <a asp-action="Edit" asp-controller="Todos" asp-route-id="@Model.Id">Edit</a> | 
        <a asp-action="Delete" asp-controller="Todos" asp-route-id="@Model.Id">Delete</a>
    </td>
</tr>

@model List<AzureStorageTodos.Models.TodoEntityModel>

<table class="table table-bordered">
    <thead>
        <tr>
            <th>Title</th>
            <th>Description</th>
            <th>Completed</th>
            <th> </th>
        </tr>
    </thead>
    <tbody>
        @foreach(var todo in Model) 
        {
            if(todo is not null) 
            {
                @Html.DisplayFor(m => todo, "ListOfTodosListItem")
            }            
        }
    </tbody>
</table>

@model AzureStorageTodos.Web.Models.TodosHomePageViewModel

<ul class="nav nav-tabs" id="TodoListsTab" role="tablist">

    <li class="nav-item" role="presentation">
        <button class="nav-link active" id="all-tab" data-bs-toggle="tab" data-bs-target="#AllTodos" type="button" role="tab" aria-controls="AllTodos" aria-selected="true">All</button>
    </li>

    <li class="nav-item" role="presentation">
        <button class="nav-link" id="completed-tab" data-bs-toggle="tab" data-bs-target="#CompletedTodos" type="button" role="tab" aria-controls="CompletedTodos">Completed</button>
    </li>

    <li class="nav-item" role="presentation">
        <button class="nav-link" id="incomplete-tab" data-bs-toggle="tab" data-bs-target="#IncompleteTodos" type="button" role="tab" aria-controls="IncompleteTodos">Incomplete</button>
    </li>

</ul>
<div class="tab-content p-4" id="TodosListContent">

    <div class="tab-pane fade show active" id="AllTodos" role="tabpanel" aria-labelledby="all-tab">
        @if(Model.AllTodos is not null)
        {
            @Html.DisplayFor(m => m.AllTodos, "ListOfTodos")
        }        
    </div>

    <div class="tab-pane fade" id="CompletedTodos" role="tabpanel" aria-labelledby="completed-tab">
        @if(Model.CompletedTodos is not null)
        {
            @Html.DisplayFor(m => m.CompletedTodos, "ListOfTodos")
        }        
    </div>

    <div class="tab-pane fade" id="IncompleteTodos" role="tabpanel" aria-labelledby="incomplete-tab">
        @if(Model.IncompleteTodos is not null)
        {
           @Html.DisplayFor(m => m.IncompleteTodos, "ListOfTodos")
        }        
    </div>    

</div>

@model AzureStorageTodos.Models.TodoEntityModel

<dl>
    <dt>@Html.DisplayNameFor(m => m.Id)</dt>
    <dd>@Html.DisplayFor(m => m.Id)</dd>

    <dt>@Html.DisplayNameFor(m => m.OwnerUserId)</dt>
    <dd>@Html.DisplayFor(m => m.OwnerUserId)</dd>

    <dt>@Html.DisplayNameFor(m => m.Title)</dt>
    <dd>@Html.DisplayFor(m => m.Title)</dd>

    <dt>@Html.DisplayNameFor(m => m.Description)</dt>
    <dd>@Html.DisplayFor(m => m.Description)</dd>

    <dt>@Html.DisplayNameFor(m => m.Completed)</dt>
    <dd>@Html.DisplayFor(m => m.Completed)</dd>
</dl>

@model AzureStorageTodos.Models.TodoEntityModel

@Html.HiddenFor(m => m.OwnerUserId)
<div class="form-group">
    <label asp-for="Id"></label>
    <input class="form-control" asp-for="Id" readonly />
</div>
<div class="form-group">
    <label asp-for="Title"></label>
    <input class="form-control" asp-for="Title" />
</div>
<div class="form-group">
    <label asp-for="Description"></label>
    <textarea class="form-control" asp-for="Description"></textarea>
</div>
<div class="form-group">
    <label asp-for="Completed"></label>
    @Html.EditorFor(m => m.Completed)
</div>

<input class="btn btn-primary" type="submit" value="Save" />

@model AzureStorageTodos.Web.Models.TodosHomePageViewModel

@{
    ViewData["Title"] = "Todos";
}

<h1>@ViewData["Title"]</h1>

<a class="btn btn-primary mb-4" asp-action="Create" asp-controller="Todos">Create</a>
<p class="text-info mb-4">* If you recently made changes to a Todo, the effects may not be immediate while the Azure Function Rebuilds the List. Refresh the page a few times after making changes.</p>

@Html.DisplayForModel()

@model AzureStorageTodos.Models.TodoEntityModel
@{
    ViewData["Title"] = "Todo Details";
}

<h1>@ViewData["Title"]</h1>

<a class="mb-4" asp-action="Index" asp-controller="Todos">Return to List</a>

@Html.DisplayForModel()

@model AzureStorageTodos.Models.TodoEntityModel
@{
    ViewData["Title"] = "Delete Todo";
}

<h1>@ViewData["Title"]</h1>

<a class="mb-4" asp-action="Index" asp-controller="Todos">Return to List</a>

@Html.DisplayForModel()

<form asp-action="Delete" method="POST">
    @Html.HiddenFor(m => m.Id)
    @Html.HiddenFor(m => m.OwnerUserId)
    @Html.HiddenFor(m => m.Title)
    @Html.HiddenFor(m => m.Description)
    @Html.HiddenFor(m => m.Completed)
    <input class="btn btn-danger" type="submit" value="Confirm" />
</form>

@model AzureStorageTodos.Models.TodoEntityModel

@{
    ViewData["Title"] = "Create Todo";
}

<h1>@ViewData["Title"]</h1>

<a class="mb-4" asp-action="Index" asp-controller="Todos">Return to List</a>

<form asp-action="Create" asp-controller="Todos" method="post">
    @Html.EditorForModel()
</form>

@model AzureStorageTodos.Models.TodoEntityModel
@{
    ViewData["Title"] = "Edit Todo";
}

<h1>@ViewData["Title"]</h1>

<a class="mb-4" asp-action="Index" asp-controller="Todos">Return to List</a>

<form asp-action="Edit" asp-controller="Todos" method="post">
    @Html.EditorForModel()
</form>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>@ViewData["Title"] - AzureStorageTodos.Web</title>
    <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
    <link rel="stylesheet" href="~/css/site.css" asp-append-version="true" />
    <link rel="stylesheet" href="~/AzureStorageTodos.Web.styles.css" asp-append-version="true" />
</head>
<body>
    <header>
        <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
            <div class="container-fluid">
                <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">AzureStorageTodos.Web</a>
                <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
                        aria-expanded="false" aria-label="Toggle navigation">
                    <span class="navbar-toggler-icon"></span>
                </button>
                <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                    <ul class="navbar-nav flex-grow-1">
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Todos" asp-action="Index">Todos</a>
                        </li>
                    </ul>
                    <partial name="_LoginPartial" />
                </div>
            </div>
        </nav>
    </header>
    <div class="container">
        <main role="main" class="pb-3">
            @RenderBody()
        </main>
    </div>

    <footer class="border-top footer text-muted">
        <div class="container">
            © 2022 - AzureStorageTodos.Web - <a asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
        </div>
    </footer>
    <script src="~/lib/jquery/dist/jquery.min.js"></script>
    <script src="~/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
    <script src="~/js/site.js" asp-append-version="true"></script>
    @await RenderSectionAsync("Scripts", required: false)
</body>
</html>

"AzureAd": {
    "Instance": "https://login.microsoftonline.com/",

{
  "DownstreamApi": {
    "BaseUrl": "https://graph.microsoft.com/v1.0",
    "Scopes": "user.read"
  },
  "ConnectionStrings": {
    "AzureStorage": "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;QueueEndpoint=http://127.0.0.1:10001/devstoreaccount1;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

{
  "DownstreamApi": {
    "BaseUrl": "https://graph.microsoft.com/v1.0",
    "Scopes": "user.read"
  },  
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

az login

APPCONFIG_CONNECTION_STRING=Connection string from <Address in your address bar>
ASPNETCORE_ENVIRONMENT=Development

APPCONFIG_CONNECTION_STRING=<Connection string that you just copied from the portal (without the angle brackets)>
ASPNETCORE_ENVIRONMENT=Development

env_file: devcontainer.env

version: '3'

services:
  app:
    env_file: devcontainer.env
    build: 
      context: .
      dockerfile: Dockerfile
      args:
        # Update 'VARIANT' to pick a version of .NET: 3.1-focal, 6.0-focal
        VARIANT: "6.0-focal"
        # Optional version of Node.js
        NODE_VERSION: "lts/*"

    volumes:
      - ..:/workspace:cached

    # Overrides default command so things don't shut down after the process ends.
    command: sleep infinity

    # Runs app on the same network as the database container, allows "forwardPorts" in devcontainer.json function.
    network_mode: service:azurite

    # Uncomment the next line to use a non-root user for all processes.
    # user: vscode

    # Use "forwardPorts" in **devcontainer.json** to forward an app port locally. 
    # (Adding the "ports" property to this file will not forward from a Codespace.)

  azurite:
    image: mcr.microsoft.com/azure-storage/azurite
    restart: unless-stopped
    command: "azurite -d /opt/azurite/azurite_logs.txt"

    # Add "forwardPorts": ["1433"] to **devcontainer.json** to forward MSSQL locally.
    # (Adding the "ports" property to this file will not forward from a Codespace.)

echo $APPCONFIG_CONNECTION_STRING
echo $ASPNETCORE_ENVIRONMENT

dotnet dev-certs https --trust
dotnet restore
az login

cd AzureStroageTodos.Web
dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore

cd ..
cd AzureStorageTods.AzureFunctions
dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore

using Microsoft.Extensions.Configuration.AzureAppConfiguration;

string? appConfigConnectionString = Environment.GetEnvironmentVariable("APPCONFIG_CONNECTION_STRING");
string? aspNetCoreEnvironmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");

builder.Host.ConfigureAppConfiguration(configurationBuilder => {
    if(appConfigConnectionString is not null && aspNetCoreEnvironmentName is not null) 
    {
        configurationBuilder.AddAzureAppConfiguration(azureAppConfigurationOptions => {
            azureAppConfigurationOptions.Connect(appConfigConnectionString)
            .Select(KeyFilter.Any, LabelFilter.Null)
            .Select(KeyFilter.Any, aspNetCoreEnvironmentName)
            .ConfigureKeyVault(kv =>
            {
                kv.SetCredential(new DefaultAzureCredential());
            });
        });
    }
});

using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.AspNetCore.Mvc.Authorization;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.UI;
using Graph = Microsoft.Graph;
using Microsoft.Extensions.Azure;
using Azure.Identity;
using AzureStorageTodos.Repository.Interface;
using AzureStorageTodos.Repository.BaseRepositories;
using AzureStorageTodos.Repository.Repositories;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.RepositoryClients;
using AzureStorageTodos.Service.Services;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;

var builder = WebApplication.CreateBuilder(args);

string? appConfigConnectionString = Environment.GetEnvironmentVariable("APPCONFIG_CONNECTION_STRING");
string? aspNetCoreEnvironmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");

builder.Host.ConfigureAppConfiguration(configurationBuilder => {
    if(appConfigConnectionString is not null && aspNetCoreEnvironmentName is not null) 
    {
        configurationBuilder.AddAzureAppConfiguration(azureAppConfigurationOptions => {
            azureAppConfigurationOptions.Connect(appConfigConnectionString)
            .Select(KeyFilter.Any, LabelFilter.Null)
            .Select(KeyFilter.Any, aspNetCoreEnvironmentName)
            .ConfigureKeyVault(kv =>
            {
                kv.SetCredential(new DefaultAzureCredential());
            });
        });
    }
});

// Add services to the container.
var initialScopes = builder.Configuration["DownstreamApi:Scopes"]?.Split(' ');

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(options => {
        options.Instance = builder.Configuration["AzureAd:Instance"];
        options.Domain = builder.Configuration["AzureAd:Domain"];
        options.TenantId = builder.Configuration["AzureAd:TenantId"];
        options.ClientId = builder.Configuration["AzureAd:ClientId"];
        options.ClientSecret = builder.Configuration["AzureAd:ClientSecret"];
        options.CallbackPath = builder.Configuration["AzureAd:CallbackPath"];

        options.Events = new WebAppOpenIdConnectEvents();
    })
    .EnableTokenAcquisitionToCallDownstreamApi(initialScopes)
        .AddMicrosoftGraph(builder.Configuration.GetSection("DownstreamApi"))
        .AddInMemoryTokenCaches();

builder.Services.AddControllersWithViews(options =>
{
    var policy = new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build();
    options.Filters.Add(new AuthorizeFilter(policy));
});
builder.Services.AddRazorPages()
    .AddMicrosoftIdentityUI();

// Register Azure Clients
builder.Services.AddAzureClients(azureClientsBuilder => {
    string azureStorageConnectionString = builder.Configuration.GetConnectionString("AzureStorage");    

    azureClientsBuilder.AddTableServiceClient(azureStorageConnectionString);
    azureClientsBuilder.AddBlobServiceClient(azureStorageConnectionString);
    azureClientsBuilder.AddQueueServiceClient(azureStorageConnectionString).ConfigureOptions(queueOptions => {
        queueOptions.MessageEncoding = Azure.Storage.Queues.QueueMessageEncoding.Base64;
    });    
    
    azureClientsBuilder.UseCredential(new DefaultAzureCredential());
});

// Register Repositories
builder.Services.AddTransient<IUsersRepository, UsersRepository>();
builder.Services.AddTransient<ITodosRepository, TodosRepository>();
builder.Services.AddTransient<ITodoListRepository, TodoListRepository>();
builder.Services.AddTransient<ITodoUpdatedQueue, TodoUpdatedQueue>();

// Register Services
builder.Services.AddTransient<IUsersRepositoryClient, UsersRepositoryClient>();
builder.Services.AddTransient<ITodosRepositoryClient, TodosRepositoryClient>();
builder.Services.AddTransient<ITodoListRepositoryClient, TodoListRepositoryClient>();
builder.Services.AddTransient<ITodoListManager, TodoListManager>();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.MapRazorPages();

app.Run();

    public override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
    {
        string appConfigConnectionString = Environment.GetEnvironmentVariable("APPCONFIG_CONNECTION_STRING");
        string aspNetCoreEnvironmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
        
        builder.ConfigurationBuilder.AddAzureAppConfiguration(azureAppConfigurationBuilder => {
            azureAppConfigurationBuilder.Connect(appConfigConnectionString)
            .Select(KeyFilter.Any, LabelFilter.Null)
            .Select(KeyFilter.Any, aspNetCoreEnvironmentName)
            .ConfigureKeyVault(kv =>
            {
                kv.SetCredential(new DefaultAzureCredential());
            });           
        });
                
        base.ConfigureAppConfiguration(builder);
    }

using Azure.Identity;
using Microsoft.Extensions.Azure;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;
using AzureStorageTodos.Repository.Interface;
using AzureStorageTodos.Repository.Repositories;
using AzureStorageTodos.Service.Interface;
using AzureStorageTodos.Service.RepositoryClients;
using AzureStorageTodos.Service.Services;
using System;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;

[assembly: FunctionsStartup(typeof(AzureStorageTodos.AzureFunctions.Startup))]

namespace AzureStorageTodos.AzureFunctions;

public class Startup : FunctionsStartup
{
    public override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
    {
        string appConfigConnectionString = Environment.GetEnvironmentVariable("APPCONFIG_CONNECTION_STRING");
        string aspNetCoreEnvironmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
        
        builder.ConfigurationBuilder.AddAzureAppConfiguration(azureAppConfigurationBuilder => {
            azureAppConfigurationBuilder.Connect(appConfigConnectionString)
            .Select(KeyFilter.Any, LabelFilter.Null)
            .Select(KeyFilter.Any, aspNetCoreEnvironmentName)
            .ConfigureKeyVault(kv =>
            {
                kv.SetCredential(new DefaultAzureCredential());
            });           
        });
                
        base.ConfigureAppConfiguration(builder);
    }

    public override void Configure(IFunctionsHostBuilder builder)
    {
        var config = builder.GetContext().Configuration;

        string azureWebJobsStorage = config.GetValue<string>("AzureWebJobsStorage");

        // Register Azure Clients
        builder.Services.AddAzureClients(azureClientsBuilder => {
            azureClientsBuilder.AddTableServiceClient(azureWebJobsStorage);
            azureClientsBuilder.AddBlobServiceClient(azureWebJobsStorage);
            
            azureClientsBuilder.UseCredential(new DefaultAzureCredential());
        });

        // Register Repositories
        builder.Services.AddTransient<ITodosRepository, TodosRepository>();
        builder.Services.AddTransient<ITodoListRepository, TodoListRepository>();

        // Register Services
        builder.Services.AddTransient<ITodosRepositoryClient, TodosRepositoryClient>();
        builder.Services.AddTransient<ITodoListRepositoryClient, TodoListRepositoryClient>();
        builder.Services.AddTransient<ITodoListManager, TodoListManager>();
    }
}

dotnet new gitignore

# Dev Container Environment
devcontainer.env

* text=auto eol=lf

# Azure Storage Todos
After cloning this repository. Open it in Visual Studio Code and when prompted say "No" to re-open in container at first. 

In order to configure your dev container to connect to our Azure App Configuration go to the .devcontainer folder. Make a copy of devcontainer.env.example and name it devcontainer.env. Copy the connection string from the link provided there to properly configure your APPCONFIG_CONNECTION_STRING environment variable.

Once you have a valid connection string do a CTRL+SHIFT+P to bring up the command pallet and select the option to re-open in container from there.

Once your container is built and Visual Studio Code is running from the container do a CTRL+SHIFT+` to bring up a command prompt from the container.

Execute the following commands (these commands will likely need to be done any time you rebuild the dev container):

```bash
dotnet restore
dotnet dev-certs https --trust
az login
gh auth login
```

After you have successfully logged in to the Azure CLI in your dev container you will be able to download the App Configuration and User Secrets for Development.

git init
git add .
git commit -a -m "Initial Commit"

gh auth login

gh repo create

# This workflow will build and push a .NET Core app to an Azure Web App when a commit is pushed to your default branch.
#
# This workflow assumes you have already created the target Azure App Service web app.
# For instructions see https://docs.microsoft.com/en-us/azure/app-service/quickstart-dotnetcore?tabs=net60&pivots=development-environment-vscode
#
# To configure this workflow:
#
# 1. Download the Publish Profile for your Azure Web App. You can download this file from the Overview page of your Web App in the Azure Portal.
#    For more information: https://docs.microsoft.com/en-us/azure/app-service/deploy-github-actions?tabs=applevel#generate-deployment-credentials
#
# 2. Create a secret in your repository named AZURE_WEBAPP_PUBLISH_PROFILE, paste the publish profile contents as the value of the secret.
#    For instructions on obtaining the publish profile see: https://docs.microsoft.com/azure/app-service/deploy-github-actions#configure-the-github-secret
#
# 3. Change the value for the AZURE_WEBAPP_NAME. Optionally, change the AZURE_WEBAPP_PACKAGE_PATH and DOTNET_VERSION environment variables below.
#
# For more information on GitHub Actions for Azure: https://github.com/Azure/Actions
# For more information on the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
# For more samples to get started with GitHub Action workflows to deploy to Azure: https://github.com/Azure/actions-workflow-samples

name: Build and deploy ASP.Net Core app to an Azure Web App

env:
  AZURE_WEBAPP_NAME: sw-storage-todos-demo    # set this to the name of your Azure Web App
  AZURE_FUNCTIONAPP_NAME: sw-storage-todos-demo-functions  # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: './myapp'      # set this to the path to your web app project, defaults to the repository root
  AZURE_FUNCTIONAPP_PACKAGE_PATH: './myfunctions'    # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                 # set this to the .NET Core version to use

on:
  push:
    branches:
      - "master"
  workflow_dispatch:

permissions:
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Set up .NET Core
        uses: actions/setup-dotnet@v2
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}
      
      - name: Set up dependency caching for faster builds
        uses: actions/cache@v3
        with:
          path: ~/.nuget/packages
          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
          restore-keys: |
            ${{ runner.os }}-nuget-

      - name: Build with dotnet
        run: dotnet build $GITHUB_WORKSPACE/AzureStorageTodos.Web/AzureStorageTodos.Web.csproj /property:GenerateFullPaths=true --configuration Release

      - name: dotnet publish
        run: dotnet publish $GITHUB_WORKSPACE/AzureStorageTodos.Web/AzureStorageTodos.Web.csproj /property:GenerateFullPaths=true -c Release -o ${{env.DOTNET_ROOT}}/myapp

      - name: Build function
        run: dotnet build $GITHUB_WORKSPACE/AzureStorageTodos.AzureFunctions/AzureStorageTodos_AzureFunctions.csproj /property:GenerateFullPaths=true --configuration Release --output ${{env.DOTNET_ROOT}}/myfunctions      

      - name: Upload web app artifact for deployment job
        uses: actions/upload-artifact@v3
        with:
          name: .net-app
          path: ${{env.DOTNET_ROOT}}/myapp

      - name: Upload functions app artificat for deployment job
        uses: actions/upload-artifact@v3
        with:
          name: .net-functions
          path: ${{env.DOTNET_ROOT}}/myfunctions

  deploy:
    permissions:
      contents: none
    runs-on: ubuntu-latest
    needs: build
    environment:
      name: 'Development'
      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}

    steps:
      - name: Download web app artifact from build job
        uses: actions/download-artifact@v3
        with:
          name: .net-app
          path: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

      - name: Download functions app artificat from build job
        uses: actions/download-artifact@v3
        with:
          name: .net-functions
          path: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}

      - name: Deploy to Azure Web App
        id: deploy-to-webapp
        uses: azure/webapps-deploy@v2
        with:
          app-name: ${{ env.AZURE_WEBAPP_NAME }}
          publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
          package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

      - name: Deploy to Azure Functions
        uses: Azure/functions-action@v1
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}          
          publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
          package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}