<p>Tomorrow, we start another Whole30 eating plan. The last two times I did this, it was both wonderful and horrible. In order to be able to look back on this experience one day and (hopefully) remember it fondly, I am going to attempt to put together a day-by-day activities list of how I ~~survived~~ thrived during what will be my third trip. As with both of the other adventures, this started with a massive shopping trip to Costco and a bunch of food prep.</p>
<h2>Buying a Lot of Chicken &#x26; Produce</h2>
<p>Today was the second trip to Costco since we moved, and the first after coming back from vacation. That meant that this was both an expensive trip and an incomplete trip. I am terrible about thinking that I can just memorize the list, and that I'll pick up everything needed. I failed at that - forgetting (at least) four things and buying (at least) three things that I didn't need.</p>
<h3>Costco Produce</h3>
<ul>
<li>10 lb. bag of whole carrots</li>
<li>5 lb. bag of baby carrots</li>
<li>2 lb. bag of Brussels sprouts</li>
<li>10 lb. golden potatoes</li>
<li>3 pack of cucumbers</li>
<li>container of mushrooms</li>
</ul>
<p>Usually, I will buy at least three bags of the Brussels sprouts, in addition to a 5 pound bag of broccoli and a large bag of yellow onions. However, SparklePony does not want to do either of the latter two right now (while breastfeeding) and is tentative about the former. Instead, we'll have lots and lots of carrots.</p>
<h3>Costco Protein</h3>
<ul>
<li>7 lb. ground beef</li>
<li>Chicken Thighs (6x bags of 4 thighs)</li>
<li>Chicken Boneless/Skinless Breasts (6x bags of 2 breasts)</li>
<li>Chicken "Party Wings" (6x bags)</li>
<li>10 lb. bag of Purdue frozen Chicken breasts</li>
<li>Fresh Salmon</li>
<li>2 dozen Grade AA Organic Eggs</li>
<li>2 dozen Grade AA Eggs</li>
</ul>
<p>I had plenty of Chicken Thighs and Breasts already on hand - so I am going to have to cook a whole lot of those really soon. I probably also didn't need to get both the frozen chicken breasts and the packages of frozen breasts. I am experimenting with seeing if SparklePony will be able to just throw a frozen breast into the microwave and chop it up for lunches. I also get two different kinds of eggs because SparklePony says she can tell the difference between them when fried or scrambled.</p>
<h2>Pantry and Refrigerator Clean-out</h2>
<p>First part of Whole30 prep is to eliminate all non-compliant foods. That means going through the pantry and taking out everything that might be tempting to grab-and-go during the month. I put them all into a bag and hid them somewhere in the house.</p>
<p>Next, I go through the refrigerator. Things that can survive and are worth keeping go into the freezer. Foods and drinks that won't be able to survive the month get eaten (which means I had to finish off a bottle of Pinot Grigio, a block of provolone, and a serving of Farfalle pasta). Anything that I don't want to eat and won't survive the month just get tossed. It really is amazing how empty my refrigerator is after this process.</p>
<h2>Initial Food Prep</h2>
<p>This evening, I took care of a few things:</p>
<ol>
<li>Cook 3 pounds of ground beef with basic seasoning - separate into ½ lb. per deli containers
<ol>
<li>1½ tsp salt</li>
<li>1½ tsp black pepper</li>
<li>1½ tsp garlic powder</li>
<li>1½ tsp chili powder</li>
</ol>
</li>
<li>Freeze remaining ground beef in 2 lb. vacuum sealed bags</li>
<li>Marinate 3 packages (12 pieces) of chicken thighs
<ol>
<li>1 cup olive oil</li>
<li>1 tbsp black pepper</li>
<li>1 tbsp salt</li>
<li>1 tbsp garlic powder</li>
<li>¼ cup coconut aminos</li>
<li>2 tbsp sesame oil</li>
</ol>
</li>
<li>Separate baby carrots into 2 servings per deli container</li>
<li>Hard boil 16 eggs</li>
</ol>
<p>Additionally, there was plenty of rearranging the freezer several times to make everything fit.</p>
<h2>Planning Some Meals</h2>
<p>Breakfast tomorrow (it's a workout day) is going to be simple. I'll bring a potato to work with the ground beef for lunch, and it'll be Salmon for dinner. The marinating chicken will get cooked on Friday, which will provide for leftovers through the weekend and early next week.</p>
<p>Weekend food prep to-do:</p>
<ol>
<li>Peel and slice a <em>lot</em> of carrots</li>
<li>Slice the Brussels sprouts</li>
<li>Slice cucumbers</li>
<li>Go shopping for additional produce
<ol>
<li>Celery (HOW DID I FORGET CELERY ???)</li>
<li>Bell peppers</li>
<li>anything else to add to salads or chili</li>
</ol>
</li>
<li>Pre-bottle salad dressing</li>
<li>Pre-mix spice combinations
<ol>
<li>Taco seasoning</li>
<li>Curry seasoning</li>
</ol>
</li>
</ol>


Whole30 2017 - Day 0: Buying the Costco Chicken Farm

<p>These are some notes that I typed up during an Azure Machine Learning - Data Camp that I attended at the Microsoft learning center in the Aon building. It was entertaining, informative, and all around a great session; unfortunately, it was entirely useless for my job, since this really has nothing to do with the work that I perform. On the plus side - I was able to recommend to my co-workers on the Analytics team that <em>they</em> should attend it.</p>
<p>Ross Loforte, Data Scientist, Microsoft
https://github.com/melzoghbi/datacamp</p>
<ul>
<li>
<p>Data science is about using <em>data</em> to <em>make decisions</em> that <em>drive actions</em>, involving Data Selection, Preprocessing, Transformation, Data Mining, Delivering value from data (interpretation and evaluation).</p>
</li>
<li>
<p>Challenges have been extremely complex overhead, expensive startup, and steep learning curves. The goal of Azure Machine Learning Services is to provide a simpler and scalable method.</p>
</li>
<li>
<p>Machine Learning is using <em>known data</em> to develop a <em>model</em> to <em>predict unknown data</em>.</p>
<ul>
<li><strong>Known Data</strong>: Big enough archive, previous observations, past data</li>
<li><strong>Model</strong>: Known data + algorithms (ML algorithms)</li>
<li><strong>Unknown Data</strong>: Missing, unseen, not existing, future data</li>
</ul>
</li>
<li>
<p>Microsoft's usage of ML: 1997 Hotmail spam filters, 2008 Bing maps routing, 2009 Bing search, 2010 Kinect</p>
</li>
<li>
<p>Azure Machine Learning's goal - Make machine learning accessible to every enterprise, data scientist, developer, information worker, consumer, and device anywhere in the world.</p>
</li>
<li>
<p>Expect that 75% of the time will be building the model and testing validity of predictions.</p>
</li>
<li>
<p>Cycle of Steps to building a machine learning solution</p>
<ul>
<li>Frame the problem</li>
<li>Get and Prepare Data</li>
<li>Develop the Model
<ul>
<li>Analysis / Metric Definition</li>
<li>Feature Engineering</li>
<li>Model Training</li>
<li>Parameter Tuning</li>
<li>Evaluation</li>
</ul>
</li>
<li>Deploy Model</li>
<li>Evaluate / Track Performance</li>
</ul>
</li>
<li>
<p>ML Algorithm defines how your <em>model</em> will react</p>
<ul>
<li>Written in R or Python</li>
</ul>
</li>
<li>
<p>Classification: answer yes/no</p>
</li>
<li>
<p>Regression: predict a numeric value</p>
</li>
<li>
<p>Anomaly Detection: value outside of bounds</p>
</li>
<li>
<p>Clustering: unsupervised learning, group like data</p>
</li>
</ul>


Azure Machine Learning - Data Camp

<p>Command Query Responsibility Segregation (<a href="https://martinfowler.com/bliki/CQRS.html">CQRS</a>) was not something that I easily understood. Martin Fowler did a thorough job of explaining it in often-linked post from 2011. However, I still did not quite grasp it at the time. I also wasn't working on any project large enough or complex enough that it made sense to use a pattern with that level of depth. When I came back to the concept many years later while working on a significantly more complex project, I could put together all of the puzzle pieces but I still couldn't quite see the whole picture. While researching the topic, I stumbled on a blog post by Cesar de la Torre from Microsoft - <a href="https://blogs.msdn.microsoft.com/cesardelatorre/2012/02/22/cqrs-bus-and-windows-azure-technologies/">CQRS BUS and Windows Azure technologies</a>. His picture was well worth the thousands of words that I had already read.</p>
<p><img src="/images/cqrs-diagram.jpg" alt="CQRS - Basic patterns"></p>
<p>I am limiting the scope of this step of the project to just creating a Message Queue in Azure, writing a command to it, and triggering an appropriate <code>Command Handler</code>. As soon as I started working on the problem, though, I was sidetracked with an important and timely concern — how do I safely store connection information to a remote server? Considering that I work on this project on at least three different machines, I need a highly portable and secure way to store the connection information to my instance of Azure without exposing that connection information to anyone who may look at the code on <a href="https://github.com/drovani/Vigil">GitHub</a>. Now, instead of having three steps to this stage, I have four; maybe more.</p>
<h2>Storing Connection Information</h2>
<p><img src="/images/vs2017-inavord-manage-user-secrets.png" alt="User Secrets in Context Menu"></p>
<p>When this migrates to a production ready environment, I will probably use <a href="https://docs.microsoft.com/en-us/azure/key-vault/key-vault-whatis">Azure Key Vault</a> or some similar service to manage these types of important secrets. However, for the limited amount of information that I need to keep, I am just going to use the built-in "User Secrets" that comes with Visual Studio 2017. Using the context menu on a Web Application project provides the option to "Manage User Secrets". This pulls up a <code>secrets.json</code> file that lives (unencrypted) on the local filesystem. There are plenty of caveats to its use, namely that it provides no security outside of making sure these settings exist entirely separate from your code. In order to store the information I needed, my <code>secrets.json</code> file looks similar to this.</p>
<pre><code>{
  "vigil-storage": "vigilstorage",
  "vigil-storage-queue": "commandqueue",
  // sample key - the real one is much longer
  "vigil-storage-key1": "ocJFUuUrYgVppKtO726cC1S..."
}
</code></pre>
<p>In order to access the user secrets to the configuration builder, a small piece is added to <code>Startup.cs</code>.</p>
<pre><code>public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
        .AddEnvironmentVariables();

    if (env.IsDevelopment())
    {
        builder.AddUserSecrets("6bf18fc4-44a1-4c9b-98ea-22cc92ed1c94");
    }

    Configuration = builder.Build();
}
</code></pre>
<p>Consuming the secrets is as simple as any other configuration value. Since I only need it right now for the <code>StorageCredentials</code> that get injected into the <code>AzureCommandQueue</code> constructor, I have the creation of the credentials as an extension method on the <code>IServiceCollection</code>. My <code>StartupExtensions</code> class can live anywhere; I have decided to put it in the same project that needs it, <code>Vigil.Azure</code>.</p>
<pre><code>public static class StartupExtensions
{
    public static IServiceCollection AddVigilAzureServices(this IServiceCollection services, IConfigurationRoot configuration)
    {
        services.AddTransient&#x3C;IEventBus, AzureEventBus>()
                .AddTransient&#x3C;ICommandQueue, AzureCommandQueue>()
                .AddTransient(srvProvider =>
                    {
                        var storageCredentials = new StorageCredentials(
                            configuration["vigil-storage"],
                            configuration["vigil-storage-key1"]
                        );
                        CloudStorageAccount storageAccount = new CloudStorageAccount(storageCredentials, true);
                        CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
                        var commandQueue = queueClient.GetQueueReference(configuration["vigil-storage-queue"]);
                        return commandQueue;
                    });

        return services;
    }
}
</code></pre>
<h2>Create a Storage Account in Azure</h2>
<p>This was the easiest step of them all, because there are many wonderful tutorials already created on how to do get started with <a href="https://docs.microsoft.com/en-us/azure/storage/storage-introduction">Azure Storage</a>. It comes down to three simple steps that can all be done in under a minute (once you know your way around).</p>
<ol>
<li>Create a <img src="/images/azure-resource-group-icon.png" alt="icon"> Resource group</li>
<li>Create a <img src="/images/azure-storage-account-icon.png" alt="icon"> Storage Account</li>
<li>View <img src="/images/azure-access-key-icon.png" alt="icon"> Access keys</li>
</ol>
<p>The name of the storage account (<code>vigilstorage</code>) and the value of one of the keys goes into the <code>User Secrets</code>, and <em>voilà</em>, the storage account is created. One item that tripped me up was that I expected to need to create the Queue within the portal. As I eventually figured out, that piece is performed exclusively in code.</p>
<h2>Sending a Message to Azure Queue Storage</h2>
<p>After many hours of digging through tutorials, hunting down <em>dotnet core</em> versions of the libraries, and trial and error - I finally got to a point where my code compiled and executed and I could test it with a <a href="https://www.getpostman.com/">Postman</a> query. I was surprised by how little code it ended up requiring. This is the entirety of what the <code>AzureCommandQueue</code> class looks like:</p>
<pre><code>public class AzureCommandQueue : ICommandQueue
{
    private CloudQueue commandQueue;

    public AzureCommandQueue(CloudQueue commandQueue)
    {
        this.commandQueue = commandQueue;
    }

    public void Publish&#x3C;TCommand>(TCommand command) where TCommand : ICommand
    {
        PublishAsync(command).Wait();
    }

    public async Task PublishAsync&#x3C;TCommand>(TCommand command) where TCommand : ICommand
    {
        await commandQueue.CreateIfNotExistsAsync();

        var newCmd = new Command(command)
        {
            DispatchedOn = DateTime.UtcNow
        };
        var message = new CloudQueueMessage(JsonConvert.SerializeObject(newCmd));
        await commandQueue.AddMessageAsync(message);
    }
}
</code></pre>
<h2>HOLY SHIT I GOT IT TO WORK</h2>
<p><img src="/images/azure-queue-data.png" alt="Data in an Azure Queue"></p>
<p>This was one of those "really cool moments" when it comes together how fantastic my job is and how amazing technology truly is. I just had a tool on my computer simulate a user pushing a non-existant button that sends information to another tool on my computer that is pretending to be a web server which then executed code that I wrote to take that message and securely send it up to the internet and sit on some unknown computer where it will stay and wait for me to call upon it.</p>


Vigil's Azure Command Queue

<p>I may have gone down a long and twisted rabbit hole trying to figure out this problem, but I learned a lot about how model binding along the way, so I consider the whole experiment a productive use of my time, even if I end up ripping it all out in a few weeks. However, since I thought this would be a good idea, I figure others might find a good use for this knowledge. Thus, this is how I am using an explicity constructor when the input is in a <code>JSON</code> format and parameter is bound using the request body.</p>
<pre><code>[HttpPost]
public IActionResult Create([FromBody]CreatePatron command)
</code></pre>
<p>An early lesson when writing Actions is that, in Core MVC, the <code>[FromBody]</code> attribute is required to use the <code>JsonInputFormatter</code>. Setting a new convention for controllers is possible (<a href="http://www.dotnetcurry.com/aspnet-mvc/1149/convert-aspnet-webapi2-aspnet5-mvc6">instructions on how to</a>), but for now I am going to stick with the tedium of remembering to apply it to every parameter.</p>
<p>The purpose of this is that I want the <code>GeneratedBy</code> and the <code>GeneratedOn</code> parameters to be required for every instance of a <code>Command</code>. This ensures that it won't be set by the user (either the end user or another user in a consuming change) since the properties' set methods are <code>protected</code>.</p>
<pre><code>using System;

namespace Vigil.Domain.Messaging
{
    public abstract class Command : KeyIdentity, ICommand
    {
        public string GeneratedBy { get; protected set; }
        public DateTime GeneratedOn { get; protected set; }

        protected Command(string generatedBy, DateTime generatedOnUtc)
        {
            if (string.IsNullOrEmpty(generatedBy)) throw new ArgumentNullException(nameof(generatedBy));
            if (generatedOnUtc == default(DateTime)) throw new ArgumentException($"{nameof(generatedOnUtc)} requires a non-default value.", nameof(generatedOnUtc));
            if (generatedOnUtc.Kind != DateTimeKind.Utc) throw new ArgumentException($"{nameof(generatedOnUtc)} must be DateTimeKind.UTC.", nameof(generatedOnUtc));

            GeneratedBy = generatedBy;
            GeneratedOn = generatedOnUtc;
        }
    }
}
</code></pre>
<p>This poses a problem with using the <code>CreatePatron</code> command as a parameter. The default <a href="https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Formatters.Json/JsonInputFormatter.cs"><code>JsonInputFormatter</code> class</a> uses the <a href="https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Formatters.Json/JsonInputFormatter.cs#L149"><code>JsonSerializer.Deserialize(JsonTextReader, Type)</code> method</a> to create the instance of the model. This method uses the parameterless constructor, which my objects to not have. To solve this problem, I inheritted from the <code>JsonInputFormatter</code> (keeping as much functionality as I could) and proceeded from there.</p>
<h2>CommandInputFormatter Constructor</h2>
<p>All of the fields that are passed to the <code>JsonInputFormatter</code> constructor are stored as private readonly fields. Therefore, I had to create my own private readonly copies of them to use in the methods that I needed to write.</p>
<pre><code>public class CommandInputFormatter : JsonInputFormatter
{
    private readonly IArrayPool&#x3C;char> _charPool;
    private readonly ILogger _logger;
    private readonly ObjectPoolProvider _objectPoolProvider;

    public CommandInputFormatter(ILogger logger
        , JsonSerializerSettings serializerSettings
        , ArrayPool&#x3C;char> charPool
        , ObjectPoolProvider objectPoolProvider)
        : base(logger, serializerSettings, charPool, objectPoolProvider)
    {
        if (charPool == null)
        {
            throw new ArgumentNullException(nameof(charPool));
        }
        _charPool = new JsonArrayPool&#x3C;char>(charPool);

        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _objectPoolProvider = objectPoolProvider ?? throw new ArgumentNullException(nameof(objectPoolProvider));
    }
}
</code></pre>
<h2>CommandInputFormatter.CanReadyType</h2>
<p>Since I wanted this formatter to only work for these specific classes, I extended the functionality of the <code>CanReadType</code> method to also filter for just models that implement the <code>Command</code> abstract base class.</p>
<pre><code>protected override bool CanReadType(Type type)
{
    return base.CanReadType(type) &#x26;&#x26; typeof(Command).IsAssignableFrom(type);
}
</code></pre>
<h2>CommandInputFormatter.ReadRequestBodyAsync</h2>
<p>The simplest way for me to change the constructor that <code>JsonInputFormatter</code> uses to generate the model would have been if they had isolated that small piece of the <code>ReadRequestBodyAsync</code> method into its own protected virtual method. However, since they didn't, I have to override the entire thing. Because ASP.NET Core (including MVC) is all open source, I was able to copy the source code from the original and only replace the parts that I needed to.</p>
<pre><code>public override Task&#x3C;InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
    if (context == null)
    {
        throw new ArgumentNullException(nameof(context));
    }
    if (encoding == null)
    {
        throw new ArgumentNullException(nameof(encoding));
    }


    using (var streamReader = context.ReaderFactory(context.HttpContext.Request.Body, encoding))
    {
        using (var jsonReader = new JsonTextReader(streamReader))
        {
            jsonReader.ArrayPool = _charPool;
            jsonReader.CloseInput = false;

            var successful = true;
            EventHandler&#x3C;Newtonsoft.Json.Serialization.ErrorEventArgs> errorHandler = (sender, eventArgs) =>
            {
                successful = false;

                var exception = eventArgs.ErrorContext.Error;

                // Handle path combinations such as "" + "Property", "Parent" + "Property", or "Parent" + "[12]".
                var key = eventArgs.ErrorContext.Path;
                if (!string.IsNullOrEmpty(context.ModelName))
                {
                    if (string.IsNullOrEmpty(eventArgs.ErrorContext.Path))
                    {
                        key = context.ModelName;
                    }
                    else if (eventArgs.ErrorContext.Path[0] == '[')
                    {
                        key = context.ModelName + eventArgs.ErrorContext.Path;
                    }
                    else
                    {
                        key = context.ModelName + "." + eventArgs.ErrorContext.Path;
                    }
                }

                var metadata = GetPathMetadata(context.Metadata, eventArgs.ErrorContext.Path);
                context.ModelState.TryAddModelError(key, eventArgs.ErrorContext.Error, metadata);

                _logger.LogDebug(1, eventArgs.ErrorContext.Error, "Command Input Formatter threw an exception");

                // Error must always be marked as handled
                // Failure to do so can cause the exception to be rethrown at every recursive level and
                // overflow the stack for x64 CLR processes
                eventArgs.ErrorContext.Handled = true;
            };

            object model = GetModel(context);
            var type = context.ModelType;
            var jsonSerializer = CreateJsonSerializer();
            jsonSerializer.Error += errorHandler;
            try
            {
                jsonSerializer.Populate(jsonReader, model);
            }
            finally
            {
                // Clean up the error handler since CreateJsonSerializer() pools instances.
                jsonSerializer.Error -= errorHandler;
                ReleaseJsonSerializer(jsonSerializer);
            }

            if (successful)
            {
                return InputFormatterResult.SuccessAsync(model);
            }

            return InputFormatterResult.FailureAsync();
        }
    }
}
</code></pre>
<p>There are only two lines that differ between the formatters; I was surprised by how little I had to change.</p>
<p>| <code>JsonInputFormatter</code>                                | <code>CommandInputFormatter</code>                   |
|-----------------------------------------------------|-------------------------------------------|
|object model;                                        |object model = GetModel(context);          |
|model = jsonSerializer.Deserialize(jsonReader, type);|jsonSerializer.Populate(jsonReader, model);|</p>
<h2>CommandInputFormatter.GetModel</h2>
<p>Of course, there was a little more that I had to add, but this piece is very specific to my application. This is the block of code that creates the appropriate <code>Command</code> object using the explicit constructor.</p>
<pre><code>private static readonly Dictionary&#x3C;Type, Func&#x3C;string, DateTime, Command>> _commandModelCreators = new Dictionary&#x3C;Type, Func&#x3C;string, DateTime, Command>>();
protected virtual object GetModel(InputFormatterContext context)
{
    if (!_commandModelCreators.ContainsKey(context.ModelType))
    {
        var generatedBy = Expression.Parameter(typeof(string), nameof(Command.GeneratedBy));
        var generatedOn = Expression.Parameter(typeof(DateTime), nameof(Command.GeneratedOn));
        var constructor = context.ModelType.GetConstructor(new Type[] { typeof(string), typeof(DateTime) });
        var newExpr = Expression.New(constructor, generatedBy, generatedOn);
        var lambda = Expression.Lambda&#x3C;Func&#x3C;string, DateTime, Command>>(newExpr, generatedBy, generatedOn);

        _commandModelCreators.Add(context.ModelType, lambda.Compile());
    }
    // @TODO Find a better way to get the current user's name
    return _commandModelCreators[context.ModelType](context?.HttpContext?.User?.Identity?.Name ?? "Anonymous User", DateTime.UtcNow);
}
</code></pre>
<p>I save the compiled expression in the formatter. There might be a better way to cache the results, but I can worry about that optimization later. I would also like to have a better way to pass in the identity of the user generating this command. This works for my testing purposes, but I need a better way to do this in the future. Additionally, it would be better if I could inject the <code>DateTime.UtcNow</code> value to be able to explicitly set it and test again in unit tests.</p>
<h2>Include the CommandInputFormatter</h2>
<p>I was not expecting this piece to turn into a three step process. In order to add an an input formatter with parameters, it needs to be configured through an <code>IConfigureOptions&#x3C;MvcOptions></code>, which is added via a <code>ServiceDescriptor</code> to the <code>Services</code> collection on the <code>IMvcBuilder</code> in the <code>Startup</code> class. I learned all this by searching through the Github repository. Once I found the path through it all, I just duplicated most of it, adapting it to my use case.</p>
<p>The <code>IConfigureOptions&#x3C;MvcOptions></code> is easy to implement. The difficulty was in finding what dependency injections were available for the constructor.</p>
<pre><code>public class VigilMvcOptionsSetup : IConfigureOptions&#x3C;MvcOptions>
{
    private readonly ILoggerFactory _loggerFactory;
    private readonly JsonSerializerSettings _jsonSerializerSettings;
    private readonly ArrayPool&#x3C;char> _charPool;
    private readonly ObjectPoolProvider _objectPoolProvider;

    public VigilMvcOptionsSetup(
        ILoggerFactory loggerFactory,
        IOptions&#x3C;MvcJsonOptions> jsonOptions,
        ArrayPool&#x3C;char> charPool,
        ObjectPoolProvider objectPoolProvider)
    {
        if (jsonOptions == null)
        {
            throw new ArgumentNullException(nameof(jsonOptions));
        }

        _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
        _jsonSerializerSettings = jsonOptions.Value.SerializerSettings;
        _charPool = charPool ?? throw new ArgumentNullException(nameof(charPool));
        _objectPoolProvider = objectPoolProvider ?? throw new ArgumentNullException(nameof(objectPoolProvider));
    }

    public void Configure(MvcOptions options)
    {
        options.InputFormatters.Insert(0, new CommandInputFormatter(
            _loggerFactory.CreateLogger&#x3C;CommandInputFormatter>(),
            _jsonSerializerSettings,
            _charPool,
            _objectPoolProvider
        ));
    }
}
</code></pre>
<p>From here, I could have easily just injected the <code>VigilMvcOptionsSetup</code> during startup config. I suspect that there will be more customization that I will want to attach to the <code>IMvcBuilder</code>, so chose to follow the lead from the MVC developers and create an extension method.</p>
<pre><code>public static class MvcBuilderExtensions
{
    public static IMvcBuilder AddCommandFormatter(this IMvcBuilder builder)
    {
        if (builder == null)
        {
            throw new ArgumentNullException(nameof(builder));
        }
        ServiceDescriptor descriptor = ServiceDescriptor.Transient&#x3C;IConfigureOptions&#x3C;MvcOptions>, VigilMvcOptionsSetup>();
        builder.Services.TryAddEnumerable(descriptor);
        return builder;
    }
}
</code></pre>
<p>The final step, to wire it all together, is to add a call to the extension method in the <code>Startup.ConfigureServices(IServiceCollection)</code> method. It is important that my extension method comes after the <code>AddMvc</code> method because I inject the <code>CommandInputFormatter</code> to the beginning of the <code>InputFormatters</code> collection. Reversing the order would put my input formatter behind all of the defaults, and the <code>JsonInputFormatter</code> would grab all of the requests before my input formatter was ever checked.</p>
<pre><code>// Add framework services.
services.AddMvc()
    .AddCommandFormatter();
</code></pre>


Using an Explicit Model Constructor with a JsonInputFormatter

<p>Now that the Vigil Project has breached into the API layer, I started to learn all kinds of new information about what takes place before the Controller's Action method is called and what happens after that method returns. The MVC framework, especially while using Visual Studio, make it incredibly easy to forget about all of the heavy lifting that the framework does – long before my code is ever executed. It is only when I wanted to start changing how pieces worked that I really start to see the true depth and breadth of what Microsoft has created. As I begin to discover new pieces of the framework, I felt that the best way to retain this information is to repeat it; and since no one around me wants to hear about all of this, I'll just type it into a blog post.</p>
<h2>Upon First Introduction</h2>
<p>My first introduction to MVC (through various tutorials) gave me the impression that the full stack looks basically like this:</p>
<p><img src="/images/mvcpipeline-initial.svg" alt="Initial Pipeline Assumptions"></p>
<p>There's a lot of black box magic going on in that diagram. But you know what? It doesn't matter. When all I wanted to do was respond to a simple request, then all I had to do was create a <code>Controller</code> and an <code>Action</code> and then <em>magic happened</em>, and I got a functioning application. Do I have any clue about how the data got to the method? Or how the <code>Controller</code> was even instantiated in order for <em>something</em> to have an object to call my method? <strong>Nope</strong>! And that's the point.</p>
<h2>The First Challenge - Explicit Constructor</h2>
<p>The Create action for the <code>BaseController</code> is simple. It just take an instance of the <code>CreatePatron</code> command and publishes is to the <code>CommandQueue</code>. This is essentially the same as the unit test that proved that a "<a href="/posts/2016/patron-can-be-created-and-updated-again/">patron can be created</a>".</p>
<pre><code>[HttpPost]
public IActionResult Create([FromBody]CreatePatron command)
{
    if (command == null || !ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    else
    {
        CommandQueue.Publish(command);
        return Accepted(Url.Action(nameof(Get),
            new { id = command.PatronId }));
    }
}
</code></pre>
<p>However, this quickly goes awry the first time I execute the code, because the <code>CreatePatron</code> command (as with all <code>PatronCommand</code> classes) has no default constructor. MVC <em>really</em> wants a default constructor, but I <em>really</em> want to guarantee that the <code>GeneratedBy</code> and <code>GeneratedOn</code> values are properly populated. "Surely," though I, "this should be an easy update and I'll be able to move onto something else."</p>
<p>I was wrong.</p>
<h2>What Creates an Instance of My Model</h2>
<p>Early in the tutorials I was following, they allude to this magical <em>Binding Handler</em> which takes data from the request and binds it to the model and passes it to the action. I now had an idea of <em>what</em> I was looking for, with the assumption that the Binding Handler is what would create the instance of my model. I also assumed that whatever was doing this work was a result of some default setting.</p>
<p>This was the first time I started really digging into what happens during the <code>Startup</code> portion of the application. <code>Startup</code> is the default class that is created with any new MVC project, and it is wired into the <code>WebHostBuilder</code> during the execution of the <code>Main</code> event. I didn't dig into all of the different methods that automatically get generated, because I had a this specific action that I was trying to find.</p>
<pre><code>// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc()
}
</code></pre>
<p>As a bit of a tangent, this is where I am estatic that .NET Core is open source. For previous frameworks, I would have to scour the web for someone to have already done all of this digging, and decided it was worth it to create a post, and then I would have to manage to find their post, and then hope it was close enough for me to get the answers I needed. Now that everything is open source, I can just go <a href="https://github.com/aspnet/mvc">view the code itself</a> to find out what happens.</p>
<pre><code>    public static class MvcServiceCollectionExtensions
    {
        public static IMvcBuilder AddMvc(this IServiceCollection services)
        {
            if (services == null)
            {
                throw new ArgumentNullException(nameof(services));
            }

            var builder = services.AddMvcCore();

            builder.AddApiExplorer();
            builder.AddAuthorization();

            AddDefaultFrameworkParts(builder.PartManager);

            // Order added affects options setup order

            // Default framework order
            builder.AddFormatterMappings();
            builder.AddViews();
            builder.AddRazorViewEngine();
            builder.AddRazorPages();
            builder.AddCacheTagHelper();

            // +1 order
            builder.AddDataAnnotations(); // +1 order

            // +10 order
            builder.AddJsonFormatters(); // &#x3C;--- THIS LOOKS PROMISING!!!

            builder.AddCors();

            return new MvcBuilder(builder.Services, builder.PartManager);
        }
</code></pre>
<p>What does the <code>AddJsonFormatters()</code> extension method do? I can go <a href="https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Formatters.Json/DependencyInjection/MvcJsonMvcCoreBuilderExtensions.cs">look that up</a>. That method calls an internal method that adds Service Descriptor to the service collection to resolve an <code>IConfigureOptions&#x3C;MvcOptions></code> into a <code>MvcJsonMvcOptionsSetup</code>. That <a href="https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Formatters.Json/Internal/MvcJsonMvcOptionsSetup.cs">source code</a> for that class indicates that it adds a <code>JsonInputFormatter</code> to the list of Input Formatters in the <code>MvcOptions</code> object that gets passed to it. Continuing to dive further into the <a href="https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Formatters.Json/JsonInputFormatter.cs">source code</a>, I finally found the magic line of code!</p>
<pre><code>namespace Microsoft.AspNetCore.Mvc.Formatters
{
    public class JsonInputFormatter : TextInputFormatter
    {
        /* snip the constructor */

        public override Task&#x3C;InputFormatterResult> ReadRequestBodyAsync(
            InputFormatterContext context,
            Encoding encoding)
        {
                    /* snip a bunch of set-up code */
                    try
                    {
                        // HERE IT IS!!!
                        model = jsonSerializer.Deserialize(jsonReader, type);
                    }
                    /* snip clean-up code */
                }
            }
        }
        /* snip the rest of the class */
    }
}
</code></pre>
<h2>What Do I Know, Now?</h2>
<p><img src="/images/mvcpipeline-chooseinputformatter.svg" alt="Getting the Input Formatter"></p>
<p>During startup, using the <code>AddMvc</code> extension method, by default, will add a <code>JsonInputFormatter</code> to the list of Input Formatters. When reading the request body, the <code>ReadRequestBodyAsync</code> using the JSON serializer's <a href="http://www.newtonsoft.com/json/help/html/M_Newtonsoft_Json_JsonSerializer_Deserialize_1.htm"><code>Deserialize</code> method</a>. I don't see anyway to injet something to override just that one line - or even the object creation portion.</p>
<p>Zoomed in - this is the tiny piece that I learned of the whole pipeline. I have no idea if this is to scale or not, but it certainly feels like only a small step.</p>
<p><img src="/images/mvcpipeline-chooseinputformatter.zoom.svg" alt="Getting the Input Formatter"></p>
<h2>What Do I Need To Do?</h2>
<ol>
<li>Inherit from <code>JsonInputFormatter</code> and override the <code>ReadRequestBodyAsync</code> method.</li>
<li>Create a new setup class to inject the new input formatter, implementing <code>IConfigureOptions&#x3C;MvcOptions></code>.</li>
<li>Create a new static class and an extension method on <code>IMvcBuilder</code> to add dependency injection for the setup class.</li>
<li>Crib unit tests from the Mvc code base.</li>
<li>Hope that it all really works.</li>
</ol>


Discovering MVC - The ASP.NET Core MVC Stack

<p>As I was writing the <a href="/posts/2017/introducing-vigil-web-api/">previous post</a>, it came as a shock how far behind my posts on the progress of the Vigil Donor Relationship Management System had gotten. I was going too deep into the code and making too many changes that I didn't pause to write a post about my progress. My posts are 22 commits behind, and there are quite a few changes I've made to the workflow and to the application. As a way to catch up on all the missed posts that I should have written, I am putting this one together as a status report of the project/journey/solution.</p>
<p>In terms of workflow, I have embraced the <a href="https://guides.github.com/introduction/flow/">GitHub Flow workflow</a> (both for Vigil and for this blog). For my little project, since there is no discussion and no deployments (as of yet), the workflow is as simple as Branch, Commit(s), Pull, Merge, Delete. I like the way that a merge can squash all of the commits made on a branch, so that I have one summarized collection of everything that I did. This way, I can easily differentiate the content of a post by doing one per Pull Request / Merge. Hopefully, this process will now keep the posts coming regularly, help me be more concise about what should be in a post, and better contain runaway developing.</p>
<h2>Quantity of code</h2>
<p>As I look at the total row count of all of the code, I am actually surprised by how many lines of code I have produced. It is a pittance compared to what I could output if I had been working on this project full time for the last two years. However, for something that I have only been poking at every once in a while, I still find myself astonished that all of the simple "Create this" and "Update that" have turned into this much actionable code.</p>
<h2>Vigil.Domain</h2>
<p>The Domain project contains a lot of interfaces and a few abstract classes. The key functionality that has been created here are the structure for what it takes to build a messaging and event sourcing system. More will probably be added here as a way to keep shared functionality across different implementations - be in for <code>Patron</code> entities or an Ordering and Inventory system or possibly a job taks/queue system.</p>
<p>The reading that I have done with regards to Domain Driven Design (DDD) talk about establishing a <em>Domain Language</em>. My interpretation is to enforce that in a shared project that creates the core concept of how the <em>domain</em> should be structured and implemented. The rest of the application is just extending these interfaces and base classes and providing for meaning over the abstractions. There was a lot of flux in the earliest stages of the <code>Vigil.Domain</code> project, but it has already settled into a stable state. My assumption is that over time, this will be the project that undergoes the least amount of change, but that changes to it will have broad reaching effects.</p>
<h3>Vigil.Domain.Tests</h3>
<p>The consensus for <a href="http://stackoverflow.com/questions/243274/how-to-unit-test-abstract-classes-extend-with-stubs">testing abstract classes</a> seems to be to either never use abstract classes or to create extremely simple inherited classes and run the tests on those. I have chosen the later option (obviously) and so far the tests seem comprehensive. Though, as with most of this project, I have constant feelings of imposter syndrome where someone smart is going to come along and tell me how awful this whole thing is and how I'm doing it all wrong.</p>
<h2>Vigil.Patrons</h2>
<p>As is the only concrete implementation of the <em>Domain Language</em>, this project is a semi-functional proof-of-concept. I keep trying to focus myself on considering it as production code, thus holding myself to the same requirements to unit test everything and keep functionality as a <a href="https://www.youtube.com/watch?v=R2Aa4PivG0g">complex web of small pieces</a>. Commands available handle the simplest of actions - <code>CreatePatron</code>, <code>UpdatePatronHeader</code>, <code>DeletePatron</code>. The <code>PatronCommandHandler</code> knows what to do with the commands, which is to just create the applicable event and push it to the Event Bus. The <code>PatronEventHandler</code> methods only update the <code>Patron</code> entity that was persisted using an <code>IPatronContext</code>.</p>
<p>Upon close examination, the Patron project is barely less of an abstraction than the Domain project from which it derives most of its functionality. It is  disheartening to know that even the after writing roughly 300 lines of code, there is very little that I can do with the code. However, I can also celebrate in knowing that it takes only 300 lines of code to be able to implement the core functionality fo what it takes to Create, Read, Update, and Delete a <code>Patron</code>. The only thing left (after I unit tested everything) was to wire the Patron project to a real implementation of all of the interfaces it was depending on.</p>
<h2>Vigil.Sql</h2>
<p>I talked about this project in detail in <em><a href="/posts/2017/illusions-of-queues-and-buses/">Illusions of Queues and Buses</a></em>. The short of it is that I wanted to put together an extremely simple implementation of the <code>ICommandQueue</code> and <code>IEventBus</code> so that I could use it in the <code>Vigil.WebApi</code> project.</p>
<h2>Vigil.WebApi</h2>
<p>The <a href="/posts/2017/introducing-vigil-web-api/">post previous to this</a> explains why I decided to venture into the API layer of the application, instead of continuing to implement more of the Patron project or begin working on another subsystem of the application. It certain has been gratifying to see everything come together and be properly integrated and <em>just work</em>.</p>
<h2>Future Tangents</h2>
<p>There are a number of quality-of-life improvements that could easily cause me to stray down a long tangent of work. It would be nice if my project templates included all of the settings that I apply to each new project. These include:</p>
<ul>
<li>Set the "Author" to "drovani"</li>
<li>Set "RepositoryType" to "git"</li>
<li>Set "RepositoryUrl" to "https://github.com/drovani/Vigil"</li>
<li>Clear the "Description"</li>
<li>Set "SignAssembly" to "true"</li>
<li>Set the "AssemblyOriginatorKeyFile" to the <code>vigil.snk</code> in the root solution folder</li>
<li>For Test projects:
<ul>
<li>Set the "RootNamespace" to be the same as the project being tested.</li>
<li>Add <code>xunit.runner.json</code> and set the "methodDisplay" to "method"</li>
<li>Include the <code>Moq</code>, <code>xunit</code>, and <code>xunit.runner.visualstudio</code> NuGet packages</li>
</ul>
</li>
</ul>
<p>Other side projects would include putting together all of the shiny automated build routines that all of the big projects have. Being able to have Pull Requests kick off builds to make sure nothing breaks - that would be cool. Turning all of the projects into NuGet packages and making them a little more portable would be an interesting experiment.</p>
<p>My problem is that each of these tangents only delay my progress on creating productive code that leads the project to a useful state.</p>


22 Month Status Report

<p>Thus far in the series, the Vigil Journey project has been able to <a href="/posts/2016/user-can-create-new-patron/">create a patron</a>, <a href="/posts/2016/user-can-update-a-patron/">update a patron</a>, and have those redefined as "<a href="/posts/2016/patron-can-be-created-and-updated-again/">a patron can be created and updated</a>". However, as acknowledged in those posts, this was all smoke and mirrors. Nothing was being persisted, and once the unit tests were run, there was no lasting effect of the code. All of the tests passed and there were lots of pretty green check marks, but no residual digital substance. Additionally, there was no application that could be left running with which someone could interact.</p>
<p>I began getting antsy about needing to have some semblence of real progress. Something that I could launch and point to and say "see there; it works!" This was my primary motivator for quickly (and sloppily) writing the <a href="/posts/2017/illusions-of-queues-and-buses/"><code>SqlCommandQueue</code> and <code>SqlEventBus</code></a> classes. I wanted to be able to demonstrate <em>something</em>.</p>
<h2>Recent Observations</h2>
<p>While my initial instinct was to spin up a complete user interface for this; what better way to show progress than to open a web browser and display grid views and form fields, thought I. However, I also had grand schemes of building a full API for the UI to utilize. This kept my ambitions in check, and after researching for ways to directly interact with an API, allowing me to reach a more attainable goal. Thus, the next  layer of the project - which is to instantiate the <code>CreatePatron</code> command and pass it to an <code>ICommandQueue</code>. Utilizing my <code>SqlCommandQueue</code>, I could wire that to a database, which would handle persistence of <code>Command</code> objects, passing those to a <code>CommandHandler</code>. These would, in turn, generate events and put them on the <code>SqlEventBus</code>; which would call the appropriate <code>EventHandler</code> classes, and thus persist the changes to the relational database.</p>
<p>An unexpected (though, in hindsight, entirely predictable) revalation I had while adding this additional layer to the application is that each piece seems to have a higher cost to initialize the first proof of concept. When all I was looking for was the ability to <em>create a patron</em>, I could claim that "it works" when the unit test proved that a short piece of code did what it was supposed to do. The <code>PatronCommandHandler</code> class required no external libraries &#x26;emdash; in fact, going up the dependencie chain, <code>System</code> is the only required library because of <code>DateTime</code> and <code>Guid</code>. However, implementing even a cheap Command Queue or Event Bus requires the <code>EntityFrameworkCore</code> and <code>System.Linq</code> NuGet packages. Adding the ability to stand up even a small Rest API requires <code>Microsoft.AspNetCore</code>, <code>Microsoft.AspNetCore.Mvc</code>, <code>Microsoft.AspNetCore.Routing</code>, and if I want to use a webserver to host the code, then it requires bringing one or more of the <code>Microsoft.AspNetCore.Server</code> packages. There is a lot more experimentation, debugging, and unit testing required for each step. This is something that I'm going to have to keep in mind anytime I get the grand ambitions to tack on another layer to the application.</p>
<h2>ASP.NET Core MVC as an API</h2>
<p>Previous versions of ASP.NET MVC separated out the <code>Controller</code> base class from the WebAPI controller base class. With ASP.NET Core MVC, there is no difference between an API controller and a web controller. I see this as being a real advantage when it comes to migrating code that was all crammed together in a web application, when an easier way to manage it would be as two different applications. Since a core goal of this entire <em>Vigil Journey</em> is to separate responsibilities wherever possible, I like having the responsibility of user presentation being entirely separate from the responsibility of the command and query part of the workflow.</p>
<p>The <code>PatronController</code> is going to start as a simple controller that implements the four basic tenents of data: Create, Read, Update, Delete - or CRUD. Each action has a different Verb, Model, and return values.</p>
<p>|        | Http Verb | Model              | Success        | Failure              |
|--------|-----------|--------------------|----------------|----------------------|
| Create | Post      | CreatePatron       | Accepted (202) | BadRequest (400)     |
| Read   | Get       | PatronId           | Ok (200)       | NotFound (404)       |
| Update | Put       | UpdatePatronHeader | Accepted       | BadRequest, NotFound |
| Delete | Delete    | PatronId           | Accepted       | NotFound             |</p>
<pre><code>using Microsoft.AspNetCore.Mvc;
using System;
using System.Linq;
using Vigil.Domain.Messaging;
using Vigil.Patrons.Commands;

namespace Vigil.WebApi.Controllers
{
    [Route("api/[controller]")]
    public class PatronController : Controller
    {
        private readonly ICommandQueue commandQueue;
        private readonly Func&#x3C;VigilWebContext> contextFactory;

        public PatronController(ICommandQueue commandQueue,
            Func&#x3C;VigilWebContext> contextFactory)
        {
            this.commandQueue = commandQueue;
            this.contextFactory = contextFactory;
        }

        [HttpGet]
        public IActionResult Get()
        {
            using (var context = contextFactory())
            {
                var patrons = context.Patrons.Where(p => p.DeletedOn == null);
                return Ok(patrons);
            }
        }

        [HttpGet("{id}")]
        public IActionResult Get(Guid id)
        {
            using (var context = contextFactory())
            {
                var patron = context.Patrons.Find(id);
                if (patron == null)
                {
                    return NotFound();
                }
                else
                {
                    return Ok(patron);
                }
            }
        }

        [HttpPost]
        public IActionResult Create([FromBody]CreatePatron command)
        {
            if (command == null || !ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            else
            {
                commandQueue.Publish(command);
                return Accepted(
                    Url.Action(nameof(Get), new { id = command.PatronId })
                );
            }
        }

        [HttpPut("{id}")]
        public IActionResult UpdateHeader(Guid id,
            [Bind(nameof(UpdatePatronHeader.DisplayName),
                  nameof(UpdatePatronHeader.IsAnonymous),
                  nameof(UpdatePatronHeader.PatronType))] UpdatePatronHeader command)
        {
            if (command == null || !ModelState.IsValid)
            {
                return BadRequest(command);
            }
            using (var context = contextFactory())
            {
                if (context.Patrons.Find(id) == null)
                {
                    command.PatronId = id;
                    commandQueue.Publish(command);
                    return Accepted(Url.Action(nameof(Get), new {
                        id = command.PatronId
                    }));
                }
                else
                {
                    return NotFound(id);
                }
            }
        }

        [HttpDelete("{id}")]
        public IActionResult Delete(Guid id)
        {
            using (var context = contextFactory())
            {
                if (context.Patrons.Any(p => p.Id == id))
                {
                    commandQueue.Publish(
                        new DeletePatron(User.Identity.Name, DateTime.Now)
                        {
                            PatronId = id
                        }
                    );
                    return Accepted();
                }
                else
                {
                    return NotFound(id);
                }
            }
        }
    }
}
</code></pre>
<h2>Unit Tests before Functional testing</h2>
<p>Before I attempted to launch Kestrel or IIS Integration, I needed to write a Unit Test. I got a little ahead of myself on this one. I wrote this first unit test, and then went off on a coding tangent, which caused a massive refactoring to occur. The unit tests never got completed for this version of the <code>PatronController</code>, but it does provide a quick overview as to how I handled the constructor requirements of the controller and checks for the return value.</p>
<pre><code>using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Moq;
using System;
using Vigil.Domain.Messaging;
using Xunit;

namespace Vigil.WebApi.Controllers
{
    public class PatronControllerTest
    {
        public readonly ICommandQueue cmdQueue = Mock.Of&#x3C;ICommandQueue>();
        public readonly Func&#x3C;VigilWebContext> Context;

        public PatronControllerTest()
        {
            var serviceProvider = new ServiceCollection()
                .AddEntityFrameworkInMemoryDatabase()
                .BuildServiceProvider();
            var builder = new DbContextOptionsBuilder&#x3C;VigilWebContext>()
                .UseInMemoryDatabase(databaseName: "TestHelper")
                .UseInternalServiceProvider(serviceProvider);

            Context = () => new VigilWebContext(builder.Options);
        }

        [Fact]
        public void Get_Returns_EmptyCollection_WhenThereAreNoPatrons()
        {
            var controller = new PatronController(cmdQueue, Context);

            var result = controller.Get() as OkObjectResult;

            Assert.NotNull(result);
            Assert.NotNull(result.Value);
        }
    }
}
</code></pre>
<p>If nothing else, this post reinforced that I need to write posts more often, and do a better job of isolating concepts into branches and merging small amounts of code at a time.</p>


Rovani's Sandbox

Blog Posts - Page 8