public JsonPatchDocument <ApiTagServerRequestModel> CreatePatch(ApiTagServerRequestModel model)
{
var patch = new JsonPatchDocument <ApiTagServerRequestModel>();
patch.Replace(x => x.Count, model.Count);
patch.Replace(x => x.ExcerptPostId, model.ExcerptPostId);
patch.Replace(x => x.TagName, model.TagName);
patch.Replace(x => x.WikiPostId, model.WikiPostId);
return(patch);
}
public virtual ApiTagServerRequestModel MapServerResponseToRequest(
ApiTagServerResponseModel response)
{
var request = new ApiTagServerRequestModel();
request.SetProperties(
response.Count,
response.ExcerptPostId,
response.TagName,
response.WikiPostId);
return(request);
}
public void MapModelToEntity()
{
var mapper = new DALTagMapper();
ApiTagServerRequestModel model = new ApiTagServerRequestModel();
model.SetProperties(1, 1, "A", 1);
Tag response = mapper.MapModelToEntity(1, model);
response.Count.Should().Be(1);
response.ExcerptPostId.Should().Be(1);
response.TagName.Should().Be("A");
response.WikiPostId.Should().Be(1);
}
public virtual ApiTagServerResponseModel MapServerRequestToResponse(
int id,
ApiTagServerRequestModel request)
{
var response = new ApiTagServerResponseModel();
response.SetProperties(id,
request.Count,
request.ExcerptPostId,
request.TagName,
request.WikiPostId);
return(response);
}
public virtual Tag MapModelToEntity(
int id,
ApiTagServerRequestModel model
)
{
Tag item = new Tag();
item.SetProperties(
id,
model.Count,
model.ExcerptPostId,
model.TagName,
model.WikiPostId);
return(item);
}
public virtual async Task <CreateResponse <ApiTagServerResponseModel> > Create(
ApiTagServerRequestModel model)
{
CreateResponse <ApiTagServerResponseModel> response = ValidationResponseFactory <ApiTagServerResponseModel> .CreateResponse(await this.TagModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
Tag record = this.DalTagMapper.MapModelToEntity(default(int), model);
record = await this.TagRepository.Create(record);
response.SetRecord(this.DalTagMapper.MapEntityToModel(record));
await this.mediator.Publish(new TagCreatedNotification(response.Record));
}
return(response);
}
public virtual async Task <UpdateResponse <ApiTagServerResponseModel> > Update(
int id,
ApiTagServerRequestModel model)
{
var validationResult = await this.TagModelValidator.ValidateUpdateAsync(id, model);
if (validationResult.IsValid)
{
Tag record = this.DalTagMapper.MapModelToEntity(id, model);
await this.TagRepository.Update(record);
record = await this.TagRepository.Get(id);
ApiTagServerResponseModel apiModel = this.DalTagMapper.MapEntityToModel(record);
await this.mediator.Publish(new TagUpdatedNotification(apiModel));
return(ValidationResponseFactory <ApiTagServerResponseModel> .UpdateResponse(apiModel));
}
else
{
return(ValidationResponseFactory <ApiTagServerResponseModel> .UpdateResponse(validationResult));
}
}
