public ActionResult Edit(ContactManageModel model)
{
if (model == null)
{
return(RedirectToAction("List"));
}
if (ModelState.IsValid)
{
var contact = contactService.GetById(model.Id);
if (contact == null)
{
this.NotifyError("Item not found.");
return(RedirectToAction("List"));
}
else
{
contact.Email = model.Email;
contact.FullName = model.FullName;
var result = contactService.Save(contact);
if (result)
{
this.NotifySuccess("Successfully saved.");
}
else
{
this.NotifyError("Item can not saved!");
}
}
}
return(View(model));
}
public ActionResult PopupEdit(ContactManageModel model, SubmitType submit)
{
if (ModelState.IsValid)
{
var response = _contactService.SaveContact(model);
SetResponseMessage(response);
if (response.Success)
{
switch (submit)
{
case SubmitType.PopupSave:
return(View("CloseFancyBox", new CloseFancyBoxViewModel
{
IsReload = false,
ReturnUrl = string.Empty
}));
case SubmitType.SaveAndContinueEdit:
return(RedirectToAction("PopupEdit", new { id = model.Id }));
}
}
}
SetupPopupAction();
return(View(model));
}
public ActionResult Edit(int?id)
{
if (!id.HasValue)
{
return(RedirectToAction("List"));
}
var contact = contactService.GetById(id.Value);
if (contact == null)
{
this.NotifyError("Item not found.");
return(RedirectToAction("List"));
}
if (contact.IsRead == false)
{
contact.IsRead = true;
contactService.Save(contact);
}
var model = new ContactManageModel
{
Id = contact.Id,
FullName = contact.FullName,
Email = contact.Email,
IsRead = contact.IsRead,
Subject = contact.Subject,
Message = contact.Message,
Date = contact.DateUtc,
};
return(View(model));
}
public ActionResult Edit(ContactManageModel model, string returnUrl, SubmitType submit)
{
if (ModelState.IsValid)
{
var response = _contactService.SaveContact(model);
SetResponseMessage(response);
if (response.Success)
{
switch (submit)
{
case SubmitType.Save:
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index"));
default:
return(RedirectToAction("Edit", new { id = model.Id, returnUrl }));
}
}
}
return(View(model));
}
/// <summary>
/// Update contact property
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel UpdateContactData(XEditableModel model)
{
var contact = GetById(model.Pk);
if (contact != null)
{
var property =
ReflectionUtilities.GetAllPropertiesOfType(typeof(ContactManageModel))
.FirstOrDefault(p => p.Name.Equals(model.Name, StringComparison.CurrentCultureIgnoreCase));
if (property != null)
{
object value = model.Value.ToType(property, WorkContext.CurrentTimezone);
#region Validate
var manageModel = new ContactManageModel(contact);
manageModel.SetProperty(model.Name, value);
var validationResults = manageModel.ValidateModel();
if (validationResults.Any())
{
return(new ResponseModel
{
Success = false,
Message = validationResults.BuildValidationMessages()
});
}
#endregion
contact.SetProperty(model.Name, value);
var response = Update(contact);
return(response.SetMessage(response.Success
? T("Contact_Message_UpdateContactInfoSuccessfully")
: T("Contact_Message_UpdateContactInfoFailure")));
}
return(new ResponseModel
{
Success = false,
Message = T("Contact_Message_PropertyNotFound")
});
}
return(new ResponseModel
{
Success = false,
Message = T("Contact_Message_ObjectNotFound")
});
}
public ActionResult Create(ContactManageModel model, SubmitType submit)
{
if (ModelState.IsValid)
{
var response = _contactService.SaveContact(model);
SetResponseMessage(response);
if (response.Success)
{
var id = (int)response.Data;
switch (submit)
{
case SubmitType.Save:
return(RedirectToAction("Index"));
default:
return(RedirectToAction("Edit", new { id }));
}
}
}
return(View(model));
}
/// <summary>
/// Save contact
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveContact(ContactManageModel model)
{
ResponseModel response;
var contact = GetById(model.Id);
if (contact != null)
{
contact.Company = _companyService.SaveCompany(model.Company);
contact.IsCompanyAdministrator = model.IsCompanyAdministrator;
contact.Email = model.Email;
contact.Title = model.Title;
contact.FirstName = model.FirstName;
contact.LastName = model.LastName;
contact.AddressLine1 = model.AddressLine1;
contact.AddressLine2 = model.AddressLine2;
contact.Suburb = model.Suburb;
contact.State = model.State;
contact.Postcode = model.Postcode;
contact.Country = model.Country;
contact.Department = model.Department;
contact.PostalAddressLine1 = model.PostalAddressLine1;
contact.PostalAddressLine2 = model.PostalAddressLine2;
contact.PostalSuburb = model.PostalSuburb;
contact.PostalState = model.PostalState;
contact.PostalPostcode = model.PostalPostcode;
contact.PostalCountry = model.PostalCountry;
contact.PreferredPhoneNumber = model.PreferredPhoneNumber;
contact.PhoneWork = model.PhoneWork;
contact.PhoneHome = model.PhoneHome;
contact.MobilePhone = model.MobilePhone;
contact.Fax = model.Fax;
contact.Occupation = model.Occupation;
contact.Website = model.Website;
contact.Sex = model.Sex;
contact.DateOfBirth = model.DateOfBirth;
contact.DontSendMarketing = model.DontSendMarketing;
contact.Unsubscribed = model.Unsubscribed;
contact.UnsubscribeDateTime = model.UnsubscribeDateTime;
contact.SubscriptionType = model.SubscriptionType;
contact.Confirmed = model.Confirmed;
contact.ConfirmDateTime = model.ConfirmDateTime;
contact.FromIPAddress = model.FromIPAddress;
contact.ValidatedOk = model.ValidatedOk;
contact.ValidateLevel = model.ValidateLevel;
contact.CRMID = model.CRMID;
contact.SalesPerson = model.SalesPerson;
contact.UnsubscribedIssueId = model.UnsubscribedIssueId;
contact.Facebook = model.Facebook;
contact.Twitter = model.Twitter;
contact.LinkedIn = model.LinkedIn;
response = Update(contact);
return(response.SetMessage(response.Success
? T("Contact_Message_UpdateSuccessfully")
: T("Contact_Message_UpdateFailure")));
}
Mapper.CreateMap <ContactManageModel, Contact>();
contact = Mapper.Map <Contact>(model);
contact.Company = _companyService.SaveCompany(contact.Company);
response = Insert(contact);
return(response.SetMessage(response.Success
? T("Contact_Message_CreateSuccessfully")
: T("Contact_Message_CreateFailure")));
}
/// <summary>
/// Register subscription
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel Register(SubscriptionManageModel model)
{
// Decode the parameter because maybe when sending to server it is in raw format
model.Parameters = model.Parameters.Decode();
var response = new ResponseModel();
var subscriptions = new List <SubscriptionManageModel>();
var contacts = _contactService.SearchContactsByEmail(model.Email).ToList();
try
{
if (contacts.Any())
{
foreach (var contact in contacts)
{
contact.SubscriptionType = model.SubscriptionType;
// Update contact
_contactService.SaveContact(new ContactManageModel(contact));
// Save contact to subscribers
subscriptions.Add(new SubscriptionManageModel
{
ContactId = contact.Id,
Email = model.Email,
Module = model.Module,
Parameters = model.Parameters
});
}
}
else
{
var contact = new ContactManageModel
{
Email = model.Email,
SubscriptionType = model.SubscriptionType
};
response = _contactService.SaveContact(contact);
if (response.Success)
{
model.ContactId = response.Data.ToNullableInt();
}
subscriptions.Add(new SubscriptionManageModel
{
ContactId = model.ContactId,
Email = model.Email,
Module = model.Module,
Parameters = model.Parameters
});
}
foreach (var subscription in subscriptions)
{
var existedSubscription = GetSubscription(subscription.Module, subscription.Email,
subscription.Parameters);
if (existedSubscription == null)
{
Mapper.CreateMap <SubscriptionManageModel, Subscription>();
var newSubscription =
Mapper.Map <SubscriptionManageModel, Subscription>(subscription);
Insert(newSubscription);
}
}
WorkContext.CurrentContact.Email = model.Email;
return(new ResponseModel
{
Success = true,
Message = T("Subscription_Message_SubscribeSuccessfully")
});
}
catch (Exception exception)
{
_logger.Error(exception);
response.SetMessage(T("Subscription_Message_SubscribeFailure"));
}
return(response);
}
