/// <summary>
/// Список последних заказов для точки доставки.
/// </summary>
/// <returns>Список последних заказов для точки доставки.</returns>
/// <param name="UoW">IUnitOfWork</param>
/// <param name="deliveryPoint">Точка доставки.</param>
/// <param name="count">Требуемое количество последних заказов.</param>
public IList <VodovozOrder> GetLatestOrdersForDeliveryPoint(IUnitOfWork UoW, DeliveryPoint deliveryPoint, int?count = null)
{
VodovozOrder orderAlias = null;
var queryResult = UoW.Session.QueryOver(() => orderAlias)
.Where(() => orderAlias.DeliveryPoint.Id == deliveryPoint.Id)
.OrderBy(() => orderAlias.Id).Desc;
if (count != null)
{
return(queryResult.Take(count.Value).List());
}
else
{
return(queryResult.List());
}
}
public AddressDto ExtractAPIAddressFromDeliveryPoint(DeliveryPoint deliveryPoint)
{
return(new AddressDto()
{
City = deliveryPoint.City,
Street = deliveryPoint.Street,
Building = deliveryPoint.Building + deliveryPoint.Letter,
Entrance = deliveryPoint.Entrance,
Floor = deliveryPoint.Floor,
Apartment = deliveryPoint.Room,
DeliveryPointCategory = deliveryPoint.Category?.Name,
EntranceType = deliveryPoint.EntranceType.ToString(),
RoomType = deliveryPoint.RoomType.ToString(),
Latitude = deliveryPoint.Latitude ?? 0,
Longitude = deliveryPoint.Longitude ?? 0
});
}
/// <inheritdoc />
public async Task <Guid> Create(DeliveryPointInfo model)
{
DeliveryPoint point = new DeliveryPoint(model.Name, model.City, model.Street, model.Building, model.Corpus, model.Office, model.Phone);
foreach (var workTime in model.WorksSchedule)
{
workTime.DeliveryPointGuid = point.Guid;
}
await _dbContext.DeliveryPoints.AddAsync(point);
await _dbContext.WorkTimes.AddRangeAsync(model.WorksSchedule);
await _dbContext.SaveChangesAsync();
return(point.Guid);
}
private DeliveryPoint GenerateCheckpoint()
{
DeliveryPoint x = new DeliveryPoint();
Transform rootPoint = spawnPoints[Random.Range(0, spawnPoints.Count - 1)];
spawnPoints.Remove(rootPoint);
Vector3 globalPoint = rootPoint.transform.position;
x.startPoint = new Vector3(globalPoint.x, globalPoint.y, globalPoint.z);
x.deliveryPoint = GenerateDeliveryPoint(x.startPoint);
x.amountOfMoney = GenerateMoney(x.startPoint, x.deliveryPoint);
x.quantityOfSeconds = GenerateSeconds(x.startPoint, x.deliveryPoint);
x.ringObject = GameObject.Instantiate(startPointModel, rootPoint);
x.ringObject.transform.position = x.startPoint;
x.ringObject.AddComponent <CheckpointCollider>().self = x;
return(x);
}
/// <summary>
/// Возврат словаря, у которого ключ это <see cref="PromotionalSet.Id"/>,
/// а значение - массив с <see cref="VodovozOrder.Id"/>, для всех точек доставок
/// похожих по полям <see cref="DeliveryPoint.City"/>,
/// <see cref="DeliveryPoint.Street"/>, <see cref="DeliveryPoint.Building"/>,
/// <see cref="DeliveryPoint.Room"/>
/// </summary>
/// <returns>Словарь</returns>
/// <param name="uow">Unit Of Work</param>
/// <param name="currOrder">Заказ, из которого берётся точка доставки</param>
/// <param name="ignoreCurrentOrder">Если <c>true</c>, то в выборке будет
/// игнорироваться заказ передаваемы в качестве параметра <paramref name="currOrder"/></param>
public Dictionary <int, int[]> GetPromotionalSetsAndCorrespondingOrdersForDeliveryPoint(IUnitOfWork uow, VodovozOrder currOrder, bool ignoreCurrentOrder = false)
{
if (GetPromotionalSetsAndCorrespondingOrdersForDeliveryPointTestGap != null)
{
return(GetPromotionalSetsAndCorrespondingOrdersForDeliveryPointTestGap(uow, currOrder, ignoreCurrentOrder));
}
VodovozOrder ordersAlias = null;
PromotionalSet promotionalSetAlias = null;
DeliveryPoint deliveryPointAlias = null;
var dp = currOrder.DeliveryPoint;
var oId = !ignoreCurrentOrder ? -1 : currOrder.Id;
var acceptableStatuses = new[] {
OrderStatus.Accepted,
OrderStatus.InTravelList,
OrderStatus.WaitForPayment,
OrderStatus.OnLoading,
OrderStatus.OnTheWay,
OrderStatus.Shipped,
OrderStatus.UnloadingOnStock,
OrderStatus.Closed
};
var subQuerySimilarDP = QueryOver.Of(() => deliveryPointAlias)
.Where(p => p.City == dp.City)
.Where(p => p.Street == dp.Street)
.Where(p => p.Building == dp.Building)
.Where(p => p.Room == dp.Room)
.Select(Projections.Property(() => deliveryPointAlias.Id))
;
var result = uow.Session.QueryOver(() => promotionalSetAlias)
.JoinAlias(() => promotionalSetAlias.Orders, () => ordersAlias)
.JoinAlias(() => ordersAlias.DeliveryPoint, () => deliveryPointAlias)
.Where(() => ordersAlias.Id != oId)
.Where(() => ordersAlias.OrderStatus.IsIn(acceptableStatuses))
.WithSubquery.WhereProperty(() => deliveryPointAlias.Id).In(subQuerySimilarDP)
.SelectList(list => list.Select(() => promotionalSetAlias.Id)
.Select(() => ordersAlias.Id))
.List <object[]>()
.GroupBy(x => (int)x[0])
.ToDictionary(g => g.Key, g => g.Select(x => (int)x[1]).ToArray());
return(result);
}
public IEnumerable <CallTask> GetActiveTaskByDeliveryPoint(IUnitOfWork UoW, DeliveryPoint deliveryPoint, CallTaskStatus?taskStatus = null, int?limit = null)
{
CallTask callTaskAlias = null;
DeliveryPoint deliveryPointAlias = null;
var tasks = UoW.Session.QueryOver(() => callTaskAlias)
.JoinAlias(x => x.DeliveryPoint, () => deliveryPointAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.Where(() => deliveryPointAlias.Id == deliveryPoint.Id)
.And(x => !x.IsTaskComplete)
.And(x => taskStatus == null || x.TaskState == taskStatus.Value);
if (limit.HasValue)
{
tasks.Take(limit.Value);
}
return(tasks.List());
}
public IEnumerable <string> GetAddressesWithFixedPrices(int counterpartyId)
{
IEnumerable <string> result;
using (var uow = UnitOfWorkFactory.CreateWithoutRoot($"Получение списка адресов имеющих фиксированную цену"))
{
DeliveryPoint deliveryPointAlias = null;
NomenclatureFixedPrice fixedPriceAlias = null;
result = uow.Session.QueryOver <NomenclatureFixedPrice>(() => fixedPriceAlias)
.Inner.JoinAlias(() => fixedPriceAlias.DeliveryPoint, () => deliveryPointAlias)
.Where(() => deliveryPointAlias.Counterparty.Id == counterpartyId)
.SelectList(list => list.SelectGroup(() => deliveryPointAlias.ShortAddress))
.List <string>();
}
return(result);
}
private static string FormatAddress1(DeliveryPoint deliveryPoint)
{
return(string.Format("{0}{1}{2}{3}{4}",
!string.IsNullOrWhiteSpace(deliveryPoint.OrganisationName)
? deliveryPoint.OrganisationName + "|"
: string.Empty,
!string.IsNullOrWhiteSpace(deliveryPoint.DepartmentName)
? deliveryPoint.DepartmentName + "|"
: string.Empty,
!string.IsNullOrWhiteSpace(deliveryPoint.POBoxNumber) ? deliveryPoint.POBoxNumber + "|" : string.Empty,
!string.IsNullOrWhiteSpace(deliveryPoint.SubBuildingName)
? deliveryPoint.SubBuildingName + "|"
: string.Empty,
(!string.IsNullOrWhiteSpace(deliveryPoint.BuildingName) && !(ValidateNumeric(deliveryPoint.BuildingName)))
? deliveryPoint.BuildingName + "|"
: string.Empty
));
}
public static IEnumerable <OrderCountResultNode> OrdersCountByDistrict(IUnitOfWork uow, DateTime date, int minBottlesInOrder)
{
OrderCountResultNode resultAlias = null;
Domain.Orders.Order orderAlias = null;
OrderItem orderItemsAlias = null;
DeliveryPoint deliveryPointAlias = null;
var districtSubquery = QueryOver.Of <District>()
.Where(
Restrictions.Eq(
Projections.SqlFunction(
new SQLFunctionTemplate(
NHibernateUtil.Boolean,
"ST_WITHIN(PointFromText(CONCAT('POINT(', ?1 ,' ', ?2,')')), ?3)"
),
NHibernateUtil.Boolean,
Projections.Property(() => deliveryPointAlias.Latitude),
Projections.Property(() => deliveryPointAlias.Longitude),
Projections.Property <District>(x => x.DistrictBorder)
),
true
)
)
.Select(x => x.Id)
.Take(1);
return(uow.Session.QueryOver(() => orderAlias)
.Where(x => x.DeliveryDate == date)
.Where(x => x.OrderStatus == OrderStatus.Accepted || x.OrderStatus == OrderStatus.InTravelList)
.JoinQueryOver(x => x.OrderItems, () => orderItemsAlias)
.JoinQueryOver(x => x.Nomenclature)
.Where(x => x.Category == Domain.Goods.NomenclatureCategory.water && !x.IsDisposableTare)
.JoinAlias(() => orderAlias.DeliveryPoint, () => deliveryPointAlias)
.SelectList(list => list.SelectGroup(x => x.Id).WithAlias(() => resultAlias.OrderId)
.SelectSum(() => (int)orderItemsAlias.Count).WithAlias(() => resultAlias.WaterCount)
.SelectSubQuery(districtSubquery).WithAlias(() => resultAlias.DistrictId)
)
.Where(Restrictions.Gt(
Projections.Sum(
Projections.Property(() => orderItemsAlias.Count)), 12))
.TransformUsing(Transformers.AliasToBean <OrderCountResultNode>())
.List <OrderCountResultNode>());
}
private bool NeedPremiumRaskatGAZelleInRouteListDate(IUnitOfWork uow)
{
if (routeList.RecalculatedDistance >= premiumRaskatGAZelleParametersProvider.MinRecalculatedDistanceForPremiumRaskatGAZelle &&
routeList.Car.IsRaskat &&
routeList.Car.TypeOfUse == CarTypeOfUse.DriverCar &&
routeList.Car.RaskatType == RaskatType.RaskatGazelle)
{
RouteListItem routeListAdressesAlias = null;
Order orderAlias = null;
DeliveryPoint deliveryPointAlias = null;
District districtAlias = null;
PremiumItem premiumItemAlias = null;
PremiumRaskatGAZelle premiumRaskatGAZelleAlias = null;
// Ищем премию
var premiumRaskatGAZelleQuery = uow.Session.QueryOver(() => premiumItemAlias)
.JoinAlias(() => premiumItemAlias.Premium, () => premiumRaskatGAZelleAlias)
.Where(() =>
( // Если МЛ переоткрыли в другой день и повторно его закрывают
(premiumRaskatGAZelleAlias.RouteList.Id == routeList.Id) ||
// Если на дату закрытия у водителя уже есть премии
(premiumRaskatGAZelleAlias.Date == DateTime.Today && premiumItemAlias.Employee == routeList.Driver)
) &&
premiumRaskatGAZelleAlias.GetType() == typeof(PremiumRaskatGAZelle)
)
.Take(1).SingleOrDefault();
// Ищем заказ в пригороде
var wageDistrictQuery = uow.Session.QueryOver(() => routeListAdressesAlias)
.JoinAlias(() => routeListAdressesAlias.Order, () => orderAlias)
.JoinAlias(() => orderAlias.DeliveryPoint, () => deliveryPointAlias)
.JoinAlias(() => deliveryPointAlias.District, () => districtAlias)
.Where(() => districtAlias.WageDistrict.Id == wageParametersProvider.GetSuburbWageDistrictId &&
routeListAdressesAlias.RouteList.Id == routeList.Id)
.Take(1).SingleOrDefault();
return(premiumRaskatGAZelleQuery == null && wageDistrictQuery != null);
}
else
{
return(false);
}
}
public bool CanAddFlyerToOrder(
IUnitOfWork uow, IRouteListParametersProvider routeListParametersProvider, int flyerId, int geographicGroupId)
{
WarehouseMovementOperation operationAddAlias = null;
WarehouseMovementOperation operationRemoveAlias = null;
VodovozOrder orderAlias = null;
DeliveryPoint deliveryPointAlias = null;
District districtAlias = null;
OrderEquipment orderEquipmentAlias = null;
var warehouseId = geographicGroupId == routeListParametersProvider.SouthGeographicGroupId
? routeListParametersProvider.WarehouseSofiiskayaId
: routeListParametersProvider.WarehouseParnasId;
var subqueryAdded = uow.Session.QueryOver(() => operationAddAlias)
.Where(() => operationAddAlias.Nomenclature.Id == flyerId)
.Where(Restrictions.IsNotNull(Projections.Property <WarehouseMovementOperation>(o => o.IncomingWarehouse)))
.Where(o => o.IncomingWarehouse.Id == warehouseId)
.Select(Projections.Sum <WarehouseMovementOperation>(o => o.Amount))
.SingleOrDefault <decimal>();
var subqueryRemoved = uow.Session.QueryOver(() => operationRemoveAlias)
.Where(() => operationRemoveAlias.Nomenclature.Id == flyerId)
.Where(Restrictions.IsNotNull(Projections.Property <WarehouseMovementOperation>(o => o.WriteoffWarehouse)))
.Where(o => o.WriteoffWarehouse.Id == warehouseId)
.Select(Projections.Sum <WarehouseMovementOperation>(o => o.Amount))
.SingleOrDefault <decimal>();
var subqueryReserved = uow.Session.QueryOver(() => orderAlias)
.JoinAlias(() => orderAlias.OrderEquipments, () => orderEquipmentAlias)
.JoinAlias(() => orderAlias.DeliveryPoint, () => deliveryPointAlias)
.JoinAlias(() => deliveryPointAlias.District, () => districtAlias)
.Where(() => orderEquipmentAlias.Nomenclature.Id == flyerId)
.Where(() => districtAlias.GeographicGroup.Id == geographicGroupId)
.Where(() => orderAlias.OrderStatus == OrderStatus.NewOrder ||
orderAlias.OrderStatus == OrderStatus.Accepted ||
orderAlias.OrderStatus == OrderStatus.InTravelList ||
orderAlias.OrderStatus == OrderStatus.OnLoading)
.Select(Projections.Sum(() => orderEquipmentAlias.Count))
.SingleOrDefault <int>();
return(subqueryAdded - subqueryRemoved - subqueryReserved > 0);
}
private void BtnAdd_Click(object sender, RoutedEventArgs e)
{
//Client.Connect($"ws://127.0.0.1:8080/Blockchain");
DeliveryPoint from = CmbFrom.SelectedItem as DeliveryPoint;
DeliveryPoint to = CmbTo.SelectedItem as DeliveryPoint;
TypeDelivery type = CmbTypes.SelectedItem as TypeDelivery;
if (from == to)
{
MessageBox.Show("Место отправки и место назначение не могут совпадать!", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
int id = Settings.Default.Id;
id++;
Settings.Default.Id = id;
Settings.Default.Save();
Order order = new Order()
{
Id = id,
Date = DateTime.Now,
Description = TbDescription.Text,
ClientId = Helper.client,
IsStatusDelivery = null,
IsStatusPaid = true,
TypeDeliveryId = type.Id,
From = from.Id,
To = to.Id,
TypeDelivery = type,
FromDeliveryPoint = from,
ToDeliveryPoint = to,
IsActive = true,
};
Helper.Blockchain.AddTransaction(Helper.context.Clients.Find(Helper.client), Helper.context.OrganizationAccounts.FirstOrDefault(), order, order.TypeDelivery.Price);
Blockchain.Helper.SaveBlockchain(Helper.Blockchain);
Helper.context.SaveChanges();
//Client.Broadcast(JsonConvert.SerializeObject(Helper.Blockchain));
//Client.Close();
Server.Close();
Close();
}
public DeliveryPointItemVM(DeliveryPoint model)
{
var orderType = Mvx.Resolve <IBasketConfigService>().Config.OrderViewType;
_bundle = new DeliveryPointBundle(model, orderType == Enums.OrderViewType.Partial ? NavigationType.PresentModal : NavigationType.Push);
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Id = model.Id;
Name = model.Name;
Address = model.Address;
WorkTime = model.WorkTime;
Distance = model.Distance;
Phone = model.Phone;
AdditionalInfo = model.AdditionalInfo;
Coordinates = model.Coordinates;
}
private Order CreateTestOrderWithClient()
{
Order testOrder = new Order();
testOrder.DeliverySchedule = Substitute.For <DeliverySchedule>();
testOrder.Contract = Substitute.For <CounterpartyContract>();
Counterparty testClient = new Counterparty();
testOrder.Client = testClient;
testClient.DefaultDocumentType = DefaultDocumentType.torg12;
testClient.PaymentMethod = PaymentType.cashless;
DeliveryPoint testDeliveryPoint = new DeliveryPoint();
testDeliveryPoint.Id = 45;
testClient.DeliveryPoints.Add(testDeliveryPoint);
return(testOrder);
}
private void AddOrUpdateWaterFixedPrice(IUnitOfWork uow, DeliveryPoint deliveryPoint, Nomenclature nomenclature, decimal fixedPrice)
{
var fixedPrices = waterFixedPricesGenerator.GenerateFixedPricesForAllWater(nomenclature.Id, fixedPrice);
foreach (var pricePair in fixedPrices)
{
var foundFixedPrice = deliveryPoint.NomenclatureFixedPrices.SingleOrDefault(x => x.Nomenclature.Id == pricePair.Key);
if (foundFixedPrice == null)
{
var newNomenclature = uow.GetById <Nomenclature>(pricePair.Key);
var nomenclatureFixedPrice = CreateNewNomenclatureFixedPrice(newNomenclature, pricePair.Value);
nomenclatureFixedPrice.DeliveryPoint = deliveryPoint;
deliveryPoint.ObservableNomenclatureFixedPrices.Add(nomenclatureFixedPrice);
}
else
{
foundFixedPrice.Price = pricePair.Value;
}
}
}
public int GetBottlesAtDeliveryPoint(IUnitOfWork UoW, DeliveryPoint deliveryPoint, DateTime?before = null)
{
BottlesMovementOperation operationAlias = null;
BottlesBalanceQueryResult result = null;
var queryResult = UoW.Session.QueryOver <BottlesMovementOperation>(() => operationAlias)
.Where(() => operationAlias.DeliveryPoint == deliveryPoint);
if (before.HasValue)
{
queryResult.Where(() => operationAlias.OperationTime < before);
}
var bottles = queryResult.SelectList(list => list
.SelectSum(() => operationAlias.Delivered).WithAlias(() => result.Delivered)
.SelectSum(() => operationAlias.Returned).WithAlias(() => result.Returned)
)
.TransformUsing(Transformers.AliasToBean <BottlesBalanceQueryResult>()).List <BottlesBalanceQueryResult>()
.FirstOrDefault()?.BottlesDebt ?? 0;
return(bottles);
}
private IEnumerable <PromosetDuplicateInfoNode> GetDeliveryPointResult(IUnitOfWork uow, DeliveryPoint deliveryPoint)
{
DeliveryPoint deliveryPointAlias = null;
Domain.Orders.Order orderAlias = null;
Domain.Orders.OrderItem orderItemAlias = null;
Counterparty counterpartyAlias = null;
Phone counterpartyPhoneAlias = null;
Phone deliveryPointPhoneAlias = null;
PromosetDuplicateInfoNode resultAlias = null;
var query = uow.Session.QueryOver(() => orderAlias)
.Left.JoinAlias(() => orderAlias.OrderItems, () => orderItemAlias)
.Left.JoinAlias(() => orderAlias.DeliveryPoint, () => deliveryPointAlias)
.Left.JoinAlias(() => orderAlias.Client, () => counterpartyAlias)
.Left.JoinAlias(() => counterpartyAlias.Phones, () => counterpartyPhoneAlias)
.Left.JoinAlias(() => deliveryPointAlias.Phones, () => deliveryPointPhoneAlias)
.Where(
Restrictions.And(
Restrictions.Where(() =>
deliveryPointAlias.City == deliveryPoint.City &&
deliveryPointAlias.Street == deliveryPoint.Street &&
deliveryPointAlias.Building == deliveryPoint.Building &&
deliveryPointAlias.Room == deliveryPoint.Room
),
Restrictions.Ge(Projections.Property(() => deliveryPointAlias.Room), 1)
)
)
.Where(Restrictions.IsNotNull(Projections.Property(() => orderItemAlias.PromoSet)));
var deliveryPointsResult = query.SelectList(list => list
.SelectGroup(() => orderAlias.Id)
.Select(() => orderAlias.DeliveryDate).WithAlias(() => resultAlias.Date)
.Select(() => counterpartyAlias.Name).WithAlias(() => resultAlias.Client)
.Select(() => deliveryPointAlias.CompiledAddress).WithAlias(() => resultAlias.Address)
).TransformUsing(Transformers.AliasToBean <PromosetDuplicateInfoNode>())
.List <PromosetDuplicateInfoNode>();
return(deliveryPointsResult);
}
public bool RequestDuplicatePromosets(IUnitOfWork uow, DeliveryPoint deliveryPoint, IEnumerable <Phone> phones)
{
if (phones == null)
{
throw new ArgumentNullException(nameof(phones));
}
IEnumerable <PromosetDuplicateInfoNode> deliveryPointResult = new List <PromosetDuplicateInfoNode>();
if (deliveryPoint != null)
{
deliveryPointResult = GetDeliveryPointResult(uow, deliveryPoint);
}
var phoneResult = GetPhonesResult(uow, phones);
if (!deliveryPointResult.Any() && !phoneResult.Any())
{
return(true);
}
string message = $"Найдены проданные промо-наборы по аналогичному адресу/телефону:{Environment.NewLine}";
int counter = 1;
foreach (var r in deliveryPointResult)
{
string date = r.Date.HasValue ? r.Date.Value.ToString("dd.MM.yyyy") + ", " : "";
message += $"{counter}. {date}{r.Client}, {r.Address}, {r.Phone}{Environment.NewLine}";
counter++;
}
foreach (var r in phoneResult)
{
string date = r.Date.HasValue ? r.Date.Value.ToString("dd.MM.yyyy") + ", " : "";
message += $"{counter}. {date}{r.Client}, {r.Address}, {r.Phone}{Environment.NewLine}";
counter++;
}
message += $"Продолжить сохранение?";
return(interactiveService.Question(message, "Найдены проданные промонаборы!"));
}
private static string FormatAddress2(ThoroughFare thoroughFare, DeliveryPoint deliveryPoint)
{
return(string.Format("{0}{1}{2}{3}{4}",
ValidateNumeric(deliveryPoint.BuildingName)
? deliveryPoint.BuildingName.Trim().PadRight(deliveryPoint.BuildingName.Trim().Length + 1, ' ')
: string.Empty,
deliveryPoint.BuildingNumber > 0
? deliveryPoint.BuildingNumber.ToString().Trim().PadRight(deliveryPoint.BuildingNumber.ToString().Trim().Length + 1, ' ')
: string.Empty,
!string.IsNullOrWhiteSpace(thoroughFare.DepThoroughFareName)
? thoroughFare.DepThoroughFareName.Trim().PadRight(thoroughFare.DepThoroughFareName.Trim().Length + 1, ' ')
: string.Empty,
!string.IsNullOrWhiteSpace(thoroughFare.DepThoroughFareDescriptor)
? thoroughFare.DepThoroughFareDescriptor + "|"
: string.Empty,
!string.IsNullOrWhiteSpace(thoroughFare.ThoroughFareDescriptor)
? thoroughFare.ThoroughFareName.Trim().PadRight(thoroughFare.ThoroughFareName.Trim().Length + 1, ' ') +
thoroughFare.ThoroughFareDescriptor + "|"
: !string.IsNullOrWhiteSpace(thoroughFare.ThoroughFareName)
? thoroughFare.ThoroughFareName.Trim().PadRight(thoroughFare.ThoroughFareName.Trim().Length + 1, ' ') + "|"
: string.Empty
));
}
private void BtnInfo_Click(object sender, RoutedEventArgs e)
{
TabItem ti = MyTabControl.SelectedItem as TabItem;
string message = "";
if (ti.Header.ToString() == "Заказы")
{
Order order = OrdersGrid.SelectedItem as Order;
if (order != null)
{
DeliveryPoint from = Helper.context.DeliveryPoints.Find(order.From);
DeliveryPoint to = Helper.context.DeliveryPoints.Find(order.To);
Client client = Helper.context.Clients.Include(x => x.Person).FirstOrDefault(x => x.Id == order.ClientId);
message += $"Клиент: {client.Person.LastName} {client.Person.FirstName} {client.Person.MiddleName}\n" +
$"Откуда: {from.Name} {from.Address} {from.Phone}\n" +
$"Куда: {to.Name} {to.Address} {to.Phone}\n" +
$"Тип доставки: {order.TypeDelivery.Name}\n" +
$"Цена доставки(оплачена): {order.TypeDelivery.Price} рублей\n" +
$"Описание: {order.Description}";
MessageBox.Show(message, "Дополнительная информация", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
}
private void BtnAdd_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(TbName.Text) || string.IsNullOrWhiteSpace(TbAddress.Text) || string.IsNullOrWhiteSpace(TbPhone.Text))
{
MessageBox.Show("Пустые поля!", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (!new PhoneAttribute().IsValid(TbPhone.Text))
{
MessageBox.Show("Номер телефона, имеет неправильный формат!", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
DeliveryPoint point = new DeliveryPoint()
{
Address = TbAddress.Text,
Name = TbName.Text,
Phone = TbPhone.Text
};
Helper.context.DeliveryPoints.Add(point);
Helper.context.SaveChanges();
Close();
}
public DeliveryPointBundle(DeliveryPoint model, NavigationType navigationType)
: base(navigationType, new Dictionary <string, string> {
{ nameof(Id), model.Id },
{ nameof(Name), model.Name },
{ nameof(Address), model.Address },
{ nameof(WorkTime), model.WorkTime },
{ nameof(Distance), model.Distance },
{ nameof(Phone), model.Phone },
{ nameof(Info), model.AdditionalInfo },
{ nameof(Longitude), model.Coordinates?.Longitude.ToString(NumberFormatInfo.InvariantInfo) ?? "-1" },
{ nameof(Latitude), model.Coordinates?.Latitude.ToString(NumberFormatInfo.InvariantInfo) ?? "-1" }
})
{
Id = model.Id;
Name = model.Name;
Address = model.Address;
WorkTime = model.WorkTime;
Distance = model.Distance;
Phone = model.Phone;
Info = model.AdditionalInfo;
Longitude = model.Coordinates?.Longitude ?? -1;
Latitude = model.Coordinates?.Latitude ?? -1;
}
public IEnumerable <CallTask> GetActiveSelfDeliveryTaskByCounterparty(IUnitOfWork UoW, Counterparty counterparty, CallTaskStatus?taskStatus = null, int?limit = null)
{
CallTask callTaskAlias = null;
DeliveryPoint deliveryPointAlias = null;
Counterparty counterpartyAlias = null;
var tasks = UoW.Session.QueryOver(() => callTaskAlias)
.JoinAlias(() => callTaskAlias.DeliveryPoint, () => deliveryPointAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => callTaskAlias.Counterparty, () => counterpartyAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.Where(Restrictions.On(() => deliveryPointAlias.Id).IsNull)
.And(() => counterpartyAlias.Id == counterparty.Id)
.And(x => !x.IsTaskComplete);
if (taskStatus.HasValue)
{
tasks = tasks.Where(() => callTaskAlias.TaskState == taskStatus.Value);
}
if (limit.HasValue)
{
tasks.Take(limit.Value);
}
return(tasks.List());
}
/// <summary>
/// Получаем текущие депозиты для точки
/// </summary>
/// <param name="depositType">Указываем тип депозита, если null то по берем все типы.</param>
public decimal GetDepositsAtDeliveryPoint(IUnitOfWork UoW, DeliveryPoint deliveryPoint, DepositType?depositType, DateTime?before = null)
{
DepositOperation operationAlias = null;
DepositsQueryResult result = null;
var queryResult = UoW.Session.QueryOver <DepositOperation>(() => operationAlias)
.Where(() => operationAlias.DeliveryPoint.Id == deliveryPoint.Id);
if (before.HasValue)
{
queryResult.Where(() => operationAlias.OperationTime < before);
}
if (depositType.HasValue)
{
queryResult.Where(() => operationAlias.DepositType == depositType);
}
var deposits = queryResult.SelectList(list => list
.SelectSum(() => operationAlias.ReceivedDeposit).WithAlias(() => result.Received)
.SelectSum(() => operationAlias.RefundDeposit).WithAlias(() => result.Refund)
).TransformUsing(Transformers.AliasToBean <DepositsQueryResult>()).List <DepositsQueryResult>()
.FirstOrDefault()?.Deposits ?? 0;
return(deposits);
}
public decimal GetAvgBottlesOrdered(IUnitOfWork uow, DeliveryPoint deliveryPoint, int?countLastOrders)
{
Order orderAlias = null;
OrderItem orderItemAlias = null;
Nomenclature nomenclatureAlias = null;
var confirmedQueryResult = uow.Session.QueryOver <Order>(() => orderAlias)
.Where(() => orderAlias.DeliveryPoint.Id == deliveryPoint.Id)
.Where(() => orderAlias.OrderStatus == OrderStatus.Closed)
.JoinAlias(() => orderAlias.OrderItems, () => orderItemAlias)
.JoinAlias(() => orderItemAlias.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Category == NomenclatureCategory.water && !nomenclatureAlias.IsDisposableTare)
.OrderByAlias(() => orderAlias.DeliveryDate).Desc;
if (countLastOrders.HasValue)
{
confirmedQueryResult.Take(countLastOrders.Value);
}
var list = confirmedQueryResult.Select(Projections.Group <Order>(x => x.Id),
Projections.Sum(() => orderItemAlias.Count)).List <object[]>();
return(list.Count > 0 ? list.Average(x => (decimal)x[1]) : 0);
}
public IList <object[]> GetGuilties(UndeliveredOrdersFilterViewModel filter)
{
OrderItem orderItemAlias = null;
Nomenclature nomenclatureAlias = null;
UndeliveredOrder undeliveredOrderAlias = null;
Domain.Orders.Order oldOrderAlias = null;
Domain.Orders.Order newOrderAlias = null;
Employee oldOrderAuthorAlias = null;
Counterparty counterpartyAlias = null;
DeliveryPoint undeliveredOrderDeliveryPointAlias = null;
Subdivision subdivisionAlias = null;
GuiltyInUndelivery guiltyInUndeliveryAlias = null;
Employee authorAlias = null;
var subquery19LWatterQty = QueryOver.Of <OrderItem>(() => orderItemAlias)
.Where(() => orderItemAlias.Order.Id == oldOrderAlias.Id)
.Left.JoinQueryOver(i => i.Nomenclature, () => nomenclatureAlias)
.Where(n => n.Category == NomenclatureCategory.water && n.TareVolume == TareVolume.Vol19L)
.Select(Projections.Sum(() => orderItemAlias.Count));
var query = _uow.Session.QueryOver <UndeliveredOrder>(() => undeliveredOrderAlias)
.Left.JoinAlias(u => u.OldOrder, () => oldOrderAlias)
.Left.JoinAlias(u => u.NewOrder, () => newOrderAlias)
.Left.JoinAlias(() => oldOrderAlias.Client, () => counterpartyAlias)
.Left.JoinAlias(() => oldOrderAlias.Author, () => oldOrderAuthorAlias)
.Left.JoinAlias(() => oldOrderAlias.DeliveryPoint, () => undeliveredOrderDeliveryPointAlias)
.Left.JoinAlias(() => undeliveredOrderAlias.GuiltyInUndelivery, () => guiltyInUndeliveryAlias)
.Left.JoinAlias(() => guiltyInUndeliveryAlias.GuiltyDepartment, () => subdivisionAlias)
.Left.JoinAlias(u => u.Author, () => authorAlias);
if (filter?.RestrictDriver != null)
{
var oldOrderIds = _undeliveredOrdersRepository.GetListOfUndeliveryIdsForDriver(_uow, filter.RestrictDriver);
query.Where(() => oldOrderAlias.Id.IsIn(oldOrderIds.ToArray()));
}
if (filter?.RestrictOldOrder != null)
{
query.Where(() => oldOrderAlias.Id == filter.RestrictOldOrder.Id);
}
if (filter?.RestrictClient != null)
{
query.Where(() => counterpartyAlias.Id == filter.RestrictClient.Id);
}
if (filter?.RestrictAddress != null)
{
query.Where(() => undeliveredOrderDeliveryPointAlias.Id == filter.RestrictAddress.Id);
}
if (filter?.RestrictOldOrderAuthor != null)
{
query.Where(() => oldOrderAuthorAlias.Id == filter.RestrictOldOrderAuthor.Id);
}
if (filter?.RestrictOldOrderStartDate != null)
{
query.Where(() => oldOrderAlias.DeliveryDate >= filter.RestrictOldOrderStartDate);
}
if (filter?.RestrictOldOrderEndDate != null)
{
query.Where(() => oldOrderAlias.DeliveryDate <= filter.RestrictOldOrderEndDate.Value.AddDays(1).AddTicks(-1));
}
if (filter?.RestrictNewOrderStartDate != null)
{
query.Where(() => newOrderAlias.DeliveryDate >= filter.RestrictNewOrderStartDate);
}
if (filter?.RestrictNewOrderEndDate != null)
{
query.Where(() => newOrderAlias.DeliveryDate <= filter.RestrictNewOrderEndDate.Value.AddDays(1).AddTicks(-1));
}
if (filter?.RestrictGuiltySide != null)
{
query.Where(() => guiltyInUndeliveryAlias.GuiltySide == filter.RestrictGuiltySide);
}
if (filter != null && filter.RestrictIsProblematicCases)
{
query.Where(() => !guiltyInUndeliveryAlias.GuiltySide.IsIn(filter.ExcludingGuiltiesForProblematicCases));
}
if (filter?.RestrictGuiltyDepartment != null)
{
query.Where(() => subdivisionAlias.Id == filter.RestrictGuiltyDepartment.Id);
}
if (filter?.RestrictInProcessAtDepartment != null)
{
query.Where(u => u.InProcessAtDepartment.Id == filter.RestrictInProcessAtDepartment.Id);
}
if (filter?.NewInvoiceCreated != null)
{
if (filter.NewInvoiceCreated.Value)
{
query.Where(u => u.NewOrder != null);
}
else
{
query.Where(u => u.NewOrder == null);
}
}
if (filter?.RestrictUndeliveryStatus != null)
{
query.Where(u => u.UndeliveryStatus == filter.RestrictUndeliveryStatus);
}
if (filter?.RestrictUndeliveryAuthor != null)
{
query.Where(u => u.Author == filter.RestrictUndeliveryAuthor);
}
if (filter?.RestrictAuthorSubdivision != null)
{
query.Where(() => authorAlias.Subdivision.Id == filter.RestrictAuthorSubdivision.Id);
}
int position = 0;
var result =
query.SelectList(list => list
.SelectGroup(u => u.Id)
.Select(Projections.SqlFunction(
new SQLFunctionTemplate(
NHibernateUtil.String,
"GROUP_CONCAT(" +
"CASE ?1 " +
$"WHEN '{nameof(GuiltyTypes.Department)}' THEN IFNULL(CONCAT('Отд: ', ?2), 'Отдел ВВ') " +
$"WHEN '{nameof(GuiltyTypes.Client)}' THEN 'Клиент' " +
$"WHEN '{nameof(GuiltyTypes.Driver)}' THEN 'Водитель' " +
$"WHEN '{nameof(GuiltyTypes.ServiceMan)}' THEN 'Мастер СЦ' " +
$"WHEN '{nameof(GuiltyTypes.ForceMajor)}' THEN 'Форс-мажор' " +
$"WHEN '{nameof(GuiltyTypes.None)}' THEN 'Нет (не недовоз)' " +
"ELSE ?1 " +
"END ORDER BY ?1 ASC SEPARATOR '\n')"
),
NHibernateUtil.String,
Projections.Property(() => guiltyInUndeliveryAlias.GuiltySide),
Projections.Property(() => subdivisionAlias.ShortName)))
.SelectSubQuery(subquery19LWatterQty))
.List <object[]>()
.GroupBy(x => x[1])
.Select(r => new[] { r.Key, r.Count(), position++, r.Sum(x => x[2] == null ? 0 : (decimal)x[2]) })
.ToList();
return(result);
}
public void SetDeliveryPoint(DeliveryPoint deliveryPoint)
{
entityViewModelEntryCounterparty.Subject = deliveryPoint.Counterparty;
referenceDeliveryPoint.Subject = deliveryPoint;
}
private string GetDeliveryPointNameForUser(DeliveryPoint point)
{
return($"{point.Name} {point.City}");
}
public static DeliveryPriceNode Calculate(DeliveryPoint point, int?bottlesCount = null)
{
deliveryPoint = point;
return(Calculate(deliveryPoint.Latitude, deliveryPoint.Longitude, bottlesCount));
}
private IQueryOver <VodovozOrder> GetOrdersQuery(IUnitOfWork uow)
{
RetailOrderJournalNode resultAlias = null;
VodovozOrder orderAlias = null;
Nomenclature nomenclatureAlias = null;
OrderItem orderItemAlias = null;
Counterparty counterpartyAlias = null;
DeliveryPoint deliveryPointAlias = null;
DeliverySchedule deliveryScheduleAlias = null;
Employee authorAlias = null;
Employee lastEditorAlias = null;
District districtAlias = null;
CounterpartyContract contractAlias = null;
Nomenclature sanitizationNomenclature = _nomenclatureRepository.GetSanitisationNomenclature(uow);
var query = uow.Session.QueryOver <VodovozOrder>(() => orderAlias);
if (FilterViewModel != null && FilterViewModel.IsForRetail != null)
{
query.JoinEntityAlias(
() => counterpartyAlias,
() => counterpartyAlias.Id == orderAlias.Client.Id &&
counterpartyAlias.IsForRetail == FilterViewModel.IsForRetail,
NHibernate.SqlCommand.JoinType.InnerJoin);
}
else
{
query.Left.JoinAlias(o => o.Client, () => counterpartyAlias);
}
if (FilterViewModel.ViewTypes != ViewTypes.Order && FilterViewModel.ViewTypes != ViewTypes.All)
{
query.Where(o => o.Id == -1);
}
if (FilterViewModel.RestrictStatus != null)
{
query.Where(o => o.OrderStatus == FilterViewModel.RestrictStatus);
}
if (FilterViewModel.RestrictPaymentType != null)
{
query.Where(o => o.PaymentType == FilterViewModel.RestrictPaymentType);
}
if (FilterViewModel.HideStatuses != null)
{
query.WhereRestrictionOn(o => o.OrderStatus).Not.IsIn(FilterViewModel.HideStatuses);
}
if (FilterViewModel.RestrictOnlySelfDelivery != null)
{
query.Where(o => o.SelfDelivery == FilterViewModel.RestrictOnlySelfDelivery);
}
if (FilterViewModel.RestrictWithoutSelfDelivery != null)
{
query.Where(o => o.SelfDelivery != FilterViewModel.RestrictWithoutSelfDelivery);
}
if (FilterViewModel.RestrictCounterparty != null)
{
query.Where(o => o.Client == FilterViewModel.RestrictCounterparty);
}
if (FilterViewModel.DeliveryPoint != null)
{
query.Where(o => o.DeliveryPoint == FilterViewModel.DeliveryPoint);
}
if (FilterViewModel.RestrictStartDate != null)
{
query.Where(o => o.DeliveryDate >= FilterViewModel.RestrictStartDate);
}
if (FilterViewModel.RestrictEndDate != null)
{
query.Where(o => o.DeliveryDate <= FilterViewModel.RestrictEndDate.Value.AddDays(1).AddTicks(-1));
}
if (FilterViewModel.RestrictLessThreeHours == true)
{
query.Where(Restrictions
.GtProperty(Projections.SqlFunction(
new SQLFunctionTemplate(NHibernateUtil.Time, "ADDTIME(?1, ?2)"),
NHibernateUtil.Time,
Projections.Property(() => deliveryScheduleAlias.From),
Projections.Constant("3:0:0")),
Projections.Property(() => deliveryScheduleAlias.To)));
}
if (FilterViewModel.RestrictHideService != null)
{
if (FilterViewModel.RestrictHideService.Value)
{
query.Where(o => o.OrderAddressType != OrderAddressType.Service);
}
else
{
query.Where(o => o.OrderAddressType == OrderAddressType.Service);
}
}
if (FilterViewModel.RestrictOnlyService != null)
{
if (FilterViewModel.RestrictOnlyService.Value)
{
query.Where(o => o.OrderAddressType == OrderAddressType.Service);
}
else
{
query.Where(o => o.OrderAddressType != OrderAddressType.Service);
}
}
if (FilterViewModel.OrderPaymentStatus != null)
{
query.Where(o => o.OrderPaymentStatus == FilterViewModel.OrderPaymentStatus);
}
if (FilterViewModel.Organisation != null)
{
query.Where(() => contractAlias.Organization.Id == FilterViewModel.Organisation.Id);
}
if (FilterViewModel.PaymentByCardFrom != null)
{
query.Where(o => o.PaymentByCardFrom.Id == FilterViewModel.PaymentByCardFrom.Id);
}
var bottleCountSubquery = QueryOver.Of <OrderItem>(() => orderItemAlias)
.Where(() => orderAlias.Id == orderItemAlias.Order.Id)
.JoinAlias(() => orderItemAlias.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Category == NomenclatureCategory.water && nomenclatureAlias.TareVolume == TareVolume.Vol19L)
.Select(Projections.Sum(() => orderItemAlias.Count));
var sanitisationCountSubquery = QueryOver.Of <OrderItem>(() => orderItemAlias)
.Where(() => orderAlias.Id == orderItemAlias.Order.Id)
.Where(() => orderItemAlias.Nomenclature.Id == sanitizationNomenclature.Id)
.Select(Projections.Sum(() => orderItemAlias.Count));
var orderSumSubquery = QueryOver.Of <OrderItem>(() => orderItemAlias)
.Where(() => orderItemAlias.Order.Id == orderAlias.Id)
.Select(
Projections.Sum(
Projections.SqlFunction(
new SQLFunctionTemplate(NHibernateUtil.Decimal, "ROUND(IFNULL(?1, ?2) * ?3 - ?4, 2)"),
NHibernateUtil.Decimal,
Projections.Property <OrderItem>(x => x.ActualCount),
Projections.Property <OrderItem>(x => x.Count),
Projections.Property <OrderItem>(x => x.Price),
Projections.Property <OrderItem>(x => x.DiscountMoney)
)
)
);
query.Left.JoinAlias(o => o.DeliveryPoint, () => deliveryPointAlias)
.Left.JoinAlias(o => o.DeliverySchedule, () => deliveryScheduleAlias)
.Left.JoinAlias(o => o.Author, () => authorAlias)
.Left.JoinAlias(o => o.LastEditor, () => lastEditorAlias)
.Left.JoinAlias(() => deliveryPointAlias.District, () => districtAlias)
.Left.JoinAlias(o => o.Contract, () => contractAlias);
query.Where(GetSearchCriterion(
() => orderAlias.Id,
() => counterpartyAlias.Name,
() => deliveryPointAlias.CompiledAddress,
() => authorAlias.LastName,
() => orderAlias.DriverCallId,
() => orderAlias.OnlineOrder,
() => orderAlias.EShopOrder,
() => orderAlias.OrderPaymentStatus
));
var resultQuery = query
.SelectList(list => list
.Select(() => orderAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => orderAlias.SelfDelivery).WithAlias(() => resultAlias.IsSelfDelivery)
.Select(() => orderAlias.DeliveryDate).WithAlias(() => resultAlias.Date)
.Select(() => orderAlias.CreateDate).WithAlias(() => resultAlias.CreateDate)
.Select(() => deliveryScheduleAlias.Name).WithAlias(() => resultAlias.DeliveryTime)
.Select(() => orderAlias.OrderStatus).WithAlias(() => resultAlias.StatusEnum)
.Select(() => orderAlias.Address1c).WithAlias(() => resultAlias.Address1c)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorLastName)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorLastName)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => orderAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime)
.Select(() => orderAlias.DriverCallId).WithAlias(() => resultAlias.DriverCallId)
.Select(() => orderAlias.OnlineOrder).WithAlias(() => resultAlias.OnlineOrder)
.Select(() => counterpartyAlias.Name).WithAlias(() => resultAlias.Counterparty)
.Select(() => districtAlias.DistrictName).WithAlias(() => resultAlias.DistrictName)
.Select(() => deliveryPointAlias.CompiledAddress).WithAlias(() => resultAlias.CompilledAddress)
.Select(() => deliveryPointAlias.City).WithAlias(() => resultAlias.City)
.Select(() => deliveryPointAlias.Street).WithAlias(() => resultAlias.Street)
.Select(() => deliveryPointAlias.Building).WithAlias(() => resultAlias.Building)
.Select(() => orderAlias.EShopOrder).WithAlias(() => resultAlias.EShopOrder)
.Select(() => orderAlias.OrderPaymentStatus).WithAlias(() => resultAlias.OrderPaymentStatus)
.SelectSubQuery(orderSumSubquery).WithAlias(() => resultAlias.Sum)
.SelectSubQuery(bottleCountSubquery).WithAlias(() => resultAlias.BottleAmount)
.SelectSubQuery(sanitisationCountSubquery).WithAlias(() => resultAlias.SanitisationAmount)
)
.OrderBy(x => x.CreateDate).Desc
.SetTimeout(60)
.TransformUsing(Transformers.AliasToBean <RetailOrderJournalNode <VodovozOrder> >());
return(resultQuery);
}
