JSON API Implementation In .NET Core Without Using DBContext

JSON API implementation in the .NET core without DBContext and it will support for any type of patterns here is my new blog for JSON API with support in .NET Core with DDD model or any other design patterns.

Here is my new blog about JSON API with support in .NET Core with DDD model or any other design pattern.

 

Introduction

JSON API is a specification for how a client should request that resources be fetched or modified, and how a server should respond to those requests.

JSON API is designed to minimize both the number of requests and the amount of data transmitted between clients and servers. This efficiency is achieved without compromising readability, flexibility, or discoverability.

The current version of JSON API is 1.0. and will always be backward compatible. And JSON API requires the use of the JSON API media type application/vnd.api+jsonfor exchanging data.

services.AddJsonApi<AppDbContext>();

But in DDD model we will not expose our entities in the controller, like below.

public class ArticlesController : JsonApiController<Article>
{
    public ArticlesController(
        IJsonApiContext jsonApiContext,
        IResourceService<Article> resourceService)
    : base(jsonApiContext, resourceService) { }
}

Also in this implementation we have overriden all our GET, PUT, Update and Delete commands. Because JSON API has their own implementions.

 

Also, I have seen the main drawback with filtering is that it will work in case-sensitive mode. In case you send your attribute and value in a different model, it will throw you an error. If you have seen JSON API code in GitHub you will find these codes.

Class Customer{
  public string FirstName {get; set;}
  public string LastName {get; set;}
  }

// Also There were doing un-necessary implemenation to make first letter in the attribute make Uppercase.
// eg:- URL:- /api/articles?filter[firstname]=sam

private List<FilterQuery> ParseFilterQuery(string key, string value)
{
var queries = new List<FilterQuery>();

var propertyName = key.Split('[', ']')[1].ToProperCase();
}

 // Atribute name look like FirstName, once they apply Propercase method
var concreteType = typeof(TSource);
var property = concreteType.GetProperty(filterQuery.FilteredAttribute.InternalAttributeName);
if (property == null)
throw new ArgumentException($"'{filterQuery.FilteredAttribute.InternalAttributeName}' is not a valid property of '{concreteType}'");

// here it will throw you the exception because it is not able to find the Attribute name, hence your sending filter with lower case

Also, JSON API will first fetch data and then apply filtering, sorting, and paging. 

 

So, I have created a custom JSON API with the support of a large-scale application and it will fetch the data from the database rather than using an in-memory query.  In regards to filter, I will explain to you how our library will support us to fetch data using filters.

 

First, we have to install my custom library, here is the code:

Install-Package VisionPlanner.JsonAPI -Version 1.1.1

Once we have installed this package, we can now register in startup class as shown below,

services.AddJsonApi(opt =>
            {
                opt.Namespace = "api/v1";
                opt.DefaultPageSize = 5;
                opt.IncludeTotalRecordCount = true;
            });

Then we have to inject services which are provided by the library in controller constructor.

public class JsonAPISuccessController : Controller
   {
       private readonly IJsonoutputService _jsonoutputService;

       public JsonAPISuccessController(IJsonoutputService jsonoutputService)
       {
           _jsonoutputService = jsonoutputService;
       }
}

And we have to inject the same service in your repository class because here we are implementing the actual logic to fetch the data from the database using filter expressions.

public class ModelService
{
    private readonly IJsonoutputService _jsonoutputService;

    public ModelService(IJsonoutputService jsonoutputService)
    {
        _jsonoutputService = jsonoutputService;
    }
}

In this service we have all the data access methods like select, insert, update and delete etc. Here, we are going to write one private method to get the total count of the entity or a table.

private int getTotalItems<TSource>(Expression expressions)
{
   var usersCount = expressions != null ? MockingUserDetails().AsQueryable().Where(expressions.ToString()).ToList().Count() : MockingUserDetails().AsQueryable().ToList().Count();
   return usersCount;
}

If you look closely, you'll see that we are sending the expression to this method, becuase this expression will help to get the accurate data from the database.

public JsonParseObject getParseObject()
{
   var oblDetails = _jsonoutputService.GetFilterExpression<UserDetails>();
   oblDetails.TotalCount = getTotalItems<UserDetails>(oblDetails.Expression);
   return oblDetails;
}

This method is public and we will call this from controller, but totalcount is private and we will call from this method.

 

Then we have to call our actual method to GetAllAsyn(). This method needs expression, sorting parameters, and paging parameter, but the sort and filter are optional parameters.

public List<UserDetails> getUserDetails<TSource>(JsonParseObject parseObject)
{
    var query = parseObject.Expression != null ? MockingUserDetails().AsQueryable().Where(parseObject.Expression.ToString()).ToList() :
                                  MockingUserDetails().AsQueryable().ToList();

    if (parseObject.SortQueries != null)
    {
        var orderedEntities = query.AsQueryable().Sort(parseObject.SortQueries[0]);

        if (parseObject.SortQueries.Count() > 1)
        {
            for (var i = 1; i < parseObject.SortQueries.Count(); i++)
                orderedEntities = orderedEntities.Sort(parseObject.SortQueries[i]);
        }

        if (orderedEntities != null)
            query = orderedEntities.ToList();
    }

    var results = query.Skip(parseObject.pageSize * (parseObject.pageNumber - 1))
                   .Take(parseObject.pageSize);

    return results.ToList();
}

This method needs references from the library to utlize extensions and properties,

 

"using Visionplanner.JsonAPI.Extensions;"

"using Visionplanner.JsonAPI.Models;"
"using Visionplanner.JsonAPI.Repository;"

 

Service layer implementation is completed, so we have to call these services in the controller correctly to fetch the data.

[HttpGet, Route("userdetails")]
        [ProducesResponseType((int)HttpStatusCode.OK)]
        [ProducesResponseType((int)HttpStatusCode.NotFound)]
        public IActionResult GetUserDetails()
        {
            var details = _modelService.getParseObject(); // it will return JsonParseobject with Filter/Sort/Paging

            var userDetails = _modelService.getUserDetails<UserDetails>(details); // it will retuern processed data

            var results = _jsonoutputService.GetParsingData<UserDetails>(userDetails.AsQueryable(), details.pageSize, details.pageNumber, details.TotalCount); // it will return seralize data.

            if (results.Data.Count() > 0)
                return new ObjectResult("SuccessCode") { StatusCode = 200 };
            else
                return new ObjectResult("NotApplicable") { StatusCode = 406 };
        }

We can see that we are calling three methods,

1. The method will prepare jsonParseobject (inside we have Expression built based on the url and sorting parameters and paging parameters)
2. This is the actual method that will return data from the service layer.
3. This method is the JSON library method to transform data and prepare the JSON object.

{
    "links": [
        {
            "href": "http://localhost:59312/api/v1.0/Contact/tenantid/76E23186-D637-46E3-9D07-845DD928D3B6?page[size]=5&page[number]=1",
            "rel": "first",
            "method": "GET"
        }
    ],
    "meta": {
        "total-records": 1
    },
    "data": {
        "data": [
            {
                "type": "userviewmodel",
                "id": "2e2d946b-9874-4e97-b732-a97000b74513",
                "attributes": {
                    "firstName": "krishna",
                    "lastName": "jaya",
                    "initial": "k",
                    "gender": "Male",
                    "email": "[email protected]",
                    "optedOut": "Yes",
                    "linekedHomePage": "www.google.com",
                    "phone": "1234567890",
                    "attachment": "Nothing",
                    "roles": [
                        {
                            "roleName": "DecisionMaker"
                        }
                    ],
                    "notes": "Testing User",
                    "contactType": "UserContact",
                    "status": "Active",
                    "salutation": "MR",
                    "tenantId": "76e23186-d637-46e3-9d07-845dd928d3b6"
                }
            }
        ]
    }
}

So, our library will help us to make our lives easier, we don't need to worry about the search, sort and paging. 

 

Here is a sample JSON standard URL to fetch the data from the library.

 

sort:- /jsonapi-success/userdetails?sort=firstName,lastname

Search:- /jsonapi-success/userdetails?filter[firstname]=kri&filter[lastname]=jaya

Paging:- /jsonapi-success/userdetails?page[size]=1&page[number]=1 

 

In JSON API the filter will work one by one using for loop, but in our library, it will prepare the complete expression like below and send it to the actual method to fetch the data from the database.

 

(c=>c.FirstName.Tolower().Contains("kri") && c.LastName.ToLower().Contains("jaya"))

 

Also, you can prepare a url with a combination. And all are an option in the url if you provide it will apply it; otherwise it will return a complete set of data.

 

plain url:- /jsonapi-success/userdetails "it will return complete data like above example out" .

 

By default, paging will also apply based on the page size we have to register in startup class.

 

I hope this document will help you understand how to use the library and this library will help to solve the problem I have mentioned above.

 

Please let me know in case you have any other concerns so that I can try to embed those changes and release a new package.