/// <summary>
/// Save form default component field
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveFormDefaultComponentField(FormDefaultComponentFieldManageModel model)
{
ResponseModel response;
var formDefaultComponentField = GetById(model.Id);
if (formDefaultComponentField != null)
{
formDefaultComponentField.FormDefaultComponentId = model.FormDefaultComponentId;
formDefaultComponentField.Name = model.Name;
formDefaultComponentField.Attributes = SerializeUtilities.Serialize(model.Attributes);
formDefaultComponentField.RecordOrder = model.RecordOrder;
response = Update(formDefaultComponentField);
return(response.SetMessage(response.Success
? T("FormDefaultComponentField_Message_UpdateSuccessfully")
: T("FormDefaultComponentField_Message_UpdateFailure")));
}
formDefaultComponentField = new FormDefaultComponentField
{
FormDefaultComponentId = model.FormDefaultComponentId,
Name = model.Name,
Attributes = SerializeUtilities.Serialize(model.Attributes),
RecordOrder = model.RecordOrder
};
response = Insert(formDefaultComponentField);
return(response.SetMessage(response.Success
? T("FormDefaultComponentField_Message_CreateSuccessfully")
: T("FormDefaultComponentField_Message_CreateFailure")));
}
/// <summary>
/// Save template
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveTemplateManageModel(WidgetTemplateManageModel model)
{
ResponseModel response;
var template = GetById(model.Id);
if (template != null)
{
var log = new WidgetTemplateLogManageModel(template);
template.Name = model.Name;
template.Widgets = SerializeUtilities.Serialize(model.Shortcuts);
template.Content = model.Content;
template.Style = model.Style;
template.Script = model.Script;
template.FullContent = GetFullTemplate(model);
response = Update(template);
if (response.Success)
{
_templateLogService.SaveTemplateLog(log);
}
return(response.SetMessage(response.Success
? T("WidgetTemplate_Message_UpdateSuccessfully")
: T("WidgetTemplate_Message_UpdateFailure")));
}
Mapper.CreateMap <WidgetTemplateManageModel, WidgetTemplate>();
template = Mapper.Map <WidgetTemplateManageModel, WidgetTemplate>(model);
template.FullContent = GetFullTemplate(model);
response = CreateTemplate(template);
return(response.SetMessage(response.Success
? T("WidgetTemplate_Message_CreateSuccessfully")
: T("WidgetTemplate_Message_CreateFailure")));
}
/// <summary>
/// Save site setup
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveCompanySetupModel(CompanySetupModel model)
{
ResponseModel response;
var setting = _siteSettingRepository.FetchFirst(s => s.Name.Equals(SettingNames.CompanySetupSetting));
if (setting == null)
{
setting = new SiteSetting
{
Name = SettingNames.CompanySetupSetting,
Description = SettingNames.CompanySetupSetting,
Value = SerializeUtilities.Serialize(model),
SettingType = "system"
};
response = _siteSettingRepository.Insert(setting);
}
else
{
setting.Value = SerializeUtilities.Serialize(model);
response = _siteSettingRepository.Update(setting);
}
return(response);
}
/// <summary>
/// Post status
/// </summary>
/// <param name="model"></param>
/// <param name="network"></param>
/// <returns></returns>
public ResponseModel Post(SocialMessageModel model, SocialMediaEnums.SocialNetwork network)
{
try
{
var token = GetActiveTokenOfSocialMedia(network);
if (token != null)
{
object response = null;
var authorizeModel = new SocialMediaResponseModel
{
AppId = token.AppId,
AppSecret = token.AppSecret,
AccessToken = token.AccessToken,
AccessTokenSecret = token.AccessTokenSecret
};
switch (network)
{
case SocialMediaEnums.SocialNetwork.Facebook:
response = SocialUtilities.PostFacebookStatus(authorizeModel, model);
break;
case SocialMediaEnums.SocialNetwork.Twitter:
response = SocialUtilities.PostTwitterStatus(authorizeModel, model);
break;
case SocialMediaEnums.SocialNetwork.LinkedIn:
response = SocialUtilities.PostLinkedInStatus(authorizeModel, model);
break;
}
var responseResult = string.Empty;
if (response != null)
{
responseResult = SerializeUtilities.Serialize(response);
}
return(new ResponseModel
{
Success = true,
Data = responseResult
});
}
return(new ResponseModel
{
Success = false,
Message = T("SocialMediaToken_Message_ObjectNotFound")
});
}
catch (Exception exception)
{
return(new ResponseModel(exception));
}
}
public SubscriptionManageModel(Page page)
: this()
{
var parameterModel = new SubscriptionPageParameterModel(page);
Parameters = SerializeUtilities.Serialize(parameterModel);
Module = SubscriptionEnums.SubscriptionModule.Page;
SubscriptionType = SubscriptionEnums.SubscriptionType.Midnight;
}
/// <summary>
/// Get url request
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <returns></returns>
public static string PostRequest(string url, object data)
{
using (var client = new WebClient())
{
client.Headers.Add("Content-Type", "application/json");
var dataString = SerializeUtilities.Serialize(data);
return(client.UploadString(url, dataString));
}
}
/// <summary>
/// Get default components
/// </summary>
/// <returns></returns>
private string GetDefaultFormComponents()
{
var components = _formDefaultComponentRepository.GetAll().ToList();
var data = components.Select(c => new FormData
{
title = c.Name,
template = c.FormComponentTemplate.Name,
fields = GetFields(c.FormDefaultComponentFields)
});
return(SerializeUtilities.Serialize(data));
}
public string GetGridSettings(string name)
{
var setting = _userService.GetUserGridSetting(WorkContext.CurrentUser.Id, name);
if (setting == null)
{
setting = new GridSettingItem
{
Name = name,
Columns = new List <ColumnSetting>()
};
}
return(SerializeUtilities.Serialize(setting).RemoveNewLine());
}
/// <summary>
/// Save contact group to notification
/// </summary>
/// <param name="model"></param>
/// <param name="message"></param>
/// <returns></returns>
public ContactStatisticModel SaveContactGroup(ContactGroupSetupModel model, out string message)
{
var notification = GetById(model.Id);
if (notification != null)
{
// Deserialize contact queries string in notification model to object
var contactSearchModels = string.IsNullOrEmpty(notification.ContactQueries)
? new List <ContactSearchModel>()
: SerializeUtilities.Deserialize <List <ContactSearchModel> >(notification.ContactQueries);
// Number of contacts before new queries is added
var totalExistingContacts = _contactService.SearchContacts(contactSearchModels).Count();
// Add new queries
contactSearchModels.Add(model.ContactSearchModel);
// Number of contact after new queries is added
var totalContactsAfterAdded = _contactService.SearchContacts(contactSearchModels).Count();
// Number of contact in new queries
var totalNewContactsExpected = _contactService.SearchContacts(model.ContactSearchModel).Count();
// Serialize contact queries and assign to notification model
notification.ContactQueries = SerializeUtilities.Serialize(contactSearchModels);
// Save new notification
var response = Update(notification);
if (response.Success)
{
message = string.Format("{0} duplicated contact(s). {1} contact(s) added successfully.",
totalNewContactsExpected + totalExistingContacts - totalContactsAfterAdded,
totalContactsAfterAdded - totalExistingContacts);
return(new ContactStatisticModel
{
ExistedContacts = totalNewContactsExpected + totalExistingContacts - totalContactsAfterAdded,
NewContacts = totalContactsAfterAdded - totalExistingContacts,
TotalContacts = totalContactsAfterAdded,
ContactSearchDetailsModel = new ContactSearchDetailsModel(model.ContactSearchModel)
});
}
message = T("Notification_Message_SavingContactGroupFailure");
return(null);
}
message = T("Notification_Message_ObjectNotFound");
return(null);
}
/// <summary>
/// Count contacts
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel CountContacts(ContactSearchModel model)
{
var notification = GetById(model.NotificationId);
if (notification != null)
{
// Deserialize contact queries string in notification model to object
var contactSearchModels = string.IsNullOrEmpty(notification.ContactQueries)
? new List <ContactSearchModel>()
: SerializeUtilities.Deserialize <List <ContactSearchModel> >(notification.ContactQueries);
// Number of contacts before new queries is added
var totalExistingContacts = _contactService.SearchContacts(contactSearchModels).Count();
// Add new queries
contactSearchModels.Add(model);
// Number of contact after new queries is added
var totalContactsAfterAdded = _contactService.SearchContacts(contactSearchModels).Count();
// Number of contact in new queries
var totalNewContactsExpected = _contactService.SearchContacts(model).Count();
// Serialize contact queries and assign to notification model
notification.ContactQueries = SerializeUtilities.Serialize(contactSearchModels);
var contactStatistic = new ContactStatisticModel
{
ExistedContacts = totalNewContactsExpected + totalExistingContacts - totalContactsAfterAdded,
NewContacts = totalContactsAfterAdded - totalExistingContacts,
TotalContacts = totalContactsAfterAdded
};
var response = new ResponseModel
{
Success = true,
Data = contactStatistic
};
return(response);
}
return(new ResponseModel
{
Success = false,
Message = T("Notification_Message_ObjectNotFound")
});
}
/// <summary>
/// Create email queue
/// </summary>
/// <param name="emailLog"></param>
/// <param name="useDefaultAccount"></param>
/// <returns></returns>
public ResponseModel CreateEmail(EmailLog emailLog, bool useDefaultAccount = false)
{
if (useDefaultAccount || emailLog.EmailAccountId == 0)
{
var defaultAccount = _emailAccountService.GetDefaultAccount();
if (defaultAccount == null)
{
defaultAccount = _emailAccountService.GetAll().FirstOrDefault();
if (defaultAccount == null)
{
return new ResponseModel
{
Success = false,
Message = T("EmailLog_Message_MissingDefaultAccount")
}
}
;
}
if (string.IsNullOrEmpty(emailLog.From))
{
emailLog.From = defaultAccount.Email;
}
if (string.IsNullOrEmpty(emailLog.FromName))
{
emailLog.FromName = defaultAccount.Email;
}
emailLog.EmailAccountId = defaultAccount.Id;
}
var logs = new List <EmailSendingLog>
{
new EmailSendingLog
{
Time = DateTime.Now,
Message = TFormat("EmailLog_Message_CreateEmailLog", DateTime.UtcNow)
}
};
emailLog.Message = SerializeUtilities.Serialize(logs);
var response = Insert(emailLog);
return(response.SetMessage(response.Success
? T("EmailLog_Message_CreateSuccessfully")
: T("EmailLog_Message_CreateFailure")));
}
/// <summary>
/// Get tab configurations
/// </summary>
/// <returns></returns>
private string GetTabConfigurations()
{
var tabs =
_formTabRepository.GetAll().Include(t => t.FormComponents.Select(c => c.FormComponentFields)).ToList();
var data = tabs.Select(t => new FormTabModel
{
title = t.Name,
data = t.FormComponents.Select(c => new FormData
{
title = c.Name,
template = c.FormComponentTemplate.Name,
fields = GetFields(c.FormComponentFields)
})
});
return(SerializeUtilities.Serialize(data));
}
public override void Initialize(DbContext ezDbContext)
{
EzCMSEntities dbContext = ezDbContext as EzCMSEntities;
if (dbContext != null)
{
var setting = GetSetup().DefaultValue;
var settingString = SerializeUtilities.Serialize(setting);
var insertSetting = new SiteSetting
{
Name = GetSetup().Name,
Description = GetSetup().Description,
Value = settingString,
SettingType = GetSetup().SettingType
};
dbContext.SiteSettings.AddIfNotExist(i => i.Name, insertSetting);
}
}
/// <summary>
/// Get widget template widgets
/// </summary>
/// <param name="widgetSetup"></param>
/// <returns></returns>
public static string GetTemplateWidgets(WidgetSetupModel widgetSetup)
{
try
{
var folder = string.Format("{0}.{1}.Widgets", DataSetupResourceType.WidgetTemplate.GetEnumName(), widgetSetup.Widget);
var widgets = GetAllResourcesInFolder(folder).Select(r => new WidgetTemplate
{
Name = r.Name.Replace(".cshtml", string.Empty),
Content = r.Content
}).ToList();
return(SerializeUtilities.Serialize(widgets));
}
catch (ArgumentException)
{
// No folder
return(string.Empty);
}
}
public JsonResult Contact(ContactModel model)
{
if (ModelState.IsValid)
{
var formModel = new FormModel()
{
FormTypeID = FormType.Contact,
Data = SerializeUtilities.Serialize(model),
EmailBodyString = RenderRazorViewToString("Contact", model)
};
var respone = _formServices.SaveForm(formModel);
if (respone)
{
return(Json(new { success = true }));
}
}
return(Json(new { success = false }));
}
public JsonResult Advisory(AdvisoryModel model)
{
if (ModelState.IsValid)
{
var formModel = new FormModel()
{
FormTypeID = FormType.Advisory,
Data = SerializeUtilities.Serialize(model),
EmailBodyString = RenderRazorViewToString("Advisory", model)
};
var respone = _formServices.SaveForm(formModel);
if (respone)
{
return(Json(new { success = true, idfield = "tuvan" }));
}
}
return(Json(new { success = false }));
}
/// <summary>
/// Save group settings
/// </summary>
/// <param name="model">the group setting model</param>
/// <returns></returns>
public ResponseModel SaveGroupSettings(GroupManageSettingModel model)
{
var group = GetById(model.Id);
if (group != null)
{
group.Settings = SerializeUtilities.Serialize(model.GroupSettingModel);
var response = Update(group);
return(response.SetMessage(response.Success
? T("RotatingImageGroup_Message_UpdateSuccessfully")
: T("RotatingImageGroup_Message_UpdateFailure")));
}
return(new ResponseModel
{
Success = false,
Message = T("RotatingImageGroup_Message_ObjectNotFound")
});
}
public JsonResult GoogleAnalyticApiSetup(GoogleAnalyticApiSetting model)
{
if (ModelState.IsValid)
{
var setting = _siteSettingService.GetSetting(model.GetSetup().Name);
var manageModel = _siteSettingService.GetSettingManageModel(setting.Id);
manageModel.Value = SerializeUtilities.Serialize(model);
var response = _siteSettingService.SaveSettingManageModel(manageModel);
return(Json(response));
}
return(Json(new ResponseModel
{
Success = false,
Message = ModelState.BuildValidationMessages()
}));
}
public ActionResult Edit(SiteSettingManageModel model, SubmitType submit)
{
if (ModelState.IsValid)
{
var setting = _siteSettingService.GetSetting(model.SettingName);
var updateSuccess = true;
var settingParser = HostContainer.GetInstances <IComplexSetting>().FirstOrDefault(parser => parser.GetSetup().Name.Equals(setting.Name));
if (settingParser != null)
{
if (TryUpdateModel((dynamic)settingParser))
{
model.Value = SerializeUtilities.Serialize(settingParser);
}
else
{
updateSuccess = false;
}
}
if (updateSuccess)
{
var response = _siteSettingService.SaveSettingManageModel(model);
SetResponseMessage(response);
if (response.Success)
{
switch (submit)
{
case SubmitType.Save:
return(RedirectToAction("Index"));
default:
return(RedirectToAction("Edit", new { id = model.Id }));
}
}
}
SetErrorMessage(T("SiteSetting_Message_UpdateFailure"));
return(RedirectToAction("Edit", new { id = model.Id }));
}
return(View(model));
}
/// <summary>
/// Load setting
/// </summary>
/// <returns></returns>
public virtual T LoadSetting <T>()
{
var settingService = HostContainer.GetInstance <IEzSiteSettingService>();
var settingString = settingService.GetSetting <string>(GetSetup().Name);
if (string.IsNullOrEmpty(settingString))
{
var setting = GetSetup().DefaultValue;
settingString = SerializeUtilities.Serialize(setting);
settingService.InsertSetting(new SiteSetting
{
Name = GetSetup().Name,
Description = GetSetup().Description,
Value = settingString,
SettingType = GetSetup().SettingType
});
return(setting);
}
return(SerializeUtilities.Deserialize <T>(settingString));
}
/// <summary>
/// Initialize default languages
/// </summary>
public void Initialize(DbContext ezContext)
{
var context = ezContext as EzCMSEntities;
if (context != null)
{
var dbContext = new EzCMSEntities();
var availableTools = EnumUtilities.GetAllItems <EditorTool>().Select(t => t.ToString());
var availableToolsJsonString = SerializeUtilities.Serialize(availableTools);
var toolbar = new Toolbar
{
Name = "Default Toolbar",
IsDefault = true,
BasicToolbar = availableToolsJsonString,
PageToolbar = availableToolsJsonString
};
dbContext.Toolbars.AddIfConditionInvalid(t => t.IsDefault, toolbar);
dbContext.SaveChanges();
}
}
/// <summary>
/// Add contact search to group
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel AddToGroup(AddToGroupModel model)
{
var contactGroupManageModel = new ContactGroupManageModel();
var contactSearchModel = SerializeUtilities.Deserialize <ContactSearchModel>(model.ContactSearchModel);
var contactSearchModels = new List <ContactSearchModel>();
switch (model.AddToGroupType)
{
case ContactGroupEnums.AddToGroupType.New:
contactSearchModels.Add(contactSearchModel);
contactGroupManageModel.Name = model.Name;
contactGroupManageModel.Queries = SerializeUtilities.Serialize(contactSearchModels);
break;
case ContactGroupEnums.AddToGroupType.Existing:
var contactGroup = GetById(model.Id);
if (contactGroup != null)
{
contactSearchModels =
SerializeUtilities.Deserialize <List <ContactSearchModel> >(contactGroup.Queries);
contactSearchModels.Add(contactSearchModel);
contactGroupManageModel.Id = contactGroup.Id;
contactGroupManageModel.Name = contactGroup.Name;
contactGroupManageModel.Queries = SerializeUtilities.Serialize(contactSearchModels);
contactGroupManageModel.Active = contactGroup.Active;
}
break;
}
var response = SaveContactGroup(contactGroupManageModel);
return(response.SetMessage(response.Success
? T("ContactGroup_Message_AddToGroupSuccessfully")
: T("ContactGroup_Message_AddToGroupFailure")));
}
/// <summary>
/// Generate subscription model
/// </summary>
/// <param name="module"></param>
/// <param name="email"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public SubscriptionWidget GenerateSubscription(SubscriptionEnums.SubscriptionModule module, string email,
dynamic parameters)
{
var model = new SubscriptionWidget();
if (parameters == null)
{
return(model);
}
model.Parameters = SerializeUtilities.Serialize(parameters);
model.Module = module;
model.Email = email;
// Check subscription existed or not
var currentSubscription = GetSubscription(module, email, parameters);
if (currentSubscription != null)
{
model.Id = currentSubscription.Id;
}
return(model);
}
public NotificationInitializeModel(NotificationEnums.NotificationModule module, dynamic parameters)
: this()
{
Module = module;
Parameters = SerializeUtilities.Serialize(parameters);
}
public AddToGroupModel(ContactSearchModel contactSearchModel)
: this()
{
ContactSearchModel = SerializeUtilities.Serialize(contactSearchModel);
}
/// <summary>
/// Initialize default settings
/// </summary>
public void Initialize(DbContext ezContext)
{
var context = ezContext as EzCMSEntities;
if (context != null)
{
if (!context.FormTabs.Any())
{
var now = DateTime.UtcNow;
#region Save Templates
var embeddedResources = DataInitializeHelper.GetAllResourcesInFolder("FormBuilder.Components",
DataSetupResourceType.Others);
foreach (var embeddedResource in embeddedResources)
{
var formComponentTemplate = new FormComponentTemplate
{
Name = Path.GetFileNameWithoutExtension(embeddedResource.Name),
Content = embeddedResource.Content
};
context.FormComponentTemplates.AddEntities(formComponentTemplate);
}
context.SaveChanges();
#endregion
#region Save Tabs
var setup = DataInitializeHelper.GetResourceContent("FormBuilder.Tabs.json", DataSetupResourceType.Others);
var tabs = SerializeUtilities.Deserialize <List <FormTabModel> >(setup);
var tabOrder = 0;
foreach (var item in tabs)
{
tabOrder += 10;
var tab = new FormTab
{
Name = item.title,
RecordOrder = tabOrder,
Created = now,
CreatedBy = FrameworkConstants.DefaultMigrationAccount
};
var componentOrder = 0;
foreach (var data in item.data)
{
// Get templates for component
var formComponentTemplate = context.FormComponentTemplates.First(t => t.Name.Equals(data.template));
componentOrder += 10;
var component = new FormComponent
{
FormTab = tab,
FormComponentTemplate = formComponentTemplate,
Name = data.title,
RecordOrder = componentOrder,
Created = now,
CreatedBy = FrameworkConstants.DefaultMigrationAccount
};
if (data.fields != null && data.fields.Keys.Any())
{
var fieldOrder = 0;
foreach (var field in data.fields)
{
fieldOrder += 10;
var formField = new FormComponentField
{
FormComponent = component,
Name = field.Key,
Attributes = SerializeUtilities.Serialize(field.Value),
RecordOrder = fieldOrder,
Created = now,
CreatedBy = FrameworkConstants.DefaultMigrationAccount
};
context.FormComponentFields.AddEntities(formField);
}
}
else
{
context.FormComponents.AddEntities(component);
}
}
}
#endregion
#region Save Default Form components
var componentsSetup = DataInitializeHelper.GetResourceContent("FormBuilder.DefaultFormComponents.json", DataSetupResourceType.Others);
var defaultFormComponents = SerializeUtilities.Deserialize <List <FormData> >(componentsSetup);
var defaultComponentOrder = 0;
foreach (var data in defaultFormComponents)
{
defaultComponentOrder += 10;
// Get template for component
var formComponentTemplate = context.FormComponentTemplates.First(t => t.Name.Equals(data.template));
var component = new FormDefaultComponent
{
FormComponentTemplate = formComponentTemplate,
Name = data.title,
RecordOrder = defaultComponentOrder,
Created = now,
CreatedBy = FrameworkConstants.DefaultMigrationAccount
};
if (data.fields != null && data.fields.Keys.Any())
{
var fieldOrder = 0;
foreach (var field in data.fields)
{
fieldOrder += 10;
var formField = new FormDefaultComponentField
{
FormDefaultComponent = component,
Name = field.Key,
Attributes = SerializeUtilities.Serialize(field.Value),
RecordOrder = fieldOrder,
Created = now,
CreatedBy = FrameworkConstants.DefaultMigrationAccount
};
context.FormDefaultComponentFields.AddEntities(formField);
}
}
else
{
context.FormDefaultComponents.AddEntities(component);
}
}
#endregion
context.SaveChanges();
}
}
}
public SubscriptionLogManageModel(SubscriptionEnums.SubscriptionModule module, dynamic parameters) : this()
{
Module = module;
Parameters = SerializeUtilities.Serialize(parameters);
}
public void Run(BackgroundTaskExecuteContext context)
{
var logger = HostContainer.GetInstance <ILogger>();
if (Interlocked.CompareExchange(ref _hasActiveTask, 1, 0) == 0)
{
var countEmails = 0;
try
{
// Update the background task last running time
var backgroundTaskService = HostContainer.GetInstance <IEzBackgroundTaskService>();
backgroundTaskService.UpdateLastRunningTimeTask(GetType());
var emailLogService = HostContainer.GetInstance <IEmailLogService>();
var emailAccountService = HostContainer.GetInstance <IEmailAccountService>();
var emailAccounts = emailAccountService.GetAll().ToList();
var emailLogs = emailLogService.GetEmailSendingQueues();
countEmails = emailLogs.Count();
foreach (var emailLog in emailLogs)
{
var emailAccount = emailAccounts.FirstOrDefault(e => e.Id == emailLog.EmailAccountId);
if (emailAccount != null)
{
var emailSetting = new EmailSetting
{
Host = emailAccount.Host,
Port = emailAccount.Port,
User = emailAccount.Username,
Password = emailAccount.Password,
EnableSsl = emailAccount.EnableSsl,
Timeout = emailAccount.TimeOut
};
var mailUtilities = new MailUtilities(emailSetting);
var logs = new List <EmailSendingLog>();
try
{
if (!string.IsNullOrEmpty(emailLog.Message))
{
logs = SerializeUtilities.Deserialize <List <EmailSendingLog> >(emailLog.Message);
}
mailUtilities.SendEmail(emailLog.From ?? emailAccount.Email, emailLog.FromName ?? emailAccount.DisplayName, emailLog.To, emailLog.CC, emailLog.Bcc,
true, emailLog.Subject, emailLog.Body);
emailLog.SentOn = DateTime.UtcNow;
logs.Add(new EmailSendingLog
{
Time = DateTime.Now,
Message = string.Format("Mail sent at {0} UTC Time", DateTime.UtcNow)
});
}
catch (Exception exception)
{
logs.Add(new EmailSendingLog
{
Time = DateTime.Now,
Message = string.Format("Error: {0}", exception.Message)
});
}
emailLog.SentTries++;
emailLog.Message = SerializeUtilities.Serialize(logs);
emailLogService.UpdateMail(emailLog);
}
}
}
catch (Exception exception)
{
logger.Error(string.Format("[{0}]", EzCMSContants.EmailTaskName), exception);
}
if (countEmails > 0)
{
logger.Info(string.Format("[{0}] Send {1} email(s) in queues", EzCMSContants.EmailTaskName, countEmails));
}
Interlocked.Exchange(ref _hasActiveTask, 0);
}
}
/// <summary>
/// Execute the background task
/// </summary>
/// <param name="context"></param>
public void Run(BackgroundTaskExecuteContext context)
{
var logger = HostContainer.GetInstance <ILogger>();
if (Interlocked.CompareExchange(ref _hasActiveTask, 1, 0) == 0)
{
var countNotifications = 0;
var countContacts = 0;
try
{
// Update the background task last running time
var backgroundTaskService = HostContainer.GetInstance <IEzBackgroundTaskService>();
backgroundTaskService.UpdateLastRunningTimeTask(GetType());
var notificationService = HostContainer.GetInstance <INotificationService>();
var contactGroupService = HostContainer.GetInstance <IContactGroupService>();
var emailLogService = HostContainer.GetInstance <IEmailLogService>();
// Get in queue notifications
var notifications = notificationService.GetNotificationQueues().ToList();
countNotifications = notifications.Count;
foreach (var notification in notifications)
{
var notificationTemplate = new NotificationTemplate
{
Subject = notification.NotificationSubject,
Body = notification.NotificationBody
};
// Get contacts from contact group in notification
var contacts = contactGroupService.GetContacts(notification.ContactQueries).ToList();
countContacts = contacts.Count;
// Save found contacts
var notifiedContactModels = contacts.Select(contact => new NotifiedContactModel(contact)).ToList();
notification.NotifiedContacts = SerializeUtilities.Serialize(notifiedContactModels);
notificationService.UpdateNotification(notification);
// Loop through notification email model to get the final html to send
foreach (var contact in contacts)
{
var emailBody = string.Empty;
switch (notification.Module)
{
case NotificationEnums.NotificationModule.Page:
emailBody = GetPageNotificationEmailContent(notification, notificationTemplate, contact);
break;
}
// Create email in email queue, ready to be sent
var response = emailLogService.CreateEmail(new EmailLog
{
To = contact.Email,
ToName = contact.FullName,
Subject = notificationTemplate.Subject,
Body = emailBody,
SendLater = notification.SendTime
});
// Deactive notification if email queue created successfully
if (response.Success)
{
notificationService.DeactiveNotification(notification);
}
}
}
}
catch (Exception exception)
{
logger.Error(string.Format("[{0}]", EzCMSContants.NotificationTaskName), exception);
}
if (countContacts > 0)
{
logger.Info(string.Format("[{0}] Send {1} notification(s) to {2} contact(s)", EzCMSContants.NotificationTaskName, countNotifications, countContacts));
}
Interlocked.Exchange(ref _hasActiveTask, 0);
}
}
