public void FileCreateAndRead()
{
//Arrange
string filePath = @"C:/TFS/JeroenH/TestingFolderFilesAndMore/FileCreateAndRead.txt";
FileArchiver fileArchiver = new FileArchiver();
using (StreamWriter sw = File.CreateText(filePath))
{
sw.WriteLine("Bla bla");
}
Thread.Sleep(1000);
//Act
var result = fileArchiver.FileContent;
//Assert
Assert.AreEqual("Bla bla", result);
Assert.IsTrue(fileArchiver.HasChanged);
//Garbage Collection
Thread.Sleep(100);
File.Delete(filePath);
Thread.Sleep(100);
}
public void FileCreateAndCopyToArchiveFolder()
{
//Arrange
string filePath = @"C:/TFS/JeroenH/TestingFolderFilesAndMore/FileCreateAndCopyToArchiveFolder.txt";
FileArchiver fileArchiver = new FileArchiver();
using (StreamWriter sw = File.CreateText(filePath))
{
Thread.Sleep(100);
sw.WriteLine("Bla bla");
}
string date = DateTime.Now.Date.ToString();
Thread.Sleep(1000);
//Act
//Assert
//Assert.IsTrue(File.Exists($"C:/TFS/JeroenH/TestingFolderFilesAndMore/FileCreateAndRead_{date}/FileCreateAndRead.txt"));
//Garbage Collection
Thread.Sleep(100);
File.Delete(filePath);
//File.Delete($"C:/TFS/JeroenH/TestingFolderFilesAndMore/Archive/FileCreateAndRead_{date}.txt");
Thread.Sleep(100);
}
public void FileCreatedEvent()
{
//Arrange
string filePath = @"C:/TFS/JeroenH/TestingFolderFilesAndMore/FileCreatedEvent.txt";
FileArchiver fileArchiver = new FileArchiver();
//Act
StreamWriter sw = File.CreateText(filePath);
Thread.Sleep(200);
bool result = fileArchiver.HasCreated;
//Assert
Assert.IsTrue(result);
//Garbage Collection
sw.Dispose();
Thread.Sleep(100);
File.Delete(filePath);
Thread.Sleep(100);
}
public void BackupFile()
{
Monitor.Enter(this.Lock);
try
{
if (this.database.logger.PropIncrementBackup)
{
if (this.Fa.IsStreamElement(this.BackupFileName))
{
this.DeleteBackup();
}
}
else if (this.Fa.IsStreamElement(this.DataFileName))
{
FileArchiver.Archive(this.DataFileName, this.BackupFileName + ".new", this.database.logger.GetFileAccess(), 1);
}
}
catch (IOException exception)
{
this.database.logger.LogSevereEvent(FwNs.Core.LC.cResources.SR.DataFileCache_SetIncrementBackup_backupFile_failed, exception);
throw Error.GetError(0x1d2, exception);
}
finally
{
Monitor.Exit(this.Lock);
}
}
public void HandlesExistingFileName()
{
// Create Source file
string sourceFilePath = Path.Combine(TestTempDirectory, "TestFile.txt");
File.WriteAllText(sourceFilePath, "Test Content");
// Create Destination file
string destinationDirectory = Path.Combine(TestTempDirectory, "Archive");
Directory.CreateDirectory(destinationDirectory);
File.WriteAllText(Path.Combine(destinationDirectory, "TestFile.txt"), "Test Content");
FileArchiver.ArchiveFile(sourceFilePath, destinationDirectory);
string[] files = Directory.GetFiles(destinationDirectory);
// CodeGen.GenerateAssertions(files, "files"); // The following assertions were generated on 21-Feb-2011
#region Generated Assertions
Assert.AreEqual(2, files.Length);
Assert.AreEqual(TestTempDirectory + "\\Archive\\TestFile.txt", files[0]);
Assert.AreEqual(TestTempDirectory + "\\Archive\\TestFile.txt.1", files[1]);
#endregion
}
static void Main(string[] args)
{
// Ikke akkurat dependency injection
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var measurementRepo = new MeasurementRepository(context);
var eventFetcher = new FilesystemEventDataFetcher();
var measurementReader = new MeasurementReader();
var fileArchiver = new FileArchiver();
var ingestor = new MeasurementIngestor(eventRepo, measurementRepo, eventFetcher, measurementReader, fileArchiver);
ingestor.ReadAndIngestData();
}
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var allEvents = eventRepo.GetAll()
.ToList();
var test = new RenderTest();
foreach (var bsEvent in allEvents)
{
test.Render(bsEvent);
}
}
}
public void Before()
{
FileInfo = new Mock <IFileInfo>();
Checker = new Mock <IArchiveNecessityChecker>();
FileService = new Mock <IFileService>();
DirectoryService = new Mock <IDirectoryService>();
Archiver = new FileArchiver(
FileInfo.Object, "", Checker.Object, FileService.Object, DirectoryService.Object);
}
public void ArchiveDirectory()
{
const string dirArch = @"\\cgivmapp_test\D$\App_Working_Folder\SalesAudit\EcomSales";
const string zipPath = @"\\cgivmapp_test\D$\App_Working_Folder\SalesAudit\EcomSales\Archive\archived.zip";
var result = new FileArchiver().ArchiveDirectory(dirArch,
zipPath);
Assert.Contains(result, val => val.ArchivalStatus);
}
static ILogWriter CreateBasicFileWriter()
{
var fileInfo = new SystemFileInfo("logs.txt");
var checker = new TimeArchiveNecessityChecker(fileInfo, 5, TimeUnit.SECONDS);
var archiver = new FileArchiver(fileInfo, "Archive", checker);
return(FileLogWriter.Builder()
.SetFileInfo(fileInfo)
.SetFileArchiver(archiver)
.Build());
}
public void BackupData()
{
if (this._database.logger.PropIncrementBackup)
{
this._fa.RemoveElement(this._fileName + ".backup");
}
else if (this._fa.IsStreamElement(this._fileName + ".data"))
{
FileArchiver.Archive(this._fileName + ".data", this._fileName + ".backup.new", this._database.logger.GetFileAccess(), 1);
}
}
public MainWindowViewModel(IEventAggregator eventAggregator)
{
eventAggregator.Subscribe(this);
_logger = new CompositeLogger();
_logger.Add(this);
_logger.Add(new TextLogger());
_archiver = new FileArchiver(eventAggregator);
_watcher = new FileSystemWatcher();
_watcher.Created += Archive;
}
static ILogWriter CreateErrorsFileWriter()
{
var errorsFileInfo = new SystemFileInfo("errors.txt");
var errorsChecker = new SizeArchiveNecessityChecker(errorsFileInfo, 100, MemoryUnit.B);
var fileNameFormatter = new MillisecondsArchiveFileNameFormatter("json");
var errorsArchiver = new FileArchiver(errorsFileInfo, "Archive_Errors", errorsChecker, fileNameFormatter: fileNameFormatter);
var logLevels = new LogLevel[] { LogLevel.ERROR, LogLevel.FATAL };
return(FileLogWriter.Builder()
.SetFileInfo(errorsFileInfo)
.SetFileArchiver(errorsArchiver)
.SetAllowedLogLevels(logLevels)
.Build());
}
public void FirstHandlesArchiveExistanceThenMovesTheLog()
{
var sequence = new MockSequence();
DirectoryService = new Mock <IDirectoryService>(MockBehavior.Strict);
FileService = new Mock <IFileService>(MockBehavior.Strict);
DirectoryService.InSequence(sequence).Setup(x => x.Exists(It.IsAny <string>())).Returns(false);
DirectoryService.InSequence(sequence).Setup(x => x.Create(It.IsAny <string>()));
FileService.InSequence(sequence).Setup(x => x.Move(It.IsAny <string>(), It.IsAny <string>()));
Archiver = new FileArchiver(FileInfo.Object, "", Checker.Object, FileService.Object, DirectoryService.Object);
Archiver.Archive();
DirectoryService.Verify(x => x.Exists(It.IsAny <string>()), Times.Once);
DirectoryService.Verify(x => x.Create(It.IsAny <string>()), Times.Once);
FileService.Verify(x => x.Move(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public void Test1()
{
var arc = new ArchiveDefinition
{
FileLocation =
@"\\cgivmapp_test\D$\App_Working_Folder\SalesAudit\EcomSales\XPOLLD09800001_2018-08-20_04-57-58",
ZipLocation = @"\\cgivmapp_test\D$\App_Working_Folder\SalesAudit\EcomSales\Archive",
ZipFileName = "newZipFile.zip"
};
var result = new FileArchiver().ArchiveFile(new List <IArchiveDefinition>
{
arc
});
Assert.Contains(result, val => val.ArchivalStatus);
}
public Application(AppConfiguration configuration, CSVFieldOverrides fieldOverrides, ILogger logger)
{
this.configuration = configuration;
this.fieldOverrides = fieldOverrides;
this.logger = logger;
try
{
timeStamp = DateTime.Now;
fileArchiver = new FileArchiver(this.timeStamp, this.logger);
this.templateFile = new FileInfo(Environment.ExpandEnvironmentVariables(configuration.ExcelTemplatePath));
this.csvFile = new FileInfo(Environment.ExpandEnvironmentVariables(configuration.CSVReportPath));
}
catch (Exception ex)
{
logger.Error("Failed to parse file paths | Reason: {0}", ex);
Environment.Exit(0);
}
}
public void Archive_SavesFileInProvidedDestinationDirectory()
{
var mockLog = new Mock <ILogger>();
FileInfo inputFile = new FileInfo("../../../Utilities/TestData/TestFileToArchive.txt").CopyTo("../../../Utilities/TestData/CopyToArchive.txt");;
DirectoryInfo destinationDirectory = new DirectoryInfo("../../../Utilities/TestData/ExistingTestDirectory");
DateTime timestamp = DateTime.Now;
FileArchiver archiver = new FileArchiver(timestamp, mockLog.Object);
String expectedDestinationDirectory = destinationDirectory.FullName;
FileInfo result = archiver.Archive(inputFile, destinationDirectory);
String resultDirectoryPath = result.DirectoryName;
result.Delete();
Assert.Contains(expectedDestinationDirectory, resultDirectoryPath);
}
public void Archive_AppendsDateTimeStampToEndOfFileName()
{
var mockLog = new Mock <ILogger>();
FileInfo inputFile = new FileInfo("../../../Utilities/TestData/TestFileToArchive.txt").CopyTo("../../../Utilities/TestData/CopyToArchive.txt");
DirectoryInfo destinationDirectory = new DirectoryInfo("../../../Utilities/TestData/ExistingTestDirectory");
DateTime timestamp = DateTime.Now;
//Match String such as /Utilities/TestData/TestFileToArchive_20002021-142245.txt
Regex pattern = new Regex("^.+_[\\d-]+\\..*");
FileArchiver archiver = new FileArchiver(timestamp, mockLog.Object);
FileInfo result = archiver.Archive(inputFile, destinationDirectory);
String resultFullName = result.FullName;
result.Delete();
inputFile.Delete();
Assert.Matches(pattern, resultFullName);
}
private bool RestoreBackup()
{
bool flag;
this.DeleteOrResetFreePos();
try
{
UtlFileAccess fileAccess = this.database.logger.GetFileAccess();
if (fileAccess.IsStreamElement(this.BackupFileName))
{
FileArchiver.Unarchive(this.BackupFileName, this.DataFileName, fileAccess, 1);
return(true);
}
flag = false;
}
catch (Exception exception)
{
object[] add = new object[] { exception.Message, this.BackupFileName };
throw Error.GetError(exception, 0x1c4, 0x1a, add);
}
return(flag);
}
static void Main(string[] args)
{
var sw = new Stopwatch();
sw.Start();
SetupTraceListeners();
List <BillettServiceEvent> updatedEvents;
// Ikke akkurat dependency injection
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var measurementRepo = new MeasurementRepository(context);
var eventFetcher = new FilesystemEventDataFetcher();
var measurementReader = new MeasurementReader();
var fileArchiver = new FileArchiver();
var ingestor = new MeasurementIngestor(eventRepo, measurementRepo, eventFetcher, measurementReader, fileArchiver);
updatedEvents = ingestor.ReadAndIngestData().ToList();
}
Trace.TraceInformation("{0} events updated: {1}", updatedEvents.Count, String.Join(", ", updatedEvents.Select(e => e.EventNumber)));
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var allEvents = eventRepo.GetAll()
//.Where(e => updatedEvents.Any(ue => ue.EventNumber == e.EventNumber))
.ToList();
var missingFileEvents =
allEvents.Where(
ev =>
!File.Exists(Path.Combine(StautConfiguration.Current.StaticImageDirectory,
ev.EventNumber + ".png")))
.ToList();
var eventsToRender =
missingFileEvents.Concat(
allEvents.Where(
ae =>
!missingFileEvents.Contains(ae) &&
updatedEvents.Any(ue => ue.EventNumber == ae.EventNumber))).ToList();
var test = new RenderTest();
foreach (var bsEvent in eventsToRender)
{
test.Render(bsEvent);
}
}
sw.Stop();
Trace.TraceInformation("Ingest process complete, took {0}ms", sw.ElapsedMilliseconds);
Trace.Flush();
Trace.Close();
}
