public async Task <IWrappedResponse> SendOrdersAsync(OrdersSyncRequest request)
{
try
{
_queueClient = new QueueClient(_syncServiceBusConnectionString, _orderSyncRequestQueueName,
retryPolicy: RetryPolicy.Default);
var messages = new List <Message>();
messages.AddRange(request.OrderCreateSyncRequests.AsMessages());
messages.AddRange(request.OrderCancelSyncRequests.AsMessages());
messages.AddRange(request.OrderFulfillSyncRequests.AsMessages());
messages.AddRange(request.OrderRollbackFulfillmentSyncRequests.AsMessages());
await _queueClient.SendAsync(messages);
return(new WrappedResponse
{
ResultType = ResultType.Ok
});
}
catch (Exception exception)
{
ErrorHandler.Create()
.LogException(new SynchronizationException("Send orders failed.", exception), request);
return(new WrappedResponse
{
ResultType = ResultType.Failed
});
}
}
private async Task CheckOrdersSyncDate(CancellationToken stoppingToken)
{
using var scope = Services.CreateScope();
var olmaOrderRepo =
scope.ServiceProvider.GetRequiredService <IRepository <Olma.Order> >();
var orders = olmaOrderRepo.FindByCondition(o =>
//Order created but not synchronized
(!o.IsDeleted && !o.SyncDate.HasValue)
//Order canceled but not synchronized
|| (!o.IsDeleted && o.SyncDate.HasValue && o.ChangedAt.HasValue && o.ChangedAt > o.SyncDate &&
o.Status == OrderStatus.CancellationRequested))
.Include(og => og.LoadingLocation).ThenInclude(loc => loc.Address)
.Include(og => og.CreatedBy).ThenInclude(u => u.Person)
.Include(og => og.ChangedBy).ThenInclude(u => u.Person)
.Include(og => og.DeletedBy).ThenInclude(u => u.Person)
.Include(og => og.LoadCarrier).Include(og => og.BaseLoadCarrier)
.Include(og => og.PostingAccount).ThenInclude(pa => pa.CustomerDivisions).ThenInclude(cd => cd.Customer)
.IgnoreQueryFilters().ToList();
var mapper = scope.ServiceProvider.GetRequiredService <IMapper>();
var synchronizationsService =
scope.ServiceProvider.GetRequiredService <ISynchronizationsService>();
foreach (var order in orders)
{
var ordersSyncRequest = new OrdersSyncRequest
{
OrderCreateSyncRequests = new List <OrderCreateSyncRequest>(),
OrderCancelSyncRequests = new List <OrderCancelSyncRequest>()
};
if (!order.IsDeleted && !order.SyncDate.HasValue)
{
ordersSyncRequest.OrderCreateSyncRequests.Add(
mapper.Map <OrderCreateSyncRequest>(order));
}
if (!order.IsDeleted && order.SyncDate.HasValue && order.ChangedAt.HasValue &&
order.ChangedAt > order.SyncDate && order.Status == OrderStatus.CancellationRequested)
{
ordersSyncRequest.OrderCreateSyncRequests.Add(
mapper.Map <Olma.Order, OrderCreateSyncRequest>(order));
}
var syncResult = await synchronizationsService.SendOrdersAsync(ordersSyncRequest);
if (syncResult.ResultType == ResultType.Ok)
{
order.SyncDate = DateTime.UtcNow;
olmaOrderRepo.Update(order);
olmaOrderRepo.Save();
}
}
await Task.Delay(30000, stoppingToken);
}
private async Task <IWrappedResponse> CancelAction(Rules.Order.Cancel.MainRule rule)
{
var order = rule.Context.Rules.OrderResourceRule.Context.Resource;
var request = rule.Context.Request;
if (IsDplEmployee)
{
var dplNote = Mapper.Map <Olma.EmployeeNote>(request.DplNote);
order.DplNotes.Add(dplNote);
order.Status = OrderStatus.Cancelled;
}
else
{
order.Status = OrderStatus.CancellationRequested;
}
_olmaOrderRepo.Save();
var orderCancelSyncRequest = Mapper.Map <Olma.Order, OrderCancelSyncRequest>(order);
orderCancelSyncRequest.IsApproved = IsDplEmployee;
// TODO generate string from all emplyoeenote fields
orderCancelSyncRequest.Note = IsDplEmployee ? request.DplNote.Text : request.Note;
var ordersSyncRequest = new OrdersSyncRequest
{
OrderCancelSyncRequests = new List <OrderCancelSyncRequest>
{
orderCancelSyncRequest
}
};
var syncResult = await _synchronizationsService.SendOrdersAsync(ordersSyncRequest);
if (syncResult.ResultType == ResultType.Ok)
{
order.SyncDate = DateTime.UtcNow;
}
_olmaOrderRepo.Save();
var responseOrder = Mapper.Map <Order>(order);
return(Updated(responseOrder));
}
private async Task <IWrappedResponse> CreateAction(Rules.OrderGroup.Create.MainRule rule)
{
Olma.OrderGroup orderGroup = new Olma.OrderGroup()
{
Orders = new List <Olma.Order>()
};
// create orders for order group
switch (rule.Context.OrderGroupsCreateRequest.QuantityType)
{
case OrderQuantityType.Load:
{
for (var i = 0; i < rule.Context.OrderGroupsCreateRequest.NumberOfLoads; i++)
{
Olma.Order order = Mapper.Map <Olma.Order>(rule.Context.OrderGroupsCreateRequest);
order.Status = OrderStatus.Pending;
orderGroup.Orders.Add(order);
}
break;
}
case OrderQuantityType.LoadCarrierQuantity:
{
Olma.Order order = Mapper.Map <Olma.Order>(rule.Context.OrderGroupsCreateRequest);
order.Status = OrderStatus.Pending;
orderGroup.Orders.Add(order);
break;
}
case OrderQuantityType.Stacks:
{
Olma.Order order = Mapper.Map <Olma.Order>(rule.Context.OrderGroupsCreateRequest);
order.Status = OrderStatus.Pending;
orderGroup.Orders.Add(order);
break;
}
default:
throw new ArgumentOutOfRangeException($"Unknown QuantityType: {rule.Context.OrderGroupsCreateRequest.QuantityType}");
}
bool transactionRolledBack = false;
IWrappedResponse <OrderMatch> orderMatchServiceResponse = null;
_olmaDbContext.Database.CreateExecutionStrategy().Execute(operation: () =>
{
using (_olmaDbContext.Database.BeginTransaction())
{
_olmaOrderGroupRepo.Create(orderGroup);
_olmaOrderGroupRepo.Save();
// this needs to happen after order is created in db as otherwise no orderGroupid exists
if (rule.Context.OrderGroupsCreateRequest.MatchLmsOrderGroupRowGuid.HasValue)
{
var order = orderGroup.Orders.Single();
var orderMatchQuantity = this.CalculateOrderMatchQuantities(order, order.StackHeightMax);
var orderMatchesCreateRequest = Mapper.Map <OrderMatchesCreateRequest>(order);
orderMatchesCreateRequest = Mapper.Map(orderMatchQuantity, orderMatchesCreateRequest);
if (rule.Context.OrderGroupsCreateRequest.Type == OrderType.Demand)
{
orderMatchesCreateRequest.SupplyOrderRowGuid = rule.Context.OrderGroupsCreateRequest.MatchLmsOrderGroupRowGuid.Value;
orderMatchesCreateRequest.DemandOrderRowGuid = order.RefLmsOrderRowGuid;
}
else
{
orderMatchesCreateRequest.DemandOrderRowGuid = rule.Context.OrderGroupsCreateRequest.MatchLmsOrderGroupRowGuid.Value;
orderMatchesCreateRequest.SupplyOrderRowGuid = order.RefLmsOrderRowGuid;
}
orderMatchServiceResponse = (IWrappedResponse <OrderMatch>)_orderMatchesService.Create(orderMatchesCreateRequest).Result;
if (orderMatchServiceResponse.ResultType != ResultType.Created)
{
_olmaDbContext.Database.RollbackTransaction();
transactionRolledBack = true;
}
else
{
_olmaDbContext.Database.CommitTransaction();
}
}
else
{
_olmaDbContext.Database.CommitTransaction();
}
}
});
if (transactionRolledBack)
{
return(orderMatchServiceResponse);
}
var orders = _olmaDbContext.Orders.Where(i => i.GroupId == orderGroup.Id)
.Include(og => og.LoadingLocation).ThenInclude(loc => loc.Address)
.Include(og => og.LoadingLocation.BusinessHours)
.Include(og => og.LoadingLocation.CustomerDivision).ThenInclude(cd => cd.Customer)
.Include(og => og.CreatedBy).ThenInclude(u => u.Person)
.Include(og => og.LoadCarrier)
.Include(og => og.BaseLoadCarrier)
.Include(og => og.PostingAccount).ThenInclude(pa => pa.CustomerDivisions)
.ThenInclude(cd => cd.Customer);
DateTime syncDate = DateTime.UtcNow;
foreach (var order in orders)
{
order.OrderNumber = await _numberSequencesService.GetProcessNumber(ProcessType.Order, order.Id);
var orderCreateSyncRequest = Mapper.Map <Olma.Order, OrderCreateSyncRequest>(order);
if (orderMatchServiceResponse != null)
{
switch (order.Type)
{
case OrderType.Demand:
orderCreateSyncRequest.RefLmsAvailabilityRowGuid = orderMatchServiceResponse.Data.RefLmsAvailabilityRowGuid;
orderCreateSyncRequest.RefLmsPermanentAvailabilityRowGuid = orderMatchServiceResponse.Data.RefLmsPermanentAvailabilityRowGuid;
break;
case OrderType.Supply:
orderCreateSyncRequest.RefLmsDeliveryRowGuid = orderMatchServiceResponse.Data.RefLmsDeliveryRowGuid;
orderCreateSyncRequest.RefLmsPermanentDeliveryRowGuid = orderMatchServiceResponse.Data.RefLmsPermanentDeliveryRowGuid;
break;
}
orderCreateSyncRequest.DigitalCode = orderMatchServiceResponse.Data.DigitalCode;
orderCreateSyncRequest.LoadCarrierQuantity = orderMatchServiceResponse.Data.LoadCarrierQuantity;
orderCreateSyncRequest.BaseLoadCarrierQuantity = orderMatchServiceResponse.Data.BaseLoadCarrierQuantity;
}
var ordersSyncRequest = new OrdersSyncRequest
{
OrderCreateSyncRequests = new List <OrderCreateSyncRequest>
{
orderCreateSyncRequest
}
};
var syncResult = await _synchronizationsService.SendOrdersAsync(ordersSyncRequest);
if (syncResult.ResultType == ResultType.Ok)
{
order.SyncDate ??= syncDate;
}
}
_olmaDbContext.SaveChanges();
var result = Mapper.Map <Olma.OrderGroup, OrderGroup>(orderGroup);
return(new WrappedResponse <OrderGroup>
{
ResultType = ResultType.Created,
Data = result
});
}
/// <summary>
/// Erzeugt eine Quittungen. Diese Action hat abhängigkeiten zum NumberSequencesService und zum PostingRequestsService.
/// </summary>
/// <param name="mainRule"></param>
/// <returns></returns>
private async Task <IWrappedResponse> CreateAction(Rules.LoadCarrierReceipts.Create.MainRule mainRule)
{
var request = mainRule.Context.Parent;
var printLanguageId = request.PrintLanguageId;
var loadCarrierReceipt = mainRule.Context.LoadCarrierReceipt;
var customerDivision = mainRule.Context.CustomerDivision;
var isSupply = mainRule.Context.IsSupply;
var targetRefLtmsAccountId = mainRule.Context.TargetRefLtmsAccountId;
var orderLoad = mainRule.Context.OrderLoad;
var refLtmsTransactionId = mainRule.Context.RefLtmsTransactionId;
var isSelfService = mainRule.Context.IsSelfService;
var documentType = mainRule.Context.DocumentType;
var lmsAvail2deli = mainRule.Context.LmsAvail2deli;
var documentNumber = _numberSequencesService
.GetDocumentNumber(documentType, request.CustomerDivisionId).Result;
mainRule.Context.LoadCarrierReceipt.Document.Number = documentNumber;
var strategy = _olmaDbContext.Database.CreateExecutionStrategy();
var result = await strategy.ExecuteAsync(async() =>
{
await using var ctxTransaction = await _olmaDbContext.Database.BeginTransactionAsync();
var strategyResult = _olmaLoadCarrierReceiptRepo
.Create <Olma.LoadCarrierReceipt, Olma.LoadCarrierReceipt, LoadCarrierReceipt>(
loadCarrierReceipt);
var reportGeneratorServiceResponse =
(IWrappedResponse <Report>)_reportGeneratorService.GenerateReportForLanguage(
strategyResult.Data.DocumentId, printLanguageId, request.PrintCount - 1,
request.PrintDateTimeOffset);
var downloadLink = (IWrappedResponse <string>) await _documentsService
.GetDocumentDownload(strategyResult.Data.DocumentId, DocumentFileType.Composite);
if (downloadLink.ResultType != ResultType.Ok)
{
await ctxTransaction.RollbackAsync();
return(new WrappedResponse <LoadCarrierReceipt>
{
ResultType = ResultType.Failed,
State = ErrorHandler.Create().AddMessage(new DocumentLinkError()).GetServiceState()
});
}
strategyResult.Data.DownloadLink = downloadLink.Data;
var postingRequestsCreateRequest = new PostingRequestsCreateRequest
{
Type = isSupply
? PostingRequestType.Credit
: PostingRequestType
.Charge, //HACK Only to fix UI, from LTMS WebApp viewpoint it would be a charge
ReferenceNumber = loadCarrierReceipt.Document?.Number,
Reason = PostingRequestReason.LoadCarrierReceipt,
LoadCarrierReceiptId = strategyResult.Data.Id,
IsSortingRequired = strategyResult.Data.IsSortingRequired,
DocumentFileName = reportGeneratorServiceResponse.Data.DocumentArchiveName,
IsSelfService = isSelfService,
Positions = loadCarrierReceipt.Positions.Select(lcr =>
new PostingRequestPosition
{
LoadCarrierId = lcr.LoadCarrierId,
LoadCarrierQuantity = lcr.LoadCarrierQuantity
}),
RefLtmsProcessId = Guid.NewGuid(),
RefLtmsTransactionId = refLtmsTransactionId ?? Guid.NewGuid(),
PostingAccountId = customerDivision.PostingAccountId.Value,
RefLtmsProcessTypeId =
isSupply ? (int)RefLtmsProcessType.Excemption : (int)RefLtmsProcessType.DepotAcceptance,
SourceRefLtmsAccountId =
isSupply ? customerDivision.PostingAccount.RefLtmsAccountId : targetRefLtmsAccountId,
DestinationRefLtmsAccountId = !isSupply
? customerDivision.PostingAccount.RefLtmsAccountId
: targetRefLtmsAccountId,
DigitalCode = loadCarrierReceipt.DigitalCode,
RefLmsBusinessTypeId = request.RefLmsBusinessTypeId,
RefLtmsTransactionRowGuid = request.RefLtmsTransactionRowGuid,
DeliveryNoteNumber = loadCarrierReceipt.DeliveryNoteNumber,
PickUpNoteNumber = loadCarrierReceipt.PickUpNoteNumber
};
var postingRequestsServiceResponse =
(IWrappedResponse <IEnumerable <PostingRequest> >) await _postingRequestsService
.Create(postingRequestsCreateRequest);
if (postingRequestsServiceResponse.ResultType != ResultType.Created)
{
await ctxTransaction.RollbackAsync();
return(new WrappedResponse <LoadCarrierReceipt>
{
ResultType = postingRequestsServiceResponse.ResultType,
State = postingRequestsServiceResponse.State
});
}
if (lmsAvail2deli != null)
{
var orderFulfillSyncRequest = new OrderFulfillSyncRequest
{
DigitalCode = loadCarrierReceipt.DigitalCode,
FulfillmentDateTime = DateTime.UtcNow,
RefLmsDeliveryRowGuid = lmsAvail2deli.Delivery.RowGuid,
RefLmsAvailabilityRowGuid = lmsAvail2deli.Availability.RowGuid
};
var ordersSyncRequest = new OrdersSyncRequest
{
OrderFulfillSyncRequests = new List <OrderFulfillSyncRequest>
{
orderFulfillSyncRequest
}
};
//Reine Sync-Fehler für Updates werden geloggt und müssen manuell behoben werden.
await _synchronizationsService.SendOrdersAsync(ordersSyncRequest);
}
await ctxTransaction.CommitAsync();
return(strategyResult);
});
return(result);
}
public async Task <IWrappedResponse> Cancel(int id, OrderLoadCancelRequest request)
{
#region security
// TODO add security
#endregion
var orderLoad = _olmaOrderLoadRepo.FindByCondition(o => o.Id == id)
.Include(i => i.Detail)
.Include(i => i.DplNotes)
.Include(o => o.Order)
.Include(o => o.CreatedBy)
.FirstOrDefault();
if (orderLoad == null)
{
return(NotFound <OrderLoad>(id));
}
var cancellableStates = new[] { OrderLoadStatus.Pending, OrderLoadStatus.TransportPlanned };
if (IsDplEmployee)
{
cancellableStates = cancellableStates.Append(OrderLoadStatus.CancellationRequested).ToArray();
}
if (!cancellableStates.Contains(orderLoad.Detail.Status))
{
return(BadRequest <OrderLoad>("OrderLoad is in a state that cannot be cancelled"));
}
var status = IsDplEmployee ? OrderLoadStatus.Canceled : OrderLoadStatus.CancellationRequested;
orderLoad.Detail.Status = status;
if (IsDplEmployee)
{
var dplNote = Mapper.Map <Olma.EmployeeNote>(request.DplNote);
orderLoad.DplNotes.Add(dplNote);
}
_olmaOrderLoadRepo.Save();
var orderCancelSyncRequest = Mapper.Map <Olma.OrderLoad, OrderCancelSyncRequest>(orderLoad);
orderCancelSyncRequest.Note = IsDplEmployee ? request.DplNote.Text : request.Note;
var ordersSyncRequest = new OrdersSyncRequest
{
OrderCancelSyncRequests = new List <OrderCancelSyncRequest>
{
orderCancelSyncRequest
}
};
var syncResult = await _synchronizationsService.SendOrdersAsync(ordersSyncRequest);
if (syncResult.ResultType == ResultType.Ok)
{
orderLoad.Order.SyncDate = DateTime.UtcNow;
}
_olmaOrderLoadRepo.Save();
var responseOrderLoad = Mapper.Map <OrderLoad>(orderLoad);
return(Updated(responseOrderLoad));
}
