Shazwazza

Isolated WebApi attribute routing

Thu, 23 Mar 2023 15:08:15 Z

Attribute routing in ASP.Net WebApi is great and makes routing your controllers quite a bit more elegant than writing routes manually. However one problem I have with it is that it is either “on” or “off” at an application level. There is no way for a library developer to tell ASP.Net to create routes based on attributes for specific controllers or assemblies without forcing the consumer of that library to enable Attribute Routing for the whole application. In many cases this might not matter, but if you are creating a package or library of that contains it’s own API routes, you probably don’t want to interfere with a developers’ normal application setup. There should be no reason why they need to be forced to turn on attribute routing in order for your product to work, and similarly they might not want your routes automatically enabled.

The good news is that this is possible. With a bit of code, you can route your own controllers with attribute routing and be able to turn them on or off without affecting the default application attribute routes. A full implementation of this has been created for the Umbraco RestApi project so I’ll reference that source in this post for the following code examples.

Show me the code

They key to getting this to work is: IDirectRouteProvider, IDirectRouteFactory

The first thing we need is a custom IDirectRouteFactory which is actually a custom attribute. I’ve called this CustomRouteAttribute but you could call it whatever you want.

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class CustomRouteAttribute : Attribute, IDirectRouteFactory

This custom attribute just wraps the default WebApi RouteAttribute’s IDirectRouteFactory implementation so we don’t have to re-write any code for that.

(see full implementation here)

Next we’ll create a custom IDirectRouteProvider:

/// <summary>
/// This is used to lookup our CustomRouteAttribute instead of the normal RouteAttribute so that 
/// we can use the CustomRouteAttribute instead of the RouteAttribute on our controlles so the normal
/// MapHttpAttributeRoutes method doesn't try to route our controllers - since the point of this is
/// to be able to map our controller routes with attribute routing explicitly without interfering
/// with default application routes.
/// </summary>
public class CustomRouteAttributeDirectRouteProvider : DefaultDirectRouteProvider
{
    private readonly bool _inherit;

    public CustomRouteAttributeDirectRouteProvider(bool inherit = false)
    {
        _inherit = inherit;
    }

    protected override IReadOnlyList<IDirectRouteFactory> GetActionRouteFactories(HttpActionDescriptor actionDescriptor)
    {
        return actionDescriptor.GetCustomAttributes<CustomRouteAttribute>(inherit: _inherit);
    }
}

So far this is all pretty straight forward so far but here’s where things start to get interesting. Because we only want to create routes for specific controllers, we need to use a custom IHttpControllerTypeResolver. However, since the HttpConfiguration instance only contains a single reference to the IHttpControllerTypeResolver we need to do some hacking. The route creation process for attribute routing happens during the HttpConfiguration initialization so we need to create an isolated instance of HttpConfiguration, set it up with the services we want to use, initialize it to create our custom routes and assign those custom routes back to the main application’s HttpConfiguration.

Up first, we create a custom IHttpControllerTypeResolver to only resolve the controller we’re looking for:

public class SpecificControllerTypeResolver : IHttpControllerTypeResolver
{
    private readonly IEnumerable<Type> _controllerTypes;

    public SpecificControllerTypeResolver(IEnumerable<Type> controllerTypes)
    {
        if (controllerTypes == null) throw new ArgumentNullException("controllerTypes");
        _controllerTypes = controllerTypes;
    }

    public ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
    {
        return _controllerTypes.ToList();
    }
}

Before we look at initializing a separate instance of HttpConfiguration, lets look at the code you’d use to enable all of this in your startup code:

//config = the main application HttpConfiguration instance
config.MapControllerAttributeRoutes(
    routeNamePrefix: "MyRoutes-",
    //Map these explicit controllers in the order they appear
    controllerTypes: new[]
    {                    
        typeof (MyProductController),
        typeof (MyStoreController)
    });

The above code will enable custom attribute routing for the 2 specific controllers. These controllers will be routed with attribute routing but instead of using the standard [Route] attribute, you’d use our custom [CustomRoute] attribute. The MapControllerAttributeRoutes extension method is where all of the magic happens, here’s what it does:

Iterates over each controller type
Creates an instance of HttpConfiguration
Sets it’s IHttpControllerTypeResolver instance to SpecificControllerTypeResolver for the current controller iteration (The reason an instance of HttpConfiguration is created for each controller is to ensure that the routes are created in the order of which they are specified in the above code snippet)
Initialize the HttpConfiguration instance to create the custom attribute routes
Copy these routes back to the main application’s HttpConfguration route table

You can see the full implementation of this extension method here which includes code comments and more details on what it’s doing. The actual implementation of this method also allows for some additional parameters and callbacks so that each of these routes could be customized if required when they are created.

There is obviously a bit of code involved to achieve this and there could very well be a simpler way, however this implementation does work rather well and offers quite a lot of flexibility. I’d certainly be interested to hear if other developers have figured this out and what their solutions were.

Consume Json REST service with WCF and dynamic object response

Thu, 23 Mar 2023 15:08:09 Z

This post was imported from FARMCode.org which has been discontinued. These posts now exist here as an archive. They may contain broken links and images.

This was my first shot at WCF and though I saw how nice it could be, i failed miserably… well, I’m actually not too sure. I tried all sorts of things but no matter what couldn’t get WCF to behave and return the actual response you would get if you just consumed the service with the WebClient object. Here’s what I tried and assumed that this ‘should’ work but the result was always an empty dictionary:

Note: this demo is based off of the @Task project management tool’s REST API.

Define the contract:

[ServiceContract]
public interface IAtTaskService
{        
    [OperationContract]
    [WebGet(
        UriTemplate = "/api/login?username={username}&password={password}", 
        RequestFormat = WebMessageFormat.Json)]
    IDictionary<string, object> Login(string username, string password);
}

Run the code:

public IDictionary<string, object> DoThis(string username, string pword)
{
    using (var cf = new WebChannelFactory<IAtTaskService>(
        new Uri("https://mycompaniesurl.attask-ondemand.com/attask/")))
    {
        var s = cf.CreateChannel();
        var token = s.Login(username, pword);
        return token;
    } 
}

The above seemed really nice to be able to consume services but the result was always empty. I tried using strongly typed objects in the result, made sure it wasn’t an HTTPS issue, used the normal WCF configuration approach, etc… but couldn’t get it to work.

The ‘Fix’

I quite like the way that WCF has UriTemplates and you can just attribute up an interface and then make strongly typed calls to access your services so i decided I’d just make that work with my own implementation. Again, perhaps I was ‘doing it wrong’ or whatever, but the below implementation is pretty cool and also lets you get JSON results as a dynamic object :)

Define the contract:

This is pretty much the same as above, but we have a dynamic response

[ServiceContract]
public interface IAtTaskService
{        
    [OperationContract]
    [WebGet(
        UriTemplate = "/api/login?username={username}&password={password}", 
        RequestFormat = WebMessageFormat.Json)]
    dynamic Login(string username, string password);
}

The JsonRestService base class

I created a class that lets you specify you contract service as a generic argument and then provides you with a method called “Send” which is defined a:

protected dynamic Send(Func<T, dynamic> func)

This class will manage all of the http requests and use the WCF attributes applied to your contract to generate the correct URLs and parameters (source code at the bottom of this article)

Define a standard service

So to consume the REST services, we just create a ‘real’ service class such as:

public class AtTaskService : JsonRestService<IAtTaskService>, IAtTaskService
{
    public AtTaskService(string serviceUrl)
        : base(serviceUrl)
    {
    }

    public dynamic Login(string username, string password)
    {
        return Send(x => x.Login(username, password));
    }
}

As you can see, the “Login” method just calls the underlying “Send” method which uses a strongly typed delegate. The Send method then inspects the delegate and generates the correct URL with parameters based on the WCF attributes.

Using the service

So now, to use the new service we can do something like:

[TestMethod]
public void AtAtask_Login()
{

    //Arrange
    var svc = new AtTaskService("https://mycompanyname.attask-ondemand.com/attask/");
            
    //Act
    var token = svc.Login("MyUserName", "mypassword");
            
    //Assert
    Assert.IsTrue(token != null);
    Assert.IsTrue(token.data != null);
    Assert.IsTrue(token.data.userID != null);        
}

Too easy!

As I mentioned earlier, I would have assumed that WCF should handle this out of the box, but for the life of my I couldn’t get it to return any results. Whether it was a request issue or a parsing issue, or whatever i have no idea. In the meantime, here’s the source code for the JsonRestService class which will allow you to do the above. The source requires references to Json.Net and Aaron-powell.dynamics

JsonRestService source

Disclaimer: I made this today in a couple of hours, I’m sure there’s some code in here that could be refactored to be nicer

public class JsonRestService<T>
{
    public string ServiceUrl { get; private set; }

    public JsonRestService(string serviceUrl)
    {
        ServiceUrl = serviceUrl;
    }

    /// <summary>
    /// Queries the WCF attributes of the method being called, builds the REST URL and sends the http request
    /// based on the WCF attribute parameters. When the JSON response is returned, it is changed to a dynamic object.
    /// </summary>
    /// <param name="func"></param>
    /// <returns></returns>
    protected dynamic Send(Func<T, dynamic> func)
    {
        //find the method on the main type that is being called... i'm sure there's a better way to do this,
        //but this does work.
        //This will not work if there are methods with overloads.
        var methodNameMatch = Regex.Match(func.Method.Name, "<(.*?)>");
        if (!methodNameMatch.Success && methodNameMatch.Groups.Count == 2)
        {
            throw new MissingMethodException("Could not find method " + func.Method.Name);
        }
        var realMethodName = methodNameMatch.Groups[1].Value;
        var m = typeof(T).GetMethods().Where(x => x.Name == realMethodName).SingleOrDefault();
        if (m == null)
        {
            throw new MissingMethodException("Could not find method" + realMethodName + " on type " +
                                                typeof(T).FullName);
        }

        //now that we have the method, find the wcf attributes
        var a = m.GetCustomAttributes(false);
        var webGet = a.OfType<WebGetAttribute>().SingleOrDefault();
        var webInvoke = a.OfType<WebInvokeAttribute>().SingleOrDefault();
        var httpMethod = webGet != null ? "GET" : webInvoke != null ? webInvoke.Method : string.Empty;
        if (string.IsNullOrEmpty(httpMethod))
        {
            throw new ArgumentNullException("The WebGet or WebInvoke attribute is missing from the method " +
                                            realMethodName);
        }

        //now that we have the WCF attributes, build the REST url based on the url template and the
        //method being called with it's parameters
        var urlTemplate = webGet != null ? webGet.UriTemplate : webInvoke.UriTemplate;
        var urlWithParams = GetUrlWithParams(urlTemplate, func);
        var url = ServiceUrl + urlWithParams;

        //Do the web requests
        string output;
        if (httpMethod == "GET")
        {
            output = HttpGet(url);
               
        }
        else
        {
            //need to move the query string params to the http parameters
            var parts = url.Split('?');
            output = HttpInvoke(parts[0], httpMethod, parts.Length > 1 ? parts[1] : string.Empty);
        }

        //change the response to json and then dynamic
        var stringReader = new StringReader(output);
        var jReader = new JsonTextReader(stringReader);
        var jsonSerializer = new JsonSerializer();
        var json = jsonSerializer.Deserialize<Dictionary<string, object>>(jReader);
        return json.AsDynamic();
    }

    /// <summary>
    /// Updates the url template with the correct parameters
    /// </summary>
    /// <param name="template"></param>
    /// <param name="expression"></param>
    /// <returns></returns>
    private static string GetUrlWithParams(string template, Func<T, dynamic> expression)
    {
        //parse the template, get the matches
        foreach (var m in Regex.Matches(template, @"\{(.*?)\}").Cast<Match>())
        {
            if (m.Groups.Count == 2)
            {
                var m1 = m;
                //find the fields based on the expression(Func<T>), get their values and replace the tokens in the url template
                var field = expression.Target.GetType().GetFields().Where(x => x.Name == m1.Groups[1].Value).Single();
                template = template.Replace(m.Groups[0].Value, field.GetValue(expression.Target).ToString());
            }
        }
        return template;
    }

    /// <summary>
    /// Do an Http GET
    /// </summary>
    /// <param name="uri"></param>
    /// <returns></returns>
    private static string HttpGet(string uri)
    {
        var webClient = new WebClient();
        var data = webClient.DownloadString(uri);
        return data;
    }

    /// <summary>
    /// Do an Http POST/PUT/etc...
    /// </summary>
    /// <param name="uri"></param>
    /// <param name="method"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    private static string HttpInvoke(string uri, string method, string parameters)
    {
        var webClient = new WebClient();
        var data = webClient.UploadString(uri, method, parameters);
        return data;
    }
}

Uploading files and JSON data in the same request with Angular JS

Thu, 23 Mar 2023 15:08:08 Z

I decided to write a quick blog post about this because much of the documentation and examples about this seems to be a bit scattered. What this achieves is the ability to upload any number of files with any other type of data in one request. For this example we’ll send up JSON data along with some files.

File upload directive

First we’ll create a simple custom file upload angular directive

app.directive('fileUpload', function () {
    return {
        scope: true,        //create a new scope
        link: function (scope, el, attrs) {
            el.bind('change', function (event) {
                var files = event.target.files;
                //iterate files since 'multiple' may be specified on the element
                for (var i = 0;i<files.length;i++) {
                    //emit event upward
                    scope.$emit("fileSelected", { file: files[i] });
                }                                       
            });
        }
    };
});

The usage of this is simple:

<input type="file" file-upload multiple/>

The ‘multiple’ parameter indicates that the user can select multiple files to upload which this example fully supports.

In the directive we ensure a new scope is created and then listen for changes made to the file input element. When changes are detected with emit an event to all ancestor scopes (upward) with the file object as a parameter.

Mark-up & the controller

Next we’ll create a controller to:

Create a model to bind to
Create a collection of files
Consume this event so we can assign the files to the collection
Create a method to post it all to the server

NOTE: I’ve put all this functionality in this controller for brevity, in most cases you’d have a separate factory to handle posting the data

With the controller in place, the mark-up might look like this (and will display the file names of all of the files selected):

<div ng-controller="Ctrl">
    <input type="file" file-upload multiple/>
    <ul>
        <li ng-repeat="file in files">{{file.name}}</li>
    </ul>
</div>

The controller code below contains some important comments relating to how the data gets posted up to the server, namely the ‘Content-Type’ header as the value that needs to be set is a bit quirky.

function Ctrl($scope, $http) {

    //a simple model to bind to and send to the server
    $scope.model = {
        name: "",
        comments: ""
    };

    //an array of files selected
    $scope.files = [];

    //listen for the file selected event
    $scope.$on("fileSelected", function (event, args) {
        $scope.$apply(function () {            
            //add the file object to the scope's files collection
            $scope.files.push(args.file);
        });
    });
    
    //the save method
    $scope.save = function() {
        $http({
            method: 'POST',
            url: "/Api/PostStuff",
            //IMPORTANT!!! You might think this should be set to 'multipart/form-data' 
            // but this is not true because when we are sending up files the request 
            // needs to include a 'boundary' parameter which identifies the boundary 
            // name between parts in this multi-part request and setting the Content-type 
            // manually will not set this boundary parameter. For whatever reason, 
            // setting the Content-type to 'false' will force the request to automatically
            // populate the headers properly including the boundary parameter.
            headers: { 'Content-Type': false },
            //This method will allow us to change how the data is sent up to the server
            // for which we'll need to encapsulate the model data in 'FormData'
            transformRequest: function (data) {
                var formData = new FormData();
                //need to convert our json object to a string version of json otherwise
                // the browser will do a 'toString()' on the object which will result 
                // in the value '[Object object]' on the server.
                formData.append("model", angular.toJson(data.model));
                //now add all of the assigned files
                for (var i = 0; i < data.files; i++) {
                    //add each file to the form data and iteratively name them
                    formData.append("file" + i, data.files[i]);
                }
                return formData;
            },
            //Create an object that contains the model and files which will be transformed
            // in the above transformRequest method
            data: { model: $scope.model, files: $scope.files }
        }).
        success(function (data, status, headers, config) {
            alert("success!");
        }).
        error(function (data, status, headers, config) {
            alert("failed!");
        });
    };
};

Handling the data server-side

This example shows how to handle the data on the server side using ASP.Net WebAPI, I’m sure it’s reasonably easy to do on other server-side platforms too.

public async Task<HttpResponseMessage> PostStuff()
{
    if (!Request.Content.IsMimeMultipartContent())
    {
        throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
    }

    var root = HttpContext.Current.Server.MapPath("~/App_Data/Temp/FileUploads");
    Directory.CreateDirectory(root);
    var provider = new MultipartFormDataStreamProvider(root);
    var result = await Request.Content.ReadAsMultipartAsync(provider);
    if (result.FormData["model"] == null)
    {
        throw new HttpResponseException(HttpStatusCode.BadRequest);
    }

    var model = result.FormData["model"];
    //TODO: Do something with the json model which is currently a string


    //get the files
    foreach (var file in result.FileData)
    {                
        //TODO: Do something with each uploaded file
    }

    return Request.CreateResponse(HttpStatusCode.OK, "success!");
}