public async Task CreateOrUpdatePersonAsync(PersonUpdateDto input)
{
if (input.Id.Equals(0))
{
await _personRepository.InsertAsync(input.MapTo <PersonEntity>());
}
}
public async Task UpdateNotes(PersonUpdateDto person)
{
var final = await FindPerson(person.Id);
final.Notes = person.Notes;
final.Name = person.Name;
final.City = person.City;
await _persons.ReplaceOneAsync(su => su.Id == final.Id, final);
}
public Response <PersonUpdateDto> Update(PersonUpdateDto data, string token)
{
Response <PersonUpdateDto> obj = new Response <PersonUpdateDto>();
var hCliente = _global.rspClientPUT("People/" + data.PersonId, data, token);
if (hCliente.IsSuccessStatusCode)
{
obj = new JavaScriptSerializer().Deserialize <Response <PersonUpdateDto> >(hCliente.Content.ReadAsStringAsync().Result);
}
return(obj);
}
public async Task <IActionResult> PutAsync(PersonUpdateDto p)
{
var command = new PersonUpdateCommand
{
Person = p
};
var status = await _mediator.Send(command);
return(Ok(status));
}
public ActionResult <Person> UpdatePerson(int id, PersonUpdateDto personUpdate)
{
var person = _repository.GetPersonById(id);
if (person == null)
{
return(NotFound());
}
return(Ok(_repository.UpdatePerson(person, personUpdate)));
}
public static Person ToEntity(this PersonUpdateDto dto)
{
return(new Person()
{
Id = dto.Id,
LastName = dto.LastName,
FirstName = dto.FirstName,
VatNumber = dto.VatNumber,
EmploymentStatusId = dto.EmploymentStatusId
});
}
public IActionResult Update([FromBody] PersonUpdateDto dto)
{
try
{
_service.Update(dto);
return(NoContent());
}
catch (Exception)
{
throw;
}
}
public Person UpdatePerson(Person person, PersonUpdateDto personUpdate)
{
if (person == null || personUpdate == null)
{
throw new ArgumentNullException(nameof(person));
}
_mapper.Map(personUpdate, person);
_context.SaveChanges();
return(person);
}
public ActionResult UpdatePerson(Guid id, [FromBody] JsonPatchDocument <PersonUpdateDto> patchDoc)
{
PersonUpdateDto dto = _personManager.GetPersonToUpdate(id);
patchDoc.ApplyTo(dto, ModelState);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(_personManager.UpdatePerson(dto)));
}
public async Task <IActionResult> UpdateAsync(PersonUpdateDto obj)
{
if (obj != null)
{
var command = new PersonUpdateCommand
{
Person = obj
};
Log.Information("Update realizado com sucesso.");
await _mediator.Send(command);
}
Log.Error("Erro: sem objecto");
return(NoContent());
}
public ActionResult <PersonReadDto> UpdatePerson(int id, [FromBody] PersonUpdateDto updateDto)
{
var modelFromRepo = _repository.GetPersonById(id);
if (modelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(updateDto, modelFromRepo);
_repository.UpdatePerson(modelFromRepo);
return(NoContent());
}
public ActionResult <PersonUpdateDto> UpdatePerson(int id, PersonUpdateDto personUpdateDto)
{
var personModelFromRepo = _repository.GetPersonById(id);
if (personModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(personUpdateDto, personModelFromRepo);
_repository.UpdatePerson(personModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public JsonResult Update(PersonUpdateDto data)
{
#region TOKEN
var sessione = (SessionModel)Session[Resources.Constante.SessionUsuario];
LoginDto oLoginDto = new LoginDto();
oLoginDto.v_UserName = sessione.UserName;
oLoginDto.v_Password = sessione.Pass;
var validated = _securityBL.ValidateAccess(oLoginDto);
if (validated == null)
{
return(Json("", "application/json", Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
#endregion
var response = _personBL.Update(data, validated.Token);
return(Json(response, "application/json", Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Put(int id, [FromBody] PersonUpdateDto item, CancellationToken ct)
{
try
{
// return non content response if item is null
if (item == null)
{
return(NoContent());
}
// the 'unassigned' person can not be edited
if (id <= 0)
{
return(Forbid("You can't edit this person"));
}
// retrieve the person that is going to be updated
var original = await _personRepository.GetPersonSingle(id, ct);
// return not found response if existing item cannot be found
if (original == null)
{
return(NotFound());
}
// map the update dto to model
Person toUpdate = Mapper.Map(item, original);
// update the person in the repository
await _personRepository.UpdatePerson(toUpdate, ct);
// map to dto
var result = Mapper.Map <PersonDto>(toUpdate);
// return successful response
return(Ok(new SuccessResult {
Results = new[] { result }, Status = "Successful"
}));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <HttpResponseMessage> UpdatePersonInformation(PersonUpdateDto personUpdateDto)
{
if (personUpdateDto.RecognitionId != 0)
{
bool isFillFirstName = !string.IsNullOrEmpty(personUpdateDto.FirstName);
bool isFillReason = !string.IsNullOrEmpty(personUpdateDto.ReasonOfVisit);
Person person;
if (personUpdateDto.PersonId == default(Guid))
{
person = await _personService.ProcessRecognitionItem(personUpdateDto.RecognitionId);
}
else
{
person = _unit.PersonRepository.GetByApiId(personUpdateDto.PersonId);
}
if (person != null)
{
if (isFillFirstName)
{
person.FirstName = personUpdateDto.FirstName;
}
if (isFillReason)
{
var lastOrDefault = person.Visits.LastOrDefault();
if (lastOrDefault != null)
{
lastOrDefault.Reason = personUpdateDto.ReasonOfVisit;
}
}
await _unit.SaveAsync();
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, GetWebServiceError("BadRequest", "Recognition id must be specified")));
}
public IActionResult Put(PersonUpdateDto personupdateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//if null either person or group does not exist
if (!_personService.Exists(personupdateDto.Id) || !_personService.GroupExists(personupdateDto.GroupId))
{
return(NotFound());
}
var person = _mapper.Map <Person>(personupdateDto);
_personService.Update(person);
_personService.Save();
return(NoContent());
}
public async Task <IActionResult> UpdatePerson([FromBody] PersonUpdateDto p)
{
var exist = await _person.PersonExist(p.Id);
if (!exist)
{
return(BadRequest("Person not found"));
}
var userEmail = User.FindFirst(System.Security.Claims.ClaimTypes.Email).Value;
await _log.Create(userEmail, "", "", $"Notes UPDATED - {p.Name}");
await _person.UpdateNotes(p);
return(Ok());
}
public ActionResult UpdatePerson(int personId, PersonUpdateDto personUpdateDto)
{
//personModelFromRepo - the object to be replaced. Type == Person.
//personUpdateDto - new object. Map to Person.
var personModelFromRepos = _repository.GetPersonById(personId);
if (personModelFromRepos == null)
{
return(NotFound());
}
//updated personModelFromRepos, changes are being tracked via dbContext
_mapper.Map(personUpdateDto, personModelFromRepos);
//for maintaining
_repository.UpdatePerson(personModelFromRepos);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdatePerson(int id, PersonUpdateDto personUpdateDto)
{
if (personUpdateDto == null)
{
_logger.LogError("Owner object sent from client is null.");
return(BadRequest("Owner object is null"));
}
var personModelFromRepo = _repository.GetPersonById(id);
if (personModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(personUpdateDto, personModelFromRepo);
_repository.UpdatePerson(personModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public async Task UpdatePersonInformation(PersonUpdateDto personUpdateDto)
{
// Creates uri from configuration
var uri = new Uri($"{ApiBasePath}/{PersonUpdateInformationQuery}");
Debug.WriteLine("Debug: " + uri);
// Get authorization token
string token = (await TokenManagerService.GetToken()).AccessToken;
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var content = new StringContent(JsonConvert.SerializeObject(personUpdateDto), Encoding.UTF8, "application/json");
HttpResponseMessage resp = await _httpClient.PostAsync(uri, content);
if (!resp.IsSuccessStatusCode)
{
var error = JsonConvert.DeserializeObject <WebServiceError>(await resp.Content.ReadAsStringAsync());
Debug.WriteLine($"WebServiceError : {error.HttpStatus} - {error.ErrorCode} : {error.ErrorMessage}");
}
}
/// <inheritdoc/>
public Person UpdatePerson(PersonUpdateDto dto)
{
var now = DateUtil.Now;
var entity = _personRepository.Read(new PersonTableEntity {
PersonId = dto.PersonId
});
if (dto.PersonCode != null)
{
entity.PersonCode = dto.PersonCode;
}
if (dto.LoginId != null)
{
entity.LoginId = dto.LoginId;
}
if (dto.Name != null)
{
entity.Name = dto.Name;
}
if (dto.Title != null)
{
entity.Title = dto.Title;
}
if (dto.Description != null)
{
entity.Description = dto.Description;
}
if (dto.Status != null)
{
entity.Status = dto.Status;
}
if (dto.SortNo != null)
{
entity.SortNo = dto.SortNo.Value;
}
entity.UpdateTime = now;
using (var tran = new TransactionScope())
{
_personRepository.Update(entity);
if (dto.Tags != null)
{
_tagRepository.DeleteByTargetId(dto.PersonId);
foreach (var tag in dto.Tags)
{
_tagRepository.Create(new TagTableEntity
{
TagId = Guid.NewGuid(),
TargetId = entity.PersonId,
Value = tag,
TargetTable = "Person",
CreateTime = now,
});
}
}
tran.Complete();
}
return(_personQueryService.GetPerson(entity.PersonId));
}
public void Update(PersonUpdateDto dto)
{
_generic.Update(dto.Adapt <Person>());
}
public PersonGetDto UpdatePerson(PersonUpdateDto dto)
{
return(_personRepo
.UpdatePerson(dto.ToEntity())
.ToDto());
}
protected override async Task OnLoadedAsync()
{
await Task.Run(() => { while (!_isDirectLineInitialized)
{
}
});
connection.OnMessage += Connection_OnMessage;
// Registers to messenger for on screen log messages
Messenger.Default.Register <LogMessage>(this, async e => await DispatcherHelper.RunAsync(() => LogMessage += e.Message));
// Begins to listening "hello ada"
await VoiceInterface.ListeningHelloAda();
// Registers to messenger to catch messages when a speech recognition result
// was generated
Messenger.Default.Register <SpeechResultGeneratedMessage>(this, async e =>
{
if (e.Result.Constraint.Tag == "constraint_hello_ada")
{
if (VoiceInterface != null)
{
await VoiceInterface.StopListening();
}
LogHelper.Log("Message reçu ;)");
LogHelper.Log("Je suis à toi dans un instant");
await TtsService.SayAsync("Message reçu, je suis à toi dans un instant");
PersonDto person = null;
if (WebcamService.FaceDetectionEffect != null)
{
await WebcamService.StopFaceDetectionAsync();
person = (await MakeRecognition())?.FirstOrDefault();
}
if (person != null)
{
PersonUpdateDto updateDto = new PersonUpdateDto
{
PersonId = person.PersonId,
RecognitionId = person.RecognitionId
};
await VoiceInterface.SayHelloAsync(person);
// Update person's name
if (person.FirstName == null)
{
string answer = await VoiceInterface.AskIdentified();
if (answer != "non")
{
string name = await VoiceInterface.AskNameAsync();
if (name == null)
{
return;
}
updateDto.FirstName = name;
person.FirstName = name;
AdaClient client = new AdaClient()
{
WebAppUrl = AppConfig.WebUri
};
await client.PutPerson(updateDto);
}
}
}
else
{
await TtsService.SayAsync("Bonjour");
}
await DispatcherHelper.RunAsync(async() => { await SolicitExecute(); });
}
});
//// Prepares capture element to camera feed and load camera
CaptureElement = new CaptureElement();
await CameraLoadExecute();
}
public Task UpdatePersonInformation(PersonUpdateDto personUpdateDto)
{
throw new System.NotImplementedException();
}
