public void ResendEmailWithErrorSendingStatus(DateTime date)
{
using (var uowLocal = UnitOfWorkFactory.CreateWithoutRoot())
{
var configuration = uowLocal.GetAll <InstanceMailingConfiguration>().FirstOrDefault();
var dateCriterion = Projections.SqlFunction(
new SQLFunctionTemplate(
NHibernateUtil.Date,
"Date(?1)"
),
NHibernateUtil.Date,
Projections.Property <StoredEmail>(x => x.SendDate)
);
ICriterion dateResctict = Restrictions.Eq(dateCriterion, date.Date);
ICriterion dateResctictGe = Restrictions.Ge(dateCriterion, date.Date);
#region OrderDocument
OrderDocumentEmail orderDocumentEmailAlias = null;
OrderDocumentEmail orderDocumentEmailInnerAlias = null;
OrderDocument orderDocumentAlias = null;
OrderDocument orderDocumentAliasInner = null;
var resendedOrderDocumentQuery = QueryOver.Of <OrderDocumentEmail>(() => orderDocumentEmailInnerAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(x => x.State != StoredEmailStates.SendingError)
.And(dateResctictGe)
.JoinAlias(() => orderDocumentEmailInnerAlias.OrderDocument, () => orderDocumentAliasInner)
.Where(() => orderDocumentAliasInner.Order.Id == orderDocumentAlias.Order.Id)
.Select(o => o.Id);
var errorSendedOrderDocumentQuery = uowLocal.Session.QueryOver <OrderDocumentEmail>(() => orderDocumentEmailAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(se => se.State == StoredEmailStates.SendingError)
.And(dateResctict)
.JoinAlias(() => orderDocumentEmailAlias.OrderDocument, () => orderDocumentAlias)
.WithSubquery.WhereNotExists(resendedOrderDocumentQuery)
.Future();
#endregion
#region Order OrderWithoutShipmentForDebt
OrderWithoutShipmentForDebtEmail orderWithoutShipmentForDebtEmailAlias = null;
OrderWithoutShipmentForDebtEmail orderWithoutShipmentForDebtEmailInnerAlias = null;
OrderWithoutShipmentForDebt orderWithoutShipmentForDebtAlias = null;
OrderWithoutShipmentForDebt orderWithoutShipmentForDebtAliasInner = null;
var resendedOrderWithoutShipmentForDebtQuery = QueryOver.Of <OrderWithoutShipmentForDebtEmail>(() => orderWithoutShipmentForDebtEmailInnerAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(x => x.State != StoredEmailStates.SendingError)
.And(dateResctictGe)
.JoinAlias(() => orderWithoutShipmentForDebtEmailInnerAlias.OrderWithoutShipmentForDebt, () => orderWithoutShipmentForDebtAliasInner)
.Where(() => orderWithoutShipmentForDebtAliasInner.Id == orderWithoutShipmentForDebtAlias.Id)
.Select(o => o.Id);
var errorSendedOrderWithoutShipmentForDebtEmailQuery = uowLocal.Session
.QueryOver <OrderWithoutShipmentForDebtEmail>(() => orderWithoutShipmentForDebtEmailAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(se => se.State == StoredEmailStates.SendingError)
.And(dateResctict)
.JoinAlias(() => orderWithoutShipmentForDebtEmailAlias.OrderWithoutShipmentForDebt, () => orderWithoutShipmentForDebtAlias)
.WithSubquery.WhereNotExists(resendedOrderWithoutShipmentForDebtQuery)
.Future();
#endregion
#region Order OrderWithoutShipmentForAdvancePayment
OrderWithoutShipmentForAdvancePaymentEmail orderWithoutShipmentForAdvancePaymentEmailAlias = null;
OrderWithoutShipmentForAdvancePaymentEmail orderWithoutShipmentForAdvancePaymentEmailInnerAlias = null;
OrderWithoutShipmentForAdvancePayment orderWithoutShipmentForAdvancePaymentAlias = null;
OrderWithoutShipmentForAdvancePayment orderWithoutShipmentForAdvancePaymentAliasInner = null;
var resendedOrderWithoutShipmentForAdvancePaymentQuery = QueryOver.Of <OrderWithoutShipmentForAdvancePaymentEmail>(() => orderWithoutShipmentForAdvancePaymentEmailInnerAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(x => x.State != StoredEmailStates.SendingError)
.And(dateResctictGe)
.JoinAlias(() => orderWithoutShipmentForAdvancePaymentEmailInnerAlias.OrderWithoutShipmentForAdvancePayment, () => orderWithoutShipmentForAdvancePaymentAliasInner)
.Where(() => orderWithoutShipmentForAdvancePaymentAliasInner.Id == orderWithoutShipmentForAdvancePaymentAlias.Id)
.Select(o => o.Id);
var errorSendedOrderWithoutShipmentForAdvancePaymentEmailQuery = uowLocal.Session
.QueryOver <OrderWithoutShipmentForAdvancePaymentEmail>(() => orderWithoutShipmentForAdvancePaymentEmailAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(se => se.State == StoredEmailStates.SendingError)
.And(dateResctict)
.JoinAlias(() => orderWithoutShipmentForAdvancePaymentEmailAlias.OrderWithoutShipmentForAdvancePayment, () => orderWithoutShipmentForAdvancePaymentAlias)
.WithSubquery.WhereNotExists(resendedOrderWithoutShipmentForAdvancePaymentQuery)
.Future();
#endregion
#region Order OrderWithoutShipmentForPayment
OrderWithoutShipmentForPaymentEmail orderWithoutShipmentForPaymentEmailAlias = null;
OrderWithoutShipmentForPaymentEmail orderWithoutShipmentForPaymentEmailInnerAlias = null;
OrderWithoutShipmentForPayment orderWithoutShipmentForPaymentAlias = null;
OrderWithoutShipmentForPayment orderWithoutShipmentForPaymentAliasInner = null;
var resendedOrderWithoutShipmentForPaymentQuery = QueryOver.Of <OrderWithoutShipmentForPaymentEmail>(() => orderWithoutShipmentForPaymentEmailInnerAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(x => x.State != StoredEmailStates.SendingError)
.And(dateResctictGe)
.JoinAlias(() => orderWithoutShipmentForPaymentEmailInnerAlias.OrderWithoutShipmentForPayment, () => orderWithoutShipmentForPaymentAliasInner)
.Where(() => orderWithoutShipmentForPaymentAliasInner.Id == orderWithoutShipmentForPaymentAlias.Id)
.Select(o => o.Id);
var errorSendedOrderWithoutShipmentForPaymentEmailQuery = uowLocal.Session
.QueryOver <OrderWithoutShipmentForPaymentEmail>(() => orderWithoutShipmentForPaymentEmailAlias)
.JoinQueryOver(ode => ode.StoredEmail)
.Where(se => se.State == StoredEmailStates.SendingError)
.And(dateResctict)
.JoinAlias(() => orderWithoutShipmentForPaymentEmailAlias.OrderWithoutShipmentForPayment, () => orderWithoutShipmentForPaymentAlias)
.WithSubquery.WhereNotExists(resendedOrderWithoutShipmentForPaymentQuery)
.Future();
#endregion
var errorSendedCounterpartyEmails = errorSendedOrderDocumentQuery
.Union <CounterpartyEmail>(errorSendedOrderWithoutShipmentForDebtEmailQuery)
.Union <CounterpartyEmail>(errorSendedOrderWithoutShipmentForAdvancePaymentEmailQuery)
.Union <CounterpartyEmail>(errorSendedOrderWithoutShipmentForPaymentEmailQuery);
var errorSendedCounterpartyEmailsList = errorSendedCounterpartyEmails.ToList();
foreach (var sendedEmail in errorSendedCounterpartyEmailsList)
{
try
{
using (var unitOfWork = UnitOfWorkFactory.CreateWithoutRoot("StoredEmail"))
{
var storedEmail = new StoredEmail
{
State = StoredEmailStates.PreparingToSend,
Author = sendedEmail.StoredEmail.Author,
ManualSending = true,
SendDate = DateTime.Now,
StateChangeDate = DateTime.Now,
Subject = sendedEmail.StoredEmail.Subject,
RecipientAddress = sendedEmail.StoredEmail.RecipientAddress
};
unitOfWork.Save(storedEmail);
switch (sendedEmail.Type)
{
case CounterpartyEmailType.OrderDocument:
var orderDocumentEmail = new OrderDocumentEmail
{
StoredEmail = storedEmail,
Counterparty = sendedEmail.Counterparty,
OrderDocument = ((OrderDocumentEmail)sendedEmail).OrderDocument
};
unitOfWork.Save(orderDocumentEmail);
break;
case CounterpartyEmailType.OrderWithoutShipmentForDebt:
var orderWithoutShipmentForDebtEmail = new OrderWithoutShipmentForDebtEmail()
{
StoredEmail = storedEmail,
Counterparty = sendedEmail.Counterparty,
OrderWithoutShipmentForDebt = (OrderWithoutShipmentForDebt)sendedEmail.EmailableDocument
};
unitOfWork.Save(orderWithoutShipmentForDebtEmail);
break;
case CounterpartyEmailType.OrderWithoutShipmentForAdvancePayment:
var orderWithoutShipmentForAdvancePaymentEmail = new OrderWithoutShipmentForAdvancePaymentEmail()
{
StoredEmail = storedEmail,
Counterparty = sendedEmail.Counterparty,
OrderWithoutShipmentForAdvancePayment = (OrderWithoutShipmentForAdvancePayment)sendedEmail.EmailableDocument
};
unitOfWork.Save(orderWithoutShipmentForAdvancePaymentEmail);
break;
case CounterpartyEmailType.OrderWithoutShipmentForPayment:
var orderWithoutShipmentForPaymentEmail = new OrderWithoutShipmentForPaymentEmail()
{
StoredEmail = storedEmail,
Counterparty = sendedEmail.Counterparty,
OrderWithoutShipmentForPayment = (OrderWithoutShipmentForPayment)sendedEmail.EmailableDocument
};
unitOfWork.Save(orderWithoutShipmentForPaymentEmail);
break;
}
unitOfWork.Commit();
}
}
catch (Exception e)
{
Console.WriteLine($"Ошибка отправки { sendedEmail.Id } : { e.Message }");
}
}
}
}
public void ResendEmailWithErrorSendingStatus(DateTime date)
{
IEmailService service = EmailServiceSetting.GetEmailService();
if (service == null)
{
return;
}
IList <StoredEmail> errorSendedEmails;
using (var uowLocal = UnitOfWorkFactory.CreateWithoutRoot()) {
StoredEmail unsendedEmailAlias = null;
StoredEmail alreadyResendedEmailAlias = null;
var dateCriterion = Projections.SqlFunction(
new SQLFunctionTemplate(
NHibernateUtil.Date,
"Date(?1)"
),
NHibernateUtil.Date,
Projections.Property <StoredEmail>(x => x.SendDate)
);
ICriterion dateResctict = Restrictions.Eq(dateCriterion, date.Date);
ICriterion dateResctictGe = Restrictions.Ge(dateCriterion, date.Date);
var resendedQuery = QueryOver.Of <StoredEmail>()
.Where(Restrictions.EqProperty(Projections.Property <StoredEmail>(x => x.Order.Id), Projections.Property(() => unsendedEmailAlias.Order.Id)))
.Where(x => x.State != StoredEmailStates.SendingError)
.Where(dateResctictGe)
.Select(Projections.Count(Projections.Id()));
errorSendedEmails = uowLocal.Session.QueryOver <StoredEmail>(() => unsendedEmailAlias)
.Where(x => x.State == StoredEmailStates.SendingError)
.Where(dateResctict)
.WithSubquery.WhereValue(0).Eq(resendedQuery)
.List();
foreach (var sendedEmail in errorSendedEmails)
{
var billDocument = sendedEmail.Order.OrderDocuments.FirstOrDefault(y => y.Type == OrderDocumentType.Bill) as BillDocument;
if (billDocument == null)
{
continue;
}
billDocument.HideSignature = false;
ReportInfo ri = billDocument.GetReportInfo();
var billTemplate = billDocument.GetEmailTemplate();
Email email = new Email {
Title = string.Format("{0} {1}", billTemplate.Title, billDocument.Title),
Text = billTemplate.Text,
HtmlText = billTemplate.TextHtml,
Recipient = new EmailContact("", sendedEmail.RecipientAddress),
Sender = new EmailContact("vodovoz-spb.ru", ParametersProvider.Instance.GetParameterValue("email_for_email_delivery")),
Order = billDocument.Order.Id,
OrderDocumentType = OrderDocumentType.Bill
};
foreach (var item in billTemplate.Attachments)
{
email.AddInlinedAttachment(item.Key, item.Value.MIMEType, item.Value.FileName, item.Value.Base64Content);
}
using (MemoryStream stream = ReportExporter.ExportToMemoryStream(ri.GetReportUri(), ri.GetParametersString(), ri.ConnectionString, OutputPresentationType.PDF, true)) {
string billDate = billDocument.DocumentDate.HasValue ? "_" + billDocument.DocumentDate.Value.ToString("ddMMyyyy") : "";
email.AddAttachment($"Bill_{billDocument.Order.Id}{billDate}.pdf", stream);
}
email.AuthorId = sendedEmail.Author.Id;
email.ManualSending = sendedEmail.ManualSending ?? false;
service.SendEmail(email);
}
}
}
public bool CanSendByTimeout(string address, int orderId, OrderDocumentType type)
{
// Время в минутах, по истечению которых будет возможна повторная отправка
double timeLimit = 10;
using (var uow = UnitOfWorkFactory.CreateWithoutRoot($"[ES]Получение возможна ли повторная отправка"))
{
if (type == OrderDocumentType.Bill || type == OrderDocumentType.SpecialBill)
{
StoredEmail storedEmailAlias = null;
OrderDocument orderDocumentAlias = null;
var lastSendTime = uow.Session.QueryOver <OrderDocumentEmail>()
.JoinAlias(ode => ode.OrderDocument, () => orderDocumentAlias)
.Where(() => orderDocumentAlias.Order.Id == orderId)
.JoinAlias(ode => ode.StoredEmail, () => storedEmailAlias)
.Where(() => storedEmailAlias.RecipientAddress == address)
.And(() => storedEmailAlias.State != StoredEmailStates.SendingError)
.Select(Projections.Max(() => storedEmailAlias.SendDate))
.SingleOrDefault <DateTime>();
if (lastSendTime != default(DateTime))
{
return(DateTime.Now.Subtract(lastSendTime).TotalMinutes > timeLimit);
}
}
else if (type == OrderDocumentType.BillWSForDebt)
{
StoredEmail storedEmailAlias = null;
var lastSendTime = uow.Session.QueryOver <OrderWithoutShipmentForDebtEmail>()
.Where(ode => ode.OrderWithoutShipmentForDebt.Id == orderId)
.JoinAlias(ode => ode.StoredEmail, () => storedEmailAlias)
.Where(() => storedEmailAlias.RecipientAddress == address)
.And(() => storedEmailAlias.State != StoredEmailStates.SendingError)
.Select(Projections.Max(() => storedEmailAlias.SendDate))
.SingleOrDefault <DateTime>();
if (lastSendTime != default(DateTime))
{
return(DateTime.Now.Subtract(lastSendTime).TotalMinutes > timeLimit);
}
}
else if (type == OrderDocumentType.BillWSForAdvancePayment)
{
StoredEmail storedEmailAlias = null;
var lastSendTime = uow.Session.QueryOver <OrderWithoutShipmentForAdvancePaymentEmail>()
.Where(ode => ode.OrderWithoutShipmentForAdvancePayment.Id == orderId)
.JoinAlias(ode => ode.StoredEmail, () => storedEmailAlias)
.Where(() => storedEmailAlias.RecipientAddress == address)
.And(() => storedEmailAlias.State != StoredEmailStates.SendingError)
.Select(Projections.Max(() => storedEmailAlias.SendDate))
.SingleOrDefault <DateTime>();
if (lastSendTime != default(DateTime))
{
return(DateTime.Now.Subtract(lastSendTime).TotalMinutes > timeLimit);
}
}
else if (type == OrderDocumentType.BillWSForPayment)
{
StoredEmail storedEmailAlias = null;
var lastSendTime = uow.Session.QueryOver <OrderWithoutShipmentForPaymentEmail>()
.Where(ode => ode.OrderWithoutShipmentForPayment.Id == orderId)
.JoinAlias(ode => ode.StoredEmail, () => storedEmailAlias)
.Where(() => storedEmailAlias.RecipientAddress == address)
.And(() => storedEmailAlias.State != StoredEmailStates.SendingError)
.Select(Projections.Max(() => storedEmailAlias.SendDate))
.SingleOrDefault <DateTime>();
if (lastSendTime != default(DateTime))
{
return(DateTime.Now.Subtract(lastSendTime).TotalMinutes > timeLimit);
}
}
}
return(true);
}
