public async Task <CurrenciesResult> GetAsync(string SessionKey, int[] CurrencyId)
{
return(await authorizationProcessor.DoAuthorizeAsync(SessionKey, async token =>
{
var result = (await currencyProcessor.GetAsync(new CurrencySearch {
Ids = CurrencyId
}, token)).ToList();
return new CurrenciesResult
{
ProcessResult = new ProcessResult {
Result = true
},
Currencies = result,
};
}, logger));
}
/// <summary>インポート処理</summary>
/// <param name="source"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <ImportResult> ImportAsync(MasterImportSource source, CancellationToken token = default(CancellationToken))
{
var mode = (ImportMethod)source.ImportMethod;
var encoding = Encoding.GetEncoding(source.EncodingCodePage);
var csv = encoding.GetString(source.Data);
var companyTask = companyProcessor.GetAsync(new CompanySearch {
Id = source.CompanyId,
}, token);
var loginUsersTask = loginUserProcessor.GetAsync(new LoginUserSearch {
CompanyId = source.CompanyId,
}, token);
var appConTask = applicationControlProcessor.GetAsync(source.CompanyId, token);
var customerTask = customerProcessor.GetAsync(new CustomerSearch {
CompanyId = source.CompanyId
}, token);
var currencyTask = currencyProcessor.GetAsync(new CurrencySearch {
CompanyId = source.CompanyId,
}, token);
await Task.WhenAll(companyTask, loginUsersTask, appConTask, customerTask, currencyTask);
var company = companyTask.Result.First();
var loginUserDictionary = loginUsersTask.Result.ToDictionary(x => x.Code);
var loginUser = loginUsersTask.Result.First(x => x.Id == source.LoginUserId);
var appCon = appConTask.Result;
var customerDictionary = customerTask.Result.ToDictionary(x => x.Code);
var currencyDictionary = currencyTask.Result.ToDictionary(x => x.Code);
var useForeignCurrency = appCon.UseForeignCurrency == 1;
var definition = new CustomerRegistrationFeeFileDefinition(new DataExpression(appCon));
var parser = new CsvParser {
Encoding = encoding,
StreamCreator = new PlainTextMemoryStreamCreator(),
};
definition.CurrencyCodeField.Ignored = !useForeignCurrency;
definition.CustomerIdField.GetModelsByCode = val => customerDictionary;
definition.CurrencyCodeField.GetModelsByCode = code => currencyDictionary;
var importer = definition.CreateImporter(x => new { x.CustomerCode, x.CurrencyCode, x.Fee }, parser);
importer.UserId = source.LoginUserId;
importer.UserCode = loginUser.Code;
importer.CompanyId = source.CompanyId;
importer.CompanyCode = company.Code;
importer.LoadAsync = () => customerFeeProcessor.GetAsync(new CustomerFeeSearch {
CompanyId = source.CompanyId,
}, token);
importer.RegisterAsync = x => customerFeeProcessor.ImportAsync(x.New, x.Dirty, x.Removed, token);
var result = await importer.ImportAsync(csv, mode, token, null);
result.Logs = importer.GetErrorLogs();
return(result);
}
private async Task <List <Currency> > GetCurrenciesAsync(int companyId, string[] codes, CancellationToken token)
=> (await currencyProcessor.GetAsync(new CurrencySearch {
CompanyId = companyId, Codes = codes,
}, token)).ToList();
/// <summary>読み込み・検証・一時データ登録処理</summary>
/// <param name="source"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <ImportDataResult> ReadAsync(TransactionImportSource source, CancellationToken token = default(CancellationToken))
{
var encoding = Encoding.GetEncoding(source.EncodingCodePage);
var csv = encoding.GetString(source.Data);
var companyTask = companyProcessor.GetAsync(new CompanySearch {
Id = source.CompanyId,
}, token);
var appConTask = applicationControlProcessor.GetAsync(source.CompanyId, token);
await Task.WhenAll(companyTask, appConTask);
var company = companyTask.Result.First();
var applicationControl = appConTask.Result;
var importer = new ReceiptImporterBase(applicationControl)
{
CompanyId = source.CompanyId,
CompanyCode = company.Code,
LoginUserId = source.LoginUserId,
ImporterSettingId = source.ImporterSettingId,
FilePath = csv,
CsvParser = new CsvParser {
Encoding = encoding,
StreamCreator = new PlainTextMemoryStreamCreator(),
},
GetImporterSettingAsync = async settingId => (await importerSettingProcessor.GetAsync(new ImporterSetting {
Id = settingId
}, token)).FirstOrDefault(),
GetImporterSettingDetailByIdAsync = async settingId => (await importerSettingDetailProcessor.GetAsync(new ImporterSetting {
Id = settingId
}, token)).ToList(),
GetGeneralSettingValueAsync = async(companyId, code) => (await generalSettingProcessor.GetAsync(new GeneralSetting {
CompanyId = companyId, Code = code,
}, token)).FirstOrDefault()?.Value,
ReceiptImportDuplicationCheckAsync = async(companyid, items, details) => (await receiptProcessor.ReceiptImportDuplicationCheckAsync(companyid, items, details, token)).ToArray(),
GetCurrenciesAsync = async(companyId, codes) => (await currencyProcessor.GetAsync(new CurrencySearch {
CompanyId = companyId, Codes = codes,
}, token)).ToList(),
GetCategoriesByCodesAsync = async(companyId, categoryType, codes) => (await categoryProcessor.GetAsync(new CategorySearch {
CompanyId = companyId, CategoryType = categoryType, Codes = codes,
}, token)).ToList(),
GetSectionByCodesAsync = async(companyId, codes) => (await sectionProcessor.GetAsync(new SectionSearch {
CompanyId = companyId, Codes = codes,
}, token)).ToList(),
GetCustomerByCodesAsync = async(companyId, codes) => (await customerProcessor.GetAsync(new CustomerSearch {
CompanyId = companyId, Codes = codes,
}, token)).ToList(),
GetLegalPersonaritiesAsync = async(companyId) => (await juridicalPersonalityProcessor.GetAsync(new JuridicalPersonality {
CompanyId = companyId,
}, token)).Select(x => x.Kana).ToArray(),
GetCollationSettingAsync = companyId => collationSettingProcessor.GetAsync(companyId, token),
LoadColumnNameSettingsInnerAsync = async tableName => (await columnNameSettingProcessor.GetAsync(new ColumnNameSetting {
CompanyId = source.CompanyId, TableName = tableName,
}, token)).ToArray(),
Serialize = item => serializer.PackSingleObject(item),
SaveImportDataAsync = data => importDataProcessor.SaveAsync(data, token),
};
var readResult = await importer.ReadCsvAsync();
return(new ImportDataResult {
ImportData = importer.ImportData,
ReadCount = importer.ReadCount,
ValidCount = importer.ValidCount,
InvalidCount = importer.InvalidCount,
Logs = importer.GetValidationLogs(),
});
}
public async Task <ActionResult <IEnumerable <Currency> > > GetItems(CurrencySearch option, CancellationToken token) => (await currencyProcess.GetAsync(option, token)).ToArray();
/// <summary>constructor</summary>
public EbFileImportProcessor(
ICompanyProcessor companyProcessor,
ILoginUserProcessor loginUserProcessor,
IApplicationControlProcessor applicationControlProcessor,
ICollationSettingProcessor collationSettingProcessor,
ICategoryProcessor categoryProcessor,
ICurrencyProcessor currencyProcessor,
IJuridicalPersonalityProcessor juridicalPersonalityProcessor,
IBankAccountProcessor bankAccountProcessor,
ICustomerProcessor customerProcessor,
IIgnoreKanaProcessor ignoreKanaProcessor,
IEBExcludeAccountSettingProcessor ebExcludeAccountSettingProcessor,
ISectionProcessor sectionProcessor,
IImportFileLogProcessor importFileLogProcessor
)
{
this.companyProcessor = companyProcessor;
this.loginUserProcessor = loginUserProcessor;
this.applicationControlProcessor = applicationControlProcessor;
this.collationSettingProcessor = collationSettingProcessor;
this.categoryProcessor = categoryProcessor;
this.currencyProcessor = currencyProcessor;
this.juridicalPersonalityProcessor = juridicalPersonalityProcessor;
this.bankAccountProcessor = bankAccountProcessor;
this.ignoreKanaProcessor = ignoreKanaProcessor;
this.customerProcessor = customerProcessor;
this.ebExcludeAccountSettingProcessor = ebExcludeAccountSettingProcessor;
this.sectionProcessor = sectionProcessor;
this.importFileLogProcessor = importFileLogProcessor;
importer = new EbDataImporterBase {
IsAsync = true,
IsPlainText = true,
};
importer.Helper.InitializeAsync = async token => {
var applicationControlTask = applicationControlProcessor.GetAsync(importer.Helper.CompanyId, token);
var collationSettingTask = collationSettingProcessor.GetAsync(importer.Helper.CompanyId, token);
var defaultCurrencyTask = currencyProcessor.GetAsync(new CurrencySearch {
CompanyId = importer.Helper.CompanyId,
Codes = new[] { Rac.VOne.Common.Constants.DefaultCurrencyCode },
}, token);
var defaultReceiptCategoryTask = categoryProcessor.GetAsync(new CategorySearch {
CompanyId = importer.Helper.CompanyId,
CategoryType = CategoryType.Receipt,
Codes = new[] { "01" },
}, token);
var juridicalPersonalityTask = juridicalPersonalityProcessor.GetAsync(new JuridicalPersonality {
CompanyId = importer.Helper.CompanyId
}, token);
await Task.WhenAll(
applicationControlTask,
collationSettingTask,
defaultCurrencyTask,
defaultReceiptCategoryTask,
juridicalPersonalityTask
);
importer.Helper.ApplicationControl = applicationControlTask.Result;
importer.Helper.CollationSetting = collationSettingTask.Result;
importer.Helper.DefaultCurrency = defaultCurrencyTask.Result.First();
importer.Helper.DefaultReceiptCategory = defaultReceiptCategoryTask.Result.First();
importer.Helper.LegalPersonalities = juridicalPersonalityTask.Result.Select(x => x.Kana).ToArray();
};
importer.Helper.GetBankAccountAsync = async(bankCode, branchCode, accountTypeId, accountNumber, token) => {
var result = await bankAccountProcessor.GetAsync(new BankAccountSearch {
CompanyId = importer.Helper.CompanyId,
BankCodes = new[] { bankCode },
BranchCodes = new[] { branchCode },
AccountTypeId = accountTypeId,
AccountNumber = accountNumber,
}, token);
return(result.FirstOrDefault());
};
importer.Helper.GetBankAccountByBankNameAsync = async(bankName, branchName, accountTypeId, accountNumber, token) => {
var result = await bankAccountProcessor.GetAsync(new BankAccountSearch {
CompanyId = importer.Helper.CompanyId,
BankName = bankName,
BranchName = branchName,
AccountTypeId = accountTypeId,
AccountNumber = accountNumber,
}, token);
return(result.FirstOrDefault());
};
importer.Helper.GetBankAccountByBranchNameAsync = async(bankCode, branchName, token) => {
var result = await bankAccountProcessor.GetAsync(new BankAccountSearch {
CompanyId = importer.Helper.CompanyId,
BankCodes = new[] { bankCode },
BranchName = branchName,
}, token);
return(result.FirstOrDefault());
};
importer.Helper.GetBankAccountByBranchNameAndNumberAsync = async(bankCode, branchName, accountTypeId, accountNumber, token) => {
var result = await bankAccountProcessor.GetAsync(new BankAccountSearch {
CompanyId = importer.Helper.CompanyId,
BankCodes = new[] { bankCode },
BranchName = branchName,
AccountTypeId = accountTypeId,
AccountNumber = accountNumber,
}, token);
return(result.FirstOrDefault());
};
importer.Helper.GetCustomerIdByExclusiveInfoAsync = async(bankCode, branchCode, payerCode, token) => {
var result = await customerProcessor.GetAsync(new CustomerSearch {
CompanyId = importer.Helper.CompanyId,
ExclusiveBankCode = bankCode,
ExclusiveBranchCode = branchCode,
ExclusiveAccountNumber = payerCode,
}, token);
return(result.FirstOrDefault()?.Id);
};
importer.Helper.GetSectionIdByPayerCodeAsync = async(payerCode, token) => {
var result = await sectionProcessor.GetAsync(new SectionSearch {
CompanyId = importer.Helper.CompanyId,
PayerCodes = new[] { payerCode },
}, token);
return(result.FirstOrDefault()?.Id);
};
importer.Helper.GetExcludeCategoryIdAsync = async(payerName, token) => {
var result = await ignoreKanaProcessor.GetAsync(new IgnoreKana {
CompanyId = importer.Helper.CompanyId,
Kana = payerName,
}, token);
return(result.FirstOrDefault()?.ExcludeCategoryId);
};
importer.Helper.GetEBExcludeAccountSettingListAsync = async token
=> (await ebExcludeAccountSettingProcessor.GetAsync(importer.Helper.CompanyId, token)).ToList();
importer.Helper.SaveDataInnerAsync = async(logs, token)
=> (await importFileLogProcessor.SaveAsync(logs, token)).ToList();
}