private static StreamFilter CreateFilter(FileTypes fileType, bool removeAssemblyVersion = false)
{
var filterItems = new List<StreamFilter.Item>();
if (fileType == FileTypes.Res)
{
if (!removeAssemblyVersion)
{
return StreamFilter.None;
}
filterItems.Add(new StreamFilter.RegexItem(regexVsVersionInfoRes, true, 0));
filterItems.Add(new StreamFilter.RegexItem(regexProductVersionRes, true, 0));
filterItems.Add(new StreamFilter.RegexItem(regexFileVersionRes, true, 0));
filterItems.Add(new StreamFilter.RegexItem(regexAssemblyVersionRes, true, 0));
}
else
{
filterItems.Add(new StreamFilter.StartsWithItem("// Entry point code", true, 2));
filterItems.Add(new StreamFilter.StartsWithItem(".imagebase"));
filterItems.Add(new StreamFilter.StartsWithItem("//", false));
filterItems.Add(new StreamFilter.ContainsItem("<PrivateImplementationDetails>", false));
filterItems.Add(new StreamFilter.StartsWithItem(" .custom", false,
skipUntil: new StreamFilter.ContainsItem(" )")));
filterItems.Add(new StreamFilter.StartsWithItem(" .custom", false,
skipUntil: new StreamFilter.ContainsItem(" )")));
if (removeAssemblyVersion)
{
filterItems.Add(new StreamFilter.ContainsItem("AssemblyFileVersionAttribute", false));
filterItems.Add(new StreamFilter.StartsWithItem(" .ver", false));
}
}
return new StreamFilter(filterItems.ToArray());
}
public static string GetFileName(DateTime timeStamp, FileTypes fileType, FileStates fileState)
{
var fileName = "{0:yyyyMMdd-HHmmss-fff}.{1}.{2}"
.FormatWith(timeStamp, fileType, fileState);
return fileName;
}
internal RealFile(String name, IRealFile parent, String fullPath, FileTypes fileType)
{
this.parent = parent;
this.name = name;
this.fullPath = fullPath;
this.fileType = fileType;
}
/// <summary>
/// Adds an IFile to the elements orginizer.
/// </summary>
/// <param name="file1"></param>
public void AddFile(FileTypes.IFile file1)
{
if (_files.Contains(file1))
{
}
}
public static void TestConversion(IConverter converter, string sourceFileName, FileTypes sourceFormat, FileTypes targetFormat, bool assertSuccess)
{
string sourceFile = Path.GetFullPath(sourceFileName);
// Get a temporary target file
TempFolder tempFolder = new TempFolder();
string targetFile = tempFolder.getFilePath("target." + targetFormat);
// Do the conversion
bool converted = converter.Convert(sourceFile, (int)sourceFormat, targetFile, (int)targetFormat);
if (assertSuccess)
{
// Check that converter returned true
Assert.IsTrue(converted);
// Check that converter created the target file and it's not empty
Assert.AreNotEqual(0, new FileInfo(targetFile).Length);
}
else
{
// Check that converter returned false
Assert.IsFalse(converted);
}
// Delete the temp folder created
tempFolder.Release();
}
public File GetNewRawFile(FileTypes fileTypes)
{
var timestamp = _clock.NextUniqueTimeStamp();
var fileName = LocationExtensions.GetFileName(timestamp, fileTypes, FileStates.Raw);
var file = _vendorLocation.GetChildFile(fileName);
return file;
}
public static byte[] CreateFile(ReportFromFileDefinitionFacade report, FileTypes outputType = FileTypes.PDF)
{
var localReport = GetNewLocalReport(report.ReportDataSet);
localReport.ReportPath = report.DefinitionFilePath;
return localReport.Render(outputType.ToString());
}
public File GetNewStandardizedFile(FileTypes fileType)
{
var timeStamp = _clock.NextUniqueTimeStamp();
var filename = LocationExtensions.GetFileName(timeStamp, fileType, FileStates.Standardized);
var file = _readyLocation.GetChildFile(filename);
return file;
}
public IEnumerable<File> GetFiles(FileTypes type, FileStates state)
{
var searchPattern = "*.{0}.{1}"
.FormatWith(type, state);
var files = _vendorLocation.GetFiles(searchPattern);
return files;
}
public File GetNewErrorFile(FileTypes fileType)
{
var errorDirectory = GetErrorDirectory();
var timeStamp = _clock.NextUniqueTimeStamp();
var filename = LocationExtensions.GetFileName(timeStamp, fileType, FileStates.Error);
var file = errorDirectory.GetChildFile(filename);
return file;
}
public static StreamFilter GetFilter(FileTypes fileType, bool removeAssemblyVersion = false)
{
StreamFilter filter;
var key = new Tuple<FileTypes, bool>(fileType, removeAssemblyVersion);
if (!_filters.TryGetValue(key, out filter))
{
filter = _filters[key] = CreateFilter(fileType, removeAssemblyVersion);
}
return filter;
}
// Generic function to get instance of parser class based on file type.
public static Parser GetParser(string filePath, FileTypes type)
{
Parser parsr = null;
switch (type)
{
case FileTypes.CSV:
parsr = new CsvParser(filePath, System.Globalization.CultureInfo.CurrentUICulture.TextInfo.ListSeparator[0]);
break;
case FileTypes.TAB:
parsr = new CsvParser(filePath, '\t');
break;
case FileTypes.XLS:
try
{
parsr = new ExcelParser(filePath, HttpContext.Current.Session["SheetName"].ToString());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
break;
case FileTypes.XLSX:
try
{
parsr = new ExcelParser(filePath, HttpContext.Current.Session["SheetName"].ToString());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
break;
case FileTypes.MDB:
try
{
parsr = new AccessParser(filePath, HttpContext.Current.Session["TableName"].ToString());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
break;
case FileTypes.ACCDB:
try
{
parsr = new AccessParser(filePath, HttpContext.Current.Session["TableName"].ToString());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
break;
}
return parsr;
}
/// <summary>
/// NOTE:: RETURNS NEW MODIFIED HEADER OBJECT. This function considers the filetype required to parse, then assigns the work to another function. It requires the header object to modify and the index of the signal to be written to.
/// </summary>
/// <param name="fileType"></param>
/// <param name="path"></param>
/// <param name="signalIndex"></param>
public EDFHeader.EDFHeader addFile(FileTypes fileType, string path, EDFHeader.EDFHeader iHeader, int signalIndexStart, int signalIndexEnd)
{
Console.WriteLine("Adding file {0}", path);
switch (fileType)
{
case FileTypes.zeoEEGCNT:
return addZeoEEGCNT(path, iHeader, signalIndexStart, signalIndexEnd);
default:
return iHeader;
throw new ArgumentException("Adding file failed. Specfied filetype argument incorrect");
}
}
public static byte[] CreateFile(ReportFromStreamDefinitionFacade report, FileTypes ouputType = FileTypes.PDF)
{
var localReport = GetNewLocalReport(report.ReportDataSet);
localReport.LoadReportDefinition(report.Definition);
foreach (var subReport in report.SubReports)
{
localReport.LoadSubreportDefinition(subReport.Name, subReport.Definition);
}
return localReport.Render(ouputType.ToString());
}
/// <summary>
/// Gets ssytenm folder path.
/// </summary>
/// <param name="fileType">system folder type.</param>
/// <returns>system folder path or empty string if not found.</returns>
internal static String GetSystemFolder(FileTypes fileType)
{
switch (fileType)
{
case FileTypes.MyDocuments:
return platform.GetMyDocumentsFolder();
case FileTypes.Desktop:
return platform.GetDesktopFolder();
default:
return "";
}
}
public static void startSendFile(string filePath, int x, FileTypes ext)
{
if (shouldZip)
{
fileP = filePath;
xTime = x;
comparezipping(ext, x);
return;
}
if (x == 50)
{
return;
}
fileP = filePath;
xTime = x;
bytesPerPush = (x + 1) * 1000;
sendFileInf(filePath);
}
public void TestValidateBlankFile(string fileName)
{
string testFolder = GetTestDataFolder();
IFileProcessor fileProcessor = new FileProcessor();
FileTypes fileTypes = FileTypes.GetFileTypes();
DataFile testFile = fileProcessor.FetchAllDataFiles(fileTypes, testFolder)
.Find(x => x.FileName.Contains(fileName));
FileType fileType = new FileType();
FileProcessStatus validationSuccess = FileProcessStatus.Undetermined;
string[] file = fileProcessor.ValidateInputFile(testFile, fileTypes, ref fileType, testFolder, ref validationSuccess);
//Test if the array returned by the validate function has nothing in it
Assert.AreEqual(0, file.Count());
//Test if correct fileprocessing status is returned
Assert.AreEqual(FileProcessStatus.BlankFileDetected, validationSuccess);
}
private void OnFileHeaderReceived(int numPackages, string name, FileTypes type, double id)
{
FileInterface file = new FileInterface();
file.Name = name;
file.NumPackages = numPackages;
file.id = id;
file.type = type;
ReceivedFiles.Add(file);
if (type == FileTypes.ExeFile)
{
MessageEvent("Updating Program.");
}
else
{
MessageEvent("Downloading file " + file.Name);
}
}
public static string GetFileExtension(FileTypes fileType)
{
string extension = "";
switch (fileType)
{
case FileTypes.Text:
extension = ".txt";
break;
case FileTypes.Doc:
extension = ".doc";
break;
case FileTypes.Excel:
extension = ".xls";
break;
case FileTypes.ExcelX:
extension = ".xlsx";
break;
case FileTypes.PDF:
extension = ".pdf";
break;
case FileTypes.csv:
extension = ".csv";
break;
case FileTypes.XML:
extension = ".xml";
break;
case FileTypes.Zip:
extension = ".zip";
break;
case FileTypes.IIF:
extension = ".IIF";
break;
}
return(extension);
}
private async void AssociatedObject_Drop(object sender, Windows.UI.Xaml.DragEventArgs e)
{
if (e.DataView != null &&
e.DataView.Properties != null)
{
var def = e.GetDeferral();
if (e.DataView.Contains(StandardDataFormats.StorageItems))
{
if (sender is GridView grid)
{
if (grid.DataContext is GalleryPageViewModel vm)
{
var items = await e.DataView.GetStorageItemsAsync();
foreach (var item in items)
{
if (item is StorageFile file)
{
if (FileTypes.IsSupportedExtension(file.FileType)) // Check if file type is supported. Using MIME allows for all kinds of videos and images.
{
await CopyLocalFile(vm, file);
}
else if (file.FileType.Equals(".url", StringComparison.InvariantCultureIgnoreCase)) // If file is an internet shortcut.
{
await DownloadFromUrl(file);
}
else if (file.FileType.Equals(".webp", StringComparison.InvariantCultureIgnoreCase)) // If file is an internet shortcut.
{
await DownloadFromWebp(file);
}
}
}
}
}
}
def.Complete();
}
else
{
e.AcceptedOperation = DataPackageOperation.None;
}
}
/*
* os_read_file_name
*
* Return the name of a file. Flag can be one of:
*
* FILE_SAVE - Save game file
* FILE_RESTORE - Restore game file
* FILE_SCRIPT - Transcript file
* FILE_RECORD - Command file for recording
* FILE_PLAYBACK - Command file for playback
* FILE_SAVE_AUX - Save auxiliary ("preferred settings") file
* FILE_LOAD_AUX - Load auxiliary ("preferred settings") file
*
* The length of the file name is limited by MAX_FILE_NAME. Ideally
* an interpreter should open a file requester to ask for the file
* name. If it is unable to do that then this function should call
* print_string and read_string to ask for a file name.
*
*/
public static bool read_file_name(out string file_name, string default_name, FileTypes flag)
{
String fileName = "";
switch (flag)
{
case FileTypes.FILE_SAVE:
fileName = _screen.OpenNewOrExistingFile(FastMem.save_name, "Choose save game file", "Save Files (*.sav)|*.sav", ".sav");
break;
case FileTypes.FILE_RESTORE:
fileName = _screen.OpenExistingFile(FastMem.save_name, "Choose save game to restore", "Save Files (*.sav)|*.sav");
break;
case FileTypes.FILE_SCRIPT:
fileName = _screen.OpenNewOrExistingFile(General.DEFAULT_SCRIPT_NAME, "Choose Script File", "Script File (*.scr)|*.scr", ".scr");
break;
case FileTypes.FILE_RECORD:
fileName = _screen.OpenNewOrExistingFile(default_name, "Choose File to Record To", "Record File(*.rec)|*.rec", ".rec");
break;
case FileTypes.FILE_PLAYBACK:
fileName = _screen.OpenExistingFile(default_name, "Choose File to playback from", "Record File(*.rec)|*.rec");
break;
case FileTypes.FILE_SAVE_AUX:
case FileTypes.FILE_LOAD_AUX:
fail("Need to implement other types of files");
break;
}
if (fileName != null)
{
file_name = fileName;
return(true);
}
else
{
file_name = null;
return(false);
}
}
/// <summary>
/// Create file in file server with additional directory, Replace file if exist
/// </summary>
/// <param name="fileData">File data to write.</param>
/// <param name="fileType">Type of the file.</param>
/// <param name="directory">Any directory path before fileName.</param>
/// <param name="fileName">Name of the file.</param>
public void Create(byte[] fileData, FileTypes fileType, string directory, string fileName)
{
try
{
string fullPath = GetFullFilePathOnFileServer(fileType, fileName, directory);
string dirName = Path.GetDirectoryName(fullPath);
if (null != dirName && !Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
File.WriteAllBytes(fullPath, fileData);
}
catch (Exception er)
{
throw new Exception("Error in creating file" + Environment.NewLine + er.Message);
}
}
public IHttpActionResult AddDictionary(object obj)
{
try
{
JObject JsonObject = JObject.Parse(obj.ToString());
ViewModel.tblDictionary NewDictionary = JsonObject.ToObject <ViewModel.tblDictionary>();
string FileUrl = "";
if (NewDictionary.PicUrl != "" && NewDictionary.PicUrl != null)
{
byte[] imageBytes = Convert.FromBase64String(JsonObject["PicUrl"].ToString().Split(',')[1]);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
ms.Write(imageBytes, 0, imageBytes.Length);
Image imageDictionary = Image.FromStream(ms);
FileTypes ft = new FileTypes();
string FileType = ft.FindImageTypeInString(JsonObject["PicUrl"].ToString().Split(',')[0]);
if (imageBytes.Length < 1024 * 1024 && ft.IsImage(FileType))
{
FileUrl = @"Picture\Dictionary\" + NewDictionary.IDDictionary + FileType;
imageDictionary.Save(AppDomain.CurrentDomain.BaseDirectory + FileUrl);
}
else
{
return(NotFound());
}
}
NewDictionary.PicUrl = FileUrl;
bool ret = BisDictionary.AddDictionary(NewDictionary);
if (ret)
{
return(Ok(ret));
}
else
{
return(NotFound());
}
}
catch (Exception ex)
{
return(NotFound());
}
}
public static IContentReader GetReader(FileTypes fileType)
{
if (fileType == FileTypes.Text)
{
return(new TextFileReader());
}
if (fileType == FileTypes.Xml)
{
return(new XmlFileReader());
}
if (fileType == FileTypes.Json)
{
return(new JsonFileReader());
}
throw new NotImplementedException();
}
/// <summary>The bundle file sets.</summary>
/// <param name="fileSets">The file sets.</param>
/// <param name="fileType">The file type.</param>
/// <returns>The <see cref="bool"/>.</returns>
private bool BundleFileSets(IEnumerable <IFileSet> fileSets, FileTypes fileType)
{
if (fileSets.Any())
{
var varBySettings = new { fileSets, fileType, this.context.Configuration };
return(this.context.SectionedAction(SectionIdParts.BundleActivity, fileType.ToString())
.MakeCachable(varBySettings, isSkipable: true)
.RestoreFromCacheAction(this.RestoreBundleFromCache)
.Execute(cacheSection =>
{
this.context.Log.Information("Begin {0} bundle pipeline".InvariantFormat(fileType));
var result = this.Bundle(fileSets, fileType);
this.context.Log.Information("End {0} bundle pipeline".InvariantFormat(fileType));
return result;
}));
}
return(true);
}
private async ValueTask AddToParentsChildrenCollection(NodeID parentPath, NodeID requested, FileTypes.Ft fileType, IDatabaseSession db)
{
var parentDir = await db.Read(parentPath);
var alreadyPresent = parentDir?.Attributes.Items
.FirstOrDefault(kv => kv.Key.Equals(Attr.Children))
?.Value.Map?.Items?.Any(x => x.Key.Equals(requested)) ?? false;
if (!alreadyPresent)
{
var dataToAdd = new Node
{
Id = parentPath,
Attributes = new Map
{
Items = new List <KeyValue>()
{
Utils.Prop(DateTime.UtcNow.Ticks,
Attr.Children,
new Map
{
Items = new List <KeyValue>()
{
Utils.Prop(DateTime.UtcNow.Ticks, requested,
FileTypes.FromFt(fileType))
}
})
}
}
};
if (parentDir == null)
{
dataToAdd.Attributes.Items.Add(
Utils.Prop(DateTime.UtcNow.Ticks,
Attr.Type, FileTypes.TypeFolder
)
);
}
// Merge these new fields into the existing node.
await db.Merge(dataToAdd);
}
}
private void PerformFileAction(byte[] fileData)
{
FileTypes fileType = IdentifyFile(fileData);
switch (fileType)
{
case FileTypes.cmb:
modelFile = new ModelHandler(fileData, 0, fileData.Length);
treeViewEx1.Nodes.Add(new TreeNode(Path.GetFileName(Properties.Settings.Default.LastFile))
{
ImageKey = "default"
});
AddSepdChunksToTree(treeViewEx1, treeViewEx1.TopNode);
break;
case FileTypes.ZAR:
case FileTypes.GAR:
archiveFile = new ArchiveFile(fileData);
treeViewEx1.Enabled = true;
CreateArchiveTree();
break;
case FileTypes.LzS:
byte[] decData = LZSS.Decompress(fileData);
string outfile = @"H:\temp\mm3d-test\" + Path.GetFileName(Properties.Settings.Default.LastFile) + ".dec";
//File.WriteAllBytes(outfile, decData);
PerformFileAction(decData);
break;
case FileTypes.ZSI:
treeViewEx1.Nodes.Add(new TreeNode(Path.GetFileName(Properties.Settings.Default.LastFile))
{
ImageKey = "default"
});
zsiFile = new ZSIHandler(fileData, 0, fileData.Length);
if (zsiFile.SelectedSetup != null)
{
modelFile = zsiFile.SelectedSetup.Model;
}
AddZsiDataToTree(treeViewEx1, treeViewEx1.TopNode);
break;
}
}
public static IFileCommand FileFactory(FileTypes ft)
{
string strfilepath = string.Empty;
switch (ft)
{
case FileTypes.Product:
{
return(new ProductXML());
}
case FileTypes.LogLocations:
{
return(new clsLogLocations());
}
case FileTypes.PatchSetupFileNames:
{
return(new clsPatchSetupFileNames());
}
case FileTypes.RepositoryFolder:
{
return(new clsRepositoryFolder());
}
case FileTypes.SharedFolder:
{
return(new clsSharedFolder());
}
case FileTypes.SOSetupFileNames:
{
return(new clsSOSetupFileNames());
}
default:
{
return(new clsDefultXML());
}
}
}
public void Write(FileTypes fileTypes, Item item)
{
if ((fileTypes & FileTypes.Detail) != 0 &&
_detailGenerator.TryGenerateLine(item.Detail, out var detailLine))
{
_detailWriter.Write(detailLine);
}
if ((fileTypes & FileTypes.Link) != 0 && _linkGenerator.TryGenerateLine(item.Link, out var linkLine))
{
_linkWriter.Write(linkLine);
}
if ((fileTypes & FileTypes.Marketing) != 0 &&
_marketingGenerator.TryGenerateLine(item.Marketing, out var marketingLine))
{
_marketingWriter.Write(marketingLine);
}
if ((fileTypes & FileTypes.Option) != 0 &&
_optionsGenerator.TryGenerateLine(item.Options, out var optionLine))
{
_optionsWriter.Write(optionLine);
}
if ((fileTypes & FileTypes.Product) != 0 &&
_productGenerator.TryGenerateLine(item.Product, out var productLine))
{
_productWriter.Write(productLine);
}
if ((fileTypes & FileTypes.Specification) != 0 &&
_specificationsGenerator.TryGenerateLine(item.Specifications, out var specLine))
{
_specificationsWriter.Write(specLine);
}
//if (fileTypes.HasFlag(FileTypes.Supplier))
//{
// await _supplierWriter.Write(_supplierGenerator.GenerateLine(item.Supplier));
//}
}
public async Task <IActionResult> UpdateDocument([FromBody] UpdateDocumentRequest request)
{
var updateDocumentResponse = new UpdateDocumentResponse();
if (request.File == null || request.File.Length <= 0)
{
return(new BadRequestObjectResult(new { Message = "Requested file can not be empty." }));
}
var filePath = Path.GetTempFileName();
var fileName = Path.GetFileName(filePath);
if (!FileTypes.IsValidContentType(fileName))
{
ModelState.AddModelError(fileName, "File Type Not Supported. Only Word, Pdf, Jpg and Png file types uploadable.");
}
if (request.File.Length > 1048576)
{
ModelState.AddModelError(fileName, "Maximum File size of 1 Mb exceeded.");
}
if (ModelState.Values.Sum(c => c.Errors.Count) > 0)
{
updateDocumentResponse.HandleValidation(ModelState);
return(Ok(updateDocumentResponse));
}
var updateModel = new UpdateDocumentModel
{
DocumentId = request.DocumentId,
ProjectId = request.ProjectId,
DocumentTypeId = request.DocumentTypeId,
TagId = request.TagId,
UploadedFile = new FileModel
{
Content = request.File.OpenReadStream(),
Name = fileName
}
};
var commandHandlerResponse = await _mediator.Send(updateModel);
updateDocumentResponse.HandleSuccess(commandHandlerResponse);
return(Ok(updateDocumentResponse));
}
bool CopyDataFiles()
{
List <string> filestoignore = new List <string>()
{
};
List <string> directoriestoignore = new List <string>()
{
};
string finaldir = Path.Combine(DataPath, Destination);
if (!Directory.Exists(finaldir))
{
Directory.CreateDirectory(finaldir);
}
var files = (from file in Directory.EnumerateFiles(Source, "*", SearchOption.AllDirectories)
where FileTypes.Contains(Path.GetExtension(file), StringComparer.InvariantCultureIgnoreCase)
select new
{
Source = file,
Destination = Path.Combine(finaldir, file.Replace(Source, ""))
});
foreach (var file in files)
{
try
{
FileInfo fi = new FileInfo(file.Source);
new FileInfo(file.Destination).Directory.Create();
if (!filestoignore.Contains(fi.Name) && !directoriestoignore.Contains(fi.Directory.Name))
{
File.Copy(file.Source, file.Destination, Overwrite);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(false);
}
}
return(true);
}
public static async Task <IReadOnlyList <StorageFile> > PickFiles(FileTypes groupType)
{
FileOpenPicker fileOpenPicker = new FileOpenPicker();
switch (groupType)
{
case FileTypes.Images:
fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileOpenPicker.FileTypeFilter.Add(".jpg");
fileOpenPicker.FileTypeFilter.Add(".jpeg");
fileOpenPicker.FileTypeFilter.Add(".png");
break;
default:
break;
}
return(await fileOpenPicker.PickMultipleFilesAsync());
}
public static IFileReader FromFileType(FileTypes fileType)
{
var encryption = new ReverseTextEncryption();
var security = new RoleBasedSecurity();
switch (fileType)
{
case FileTypes.Text:
return(new TextFileReader(encryption, security));
case FileTypes.Xml:
return(new XmlFileReader(encryption, security));
case FileTypes.Json:
return(new JsonFileReader(encryption, security));
default:
throw new ArgumentOutOfRangeException(nameof(fileType), fileType, null);
}
}
/// <summary>
/// Подсчет количества файлов
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static string CountFiles(FileTypes type = FileTypes.All)
{
int resoult = 0;
LoadCatalogsAndFiles();
foreach (var Catalog in Catalogs) //Проходимся по всем вложенные каталоги и проходимся по каждому
{
if (type == FileTypes.All)
{
resoult += Catalog.Value.Count; //Считаем сколько файлов в каталогах.
}
else if (Catalog.Key.EndsWith(type.ToString()))
{
resoult += Catalog.Value.Count; //Считаем сколько файлов в нужном каталоге.
}
}
return(String.Format("Количество файлов: {0}", resoult));
}
/// <summary>
/// Sets the default folder for a file type
/// </summary>
/// <param name="fileType">The file type.</param>
/// <param name="folder">The value to set the default folder to.</param>
public void SetFolder(FileTypes fileType, string folder)
{
switch (fileType)
{
case FileTypes.Disc:
SetStringSetting(_discsFolderSettingName, folder);
break;
case FileTypes.Tape:
SetStringSetting(_tapesFolderSettingName, folder);
break;
case FileTypes.Machine:
SetStringSetting(_machinesFolderSettingName, folder);
break;
default:
throw new Exception(String.Format("Unknown FileTypes value {0}.", fileType));
}
}
// Checks the input of the args and adds defaults for empty args
public void CheckArgs()
{
if (Directories.Count == 0)
{
Console.WriteLine("[!] No directories entered. Adding all mounted drives.");
// foreach (DriveInfo d in DriveInfo.GetDrives()) {
Directories.Add("c:\\");
//}
}
if (FileTypes.Count == 0)
{
Console.WriteLine("[!] No filetypes entered. Adding '.xlsx' and '.docx' as defaults.");
foreach (string s in DefaultFileTypes)
{
FileTypes.Add(s);
}
}
}
public static bool HasFileTypeExtension(this string path, FileTypes fileType)
{
var ext = Path.GetExtension(path);
if (ext == "")
{
return(false);
}
switch (fileType)
{
case FileTypes.RasterImageFiles:
return(ValidRasterImageFilesExtensions.Contains(ext.ToLower()));
case FileTypes.DataFiles:
return(ValidDataFilesExtensions.Contains(ext.ToLower()));
default:
return(false);
}
}
public static void DeleteExistingFiles(FileTypes fileTypes, WriterConfiguration config)
{
DeleteFile(FileTypes.Detail, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.DetailFileName));
DeleteFile(FileTypes.Link, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.LinkFileName));
DeleteFile(FileTypes.Marketing, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.MarketingFileName));
DeleteFile(FileTypes.Option, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.OptionFileName));
DeleteFile(FileTypes.Product, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.ProductFileName));
DeleteFile(FileTypes.Specification, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.SpecificationFileName));
DeleteFile(FileTypes.Pure_Hierarchy, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.PureHierarchyFileName));
DeleteFile(FileTypes.Supplier, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.SupplierFileName));
DeleteFile(FileTypes.Json, fileTypes,
Path.Combine(config.OutputPath, config.CsvDirectory, config.JsonFileName));
}
public bool Set(FileTypes viewModel)
{
bool result = false;
try
{
UpdateTextByFile(AudioFilesPath, viewModel.AudioFiles);
UpdateTextByFile(DataFilesPath, viewModel.DataFiles);
UpdateTextByFile(DocumentFilesPath, viewModel.DocumentFiles);
UpdateTextByFile(ExecutableFilesPath, viewModel.ExecutablesFiles);
UpdateTextByFile(GraphicFilesPath, viewModel.GraphicFiles);
UpdateTextByFile(VideoFilesPath, VideoFilesPath);
UpdateTextByFile(WebFilesPath, viewModel.WebFiles);
result = true;
}
catch (Exception)
{
}
return(result);
}
public void SaveTargetDir(FileTypes selectedFileType, string serialInput, string positionInput)
{
Microsoft.Win32.SaveFileDialog saveDialog = new Microsoft.Win32.SaveFileDialog();
saveDialog.Filter = "Data Files (*.txt)|*.txt|All Files (*.*)|*.*";
saveDialog.FileName = string.Format(@"{0}_{1}_{2}_{3:MM-yy_HHmm}.txt", selectedFileType.ToString(), serialInput, positionInput, DateTime.Now);
saveDialog.InitialDirectory = DirPath;
try
{
if (saveDialog.ShowDialog() == true)
{
FileSaveName = saveDialog.FileName;
}
}
catch (Exception saveLocEx)
{
System.Diagnostics.Trace.WriteLine(DateTime.Now + "," + saveLocEx.ToString(), ",File name or save location invalid");
FileSaveName = null;
throw;
}
}
static void comparezipping(FileTypes ext, int x)
{
if (x == 10)
{
return;
}
string filePath = "";
switch (ext)
{
case FileTypes.mp4:
filePath = @"C:\Users\Sid\Desktop\mp4\" + ((x % 5) + 1).ToString() + ".mp4";
break;
}
if (x > 4)
{
Compress(filePath); filePath = filePath.Split('.')[0] + ".zip";
}
bytesPerPush = 20000;
sendFileInf(filePath);
}
public static string[] GetFilesByType(string directoryPath, FileTypes fileType, SearchOption searchOption)
{
if (!Directory.Exists(directoryPath))
{
throw new DirectoryNotFoundException(string.Format("Directory '{0}' does not exist.", directoryPath));
}
var files = Directory.GetFiles(directoryPath, "*.*", searchOption);
switch (fileType)
{
case FileTypes.RasterImageFiles:
files = files.Where(f => f.HasFileTypeExtension(FileTypes.RasterImageFiles)).ToArray();
break;
case FileTypes.DataFiles:
files = files.Where(f => f.HasFileTypeExtension(FileTypes.DataFiles)).ToArray();
break;
}
return(files);
}
public void MapFileDataTypeExtensionTest()
{
Assert.IsTrue(FileTypes.MapFileDataTypeExtension("c:\\") == FileDataTypesEnum.unknown);
Assert.IsTrue(FileTypes.MapFileDataTypeExtension("") == FileDataTypesEnum.unknown);
Assert.IsTrue(FileTypes.MapFileDataTypeExtension(null) == FileDataTypesEnum.unknown);
Assert.IsTrue(FileTypes.MapFileDataTypeExtension("noextension") == FileDataTypesEnum.unknown);
Assert.IsTrue(FileTypes.MapFileDataTypeExtension("./test.csv") == FileDataTypesEnum.unknown);
Assert.IsTrue(FileTypes.MapFileDataTypeExtension("./test.etl") == FileDataTypesEnum.unknown);
Assert.IsTrue(FileTypes.MapFileDataTypeExtension("./test.json") == FileDataTypesEnum.unknown);
ExtensionTests(Constants.CsvExtension, FileDataTypesEnum.unknown);
ExtensionTests(Constants.DumpExtension, FileDataTypesEnum.fabriccrashdumps);
ExtensionTests(Constants.EtlExtension, FileDataTypesEnum.unknown);
ExtensionTests(Constants.JsonExtension, FileDataTypesEnum.unknown);
ExtensionTests(Constants.PerfCsvExtension, FileDataTypesEnum.counter);
ExtensionTests(Constants.PerfCtrExtension, FileDataTypesEnum.counter);
ExtensionTests(Constants.SetupExtension, FileDataTypesEnum.fabricsetup);
ExtensionTests(Constants.TableExtension, FileDataTypesEnum.table);
ExtensionTests(Constants.DtrExtension, FileDataTypesEnum.fabric);
ExtensionTests(Constants.DtrZipExtension, FileDataTypesEnum.fabric);
ExtensionTests(Constants.ZipExtension, FileDataTypesEnum.unknown);
}
public ValidFileInfo(string path, string source, FileTypes fileType)
{
var fileInfo = new FileInfo(path);
if (!fileInfo.Exists)
{
throw new ArgumentException("The file path is not valid.");
}
if (String.IsNullOrEmpty(source))
{
throw new ArgumentException("Data source is required to be populated");
}
FileType = fileType;
Source = source;
//todo: extend to ensure the file is not locked as well.
Value = fileInfo;
}
public void DeletePlatformInformation(string index, string platformId, string platformName)
{
FileTypes ft = FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.GetNotCashedConfiguration <FileTypes>();
MediationServiceConfiguration ms = FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.GetNotCashedConfiguration <MediationServiceConfiguration>();
CheckInput ci = FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.GetNotCashedConfiguration <CheckInput>();
var fileTypeList = ft.FileTypesList;
var inputDir = ms.InputDirectories;
var arhDir = ms.ArchiveDirectories;
var files = ci.Fajlovi;
string fileTypeID = platformId;
string fileTypeName = platformName;
var delFile = files.Find(p => p.FileType == fileTypeName);
inputDir = inputDir.Where(p => p.FileType != fileTypeName).ToArray();
arhDir = arhDir.Where(p => p.FileType != fileTypeName).ToArray();
fileTypeList.RemoveAt(Convert.ToInt32(index));
files.Remove(delFile);
ms.InputDirectories = inputDir;
ms.ArchiveDirectories = arhDir;
string logString = "FileTypeID: " + fileTypeID + "|" +
"FileTypeName: " + fileTypeName;
WriteLog("DELETE", "MED Configuration", "FileTypes", WindowsIdentity.GetCurrent().Name, logString, "");
FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.SaveConfiguration(ft.GetType(), ft);
FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.SaveConfiguration(ms.GetType(), ms);
FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.SaveConfiguration(ci.GetType(), ci);
try
{
NtsMed.DeleteFileSource(int.Parse(fileTypeID), fileTypeName);
}
catch (Exception ex)
{
FORIS.Interbilling.NTS.Mediation.Logger.LogError(ex.ToString());
}
}
/// <summary>
/// Get files
/// </summary>
/// <param name="type">The type of the files to retrieve</param>
/// <param name="source">Specifies to retrieve files from a particular source</param>
/// <param name="limit">Specifies the number of results per page in the output, from 1 - 50, default = 50.</param>
/// <param name="pag">Pagination object.</param>
/// <returns>Returns a collection of MyLibraryFile objects.</returns>
public ResultSet<MyLibraryFile> GetLibraryFiles(FileTypes? type, FilesSources? source, int? limit, Pagination pag)
{
return MyLibraryService.GetLibraryFiles(this.AccessToken, this.APIKey, type, source, limit, pag);
}
public File[] GetReadyFiles(FileTypes fileType)
{
return _readyLocation.GetFiles(string.Format("*.{0}.Standardized", fileType)).ToArray();
}
public IList<string> FindFiles(ISearchQuery searchQuery, FileTypes fileType, FileListSort fileListSort)
{
return FindFiles(searchQuery, new List<FileTypes>(new FileTypes[] { fileType }), fileListSort);
}
/// <summary>
/// Get files
/// </summary>
/// <param name="type">The type of the files to retrieve</param>
/// <returns>Returns a collection of MyLibraryFile objects.</returns>
public ResultSet<MyLibraryFile> GetLibraryFiles(FileTypes? type)
{
return this.GetLibraryFiles(type, null, null, null);
}
/// <summary>
/// Get files from Trash folder
/// </summary>
/// <param name="type">The type of the files to retrieve</param>
/// <param name="sortBy">Specifies how the list of folders is sorted</param>
/// <param name="limit">Specifies the number of results per page in the output, from 1 - 50, default = 50.</param>
/// <returns>Returns a collection of MyLibraryFile objects.</returns>
public ResultSet<MyLibraryFile> GetLibraryTrashFiles(FileTypes? type, TrashSortBy? sortBy, int? limit)
{
return this.GetLibraryTrashFiles(type, sortBy, limit, null);
}
public TagInfo(string id, FileTypes fileType)
{
Id = id;
FileType = fileType;
}
public int GetTotalLineCount(LineTypes lineType, FileTypes fileType, bool scale)
{
var sloc = from v in Sloc.ToDictionary()[fileType]
from x in v.Lines
where x.LineType == lineType
select x;
return sloc.Count();
}
private void LoadDMSGFile(FileTypes type, Languages language, ResourceBit rb)
{
String Path = GetFilePath(type, language);
//int index = GetFileNumber(type, language);
if (!String.IsNullOrEmpty(Path))
{
d_msgFile en_d_msg = new d_msgFile(Path);
if ((en_d_msg == null) || (en_d_msg.EntryList == null) || (en_d_msg.Header == null))
return;
int Length = (int)en_d_msg.Header.EntryCount;
// for each entry
for (int i = 0; i < Length; i++)
{
if ((en_d_msg.EntryList[i] == null) ||
(en_d_msg.EntryList[i].data == null) ||
(en_d_msg.EntryList[i].data[0] == null) ||
(en_d_msg.EntryList[i].data[0].Length <= 0))
continue;
//if (String.IsNullOrEmpty(en_d_msg.EntryList[i].data[0]) || String.IsNullOrEmpty(en_d_msg.EntryList[i].data[0].Trim('.')))
//continue;
if (en_d_msg.EntryList[i].data[0].Length > 0)
{
// SpellNames are special case. To make them match up with FFACETools, we need to double the index.
String s = en_d_msg.EntryList[i].data[0];
if (type == FileTypes.SpellNames)
ResourcesCache.Add((int)((uint)(i * 2) | (uint)rb), s);
else
ResourcesCache.Add((int)((uint)i | (uint)rb), s);
}
}
}
}
protected string FileNameSelection(string FileName) {
mSaveDialog.FileName = FileName;
switch (mSaveDialog.ShowDialog()) {
case DialogResult.OK:
mSaveDialog.InitialDirectory = new System.IO.FileInfo(mSaveDialog.FileName).Directory.ToString();
SelectedFileType = (FileTypes) mSaveDialog.FilterIndex;
return mSaveDialog.FileName;
case DialogResult.Cancel:
return null;
}
return null;
}
/// <summary>
/// Get files from Trash folder
/// </summary>
/// <param name="type">The type of the files to retrieve</param>
/// <param name="sortBy">Specifies how the list of folders is sorted</param>
/// <param name="limit">Specifies the number of results per page in the output, from 1 - 50, default = 50.</param>
/// <param name="pag">Pagination object.</param>
/// <returns>Returns a collection of MyLibraryFile objects.</returns>
public ResultSet<MyLibraryFile> GetLibraryTrashFiles(FileTypes? type, TrashSortBy? sortBy, int? limit, Pagination pag)
{
return MyLibraryService.GetLibraryTrashFiles(this.AccessToken, this.APIKey, type, sortBy, limit, pag);
}
private String GetFilePath(FileTypes filetype, Languages language)
{
return GetFilePath((int)filetype, (int)language);
}
/// <summary>
/// Get files
/// </summary>
/// <param name="type">The type of the files to retrieve</param>
/// <param name="source">Specifies to retrieve files from a particular source</param>
/// <param name="limit">Specifies the number of results per page in the output, from 1 - 50, default = 50.</param>
/// <returns>Returns a collection of MyLibraryFile objects.</returns>
public ResultSet<MyLibraryFile> GetLibraryFiles(FileTypes? type, FilesSources? source, int? limit)
{
return this.GetLibraryFiles(type, source, limit, null);
}
/// <summary>
/// Generic loader for loading Item names
/// </summary>
/// <param name="filetype">FileTypes enum to indicate which file to load.</param>
/// <param name="language">Preferred language as an Languages enum.</param>
private void LoadItemFile(FileTypes filetype, Languages language)
{
String Path = GetFilePath(filetype, language);
if (!String.IsNullOrEmpty(Path))
{
FileInfo fi = new FileInfo(Path);
Boolean file_error = false;
if (!fi.Exists)
return;
if ((fi.Length % 0xC00) != 0)
return;
int items_in_file = (int)(fi.Length / 0xC00);
BinaryReader iteminfo = null;
try
{
iteminfo = new BinaryReader(File.Open(Path, FileMode.Open, FileAccess.Read));
}
catch (IOException e)
{
// this line isn't necessary, but it avoids the annoying (e is assigned but never used)
Path = e.Message;
file_error = true;
}
if (file_error == true)
return; // Attempt a Sanity Check
for (int item_counter = 0; item_counter < items_in_file; item_counter++)
{
iteminfo.BaseStream.Position = 0xC00 * item_counter;
byte[] readbytes = DecodeBlock(iteminfo.ReadBytes(0x200), 5);
BinaryReader data = new BinaryReader(new MemoryStream(readbytes, false));
itemFormat itemObjects = new itemFormat(data);
// INSERT ITEM CHECK DATA HERE
data.Close();
//if ((itemObjects.itemHeader.ID < 0xFFFF) && (itemObjects.itemHeader.ID > 0x6FFF))
// continue;
if (String.IsNullOrEmpty(itemObjects.text) || String.IsNullOrEmpty(itemObjects.text.Trim('.')))
continue;
if ((itemObjects.itemHeader.Flags & (ushort)ItemFlags.Nothing) == (ushort)ItemFlags.Nothing)
continue;
if (itemObjects.itemHeader.ID == 0x00)
continue;
// 0x0100 0x0040 0x1000
/* UINT32 ID
* UINT16 Flags
* UINT16 Stack Size
* UINT16 Type
* UINT16 ResourceID
* UINT16 ValidTargets
* 14 Bytes - Common Header Size
*/
if (String.IsNullOrEmpty(itemObjects.text))
continue;
else if (Char.IsSymbol(itemObjects.text[0]))
continue;
ResourcesCache.Add((int)itemObjects.itemHeader.ID, itemObjects.text);
// or itemObjects.logtext
}
iteminfo.Close();
}
}
/// <summary>
/// Returns the size and type of the specified file or directory.
/// </summary>
/// <param name="path">The file or directory for which to retrieve information.</param>
/// <param name="size">Returns the size of the specified file or directory</param>
/// <param name="fileType">Returns the size of the specified file or directory</param>
public unsafe void GetFileInfoDetails(string path, out int size, out FileTypes fileType)
{
IntPtr data;
IntPtr current_data;
uint data_size;
uint offset;
string name;
string value;
int ret;
data = IntPtr.Zero;
size = 0;
fileType = FileTypes.Unknown;
ret = MobileDevice.AFCGetFileInfo(new IntPtr(hAFC), path, ref data, out data_size);
if (ret != 0)
{
return;
}
offset = 0;
while (offset < data_size)
{
current_data = new IntPtr(data.ToInt32() + offset);
name = Marshal.PtrToStringAnsi(current_data);
offset += (uint)name.Length + 1;
current_data = new IntPtr(data.ToInt32() + offset);
value = Marshal.PtrToStringAnsi(current_data);
offset += (uint)value.Length + 1;
switch (name)
{
case "st_size": size = Int32.Parse(value); break;
case "st_blocks": break;
case "st_ifmt":
//S_IFBLK File (#rtl.baseunix.stat record) mode: Block device
//S_IFCHR File (#rtl.baseunix.stat record) mode: Character device
//S_IFDIR File (#rtl.baseunix.stat record) mode: Directory
//S_IFIFO File (#rtl.baseunix.stat record) mode: FIFO
//S_IFLNK File (#rtl.baseunix.stat record) mode: Link
//S_IFMT File (#rtl.baseunix.stat record) mode: File type bit mask
//S_IFREG File (#rtl.baseunix.stat record) mode: Regular file
//S_IFSOCK File (#rtl.baseunix.stat record) mode: Socket
switch (value)
{
case "S_IFDIR":
fileType = FileTypes.Folder;
break;
case "S_IFREG":
fileType = FileTypes.File;
break;
case "S_IFBLK":
fileType = FileTypes.BlockDevice;
break;
case "S_IFCHR":
fileType = FileTypes.CharDevice;
break;
case "S_IFIFO":
fileType = FileTypes.FIFO;
break;
case "S_IFLNK":
fileType = FileTypes.Link;
break;
case "S_IFMT":
fileType = FileTypes.FileMask;
break;
case "S_IFSOCK":
fileType = FileTypes.Socket;
break;
}
break;
}
}
}
/// <summary>
/// Applied formatting rules stored in <see cref="Formatter.Formatters"/>
/// on the specified string.
/// </summary>
/// <remarks>
/// FileTypes isnullable here because Metadata types
/// do not inherit from the File class. Implicitly
/// null filetypes here represent Metadata formatting.
/// </remarks>
public string Format(FileTypes? filetype, string value)
{
// Determine case formatting
switch (filetype)
{
case FileTypes.RELEASE:
CurrentCase = AlbumCasing; break;
case FileTypes.SONG:
CurrentCase = SongCasing; break;
case FileTypes.FLAT:
CurrentCase = FlatCasing; break;
default:
CurrentCase = MetadataCasing; break;
}
foreach (KeyValuePair<string, string> kv in replacements)
{
value = value.Replace(kv.Key, kv.Value, StringComparison.InvariantCultureIgnoreCase);
}
value = ApplyCase(value);
return value;
}
