Dominic Burford - Professional Profile

public async Task<string> Get(string subscriber, string trackertype)
{
  var response = await this.GetData(subscriber, trackertype);
  return response;
}

[TestMethod]
public async Task GetVehicleTests()
{
  //Arrange
  TrackerController controller = new TrackerController();

  //Act
  string subscriber = "testsubscriber";
  string vehicle = "testvehicle";    
  var response = controller.Get(subscriber, vehicle);

  //Assert
  Assert.IsNotNull(response);
  Assert.IsNotNull(response.Result.ToString());
}

[TestMethod]
public async Task GetVehicleTests()
{
  //Arrange
  TrackerController controller = new TrackerController();

  //Act
  string subscriber = "testsubscriber";
  string vehicle = "testvehicle";    
  var response = await controller.Get(subscriber, vehicle);

  //Assert
  Assert.IsNotNull(response);
  Assert.IsNotNull(response.ToString());
}

public async Task<string> Get(string subscriber, string trackertype)
{
  var response = await this.GetData(subscriber, trackertype).ConfigureAwait(false);
  return response;
}

public class WebTasksController : BaseController
{
  public WebTasksController()
  {
  }

  public string WebGetData(string queryname, string queryterms)
  {
  }
}

[HttpGet]
[EnableCors(origins: "*", headers: "*", methods: "*")]
public string WebGetData(string queryname, string queryterms)
{
}

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

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

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

var user = GetUser(emailaddress);
WebQueryTasks query = new WebQueryTasks();
query.QuerySearchTerms.Add("userid", user.Id);
query.QuerySearchTerms.Add("journeydate", Datetime.Now);
string queryterms = ManagerHelper.SerializerManager().SerializeObject(query);

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;
switch (queryname.ToLower())
{
  case WebTasksTypeConstants.GetCompanyByName:
    webResults = this._userService.GetQuerySearchTerm("name", query);
    temp = this._companiesService.Find(webResults);
    break;
  case WebTasksTypeConstants.GetCompanyById:
    webResults = this._userService.GetQuerySearchTerm("companyid", query);
    int companyId = Convert.ToInt32(webResults);
    temp = this._companiesService.Find(companyId);
    break;
  default:
    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError($"Unknown query type {queryname}.")));
}

var result = ManagerHelper.SerializerManager().SerializeObject(temp);
return result;

[HttpGet]
[EnableCors(origins: "*", headers: "*", methods: "*")]
public string WebGetData(string queryname, string queryterms)
{
  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;
  switch (queryname.ToLower())
  {
    case WebTasksTypeConstants.GetCompanyByName:
      webResults = this._userService.GetQuerySearchTerm("name", query);
      temp = this._companiesService.Find(webResults);
      break;
    case WebTasksTypeConstants.GetCompanyById:
      webResults = this._userService.GetQuerySearchTerm("companyid", query);
      int companyId = Convert.ToInt32(webResults);
      temp = this._companiesService.Find(companyId);
      break;
    default:
      throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError($"Unknown query type {queryname}.")));
  }

  var result = ManagerHelper.SerializerManager().SerializeObject(temp);
  return result;
}

What is Asynchronous Programming?

var myList = new List<string>();
myList.Add("item1");
myList.Add("item2");
myList.Add("item3");
myList.Remove("item1");

Asynchronous programming with C#

public async Task<HttpResponseMessage> PostData(string url, HttpContent content)
{
    using (var client = new HttpClient())
    {
        return await client.PostAsync(new Uri(url), content);
    }
}

var response = await PostData(url, content);

public async Task<string> GetData(string url)
{
    using (var client = new HttpClient())
    {
        using (var r = await client.GetAsync(new Uri(url)))
        {
            string result = await r.Content.ReadAsStringAsync();
            return result;
        }
    }
}

string response = await GetData(url);
if (!string.IsNullOrEmpty(response))
{
  //de-serialise the string into an object here
}

Key takeaways

dotnet publish -c release

Quote:

a legacy system is an old method, technology, computer system, or application program "of, relating to, or being a previous or outdated computer system"

CREATE VIEW [dbo].[v_CardDefinitions] AS
	SELECT 
		CardDefinitions.*,
		Cards.ID AS CardID,
		Cards.ParentID,
		Cards.[Index],
		Cards.UserID,
		Cards.CardDefinitionID,
		Users.Email AS UserEmail,
		Modules.Name AS ModuleName
	FROM 
		CardDefinitions
	LEFT JOIN
		Cards ON CardDefinitions.ID = Cards.CardDefinitionID
	JOIN
		Modules ON CardDefinitions.ModuleID = Modules.ID
	LEFT JOIN
		Users ON Cards.UserID = Users.ID
	WHERE 
		CardDefinitions.Active = 1

CREATE PROCEDURE [dbo].[Cards_GetById] 
	@cardId INT
AS
BEGIN
	-- SET NOCOUNT ON added to prevent extra result sets from
	-- interfering with SELECT statements.
	SET NOCOUNT ON;

    SELECT 
		DISTINCT ID, Name, [Permissions] 
	FROM 
		v_CardDefinitions 
	WHERE 
		ID = @cardId
END

CREATE FUNCTION [dbo].[Split]
(
	@List nvarchar(2000),
	@SplitOn nvarchar(5)
)  
RETURNS @RtnValue table 
(
		
	Id int identity(1,1),
	Value nvarchar(100)
) 
AS  
BEGIN 
	While (Charindex(@SplitOn,@List)>0)
	Begin

		Insert Into @RtnValue (value)
		Select 
			Value = ltrim(rtrim(Substring(@List,1,Charindex(@SplitOn,@List)-1)))

		Set @List = Substring(@List,Charindex(@SplitOn,@List)+len(@SplitOn),len(@List))
	End

	Insert Into @RtnValue (Value)
	Select Value = ltrim(rtrim(@List))
	
	Return
END

@List = '1, 2, 3, 4, 5'

@SplitOn = ','

CREATE PROCEDURE [dbo].[Documents_UpdateOwner] 
	@owner INT,
	@documentids NVARCHAR(1000)
AS
BEGIN
	UPDATE 
		Documents 
	SET 
		UploadedBy = @owner  
	WHERE 
		ID IN (SELECT CONVERT(INT, Value) FROM Split(@documentids, ',')) 
END

@echo off
cls

ECHO Setting version number to %1

cd <projectFolder>
dotnet restore
dotnet publish <project>.csproj --configuration Release /p:Version=%1

Quote:

the number of people who think social media is a net positive for society is down to 40 percent.

private async Task<string> GetValueFromTextbox(string controlId)
{
    return await WebView.EvaluateJavaScriptAsync($"document.getElementById('{controlId}').value;");
}
private async Task<string> GetValueFromCheckbox(string controlId)
{
    return await WebView.EvaluateJavaScriptAsync($"document.getElementById('{controlId}').checked;");
}
private async Task<string> GetValueFromRadioButton(string controlname)
{
    return await WebView.EvaluateJavaScriptAsync($"document.querySelector(\'input[name=\"{controlname}\"]:checked\').value;");
}
private async Task<string> GetValueFromDropdownn(string controlId)
{
    return await WebView.EvaluateJavaScriptAsync($"document.getElementById(\'{controlId}\').options[document.getElementById(\'{controlId}\').selectedIndex].value;");
}

public class BaseFormModel : NotifyPropertyChangedBase
{
}

public interface IFormData<T>
{
    T CreateDefaultModel();
}

public class MessageUsModel : BaseFormModel, IFormData<MessageUsModel>
{
    private string _messageToSend;

    [DisplayOptions(Header = MessageUsModelConstants.MessageHeader)]
    [NonEmptyValidator(MessageUsModelConstants.MessageError)]
    public string MessageToSend
    {
        get => _messageToSend;
        set
        {
            if (_messageToSend == value) return;
            _messageToSend = value;
            OnPropertyChanged();
        }
    }

    public MessageUsModel CreateDefaultModel()
    {
        return new MessageUsModel
        {
            _messageToSend = ""
        };
    }
}

public abstract class ViewModelBase<T> : NotifyPropertyChangedBase where T : new()
{
    /// <summary>
    /// This is the View-Model's reference to the Model. Use this whenever the view-model needs to reference the model.
    /// </summary>
    public T FormModel = new T();

    /// <summary>
    /// Implement this method in the derived class to define what actions to take when the user
    /// submits data from one of the data-entry forms 
    /// </summary>
    /// <returns></returns>
    public abstract Task PostCompleteTask();
}

public class MessageUsViewModel : ViewModelBase<MessageUsModel>
{
    public MessageUsModel MessageUsModel;
        
    public MessageUsViewModel()
    {
        this.MessageUsModel = this.FormModel.CreateDefaultModel();
    }

    public override async Task PostCompleteTask()
    {
        //implement your code here to submit the form data
    }
}

this.MessageUsModel = this.FormModel.CreateDefaultModel();

[XamlCompilation(XamlCompilationOptions.Compile)]
public partial class MessageUsView : ContentPage
{
    public MessageUsViewModel Muvm;

    public MessageUsView()
    {
        InitializeComponent();

        //initiate the view-model and bind it to the form
        this.Muvm = new MessageUsViewModel();
        this.BindingContext = this.Muvm;
    }

    private async void DataFormValidationCompleted(object sender, FormValidationCompletedEventArgs e)
    {
        dataForm.FormValidationCompleted -= this.DataFormValidationCompleted;

        if (e.IsValid)
        {
            await this.Muvm.PostCompleteTask();
        }
    }

    private void CommitButtonClicked(object sender, EventArgs e)
    {
        dataForm.FormValidationCompleted += this.DataFormValidationCompleted;
        dataForm.CommitAll();
    }
}

<input:RadDataForm x:Name="dataForm" CommitMode="Immediate"  />
<input:RadButton x:Name="CommitButton" Text="Save" Clicked="CommitButtonClicked" IsEnabled="True"/>

this.Muvm = new MessageUsViewModel();
this.BindingContext = this.Muvm;

WebPublishMethod=Package;
PackageFileName=$(Build.ArtifactStagingDirectory)\package.zip;
DesktopBuildPackageLocation=$(Build.ArtifactStagingDirectory)\package.zip;
PackageAsSingleFile=true;
PackageLocation=$(Build.ArtifactStagingDirectory)\package.zip;
DeployOnBuild=true;
DeployTarget=Package

$(Build.ArtifactStagingDirectory)

<div>
  rest of the Razor page goes here
</div>
<script>
    $(document).ready(function () {
        var queryparams = window.location.search;
        //using URLSearchParams to extract the querystring parameter
        if (queryparams && typeof (queryparams) === "string" && queryparams.length > 0) {
            var urlParams = new URLSearchParams(window.location.search);
            var documentid = urlParams.get('documentid');
            //call the JS function that will make the AJAX request and fetch the data
            loadDocumentManagerForDocument(documentid ); //see below for definition!
        }
    });
</script>

function loadDocumentManagerForDocument(documentid) {
    if (documentid) {

        //AJAX call to Razor page handler to fetch the document details

        $.ajax({
            type: "GET",
            url: `/DocumentManager/DocumentManager?handler=document&documentid=${documentid}`,
            contentType: "application/json",
            dataType: "json",
            success: function (response) {
                //populate the form elements with the returned data
            },
            failure: function (response) {
                //handle the error
            }
        });
    }
}

public async Task<JsonResult> OnGetDocument(int documentid)
{
    JsonResult result = null;
    var response = await new DocumentManagerPageModelService().GetDocumentById(documentid);
    result = new JsonResult(document);
    return result;
}