private async Task <IWrappedResponse> CreateAction(Rules.BalanceTransfer.Create.MainRule rule)
{
var sourceAccount = rule.Context.SourceAccount;
var destinationAccount = rule.Context.DestinationAccount;
var loadCarrierId = (int)rule.Context.LoadCarrierId;
var quantity = (int)rule.Context.LoadCarrierQuantity;
var postingRequest = new PostingRequestsCreateRequest()
{
Type = PostingRequestType.Charge, //HACK Only to fix UI, from LTMS WebApp viewpoint it would be a credit
Reason = PostingRequestReason.Transfer,
RefLtmsProcessTypeId = (int)RefLtmsProcessType.BalanceTransfer,
Positions = new List <PostingRequestPosition>()
{
new PostingRequestPosition()
{
LoadCarrierId = loadCarrierId,
LoadCarrierQuantity = Math.Abs(quantity)
}
},
RefLtmsProcessId = Guid.NewGuid(),
RefLtmsTransactionId = Guid.NewGuid(),
PostingAccountId = sourceAccount.Id,
SourceRefLtmsAccountId = destinationAccount.RefLtmsAccountId, // on LTMS ViewPoint source and destination have to be switched
DestinationRefLtmsAccountId = sourceAccount.RefLtmsAccountId, // on LTMS ViewPoint source and destination have to be switched
Note = rule.Context.Parent.Note,
DplNote = rule.Context.Parent.DplNote
};
var response = (IWrappedResponse <IEnumerable <PostingRequest> >) await _postingRequestService.Create(postingRequest);
//To avoit breaking changes with UI
//Only one PostingRequest is returned
var result = new WrappedResponse <PostingRequest>()
{
ResultType = response.ResultType, Data = response.Data.First(), Errors = response.Errors,
Id = response.Id, Warnings = response.Warnings
};
;
return(result);
}
public async Task <IWrappedResponse> Create(PostingRequestsCreateRequest request)
{
var olmaPostingRequests = new List <Olma.PostingRequest>();
foreach (var postingRequestPosition in request.Positions)
{
var olmaPostingRequest = Mapper.Map <Olma.PostingRequest>(request);
olmaPostingRequest.LoadCarrierId = postingRequestPosition.LoadCarrierId;
olmaPostingRequest.LoadCarrierQuantity = postingRequestPosition.LoadCarrierQuantity;
olmaPostingRequest.SyncDate = DateTime.UtcNow;
_olmaPostingRequestRepo.Create(olmaPostingRequest);
_olmaPostingRequestRepo.Save();
var postingRequest = olmaPostingRequest;
olmaPostingRequest = _olmaPostingRequestRepo.FindByCondition(pr => pr.Id == postingRequest.Id)
.Include(lc => lc.LoadCarrier)
.Include(pa => pa.PostingAccount)
.FirstOrDefault();
if (olmaPostingRequest == null)
{
return(Failed <IEnumerable <PostingRequest> >());
}
if (string.IsNullOrEmpty(request.ReferenceNumber))
{
olmaPostingRequest.ReferenceNumber =
await _numberSequencesService.GetProcessNumber(ProcessType.PostingRequest,
olmaPostingRequest.Id);
}
olmaPostingRequests.Add(olmaPostingRequest);
}
var postingRequestsSyncRequest = new PostingRequestsSyncRequest
{
PostingRequestCreateSyncRequests = new List <PostingRequestCreateSyncRequest>()
};
var postingRequestCreateSyncRequest =
new PostingRequestCreateSyncRequest
{
IsSortingRequired = olmaPostingRequests.Select(i => i.IsSortingRequired).FirstOrDefault(),
Positions = olmaPostingRequests.Select(pr => new PostingRequestPosition
{
RefLtmsPalletId = pr.LoadCarrier.RefLtmsPalletId,
LoadCarrierQuantity = pr.LoadCarrierQuantity,
RefLtmsBookingRowGuid = pr.RowGuid
}),
CreditRefLtmsAccountId =
olmaPostingRequests.Select(pr => pr.DestinationRefLtmsAccountId).FirstOrDefault(),
DebitRefLtmsAccountId =
olmaPostingRequests.Select(pr => pr.SourceRefLtmsAccountId).FirstOrDefault(),
ReferenceNumber = olmaPostingRequests.Select(pr => pr.ReferenceNumber).FirstOrDefault(),
IssuedByRefLtmsAccountId = olmaPostingRequests.Select(pr => pr.PostingAccount.RefLtmsAccountId)
.FirstOrDefault(),
Note = olmaPostingRequests.Select(pr => pr.Note).FirstOrDefault(),
RefLtmsProcessId = olmaPostingRequests.Select(pr => pr.RefLtmsProcessId).FirstOrDefault(),
RefLtmsProcessType =
(RefLtmsProcessType)olmaPostingRequests.Select(pr => pr.RefLtmsProcessTypeId)
.FirstOrDefault(),
RefLtmsTransactionId = request.RefLtmsTransactionRowGuid ?? olmaPostingRequests.Select(pr => pr.RefLtmsTransactionId).FirstOrDefault(),
DocumentFileName = request.DocumentFileName,
IsSelfService = request.IsSelfService,
DigitalCode = request.DigitalCode,
DeliveryNoteNumber = request.DeliveryNoteNumber,
PickUpNoteNumber = request.PickUpNoteNumber,
RefLmsBusinessTypeId = request.RefLmsBusinessTypeId
};
var result =
Mapper.Map <IEnumerable <Olma.PostingRequest>, IEnumerable <PostingRequest> >(olmaPostingRequests);
postingRequestsSyncRequest.PostingRequestCreateSyncRequests.Add(postingRequestCreateSyncRequest);
var syncResult = await _synchronizationsService.SendPostingRequestsAsync(postingRequestsSyncRequest);
// Switch (override) Type and loadCarrierQuantity sign when quantity is negative to support Split Bookings
// PostingRequests have to have positive quantities all the time
if (olmaPostingRequests.Any(r => r.LoadCarrierQuantity < 0))
{
foreach (var postingRequest in olmaPostingRequests.Where(r => r.LoadCarrierQuantity < 0))
{
postingRequest.LoadCarrierQuantity = Math.Abs(postingRequest.LoadCarrierQuantity);
postingRequest.Type = PostingRequestType.Credit;
}
_olmaPostingRequestRepo.Save();
}
if (syncResult.ResultType != ResultType.Ok)
{
return(new WrappedResponse
{
ResultType = ResultType.Failed
});
}
return(Created(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 Task <ActionResult <IEnumerable <PostingRequest> > > Post([FromBody] PostingRequestsCreateRequest request)
{
return(this._postingRequestsService.Create(request).Convert <IEnumerable <PostingRequest> >(this));
}
public async Task <IWrappedResponse> Create(LoadCarrierSortingCreateRequest request)
{
var loadCarrierReceipt = _olmaLoadCarrierReceiptRepo.FindByCondition(r => r.Id == request.LoadCarrierReceiptId)
.Include(r => r.Positions)
.Include(r => r.PostingAccount)
.Include(r => r.PostingRequests)
.Include(r => r.Document)
.Single();
var loadCarrierSorting = Mapper.Map <Olma.LoadCarrierSorting>(request);
foreach (var position in request.Positions)
{
var receiptPosition = loadCarrierReceipt.Positions.Single(p => p.LoadCarrierId == position.LoadCarrierId);
var sortingPosition = loadCarrierSorting.Positions.Single(p => p.LoadCarrierId == position.LoadCarrierId);
sortingPosition.Outputs = new List <Olma.LoadCarrierSortingResultOutput>();
var inputQuantity = receiptPosition.LoadCarrierQuantity;
sortingPosition.InputQuantity = inputQuantity;
foreach (var output in position.Outputs)
{
var inputLoadCarrier = _olmaLoadCarrierRepo.GetByKey(position.LoadCarrierId);
var outputLoadCarrier = _olmaLoadCarrierRepo.FindByCondition(l =>
l.TypeId == inputLoadCarrier.TypeId && l.QualityId == output.LoadCarrierQualityId).Single();
var _output = new Olma.LoadCarrierSortingResultOutput()
{
LoadCarrierId = outputLoadCarrier.Id,
LoadCarrierQuantity = output.Quantity
};
sortingPosition.Outputs.Add(_output);
}
var sumOutputQuantities = sortingPosition.Outputs.Sum(o => o.LoadCarrierQuantity);
if (sumOutputQuantities > inputQuantity)
{
throw new ArgumentException("Sum of output quantities does not match input");
}
sortingPosition.RemainingQuantity = inputQuantity - sumOutputQuantities;
}
var strategy = _olmaDbContext.Database.CreateExecutionStrategy();
var result = await strategy.ExecuteAsync(async() =>
{
await using var ctxTransaction = await _olmaDbContext.Database.BeginTransactionAsync();
// Create LoadCarrierSorting
var loadCarrierSortingResult = _olmaLoadCarrierSortingRepo
.Create <Olma.LoadCarrierSorting, Olma.LoadCarrierSorting, LoadCarrierSorting>(loadCarrierSorting);
// Create PostingRequestsCreateRequest
#region PostingRequestsCreateRequest
var postingAccount = loadCarrierReceipt.PostingAccount;
foreach (var receiptPosition in loadCarrierReceipt.Positions)
{
var sortingPosition =
loadCarrierSorting.Positions.Single(p => p.LoadCarrierId == receiptPosition.LoadCarrierId);
var postingRequestsCreateRequest = new PostingRequestsCreateRequest
{
Type = PostingRequestType.Charge, //HACK Only to fix UI, from LTMS WebApp viewpoint it would be a charge
ReferenceNumber = loadCarrierReceipt.Document?.Number,
Reason = PostingRequestReason.LoadCarrierReceipt,
LoadCarrierReceiptId = loadCarrierReceipt.Id,
RefLtmsProcessId = loadCarrierReceipt.PostingRequests.First().RefLtmsProcessId,
RefLtmsTransactionId = Guid.NewGuid(),
PostingAccountId = postingAccount.Id,
RefLtmsProcessTypeId = (int)RefLtmsProcessType.Sorting,
SourceRefLtmsAccountId = postingAccount.RefLtmsAccountId,
DestinationRefLtmsAccountId = postingAccount.RefLtmsAccountId,
DeliveryNoteNumber = loadCarrierReceipt.DeliveryNoteNumber,
PickUpNoteNumber = loadCarrierReceipt.PickUpNoteNumber
};
var debitPosition =
new PostingRequestPosition //TODO: make it support 1 + n positions
{
LoadCarrierId = sortingPosition.LoadCarrierId,
LoadCarrierQuantity = -sortingPosition.InputQuantity
};
var creditPositions = sortingPosition.Outputs.Select(o =>
new PostingRequestPosition
{
LoadCarrierId = o.LoadCarrierId,
LoadCarrierQuantity = o.LoadCarrierQuantity
}
);
var positions = new List <PostingRequestPosition>()
{
debitPosition
};
positions.AddRange(creditPositions);
postingRequestsCreateRequest.Positions = positions;
var postingRequestsServiceResponse =
(IWrappedResponse <IEnumerable <PostingRequest> >) await _postingRequestsService
.Create(postingRequestsCreateRequest);
if (postingRequestsServiceResponse.ResultType != ResultType.Created)
{
await ctxTransaction.RollbackAsync();
return(new WrappedResponse <LoadCarrierSorting>
{
ResultType = postingRequestsServiceResponse.ResultType,
State = postingRequestsServiceResponse.State
});
}
}
#endregion
//Set IsSortingCompleted Flag on LoadCarrierReceipt
if (loadCarrierSorting.Positions.Count == loadCarrierReceipt.Positions.Count &&
loadCarrierSorting.Positions.SelectMany(p => p.Outputs).Sum(o => o.LoadCarrierQuantity) == loadCarrierReceipt.Positions.Sum(p => p.LoadCarrierQuantity))
{
loadCarrierReceipt.IsSortingCompleted = true;
_olmaLoadCarrierRepo.Save();
}
// Commit
await ctxTransaction.CommitAsync();
return(loadCarrierSortingResult);
});
return(Created(result.Data));
}
private async Task <IWrappedResponse> CreateAction(Rules.Vouchers.Create.MainRule rule)
{
var voucher = rule.Context.Rules.Voucher.Context.Voucher;
var digitalCode = rule.Context.ExpressCode;
#region map partner to CustomerPartner
// if not exists: CustomerPartner has to copied from global Partner and stored in special 'ExpressCode' PartnerDirectory
var partnerDictionary = new Dictionary <EntryType, Guid>
{
{ EntryType.Recipient, rule.Context.RecipientGuid },
{ EntryType.Shipper, rule.Context.ShipperGuid },
{ EntryType.SubShipper, rule.Context.SubShipperGuid },
{ EntryType.Supplier, rule.Context.SupplierGuid }
};
//If Guid identifies a Partner, gets the matching CustomerPartner or creates a new one if does not exist
var customerPartnerDictionary = ConvertToCustomerPartner(partnerDictionary);
foreach (var customerPartner in customerPartnerDictionary)
{
switch (customerPartner.Key)
{
case EntryType.Default:
break;
case EntryType.Recipient:
voucher.Recipient = customerPartner.Value;
break;
case EntryType.Supplier:
voucher.Supplier = customerPartner.Value;
break;
case EntryType.Shipper:
voucher.Shipper = customerPartner.Value;
break;
case EntryType.SubShipper:
voucher.SubShipper = customerPartner.Value;
break;
default:
return(new WrappedResponse
{
ResultType = ResultType.Failed,
State = ErrorHandler.Create()
.AddMessage(new CustomerPartnerNotFoundError())
.GetServiceState()
});
}
}
#endregion
var documentType = rule.Context.Rules.DocumentType.Context.DocumentType;
voucher.ReceivingCustomerId = voucher.Recipient.Partner?.Customer?.Id;
voucher.ReceivingPostingAccountId = voucher.Recipient.Partner?.DefaultPostingAccountId;
var strategy = _olmaDbContext.Database.CreateExecutionStrategy();
var result = await strategy.ExecuteAsync(operation : async() =>
{
await using var ctxTransaction = await _olmaDbContext.Database.BeginTransactionAsync();
var documentNumber =
_numberSequencesService.GetDocumentNumber(documentType, rule.Context.CustomerDivisionId);
var typeId = _documentTypesService.GetIdByDocumentType(documentType);
voucher.Document = new Olma.Document()
{
Number = documentNumber.Result,
TypeId = typeId,
StateId = 1,
CustomerDivisionId = rule.Context.CustomerDivisionId,
IssuedDateTime = DateTime.UtcNow,
LanguageId = rule.Context.PrintLanguageId,
};
var wrappedResponse = _olmaVoucherRepo.Create <Olma.Voucher, Olma.Voucher, Voucher>(voucher);
var reportGeneratorServiceResponse = _reportGeneratorService.GenerateReportForLanguage(
wrappedResponse.Data.DocumentId,
rule.Context.PrintLanguageId,
rule.Context.PrintCount - 1,
rule.Context.PrintDateTimeOffset);
if (reportGeneratorServiceResponse.ResultType != ResultType.Created)
{
await ctxTransaction.RollbackAsync();
return(new WrappedResponse <Voucher>
{
ResultType = ResultType.Failed,
State = ErrorHandler.Create().AddMessage(new GenerateReportError()).GetServiceState()
});
}
var downloadLink =
(WrappedResponse <string>) await _documentsService.GetDocumentDownload(
wrappedResponse.Data.DocumentId, DocumentFileType.Composite);
if (downloadLink.ResultType != ResultType.Ok)
{
await ctxTransaction.RollbackAsync();
return(new WrappedResponse <Voucher>
{
ResultType = ResultType.Failed,
State = ErrorHandler.Create().AddMessage(new DocumentLinkError()).GetServiceState()
});
}
wrappedResponse.Data.DownloadLink = downloadLink.Data;
var refLtmsTransactionId = Guid.NewGuid();
#region Send Voucher to LTMS
//Make sure voucher.Position.Loadcarrier is loaded, because RefLtmsPalettId is need when
//mapping to VoucherCreateSyncRequest
foreach (var position in voucher.Positions)
{
_olmaDbContext.Entry(position).Reference(c => c.LoadCarrier).Load();
}
//Make sure voucher.ReasonType is loaded, because RefLtmsReasonTypeId is needed when mapping to VoucherCreateSyncRequest
_olmaDbContext.Entry(voucher).Reference(r => r.ReasonType).Load();
var voucherCreateRequest = Mapper.Map <VoucherCreateSyncRequest>(voucher);
var voucherSyncRequest = new VoucherSyncRequest {
VoucherCreateSyncRequest = voucherCreateRequest
};
voucherSyncRequest.VoucherCreateSyncRequest.RefLtmsTransactionRowGuid = refLtmsTransactionId;
var synchronizationsServiceResponse =
await _synchronizationsService.SendVoucherRequestsAsync(voucherSyncRequest);
if (synchronizationsServiceResponse.ResultType == ResultType.Failed)
{
await ctxTransaction.RollbackAsync();
return(new WrappedResponse <Voucher>
{
ResultType = ResultType.Failed,
State = ErrorHandler.Create().AddMessage(new TechnicalError()).GetServiceState()
});
}
#endregion
if (rule.Context.Type == VoucherType.Direct && rule.Context.CustomerDivision != null)
{
var postingRequestsCreateRequest = new PostingRequestsCreateRequest
{
Type = PostingRequestType.Charge, //HACK Only to fix UI, from LTMS W
ReferenceNumber = voucher.Document.Number,
Reason = PostingRequestReason.Voucher,
VoucherId = wrappedResponse.Data.Id,
RefLtmsProcessId = Guid.NewGuid(),
RefLtmsProcessTypeId = (int)RefLtmsProcessType.DirectBooking,
RefLtmsTransactionId = refLtmsTransactionId,
// ReSharper disable once PossibleInvalidOperationException -> secured by rule
PostingAccountId = rule.Context.CustomerDivision.PostingAccountId.Value,
// ReSharper disable once PossibleInvalidOperationException -> secured by rule
SourceRefLtmsAccountId =
(int)voucher.Recipient.Partner?.DefaultPostingAccount.RefLtmsAccountId,
DestinationRefLtmsAccountId =
rule.Context.CustomerDivision.PostingAccount.RefLtmsAccountId,
Positions = voucher.Positions.Select(v => new PostingRequestPosition()
{
LoadCarrierId = v.LoadCarrierId,
LoadCarrierQuantity = v.LoadCarrierQuantity
}),
Note = voucher.Shipper?.CompanyName,
DigitalCode = digitalCode
};
var postingRequestsServiceResponse =
(IWrappedResponse <IEnumerable <PostingRequest> >) await _postingRequestsService.Create(
postingRequestsCreateRequest);
if (postingRequestsServiceResponse.ResultType != ResultType.Created)
{
await ctxTransaction.RollbackAsync();
return(new WrappedResponse <Voucher>
{
ResultType = ResultType.Failed,
State = ErrorHandler.Create().AddMessage(new TechnicalError()).GetServiceState()
});
}
}
await ctxTransaction.CommitAsync();
return(wrappedResponse);
});
return(result);
}