public JsonPatchDocument <ApiFollowerServerRequestModel> CreatePatch(ApiFollowerServerRequestModel model)
{
var patch = new JsonPatchDocument <ApiFollowerServerRequestModel>();
patch.Replace(x => x.Blocked, model.Blocked);
patch.Replace(x => x.DateFollowed, model.DateFollowed);
patch.Replace(x => x.FollowRequestStatu, model.FollowRequestStatu);
patch.Replace(x => x.FollowedUserId, model.FollowedUserId);
patch.Replace(x => x.FollowingUserId, model.FollowingUserId);
patch.Replace(x => x.Muted, model.Muted);
return(patch);
}
public virtual ApiFollowerServerRequestModel MapServerResponseToRequest(
ApiFollowerServerResponseModel response)
{
var request = new ApiFollowerServerRequestModel();
request.SetProperties(
response.Blocked,
response.DateFollowed,
response.FollowedUserId,
response.FollowingUserId,
response.FollowRequestStatu,
response.Muted);
return(request);
}
public virtual ApiFollowerServerResponseModel MapServerRequestToResponse(
int id,
ApiFollowerServerRequestModel request)
{
var response = new ApiFollowerServerResponseModel();
response.SetProperties(id,
request.Blocked,
request.DateFollowed,
request.FollowedUserId,
request.FollowingUserId,
request.FollowRequestStatu,
request.Muted);
return(response);
}
public void MapModelToEntity()
{
var mapper = new DALFollowerMapper();
ApiFollowerServerRequestModel model = new ApiFollowerServerRequestModel();
model.SetProperties("A", DateTime.Parse("1/1/1987 12:00:00 AM"), 1, 1, "A", "A");
Follower response = mapper.MapModelToEntity(1, model);
response.Blocked.Should().Be("A");
response.DateFollowed.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM"));
response.FollowedUserId.Should().Be(1);
response.FollowingUserId.Should().Be(1);
response.FollowRequestStatu.Should().Be("A");
response.Muted.Should().Be("A");
}
public virtual async Task <CreateResponse <ApiFollowerServerResponseModel> > Create(
ApiFollowerServerRequestModel model)
{
CreateResponse <ApiFollowerServerResponseModel> response = ValidationResponseFactory <ApiFollowerServerResponseModel> .CreateResponse(await this.FollowerModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
Follower record = this.DalFollowerMapper.MapModelToEntity(default(int), model);
record = await this.FollowerRepository.Create(record);
response.SetRecord(this.DalFollowerMapper.MapEntityToModel(record));
await this.mediator.Publish(new FollowerCreatedNotification(response.Record));
}
return(response);
}
public virtual Follower MapModelToEntity(
int id,
ApiFollowerServerRequestModel model
)
{
Follower item = new Follower();
item.SetProperties(
id,
model.Blocked,
model.DateFollowed,
model.FollowedUserId,
model.FollowingUserId,
model.FollowRequestStatu,
model.Muted);
return(item);
}
public virtual async Task <UpdateResponse <ApiFollowerServerResponseModel> > Update(
int id,
ApiFollowerServerRequestModel model)
{
var validationResult = await this.FollowerModelValidator.ValidateUpdateAsync(id, model);
if (validationResult.IsValid)
{
Follower record = this.DalFollowerMapper.MapModelToEntity(id, model);
await this.FollowerRepository.Update(record);
record = await this.FollowerRepository.Get(id);
ApiFollowerServerResponseModel apiModel = this.DalFollowerMapper.MapEntityToModel(record);
await this.mediator.Publish(new FollowerUpdatedNotification(apiModel));
return(ValidationResponseFactory <ApiFollowerServerResponseModel> .UpdateResponse(apiModel));
}
else
{
return(ValidationResponseFactory <ApiFollowerServerResponseModel> .UpdateResponse(validationResult));
}
}
