public EmailQueue GetEmailQueueByID(int id)
{
EmailQueue result = null;
using (IDbConnection conn = Connection)
{
string sql = string.Format("select * from EmailQueues where ID = {0}", id);
try
{
conn.Open();
result = conn.Query <EmailQueue>(sql).AsQueryable().FirstOrDefault();
}
catch (SqlException sqlEx)
{
Logger.ErrorException(sqlEx);
}
catch (Exception ex)
{
Logger.ErrorException(ex);
}
finally
{
if (conn != null && conn.State != ConnectionState.Closed)
{
conn.Close();
}
}
}
return(result);
}
public Task <CommunicationResponse> Handle(SendEmailRequest Request, CancellationToken cancellationToken)
{
try
{
var Email = new EmailQueue()
{
EmailType = Request.EmailType,
Recepient = Request.Recepient,
Attachment = Request.Attachment,
BCC = Request.BCC,
CC = Request.CC,
Body = Request.Body,
Status = Convert.ToInt16(MessageStatusType.Initialize),
Subject = Request.Subject,
CreatedDate = DateTime.UtcNow
};
_MessageRepository.Add(Email);
return(Task.FromResult(new CommunicationResponse {
ErrorCode = 101, ReturnMsg = "Message sent."
}));
}
catch (Exception ex)
{
return(Task.FromResult(new CommunicationResponse {
ErrorCode = 99, ReturnMsg = "Message not sent."
}));
}
}
private EmailQueue GetEmail(FormType type, string jsonData, string employeeEmail, string employeeName)
{
var email = new EmailQueue()
{
From = "",
FromName = "Hệ Thống",
To = employeeEmail,
ToName = employeeName,
Subject = "",
CreatedBy = "system",
Created = DateTime.Now,
RecordActive = true,
};
var data = new object();
string resourceName = string.Empty;
string templateFilePath = string.Empty;
switch (type)
{
case FormType.Admission:
email.Subject = "Đăng kí nhập học";
data = SerializeUtilities.Deserialize <AdmissionData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Admission.cshtml";
break;
case FormType.Advisory:
email.Subject = "Đăng kí tư vấn";
data = SerializeUtilities.Deserialize <AdvisoryData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Advisory.cshtml";
break;
case FormType.Alumni:
email.Subject = "Thông tin cựu sinh viên";
data = SerializeUtilities.Deserialize <AlumniData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Alumni.cshtml";
break;
case FormType.Contact:
email.Subject = "Liên hệ";
data = SerializeUtilities.Deserialize <ContactData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Contact.cshtml";
break;
case FormType.Visit:
email.Subject = "Đăng kí tham quan";
data = SerializeUtilities.Deserialize <VisitSchoolData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.VisitSchool.cshtml";
break;
}
var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
string templateStr = reader.ReadToEnd();
email.Body = Engine.Razor.RunCompile(templateStr, "templateKey", null, data);
}
return(email);
}
public ActionResult ViewEmail(int emailid)
{
var email = CurrentDatabase.EmailQueues.SingleOrDefault(ee => ee.Id == emailid);
if (email == null)
{
return(Content("no email found"));
}
var curruser = CurrentDatabase.LoadPersonById(Util.UserPeopleId ?? 0);
if (curruser == null)
{
return(Content("no user"));
}
if (User.IsInRole("Admin") ||
User.IsInRole("ManageEmails") ||
email.FromAddr == curruser.EmailAddress ||
email.QueuedBy == curruser.PeopleId ||
email.EmailQueueTos.Any(et => et.PeopleId == curruser.PeopleId))
{
var em = new EmailQueue
{
Subject = email.Subject,
Body = Regex.Replace(email.Body, "({first}|{tracklinks}|{track})", "", RegexOptions.IgnoreCase)
};
return(View("Emails/View", em));
}
return(Content("not authorized"));
}
private void CreateEmailQueue(Form formData, FormType type)
{
List <Employees> listEmployees = _employeesService.GetList();
try
{
List <EmailQueue> emails = new List <EmailQueue>();
foreach (var employees in listEmployees)
{
EmailQueue newEmail = GetEmail(type, formData.Data, employees.Email, employees.Name);
int addToQueue = _emailQueueService.AddNewEmail(newEmail);
if (addToQueue > 0)
{
emails.Add(newEmail);
}
}
TaskSentMail(emails);
}
catch (Exception ex)
{
Logger.ErrorException(ex);
}
}
public List <long> Save(CoreEmailDto emailQueueDto)
{
using (var dbContext = MailerContext)
{
var savedEmailIds = new List <long>();
using (var trans = new TransactionScope())
{
var emailMessage = new EmailMessage
{
FromAddress = emailQueueDto.From.EmailAddress,
FromPerson = emailQueueDto.From.DisplayName,
SubjectTemplate = emailQueueDto.SubjectTemplate,
BodyTemplate = emailQueueDto.BodyTemplate,
Host = emailQueueDto.Host,
Port = emailQueueDto.Port
};
dbContext.EmailMessages.Add(emailMessage);
dbContext.SaveChanges();
var newEmailMessageId = emailMessage.EmailMessageId;
foreach (var receiverMail in emailQueueDto.To)
{
var emailQueue = new EmailQueue
{
EmailMessageId = newEmailMessageId,
EmailStatus = (byte)EmailQueueStatus.Unprocessed,
EmailType = emailQueueDto.EmailType,
TriesLeft = emailQueueDto.TriesLeft,
AvailableToSendFromUtc = DateTime.UtcNow,
CreatedOn = DateTime.UtcNow,
CreatedBy = "System", // TODO change that
ToEmailAddress = receiverMail.EmailAddress,
ToPerson = receiverMail.DisplayName
};
var replacements = new List <EmailReplacement>();
foreach (var replacementDto in emailQueue.EmailReplacements)
{
var replacement = new EmailReplacement
{
Token = replacementDto.Token,
Value = replacementDto.Value
};
replacements.Add(replacement);
}
replacements.ForEach(x => emailQueue.EmailReplacements.Add(x));
dbContext.EmailQueues.Add(emailQueue);
dbContext.SaveChanges();
savedEmailIds.Add(emailQueue.EmailQueueId);
}
trans.Complete();
}
return(savedEmailIds);
}
}
public ReturnObject CreatePendingEmail(TransferData transferData)
{
logger.Info("Create pending email");
string address = transferData.To;
string toEmail = _walletBusiness.FindEmailByAddressAndNetworkName(address, transferData.Symbol());
if (toEmail == null)
{
return new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = "Cannot find email address of user!!"
}
}
;
var email = new EmailQueue
{
ToEmail = toEmail,
SignInUrl = EmailConfig.SIGN_IN_URL,
Amount = transferData.Amount(),
Template = EmailTemplate.Received,
// SentOrReceived = EmailConfig.SentOrReceived_Received,
NetworkName = transferData.Symbol(),
Subject = EmailConfig.SUBJECT_SENT_OR_RECEIVED,
Status = Status.STATUS_PENDING,
IsProcessing = 0,
Version = 0
};
var result = _sendMailBusiness.CreateEmailQueueAsync(email);
return(result.Result);
}
}
private MessageContext prepareMessage(EmailQueue email)
{
context = new MessageContext();
context.SMTPSetting = email.SiteSMTP;
context.domain = email;
context.MailMessage.To.Add(GetValidEmailID(email.TO));
context.MailMessage.From = new MailAddress(email.From, string.Empty, System.Text.Encoding.UTF8);
if (!String.IsNullOrEmpty(email.CC))
{
context.MailMessage.CC.Add(GetValidEmailID(email.CC));
}
if (!String.IsNullOrEmpty(email.BCC))
{
context.MailMessage.Bcc.Add(GetValidEmailID(email.BCC));
}
if (!String.IsNullOrEmpty(email.ReplyTO))
{
context.MailMessage.ReplyToList.Add(new MailAddress(email.ReplyTO));
}
context.MailMessage.Subject = email.Subject;
ContentType c = new ContentType(MediaTypeNames.Text.Html);
AlternateView oAlternateView = AlternateView.CreateAlternateViewFromString(email.EmailContent, c);
context.MailMessage.AlternateViews.Add(oAlternateView);
context.MailMessage.Body = email.EmailContent;
context.MailMessage.Priority = MailPriority.High;
return(context);
}
static void Main(string[] args)
{
EmailQueue = new EmailQueue();
Addfila();
Console.ReadLine();
Processar();
}
/// <summary>
/// CreateDataEmail
/// </summary>
/// <param name="subject"></param>
/// <param name="email"></param>
/// <param name="amount"></param>
/// <param name="transactionId"></param>
/// <param name="template"></param>
/// <param name="networkName"></param>
/// <param name="smartcontractRepositoryFactory"></param>
/// <param name="isInnerTransaction"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public static async Task CreateDataEmail(string subject, string email, decimal amount, string transactionId,
EmailTemplate template, string networkName, ISmartContractRepositoryFactory smartcontractRepositoryFactory,
bool isInnerTransaction)
{
try
{
var currentTime = CommonHelper.GetUnixTimestamp();
var sendMailBusiness = new SendMailBusiness(smartcontractRepositoryFactory, false);
if (email == null)
{
return;
}
var emailQueue = new EmailQueue
{
Id = CommonHelper.GenerateUuid(),
ToEmail = email,
Template = template,
Subject = subject,
NetworkName = networkName,
IsInnerTransaction = isInnerTransaction,
Amount = amount,
TransactionId = transactionId,
Status = Status.STATUS_PENDING,
CreatedAt = currentTime,
UpdatedAt = currentTime
};
await sendMailBusiness.CreateEmailQueueAsync(emailQueue);
}
catch (Exception e)
{
throw e;
}
}
private string GetReceivedAddress(EmailQueue emailQueue)
{
try
{
if (emailQueue.IsInnerTransaction == false)
{
return(GetTransaction(emailQueue).ToAddress);
}
using (var internalTransactionsRepository = new InternalTransactionsRepository(_connectionDb))
{
var transaction = internalTransactionsRepository.FindById(emailQueue.TransactionId);
using (var userRepository = new UserRepository(_connectionDb))
{
var user = userRepository.FindById(transaction.ReceiverUserId);
return(user.mem_id);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
using (var sd = UserManager.GetSecureData(false)){
using (var dm = DataManager.Create(sd.DataConnectionSpec)){
var resultID = saveData(false);
// mark it as submitted
var dt = dm.Read("select feedback_result_group_id from feedback_result where feedback_result_id = :frid", new DataParameters(":frid", resultID, DbType.Int32));
if (dt.Rows.Count > 0)
{
var dr = dt.Rows[0];
dm.Write(@"
update
feedback_result_group
set
modified_date = :now1,
modified_by = :who1,
submitted_date = :now2
where
feedback_result_group_id = :frid
", new DataParameters(":now1", DateTime.UtcNow, DbType.DateTime2,
":who1", sd.CooperatorID, DbType.Int32,
":now2", DateTime.UtcNow, DbType.DateTime2,
":frid", Toolkit.ToInt32(dr["feedback_result_group_id"], -1), DbType.Int32));
}
// cancel any reminder emails
EmailQueue.DequeueEmail("feedback_result|%", resultID);
}
}
Master.FlashMessage("Your data has been submitted for review. Thank you!", "~/feedback/participantdefault.aspx", null);
}
public static async Task SendAsync(string tenant, Uri baseUri, EmailViewModel model)
{
var processor = EmailProcessor.GetDefault(tenant);
if (processor == null)
{
throw new EmailException(I18N.NoEmailProcessorDefined);
}
string attachmentPath = ExportHelper.Export(tenant, baseUri, "pdf", model.Html);
attachmentPath = PathMapper.MapPath(attachmentPath);
var email = new EmailQueue
{
AddedOn = DateTimeOffset.UtcNow,
SendOn = DateTimeOffset.UtcNow,
SendTo = model.SendTo,
FromName = processor.Config.FromName,
ReplyTo = processor.Config.FromEmail,
Subject = model.Subject,
Message = model.Message,
Attachments = attachmentPath
};
var manager = new MailQueueManager(tenant, email);
await manager.AddAsync().ConfigureAwait(false);
await manager.ProcessQueueAsync(processor, true).ConfigureAwait(false);
}
private async Task SaveFailedEmailToQueue(string email, string subject, string message, int?companyId = default)
{
try
{
var item = new EmailQueue()
{
EmailAddress = email,
Subject = subject,
Body = message
};
using (var serviceScope = _serviceScopeFactory.CreateScope())
{
AppDbContext context = serviceScope.ServiceProvider.GetRequiredService <AppDbContext>();
if (companyId.HasValue)
{
item.CompanyId = companyId.Value;
context.SetCompanyID(item.CompanyId);
}
context.Add(item);
await context.SaveChangesAsync();
}
}
catch (Exception ex)
{
_logger.LogError(ex, "SaveFailedEmailToQueue");
}
}
protected void Application_Start(object sender, EventArgs e)
{
// wipe out all caches to make sure an app restart causes a clean slate
CacheManager.ClearAll();
// clean up the export folder so it doesn't get huge over time
// this will also alert us up front if there's problems being able to write to the exports folder
// instead of exports just failing whenever they are requested
string exportFolder = Server.MapPath("~/uploads/exports/");
if (Directory.Exists(exportFolder))
{
foreach (string f in Directory.GetFiles(exportFolder))
{
if (!f.ToLower().EndsWith("placeholder.txt"))
{
File.Delete(f);
}
}
}
// look up the version # of the gringlobal.web.dll so we can show it on the website
var path = Server.MapPath("~/bin/GrinGlobal.Web.dll");
if (File.Exists(path))
{
var fvi = FileVersionInfo.GetVersionInfo(path);
Application["VERSION"] = fvi.FileVersion;
}
// begin monitoring for emails to send
EmailQueue.BeginMonitoring();
}
/// <summary>
///
/// </summary>
/// <param name="objectID"></param>
/// <param name="sender"></param>
/// <param name="subject"></param>
/// <returns></returns>
public Email GetNextEmail(UUID objectID, string sender, string subject)
{
EmailQueue queue = m_MailQueues.GetOrAddIfNotExists(objectID, delegate() { return(new EmailQueue()); });
queue.m_LastCall = DateTime.Now;
// Hopefully this isn't too time consuming. If it is, we can always push it into a worker thread.
DateTime now = DateTime.Now;
foreach (UUID uuid in m_MailQueues.Keys)
{
if (m_MailQueues.TryGetValue(uuid, out queue))
{
if ((now - queue.m_LastCall) > m_QueueTimeout)
{
m_MailQueues.Remove(uuid);
}
}
}
queue = m_MailQueues.GetOrAddIfNotExists(objectID, delegate() { return(new EmailQueue()); });
return(queue.m_Queue.RemoveMatch(delegate(Email m)
{
return ((sender == null || sender.Equals("") || sender.Equals(m.sender)) &&
(subject == null || subject.Equals("") || subject.Equals(m.subject)));
}));
}
public ActionResult ViewEmail(int emailid)
{
var email = DbUtil.Db.EmailQueues.SingleOrDefault(ee => ee.Id == emailid);
if (email == null)
{
return(Content("no email found"));
}
var curruser = DbUtil.Db.LoadPersonById(Util.UserPeopleId ?? 0);
if (curruser == null)
{
return(Content("no user"));
}
if (User.IsInRole("Admin") ||
User.IsInRole("ManageEmails") ||
email.FromAddr == curruser.EmailAddress ||
email.QueuedBy == curruser.PeopleId ||
email.EmailQueueTos.Any(et => et.PeopleId == curruser.PeopleId))
{
var em = new EmailQueue
{
Subject = email.Subject,
Body = email.Body.Replace("{track}", "", true).Replace("{first}", "", true)
};
return(View("Emails/View", em));
}
return(Content("not authorized"));
}
public async Task <bool> RemindAsync(string tenant, ReminderMessage message)
{
await Task.Delay(0).ConfigureAwait(false);
string sendTo = message.Contact.EmailAddresses;
string timezone = message.Contact.TimeZone.Or(message.Event.TimeZone);
if (string.IsNullOrWhiteSpace(sendTo))
{
return(false);
}
int alarm = message.Event.Alarm ?? 0;
if (alarm == 0)
{
return(false);
}
string template = Configs.GetNotificationEmailTemplate(tenant);
string eventDate = TimeZoneInfo.ConvertTime(DateTime.UtcNow.AddMinutes(alarm), TimeZoneInfo.FindSystemTimeZoneById(timezone)).Date.ToString("D");
string startTime = TimeZoneInfo.ConvertTime(message.Event.StartsAt, TimeZoneInfo.FindSystemTimeZoneById(timezone)).ToString("t");
string endTime = TimeZoneInfo.ConvertTime(message.Event.EndsOn, TimeZoneInfo.FindSystemTimeZoneById(timezone)).ToString("t");
template = template.Replace("{Name}", message.Event.Name);
template = template.Replace("{StartTime}", startTime);
template = template.Replace("{EndTime}", endTime);
template = template.Replace("{Date}", eventDate);
template = template.Replace("{Location}", message.Event.Location);
template = template.Replace("{Note}", message.Event.Note);
var processor = EmailProcessor.GetDefault(tenant);
if (processor == null)
{
return(false);
}
var email = new EmailQueue
{
AddedOn = DateTimeOffset.UtcNow,
SendOn = DateTimeOffset.UtcNow,
SendTo = sendTo,
FromName = processor.Config.FromName,
ReplyTo = processor.Config.FromEmail,
ReplyToName = processor.Config.FromName,
Subject = string.Format(I18N.CalendarNotificationEmailSubject, message.Event.Name, startTime),
Message = template
};
var manager = new MailQueueManager(tenant, email);
await manager.AddAsync().ConfigureAwait(false);
await manager.ProcessQueueAsync(processor).ConfigureAwait(false);
return(true);
}
// Method to notify the Trainer of any Task completion.
public bool Trainer_Notification(int id, bool done)
{
try
{
Task data = taskrepo.ReadById(id);
Users trainee = usersrepo.ReadById(data.TraineeId);
Users trainer = usersrepo.ReadById(data.TrainerId);
EmailQueue email = new EmailQueue();
if (done)
{
email.ToAddress = trainer.Email;
email.FromAddress = "*****@*****.**";
email.Subject = trainee.Name + " Task Update";
email.Body = string.Format("Dear "
+ trainer.Name
+ ",<BR><BR> The Task that you assigned to " + trainee.Name +
" has been completed. Kindly check whether it is done properly or not.<BR><BR>Sincerely,<BR>Clanstech Team.");
int r = emailrepo.Insert(email);
if (r >= 1)
{
return(true);
}
}
else
{
email.ToAddress = trainer.Email;
email.FromAddress = "*****@*****.**";
email.Subject = trainee.Name + " Task Update";
email.Body = string.Format("Dear "
+ trainer.Name
+ ",<BR><BR> The Task that you assigned to " + trainee.Name +
" is not completed on time. Kindly take appropriate action.<BR><BR>Sincerely,<BR>Clanstech Team.");
emailrepo.Insert(email);
}
}
catch (Exception ex)
{
MethodBase method = MethodBase.GetCurrentMethod();
Exceptions exception = new Exceptions
{
Number = ex.HResult.ToString(),
Message = ex.Message,
Method = method.Name,
Url = System.Web.HttpContext.Current.Request.Url.AbsoluteUri
};
int r = exceptionrepo.Exception_Create(exception);
if (r == 0)
{
exceptionrepo.Exception_InsertInLogFile(exception);
}
if (constr.State != ConnectionState.Open)
{
constr.Close();
constr.Open();
}
}
return(false);
}
public static EmailQueue EmailQueue(int?counter)
{
var rtValue = new EmailQueue();
rtValue.Text = "Text" + counter.Extra();
rtValue.Order = new Order();
rtValue.NotificationType = Purchasing.Core.Domain.EmailPreferences.NotificationTypes.PerEvent;
return(rtValue);
}
public static EmailQueue EmailQueue(int? counter)
{
var rtValue = new EmailQueue();
rtValue.Student = new Student();
rtValue.Template = new Template();
rtValue.Subject = "Subject" + counter.Extra();
rtValue.Body = "Body" + counter.Extra();
return rtValue;
}
public ActionResult Delete(int id)
{
DBEntities e = COREobject.i.Context;
EmailQueue row = e.EmailQueueItems.Single(m => m.Id == id);
e.EmailQueueItems.Remove(row);
e.SaveChanges();
return(RedirectToRoute("Hermes", new { @action = "Index" }));
}
public bool Save(EmailQueue email)
{
if (email.id > 0)
{
return(_emailQueueDao.Update(email) > 0);
}
else
{
return(_emailQueueDao.Insert(email) > 0);
}
}
static public void Send(string to, string vesselName, string subject, string body, string attachmentFileName)
{
EmailItem item = new EmailItem(FromEmailAddress, to, vesselName, subject, body, attachmentFileName);
lock (_lock)
{
EmailQueue.Add(item);
}
// Try sending email 3 seconds from now.
_timer.Change(3000, 3000);
}
private void SendWarningHtml(string lang, int pid, string pname, string email, int uid)
{
string url = string.Format("{0}/plant/warningfilter/?pid={1}&uid={2}", domainUrl, pid, uid);
string html = Tool.LoadContent(url, lang);
EmailQueue queue = new EmailQueue();
queue.title = pname + " Warning Report";
queue.content = html;
queue.receiver = email;
queue.state = 0;
queue.sender = "*****@*****.**";
EmailQueueService.GetInstance().Save(queue);
}
public async Task <ReturnObject> SendEmail(EmailQueue emailQueue, string apiUrl, string apiKey, string from,
string fromName)
{
string emailBody = CreateEmailBody(emailQueue);
if (emailBody == null)
{
return new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = "Cannot find template"
}
}
;
var values = new NameValueCollection
{
{ "apikey", apiKey },
{ "from", from },
{ "fromName", fromName },
{ "to", emailQueue.ToEmail },
{ "subject", emailQueue.Subject },
{ "bodyHtml", emailBody },
{ "isTransactional", "true" }
};
using (var client = new WebClient())
{
try
{
byte[] apiResponse = client.UploadValues(apiUrl, values);
var result = JsonHelper.DeserializeObject <JObject>(Encoding.UTF8.GetString(apiResponse));
var status = (bool)result["success"] ? Status.STATUS_SUCCESS : Status.STATUS_ERROR;
return(new ReturnObject
{
Status = status,
Message = Encoding.UTF8.GetString(apiResponse)
});
}
catch (Exception ex)
{
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = ex.Message
});
}
}
}
public ActionResult <ReturnObject> GetWalletReport([FromBody] HistoryReport walletReport)
{
try
{
// var _history = _walletBusiness.GetHistory(walletSearch.wallet, 1, 3, new string[] { nameof(BlockchainTransaction.CreatedAt) });
var userModel = (User)RouteData.Values[ParseDataKeyApi.KEY_PASS_DATA_USER_MODEL];
// CommonHelper.GetUnixTimestamp
DateTime dateForButton = DateTime.Now.AddDays(-1 * walletReport.DayTime);
var _searchTime = UnixTimestamp.ToUnixTimestamp(dateForButton);
int numberData;
var history = _walletBusiness.GetHistory(out numberData, userModel.Id, walletReport.NetworkName, -1, -1, null, null, _searchTime);
if (walletReport.Email != null)
{
string fileName = userModel.Id + UnixTimestamp.ToUnixTimestamp(DateTime.Now) + ".csv";
using (StreamWriter sw = new StreamWriter(System.IO.File.Open(AppSettingHelper.GetReportStoreUrl() + fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite)))
{
var csv = new CsvWriter(sw);
csv.WriteRecords(history);
}
EmailQueue email = new EmailQueue()
{
ToEmail = walletReport.Email,
NetworkName = walletReport.NetworkName,
// Amount = addedBalance,
Template = EmailTemplate.Report,
Subject = EmailConfig.SUBJECT_REPORT,
SendFileList = fileName
// Content = networkName + "+" + addedBlance
};
_sendMailBusiness.CreateEmailQueueAsync(email);
}
// Console.WriteLine("csv " + csv);
return(new ReturnObject()
{
Status = Status.STATUS_SUCCESS,
Data = JsonHelper.SerializeObject(history),
Message = numberData.ToString()
});
}
catch (Exception e)
{
return(new ReturnObject()
{
Status = Status.STATUS_ERROR,
Message = e.Message
});
}
// return null;
}
public static async Task <bool> SendAsync(string tenant, EmailViewModel model)
{
var processor = EmailProcessor.GetDefault(tenant);
if (processor == null)
{
return(false);
}
foreach (var contactId in model.Contacts)
{
var contact = await DAL.Contacts.GetContactAsync(tenant, model.UserId, contactId).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(contact?.EmailAddresses) || !contact.EmailAddresses.Split(',').Any())
{
continue;
}
//Only select the first email address
string emailAddress = contact.EmailAddresses.Split(',').Select(x => x.Trim()).FirstOrDefault(IsValidEmail);
if (string.IsNullOrWhiteSpace(emailAddress))
{
continue;
}
string message = model.Message;
message = MessageParser.ParseMessage(message, contact);
var email = new EmailQueue
{
AddedOn = DateTimeOffset.UtcNow,
SendOn = DateTimeOffset.UtcNow,
SendTo = emailAddress,
FromName = processor.Config.FromName,
ReplyTo = processor.Config.FromEmail,
ReplyToName = processor.Config.FromName,
Subject = model.Subject,
Message = message
};
var manager = new MailQueueManager(tenant, email);
await manager.AddAsync().ConfigureAwait(false);
await manager.ProcessQueueAsync(processor).ConfigureAwait(false);
}
return(true);
}
public async Task <CommunicationResponse> Handle(SendEmailRequest Request, CancellationToken cancellationToken)
{
try
{
var Email = new EmailQueue()
{
EmailType = Request.EmailType,
Recepient = Request.Recepient,
Attachment = Request.Attachment,
BCC = Request.BCC,
CC = Request.CC,
Body = Request.Body,
Status = Convert.ToInt16(MessageStatusType.Initialize),
Subject = Request.Subject,
CreatedDate = DateTime.UtcNow
};
_MessageRepository.Add(Email);
Email.InQueueMessage();
_MessageRepository.Update(Email);
IQueryable Result = await _MessageConfiguration.GetAPIConfigurationAsync(1, 2);
foreach (CommunicationProviderList Provider in Result)
{
string Response = await _MessageService.SendEmailAsync(Email.Recepient, Email.Subject, Email.BCC, Email.CC, Email.Body, Provider.SendURL, Provider.UserID, Provider.Password, Convert.ToInt16(Provider.SenderID));
Email.BCC = Response;
CopyClass.CopyObject(Provider, ref _GetDataForParsingAPI);
_GenerateResponse = _WebApiParseResponse.ParseResponseViaRegex(Response, _GetDataForParsingAPI);
if (_GenerateResponse.Status == enTransactionStatus.Success)
{
Email.SentMessage();
_MessageRepository.Update(Email);
return(await Task.FromResult(new CommunicationResponse { ReturnCode = enResponseCode.Success, ReturnMsg = EnResponseMessage.EMailSuccessMessage }));
}
else
{
continue;
}
}
Email.FailMessage();
_MessageRepository.Update(Email);
return(await Task.FromResult(new CommunicationResponse { ReturnCode = enResponseCode.Fail, ReturnMsg = EnResponseMessage.EmailFailMessage }));
}
catch (Exception ex)
{
return(await Task.FromResult(new CommunicationResponse { ReturnCode = enResponseCode.InternalError, ReturnMsg = EnResponseMessage.EmailExceptionMessage }));
}
}
private static string CreateEmailBody(EmailQueue emailQueue)
{
try
{
string body;
var directory = Directory.GetParent(Directory.GetCurrentDirectory()) +
"/MailTemplate/BodyEmail.html";
var builder = new BodyBuilder();
using (var sourceReader = File.OpenText(directory))
{
builder.HtmlBody = sourceReader.ReadToEnd();
}
switch (emailQueue.Template)
{
case 1:
body = string.Format(builder.HtmlBody,
emailQueue.LinkEmail,
"https://i.imgur.com/8idVPQD.png",
"https://i.imgur.com/ooQLCzZ.png",
"Your account is being locked. Verify email to activate your account."
);
break;
case 2:
body = string.Format(builder.HtmlBody,
emailQueue.LinkEmail,
"https://i.imgur.com/8idVPQD.png",
"https://i.imgur.com/ooQLCzZ.png",
"In order to start using your VakaxaId account, you need to confirm your email address."
);
break;
default:
return(null);
}
return(body);
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
}
void IEmailService.DequeueEmail(EmailQueue email, IEnumerable <EmailAttachment> attachments)
{
try
{
_unitOfWork.EmailLogRepository.Add(_mapper.Map <EmailQueue, EmailLog>(email));
if (attachments.Any())
{
_unitOfWork.EmailAttachmentRepository.Delete(attachments);
}
_unitOfWork.EmailQueueRepository.Delete(email);
}
catch (Exception ex)
{
throw ex;
}
}
public void Add()
{
if (this.IsEnabled())
{
EmailQueue queue = new EmailQueue
{
Subject = this.Subject,
SendTo = this.SendTo,
Attachments = this.Attachments,
Message = this.Message,
AddedOn = DateTime.UtcNow
};
Database.MailQueue.AddToQueue(this.Catalog, queue);
}
}
private void SendEmail(string email)
{
Maticsoft.Model.MailConfig model = new Maticsoft.BLL.MailConfig().GetModel();
WebSiteSet set = new WebSiteSet(ApplicationKeyType.Shop);
string webName = set.WebName;
string str2 = string.Format("您对商品【{0}】的咨询有了新的回复，请及时查看！", webName);
EmailQueue queue = new EmailQueue {
EmailTo = model.Mailaddress,
EmailSubject = string.Format("{0}回复通知", webName),
EmailFrom = model.Mailaddress,
EmailBody = str2,
EmailPriority = 0,
IsBodyHtml = false,
NextTryTime = DateTime.Now
};
EmailManage.PushQueue(queue);
}
/// <summary>
/// Transfer editable values from source to destination
/// </summary>
private static void TransferValues(EmailQueue source, EmailQueue destination)
{
destination.Body = source.Body;
destination.Immediate = source.Immediate;
destination.Pending = source.Pending;
destination.Subject = source.Subject;
}
public ActionResult EmailStudents(EmailStudentsViewModel emailStudents, HttpPostedFileBase file)
{
ModelState.Clear();
// get the template type
var templateType = emailStudents.TemplateType;
//if (templateType == null) // It looks like this can be optional. The two mass Email Templates don't look like they are actually used later on
//{
// Message = "Invalid template type, please have the database checked.";
// return RedirectToAction("Index");
//}
if (emailStudents.Ceremony == null)
{
ModelState.AddModelError("Ceremony", "Ceremony is required.");
}
if (string.IsNullOrWhiteSpace(emailStudents.Subject))
{
ModelState.AddModelError("Subject", "Subject is required");
}
if (string.IsNullOrWhiteSpace(emailStudents.Body))
{
ModelState.AddModelError("Body", "Body is required.");
}
if (templateType != null && templateType.Name == StaticValues.Template_ElectronicTicketDistribution && emailStudents.EmailType != EmailStudentsViewModel.MassEmailType.Registered)
{
ModelState.AddModelError("EmailType", "The Student Population must be Registered when using the Electronic Ticket Distribution Template");
}
if (ModelState.IsValid)
{
Attachment attachment = null;
if (file != null)
{
var reader = new BinaryReader(file.InputStream);
var data = reader.ReadBytes(file.ContentLength);
attachment = new Attachment();
attachment.Contents = data;
attachment.ContentType = file.ContentType;
attachment.FileName = file.FileName;
}
// Those registered
if (emailStudents.EmailType == EmailStudentsViewModel.MassEmailType.Registered)
{
foreach (var participation in emailStudents.Ceremony.RegistrationParticipations.Where(a => !a.Cancelled))
{
var bodyText = _letterGenerator.GenerateEmailAllStudents(emailStudents.Ceremony, participation.Registration.Student, emailStudents.Body, templateType, participation.Registration, attachment, Request, Url);
var eq = new EmailQueue(participation.Registration.Student, null, emailStudents.Subject, bodyText, false);
eq.Registration = participation.Registration;
eq.RegistrationParticipation = participation;
if (attachment != null)
{
eq.Attachment = attachment;
}
Repository.OfType<EmailQueue>().EnsurePersistent(eq);
}
}
// Those eligible but not registered
else if (emailStudents.EmailType == EmailStudentsViewModel.MassEmailType.Eligible || emailStudents.EmailType == EmailStudentsViewModel.MassEmailType.AllEligible)
{
var students = emailStudents.Ceremony.Majors.SelectMany(a => a.Students).Where(a => a.TermCode == emailStudents.Ceremony.TermCode);
// filter out students who have registered, only trying to send to students who are eligible and not registered
if (emailStudents.EmailType == EmailStudentsViewModel.MassEmailType.Eligible)
{
students = students.Where(a => !emailStudents.Ceremony.RegistrationParticipations.Select(x => x.Registration.Student).Contains(a)).ToList();
}
foreach (var student in students)
{
var bodyText = _letterGenerator.GenerateEmailAllStudents(emailStudents.Ceremony, student, emailStudents.Body, templateType, null, attachment, Request, Url);
var eq = new EmailQueue(student, null, emailStudents.Subject, bodyText, false);
if (attachment != null)
{
eq.Attachment = attachment;
}
Repository.OfType<EmailQueue>().EnsurePersistent(eq);
}
}
else if(emailStudents.EmailType == EmailStudentsViewModel.MassEmailType.ExtraTicketDenied)
{
var useTemplate = emailStudents.Ceremony.Templates.FirstOrDefault(a => a.TemplateType == templateType && a.IsActive);
foreach (var participation in emailStudents.Ceremony.RegistrationParticipations.Where(a => a.ExtraTicketPetition != null && a.ExtraTicketPetition.IsApproved == false))
{
//var bodyText = _letterGenerator.GenerateEmailAllStudents(emailStudents.Ceremony, participation.Registration.Student, emailStudents.Body, templateType, participation.Registration);
var bodyText = _letterGenerator.GenerateExtraTicketRequestPetitionDecision(participation, useTemplate, attachment, Request, Url, emailStudents.Body);//(emailStudents.Ceremony, participation.Registration.Student, emailStudents.Body, templateType, participation.Registration);
var eq = new EmailQueue(participation.Registration.Student, null, emailStudents.Subject, bodyText, false);
eq.Registration = participation.Registration;
eq.RegistrationParticipation = participation;
if (attachment != null)
{
eq.Attachment = attachment;
}
Repository.OfType<EmailQueue>().EnsurePersistent(eq);
}
}
Message = "Emails have been queued.";
return RedirectToAction("Index");
}
var viewModel = EmailStudentsViewModel.Create(Repository, _ceremonyService, CurrentUser.Identity.Name, _massEmailTemplates);
viewModel.Ceremony = emailStudents.Ceremony;
viewModel.Subject = emailStudents.Subject;
viewModel.Body = emailStudents.Body;
viewModel.TemplateType = emailStudents.TemplateType;
return View(viewModel);
}
public static SendNotificationViewModel Create(IRepository repository, NotificationTrackingViewModel notificationTrackingViewModel, EmailQueue emailQueue = null, string email = null)
{
Check.Require(repository != null, "Repository is required.");
Check.Require(notificationTrackingViewModel != null, "notificationTrackingViewModel is required.");
var viewModel = new SendNotificationViewModel()
{
NotificationTrackingViewModel = notificationTrackingViewModel,
EmailQueue = emailQueue ?? new EmailQueue() { FromAddress = email}
};
return viewModel;
}
public void QueueVisaLetterDecision(VisaLetter visaLetter, Ceremony ceremony, HttpRequestBase request, UrlHelper url)
{
Check.Require(visaLetter != null, "Visa Letter Request Required.");
var template = ceremony.Templates.FirstOrDefault(a => a.TemplateType.Name == StaticValues.Template_VisaLetterDecision && a.IsActive);
if (template != null)
{
var subject = template.Subject;
var body = _letterGenerator.GenerateVisaLetterRequestDecision(visaLetter, template, request, url);
var emailQueue = new EmailQueue(visaLetter.Student, template, subject, body);
_emailQueueRepository.EnsurePersistent(emailQueue);
}
}
public static void SendEmail(MailMessage message)
{
try
{
var context = new SimplicityEntities();
string toEmails = "";
string toNames = "";
foreach (MailAddress address in message.To)
{
toNames += address.DisplayName + ",";
toEmails += address.Address + ",";
}
EmailQueue ta = new EmailQueue{LogTime=DateTime.Now,NumOfTries=1, FromName="Simplicity4Business", FromAddress=FROM_ADDRESS,
ToNames=toNames.Substring(0, toNames.Length - 1), ToAddresses=toEmails.Substring(0, toEmails.Length),
Subject=message.Subject, Body=message.Body, SentTime=null};
}
catch (Exception ex)
{
}
}
public static void AddToQueue(string catalog, EmailQueue queue)
{
Factory.Insert(catalog, queue);
}
public void QueueRegistrationPetitionDecision(RegistrationPetition registrationPetition)
{
Check.Require(registrationPetition != null, "registration is required.");
var template =
registrationPetition.Ceremony.Templates.Where(
a => a.TemplateType.Name == StaticValues.Template_RegistrationPetition_Approved && a.IsActive).
FirstOrDefault();
if (template != null)
{
var subject = template.Subject;
var body = _letterGenerator.GenerateRegistrationPetitionApproved(registrationPetition, template);
var emailQueue = new EmailQueue(registrationPetition.Registration.Student, template, subject, body);
emailQueue.Registration = registrationPetition.Registration;
emailQueue.RegistrationPetition = registrationPetition;
_emailQueueRepository.EnsurePersistent(emailQueue);
}
}
public void QueueMajorMove(Registration registration, RegistrationParticipation participation)
{
Check.Require(registration != null, "registration is required.");
var template = participation.Ceremony.Templates.Where(a => a.TemplateType.Name == StaticValues.Template_MoveMajor && a.IsActive).FirstOrDefault();
if (template != null)
{
var subject = template.Subject;
var body = _letterGenerator.GenerateMoveMajor(participation, template);
var emailQueue = new EmailQueue(registration.Student, template, subject, body, true);
emailQueue.Registration = registration;
emailQueue.RegistrationParticipation = participation;
_emailQueueRepository.EnsurePersistent(emailQueue);
}
}
/// <summary>
/// Queue's up each individual email for each registration participation
/// </summary>
/// <param name="registration"></param>
public void QueueRegistrationConfirmation(Registration registration, string additionalMessage = null)
{
Check.Require(registration != null, "Registration is required.");
// fix for task 237
foreach (var a in registration.RegistrationParticipations)
{
var template = a.Cancelled ?
a.Ceremony.Templates.FirstOrDefault(b => b.TemplateType.Name == StaticValues.Template_Cancellation && b.IsActive)
:
a.Ceremony.Templates.FirstOrDefault(b => b.TemplateType.Name == StaticValues.Template_RegistrationConfirmation && b.IsActive);
if (template != null)
{
var subject = template.Subject;
var body = _letterGenerator.GenerateRegistrationConfirmation(a, template);
if (!string.IsNullOrEmpty(additionalMessage))
{
body += additionalMessage;
}
var emailQueue = new EmailQueue(a.Registration.Student, template, subject, body, true);
emailQueue.Registration = registration;
emailQueue.RegistrationParticipation = a;
_emailQueueRepository.EnsurePersistent(emailQueue);
}
}
}
public void QueueRegistrationPetition(Registration registration)
{
Check.Require(registration != null, "registration is required.");
#region Old Code to remove
//var template = registration.RegistrationPetitions.First().Ceremony.Templates.Where(b => b.TemplateType.Name == StaticValues.Template_RegistrationPetition
// && b.IsActive).FirstOrDefault();
//Check.Require(template != null, "No template is available.");
//foreach (var a in registration.RegistrationPetitions)
//{
// var subject = template.Subject;
// var body = _letterGenerator.GenerateRegistrationPetitionConfirmation(a, template);
// var emailQueue = new EmailQueue(a.Registration.Student, template, subject, body, false);
// emailQueue.Registration = registration;
// emailQueue.RegistrationPetition = a;
// _emailQueueRepository.EnsurePersistent(emailQueue);
//}
#endregion Old Code to remove
// fix for problem similar to task 237
foreach (var a in registration.RegistrationPetitions)
{
var template =
a.Ceremony.Templates.Where(b => b.TemplateType.Name == StaticValues.Template_RegistrationPetition
&& b.IsActive).FirstOrDefault();
if(template != null)
{
var subject = template.Subject;
var body = _letterGenerator.GenerateRegistrationPetitionConfirmation(a, template);
var emailQueue = new EmailQueue(a.Registration.Student, template, subject, body, false);
emailQueue.Registration = registration;
emailQueue.RegistrationPetition = a;
_emailQueueRepository.EnsurePersistent(emailQueue);
}
}
}
public static EmailQueue EmailQueue(int? counter)
{
var rtValue = new EmailQueue();
rtValue.Text = "Text" + counter.Extra();
rtValue.Order = new Order();
rtValue.NotificationType = Purchasing.Core.Domain.EmailPreferences.NotificationTypes.PerEvent;
return rtValue;
}
public void QueueExtraTicketPetitionDecision(RegistrationParticipation participation)
{
Check.Require(participation != null, "participation is required.");
var template = participation.Ceremony.Templates.Where(a => a.TemplateType.Name == StaticValues.Template_TicketPetition_Decision && a.IsActive).FirstOrDefault();
if (template != null)
{
var subject = template.Subject;
var body = _letterGenerator.GenerateExtraTicketRequestPetitionDecision(participation, template, null, null, null);
var emailQueue = new EmailQueue(participation.Registration.Student, template, subject, body, false);
emailQueue.Registration = participation.Registration;
emailQueue.RegistrationParticipation = participation;
emailQueue.ExtraTicketPetition = participation.ExtraTicketPetition;
_emailQueueRepository.EnsurePersistent(emailQueue);
}
}
public ActionResult Edit(int id, int callForProposalId, EmailQueue emailqueue)
{
var callforproposal = Repository.OfType<CallForProposal>().GetNullableById(callForProposalId);
if (callforproposal == null)
{
return this.RedirectToAction<CallForProposalController>(a => a.Index(null, null, null));
}
if (!_accessService.HasAccess(null, callForProposalId, CurrentUser.Identity.Name))
{
Message = string.Format(StaticValues.Message_NoAccess, "that");
return this.RedirectToAction<HomeController>(a => a.Index());
}
var emailqueueToEdit = _emailqueueRepository.GetNullableById(id);
if (emailqueueToEdit == null)
{
Message = string.Format(StaticValues.Message_NotFound, "Email");
return this.RedirectToAction(a => a.Index(callForProposalId));
}
if (!_accessService.HasSameId(null, callforproposal, null, emailqueueToEdit.CallForProposal.Id))
{
Message = string.Format(StaticValues.Message_NoAccess, "that");
return this.RedirectToAction<HomeController>(a => a.Index());
}
var previousPendingState = emailqueueToEdit.Pending;
TransferValues(emailqueue, emailqueueToEdit);
emailqueueToEdit.TransferValidationMessagesTo(ModelState);
if (!emailqueue.Pending && !previousPendingState)
{
ModelState.AddModelError("Pending", "Can't edit an email that was already sent");
}
if (ModelState.IsValid)
{
_emailqueueRepository.EnsurePersistent(emailqueueToEdit);
Message = string.Format(StaticValues.Message_EditedSuccessfully, "EmailQueue");
return this.RedirectToAction(a => a.Index(callForProposalId));
}
else
{
var viewModel = EmailQueueViewModel.Create(Repository, callforproposal);
viewModel.EmailQueue = emailqueueToEdit;
return View(viewModel);
}
}
