public Organization GetOrganizationForOrderWithoutShipment(IUnitOfWork uow, OrderWithoutShipmentForAdvancePayment order)
{
if (uow == null)
{
throw new ArgumentNullException(nameof(uow));
}
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
var organizationId = IsOnlineStoreOrderWithoutShipment(order)
? _organizationParametersProvider.VodovozSouthOrganizationId
: _organizationParametersProvider.VodovozOrganizationId;
return(uow.GetById <Organization>(organizationId));
}
private IQueryOver <OrderWithoutShipmentForAdvancePayment> GetOrdersWithoutShipmentForAdvancePaymentQuery(IUnitOfWork uow)
{
RetailOrderJournalNode resultAlias = null;
OrderWithoutShipmentForAdvancePayment orderWSAPAlias = null;
OrderWithoutShipmentForAdvancePaymentItem orderWSAPItemAlias = null;
Counterparty counterpartyAlias = null;
Employee authorAlias = null;
Nomenclature nomenclatureAlias = null;
var query = uow.Session.QueryOver(() => orderWSAPAlias)
.Left.JoinAlias(o => o.Author, () => authorAlias);
if (FilterViewModel.ViewTypes != ViewTypes.OrderWSFAP && FilterViewModel.ViewTypes != ViewTypes.All ||
FilterViewModel.RestrictStatus != null && FilterViewModel.RestrictStatus != OrderStatus.Closed ||
FilterViewModel.RestrictPaymentType != null ||
FilterViewModel.DeliveryPoint != null ||
FilterViewModel.RestrictOnlyService != null ||
FilterViewModel.RestrictOnlySelfDelivery != null ||
FilterViewModel.RestrictLessThreeHours == true ||
FilterViewModel.OrderPaymentStatus != null ||
FilterViewModel.Organisation != null ||
FilterViewModel.PaymentByCardFrom != null)
{
query.Where(o => o.Id == -1);
}
if (FilterViewModel != null && FilterViewModel.IsForRetail != null)
{
query.JoinEntityAlias(
() => counterpartyAlias,
() => counterpartyAlias.Id == orderWSAPAlias.Client.Id &&
counterpartyAlias.IsForRetail == FilterViewModel.IsForRetail,
NHibernate.SqlCommand.JoinType.InnerJoin);
}
else
{
query.Left.JoinAlias(o => o.Client, () => counterpartyAlias);
}
if (FilterViewModel.RestrictStartDate != null)
{
query.Where(o => o.CreateDate >= FilterViewModel.RestrictStartDate);
}
if (FilterViewModel.RestrictEndDate != null)
{
query.Where(o => o.CreateDate <= FilterViewModel.RestrictEndDate.Value.AddDays(1).AddTicks(-1));
}
if (FilterViewModel.RestrictCounterparty != null)
{
query.Where(o => o.Client == FilterViewModel.RestrictCounterparty);
}
var bottleCountSubquery = QueryOver.Of(() => orderWSAPItemAlias)
.Where(() => orderWSAPAlias.Id == orderWSAPItemAlias.OrderWithoutDeliveryForAdvancePayment.Id)
.JoinAlias(() => orderWSAPItemAlias.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Category == NomenclatureCategory.water && nomenclatureAlias.TareVolume == TareVolume.Vol19L)
.Select(Projections.Sum(() => orderWSAPItemAlias.Count));
var orderSumSubquery = QueryOver.Of(() => orderWSAPItemAlias)
.Where(() => orderWSAPItemAlias.OrderWithoutDeliveryForAdvancePayment.Id == orderWSAPAlias.Id)
.Select(Projections.Sum(
Projections.SqlFunction(new SQLFunctionTemplate(NHibernateUtil.Decimal, "(?1 * ?2 - ?3)"),
NHibernateUtil.Decimal, new IProjection[] {
Projections.Property(() => orderWSAPItemAlias.Price),
Projections.Property(() => orderWSAPItemAlias.Count),
Projections.Property(() => orderWSAPItemAlias.DiscountMoney)
})
)
);
query.Where(GetSearchCriterion(
() => orderWSAPAlias.Id,
() => counterpartyAlias.Name,
() => authorAlias.LastName
));
var resultQuery = query
.SelectList(list => list
.Select(() => orderWSAPAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => orderWSAPAlias.CreateDate).WithAlias(() => resultAlias.CreateDate)
.Select(() => orderWSAPAlias.CreateDate).WithAlias(() => resultAlias.Date)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorLastName)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => counterpartyAlias.Name).WithAlias(() => resultAlias.Counterparty)
.SelectSubQuery(orderSumSubquery).WithAlias(() => resultAlias.Sum)
.SelectSubQuery(bottleCountSubquery).WithAlias(() => resultAlias.BottleAmount)
)
.OrderBy(x => x.CreateDate).Desc
.SetTimeout(60)
.TransformUsing(Transformers.AliasToBean <RetailOrderJournalNode <OrderWithoutShipmentForAdvancePayment> >());
return(resultQuery);
}
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 }");
}
}
}
}
private bool IsOnlineStoreOrderWithoutShipment(OrderWithoutShipmentForAdvancePayment order)
{
return(order.OrderWithoutDeliveryForAdvancePaymentItems.Any(x =>
x.Nomenclature.OnlineStore != null && x.Nomenclature.OnlineStore.Id != _orderParametersProvider.OldInternalOnlineStoreId));
}
