adding .net project

Author: JFolberth

YAML/demo_environment_template.yml

@@ -22,15 +22,23 @@ parameters:
       environmentDefinitionName: 'DemoApp'
       environmentType: 'CICD'
       regionAbrvs: ['eus']
+- name: projectNamesConfigurations
+  type: object
+  default:
+    - projectName: 'todo'
+      publishWebProject: true
+      dotnetTest: false
+      
 
 
 stages:
-- template: stages/bicep_build_stage.yml@templates
+- template: stages/bicep_dotnet_build_stage.yml@templates
   parameters:
     environmentObjects: ${{ parameters.environmentObjects }}
     templateFileName: ${{ parameters.templateFileName }}
     serviceName: ${{ parameters.serviceName }}
     templateDirectory: ${{ parameters.templateDirectory }}
+    projectNamesConfigurations: ${{ parameters.projectNamesConfigurations }}
 - template: stages/ade_loadtest_stage.yml@templates
   parameters:
     adeObjects: ${{ parameters.adeObjects }}

src/.dockerignore

@@ -0,0 +1,8 @@
+# directories
+**/bin/
+**/obj/
+**/out/
+
+# files
+Dockerfile*
+**/*.md

src/Controllers/ItemController.cs

@@ -0,0 +1,106 @@
+namespace todo.Controllers
+{
+    using System;
+    using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Mvc;
+    using todo.Models;
+
+    public class ItemController : Controller
+    {
+        private readonly ICosmosDbService _cosmosDbService;
+        public ItemController(ICosmosDbService cosmosDbService)
+        {
+            _cosmosDbService = cosmosDbService;
+        }
+
+        [ActionName("Index")]
+        public async Task<IActionResult> Index()
+        {
+            return View(await _cosmosDbService.GetItemsAsync("SELECT * FROM c"));
+        }
+
+        [ActionName("Create")]
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ActionName("Create")]
+        [ValidateAntiForgeryToken]
+        public async Task<ActionResult> CreateAsync([Bind("Id,Name,Description,Completed")] Item item)
+        {
+            if (ModelState.IsValid)
+            {
+                item.Id = Guid.NewGuid().ToString();
+                await _cosmosDbService.AddItemAsync(item);
+                return RedirectToAction("Index");
+            }
+
+            return View(item);
+        }
+
+        [HttpPost]
+        [ActionName("Edit")]
+        [ValidateAntiForgeryToken]
+        public async Task<ActionResult> EditAsync([Bind("Id,Name,Description,Completed")] Item item)
+        {
+            if (ModelState.IsValid)
+            {
+                await _cosmosDbService.UpdateItemAsync(item.Id, item);
+                return RedirectToAction("Index");
+            }
+
+            return View(item);
+        }
+
+        [ActionName("Edit")]
+        public async Task<ActionResult> EditAsync(string id)
+        {
+            if (id == null)
+            {
+                return BadRequest();
+            }
+
+            Item item = await _cosmosDbService.GetItemAsync(id);
+            if (item == null)
+            {
+                return NotFound();
+            }
+
+            return View(item);
+        }
+
+        [ActionName("Delete")]
+        public async Task<ActionResult> DeleteAsync(string id)
+        {
+            if (id == null)
+            {
+                return BadRequest();
+            }
+
+            Item item = await _cosmosDbService.GetItemAsync(id);
+            if (item == null)
+            {
+                return NotFound();
+            }
+
+            return View(item);
+        }
+
+        [HttpPost]
+        [ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<ActionResult> DeleteConfirmedAsync([Bind("Id")] string id)
+        {
+            await _cosmosDbService.DeleteItemAsync(id);
+            return RedirectToAction("Index");
+        }
+
+        [ActionName("Details")]
+        public async Task<ActionResult> DetailsAsync(string id)
+        {
+            return View(await _cosmosDbService.GetItemAsync(id));
+        }
+    }
+}

src/Dockerfile

@@ -0,0 +1,19 @@
+# https://hub.docker.com/_/microsoft-dotnet
+FROM mcr.microsoft.com/dotnet/sdk:3.1 AS build
+
+WORKDIR /source
+
+# copy csproj and restore as distinct layers
+COPY *.csproj .
+RUN dotnet restore
+
+# copy and publish app and libraries
+COPY . .
+RUN dotnet publish -c release -o /app --no-restore
+
+# final stage/image
+FROM mcr.microsoft.com/dotnet/aspnet:3.1
+
+WORKDIR /app
+COPY --from=build /app .
+ENTRYPOINT ["dotnet", "todo.dll"]

src/Models/ErrorViewModel.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace todo.Models
+{
+    public class ErrorViewModel
+    {
+        public string RequestId { get; set; }
+
+        public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
+    }
+}

src/Models/Item.cs

@@ -0,0 +1,19 @@
+namespace todo.Models
+{
+    using Newtonsoft.Json;
+
+    public class Item
+    {
+        [JsonProperty(PropertyName = "id")]
+        public string Id { get; set; }
+
+        [JsonProperty(PropertyName = "name")]
+        public string Name { get; set; }
+
+        [JsonProperty(PropertyName = "description")]
+        public string Description { get; set; }
+
+        [JsonProperty(PropertyName = "isComplete")]
+        public bool Completed { get; set; }
+    }
+}

src/Program.cs

@@ -0,0 +1,17 @@
+namespace todo
+{
+    using Microsoft.AspNetCore;
+    using Microsoft.AspNetCore.Hosting;
+
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateWebHostBuilder(args).Build().Run();
+        }
+
+        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseStartup<Startup>();
+    }
+}

src/Services/CosmosDbService.cs

@@ -0,0 +1,66 @@
+namespace todo
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using todo.Models;
+    using Microsoft.Azure.Cosmos;
+    using Microsoft.Azure.Cosmos.Fluent;
+    using Microsoft.Extensions.Configuration;
+
+    public class CosmosDbService : ICosmosDbService
+    {
+        private Container _container;
+
+        public CosmosDbService(
+            CosmosClient dbClient,
+            string databaseName,
+            string containerName)
+        {
+            this._container = dbClient.GetContainer(databaseName, containerName);
+        }
+        
+        public async Task AddItemAsync(Item item)
+        {
+            await this._container.CreateItemAsync<Item>(item, new PartitionKey(item.Id));
+        }
+
+        public async Task DeleteItemAsync(string id)
+        {
+            await this._container.DeleteItemAsync<Item>(id, new PartitionKey(id));
+        }
+
+        public async Task<Item> GetItemAsync(string id)
+        {
+            try
+            {
+                ItemResponse<Item> response = await this._container.ReadItemAsync<Item>(id, new PartitionKey(id));
+                return response.Resource;
+            }
+            catch(CosmosException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
+            { 
+                return null;
+            }
+
+        }
+
+        public async Task<IEnumerable<Item>> GetItemsAsync(string queryString)
+        {
+            var query = this._container.GetItemQueryIterator<Item>(new QueryDefinition(queryString));
+            List<Item> results = new List<Item>();
+            while (query.HasMoreResults)
+            {
+                var response = await query.ReadNextAsync();
+                
+                results.AddRange(response.ToList());
+            }
+
+            return results;
+        }
+
+        public async Task UpdateItemAsync(string id, Item item)
+        {
+            await this._container.UpsertItemAsync<Item>(item, new PartitionKey(id));
+        }
+    }
+}

src/Services/ICosmosDbService.cs

@@ -0,0 +1,15 @@
+namespace todo
+{
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using todo.Models;
+
+    public interface ICosmosDbService
+    {
+        Task<IEnumerable<Item>> GetItemsAsync(string query);
+        Task<Item> GetItemAsync(string id);
+        Task AddItemAsync(Item item);
+        Task UpdateItemAsync(string id, Item item);
+        Task DeleteItemAsync(string id);
+    }
+}

src/Startup.cs

@@ -0,0 +1,90 @@
+namespace todo
+{
+    using System;
+    using System.Threading.Tasks;
+    using Azure.Identity;
+    using Microsoft.AspNetCore.Builder;
+    using Microsoft.AspNetCore.Hosting;
+    using Microsoft.Extensions.Configuration;
+    using Microsoft.Extensions.DependencyInjection;
+    using Microsoft.Extensions.Hosting;
+
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        // <ConfigureServices> 
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddControllersWithViews();
+            services.AddSingleton<ICosmosDbService>(InitializeCosmosClientInstanceAsync(Configuration.GetSection("CosmosDb")).GetAwaiter().GetResult());
+        }
+        // </ConfigureServices> 
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+            else
+            {
+                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.UseAuthorization();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapControllerRoute(
+                    name: "default",
+                    pattern: "{controller=Item}/{action=Index}/{id?}");
+            });
+        }
+
+        // <InitializeCosmosClientInstanceAsync>
+        /// <summary>
+        /// Creates a Cosmos DB database and a container with the specified partition key. 
+        /// </summary>
+        /// <returns></returns>
+        private static async Task<CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
+        {
+            string databaseName = configurationSection.GetSection("DatabaseName").Value;
+            string containerName = configurationSection.GetSection("ContainerName").Value;
+            string account = configurationSection.GetSection("Account").Value;
+
+            // If key is not set, assume we're using managed identity
+            string key = configurationSection.GetSection("Key").Value;
+            ManagedIdentityCredential miCredential;
+            Microsoft.Azure.Cosmos.CosmosClient client;
+            if (string.IsNullOrEmpty(key))
+            {
+                miCredential = new ManagedIdentityCredential();
+                client = new Microsoft.Azure.Cosmos.CosmosClient(account, miCredential);
+            }
+            else
+            {
+                client = new Microsoft.Azure.Cosmos.CosmosClient(account, key);
+            }
+            
+            CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
+            Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
+            await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
+
+            return cosmosDbService;
+        }
+        // </InitializeCosmosClientInstanceAsync>
+    }
+}