public ReviewerPerson Get(int id)
{
_logHelper.GetTaskActionName("GetPerson", id.ToString());
var person = Builders <Person> .Filter.Eq("Id", id);
var targetPerson = _context.People.Find(person).FirstOrDefault();
if (targetPerson == null)
{
_logHelper.ReturnNoFoudStatus(id.ToString());
return(null);
}
var reviewerPerson = new ReviewerPerson();
try
{
reviewerPerson = _mapper.Map <ReviewerPerson>(targetPerson);
_logHelper.ReturnSuccessStatus();
}
catch (Exception e)
{
_logHelper.ReturnUncontrolException(e.Message);
}
return(reviewerPerson);
}
public void Post(ReviewerPerson person)
{
_logHelper.GetTaskActionName("PostPerson");
if (_context.People.Find(x => true).Any())
{
var maxId = _context.People.Find(x => true)
.SortByDescending(d => d.Id).Limit(1).FirstOrDefault().Id;
person.Id = maxId + 1;
}
else
{
person.Id = 1;
}
person = UpdateInputInfoId(person);
var convertedPerson = _mapper.Map <Person>(person);
try
{
_context.People.InsertOne(convertedPerson);
_logHelper.ReturnSuccessStatus();
}
catch (Exception e)
{
_logHelper.ReturnUncontrolException(e.Message);
}
}
public async Task <IActionResult> PutPerson([FromRoute] int id, [FromBody] ReviewerPerson person)
{
var updatePersonId = id.ToString();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != person.Id)
{
return(BadRequest());
}
var task = Task.Run(() => _peopleService.Update(id, person));
var executeResult = await task;
switch (executeResult)
{
case "Success":
return(Ok());
case "NotFound":
return(NotFound());
default:
return(ValidationProblem());
}
}
public string Update(int id, ReviewerPerson person)
{
_logHelper.GetTaskActionName("UpdatePerson", id.ToString());
if (_context.People.Find(x => x.Id == id).Any())
{
person = UpdateInputInfoId(person);
var convertedPerson = _mapper.Map <Person>(person);
try
{
_context.People.ReplaceOne(x => x.Id == id, convertedPerson);
_logHelper.ReturnSuccessStatus();
return("Success");
}
catch (Exception e)
{
_logHelper.ReturnUncontrolException(e.Message);
return("UnExpectError");
}
}
_logHelper.ReturnNoFoudStatus(id.ToString());
return("NotFound");
}
public ReviewerPerson Get(int id)
{
_logHelper.GetTaskActionName("GetPerson", id.ToString());
if (!PersonExists(id))
{
_logHelper.ReturnNoFoudStatus(id.ToString());
return(null);
}
var person = _context.People
.Include(a => a.Addresses)
.Include(e => e.EmailAddresses).Where(x => x.Id == id).ToList().FirstOrDefault();
var reviewerPerson = new ReviewerPerson();
try
{
reviewerPerson = _mapper.Map <ReviewerPerson>(person);
_logHelper.ReturnSuccessStatus();
}
catch (Exception e)
{
_logHelper.ReturnUncontrolException(e.Message);
}
return(reviewerPerson);
}
public async Task <IActionResult> PostPerson([FromBody] ReviewerPerson person)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var task = Task.Run(() => _peopleService.Post(person));
await task;
return(CreatedAtAction("GetPerson", new { id = person.Id }, person));
}
public string Update(int id, ReviewerPerson person)
{
var beReplaceTarget = _reviewerPeople.Where(x => x.Id == id).First();
if (beReplaceTarget != null)
{
_reviewerPeople.Remove(beReplaceTarget);
_reviewerPeople.Add(person);
return("Success");
}
return("NotFound");
}
private ReviewerPerson UpdateInputInfoId(ReviewerPerson person)
{
for (int i = 0; i < person.EmailAddresses.Count; i++)
{
person.EmailAddresses[i].Id = i + 1;
}
for (int i = 0; i < person.Addresses.Count; i++)
{
person.Addresses[i].Id = i + 1;
}
return(person);
}
public async void ShouldReturnPostPersonResult(int id, string name)
{
var person = new ReviewerPerson
{
Id = id,
FirstName = name
};
await _controller.PostPerson(person);
var target = await _controller.GetPerson(3) as OkObjectResult;;
var targetPerson = target.Value as ReviewerPerson;
Assert.Equal(name, targetPerson.FirstName);
}
public async void ShouldUpdateTargetPerson()
{
var person = new ReviewerPerson
{
Id = 2,
FirstName = "MinaNew"
};
await _controller.PutPerson(2, person);
var target = await _controller.GetPerson(2) as OkObjectResult;
var targetPerson = target.Value as ReviewerPerson;
Assert.Equal("MinaNew", targetPerson.FirstName);
}
public void Post(ReviewerPerson person)
{
_logHelper.GetTaskActionName("PostPerson");
var convertedPerson = _mapper.Map <Person>(person);
_context.People.Add(convertedPerson);
try
{
_context.SaveChanges();
_logHelper.ReturnSuccessStatus();
}
catch (Exception e)
{
_logHelper.ReturnUncontrolException(e.Message);
}
}
public string Update(int id, ReviewerPerson inputPerson)
{
_logHelper.GetTaskActionName("UpdatePerson", id.ToString());
var originalPerson = _context.People
.Include(a => a.Addresses)
.Include(e => e.EmailAddresses)
.Where(x => x.Id == id)
.FirstOrDefault();
var convertedInputPerson = _mapper.Map <Person>(inputPerson);
if (originalPerson != null)
{
_context.Entry(originalPerson).CurrentValues.SetValues(convertedInputPerson);
CleanAddressInDbContext(originalPerson, convertedInputPerson);
CleanEmailAddressesInDbContext(originalPerson, convertedInputPerson);
UpdateAddresseInDbContext(originalPerson.Addresses, convertedInputPerson.Addresses);
UpdateEmailAddresseInDbContext(originalPerson.EmailAddresses, convertedInputPerson.EmailAddresses);
}
try
{
_context.SaveChanges();
_logHelper.ReturnSuccessStatus();
return("Success");
}
catch (DbUpdateConcurrencyException e)
{
if (!PersonExists(id))
{
_logHelper.ReturnNoFoudStatus(id.ToString());
return("NotFound");
}
else
{
_logHelper.ReturnUncontrolException(e.Message);
return("UnExpectError");
}
}
}
public void Post(ReviewerPerson person)
{
_reviewerPeople.Add(person);
}
