Dominic Burford - Professional Profile

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.")));
            }
        }

-- =============================================
-- Author:		Dominic Burford
-- Create date: 21/09/2017
-- Description:	Upsert a user
-- =============================================
CREATE PROCEDURE [dbo].[Users_Upsert] 
	@username VARCHAR(128),
	@email VARCHAR(128)
AS
BEGIN

    -- are we inserting a new record or updating an existing one?
	SELECT ID FROM	Users
		WHERE Email = @email

	IF @@ROWCOUNT = 0
		BEGIN
			INSERT INTO Users
			(
				UserName,
				Email
			)
			VALUES
			(
				@username,
				@email
			)
		END
	ELSE
		BEGIN
			UPDATE Users
				SET UserName = @username,
				Updated = GETDATE()
				WHERE Email = @email

		END
END

GO

int counter = GetNewCounterValue();

if (counter == 0)
{
    //do something here
}

Wikipedia:

Defensive programming is a form of defensive design intended to ensure the continuing function of a piece of software under unforeseen circumstances. Defensive programming practices are often used where high availability, safety or security is needed.

Assert()

SqlConnection connection = new SqlConnection("myDatabaseConnectionString");
connection.Open(); //what if this line of code fails!!
SqlCommand cmd = new SqlCommand("myStoredProcedure", connection)

SqlDataReader reader = cmd.ExecuteReader();
string firstName= reader["firstName"]; //what if there was no data or the value for firstname is null!!

MyMoneyClass money; //declared but not initialised
decimal funds = money.GetFunds(); //this will cause an error as it has not been initialised!!