Exemple #1
0
        private FileTypeExtension GetFileType(string filePath, FileTypeExtension defaultValue)
        {
            var fileExtension = Path.GetExtension(filePath);

            if (string.IsNullOrEmpty(fileExtension))
            {
                return(defaultValue);
            }

            if (fileExtension.StartsWith("."))
            {
                fileExtension = fileExtension.Substring(1);
            }

            foreach (var enumName in Enum.GetNames(typeof(FileTypeExtension)))
            {
                if (string.Equals(enumName, fileExtension, StringComparison.CurrentCultureIgnoreCase))
                {
                    var enumValue = (FileTypeExtension)Enum.Parse(typeof(FileTypeExtension), enumName);
                    return(enumValue);
                }
            }

            return(defaultValue);
        }
Exemple #2
0
        /// <summary>
        /// Reads some text from file.
        /// </summary>
        /// <param name="fileName">The name of file</param>
        /// <param name="fileFormat">The file format extension</param>
        /// <param name="filePath">The location of file to write to</param>
        /// <param name="isCreateNewAndSave">If value is true, indicating save file as new file</param>
        /// <returns></returns>

        public async Task <List <string> > ReadTextFromFileAsync(string fileName, FileTypeExtension fileFormat, string filePath, bool isCreateNewAndSave = true)
        {
            var text    = default(string);
            var content = new List <string>();


            try
            {
                filePath = NormalizePath(filePath);

                filePath = ResolvePath(filePath);

                await AsyncEngine.AwaitAsync(nameof(FileManager) + filePath, async() =>
                {
                    await Task.Run(() =>
                    {
                        using (var streamReader = (TextReader) new StreamReader(File.Open($"{filePath}/{fileName}{FileExtensions.FileTypeExtensions(fileFormat)}", FileMode.Open)))
                        {
                            while (streamReader.Peek() > -1)
                            {
                                text = streamReader.ReadLine();

                                content = text.Split(new char[] { '\n' }).ToList();
                            }
                        }
                    });
                });
            }
            catch (Exception Ex)
            {
                Logger.Log($"{Ex.Message}", LogLevel.Error);
            }

            return(content);
        }
        /// <summary>
        /// Show the open file window to the user
        /// </summary>
        /// <param name="preferredFileType">Preferred file extension</param>
        private void ShowOpenFileWindow(FileTypeExtension preferredFileType)
        {
            var fileTypesUsed = new List <FileTypeExtension>
            {
                FileTypeExtension.Txt,
                FileTypeExtension.Tsv,
                FileTypeExtension.Csv,
                FileTypeExtension.Xls,
                FileTypeExtension.Xlsx
            };

            var filter = GetFilterSpec(preferredFileType);

            foreach (var fileType in fileTypesUsed)
            {
                if (fileType != preferredFileType)
                {
                    filter += GetFilterSpec(fileType);
                }
            }

            filter += "All files (*.*)|*.*";

            ShowOpenFileWindow(filter);
        }
Exemple #4
0
        private string GetFilterSpec(FileTypeExtension fileType)
        {
            switch (fileType)
            {
            case FileTypeExtension.Txt:
                return("Tab delimited txt files (*.txt)|*.txt|");

            case FileTypeExtension.Csv:
                return("CSV files (*.csv)|*.csv|");

            case FileTypeExtension.Xls:
                return("Excel files (*.xls)|*.xls|");

            case FileTypeExtension.Xlsx:
                return("Excel 2007 files (*.xlsx)|*.xlsx|");

            default:
                throw new ArgumentException("fileType", "Unrecognized value for fileType: " + fileType);
            }
        }
Exemple #5
0
        /// <summary>
        /// Gets the specific file extension, and return it.
        /// </summary>
        /// <param name="fileType">The type of file extension format</param>
        /// <returns></returns>
        public static string FileTypeExtensions(FileTypeExtension type)
        {
            switch (type)
            {
            case FileTypeExtension.DOC:
                return(".doc");

            case FileTypeExtension.TXT:
                return(".txt");

            case FileTypeExtension.PDF:
                return(".pdf");

            case FileTypeExtension.LOG:
                return(".log");

            default:
                Debugger.Break();
                return(null);
            }
        }
Exemple #6
0
        /// <summary>
        /// Show a file dialog to allow the user to choose an expressions file to load
        /// </summary>
        protected void OpenExpressionFileCheckExisting()
        {
            if (mhtDatasets.ContainsKey("Expressions"))
            {
                MessageBox.Show("Expressions are already loaded.", "Error", MessageBoxButtons.OK,
                                MessageBoxIcon.Exclamation);
                return;
            }

            mDataSetType  = enmDataType.ESET;
            mstrFldgTitle = "Open Expressions";

            ShowOpenFileWindow(mMostRecentFileType);

            if (string.IsNullOrWhiteSpace(mstrLoadedfileName))
            {
                return;
            }

            mMostRecentFileType = GetFileType(mstrLoadedfileName, mMostRecentFileType);

            OpenExpressionFile(mstrLoadedfileName);
        }
        /// <summary>
        /// Show a file dialog to allow the user to choose an expressions file to load
        /// </summary>
        protected void OpenExpressionFileCheckExisting()
        {
            if (mhtDatasets.ContainsKey("Expressions"))
            {
                MessageBox.Show("Expressions are already loaded.", "Error", MessageBoxButtons.OK,
                                MessageBoxIcon.Exclamation);
                return;
            }

            mDataSetType = enmDataType.ESET;
            mstrFldgTitle = "Open Expressions";

            ShowOpenFileWindow(mMostRecentFileType);

            if (string.IsNullOrWhiteSpace(mstrLoadedfileName))
            {
                return;
            }

            mMostRecentFileType = GetFileType(mstrLoadedfileName, mMostRecentFileType);

            OpenExpressionFile(mstrLoadedfileName);
        }
Exemple #8
0
        /// <summary>
        /// Writes some text to add to the file.
        /// </summary>
        /// <param name="text">The text to write to</param>
        /// <param name="fileName">The name of file</param>
        /// <param name="fileFormat">The file format extension</param>
        /// <param name="filePath">The location of file to write to</param>
        /// <param name="isAppend">If value is true, indicating add text to the end of file</param>
        /// <returns></returns>
        public async Task WriteTextToFileAsync(string fileName, FileTypeExtension fileFormat, string filePath, string text, bool isAppend = false)
        {
            try
            {
                filePath = NormalizePath(filePath);

                filePath = ResolvePath(filePath);

                await AsyncEngine.AwaitAsync(nameof(FileManager) + filePath, async() =>
                {
                    await Task.Run(() =>
                    {
                        using (var streamWriter = (TextWriter) new StreamWriter(File.Open($"{filePath}/{fileName}{FileExtensions.FileTypeExtensions(fileFormat)}", isAppend ? FileMode.Append : FileMode.Create)))
                        {
                            streamWriter.Write(text);
                        }
                    });
                });
            }
            catch (Exception Ex)
            {
                Logger.Log($"{Ex.Message}", LogLevel.Error);
            }
        }
Exemple #9
0
 /// <summary>
 /// Default constructor
 /// </summary>
 /// <param name="fileName">The name of file logger.</param>
 /// <param name="fileFormat">The format extension of file logger</param>
 /// <param name="filePath">The location of file logger</param>
 public FileLogger(string fileName, FileTypeExtension fileFormat, string filePath)
 {
     FilePath   = filePath;
     FileName   = fileName;
     FileFormat = fileFormat;
 }
        /// <summary>
        /// Show the open file window to the user
        /// </summary>
        /// <param name="preferredFileType">Preferred file extension</param>
        private void ShowOpenFileWindow(FileTypeExtension preferredFileType)
        {
            var fileTypesUsed = new List<FileTypeExtension>
            {
                FileTypeExtension.Txt,
                FileTypeExtension.Csv,
                FileTypeExtension.Xls,
                FileTypeExtension.Xlsx
            };

            var filter = GetFilterSpec(preferredFileType);

            foreach (var fileType in fileTypesUsed)
            {
                if (fileType != preferredFileType)
                    filter += GetFilterSpec(fileType);
            }

            filter += "All files (*.*)|*.*";

            ShowOpenFileWindow(filter);
        }
 private string GetFilterSpec(FileTypeExtension fileType)
 {
     switch (fileType)
     {
         case FileTypeExtension.Txt:
             return "Tab delimited txt files (*.txt)|*.txt|";
         case FileTypeExtension.Csv:
             return "CSV files (*.csv)|*.csv|";
         case FileTypeExtension.Xls:
             return "Excel files (*.xls)|*.xls|";
         case FileTypeExtension.Xlsx:
             return "Excel 2007 files (*.xlsx)|*.xlsx|";
         default:
             throw new ArgumentException("fileType", "Unrecognized value for fileType: " + fileType);
     }
 }
        private FileTypeExtension GetFileType(string filePath, FileTypeExtension defaultValue)
        {
            var fileExtension = Path.GetExtension(filePath);
            if (string.IsNullOrEmpty(fileExtension))
                return defaultValue;

            if (fileExtension.StartsWith("."))
                fileExtension = fileExtension.Substring(1);

            foreach (var enumName in Enum.GetNames(typeof(FileTypeExtension)))
            {
                if (string.Equals(enumName, fileExtension, StringComparison.CurrentCultureIgnoreCase))
                {
                    var enumValue = (FileTypeExtension)Enum.Parse(typeof(FileTypeExtension), enumName);
                    return enumValue;
                }

            }

            return defaultValue;
        }
		internal async Task<FindFileResponse> FindFirstAsyncInternal(FileTypeExtension fileType)
		{
			return await FindFirstAsyncInternal("*." + fileType.ToString());
		}
Exemple #14
0
        /// <summary>
        /// Reads all text from our monitor files.
        /// </summary>
        /// <param name="fileName">The name of file</param>
        /// <param name="fileFormat">The file format extension</param>
        /// <param name="filePath">The location of file to write to</param>
        /// <returns></returns>
        public async Task <List <string> > ReadTextFromMonitorFile(string filePath, string fileName, FileTypeExtension fileFormat)
        {
            var content = new List <string>();

            try
            {
                content = await File.ReadTextFromFileAsync(fileName, fileFormat, filePath, false);

                return(content);
            }
            catch (Exception Ex)
            {
                Debug.WriteLine($"Message: {Ex.Message}");
            }


            return(content);
        }