예제 #1
0
        public static bool CreateAFile(FileDto fileDto)
        {
            if (!IsFileDtoValid(fileDto))
            {
                return false;
            }

            fileDto.FileXinfo.Refresh();

            if (fileDto.FileXinfo.Exists)
            {
                return true;
            }

            try
            {
                fileDto.FileXinfo.Create();
            }
            catch
            {
                return false;
            }

            return true;
        }
예제 #2
0
        public StreamWriterDto(FileDto swFile, Encoding streamWriterEncoding)
        {
            if (!FileHelper.IsFileDtoValid(swFile))
            {
                var ex = new Exception("Invalid FileDto Passed to StreamWriter!");
                var err = new FileOpsErrorMessageDto
                {
                    DirectoryPath = string.Empty,
                    ErrId = 2,
                    ErrorMessage = ex.Message,
                    ErrSourceMethod = "SetStreamWriter()",
                    ErrException = ex,
                    FileName = string.Empty,
                    LoggerLevel = LogLevel.FATAL
                };

                ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
                ErrorMgr.WriteErrorMsg(err);
                throw ex;

            }

            _streamWriterEncoding = streamWriterEncoding;

            CreateStreamWriter(swFile.FileXinfo.FullName);
        }
예제 #3
0
        public void ConsoleCommandShouldCorrectlyProcessWithNoCommandExecutor()
        {
            var mainTestDir = TestDirectories.GetMainLibLoadTestDir();
            var xmlFileDto = new FileDto(mainTestDir, ".\\XmlCmdFiles\\CmdFile002.xml");

            if (!FileHelper.IsFileDtoValid(xmlFileDto) || !xmlFileDto.FileXinfo.Exists)
            {
                Assert.IsTrue(false);
            }

            var cmdExeDto = TestDirectories.GetConsoleExecutorDto();
            cmdExeDto.XmlCmdFileDto = xmlFileDto;

            var builder = new XmlParameterBuilder(cmdExeDto);

            var jobGroup = builder.BuildParmsFromXml();

            var job = jobGroup.Jobs[0];

            Assert.IsNotNull(job);

            var expectedProcFile = "npm";
            var expectedProcArgs = "install --save-dev gulp-jshint gulp-jscs jshint-stylish";

            Assert.IsTrue(job.ProcFileNameCommand == expectedProcFile);

            Assert.IsTrue(job.ProcFileArguments == expectedProcArgs);
        }
예제 #4
0
        public ApplicationLogger(
				string defaultApplicationLogPathFileName,
						string logFileTimeStamp)
        {
            _logfileTimeStamp = StringHelper.TrimStringEnds(logFileTimeStamp);

            _defautlLogFileDto = ExtractLogFileDto(defaultApplicationLogPathFileName,
                                                            _logfileTimeStamp);

            _defaultApplicationLogPathFileBaseName = defaultApplicationLogPathFileName;

            if (!FileHelper.IsFileDtoValid(_defautlLogFileDto))
            {
                var msg = "Default Command Console Log File is INVALID!";
                var err = new FileOpsErrorMessageDto
                {
                    DirectoryPath = string.Empty,
                    ErrId = 1,
                    ErrorMessage = msg,
                    ErrSourceMethod = "Constructor()",
                    FileName = defaultApplicationLogPathFileName,
                    LoggerLevel = LogLevel.FATAL
                };

                ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
                ErrorMgr.WriteErrorMsg(err);

                throw new Exception(msg);

            }

            try
            {

                FileHelper.DeleteAFile(_defautlLogFileDto);

                _currentApplicationLogPathFileBaseName = defaultApplicationLogPathFileName;
                _currentLogfileDto = new FileDto(_defautlLogFileDto.FileXinfo.FullName);

            }
            catch (Exception ex)
            {
                var msg = "Consold Command Log Setup Failed! " + ex.Message;
                var err = new FileOpsErrorMessageDto
                {
                    DirectoryPath = string.Empty,
                    ErrId = 3,
                    ErrorMessage = msg,
                    ErrSourceMethod = "Constructor()",
                    FileName = defaultApplicationLogPathFileName,
                    LoggerLevel = LogLevel.FATAL
                };

                ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
                ErrorMgr.WriteErrorMsg(err);

                throw;
            }
        }
예제 #5
0
 public void Test002CreateFileDtoUsingFileNameOnly()
 {
     var testStr = @"SomefileName.txt";
     var expectedDir = TestDirectories.GetTestExeDir();
     var expectedResult = Path.Combine(expectedDir.DirInfo.FullName, testStr);
     var fileDto = new FileDto(testStr);
     Assert.IsTrue(fileDto.FileXinfo.FullName == expectedResult);
 }
예제 #6
0
        public void Test001CreateFileDtoUsingFileNameString()
        {
            var testStr = @"D:\Level1\Level2\SomefileName.txt";

            var fileDto = new FileDto(testStr);

            Assert.IsTrue(fileDto.FileXinfo.FullName == testStr);
        }
예제 #7
0
 public void Test003CreateFileDtoWithNoExt()
 {
     var testStr = @"D:\Level1\Level2";
     var expectedResult = "Level2";
     var expectedDir = @"D:\Level1";
     var fileDto = new FileDto(testStr);
     Assert.IsTrue(fileDto.FileXinfo.Name == expectedResult);
     Assert.IsTrue(fileDto.DirDto.DirInfo.FullName == expectedDir);
 }
예제 #8
0
 public void Test005CreateFileDtoFromFileAndDirectoryCombination()
 {
     var testStr = @"D:\Level1\Level2";
     var testDirDto = new DirectoryDto(testStr);
     var fileComponent = @"SomefileName.txt";
     var expectedResult = @"D:\Level1\Level2\SomefileName.txt";
     var fileDto = new FileDto(testDirDto, fileComponent);
     Assert.IsTrue(FileHelper.IsFileDtoValid(fileDto));
     Assert.IsTrue(fileDto.FileXinfo.FullName == expectedResult);
 }
예제 #9
0
        private bool DeleteOldLogFiles(string[] logFiles)
        {
            if (logFiles == null || logFiles.Length < 1)
            {
                return true;
            }

            TimeSpan dif = new TimeSpan(_logRetentionInDays, 0, 0, 0);

            DateTime threshold = DateTime.Now.Subtract(dif);

            foreach (var logFile in logFiles)
            {
                try
                {
                    var fileDto = new FileDto(logFile);

                    if (fileDto.FileXinfo.CreationTime < threshold)
                    {
                        FileHelper.DeleteAFile(fileDto);
                    }
                }
                catch (Exception ex)
                {
                    var err = new FileOpsErrorMessageDto
                    {
                        DirectoryPath = string.Empty,
                        ErrId = 79,
                        ErrorMessage = "Exception Thrown While Deleting Log File!",
                        ErrSourceMethod = "PurgeOldLogs",
                        ErrException = ex,
                        FileName = logFile,
                        LoggerLevel = LogLevel.INFO
                    };

                    ErrorMgr.WriteErrorMsg(err);

                }
            }

            return true;
        }
예제 #10
0
        public static bool CreateDirectoryAndFile(FileDto fileDto)
        {
            if (!IsFileDtoValid(fileDto))
            {
                return false;
            }

            fileDto.DirDto.DirInfo.Refresh();

            if (fileDto.FileXinfo.Exists)
            {
                return true;
            }

            if (!fileDto.DirDto.DirInfo.Exists)
            {
                try
                {
                    fileDto.DirDto.DirInfo.Create();

                    fileDto.DirDto.DirInfo.Refresh();

                    if (!fileDto.DirDto.DirInfo.Exists)
                    {
                        return false;
                    }
                }
                catch
                {
                    return false;
                }

            }

            return CreateAFile(fileDto);
        }
예제 #11
0
 public StreamWriterDto(FileDto swFile)
     : this(swFile, Encoding.UTF8)
 {
 }
예제 #12
0
        private void SetLogFileDto()
        {
            LogPathFileNameDto?.Dispose();

            var fName = LogFileNameOnly + "_" + LogFileTimeStamp + "." + LogFileExtensionWithNoLeadingDot;
            var fileDto = new FileDto(LogDirectoryDto, fName);

            if (!FileHelper.IsFileDtoValid(fileDto))
            {
                var msg = "Application Log Directory Dto Invalid!";
                var ex = new ArgumentException(msg);

                var err = new FileOpsErrorMessageDto
                {
                    ErrId = 35,
                    ErrorMessage = "Application Log Directory Dto Invalid!",
                    ErrSourceMethod = "CreateApplicaitonLogDirectory()",
                    ErrException = ex,
                    FileName = fName,
                    DirectoryPath = LogDirectoryDto?.DirInfo?.FullName,
                    LoggerLevel = LogLevel.FATAL
                };

                ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
                ErrorMgr.WriteErrorMsg(err);

                throw ex;

            }

            LogPathFileNameDto = fileDto;
        }
예제 #13
0
        public static bool CreateDirectoryIfNecessary(FileDto fileDto)
        {
            if (!FileHelper.IsFileDtoValid(fileDto))
            {
                return false;
            }

            return CreateDirectoryIfNecessary(fileDto.DirDto);
        }
예제 #14
0
        public static bool DeleteAFile(FileDto fileDto)
        {
            if (fileDto?.FileXinfo == null)
            {
                return false;
            }

            if (!fileDto.FileXinfo.Exists)
            {
                return true;
            }

            try
            {
                fileDto.FileXinfo.Delete();
            }
            catch
            {
                return false;
            }

            return true;
        }
예제 #15
0
        protected virtual void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (!_disposed)
            {
                // If disposing equals true, dispose all managed
                // and unmanaged resources.
                if (disposing)
                {
                    // Dispose managed resources.
                    if (_swDto != null)
                    {
                        _swDto.GetStreamWriter().Flush();
                        _swDto.Close();
                        _swDto = null;
                    }

                    if (_defautlLogFileDto != null)
                    {
                        _defautlLogFileDto.Dispose();
                        _defautlLogFileDto = null;
                    }

                    if (_currentLogfileDto != null)
                    {
                        _currentLogfileDto.Dispose();
                        _currentLogfileDto = null;
                    }

                }

                // Note disposing has been done.
                _disposed = true;

            }
        }
예제 #16
0
        public static bool DeleteFileWithZeroBytes(FileDto fileDto)
        {
            if (!IsFileDtoValid(fileDto))
            {
                return false;
            }

            return fileDto.FileXinfo.Length != 0 || DeleteAFile(fileDto);
        }
예제 #17
0
        protected virtual void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (!_disposed)
            {
                // If disposing equals true, dispose all managed
                // and unmanaged resources.
                if (disposing)
                {
                    // Dispose managed resources.
                    if (XmlCmdFileDto != null)
                    {
                        XmlCmdFileDto.Dispose();
                        XmlCmdFileDto = null;
                    }

                    if (DefaultCommandExeDirectoryDto!=null)
                    {
                        DefaultCommandExeDirectoryDto.Dispose();
                        DefaultCommandExeDirectoryDto = null;
                    }
                }

                // Note disposing has been done.
                _disposed = true;

            }
        }
예제 #18
0
        public void CreateNewStreamWriter(FileDto fileDto)
        {
            CloseStreamWriter();

            _swDto = new StreamWriterDto(_currentLogfileDto);
        }
예제 #19
0
        public static FileDto GetXmlCmdTest002FileDto()
        {
            var fileName = "\\XmlCmdFiles\\Test002.xml";
            var testDir = GetMainLibLoadTestDir();
            var result = new FileDto(testDir.DirInfo.FullName + fileName);
            if (!FileHelper.IsFileDtoValid(result) || !result.FileXinfo.Exists)
            {
                throw new Exception("Invalid FileDto created for XmlCmdFile: " + fileName);
            }

            return result;
        }
예제 #20
0
        public static FileDto GetXmlCmdFileDto()
        {
            var fileName = ConfigurationManager.AppSettings["DefaultXmlCmdFile"];
            var testDir = GetMainLibLoadTestDir();
            var result = new FileDto(testDir.DirInfo.FullName + "\\" + fileName);
            if (!FileHelper.IsFileDtoValid(result))
            {
                throw new Exception("Invalid FileDto created for XmlCmdFile: " + fileName);
            }

            return result;
        }
예제 #21
0
        public static bool DoesFileExist(FileDto targetFileDto)
        {
            if (targetFileDto?.FileXinfo == null)
            {
                return false;
            }

            return targetFileDto.FileXinfo.Exists;
        }
예제 #22
0
        public void Close()
        {
            if (_swWriter != null)
            {
                _swWriter.Flush();
                _swWriter.Close();
                _swWriter.Dispose();
                _swWriter = null;
            }

            if (_fStream != null)
            {
                _fStream.Close();
                _fStream.Dispose();
                _fStream = null;
            }

            if (StreamWriterFile != null)
            {
                StreamWriterFile.Dispose();
                StreamWriterFile = null;

            }
        }
예제 #23
0
        public static bool IsFileDtoValid(FileDto fileDto)
        {
            if (fileDto?.FileXinfo == null
                || fileDto.DirDto == null)
            {
                return false;
            }

            if (string.IsNullOrWhiteSpace(fileDto.FileXinfo.FullName)
                || fileDto.FileXinfo.FullName.Length < 4)
            {
                return false;
            }

            if (!DirectoryHelper.IsDirectoryDtoValid(fileDto.DirDto))
            {
                return false;
            }

            return true;
        }
예제 #24
0
        public bool CreateStreamWriter(string swFileName)
        {
            Close();

            StreamWriterFile = new FileDto(swFileName);

            if (!FileHelper.IsFileDtoValid(StreamWriterFile))
            {
                var ex = new Exception("Invalid FileDto Passed to StreamWriter!");
                var err = new FileOpsErrorMessageDto
                {
                    DirectoryPath = string.Empty,
                    ErrId = 30,
                    ErrorMessage = ex.Message,
                    ErrSourceMethod = "CreateStreamWriter()",
                    ErrException = ex,
                    FileName = string.Empty,
                    LoggerLevel = LogLevel.FATAL
                };

                ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
                ErrorMgr.WriteErrorMsg(err);
                throw ex;
            }

            try
            {
                StreamWriterFile.DirDto.DirInfo.Refresh();

                if (!StreamWriterFile.DirDto.DirInfo.Exists)
                {
                    if (!DirectoryHelper.CreateDirectoryIfNecessary(StreamWriterFile))
                    {
                        var ex = new Exception("Failed to create directory for StreamWriter!");
                        var err = new FileOpsErrorMessageDto
                        {
                            DirectoryPath = string.Empty,
                            ErrId = 30,
                            ErrorMessage = ex.Message,
                            ErrSourceMethod = "CreateStreamWriter()",
                            ErrException = ex,
                            FileName = string.Empty,
                            LoggerLevel = LogLevel.FATAL
                        };

                        ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
                        ErrorMgr.WriteErrorMsg(err);
                        throw ex;

                    }
                }

                _fStream = new FileStream(StreamWriterFile.FileXinfo.FullName,
                                            FileMode.Append,
                                                FileAccess.Write,
                                                    FileShare.ReadWrite);

                _swWriter = new StreamWriter(_fStream,_streamWriterEncoding);
            }
            catch(Exception ex)
            {
                var err = new FileOpsErrorMessageDto
                {
                    DirectoryPath = string.Empty,
                    ErrId = 32,
                    ErrorMessage = "Failed To Create StreamWriter! " + ex.Message,
                    ErrSourceMethod = "SetStreamWriter()",
                    ErrException = ex,
                    FileName = string.Empty,
                    LoggerLevel = LogLevel.FATAL
                };

                ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
                ErrorMgr.WriteErrorMsg(err);

                throw;
            }

            return true;
        }
예제 #25
0
        public void LoggerShouldInitializeCorrectly()
        {
            var appLogDir = ".//installDir";
            var logDirDto = new DirectoryDto(appLogDir);

            if (logDirDto.DirInfo.Exists)
            {
                DirectoryHelper.DeleteADirectory(logDirDto);
            }

            var appLogFileNameOnly = "LibLoadTests";
            var appLogFileExensionWithoutLeadingDot = "log";
            var appLogFileTimeStamp = DateHelper.NowYearMthDayHrsSecs();

            var appLogMgr = new ApplicationLogMgr(appLogDir,
                                                    appLogFileNameOnly,
                                                        appLogFileExensionWithoutLeadingDot,
                                                            appLogFileTimeStamp);

            var logger = appLogMgr.ConfigureLogger();

            Assert.IsTrue(appLogMgr.LogPathFileNameDto.FileXinfo.Exists);

            var logFileName = appLogMgr.LogPathFileNameDto.FileXinfo.FullName;

            LogUtil.ConfigureLogger(logger);

            LogUtil.WriteLog(LogLevel.INFO, "Test9758: Originated from Test Method: LoggerShouldInitializeCorrectly()");

            LogUtil.Dispose();

            appLogMgr.Dispose();

            FileStream fs = new FileStream(logFileName,FileMode.Open,FileAccess.Read,FileShare.Read);

            StreamReader fr = new StreamReader(fs);

            var sb = new StringBuilder();

            sb.Append(fr.ReadToEnd());

            fs.Flush();
            fs.Close();
            fr.Close();
            fs.Dispose();
            fr.Dispose();
            var s = sb.ToString();
            var result = s.IndexOf("Test9758", StringComparison.Ordinal);

            var logFileDto = new FileDto(logFileName);

            DirectoryHelper.DeleteADirectory(logDirDto);

            logFileDto.FileXinfo.Refresh();
            Assert.IsFalse(logFileDto.FileXinfo.Exists);

            logFileDto.Dispose();
            logDirDto.Dispose();

            Assert.IsTrue(result > -1);
        }