Dominic Burford - Professional Profile

"Path\To\MSBuild\MSBuild.exe" /p:configuration="release";platform="any cpu";WebPublishMethod=Package;PackageFileName="\MyFolder\package.zip";DesktopBuildPackageLocation="\MyFolder\package.zip";PackageAsSingleFile=true;PackageLocation="\MyFolder\package.zip";DeployOnBuild=true;DeployTarget=Package

<form asp-page-handler=@toolbar.PageHandler method=@toolbar.Method>
  <button class="btn btn-default">@toolbar.DisplayText</button>
</form>

<form asp-page-handler=@toolbar.PageHandler method=@toolbar.Method onclick="return confirm('Are you sure you want to delete this?')">
  <button class="btn btn-default">@toolbar.DisplayText</button>
</form>

<form asp-page-handler="upload" method="post">
  @(Html.Kendo().Upload()
    .Name("files")
  )
  <button>Save</button>
</form>

public void OnPostUpload(IEnumerable<IFormFile> files)
{
  //do something with the file(s) here
}

<form asp-page-handler="Customers" method="GET">
    <button class="btn btn-default">List Customers</button>
</form>

public void OnGetCustomers()
{
    //fetch a list of customer here!
}

<form asp-page-handler="Customer" method="GET">
    <button class="btn btn-default">Get Customer</button>
    <input id="handler_parameter" type="hidden" name="selectedCustomerID" value="0"/>
</form>

public void OnGetCustomer(int selectedCustomerID)
{
    //fetch a specific customer here!
}

function onDocumentViewNode(data) {
    $("#handler_parameter")[0].value = data.id;
}

$.ajax({
    type: "GET",
    url: "/Customer?handler=customer&selectedCustomerID="+ data.id,
    contentType: "application/json",
    dataType: "json",
    success: function (response) {
      //do something here
    },
    failure: function (response) {
      console.log(JSON.stringify(response));
    }
});

public class MockHttpSession : ISession
{
    readonly Dictionary<string, object> _sessionStorage = new Dictionary<string, object>();
    string ISession.Id => throw new NotImplementedException();
    bool ISession.IsAvailable => throw new NotImplementedException();
    IEnumerable<string> ISession.Keys => _sessionStorage.Keys;

    void ISession.Clear()
    {
        _sessionStorage.Clear();
    }
    Task ISession.CommitAsync(CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }
    Task ISession.LoadAsync(CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }
    void ISession.Remove(string key)
    {
        _sessionStorage.Remove(key);
    }
    void ISession.Set(string key, byte[] value)
    {
        _sessionStorage[key] = Encoding.UTF8.GetString(value);
    }
    bool ISession.TryGetValue(string key, out byte[] value)
    {
        if (_sessionStorage[key] != null)
        {
            value = Encoding.ASCII.GetBytes(_sessionStorage[key].ToString());
            return true;
        }
        value = null;
        return false;
    }
}

public void MyFunction(ISession context = null)
{
    if (context == null)
    {
        context = HttpContext.Session;
    }

    string email = context.Get("UserEmail");
    //rest of the function code goes here
}

[TestMethod]
public async Task InvokeAsyncTest()
{
    MainMenuViewComponent component = new MainMenuViewComponent();
    var mockContext = MockHttpContext();

    var result = await component.InvokeAsync(mockContext);

    Assert.IsNotNull(result);
}

private static ISession MockHttpContext()
{
    MockHttpSession httpcontext = new MockHttpSession();
    httpcontext.Set<string>("UserEmail", "unittest@mycompany.com");
    return httpcontext;
}

Quote:

New to ASP.NET Core MVC, view components are similar to partial views, but they're much more powerful. View components don't use model binding, and only depend on the data provided when calling into it. A view component:

- Renders a chunk rather than a whole response.
- Includes the same separation-of-concerns and testability benefits found between a controller and view.
- Can have parameters and business logic.
- Is typically invoked from a layout page.

View components are intended anywhere you have reusable rendering logic that's too complex for a partial view, such as:

- Dynamic navigation menus // bingo!! this is what we're looking for!!

public class MenuItemsViewComponent: ViewComponent
{
    public async Task<IViewComponentResult> InvokeAsync(int parentId, string email)
    {
        var response = await new MenuServices().GetModulesItemsForUser(parentId, email);
         
        return View(response);
    }
}

@model Common.Models.MainMenuModels
    
@if (Model != null && Model.MenuItems != null && Model.MenuItems.Any())
{
    foreach (var menuitem in Model.MenuItems)
    {
        <a asp-page=@menuitem.Routing>@menuitem.DisplayText</a>
    }
}

@await Component.InvokeAsync("MenuItems", 0, "myemail@company.co.uk")

public class LoggingService
{
    private readonly TelemetryClient _telemetryClient = new TelemetryClient();

    public void TrackEvent(string eventName, TimeSpan timespan, IDictionary<string, string> properties = null)
    {
        var telemetry = new EventTelemetry(eventName);
        telemetry.Metrics.Add("Elapsed", timespan.TotalMilliseconds);
        if (properties != null)
        {
            foreach (var property in properties)
            {
                telemetry.Properties.Add(property.Key, property.Value);
            }
        }

        this._telemetryClient.TrackEvent(eventName, properties);
        this._telemetryClient.TrackEvent(telemetry);
    }
}

stopwatch.Restart();
try
{
    //make an request to a service
    var response = await new MyService().GetMyData(param1, param2);
}
catch (Exception ex)
{
    service.TrackException(ex);
    throw;
}
finally
{
    stopwatch.Stop();
    var properties = new Dictionary<string, string>
    {
        { "param1", param1 },
        { "param2", param2 }
    };
    service.TrackEvent("GetMyData", stopwatch.Elapsed, properties);
}

public class IndexModel : PageModel
{
    //rest of code goes here
}

public class PageModelBase<T>: PageModel where T : PageModelService, new()
{
    public readonly T Service = new T();
}

public abstract class PageModelService
{
    protected abstract string ModuleName { get; }
}

public class ExamplePageModelService : PageModelService
{
    public ExamplePageModelService ()
    {
        ModuleName = "Example Module;
    }
    protected override string ModuleName { get; }
}

public class ExamplePageModel : PageModelBase<ExamplePageModelService>
{
    public OnPost()
    {

    }

    public void OnGet()
    {
            
    }
}

dotnet test "MyProject.Tests.csproj" --no-build --no-restore /p:CollectCoverage=true

@{
    ViewData["Title"] = "Security";
}
<h2>Secure</h2>

<dl>
    @foreach (var claim in User.Claims)
    {
        <dt>@claim.Type</dt>
        <dd>@claim.Value</dd>
    }
</dl>

User.Claims

@echo off
cls

ECHO Setting version number to %1

cd <projectFolder>
dotnet restore
dotnet setversion %1

public interface ILoginData<TEntity, TModel>
{
    TEntity FindByUsername(TModel model);
}

public class UserModel
{
    public string Email { get; set; }
    public string Password { get; set; }
}

public class UsersData : ILoginData<UserEntity, UserModel>
{
    public UserEntity FindByUsername(UserModel model)
    {
        UserEntity result = null;
        if (!string.IsNullOrEmpty(model?.Email))
        {
            result = this.GetUserByEmail(model.Email);
        }
        return result;
    }
}

public interface ILoginService<T>
{
    T LoginUser(string username, string password);
}

public class WebLoginService : ILoginService<UserEntity>
    
    //ensure that our data class implements our interface from earlier so that we can 
    //guarantee that is contains the method FindByUsername()
    private readonly ILoginData<UserEntity, UserModel> _data;

    public UserEntity LoginUser(string username, string password)
    {
        UserEntity result = null;

        if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
        {
            UserModel user = new UserModel
            {
                UserName = username,
                Password = password,
            };
            result = this._data.FindByUsername(user);
            if (result != null)
            {
                //check if the user's email address and the entered password matches the one in the database
                result.IsAuthenticated = string.CompareOrdinal(password, result.Password) == 0;
            }
        }
        return result;
    }
}

result = this._data.FindByUsername(user);

public WebLoginService(ILoginData<UserEntity, UserModel> data)
{
    this._data = data;
}

@model Common.Models.EmailRequests.UnitTestModel

<h1>This is a Unit Test Email Razor Template</h1>
<h2>User Details</h2>
<h3>Name: @Model.Name</h3>
<h3>Company: @Model.Company</h3>
<h3>Telephone: @Model.Telephone</h3>

<h2>Car Details</h2>
<h3>Registration: @Model.Registration</h3>
<h3>Description: @Model.Description</h3>

namespace Common.Models.EmailRequests
{
    public class UnitTestModel 
    {
        public string Registration { get; set; }
        public string Description { get; set; }
        public string Name { get; set; }
        public string Forename { get; set; }
        public string Surname { get; set; }
        public string Telephone { get; set; }
        public string Company { get; set; }
    }
}

/// <summary>
/// Generate an HTML document from the specified Razor template and model.
/// </summary>
/// <param name="rootpath">The path to the folder containing the Razor templates</param>
/// <param name="templatename">The name of the Razor template (.cshtml)</param>
/// <param name="templatekey">The template key used for caching Razor templates which is essential for improved performance</param>
/// <param name="model">The model containing the information to be supplied to the Razor template</param>
/// <returns></returns>
public string RunCompile(string rootpath, string templatename, string templatekey, object model)
{
    string result = string.Empty;

    if (string.IsNullOrEmpty(rootpath) || string.IsNullOrEmpty(templatename) || model == null) return result;

    string templateFilePath = Path.Combine(rootpath, templatename);

    if (File.Exists(templateFilePath))
    {
        string template = File.ReadAllText(templateFilePath);

        if (string.IsNullOrEmpty(templatekey))
        {
            templatekey = Guid.NewGuid().ToString();
        }
        result = Engine.Razor.RunCompile(template, templatekey, null, model);
    }
    return result;
}

<h1>This is a Unit Test Email</h1>
<h2>User Details</h2>
<h1>Name: Mr Unit Test</h1>
<h1>Company: Unit Test Company</h1>
<h1>Telephone: 01536536536</h1>

<h2>Car Details</h2>
<h1>Registration: UT01UNIT</h1>
<h1>Description: Ford Mustang</h1>

var msg = new SendGridMessage();
msg.SetFrom(new EmailAddress(joe.bloggs@company.co.uk, "Development Manager"));

var recipients = new List<EmailAddress>
{
    new EmailAddress(fred.smith@company.co.uk, "Software Developer")
};
msg.AddTos(recipients);
msg.SetSubject("Please ignore - Testing the SendGrid C# Library");
msg.AddContent(MimeType.Html, "<p>Hello World!</p>");
var client = new SendGridClient("place_your_api_key_here");
var response = await client.SendEmailAsync(msg);

Console.WriteLine($"Response from SendGrid demo email: {response.StatusCode}");
Console.WriteLine("Press any key to finish.......");
Console.ReadKey();

{"QuerySearchTerms":{"email":"test@mycompany.co.uk"}}

[DataContract]
    public class WebQueryTasks
    {
        [DataMember]
        public Dictionary<string, object> QuerySearchTerms { get; set; }

        /// <summary>
        /// Default constructor
        /// </summary>
        public WebQueryTasks()
        {
            this.QuerySearchTerms = new Dictionary<string, object>();
        }
    }

public string WebGetData(string queryname, string queryterms)
        {
            //initial checks such as validation and parameter checking

            try
            {
		//deserialise the JSON array structure
                WebQueryTasks query = ManagerHelper.SerializerManager().DeserializeObject<WebQueryTasks>(queryterms);
                if (query == null || !query.QuerySearchTerms.Any())
                {
                    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError("Unable to deserialise search terms.")));
                }
                
                object temp;
                string webResults;
		//detemine the type of the query
                switch (queryname.ToLower())
                {
                    case WebTasksTypeConstants.GetCompanyByName:
                        webResults = this._userService.GetQuerySearchTerm("name", query);
                        if (!string.IsNullOrEmpty(webResults))
                        {
                            temp = this._companiesService.Find(webResults);
                        }
                        else
                        {
                            throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError("Unable to locate query search term(s).")));
                        }
                        break;
                    case WebTasksTypeConstants.GetUserByEmail:
                        webResults = this._userService.GetQuerySearchTerm("email", query);
                        if (!string.IsNullOrEmpty(webResults))
                        {
                            temp = this._userService.FindByEmail(webResults);
                        }
                        else
                        {
                            throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError("Unable to locate query search term(s).")));
                        }
                        break;
                    default:
                        throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest,
                            new HttpError($"Unknown query type {queryname}.")));
                }
                var result = ManagerHelper.SerializerManager().SerializeObject(temp);
                return result;
            }
            catch (Exception ex)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError("Exception servicing request.")));
            }
        }