/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="model"></param>
public ApiResponse <bool> UpdatePerson(TestProjectDbContext context, PersonUpdateViewModel model)
{
Person person = _repository.GetPersonbyId(context, model.PersonId);
if (person == null)
{
throw new ErrorException("Person Id is invalid");
}
try
{
person.FirstName = model.FirstName;
person.LastName = model.LastName;
_repository.UpdatePerson(context, person);
return(ApiResponse <bool> .SuccessResult(true));
}
catch (Exception ex) when(ex is FailException || ex is ValidationException || ex is ArgumentException)
{
return(ApiResponse <bool> .ErrorResult(message : ex.Message, statusCode : HttpStatusCode.BadRequest));
}
catch (Exception ex) when(ex is ErrorException)
{
//LoggingManager.Error(ex.ToString());
return(ApiResponse <bool> .ErrorResult(message : ex.Message));
}
catch (Exception ex)
{
//LoggingManager.Error(ex.ToString());
return(ApiResponse <bool> .ErrorResult(message : ex.Message));
}
}
public async Task <IActionResult> Put([FromBody] PersonUpdateViewModel personViewModel)
{
var person = _mapper.Map <Person>(personViewModel);
await _personService.UpdateAsync(person.PersonId, person);
return(ResponseHelper.Ok(person));
}
public async Task UpdateAsync(PersonUpdateViewModel personVM)
{
var currentPerson = await db.People.FindAsync(personVM.Id).ConfigureAwait(false);
currentPerson.SetConfirmation(personVM.Confirmed);
currentPerson.SetMVPCode(personVM.MVP_Code);
db.People.Update(currentPerson);
await db.SaveChangesAsync().ConfigureAwait(false);
}
public void Update()
{
var controller = new PersonsController(_context);
PersonUpdateViewModel model = new PersonUpdateViewModel
{
PersonId = _context.Person.FirstOrDefault().Id,
FirstName = "FirstName",
LastName = "LastName"
};
var result = (ObjectResult)controller.Update(model);
Assert.IsType <ApiResponse <bool> >(result.Value);
var response = (ApiResponse <bool>)result.Value;
Assert.Equal(((int)HttpStatusCode.OK).ToString(), response.StatusCode.ToString());
}
public IActionResult Update()
{
var user = userManager.GetUserAsync(User).Result;
var person = uow.PersonRepository.GetById(user.PersonId ?? default);
var model = new PersonUpdateViewModel()
{
Phone = person.Phone,
Email = person.Email,
PassportSeries = person.PassportSeries,
PassportNumber = person.PassportNumber,
Tin = person.Tin,
};
return(View(model));
}
public async Task <string> RunOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
var vm = context.GetInput <PersonViewModel>();
string id = await context.CallActivityAsync <string>(ConfirmationTask.CreatePerson, vm);
var vmUpdate = PersonUpdateViewModel.Create(vm);
vmUpdate.Id = id;
var activateSendMail = new ActivatePersonSendMail {
Data = vmUpdate, InstanceId = context.InstanceId
};
await context.CallActivityAsync(ConfirmationTask.SendMailPerson, activateSendMail);
await HumanInteractionPerson(context, vmUpdate);
return(id);
}
public async Task <PersonUpdateViewModel> GetById(string id)
{
var currentPerson = await db.People.FindAsync(id).ConfigureAwait(false);
if (currentPerson == null)
{
throw new ArgumentOutOfRangeException($"Person {id} not exists");
}
PersonUpdateViewModel personVM = new PersonUpdateViewModel
{
Id = currentPerson.Id,
Name = currentPerson.Name,
Surname = currentPerson.Surname,
Picture = currentPerson.Picture,
MVP_Code = currentPerson.MVP_Code,
Confirmed = currentPerson.Confirmed
};
return(personVM);
}
public IActionResult Update(PersonUpdateViewModel model)
{
if (ModelState.IsValid)
{
var user = userManager.GetUserAsync(User).Result;
var person = uow.PersonRepository.GetById(user.PersonId ?? default);
person.Tin = model.Tin;
person.Phone = model.Phone;
person.Email = model.Email;
person.PassportSeries = model.PassportSeries;
person.PassportNumber = model.PassportNumber;
uow.PersonRepository.Update(person);
uow.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
void SelectPerson(PersonUpdateViewModel vm)
{
}
void ManagerOnConfirm(bool isOpen)
{
ManagerIsOpen = isOpen;
ManagerSelected = new PersonUpdateViewModel();
}
void OpenManagers(PersonUpdateViewModel person)
{
ManagerSelected = person;
ManagerIsOpen = true;
}
public async Task <bool> HumanInteractionPerson(IDurableOrchestrationContext context, PersonUpdateViewModel vm)
{
using (var timeoutCts = new CancellationTokenSource())
{
DateTime expiration = context.CurrentUtcDateTime.AddDays(6);
Task timeoutTask = context.CreateTimer(expiration, timeoutCts.Token);
bool authorized = false;
for (int retryCount = 0; retryCount <= 3; retryCount++)
{
Task <bool> challengeResponseTask = context.WaitForExternalEvent <bool>(ConfirmationTask.ConfirmPersonHuman);
Task winner = await Task.WhenAny(challengeResponseTask, timeoutTask);
if (winner == challengeResponseTask)
{
// We got back a response! Compare it to the challenge code.
if (challengeResponseTask.Result)
{
vm.Confirmed = challengeResponseTask.Result;
await context.CallActivityAsync(ConfirmationTask.ApproveCancelPersonOnCosmos, vm);
break;
}
}
else
{
// Timeout expired
break;
}
}
if (!timeoutTask.IsCompleted)
{
// All pending timers must be complete or canceled before the function exits.
timeoutCts.Cancel();
}
return(authorized);
}
}
public async Task ApproveCancelPersonOnCosmos([ActivityTrigger] PersonUpdateViewModel vm, ILogger log)
{
await personService.UpdateAsync(vm).ConfigureAwait(false);
}
public IActionResult Update([FromBody] PersonUpdateViewModel model)
{
var response = _personFacades.UpdatePerson(_context, model);
return(new ObjectResult(response));
}
