/// <summary>
/// mocks update contact
/// </summary>
/// <param name="updateDto">instance of <see cref="ContactUpdateDto"/></param>
/// <returns>instance of <see cref="ContactDto"/></returns>
public async Task <ContactDto> UpdateAsync(ContactUpdateDto updateDto)
{
foreach (var item in _contacts)
{
if (item.Id == updateDto.Id)
{
item.IsActive = updateDto.IsActive;
item.Name = updateDto.Name;
item.Id = updateDto.Id;
item.PhoneNumber = updateDto.PhoneNumber;
item.Type = updateDto.Type;
return(await Task.Run(() =>
{
return new ContactDto
{
Id = item.Id,
Email = item.Email,
IsActive = item.IsActive,
Type = item.Type,
PhoneNumber = item.PhoneNumber,
Name = item.Name
};
}));
}
}
throw new KeyNotFoundException($"Contact with id: {updateDto.Id} could not be found!");
}
public async Task <ContactDetailsDto> UpdateContact(ContactUpdateDto dto)
{
var command = new UpdateContactCommand(dto);
var result = await _mediator.Send(command);
return(result);
}
public IActionResult UpdateContact(int id, [FromBody] ContactUpdateDto newContact)
{
if (newContact == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_contactRepository.ContactExists(id))
{
return(NotFound());
}
var contactEntity = _contactRepository.GetContact(id);
if (contactEntity == null)
{
return(NotFound());
}
Mapper.Map(newContact, contactEntity);
if (!_contactRepository.Save())
{
return(StatusCode(500, "A problem happened while handling your request."));
}
return(NoContent());
}
public IActionResult UpdateContact([FromBody] ContactUpdateDto contactDto)
{
if (contactDto.Id == 0)
{
return(BadRequest(ModelState));
}
if (!_contactRepository.Exists(c => c.Id == contactDto.Id))
{
ModelState.AddModelError("", "contact doesn't exist in the database");
return(StatusCode(500, ModelState));
}
Contact contact = _mapper.Map <Contact>(contactDto);
_contactRepository.Update(_mapper.Map <Contact>(contactDto));
if (_contactRepository.Save() > 0)
{
return(NoContent());
}
else
{
ModelState.AddModelError("", "Something went wrong updating the contact");
return(StatusCode(500, ModelState));
}
}
public async Task <IHttpActionResult> Update(ContactUpdateDto model)
{
bool result = await _contactService.Update(model);
if (!result)
{
return(BadRequest());
}
return(Ok());
}
public IActionResult Update([FromBody] ContactUpdateDto dto)
{
try
{
_service.Update(dto);
return(NoContent());
}
catch (Exception)
{
throw;
}
}
public ActionResult <ContactUpdateDto> UpdateContact(int id, ContactUpdateDto contactUpdateDto)
{
var existingContactFromDb = _repository.GetContactById(id);
if (existingContactFromDb == null)
{
return(NotFound());
}
_mapper.Map(contactUpdateDto, existingContactFromDb);
_repository.UpdateContact(existingContactFromDb);
_repository.SaveChanges();
return(NoContent());
}
public async Task <BaseResultCRUDDto <OutPut_ContactDto> > EditContact(ContactUpdateDto editmodel)
{
var findobject = await contactRepository.GetByContactFullName(editmodel.FirstName + " " + editmodel.LastName);
if (findobject != null && findobject.Id != editmodel.Id)
{
return new BaseResultCRUDDto <OutPut_ContactDto>()
{
ErrorMessage = "نام مخاطب از قبل به ثبت رسیده است "
}
}
;
return(await contactRepository.UpdateContact(editmodel));
}
public async Task <bool> Update(ContactUpdateDto model)
{
try
{
var query = _context.Contact.FirstOrDefault(x => x.Id == model.Id);
query.Phone = model.Phone;
query.Address = model.Address;
await _context.SaveChangesAsync();
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task UpdateContactAsync(ContactUpdateDto contactDto)
{
try
{
if (contactDto == null)
{
throw new ArgumentNullException(nameof(contactDto));
}
var contactEntity = _mapper.Map <Contact>(contactDto);
await _contactRepository.UpdateAsync(contactEntity);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
throw;
}
}
public async Task <ContactUpdateDto> Update(ContactUpdateDto entity)
{
try
{
var contact = await _db.Contact.FindAsync(entity.Id);
contact.Title = entity.Title;
contact.FirstName = entity.FirstName;
contact.LastName = entity.LastName;
contact.Email = entity.Email;
await _db.SaveChangesAsync();
return(entity);
}
catch (Exception ex)
{
//log exception
return(null);
}
}
public async Task <Contact> DeleteOldMessage(string id)
{
var mesaj = _MessageDal.GetAllString(id);
ContactUpdateDto contactt = new ContactUpdateDto();
foreach (var item in mesaj)
{
contactt.Id = item.Id;
contactt.Name = item.Name;
contactt.Message = item.Message;
contactt.Email = item.Email;
contactt.Date = item.Date;
contactt.ReadInfo = item.ReadInfo;
}
await _MessageDal.RemoveAsync(_mapper.Map <Contact>(contactt));
return(null);
}
public async Task <IActionResult> Update([FromBody] ContactUpdateDto dto)
{
var entity = await _contactRepository.GetByIdAsync(dto.Id);
if (entity == null)
{
return(NotFound());
}
entity.MobileNumber = dto.MobileNumber;
entity.Name = dto.Name;
entity.Province = dto.Province;
entity.City = dto.City;
entity.Email = dto.Email;
entity.Address = dto.Address;
entity.Zip = dto.Zip;
await _contactRepository.UpdateAsync(entity);
return(Ok());
}
public async Task <IActionResult> UpdateContact(int id, ContactUpdateDto contactUpdateDtoObj)
{
try
{
var contactObj = await _context.ContactosMavidavidBlancos.FindAsync(id);
if (contactObj == null)
{
return(NotFound());
}
_mapper.Map(contactUpdateDtoObj, contactObj);
await _context.SaveChangesAsync();
return(NoContent());
}
catch (DbUpdateConcurrencyException) when(ContactosMavidavidBlancosExists(id))
{
return(StatusCode(500));
}
}
public async Task <IActionResult> EditContact(ContactUpdateDto model)
{
var result = await contactService.EditContact(model);
return(Ok(result));
}
public void Update(ContactUpdateDto dto)
{
_generic.Update(dto.Adapt <Contact>());
}
public async Task <IHttpActionResult> Edit([FromBody] ContactUpdateDto value)
{
var result = await _contactRepo.Update(value);
return(Ok(result));
}
public UpdateContactCommand(ContactUpdateDto dto)
{
Dto = dto;
}
public async Task <BaseResultCRUDDto <OutPut_ContactDto> > UpdateContact(ContactUpdateDto editmodel)
{
var EditItem = await dbContext.Contacts.FirstOrDefaultAsync(x => x.Id == editmodel.Id);
if (EditItem != null)
{
EditItem.FirstName = editmodel.FirstName;
EditItem.LastName = editmodel.LastName;
EditItem.WebSite = editmodel.WebSite;
EditItem.Address = editmodel.Address;
EditItem.BirthDate = editmodel.BirthDate;
EditItem.CompanyName = editmodel.CompanyName;
EditItem.EmailAddress = editmodel.EmailAddress;
using (var dbtrn = dbContext.Database.BeginTransaction())
{
try
{
dbContext.Update(EditItem);
var detaillist = await dbContext.ContactPhoneNumbers.Where(x => x.ContactId == editmodel.Id).ToListAsync();
dbContext.ContactPhoneNumbers.RemoveRange(detaillist);
var phoneaddedmodel = editmodel.ContactPhoneNumbers.
Select(x => new ContactPhoneNumbers()
{
ContactId = editmodel.Id,
PhoneNumberTypeId = x.PhoneNumberTypeId,
PhoneNumber = x.PhoneNumber
})
.ToList();
dbContext.ContactPhoneNumbers.AddRange(phoneaddedmodel);
await dbContext.SaveChangesAsync();
dbtrn.Commit();
return(new BaseResultCRUDDto <OutPut_ContactDto>()
{
IsSuccess = true,
CRUDObject = await GetById(editmodel.Id)
});
}
catch (Exception ex)
{
dbtrn.Rollback();
return(new BaseResultCRUDDto <OutPut_ContactDto>()
{
ErrorMessage = ex.Message
});
}
}
}
else
{
return new BaseResultCRUDDto <OutPut_ContactDto>()
{
ErrorMessage = "مخاطبی با این آی دی وجود ندارد"
}
};
}
public async Task <IActionResult> UpdateContact([FromBody] ContactUpdateDto dto)
{
var result = await _contactService.UpdateContact(dto);
return(Ok(result));
}
