public void UpdatePositionIm(PositionIm positionIm, OrderPositionData opd, DbTransaction dbTran)
{
if (NeedReCreatePositionIm(positionIm, opd.FormatData.Id))
{
DeletePositionIm(positionIm, dbTran);
CreatePositionIm(positionIm.OrderPosition.Order.BusinessUnitId, opd.OrderId, opd.OrderPositionId, opd, dbTran);
return;
}
if (_stringProcessor.CanUpdateString(positionIm))
{
positionIm = _repository.SetPositionIm(positionIm, newTaskFile: false, newMaketFile: false, isActual: true, dbTran);
_stringProcessor.UpdateFullString(positionIm.OrderPositionId, opd.StringData, dbTran);
}
if (_moduleMaketProcessor.CanUpdateModule(positionIm))
{
positionIm = _repository.SetPositionIm(positionIm, newTaskFile: true, newMaketFile: false, isActual: true, dbTran);
// Обновляем графические материалы позиции ИМ-а
var taskFileDate = (DateTime)positionIm.TaskFileDate;
var bytes = Base64ToBytesConverter.Convert(opd.ModuleData.Base64String);
_moduleMaketProcessor.CreateSampleImage(positionIm.OrderPositionId, bytes, "ImgTask", taskFileDate);
_moduleMaketProcessor.UpdateModuleGraphics(positionIm.OrderPositionId, bytes, opd.ModuleData.Name);
}
}
private GraphicData GetPackageGraphicData(OrderPositionData opd)
{
// Получаем идентификаторы графиков позиций пакета
var graphicIds = opd.Childs
.SelectMany(c => c.GraphicsData)
.Select(g => g.Id);
// Находим минимальную дату выхода позиций пакета
// с поставщиком пакета
var minOutDate = _context.Graphics
.Where(g => graphicIds.Contains(g.Id) && g.SupplierId == opd.SupplierId)
.Min(g => g.OutDate);
// Находим график выхода пакета - его дата выхода меньше
// или равна миминальной дате выхода позиций пакета
var graphic = _context.Graphics
.Where(g =>
g.SupplierId == opd.SupplierId &&
g.PricePositionTypeId == opd.FormatData.FormatTypeId &&
g.OutDate <= minOutDate)
.OrderByDescending(g => g.OutDate)
.First();
var graphicData = new GraphicData {
Id = graphic.Id, Childs = new List <int>()
};
return(graphicData);
}
public IActionResult Create([FromBody] OrderPositionData orderPosition)
{
var clientLegalPersonId = _httpContextAccessor.HttpContext.GetClientLegalPersonId();
if (orderPosition == null)
{
return(BadRequest(
new { message = "Создаваемая позиция не передана." }));
}
if (clientLegalPersonId != orderPosition.ClientLegalPersonId)
{
return(StatusCode(
(int)HttpStatusCode.Forbidden,
new { message = "Создание позиции заказа запрещено." }));
}
var logger = LogManager.GetCurrentClassLogger();
logger.Info(JsonSerializer.Serialize(orderPosition));
if (orderPosition.StringData != null && !orderPosition.StringData.PhonesData.Any())
{
throw new Exception("В строку не переданы телефоны.");
}
_orderPositionService.CreateOrderPosition(orderPosition);
return(Ok());
}
public IActionResult Update([FromBody] OrderPositionData orderPosition)
{
var clientLegalPersonId = _httpContextAccessor.HttpContext.GetClientLegalPersonId();
if (orderPosition == null)
{
return(BadRequest(
new { message = "Изменяемая позиция не передана." }));
}
if (!_orderPositionService.ExistsById(orderPosition.OrderPositionId))
{
return(StatusCode(
(int)HttpStatusCode.NotFound,
new { message = string.Format("Изменяемая позиция заказа {0} не найдена.", orderPosition.OrderPositionId) }));
}
if (clientLegalPersonId != orderPosition.ClientLegalPersonId)
{
return(StatusCode(
(int)HttpStatusCode.Forbidden,
new { message = string.Format("Изменение позиции заказа {0} запрещено.", orderPosition.OrderPositionId) }));
}
_orderPositionService.UpdateOrderPosition(orderPosition);
return(Ok());
}
public List <GraphicData> GetPackageGraphicsData(OrderPositionData opd)
{
var graphicsData = new List <GraphicData>();
graphicsData.Add(GetPackageGraphicData(opd));
return(graphicsData);
}
private bool NeedUpdateOrderPosition(OrderPosition orderPosition, OrderPositionData opd)
{
if (orderPosition.Id == opd.OrderPositionId &&
orderPosition.SupplierId == opd.SupplierId &&
orderPosition.PricePositionId == opd.FormatData.Id &&
orderPosition.PricePositionVersion == opd.FormatData.Version &&
orderPosition.PriceId == opd.PriceId)
{
return(false);
}
return(true);
}
public void UpdateOrderPosition(OrderPositionData opd)
{
using (var сontextTransaction = _context.Database.BeginTransaction())
{
var dbTran = сontextTransaction.GetDbTransaction();
var orderPosition = _orderPositionProcessor
.GetInnerOperationsOrderPositionsByIds(new[] { opd.OrderPositionId }).Single();
var basketOrder = _orderProcessor.GetBasketOrder(opd.ClientLegalPersonId, opd.PriceId);
// Обновляем позицию заказа
_orderPositionProcessor.UpdateFullOrderPosition(orderPosition, opd, dbTran);
// Перебираем переданные пакетные позиции
foreach (var child in opd.Childs)
{
var childOrderPosition = _orderPositionProcessor
.GetInnerOperationsOrderPositionsByIds(new[] { child.OrderPositionId }).SingleOrDefault();
// Если переданной позиции не существует - создаём её, иначе - обновляем
if (_orderPositionProcessor.NeedCreateFullOrderPosition(childOrderPosition))
{
_orderPositionProcessor.CreateFullOrderPosition(
basketOrder.BusinessUnitId, basketOrder.Id, orderPosition.Id, 0, child, dbTran);
}
else
{
_orderPositionProcessor.UpdateFullOrderPosition(childOrderPosition, child, dbTran);
}
}
var childOrderPositions = orderPosition.ChildOrderPositions;
// Если в существующих пакетных позициях нет переданных - удаляем их
foreach (var childOrderPosition in childOrderPositions)
{
if (_orderPositionProcessor.NeedDeleteFullOrderPosition(childOrderPosition.Id, opd.Childs))
{
_orderPositionProcessor.DeleteFullOrderPosition(childOrderPosition, dbTran);
}
}
// Обновляем заказ-корзину
_orderProcessor.UpdateOrder(basketOrder.Id, dbTran);
_context.SaveChanges();
dbTran.Commit();
}
}
private async Task <OrderPositionData> GetOrderPositionDataAsync(int orderPositionId)
{
var orderPosition = await _context.OrderPositions
.Include(op => op.Order.ClientCompany)
.Include(op => op.PricePosition)
.Include(op => op.RubricPositions)
.Include(op => op.GraphicPositions).ThenInclude(gp => gp.Graphic)
.Include(op => op.PositionIm)
.SingleAsync(op => op.Id == orderPositionId);
var opd = new OrderPositionData
{
OrderId = orderPosition.OrderId,
OrderPositionId = orderPosition.Id,
ClientId = orderPosition.Order.ClientCompanyId,
ClientLegalPersonId = orderPosition.Order.ClientLegalPersonId,
SupplierId = orderPosition.SupplierId,
FormatData = new FormatData
{
Id = orderPosition.PricePositionId,
Version = orderPosition.PricePositionVersion,
FormatTypeId = orderPosition.PricePosition.PricePositionTypeId,
FirstSize = orderPosition.PricePosition.FirstSize,
SecondSize = orderPosition.PricePosition.SecondSize,
PackageLength = orderPosition.PricePosition.PackageLength,
Description = orderPosition.PricePosition.Description
},
PriceId = orderPosition.PriceId,
RubricData = GetRubricData(orderPosition),
GraphicsData = GetGraphicsData(orderPosition)
};
if (orderPosition.PositionIm != null)
{
var positionImTypeId = orderPosition.PositionIm.PositionImTypeId;
if (positionImTypeId == 1)
{
opd.StringData = await GetStringDataAsync(orderPositionId);
}
if (positionImTypeId == 2)
{
opd.ModuleData = await GetModuleDataAsync(orderPositionId);
}
}
return(opd);
}
public void UpdateOrderPosition(OrderPosition orderPosition, OrderPositionData opd, DbTransaction dbTran)
{
if (!NeedUpdateOrderPosition(orderPosition, opd))
{
return;
}
orderPosition.Id = opd.OrderPositionId;
orderPosition.SupplierId = opd.SupplierId;
orderPosition.PriceId = opd.PriceId;
orderPosition.PricePositionId = opd.FormatData.Id;
orderPosition.PricePositionVersion = opd.FormatData.Version;
orderPosition.BeginDate = DateTime.Now;
var isUnloaded = IsUnloaded(orderPosition);
_repository.SetOrderPosition(orderPosition, isUnloaded, isActual: true, dbTran);
}
public void CreateOrderPosition(OrderPositionData opd)
{
using (var сontextTransaction = _context.Database.BeginTransaction())
{
var dbTran = сontextTransaction.GetDbTransaction();
// Получаем заказ-корзину
var basketOrder = _orderProcessor.GetBasketOrder(opd.ClientLegalPersonId, opd.PriceId);
// Если заказа-корзины не существует - создаём её
if (basketOrder == null)
{
basketOrder = _orderProcessor.CreateBasketOrder(opd, dbTran);
}
// Получааем скидку клиента
var clientDiscount = _clientProcessor.GetDiscount(
opd.ClientLegalPersonId,
basketOrder.BusinessUnitId,
opd.SupplierId,
opd.FormatData.FormatTypeId);
// Сохраняем позицию заказа
int orderPositionId = _orderPositionProcessor.CreateFullOrderPosition(
basketOrder.BusinessUnitId, basketOrder.Id, null, clientDiscount, opd, dbTran);
// Сохраняем пакетные позиции заказа
foreach (var child in opd.Childs)
{
_orderPositionProcessor.CreateFullOrderPosition(
basketOrder.BusinessUnitId, basketOrder.Id, orderPositionId, clientDiscount, child, dbTran);
}
// Обновляем заказ-корзину
_orderProcessor.UpdateOrder(basketOrder.Id, dbTran);
_context.SaveChanges();
dbTran.Commit();
}
}
public Order CreateBasketOrder(OrderPositionData opd, DbTransaction dbTran)
{
var clientLegalPersonId = opd.ClientLegalPersonId;
// Ищем бизнес юнит заказа корзины
var businessUnitId = _basketBusinessUnitIdProvider.GetByValue(
new Tuple <int, int>(clientLegalPersonId, opd.PriceId));
var clientCompanyId = _context.LegalPersons
.Include(lp => lp.Company)
.Single(lp => lp.Id == opd.ClientLegalPersonId).Company.Id;
var supplierLegalPersonId = _context.BusinessUnits
.Single(bu => bu.Id == businessUnitId).LegalPersonId;
var isAdvance = _context.LegalPersons
.Include(lp => lp.AccountSettings)
.Single(lp => lp.Id == clientLegalPersonId)
.AccountSettings.IsNeedPrepayment;
var maxExitDate = _context.Graphics
.Where(gr => opd.GetGraphicsWithChildren()
.Contains(gr.Id))
.Max(gr => gr.OutDate);
var sum = _context.Prices
.Where(p => opd.GetPrices().Contains(p.Id))
.AsEnumerable()
.Sum(p => p.GetTarifCost());
var managerId = _defaultOrderManagerId;
var order = _basketOrderFactory.Create(
businessUnitId, clientLegalPersonId, clientCompanyId,
supplierLegalPersonId, isAdvance, maxExitDate, sum, managerId);
order = _repository.SetOrder(order, true, dbTran);
return(order);
}
public void UpdateFullOrderPosition(OrderPosition orderPosition, OrderPositionData opd, DbTransaction dbTran)
{
UpdateOrderPosition(orderPosition, opd, dbTran);
// Если рубрика не задана - удаляем все позиции рубрик
if (opd.RubricData == null || opd.RubricData.Id == 0)
{
_rubricProcessor.DeleteRubricPositions(orderPosition.RubricPositions, dbTran);
}
else
{
_rubricProcessor.UpdateRubricPosition(orderPosition.Id, orderPosition.RubricPositions, opd.RubricData, dbTran);
}
// Если переданы есть пакетные позиции - вычисляем график на их основе
if (opd.Childs.Any())
{
opd.GraphicsData = _graphicProcessor.GetPackageGraphicsData(opd);
}
_graphicProcessor.UpdateGraphicPositions(orderPosition.Id, orderPosition.GraphicPositions, opd.GraphicsData, dbTran);
_positionImProcessor.UpdatePositionIm(orderPosition.PositionIm, opd, dbTran);
}
private OrderPosition CreateOrderPosition(int orderId, int?parentOrderPositionId, float clientDiscount, OrderPositionData opd,
DbTransaction dbTran)
{
var markup = _context.Prices.Single(pr => pr.Id == opd.PriceId).Markup;
var businessUnitId = _context.Prices.Single(p => p.Id == opd.PriceId).BusinessUnitId;
var nds = GetNds(businessUnitId, opd.SupplierId);
var orderPosition = _orderPositionFactory.Create(orderId, parentOrderPositionId, clientDiscount, markup, nds, opd);
orderPosition = _repository.SetOrderPosition(orderPosition, false, isActual: true, dbTran);
return(orderPosition);
}
public int CreateFullOrderPosition(int businessUnitId, int orderId, int?parentOrderPositionId, float clientDiscount, OrderPositionData opd,
DbTransaction dbTran)
{
// Создаём позицию заказа
var orderPosition = CreateOrderPosition(orderId, parentOrderPositionId, clientDiscount, opd,
dbTran);
// Если рубрика не задана (пакет) - не сохраняем её
if (opd.RubricData != null)
{
_rubricProcessor.CreateRubricPosition(orderPosition.Id, opd.RubricData, dbTran);
}
// Если передан пакет - ищем график на основе его позиций
if (opd.Childs.Any())
{
opd.GraphicsData = _graphicProcessor.GetPackageGraphicsData(opd);
}
_graphicProcessor.CreateGraphicPositions(orderPosition.Id, opd.GraphicsData, dbTran);
_positionImProcessor.CreatePositionIm(businessUnitId, orderId, orderPosition.Id, opd, dbTran);
return(orderPosition.Id);
}
public void CreatePositionIm(int businessUnitId, int orderId, int orderPositionId, OrderPositionData opd, DbTransaction dbTran)
{
Action <int, int, DbTransaction> setOrderIm = (orderId, orderImTypeId, dbTran) =>
{
var orderIm = _orderImProcessor.GetOrderIm(orderId, orderImTypeId);
if (orderIm == null)
{
_orderImProcessor.CreateOrderIm(orderId, orderImTypeId, null, dbTran);
}
};
if (opd.StringData != null)
{
var positionIm = _positionImFactory.Create(orderId, orderPositionId, positionImTypeId: 1);
_repository.SetPositionIm(positionIm, newTaskFile: false, newMaketFile: false, isActual: true, dbTran);
_stringProcessor.CreateFullString(businessUnitId, opd.ClientId, orderPositionId, opd.StringData, dbTran);
setOrderIm(orderId, 1, dbTran);
}
if (opd.ModuleData != null)
{
var positionIm = _positionImFactory.Create(orderId, orderPositionId, positionImTypeId: 2);
positionIm = _repository.SetPositionIm(positionIm, newTaskFile: true, newMaketFile: false, isActual: true, dbTran);
_moduleProcessor.CreateModule(opd.ClientId, businessUnitId, orderPositionId, dbTran);
var bytes = Base64ToBytesConverter.Convert(opd.ModuleData.Base64String);
var taskFileDate = (DateTime)positionIm.TaskFileDate;
_moduleMaketProcessor.CreateSampleImage(orderPositionId, bytes, "ImgTask", taskFileDate);
_moduleMaketProcessor.CreateModuleGraphics(orderPositionId, bytes, opd.ModuleData.Name);
setOrderIm(orderId, 2, dbTran);
}
}
public OrderPosition Create(int orderId, int?parentOrderPositionId, float discount, float markup, float nds, OrderPositionData opd)
{
var orderPosition = new OrderPosition
{
Id = 0,
ParentOrderPositionId = parentOrderPositionId,
OrderId = orderId,
SupplierId = opd.SupplierId,
PriceId = opd.PriceId,
PricePositionId = opd.FormatData.Id,
PricePositionVersion = opd.FormatData.Version,
Discount = discount,
Markup = markup,
Nds = nds,
Compensation = 0,
Description = string.Empty,
ClientPackageDiscount = 0,
BeginDate = DateTime.Now
};
return(orderPosition);
}
