Hi Bjarne,

There's a few things you'll need to understand in order to know what is going on here. Firstly, there are global formatters and then there are controller specific formatters. By default global formatters will apply to ALL controllers in your solution - but if we allowed for developers to change the formatting of our data to whatever they want then everything would probably just break. Therefore for Umbraco's purposes - we apply controller specific formatters so we know exactly how the data will be formatted & cannot be tampered with so the back office doesn't break.

Here's what these controllers do:

• UmbracoAuthorizedApiController
  • https://github.com/umbraco/Umbraco-CMS/blob/dev-v7/src/Umbraco.Web/WebApi/UmbracoAuthorizedApiController.cs
  • As you can see this has a few attributes applied to it: Ensures that it's routed as a back office request, ensures browser cache is disabled for all responses, appends a custom header to the response to provide the user's timeout value and lastly ensures that the request is authorized to access the controller. As you can see there is absolutely nothing going on with Formatters here thus Global formatters will be applied to any controllers inheriting from this one that do not have controller specific formatters applied.
• UmbracoAuthorizedJsonController
  • https://github.com/umbraco/Umbraco-CMS/blob/dev-v7/src/Umbraco.Web/Editors/UmbracoAuthorizedJsonController.cs
  • There are 2 attributes applied here - one to verify Angular's CSRF tokens and one to apply a controller specific formatter.
  • This means that all controllers inheriting from this will NOT have global formatters applied to it. Controllers inheriting from this controller are specifically made to work with Angular in the Umbraco back office, that is it. This is why you get that strange prefixed json on the response, this is because it applies a very specific Angular json formatter: https://github.com/umbraco/Umbraco-CMS/blob/dev-v7/src/Umbraco.Web/WebApi/AngularJsonOnlyConfigurationAttribute.cs

So to answer your question, if you need to use UmbracoAuthorizedJsonController because you are creating angular based requests for the back office and you want to apply custom formatting output to that, then you need to apply a controller specific formatter to your controller. Or you can attribute your classes/properties with the correct DataContract bindings to specify the exact names you want.

If it's for back office use then you absolutely must continue to use the AngularJsonMediaTypeFormatter - you can create a sub-class of this to modify it and apply the CamelCasePropertyNamesContractResolver to it

using DataContract attribute is as mention. Please have a browse through our source code, there's hundreds of examples of all of this stuff in there.

Hi Shannon

Okay, I might take a look at it at some other time. For now I found it easiest just to add [DataContract] and [DataMember] attributes for the model class and properties.

using System;
using System.Runtime.Serialization;

namespace Reviews.Models
{
    [DataContract]
    public class Review
    {

    [DataMember(Name = "id", EmitDefaultValue = false)]
    public int Id { get; set; }

    [DataMember(Name = "name", EmitDefaultValue = false)]
    public string Name { get; set; }

    [DataMember(Name = "city", EmitDefaultValue = false)]
    public string City { get; set; }

    [DataMember(Name = "date", EmitDefaultValue = false)]
    public DateTime Date { get; set; }

    [DataMember(Name = "destination", EmitDefaultValue = false)]
    public string Destination { get; set; }

    [DataMember(Name = "header", EmitDefaultValue = false)]
    public string Header { get; set; }

    [DataMember(Name = "hotel", EmitDefaultValue = false)]
    public string Hotel { get; set; }

    [DataMember(Name = "hotelRating", EmitDefaultValue = false)]
    public int HotelRating { get; set; }

    [DataMember(Name = "rating", EmitDefaultValue = false)]
    public int Rating { get; set; }

    [DataMember(Name = "showComment", EmitDefaultValue = false)]
    public bool ShowComment { get; set; }

    [DataMember(Name = "text", EmitDefaultValue = false)]
    public string Text { get; set; }

    [DataMember(Name = "photo", EmitDefaultValue = false)]
    public string Photo { get; set; }
}

[DataContract]
public class ReviewSearchResult
{
    [DataMember(Name = "id", EmitDefaultValue = false)]
    public int Id { get; set; }

    [DataMember(Name = "name", EmitDefaultValue = false)]
    public string Name { get; set; }

    [DataMember(Name = "url", EmitDefaultValue = false)]
    public string Url { get; set; }

    [DataMember(Name = "path", EmitDefaultValue = false)]
    public string Path { get; set; }

    [DataMember(Name = "review", EmitDefaultValue = false)]
    public Review Review { get; set; }
  }
}

or using [JsonProperty] in Newtonsoft.Json

using Newtonsoft.Json;
using System;

namespace Reviews.Models
{
    public class Review
    {

    [JsonProperty("id")]
    public int Id { get; set; }

    [JsonProperty("name")]
    public string Name { get; set; }

    [JsonProperty("city")]
    public string City { get; set; }

    [JsonProperty("date")]
    public DateTime Date { get; set; }

    [JsonProperty("destination")]
    public string Destination { get; set; }

    [JsonProperty("header")]
    public string Header { get; set; }

    [JsonProperty("hotel")]
    public string Hotel { get; set; }

    [JsonProperty("hotelRating")]
    public int HotelRating { get; set; }

    [JsonProperty("rating")]
    public int Rating { get; set; }

    [JsonProperty("showComment")]
    public bool ShowComment { get; set; }

    [JsonProperty("text")]
    public string Text { get; set; }

    [JsonProperty("photo")]
    public string Photo { get; set; }
}

public class ReviewSearchResult
{
    [JsonProperty("id")]
    public int Id { get; set; }

    [JsonProperty("name")]
    public string Name { get; set; }

    [JsonProperty("url")]
    public string Url { get; set; }

    [JsonProperty("path")]
    public string Path { get; set; }

    [JsonProperty("review")]
    public Review Review { get; set; }
    }
}

Thanks,

Bjarne

Hi Shannon,

Where in the source code I can check what global formatters are applied to all controllers?

Thanks

Here's the code in case anyone is wondering how to create the attribute to return the data in camel case

public class AngularJsonMediaFormatterCamelCase : AngularJsonMediaTypeFormatter
{
    public AngularJsonMediaFormatterCamelCase()
    {
        SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
    }
}

public class AngularJsonOnlyConfigurationCamelCaseAttribute : AngularJsonOnlyConfigurationAttribute
{

    public override void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
    {
        var toRemove = controllerSettings.Formatters.Where(t => (t is JsonMediaTypeFormatter) || (t is XmlMediaTypeFormatter)).ToList();
        foreach (var r in toRemove)
        {
            controllerSettings.Formatters.Remove(r);
        }
        controllerSettings.Formatters.Add(new AngularJsonMediaFormatterCamelCase());
    }

}

Cheers.

is working on a reply...