public async Task <IEnumerable <ReferentialCounterPartySearchResultDto> > SearchReferentialCounterPartyListAsync(string company, EntitySearchRequest searchRequest, bool showDuplicateCounterpartyData = false)
{
var grideCode = "referentialCounterPartiesGrid";
var grid = await _gridQueries.GetGrid(grideCode, company);
if (grid == null)
{
throw new AtlasTechnicalException($"No grid configuration found for {grideCode}.");
}
if (grid.MaxNumberOfRecords.HasValue && grid.MaxNumberOfRecords < searchRequest.Limit)
{
searchRequest.Limit = grid.MaxNumberOfRecords;
}
var dynamicQueryDefinition = AutoMapper.Mapper.Map <DynamicQueryDefinition>(searchRequest);
var columnConfiguration = AutoMapper.Mapper.Map <List <ColumnConfiguration> >(grid.Columns);
var companyDate = await _systemDateTimeService.GetCompanyDate(company);
var buildQueryResult = DynamicQueryBuilder.BuildQuery(company, _identityService.GetUserName(), dynamicQueryDefinition, "[Configuration].[Vw_ReferentialCounterPartyListAndSearch]", columnConfiguration, companyDate);
var referentialCounterPartySearchResult = await ExecuteDynamicQueryAsync <ReferentialCounterPartySearchResultDto>(buildQueryResult.Sql, buildQueryResult.Parameters);
if (showDuplicateCounterpartyData == false)
{
var result = referentialCounterPartySearchResult.ToList();
return(result.GroupBy(counterpartyData => counterpartyData.CounterpartyCode).Select(duplicateRow => duplicateRow.First()));
}
return(referentialCounterPartySearchResult.ToList());
}
public async Task <Unit> Handle(ProcessInterfaceDataChangeLogsRequest request, CancellationToken cancellationToken)
{
var paymentRequestStatus = await _paymentRequestRepository.GetPaymentRequestStatus((int)BusinessApplicationType.TRAX, request.CompanyId, null, request.TransactionDocumentId);
if (paymentRequestStatus == null || ((InterfaceStatus)paymentRequestStatus.DocumentStatus == InterfaceStatus.None || (InterfaceStatus)paymentRequestStatus.DocumentStatus == InterfaceStatus.TransmitError))
{
long eventId;
_unitOfWork.BeginTransaction();
var eventdata = new Event((int)EventSubType.PaymentRequest, request.CashId, request.CashDocumentRef, (int)InterfaceStatus.ReadyToTransmit, request.CompanyId, null);
try
{
eventId = await _interfaceEventLogService.CreateEventAsync(eventdata);
// Insert record into InterfaceStatus
await ProcessStatusUpdate(request, InterfaceStatus.ReadyToTransmit, "Ready To Transmit");
_unitOfWork.Commit();
}
catch
{
_unitOfWork.Rollback();
throw;
}
var companyDate = await _systemDateTimeService.GetCompanyDate(request.CompanyId);
_logger.LogInformation("Cash with DocumentId {Atlas_PaymentRequestCashDocumentId} having status {Atlas_PaymentRequestStatus} is sent to Treasury System at {Atlas_DateTime}", request.CashDocumentRef, InterfaceStatus.ReadyToTransmit, companyDate);
var paymentRequestMessage = await _paymentRequestRepository.GetTRAXMessageAsync(request.CashId, request.CompanyId);
var eventHistory = new EventHistory(eventId, "Message Generated", paymentRequestMessage, null, null);
_unitOfWork.BeginTransaction();
try
{
await _interfaceEventLogService.CreateEventHistoryAsync(eventHistory, request.CompanyId);
_unitOfWork.Commit();
}
catch
{
_unitOfWork.Rollback();
throw;
}
var legalEntityCode = await _paymentRequestRepository.GetLegalEntityCodeAsync(request.CompanyId, request.BusinessApplicationType);
await SendBusinessObjectToInterface(request, paymentRequestMessage, legalEntityCode, eventId);
}
else
{
_logger.LogWarning("Invalid Document ({Atlas_DocumentReference}) status {Atlas_InterfaceStatus}.", request.DocumentReference, ((InterfaceStatus)paymentRequestStatus.DocumentStatus).ToString());
}
return(Unit.Value);
}
protected virtual async Task <IEnumerable <T> > SearchAsync <T>(string company, EntitySearchRequest searchRequest, string gridCode, string viewName, bool skipPaginationLimit = false)
{
var grid = await _gridQueries.GetGrid(gridCode, company);
if (grid == null)
{
throw new AtlasTechnicalException($"No grid configuration found for {gridCode}.");
}
if (!skipPaginationLimit && grid.MaxNumberOfRecords.HasValue && grid.MaxNumberOfRecords < searchRequest.Limit)
{
searchRequest.Limit = grid.MaxNumberOfRecords;
}
var dynamicQueryDefinition = _mapper.Map <DynamicQueryDefinition>(searchRequest);
var columnConfiguration = _mapper.Map <List <ColumnConfiguration> >(grid.Columns);
var companyDate = await _systemDateTimeService.GetCompanyDate(company);
var userDepartments = (await _userService.GetUserByIdAsync(_identityService.GetUserAtlasId(), false)).Permissions
.FirstOrDefault(permission => permission.CompanyId == company)
?.Departments.Select(department => department.DepartmentId).ToList();
var dataVersionId = searchRequest.DataVersionId ?? await _systemDateTimeService.GetCompanyCurrentDataVersionId(company);
var buildQueryResult = DynamicQueryBuilder.BuildQuery(company, _identityService.GetUserName(), dynamicQueryDefinition, viewName, columnConfiguration, companyDate, dataVersionId, userDepartments);
var results = await ExecuteDynamicQueryAsync <T>(buildQueryResult.Sql, buildQueryResult.Parameters);
return(results.ToList());
}
public async Task <long> Handle(GenerateContractAdviceCommand request, CancellationToken cancellationToken)
{
var authorizationResult = await _authorizationService.AuthorizeAsync(_identityService.GetUser(), Policies.GenerateContractAdvicePolicy);
if (!authorizationResult.Succeeded)
{
throw new AtlasSecurityException("One or more privileges are required to perform this action.");
}
var template = await _physicalDocumentGenerationService.GetTemplateByPath(request.DocumentTemplatePath, PhysicalDocumentType.ContractAdvice, request.CompanyId);
if (template == null)
{
throw new AtlasBusinessException($"Cannot find requested template: {request.DocumentTemplatePath}");
}
var contractAdviceInfo = await _documentRepository.GetContractAdviceInfoAsync(request.SectionId, request.CompanyId);
var reportParameters = new Dictionary <string, string>
{
{ "CompanyId", request.CompanyId },
{ "PhysicalContractId", contractAdviceInfo.PhysicalContractId.ToString(CultureInfo.InvariantCulture) }
};
var documentResponse = await _physicalDocumentGenerationService.GenerateDocument(request.DocumentTemplatePath, reportParameters, PhysicalDocumentFormat.WORDOPENXML);
var companyDate = await _systemDateTimeService.GetCompanyDate(request.CompanyId);
string counterPartyCode = contractAdviceInfo.Type == ContractType.Purchase ? contractAdviceInfo.SellerCode : contractAdviceInfo.BuyerCode;
var documentName = $"{companyDate.ToString("yyyyMMdd_HHMMss", CultureInfo.InvariantCulture)}_{request.CompanyId}_CONADV_{request.SectionId}_PREVIEW_{counterPartyCode}_{_identityService.GetUserName()}.{documentResponse.Extension}";
// Save document in database
var documentId = await _physicalDocumentStorageService.UploadDocument(
new UploadDocumentParameters
{
CompanyId = request.CompanyId,
DocumentName = documentName,
File = documentResponse.Result,
DocumentTemplatePath = template.Path,
PhysicalDocumentTypeId = PhysicalDocumentType.ContractAdvice,
PhysicalDocumentStatus = PhysicalDocumentStatus.New,
RecordId = request.SectionId,
TableId = request.TableId,
IsDraft = true
});
_logger.LogInformation("Document with id {Atlas_DocumentId} has been created by user {Atlas_UserId}.", documentId, _identityService.GetUserName());
return(documentId);
}
public async Task <int> Handle(CreateReportCriteriasCommand request, CancellationToken cancellationToken)
{
_unitOfWork.BeginTransaction();
try
{
var grid = await _gridQueries.GetGrid(request.ReportCriterias.GridName, request.Company);
if (grid == null)
{
throw new Exception($"No grid configuration found for {request.ReportCriterias.GridName}.");
}
var dynamicQueryDefinition = Mapper.Map <DynamicQueryDefinition>(request.ReportCriterias);
var columnConfiguration = Mapper.Map <List <ColumnConfiguration> >(grid.Columns);
var companyDate = await _systemDateTimeService.GetCompanyDate(request.Company);
var criterias = DynamicQueryBuilder.BuildReportFilters(dynamicQueryDefinition, columnConfiguration, companyDate);
ReportPredicate predicate = new ReportPredicate
{
CompanyId = request.Company,
Criterias = criterias.Select(c => new ReportCriteria {
Value = c.Item1, TableAlias = c.Item2
})
};
var predicateId = await _reportRepository.CreateReportCriteriasAsync(predicate);
_unitOfWork.Commit();
_logger.LogInformation("New report criterias created with id {Atlas_PredicateId}.", predicateId);
return(predicateId);
}
catch
{
_unitOfWork.Rollback();
throw;
}
}
public async Task <Unit> Handle(ProcessHeldAndMappingErrorDocumentCommand request, CancellationToken cancellationToken)
{
_unitOfWork.BeginTransaction();
try
{
var companyDate = await _systemDateTimeService.GetCompanyDate(request.Company);
IEnumerable <AccountingDocument> accountingDocuments = await _accountingQueries.GetAccountingDocumentInHeldAndMappingErrorState(request.Company);
foreach (AccountingDocument accountingDocument in accountingDocuments)
{
await CommonRules.CalculateFunctionalAndStatutoryCurrencyAccountingLine(_foreignExchangeRateService, accountingDocument);
AccountingSetupDto accountingSetup = await _accountingQueries.GetAccountingSetup((int)accountingDocument.TransactionDocumentTypeId, request.Company);
accountingDocument.StatusId = await ReturnAccountingDocumentStatus(accountingDocument, companyDate, request.Company, accountingSetup);
await _accountingDocumentRepository.UpdateAccountingDocument(accountingDocument, request.Company);
if (accountingDocument.StatusId == PostingStatus.Authorised)
{
bool postOpClosedPolicy = await CommonRules.CheckPrivileges(_authorizationService, _identityService);
await EnqueuePostingProcessorMessage(accountingDocument.AccountingId, request.Company, postOpClosedPolicy);
}
}
_unitOfWork.Commit();
}
catch
{
_unitOfWork.Rollback();
throw;
}
return(Unit.Value);
}
private async Task AuthorizeForPosting(List <long> listOfDocId, string company, bool postOpClosedPolicy)
{
List <AccountingDocument> accountDocumentsDto = (await _accountingDocumentRepository.GetAccountingDocumentsByAccountingIdsAsync(listOfDocId, company)).ToList();
var companyDate = await _systemDateTimeService.GetCompanyDate(company);
foreach (AccountingDocument accountingDocumentDto in accountDocumentsDto)
{
await CommonRules.CalculateFunctionalAndStatutoryCurrencyAccountingLine(_foreignExchangeRateService, accountingDocumentDto);
AccountingSetupDto accountingSetup = await _accountingQueries.GetAccountingSetup((int)accountingDocumentDto.TransactionDocumentTypeId, company);
accountingDocumentDto.StatusId = await CommonRules.ReturnAccountingDocumentStatus(_accountingQueries, accountingDocumentDto, companyDate, company, accountingSetup);
await _accountingDocumentRepository.UpdateAccountingDocumentStatutoryAndFunctionalCurrencyAmounts(company, accountingDocumentDto);
}
var listOfAuthorizedDocument = accountDocumentsDto.Where(x => x.StatusId == PostingStatus.Authorised).ToList();
foreach (AccountingDocument accountingDocument in listOfAuthorizedDocument)
{
await EnqueuePostingProcessorMessage(accountingDocument.AccountingId, company, postOpClosedPolicy);
}
}
public async Task <Unit> Handle(UpdateSectionTrafficCommand request, CancellationToken cancellationToken)
{
_unitOfWork.BeginTransaction();
try
{
var sectionTraffic = ConvertToSectionTraffic(request);
var authorizationResult = await _authorizationService.AuthorizeAsync(_identityService.GetUser(), sectionTraffic, Policies.CharterPolicy);
var vesselNamePolicyResult = await _authorizationService.AuthorizeAsync(_identityService.GetUser(), sectionTraffic, Policies.VesselNamePolicy);
var blDatePolicyResult = await _authorizationService.AuthorizeAsync(_identityService.GetUser(), sectionTraffic, Policies.BlDatePolicy);
var blReferencePolicyResult = await _authorizationService.AuthorizeAsync(_identityService.GetUser(), sectionTraffic, Policies.BlReferencePolicy);
var quantityForTrafficPolicyResult = await _authorizationService.AuthorizeAsync(_identityService.GetUser(), sectionTraffic, Policies.QuantityForTrafficPolicy);
if (authorizationResult.Succeeded || vesselNamePolicyResult.Succeeded || blDatePolicyResult.Succeeded || blReferencePolicyResult.Succeeded || quantityForTrafficPolicyResult.Succeeded)
{
if (request.DataVersionId != null)
{
var freezeDate = await _freezeRepository.GetFreezeNotClosedAsync(request.CompanyId, request.DataVersionId.Value);
if (freezeDate == null)
{
throw new AtlasBusinessException($"Contracts cannot be updated in a freeze if the month is closed.");
}
}
var companyDate = await _systemDateTimeService.GetCompanyDate(request.CompanyId);
if (request.BLDate != null && request.BLDate.Value.Date > companyDate.Date)
{
throw new AtlasBusinessException($"BL Date cannot be in the future. Bl Date: {request.BLDate.Value.Date}. Company date: {companyDate}.");
}
await _charterRepository.UpdateSectionTrafficDetailsAsync(sectionTraffic, request.CompanyId, request.DataVersionId);
if (request.DataVersionId != null)
{
await InsertFreezeRecalcProcessQueue(request.SectionId, request.DataVersionId, request.CompanyId);
}
_unitOfWork.Commit();
_logger.LogInformation("Section Traffic with id {Atlas_SectionId} updated.", request.SectionId);
}
else
{
throw new AtlasSecurityException("One or more privileges are required to perform this action.");
}
return(Unit.Value);
}
catch
{
_unitOfWork.Rollback();
throw;
}
}
public async Task <ActionResult <string> > GetCompanyDate(string companyId)
{
var companyDate = await _systemDateTimeService.GetCompanyDate(companyId);
return(Ok(companyDate.Date.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)));
}
public async Task <IEnumerable <SectionReference> > Handle(CreatePhysicalFixedPricedContractCommand request, CancellationToken cancellationToken)
{
List <SectionReference> sectionReferences = new List <SectionReference>();
_unitOfWork.BeginTransaction();
try
{
if (request.ContractReference?.Length > 0)
{
request.ContractReference = request.ContractReference.PadLeft(7, '0');
}
var companyDate = await _systemDateTimeService.GetCompanyDate(request.CompanyId);
if (request.ContractDate.Date > companyDate.Date)
{
throw new AtlasBusinessException($"Contract date cannot be in the future. Contract date: {request.ContractDate.Date}. Company date: {companyDate}.");
}
if (request.DataVersionId != null)
{
var freezeDate = await _freezeRepository.GetFreezeNotClosedAsync(request.CompanyId, request.DataVersionId.Value);
if (freezeDate == null)
{
throw new AtlasBusinessException($"Contracts cannot be created in a freeze if the month is closed.");
}
if (request.ContractReference == null)
{
throw new AtlasBusinessException($"Contract reference is mandatory in a frozen database.");
}
}
await PhysicalContractCommonRules.ValidatePhysicalContract(request, _identityService, _masterDataService, _userService, _systemDateTimeService);
var user = _identityService.GetUserName();
request.CreatedBy = user;
var physicalFixedPricedContract = _mapper.Map <Section>(request);
var company = await _masterDataService.GetCompanyByIdAsync(request.CompanyId);
if (company.IsProvinceEnable)
{
physicalFixedPricedContract.ProvinceId = company.DefaultProvinceId;
physicalFixedPricedContract.BranchId = company.DefaultBranchId;
}
else
{
physicalFixedPricedContract.ProvinceId = null;
physicalFixedPricedContract.BranchId = null;
}
// At least one contract has to be always created
physicalFixedPricedContract.NumberOfContract = (request.NumberOfContracts > 0) ? request.NumberOfContracts : 1;
physicalFixedPricedContract.IsInterco = request.IsInterco;
if (!string.IsNullOrWhiteSpace(physicalFixedPricedContract.OtherReference))
{
physicalFixedPricedContract.EstimatedMaturityDate = null;
}
physicalFixedPricedContract.EstimatedMaturityDate = await CalculateEstimatedMaturityDate(physicalFixedPricedContract, request.CompanyId);
var references = (await _tradeRepository.CreatePhysicalContractAsImageAsync(physicalFixedPricedContract)).ToList();
sectionReferences.AddRange(references);
foreach (var item in references)
{
if (item.SectionId > 0 && item.Quantity > 0 && physicalFixedPricedContract.Costs.Any())
{
foreach (var costItem in physicalFixedPricedContract.Costs)
{
costItem.CompanyId = request.CompanyId;
costItem.SectionId = item.SectionId;
costItem.DataVersionId = item.DataVersionId;
}
// check the business rule for PriceUnitId.
await _costRepository.AddCostsAsync(physicalFixedPricedContract.Costs, request.CompanyId, request.DataVersionId);
}
// request.ChildSections would not be null if only it is Imaging the trade and we have selected Image Splits/tranche option as well
if (request.ChildSections != null)
{
if (item.SectionId > 0 && request.ChildSections.Any())
{
CreateSplitCommand splitRequest = new CreateSplitCommand();
splitRequest.ChildSections = request.ChildSections;
splitRequest.ChildSections.ToList().ForEach(section => section.OriginalQuantity = 0);
splitRequest.CompanyId = request.CompanyId;
splitRequest.OriginalQuantity = request.Quantity;
splitRequest.Quantity = request.Quantity;
var sectionTrancheContract = _mapper.Map <SectionDeprecated>(splitRequest);
sectionTrancheContract.SectionId = item.SectionId;
sectionTrancheContract.ContractLabel = item.ContractLabel;
foreach (var splitTrancheItem in sectionTrancheContract.ChildSections)
{
splitTrancheItem.SectionId = 0;
splitTrancheItem.ContractId = item.PhysicalContractId;
splitTrancheItem.SectionOriginId = (int)item.SectionId;
splitTrancheItem.EstimatedMaturityDate = physicalFixedPricedContract.EstimatedMaturityDate;
}
bool isTradeImage = true;
var splitTranchReferences = await _tradeRepository.CreateTrancheSplitAsync(sectionTrancheContract, request.CompanyId, isTradeImage);
// Inserting cost while creating an Image of a trade,if available
foreach (var childItem in splitTranchReferences)
{
if (request.ChildSections.First().Costs != null)
{
var childCosts = request.ChildSections.First().Costs;
foreach (var costItem in childCosts)
{
costItem.CompanyId = request.CompanyId;
costItem.SectionId = childItem.SectionId;
costItem.DataVersionId = childItem.DataVersionId;
}
await _costRepository.AddCostsAsync(childCosts, request.CompanyId, request.DataVersionId);
}
}
}
}
if (request.IsInterco)
{
sectionReferences = await CreateIntercoContractOnCreateContract(request, physicalFixedPricedContract, references, sectionReferences);
}
if (request.DataVersionId != null)
{
// this might be incorrect. This is due to the code that is written above where you can create multiple contracts in your Current db with Image
await InsertFreezeRecalcProcessQueue(references[0].SectionId, request.DataVersionId, request.CompanyId);
}
}
_unitOfWork.Commit();
_logger.LogInformation("New physical contract with id {Atlas_ContractLabel} created.", references[0].ContractLabel);
return(sectionReferences);
}
catch
{
_unitOfWork.Rollback();
throw;
}
}
public async Task <Unit> Handle(ProcessInterfaceDataChangeLogsRequest request, CancellationToken cancellationToken)
{
int tAorJLTypeId = 0;
// There should be no record in DB the first time.
var docStatus = await _accountingInterfaceRepository.GetDocumentStatus((int)BusinessApplicationType.AX, request.CompanyId, null, request.TransactionDocumentId, request.DocumentId);
var docReference = await _accountingInterfaceRepository.GetDocumentReferenceByAccountingId(request.DocumentId, (int)request.DocumentTypeId, request.CompanyId);
if (docStatus == InterfaceStatus.None || docStatus == InterfaceStatus.TransmitError)
{
long eventId;
if (request.DocumentTypeId == DocumentType.ManualTemporaryAdjustment)
{
tAorJLTypeId = await _accountingInterfaceRepository.GetTATypeIdAsync(request.TransactionDocumentId, request.DocumentTypeId, request.CompanyId);
}
if (request.DocumentTypeId == DocumentType.RegularJournal)
{
tAorJLTypeId = await _accountingInterfaceRepository.GetJLTypeIdAsync(request.TransactionDocumentId, request.DocumentTypeId, request.CompanyId);
}
EventSubType eventSubType = await GetEventSubType(request.DocumentTypeId, tAorJLTypeId);
_unitOfWork.BeginTransaction();
var eventdata = new Event((int)eventSubType, request.DocumentId, docReference, (int)InterfaceStatus.ReadyToTransmit, request.CompanyId, null);
try
{
eventId = await _interfaceEventLogService.CreateEventAsync(eventdata);
// Insert Record into InterfaceStatus
await ProcessStatusUpdate(request, InterfaceStatus.InterfaceReady, "Ready To be Interfaced");
_unitOfWork.Commit();
}
catch
{
_unitOfWork.Rollback();
throw;
}
var companyDate = await _systemDateTimeService.GetCompanyDate(request.CompanyId);
_logger.LogInformation("Accounting Document with DocumentId {Atlas_DocumentId} having status {Atlas_InterfaceStatus} is sent to Accounting System at {Atlas_DateTime}", request.DocumentId, docStatus.ToString(), companyDate);
var accountingInterfaceXMLMessage = await _accountingInterfaceRepository.GetESBMessageAsync(request.DocumentId, request.CompanyId);
var eventHistory = new EventHistory(eventId, "Message Generated", accountingInterfaceXMLMessage, null, null);
_unitOfWork.BeginTransaction();
try
{
await _interfaceEventLogService.CreateEventHistoryAsync(eventHistory, request.CompanyId);
_unitOfWork.Commit();
}
catch
{
_unitOfWork.Rollback();
throw;
}
await SendBusinessObjectToInterface(request, accountingInterfaceXMLMessage, tAorJLTypeId, eventId, false);
}
else
{
_logger.LogWarning("Invalid Document ({Atlas_DocumentReference}) status {Atlas_InterfaceStatus}.", request.DocumentReference, docStatus.ToString());
}
return(Unit.Value);
}
/// <summary>
/// Handling the creation of an accounting document
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <IEnumerable <long> > Handle(CreateAccountingDocumentCommand request, CancellationToken cancellationToken)
{
_unitOfWork.BeginTransaction();
IEnumerable <AccountingDocumentCreationStatus> accountingDocumentCreationStatusList = null;
long accountingId = -1;
IEnumerable <long> createdAccountingDocumentIds = null;
Company company = null;
try
{
TransactionDocumentDto transactionDocument = await _accountingQueries.GetTransactionDocumentTypeByDocId(request.DocId, request.Company);
if (transactionDocument == null)
{
throw new NotFoundException("TransactionDocument", request.DocId);
}
if (transactionDocument.TransactionDocumentTypeId == (int)DocumentType.CP ||
transactionDocument.TransactionDocumentTypeId == (int)DocumentType.CI)
{
// Note: the "CreateAccounting" background process is called also for cash status updates, after a
// 'response' received from the TRAX system. In this context, the caller just sends a "creaete accounting doc" message
// Below, we are checking the existance of the acc doc for the cash (through the SP update).
// Updates the document date and the value date of the given cash
accountingId = await _accountingDocumentRepository.UpdateAccountingDocumentForTraxResponse(request.DocId, request.Company);
// If the doc accounting doc of the cash exists, then accountingId is >0...
}
if (accountingId > 0)
{
// ... and in this case, we just queue the cash for posting. As a reminder, the TRAX-ed cash cannot have the “Authorized for posting” flag
// set by the user (the UI prevents it)
List <long> listOfDocId = new List <long>();
listOfDocId.Add(accountingId);
await AuthorizeForPosting(listOfDocId, request.Company, request.PostOpClosedPolicy);
_unitOfWork.Commit();
}
else
{
List <AccountingDocument> accountingDocuments = new List <AccountingDocument>();
int docTypeId = transactionDocument.TransactionDocumentTypeId;
AccountingSetupDto accountingSetup = await _accountingQueries.GetAccountingSetup(docTypeId, request.Company);
var transactionIdOfReversedDoc = await _accountingQueries.GetTransactionDocumentIdByReversalId(request.DocId, request.Company);
if (transactionIdOfReversedDoc != null)
{
// We are in the situation of a reversal
var accountingCreationStatusList = await _accountingDocumentRepository.CreateAccountingDocumentForReversal(
request.DocId, // TransDocId of the Reversal
transactionIdOfReversedDoc.Value, // TransDocId of the Reversed (original)
request.Company,
request.PostOpClosedPolicy);
await EnqueueBulkPostingProcessorMessage(
accountingCreationStatusList,
request.Company,
request.PostOpClosedPolicy);
}
else
{
// The document is a standard non-reversed document for which to generate the accounting document
company = await _masterDataService.GetCompanyByIdAsync(request.Company);
long transactionDocumentId = request.DocId;
var companyDate = await _systemDateTimeService.GetCompanyDate(request.Company);
switch (docTypeId)
{
case (int)DocumentType.PI:
case (int)DocumentType.SI:
case (int)DocumentType.CN:
case (int)DocumentType.DN:
accountingDocuments.Add(await GetInformationForInvoice(request.PostOpClosedPolicy, transactionDocumentId, docTypeId, accountingSetup, company, request.Company, companyDate));
break;
case (int)DocumentType.CP:
case (int)DocumentType.CI:
accountingDocuments.AddRange(await GetInformationForCash(request.PostOpClosedPolicy, transactionDocumentId, docTypeId, accountingSetup, company, companyDate));
/*CashForCounterpartyDto cashForCounterpartyDto = null;
* cashForCounterpartyDto = await _accountingQueries.GetCashTypeIdForCounterParty(transactionDocumentId);
* if (cashForCounterpartyDto != null && cashForCounterpartyDto.CashTypeId == (int)CashSelectionType.PaymentDifferentClient && cashForCounterpartyDto.JLTypeId == (int)JLType.CounterPartyTransfer)
* {
* accountingDocuments.Add(await GetInformationForCounterParty(request.PostOpClosedPolicy, cashForCounterpartyDto.TransactionDocumentId, docTypeId, accountingSetup, company, companyDate, cashForCounterpartyDto));
* }*/
break;
case (int)DocumentType.MJL:
case (int)DocumentType.MTA:
TransactionDocumentDto transactionDocumentDto = null;
transactionDocumentDto = await _accountingQueries.GetJLDocumentTypeByTransactionDocumentId(transactionDocumentId, company.CompanyId);
if (transactionDocumentDto != null && transactionDocumentDto.JLTypeId == 2) // JLType = 2 = Reval
{
var revalInformation = await _accountingQueries.GetRevalInformationForAccountingDocument(
transactionDocumentId, company.CompanyId);
var revalAccountingDocument = await GetInformationForRevaluation(
request.PostOpClosedPolicy,
transactionDocumentId,
docTypeId,
accountingSetup,
company,
companyDate,
revalInformation);
if (revalAccountingDocument != null &&
revalAccountingDocument.AccountingDocumentLines != null &&
revalAccountingDocument.AccountingDocumentLines.Count() > 0)
{
// We create the accounting document for reval only if it contains non-0 records
accountingDocuments.Add(revalAccountingDocument);
// Stores a new document matching in the database, to link the revaluation record to it, so that
// it appears as linked in the "delete match" screen
await _invoicingRepository.CreateDocumentMatchingAsync(new DocumentMatching
{
CompanyId = company.CompanyId,
MatchFlagId = revalInformation.MatchFlagId,
TransactionDocumentId = transactionDocumentId,
ValueDate = revalInformation.PaymentDocumentDate,
DepartmentId = revalInformation.DepartmentId
});
}
else
{
// We delete the Revaluation Transaction document if no accounting
// document has to be associated to it
await _invoicingRepository.DeleteManualJLOrRevaluationAsync(
transactionDocumentId, request.Company);
}
}
else
{
(AccountingDocument adTAJL, MonthEndTADocumentDto MonthEnd) = await CreateAccountingForTAandJL(request.PostOpClosedPolicy, transactionDocument, transactionDocumentId, docTypeId, accountingSetup, company, companyDate);
if (docTypeId == (int)DocumentType.MTA)
{
var accountingDocumentPerAccuralNumberTA = await CreateAccountingDocumentPerAccuralNumberTA(adTAJL, MonthEnd, request.Company, transactionDocumentId);
accountingDocuments.AddRange(accountingDocumentPerAccuralNumberTA);
}
else
{
accountingDocuments.Add(adTAJL);
}
}
break;
case (int)DocumentType.FJ:
accountingDocuments.Add(await CreateAccountingDocumentForFxDeal(request.PostOpClosedPolicy, transactionDocumentId, docTypeId, accountingSetup, company, request.Company, companyDate));
break;
}
var createdAccountingDocuments = await CreateAccountingDocumentsAndEnqueueForPosting(request.Company, accountingDocuments, request.PostOpClosedPolicy);
createdAccountingDocumentIds = createdAccountingDocuments.Select(a => a.AccountingId);
}
_unitOfWork.Commit();
}
if (transactionDocument.TransactionDocumentTypeId == (int)DocumentType.FJ && accountingDocumentCreationStatusList != null)
{
long createdAccountingId = accountingDocumentCreationStatusList.ToList().FirstOrDefault().AccountingId;
await UpdateFxDealInformation(company.Id, request.DocId, createdAccountingId, request.Company);
}
_logger.LogInformation("Doc with id {Atlas_DocId}.", request.DocId);
}
catch (Exception ex)
{
_logger.LogError("Exception on Creating Accouting Document for {Atlas_DocId}.", request.DocId, ex);
_unitOfWork.Rollback();
throw;
}
return(createdAccountingDocumentIds);
}
internal static async Task ValidateFxDeal(FxDeal fxDeal, IIdentityService identityService, IMasterDataService masterDataService, IUserService userService, ISystemDateTimeService systemDateTimeService)
{
var departments = await masterDataService.GetDepartmentsAsync(fxDeal.CompanyId);
if (!departments.Any(d => d.DepartmentId == fxDeal.DepartmentId))
{
throw new AtlasBusinessException($"The department {fxDeal.DepartmentId} does not belong to the {fxDeal.CompanyId} company.");
}
var trader = await userService.GetUserByIdAsync(fxDeal.TraderId);
if (trader == null)
{
throw new NotFoundException("User", fxDeal.TraderId);
}
if (!trader.Permissions.Any(p => p.CompanyId == fxDeal.CompanyId && p.IsTrader))
{
throw new AtlasBusinessException($"The user {fxDeal.TraderId} is not configured as a trader for company {fxDeal.CompanyId}.");
}
var companyDate = await systemDateTimeService.GetCompanyDate(fxDeal.CompanyId);
// The date entered in the Contract date field by the user is not in the future.
if (fxDeal.ContractDate.Date > companyDate.Date)
{
throw new AtlasBusinessException($"The contract date cannot be in the future. Company date: {companyDate.Date}");
}
// The department code must belong to the list of departments attached to the user’s account.
var user = await userService.GetUserByIdAsync(identityService.GetUserAtlasId());
var companyPermissions = user.Permissions
.FirstOrDefault(p => p.CompanyId == fxDeal.CompanyId);
var userDepartments = companyPermissions.Departments
.Select(department => department.DepartmentId).ToList();
if (!companyPermissions.AllDepartments && !userDepartments.Contains(fxDeal.DepartmentId))
{
throw new AtlasBusinessException($"The department {fxDeal.DepartmentId} does not belong to the list of departments attached to the user’s account.");
}
// The FX Deal type must belong to the Deal type master data
var fxTradeTypes = await masterDataService.GetFxTradeTypes(fxDeal.CompanyId);
if (!fxTradeTypes.Any(n => n.FxTradeTypeId == fxDeal.FxTradeTypeId))
{
throw new AtlasBusinessException($"The FX Deal type {fxDeal.FxTradeTypeId} does not belong to the company {fxDeal.CompanyId}.");
}
// Settled amount calculation
// The value is calculated by multiplying or dividing (depending on M/D field) the “Dealt amount” field’s value by the “Spot ROE” field’s value.
var settledAmount = fxDeal.Amount * (fxDeal.SpotRateType == "D" ? 1 / fxDeal.SpotRate : fxDeal.SpotRate);
// TODO: tolerance band on Spot ROE
// Traded ROE field is the sum of the “Spot ROE” and “FW Points”
var tradedRoe = fxDeal.SpotRate + fxDeal.FwPoints;
// The Nominal account (Deal) must belong to the Nominal account master data assigned to the company.
var nominalAccounts = await masterDataService.GetNominalAccountsAsync(fxDeal.CompanyId);
if (!nominalAccounts.Any(n => n.NominalAccountId == fxDeal.NominalAccountId))
{
throw new AtlasBusinessException($"The Nominal account (Deal) {fxDeal.NominalAccountId} does not belong to the company {fxDeal.CompanyId}.");
}
// The Nominal account (Settlement) must belong to the Nominal account master data assigned to the company.
if (!nominalAccounts.Any(n => n.NominalAccountId == fxDeal.SettlementNominalAccountId))
{
throw new AtlasBusinessException($"The Nominal account (Settlement) {fxDeal.NominalAccountId} does not belong to the company {fxDeal.CompanyId}.");
}
// The Bank/broker” must belong to the the list of counterparties assigned to the company and having the value “Bank” in “Account type” field
var counterparties = await masterDataService.GetCounterpartiesAsync(fxDeal.CompanyId);
if (!counterparties.Any(c => c.CounterpartyID == fxDeal.CounterpartyId))
{
throw new AtlasBusinessException($"The counterparty {fxDeal.CounterpartyId} does not belong to the company {fxDeal.CounterpartyId}.");
}
}
/// <summary>
/// Handling of the unmatching of a match (whichever a manual or the result of a cash by picking)
/// </summary>
/// <param name="request">request</param>
/// <param name="cancellationToken">cancellationToken</param>
public async Task <ManualDocumentMatchingRecord> Handle(UnmatchManualDocumentMatchingCommand request, CancellationToken cancellationToken)
{
_unitOfWork.BeginTransaction();
try
{
long?revalutionTransactionDocId = await _manualDocumentMatchingRepository.DeleteMatchFlag(
request.MatchFlagId, request.Company);
string documentReference = string.Empty;
if (revalutionTransactionDocId != null)
{
var companyDate = await _systemDateTimeService.GetCompanyDate(request.Company);
// A revaluation exists => we have to create a reversal for it
int refNumberToCreateForReversal = await _transactionDocumentQueries.GetNextTransactionDocumentReferenceValues(
request.Company,
(int)MasterDocumentType.JL, // The type of document for reversal is JL
companyDate.Year);
// Calculate the document reference
documentReference = string.Concat(
MasterDocumentType.JL,
companyDate.Year - 2000,
string.Format(CultureInfo.InvariantCulture, "{0:D5}", refNumberToCreateForReversal));
var reversalTransactionDocumentId = await _transactionDocumentRepository.ReverseDocument(
revalutionTransactionDocId.Value,
request.Company,
companyDate.Year,
refNumberToCreateForReversal,
documentReference,
companyDate);
var authorizationResult = await _authorizationService.AuthorizeAsync(_identityService.GetUser(), Policies.PostOpClosedPolicy);
var content = new JObject();
content.Add(new JProperty("docId", reversalTransactionDocumentId));
content.Add(new JProperty("postOpClosedPolicy", authorizationResult.Succeeded));
// Requesting the creation of the corresponding accounting document
await _processMessageService.SendMessage(new ProcessMessage
{
ProcessTypeId = (int)ProcessType.AtlasAccountingDocumentProcessor,
CompanyId = request.Company,
Content = content.ToString(),
});
}
_unitOfWork.Commit();
_logger.LogInformation("Match Flag Deleted");
return(revalutionTransactionDocId == null ? null : new ManualDocumentMatchingRecord()
{
ReversalRevalJournalCode = documentReference
});
}
catch
{
_unitOfWork.Rollback();
throw;
}
}
