Dominic Burford - Professional Profile

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;
}

[HttpPost]
[EnableCors(origins: "*", headers: "*", methods: "*")]
public async Task<HttpResponseMessage> WebPostData(string formname, [FromBody] JToken postdata)
{
    //log the request
    base.LogMessage(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", GetType().Name, "WebPostDataToServiceBus"));
    base.LogMessage($"Formname={formname}");

    //authenticate the request
    if (!base.IsRequestAuthenticated())
    {
        base.LogMessage("Request failed authentication");
        throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.Forbidden));
    }
    //add the request to the service bus for processing
    return await this.AddWebTaskToServiceBus(formname, postdata);
}

"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")