public void TestDirectoryFile()
{
DirectoryFile df = new DirectoryFile(@"d:\", "*.txt");
DebugObserver <string> db = new DebugObserver <string>(nameof(DirectoryFile));
df.Output.Subscribe(db);
}
public void DBContextTest2()
{
DirectoryFile intouchFile1 = new DirectoryFile("abc", "abc", Model.Enum.FileStatus.ReadFromFileSystem);
intouchFile1.FileContent = FileUtility.ReadFile("..\\..\\TestFiles\\bank_20160517220202_test2.csv");
DirectoryFile intouchFile2 = new DirectoryFile("abc", "abc", Model.Enum.FileStatus.ReadFromFileSystem);
intouchFile2.FileContent = FileUtility.ReadFile("..\\..\\TestFiles\\bank_20160517220202_test3.csv");
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
context.Database.ExecuteSqlCommand("delete from ODS.BankIntouch");
context.SaveChanges();
}
ApplicationController.ProcessBankIntouch(intouchFile1);
ApplicationController.ProcessBankIntouch(intouchFile2);
int i = 0;
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
var query = (from row in context.BankIntouch
select row).ToList();
i = query.Count;
}
Assert.AreEqual(4, i);
}
public void GetOffsetOrdering()
{
int currFile = 0;
var tf2Files = Directory.EnumerateFiles(@"D:\Games\Origin\Titanfall2\vpk", "*_dir.vpk", SearchOption.TopDirectoryOnly);
foreach (var f in tf2Files)
{
var file = new DirectoryFile(f);
ulong lastOffset = 0;
int b = 0;
int e = 0;
for (int a = 0; a < file.Archives.Length; a++)
{
Debug.WriteLine($"[[ File {f}, Archive {a} ]]");
foreach (var block in file.EntryBlocks.Where(bl => bl.ArchiveIndex == a))
{
foreach (var entry in block.Entries)
{
if (entry.EntryFlags != (EntryFlags)257)
{
Debug.WriteLine($"[A {a}: B {b}, E {e}]: DataID: {entry.EntryFlags}");
Debug.WriteLine(block.FilePath);
}
e++;
lastOffset = entry.Offset;
}
e = 0;
b++;
}
lastOffset = 0;
b = 0;
}
currFile++;
}
}
/// <summary>
/// Scan input folder for available files
/// </summary>
public static void IdentifyNewFiles(ApplicationSettings application)
{
foreach (string directory in Directory.GetDirectories(application.InputDataFolder))
{
logger.Info($"Reading files from folder [{directory}]");
Model.Enum.FileType fileType;
Model.Enum.FileStatus fileStatus = Model.Enum.FileStatus.ReadFromFileSystem;
System.Enum.TryParse(Path.GetFileName(directory), out fileType);
if (!System.Enum.TryParse(Path.GetFileName(directory), out fileType))
{
fileType = Model.Enum.FileType.Invalid;
logger.Info($"Skipping invalid folder [{directory}]");
continue;
}
foreach (string file in Directory.GetFiles(directory))
{
DirectoryFile newFile = new DirectoryFile(
folderName: directory + "\\"
, fullFileName: file
, fileName: Path.GetFileName(file)
, fileStatus: fileStatus
, fileType: fileType
);
newFile.FileContent = FileUtility.ReadFile(newFile.FullFileName);
application.InputFileList.Add(newFile);
}
logger.Info($"Successfully read [{Directory.GetFiles(directory).Count()}] files from folder [{directory}]");
}
}
public bool ListFolder(string path, DirectoryBrowseMethod cb)
{
if (m_Remote != null)
{
if (Running && m_Thread != Thread.CurrentThread)
{
BeginInvoke((ReplayRenderer r) => { cb(path, m_Remote.ListFolder(path)); });
return(true);
}
DirectoryFile[] contents = new DirectoryFile[0];
// prevent pings while fetching remote FS data
lock (m_Remote)
{
contents = m_Remote.ListFolder(path);
}
cb(path, contents);
return(true);
}
return(false);
}
public void TestTemplate()
{
var file = new DirectoryFile(TestFile);
var fullDir = Path.Combine(ExtractPath, Path.GetFileNameWithoutExtension(file.FilePath) + Path.DirectorySeparatorChar);
Directory.CreateDirectory(fullDir);
using var extractor = new Extractor(file);
}
public void AddContentTest()
{
DirectoryFile intouchFile1 = new DirectoryFile("abc", "abc", Model.Enum.FileStatus.ReadFromFileSystem);
intouchFile1.FileContent = FileUtility.ReadFile("..\\..\\TestFiles\\bank_20160517220202_test.csv");
ApplicationController.ProcessBankIntouch(intouchFile1);
Assert.AreEqual(intouchFile1.FileContent, "abc");
}
/// <summary>
/// Process all Intouch Bank CSVs
/// </summary>
private static void ProcessBankIntouchData(DirectoryFile directoryFile)
{
List <BankIntouch> BankIntouchODS = new List <BankIntouch>();
List <BankIntouch> BankIntouchNew = new List <BankIntouch>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> BankIntouchFileString = new List <string[]>();
List <BankIntouch> BankIntouchFile = new List <BankIntouch>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", BankIntouchFileString, 9, true);
foreach (string[] bankIntouchString in BankIntouchFileString)
{
BankIntouch BankIntouch = new BankIntouch
{
Date = Convert.ToDateTime(bankIntouchString[0]),
BankDescription = bankIntouchString[1],
AccountNumber = bankIntouchString[2],
EmployeeName = bankIntouchString[3],
Description = bankIntouchString[4],
UserComments = bankIntouchString[5],
Amount = Convert.ToDecimal(bankIntouchString[6]),
Net = Convert.ToDecimal(bankIntouchString[7]),
VAT = Convert.ToDecimal(bankIntouchString[8])
};
BankIntouchFile.Add(BankIntouch);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
var query = (from row in context.BankIntouch
select row).ToList();
BankIntouchODS = query;
foreach (BankIntouch bankIntouch in BankIntouchFile)
{
if (!BankIntouchODS.Contains(bankIntouch) && !String.IsNullOrEmpty(bankIntouch.Description))
{
BankIntouchNew.Add(bankIntouch);
newRows++;
}
}
foreach (BankIntouch bankIntouch in BankIntouchNew)
{
context.BankIntouch.Add(bankIntouch);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
/// <summary>
/// Process all Invoice CSVs
/// </summary>
public static void ProcessInvoiceData(DirectoryFile directoryFile)
{
List <Invoice> InvoiceODS = new List <Invoice>();
List <Invoice> InvoiceNew = new List <Invoice>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> InvoiceFileString = new List <string[]>();
List <Invoice> InvoiceFile = new List <Invoice>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", InvoiceFileString, 9, true);
foreach (string[] invoiceString in InvoiceFileString)
{
Invoice Invoice = new Invoice
{
Date = Convert.ToDateTime(invoiceString[0]),
Description = invoiceString[1],
ContractReference = invoiceString[2],
ClientName = invoiceString[3],
InvoiceReference = invoiceString[4],
Total = Convert.ToDecimal(invoiceString[5]),
VAT = Convert.ToDecimal(invoiceString[6]),
Net = Convert.ToDecimal(invoiceString[7])
};
InvoiceFile.Add(Invoice);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
var query = (from row in context.Invoice
select row).ToList();
InvoiceODS = query;
foreach (Invoice invoice in InvoiceFile)
{
if (!InvoiceODS.Contains(invoice))
{
InvoiceNew.Add(invoice);
newRows++;
}
}
foreach (Invoice invoice in InvoiceNew)
{
context.Invoice.Add(invoice);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
public bool Open()
{
(string.IsNullOrEmpty(Filename)).Then(CreateDefaultFilename);
DirectoryFile.CreateDirectory(Filename);
Filename = DirectoryFile.GetIncrementedFilename(Filename);
StreamWriter = new StreamWriter(Filename);
IsOpen = true;
return(true);
}
public SettingsService(IExceptionHandler exceptionHandler,
SettingsBag settingsBag,
DirectoryFile directoryFile)
{
Types = new List <Type>();
Filename = Path.Combine(Constants.General.SettingsSubdir, Constants.General.SettingsFilename);
SettingsBag = settingsBag;
ExceptionHandler = exceptionHandler;
DirectoryFile = directoryFile;
}
/// <summary>
/// Process all Intouch Bank CSVs
/// </summary>
public static void ProcessBankData(DirectoryFile directoryFile)
{
List <Bank> BankODS = new List <Bank>();
List <Bank> BankNew = new List <Bank>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> BankFileString = new List <string[]>();
List <Bank> BankFile = new List <Bank>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", BankFileString, 9, true);
foreach (string[] bankString in BankFileString)
{
Bank Bank = new Bank
{
FITID = Convert.ToInt64(bankString[0]),
PostedDate = Convert.ToDateTime(bankString[1]),
Amount = Convert.ToDecimal(bankString[2]),
PayeeFriendlyName = bankString[3],
Activity = bankString[4],
TransferType = bankString[5]
};
BankFile.Add(Bank);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
var query = (from row in context.Bank
select row).ToList();
BankODS = query;
foreach (Bank bank in BankFile)
{
if (!BankODS.Contains(bank))
{
BankNew.Add(bank);
newRows++;
}
}
foreach (Bank bank in BankNew)
{
context.Bank.Add(bank);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
/// <summary>
/// Process all Intouch ExpenseEdit CSVs
/// </summary>
public static void ProcessExpenseEditData(DirectoryFile directoryFile)
{
List <ExpenseEdit> ExpenseEditODS = new List <ExpenseEdit>();
List <ExpenseEdit> ExpenseEditNew = new List <ExpenseEdit>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> ExpenseEditFileString = new List <string[]>();
List <ExpenseEdit> ExpenseEditFile = new List <ExpenseEdit>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", ExpenseEditFileString, 9, true);
foreach (string[] expenseEditString in ExpenseEditFileString)
{
ExpenseEdit ExpenseEdit = new ExpenseEdit
{
Date = Convert.ToDateTime(expenseEditString[0]),
Description = expenseEditString[1],
Detail = expenseEditString[2],
Total = Convert.ToDecimal(expenseEditString[3]),
EffectiveDate = Convert.ToDateTime(expenseEditString[4]),
EffectiveDescription = expenseEditString[5]
};
ExpenseEditFile.Add(ExpenseEdit);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
var query = (from row in context.ExpenseEdit
select row).ToList();
ExpenseEditODS = query;
foreach (ExpenseEdit expenseEdit in ExpenseEditFile)
{
if (!ExpenseEditODS.Contains(expenseEdit))
{
ExpenseEditNew.Add(expenseEdit);
newRows++;
}
}
foreach (ExpenseEdit expenseEdit in ExpenseEditNew)
{
context.ExpenseEdit.Add(expenseEdit);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
/// <summary>
/// Process all Bank Cater Allen XMLs
/// </summary>
public static void ProcessBankCaterAllenData(DirectoryFile directoryFile)
{
List <BankCaterAllen> BankCaterAllenODS = new List <BankCaterAllen>();
List <BankCaterAllen> BankCaterAllenNew = new List <BankCaterAllen>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
XDocument xdoc1 = XDocument.Parse(directoryFile.FileContent);
var query = from txn in xdoc1.Descendants("STMTTRN")
select new BankCaterAllen
{
FITID = Convert.ToInt64(txn.Element("FITID").Value),
TxnType = txn.Element("TRNTYPE").Value,
PostedDate = Convert.ToDateTime(
txn.Element("DTPOSTED").Value.Substring(0, 4)
+ "-" + txn.Element("DTPOSTED").Value.Substring(4, 2)
+ "-" + txn.Element("DTPOSTED").Value.Substring(6, 2)),
Amount = Convert.ToDecimal(txn.Element("TRNAMT").Value),
Name = txn.Element("NAME").Value
};
List <BankCaterAllen> BankCaterAllenFile = query.ToList();
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
var dbquery = (from row in context.BankCaterAllen
select row).ToList();
BankCaterAllenODS = dbquery;
foreach (BankCaterAllen bankCaterAllen in BankCaterAllenFile)
{
if (!BankCaterAllenODS.Contains(bankCaterAllen))
{
BankCaterAllenNew.Add(bankCaterAllen);
newRows++;
}
}
foreach (BankCaterAllen bankCaterAllen in BankCaterAllenNew)
{
context.BankCaterAllen.Add(bankCaterAllen);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
public void TestExtractorAllFilesExtractAll()
{
foreach (var f in TestFiles)
{
var file = new DirectoryFile(f);
var fullDir = Path.Combine(ExtractPath, Path.GetFileNameWithoutExtension(file.FilePath) + Path.DirectorySeparatorChar);
Directory.CreateDirectory(fullDir);
using var extractor = new Extractor(file);
extractor.ExtractAll(fullDir);
}
}
private IEnumerable <DirectoryFile> ScanFolder()
{
List <DirectoryFile> fileList = new List <DirectoryFile>();
string[] fileListString = Directory.GetFiles(FolderName);
foreach (var file in fileListString)
{
DirectoryFile newFile = new DirectoryFile
{
FileName = file,
FolderName = FolderName
};
string extension = Path.GetExtension(file);
switch (extension.ToUpper())
{
case ".OFX":
newFile.DirectoryFileType = FileType.BankTransaction;
break;
case ".CSV":
switch (file.Substring(0, 3).ToUpper())
{
case "INV":
newFile.DirectoryFileType = FileType.Invoice;
break;
case "EXP":
newFile.DirectoryFileType = FileType.Expense;
break;
case "BAN":
newFile.DirectoryFileType = FileType.BankMetadata;
break;
default:
newFile.DirectoryFileType = FileType.Invalid;
break;
}
break;
default:
newFile.DirectoryFileType = FileType.Invalid;
break;
}
if (!(newFile.DirectoryFileType == FileType.Invalid))
{
fileList.Add(newFile);
}
}
return(fileList);
}
protected override Task InternalStart(CancellationToken token)
{
DirectoryFile dfo = new DirectoryFile(Path, SearchPattern, SearchOption);
dfo.Output.Select(s => {
return(new TOutputSchema()
{
Filename = s
});
}).Subscribe(OutputHandler, token);
return(Task.CompletedTask);
}
/// <summary>
/// Process Salary CSV
/// </summary>
public static void ProcessSalaryData(DirectoryFile directoryFile)
{
List <Salary> SalaryDIM = new List <Salary>();
List <Salary> SalaryNew = new List <Salary>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> SalaryString = new List <string[]>();
List <Salary> SalaryFile = new List <Salary>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", SalaryString, 13, true);
foreach (string[] salaryString in SalaryString)
{
Salary salary = new Salary
{
SalaryDate = Convert.ToDateTime(salaryString[1]),
TaxCode = salaryString[2],
TotalPay = Convert.ToDecimal(salaryString[3]),
TaxDeducted = Convert.ToDecimal(salaryString[4]),
EmployeeNIC = Convert.ToDecimal(salaryString[5]),
EmployeePension = Convert.ToDecimal(salaryString[6]),
SickPay = Convert.ToDecimal(salaryString[7]),
ParentingPay = Convert.ToDecimal(salaryString[8]),
StudentLoan = Convert.ToDecimal(salaryString[9]),
NetPay = Convert.ToDecimal(salaryString[10]),
EmployerNIC = Convert.ToDecimal(salaryString[11]),
EmployerPension = Convert.ToDecimal(salaryString[12])
};
SalaryFile.Add(salary);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
context.Database.ExecuteSqlCommand("delete from DIM.Salary");
foreach (Salary salary in SalaryFile)
{
context.Salary.Add(salary);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to DIM from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
/// <summary>
/// Process all Intouch BankEdit CSVs
/// </summary>
public static void ProcessBankEditData(DirectoryFile directoryFile)
{
List <BankEdit> BankEditODS = new List <BankEdit>();
List <BankEdit> BankEditNew = new List <BankEdit>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> BankEditFileString = new List <string[]>();
List <BankEdit> BankEditFile = new List <BankEdit>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", BankEditFileString, 9, true);
foreach (string[] bankEditString in BankEditFileString)
{
BankEdit BankEdit = new BankEdit
{
FITID = Convert.ToInt64(bankEditString[0]),
EffectiveDate = Convert.ToDateTime(bankEditString[1]),
EffectiveAmount = Convert.ToDecimal(bankEditString[2])
};
BankEditFile.Add(BankEdit);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
var query = (from row in context.BankEdit
select row).ToList();
BankEditODS = query;
foreach (BankEdit bankEdit in BankEditFile)
{
if (!BankEditODS.Contains(bankEdit))
{
BankEditNew.Add(bankEdit);
newRows++;
}
}
foreach (BankEdit bankEdit in BankEditNew)
{
context.BankEdit.Add(bankEdit);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
/// <summary>
/// Process DividendThreshold CSV
/// </summary>
public static void ProcessDividendThresholdData(DirectoryFile directoryFile)
{
List <DividendThreshold> DividendThresholdDIM = new List <DividendThreshold>();
List <DividendThreshold> DividendThresholdNew = new List <DividendThreshold>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> DividendThresholdString = new List <string[]>();
List <DividendThreshold> DividendThresholdFile = new List <DividendThreshold>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", DividendThresholdString, 7, true);
foreach (string[] dividendThresholdString in DividendThresholdString)
{
DividendThreshold dividendThreshold = new DividendThreshold
{
ThresholdID = Convert.ToInt32(dividendThresholdString[0]),
FinYear = dividendThresholdString[1],
MinAmount = Convert.ToDecimal(dividendThresholdString[2]),
MaxAmount = Convert.ToDecimal(dividendThresholdString[3]),
TaxPct = Convert.ToDecimal(dividendThresholdString[4]),
IsOptimumBand = Convert.ToInt16(dividendThresholdString[5]),
NetAmountCarryOver = Convert.ToDecimal(dividendThresholdString[6])
};
DividendThresholdFile.Add(dividendThreshold);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
context.Database.ExecuteSqlCommand("delete from DIM.DividendThreshold");
foreach (Model.DividendThreshold dividendThreshold in DividendThresholdFile)
{
context.DividendThreshold.Add(dividendThreshold);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to DIM from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
/// <summary>
/// Process PayeeMapping CSV
/// </summary>
public static void ProcessPayeeMappingData(DirectoryFile directoryFile)
{
List <PayeeMapping> PayeeMappingDIM = new List <PayeeMapping>();
List <PayeeMapping> PayeeMappingNew = new List <PayeeMapping>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> PayeeMappingString = new List <string[]>();
List <PayeeMapping> PayeeMappingFile = new List <PayeeMapping>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", PayeeMappingString, 9, true);
foreach (string[] payeeMappingString in PayeeMappingString)
{
PayeeMapping payeeMapping = new PayeeMapping
{
ID = Convert.ToInt32(payeeMappingString[0]),
PayeeID = Convert.ToInt32(payeeMappingString[1]),
PayeeFriendlyName = payeeMappingString[2],
PayeeSourceName = payeeMappingString[3],
PayeeSource = payeeMappingString[4]
};
PayeeMappingFile.Add(payeeMapping);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
context.Database.ExecuteSqlCommand("delete from ODS.PayeeMapping");
foreach (PayeeMapping payeeMapping in PayeeMappingFile)
{
context.PayeeMapping.Add(payeeMapping);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
/// <summary>
/// Process TransactionType CSV
/// </summary>
public static void ProcessTransactionTypeData(DirectoryFile directoryFile)
{
List <Model.TransactionType> TransactionTypeDIM = new List <Model.TransactionType>();
List <Model.TransactionType> TransactionTypeNew = new List <Model.TransactionType>();
int newRows = 0;
try
{
logger.Info($"Started processing file [{directoryFile.FileName}]");
List <string[]> TransactionTypeString = new List <string[]>();
List <Model.TransactionType> TransactionTypeFile = new List <Model.TransactionType>();
FileUtility.CSVStringReader(directoryFile.FileContent, ",", TransactionTypeString, 9, true);
foreach (string[] transactionTypeString in TransactionTypeString)
{
Model.TransactionType transactionType = new Model.TransactionType
{
TransactionTypeID = Convert.ToInt32(transactionTypeString[0]),
TransactionCategory = transactionTypeString[1],
TransactionSubCategory = transactionTypeString[2],
Activity = transactionTypeString[3],
};
TransactionTypeFile.Add(transactionType);
}
using (BusinessAccountingEntities context = new BusinessAccountingEntities())
{
context.Database.ExecuteSqlCommand("delete from DIM.TransactionType");
foreach (Model.TransactionType transactionType in TransactionTypeFile)
{
context.TransactionType.Add(transactionType);
}
context.SaveChanges();
logger.Info($"Added [{newRows.ToString()}] rows to ODS from file [{directoryFile.FileName}]");
logger.Info($"Finished processing file [{directoryFile.FileName}]");
}
}
catch (Exception e)
{
logger.Error($"Exception while trying to process file [{directoryFile.FileName}]. Exception [{e.ToString()}]");
throw;
}
}
public async Task TestExtractorExtractAllAsync()
{
var file = new DirectoryFile(TestFile);
var fullDir = Path.Combine(ExtractPath, Path.GetFileNameWithoutExtension(file.FilePath) + Path.DirectorySeparatorChar);
Directory.CreateDirectory(fullDir);
int entriesToRead = file.EntryBlocks.Sum(b => b.Entries.Count);
int entriesToDecompress = file.EntryBlocks.SelectMany(b => b.Entries.Where(e => e.IsCompressed)).Count();
int entriesRead = 0;
int entriesDecompressed = 0;
object _lock = new object();
void func(EntryOperation e)
{
lock (_lock)
{
switch (e.OperationPerformed)
{
case EntryOperation.ProcessType.Read:
entriesRead++;
Console.WriteLine($"Read: {entriesRead}/{entriesToRead}");
break;
case EntryOperation.ProcessType.Decompress:
entriesDecompressed++;
Console.WriteLine($"Decompressed: {entriesDecompressed}/{entriesToDecompress}");
break;
default:
break;
}
}
}
Progress <EntryOperation> prog = new Progress <EntryOperation>(func);
using var extractor = new Extractor(file);
var task = extractor.ExtractAllAsync(fullDir, prog);
await task;
}
public void Populate(string path, DirectoryFile[] files)
{
HasPopulated = true;
if (files.Length == 1 && files[0].flags.HasFlag(DirectoryFileProperty.ErrorAccessDenied))
{
AccessDenied = true;
return;
}
foreach (DirectoryFile file in files)
{
DirectoryFileTreeNode child = new DirectoryFileTreeNode();
child.Filename = file.filename;
if (Path == "/")
child.Path = Path + file.filename;
else
child.Path = Path + "/" + file.filename;
child.IsHidden = file.flags.HasFlag(DirectoryFileProperty.Hidden);
child.IsExecutable = file.flags.HasFlag(DirectoryFileProperty.Executable);
child.IsDirectory = file.flags.HasFlag(DirectoryFileProperty.Directory);
children.Add(child);
}
}
public void ExceptionVariants()
{
var dir = new DirectoryFile().GetFullyQualifiedDirectory(new LogToFile().GetFullPathFilename());
Debug.WriteLine("TestException() directory is " + dir);
new DirectoryFile().DeleteDirectoryWithFiles(dir);
// verify that directory has been deleted
Assert.False(Directory.Exists(dir));
TestMessageLogging();
ThrowException();
ThrowExceptionWithCustomMsg();
ThrowExceptionInner();
var text = File.ReadAllText(Path.Combine(dir, General.ExceptionFilename));
Assert.True(text.IndexOf(TestExceptionMsg) > -1);
Assert.True(text.IndexOf(TestThrowingExceptionMsg) > -1);
Assert.True(text.IndexOf(CustomMsg) > -1);
Assert.True(text.IndexOf(TestThrowingExceptionCustomMsg) > -1);
Assert.True(text.IndexOf(InnerExceptionMsg) > -1);
Assert.True(true);
}
private void SetUpSettingsService()
{
_directoryFile = new DirectoryFile();
_settingsService = new GenLib.Config.SettingsService();
_settingsService.IncludeType(typeof(TestSetting));
}
public bool ListFolder(string path, DirectoryBrowseMethod cb)
{
if (m_Remote != null)
{
if (Running && m_Thread != Thread.CurrentThread)
{
BeginInvoke((ReplayRenderer r) => { cb(path, m_Remote.ListFolder(path)); });
return true;
}
DirectoryFile[] contents = new DirectoryFile[0];
// prevent pings while fetching remote FS data
lock(m_Remote)
{
contents = m_Remote.ListFolder(path);
}
cb(path, contents);
return true;
}
return false;
}
public LoggingObserver(IExceptionHandler exceptionHandler, DirectoryFile directoryFile)
{
ExceptionHandler = exceptionHandler;
DirectoryFile = directoryFile;
}
public void MainTest()
{
DirectoryFile intouchFile1 = new DirectoryFile("abc", "abc", Model.Enum.FileStatus.ReadFromFileSystem);
Assert.AreEqual(intouchFile1.FolderName, "abc");
}
public void SimpleReadTest()
{
_ = new DirectoryFile(TestFile);
}
public bool SaveConfig()
{
DirectoryFile.CreateDirectory(Filename);
new StreamWriter(Filename).Using(sw => XmlSerializer.Serialize(sw, SettingsBag));
return(true);
}
