public IActionResult Update(UpdateContactModel InputContact4Update)
{
if (ModelState.IsValid && CheckFullNameWithTitleIsEmpty(InputContact4Update))
{
Contact Contact4Update = InputContact4Update.CreateContact();
// if (ContactsRep.GetImageById(Contact4Update.Id) != Contact4Update.Image)
// {
if (InputContact4Update.Image != null && InputContact4Update.Image.Length > 0)
{
using (var MemStream = new MemoryStream())
{
InputContact4Update.Image.CopyTo(MemStream);
Contact4Update.Image = MemStream.ToArray();
}
}
else
{
Contact4Update.Image = ContactsRep.GetImageById(Contact4Update.Id);
}
// }
//Types.DeattachTypes();
ContactsRep.Update(Contact4Update);
return(RedirectToAction());
}
AddContactModel model4disply = new AddContactModel();
model4disply.Type4Display = Types.GetAll().ToList();
model4disply.ContactItems = new List <AddContactItem>();
model4disply.ContactItems.Add(new AddContactItem {
Scope = true
});
return(View(model4disply));
}
public string SerializerDataUpdateContact(SBResponseAllContacts.Contacts contacto, string nuevoEmail)
{
UpdateContactModel dataContact = new UpdateContactModel();
dataContact.attributes = new UpdateContactModel.Attributes();
dataContact.attributes.NOMBRE = contacto.attributes.NOMBRE;
dataContact.attributes.SURNAME = contacto.attributes.SURNAME;
dataContact.attributes.Email = nuevoEmail;
if (!string.IsNullOrEmpty(contacto.attributes.SMS))
{
dataContact.attributes.SMS = contacto.attributes.SMS;
}
else
{
dataContact.attributes.SMS = string.Empty;
}
dataContact.email = contacto.email;
dataContact.listIds = new List <int>();
dataContact.listIds = contacto.listIds;
dataContact.emailBlacklisted = false;
dataContact.smsBlacklisted = false;
dataContact.unlinkListIds = new List <int>();
dataContact.smtpBlacklistSender = new List <string>();
return(JsonConvert.SerializeObject(dataContact));
}
public IActionResult Update(int id)
{
var FindedContact = ContactsRep.FindById(id);
UpdateContactModel UpdateModel = new UpdateContactModel();
UpdateModel.Id = id;
UpdateModel.FirstName = FindedContact.FirstName;
UpdateModel.LastName = FindedContact.LastName;
UpdateModel.CurrentImage = FindedContact.Image;
UpdateModel.Note = FindedContact.Note;
//UpdateModel.ContactItems = FindedContact.ContactItems;
UpdateModel.Title = FindedContact.Title;
UpdateModel.Type4Display = Types.GetAll().ToList();
UpdateModel.ContactItemsModel = new List <UpdateContacrItemModel>();
foreach (var item in FindedContact.ContactItems)
{
UpdateModel.ContactItemsModel.Add(new UpdateContacrItemModel
{
ContactItemId = item.Id,
TypeId = item.ItemType.Id,
TypeName = item.ItemType.Name,
Value = item.Value,
Scope = item.Scope
});
}
return(View(UpdateModel));
}
public async Task <Contact> UpdateAsync(int id, UpdateContactModel item)
{
var contact = _mapper.Map <ContactModel, Contact>(item);
contact.Id = id;
await _contactRepository.UpdateAsync(contact);
return(contact);
}
public async Task <int> UpdateContact(UpdateContactModel updatemodel)
{
try
{
_dbconnection.StoredProcedure = Constants.UpdateContactStoredProcedure;
_dbconnection.Parameters = updatemodel;
return(await _dapperRepository.Execute(_dbconnection));
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult UpdateItemFromContactList([FromBody] UpdateContactModel o)
{
ReturnMessage rm = _contactListService.UpdateItemFromContactList(o);
if (rm.Error)
{
return(NotFound(rm.Message));
}
else
{
return(Ok(rm.Message));
}
}
public async Task <IActionResult> Update([FromRoute] int id, [FromBody] UpdateContactModel item)
{
item.Id = id;
var result = _updateContactValidator.Validate(item);
if (result.IsValid)
{
var updated = await _contactService.UpdateAsync(id, item);
return(Ok(updated));
}
else
{
return(BadRequest(result.Errors.Select(t => t.ErrorMessage)));
}
}
public ReturnMessage UpdateItemFromContactList(UpdateContactModel o)
{
ContactModel cm = new ContactModel();
ReturnMessage rm = cm.NewContact(o.Name, o.CompanyName, o.Base64ProfileImage, o.Email, o.BirthDay.ToString(), o.PhoneNumber, o.Address);
if (!rm.Error)
{
if (_contactListStorage.ContainsKey(o.Id))
{
_contactListStorage[o.Id] = cm;
rm.Message = "Contact with id = " + o.Id + " updated ";
}
else
{
rm.Error = true;
rm.Message = "No contact with id = " + o.Id + " found";
}
}
return(rm);
}
public async Task <ObjectId> UpdateAsync(ObjectId id, UpdateContactModel model)
{
var contact = await _contactsRepository.GetAsync(id);
if (contact == null)
{
throw new NotFoundException();
}
contact.FirstName = !string.IsNullOrEmpty(model.FirstName) ? model.FirstName : contact.FirstName;
contact.LastName = !string.IsNullOrEmpty(model.LastName) ? model.LastName : contact.LastName;
contact.MiddleName = !string.IsNullOrEmpty(model.MiddleName) ? model.MiddleName : contact.MiddleName;
contact.Phone = !string.IsNullOrEmpty(model.Phone) ? model.Phone : contact.Phone;
contact.WorkPhone = !string.IsNullOrEmpty(model.WorkPhone) ? model.WorkPhone : contact.WorkPhone;
contact.WorkPosition = !string.IsNullOrEmpty(model.WorkPosition) ? model.WorkPosition : contact.WorkPosition;
contact.UpdatedAt = DateTime.UtcNow;
await _contactsRepository.UpdateAsync(contact);
return(id);
}
public IActionResult Update(int id, [FromBody] UpdateContactModel model)
{
try
{
var updatedEntity = _contactService.Update(
id,
model.FirstName,
model.LastName,
model.Email,
model.HomeNumber,
model.MobileNumber,
model.ImageHash
);
return(new JsonResult(updatedEntity));
}
catch (KeyNotFoundException) // Contact not found.
{
return(new JsonErrorResult(ErrorResults.ContactNotFoundResult, System.Net.HttpStatusCode.BadRequest));
}
}
public async Task <IActionResult> Update([FromRoute] string id, [FromBody] UpdateContactModel model) /// Стоит использовать JsonMergePatchDocument потому что если поле не передано, не надо обновлять
{
if (!ModelState.IsValid)
{
return(UnprocessableEntity());
}
ObjectId updatedId;
try
{
updatedId = await _contactsService.UpdateAsync(new ObjectId(id), model);
}
catch (NotFoundException)
{
return(NotFound());
}
return(Ok(new ContactResponse {
Id = updatedId
}));
}
public IActionResult Put(int id, [FromBody] UpdateContactModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(GetModelErrors(ModelState)));
}
var contact = _contactService.GetContactById(id, this.TenantId);
if (contact == null)
{
return(NotFound());
}
contact.Id = model.ContactId;
contact.FirstName = model.FirstName;
contact.LastName = model.LastName;
contact.Email = model.Email;
contact.Mobile = model.Mobile;
_contactService.UpdateContact(contact);
return(Ok(model));
}
public async Task <UpdateContactResponseModel> UpdateContactAsync(UpdateContactModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
try
{
string json = JsonConvert.SerializeObject(model, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
using StringContent stringContent = new StringContent(json, Encoding.Default, "application/json");
var result = await client.PostAsync(new Uri(BaseAddress + "/v1/brands/" + BrandId + "/contacts/" + model.ContactId
+ "?field_values_op=" + model.FieldValuesOperation.ToString().ToLower(DefaultCultureInfo)
+ "&list_ids_op=" + model.ListIdsOperation.ToString().ToLower(DefaultCultureInfo)
+ "&unsubscribe_ids_op=" + model.UnsubscribeIdsOperation.ToString().ToLower(DefaultCultureInfo)), stringContent);
var jsonResponse = await result.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <UpdateContactResponseModel>(jsonResponse);
response.IsSuccessfull = result.IsSuccessStatusCode;
return(response);
}
catch (Exception e)
{
return(new UpdateContactResponseModel
{
IsSuccessfull = false,
Message = e.Message
});
}
}
public UpdateContactResponseModel UpdateContact(UpdateContactModel model) => UpdateContactAsync(model).ConfigureAwait(false).GetAwaiter().GetResult();
public async Task <ActionResult> UpdateContact([FromBody] UpdateContactModel model)
{
var result = await _addressbookservice.UpdateContact(model);
return(Json(new { success = true, response = result }));
}
private bool CheckFullNameWithTitleIsEmpty(UpdateContactModel Contact4Check)
{
return(!(string.IsNullOrEmpty(Contact4Check.FirstName) &&
string.IsNullOrEmpty(Contact4Check.LastName) &&
string.IsNullOrEmpty(Contact4Check.Title)));
}
public UpdateContactModelValidatorTests()
{
_validator = new UpdateContactModelValidator();
_model = new UpdateContactModel();
}
