public async Task <ActionResult <ValidatedAccountingImport> > FileUpload([FromForm, Required] CreateAccountingLinesFileUploadCommand command, string company)
{
var lines = new List <string>();
using (var reader = new StreamReader(command.File.OpenReadStream()))
{
while (reader.Peek() >= 0)
{
lines.Add(await reader.ReadLineAsync());
}
}
var dataReadFromCsv = lines
.Skip(1)
.Select((l, i) => AccountingCsvLine.ParseFromCsv(l, i, command.IsAccuralSelected, command.IsMTMSelected))
.ToList();
var accountingImporter = new AccountingCsvImporter(_masterDataService, _accountingDocumentQueries, company, _mapper);
var validatedResult = await accountingImporter.ProcessManualAccountingImport(dataReadFromCsv, command.IsMTMSelected, company);
return(Ok(validatedResult));
}
private static bool ValidateFxDeal(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <FxDealSearchResult> searchResultFxDeals)
{
if (searchResultFxDeals.Count() > 0)
{
if (!searchResultFxDeals.Any(searchResultFxDeal => searchResultFxDeal.DealNumber == csvline.DealNumber || csvline.DealNumber == null || csvline.DealNumber.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_dealNumber"));
return(false);
}
if (!string.IsNullOrEmpty(csvline.DealNumber))
{
if (!(string.IsNullOrEmpty(csvline.SectionId) && string.IsNullOrEmpty(csvline.CommodityId)))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_value_dealNumber"));
return(false);
}
}
}
return(true);
}
private static bool ValidateSectionId(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <SectionSearchResult> searchResultSectionIds)
{
if (searchResultSectionIds.Count() > 0)
{
if (!searchResultSectionIds.Any(searchResultSectionId => searchResultSectionId.ContractLabel == csvline.SectionId || csvline.SectionId == null || csvline.SectionId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_sectionId"));
return(false);
}
if (!string.IsNullOrEmpty(csvline.SectionId))
{
if (!(string.IsNullOrEmpty(csvline.DealNumber) && string.IsNullOrEmpty(csvline.SettlementCurrency)))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_value_contractreference"));
return(false);
}
}
}
return(true);
}
private static bool ValidateTransactionDocument(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <TransactionDocumentSearch> searchResultTransactionDocuments)
{
if (searchResultTransactionDocuments.Count() > 0)
{
if (!searchResultTransactionDocuments.Any(searchResultTransactionDocument => searchResultTransactionDocument.DocRef == csvline.SecondaryDocumentReference || csvline.SecondaryDocumentReference == null || csvline.SecondaryDocumentReference.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_secondaryDocumentReference"));
return(false);
}
return(true);
}
return(true);
}
private static bool Validateprovinces(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <Province> provinces)
{
if (!provinces.Any(province => province.StateCode == csvline.ProvinceId || csvline.ProvinceId == null || csvline.ProvinceId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_provinceid"));
return(false);
}
return(true);
}
private static bool ValidateSettlementCurrencyList(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <Currency> settlementCurrencyLists)
{
if (!settlementCurrencyLists.Any(settlementCurrencyList => settlementCurrencyList.CurrencyCode == csvline.SettlementCurrency || csvline.SettlementCurrency == null || csvline.SettlementCurrency.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_settlementcurrencylist"));
return(false);
}
return(true);
}
private static bool ValidateCharterManager(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <CharterManager> charterManagers)
{
if (charterManagers.Count() > 0)
{
if (!charterManagers.Any(charterManager => charterManager.CharterCode == csvline.CharterId || csvline.CharterId == null || csvline.CharterId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_charterManager"));
return(false);
}
return(true);
}
return(true);
}
private static bool ValidateCommodityAccount(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <Commodity> commodityAccounts)
{
if (!commodityAccounts.Any(commodityAccount => commodityAccount.PrincipalCommodity == csvline.CommodityId || csvline.CommodityId == null || csvline.CommodityId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_commodityaccount"));
return(false);
}
return(true);
}
private static bool ValidateDepartmentId(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <Department> departmentIds)
{
if (!departmentIds.Any(departmentId => departmentId.DepartmentCode == csvline.DepartmentId || csvline.DepartmentId == null || csvline.DepartmentId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_departmentid"));
return(false);
}
return(true);
}
private static bool ValidateCostAccount(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <CostType> costTypes)
{
if (!costTypes.Any(costType => costType.CostTypeCode == csvline.CostTypeId || csvline.CostTypeId == null || csvline.CostTypeId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_costaccount"));
return(false);
}
return(true);
}
private static bool ValidateAccountLineTypeId(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, bool isMTMSelected, IEnumerable <AccountLineTypes> accountLineTypes)
{
if (!accountLineTypes.Any(accountLineType => accountLineType.AccountLineTypeCode == csvline.AccountLineTypeId || csvline.AccountLineTypeId == null || csvline.AccountLineTypeId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_accountlineid"));
return(false);
}
return(true);
}
private static bool ValidateAssociatedAccountId(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <Counterparty> counterparties)
{
if (!counterparties.Any(counterparty => counterparty.CounterpartyCode == csvline.AssociatedAccountId || csvline.AssociatedAccountId == null || csvline.AssociatedAccountId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_associatedaccountid"));
return(false);
}
return(true);
}
private static bool ValidateNominalAccount(List <AccountingValidationError> validationerrors, AccountingCsvLine csvline, IEnumerable <NominalAccount> nominalAccounts, IEnumerable <Counterparty> counterparty, IEnumerable <AccountLineTypes> accountLineType, IEnumerable <CostType> costType, bool isMTMSelected)
{
if (!nominalAccounts.Any(nominalAccount => nominalAccount.NominalAccountNumber == csvline.AccountReferenceId || csvline.AccountReferenceId == null || csvline.AccountReferenceId.Trim() == string.Empty))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_nominalaccount"));
return(false);
}
else
{
// check business rules if valid nominal account found
if (!string.IsNullOrEmpty(csvline.AccountReferenceId))
{
var matchingNominalAccount = nominalAccounts.Where(x => x.NominalAccountNumber == csvline.AccountReferenceId).FirstOrDefault();
if (matchingNominalAccount != null)
{
if (matchingNominalAccount.ClientAccountMandatory == 1)
{
// Business rules for Client Account
if (!string.IsNullOrEmpty(csvline.ClientAccountId))
{
if (!counterparty.Any(counterparties => counterparties.CounterpartyCode != csvline.ClientAccountId))
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_ClientAccount_BasedOn_NominalAccount"));
return(false);
}
}
// Business rules for Account Line Type mtm
if (isMTMSelected)
{
if (!string.IsNullOrEmpty(csvline.AccountLineTypeId))
{
if (csvline.AccountLineTypeId != AccountLineType.B.ToString())
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_AccountType_BasedOn_NominalAccount_Mandatory_MTM"));
return(false);
}
}
}
// Business rules for Account Line Type
if (!isMTMSelected && !string.IsNullOrEmpty(csvline.AccountLineTypeId))
{
if (csvline.AccountLineTypeId != AccountLineType.C.ToString() || csvline.AccountLineTypeId != AccountLineType.V.ToString())
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_AccountType_BasedOn_NominalAccount"));
return(false);
}
}
// Business rules for Cost Type
if (!string.IsNullOrEmpty(csvline.CostTypeId))
{
var matchingCostType = costType.Where(costtypes => costtypes.CostTypeId.ToString() == csvline.CostTypeId).FirstOrDefault();
if (matchingCostType != null)
{
if (matchingCostType.NominalAccountCode != matchingNominalAccount.NominalAccountNumber || matchingCostType.OtherAcc != matchingNominalAccount.NominalAccountNumber)
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_CostType_BasedOn_NominalAccount"));
return(false);
}
}
}
}
if (isMTMSelected && matchingNominalAccount.ClientAccountMandatory != 1)
{
if (!string.IsNullOrEmpty(csvline.AccountLineTypeId))
{
if (csvline.AccountLineTypeId != AccountLineType.L.ToString())
{
validationerrors.Add(new AccountingValidationError(csvline, "invalid_AccountType_BasedOn_NominalAccount_Notmandatory_MTM"));
return(false);
}
}
}
}
}
return(true);
}
}
public AccountingValidationError(AccountingCsvLine csvLine, string errorCode)
{
AccountingCheckCsvLine = csvLine;
ErrorCode = errorCode;
}
