public async Task <IActionResult> PostSingleState(StateDocumentModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            try
            {
                await _mediator.Send(new MergeStateDocumentCommand()
                {
                    StateId      = model.StateId,
                    ActivityId   = model.ActivityId,
                    Agent        = model.Agent,
                    Registration = model.Registration,
                    Content      = model.Content,
                    ContentType  = model.ContentType
                });

                //var etag = EntityTagHeaderValue.Parse($"\"{document.Tag}\"");
                //Response.Headers.Add("ETag", etag.ToString());
                return(NoContent());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public async Task <IActionResult> DeleteSingleState([FromQuery] StateDocumentModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            try
            {
                ActivityStateDocument stateDocument = await _mediator.Send(new GetActivityStateQuery()
                {
                    StateId      = model.StateId,
                    ActivityId   = model.ActivityId,
                    Agent        = model.Agent,
                    Registration = model.Registration
                });

                if (stateDocument == null)
                {
                    return(NotFound());
                }

                await _mediator.Send(new DeleteActivityStateCommand()
                {
                    StateId      = model.StateId,
                    ActivityId   = model.ActivityId,
                    Agent        = model.Agent,
                    Registration = model.Registration
                });

                return(NoContent());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }
        }
        public async Task <ActionResult <StateDocumentModel> > GetSingleState(StateDocumentModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            try
            {
                ActivityStateDocument stateDocument = await _mediator.Send(new GetActivityStateQuery()
                {
                    StateId      = model.StateId,
                    ActivityId   = model.ActivityId,
                    Agent        = model.Agent,
                    Registration = model.Registration
                });

                if (stateDocument == null)
                {
                    return(NotFound());
                }

                if (HttpMethods.IsHead(Request.Method))
                {
                    return(NoContent());
                }

                var content = new FileContentResult(stateDocument.Content, stateDocument.ContentType.ToString());
                content.LastModified = stateDocument.LastModified;
                content.EntityTag    = new Microsoft.Net.Http.Headers.EntityTagHeaderValue(stateDocument.Tag);
                return(content);
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public Task BindModelAsync(ModelBindingContext bindingContext)
        {
            if (bindingContext == null)
            {
                throw new ArgumentNullException(nameof(bindingContext));
            }

            var model   = new StateDocumentModel();
            var request = bindingContext.ActionContext.HttpContext.Request;

            if (request.Method == HttpMethod.Post.Method || request.Method == HttpMethod.Put.Method)
            {
                // Parse contentType
                var contentType = MediaTypeHeaderValue.Parse(request.ContentType);
                model.ContentType = contentType.MediaType;
                // Validate content as valid json if application/json

                using (var reader = new StreamContent(request.Body))
                {
                    var binaryDocument = reader.ReadAsByteArrayAsync().Result;
                    model.Content = binaryDocument;
                }

                if (contentType.MediaType == MediaTypes.Application.Json)
                {
                    string jsonString = System.Text.Encoding.UTF8.GetString(model.Content);
                    if (!IsValidJson(jsonString))
                    {
                        throw new BadRequestException("Not valid json.");
                    }
                }
            }

            bindingContext.Result = ModelBindingResult.Success(model);
            return(Task.CompletedTask);
        }