protected GetFileResult(int uid, int gid, int mode, FileKind type)
{
X_LXD_uid = uid;
X_LXD_gid = gid;
X_LXD_mode = mode;
X_LXD_type = type;
}
/// <summary>
/// Processes a single file in an input directory
/// </summary>
/// <param name="inputFile">File to process</param>
/// <param name="outputDirectory">Directory to put processed file to</param>
private void ProcessSingleFile(FileInfo inputFile, string outputDirectory)
{
FileKind fileKind = ClassifyFile(inputFile.Extension.ToLower());
string subDirectory = fileKind.GetAttributeOfType <DescriptionAttribute>().Description;
string destinationPath = string.Empty;
try
{
destinationPath = m_FileProcessorFactory.ProvideProcessorForFile(fileKind).Process(inputFile, fileKind, outputDirectory);
}
catch (FileProcessorException)
{
destinationPath = m_FileProcessorFactory.ProvideProcessorForFile(FileKind.Unrecognized).Process(inputFile, FileKind.Unrecognized, outputDirectory);
}
catch (Exception e)
{
OnFileFailed(new FileEventArgs(inputFile.Name, subDirectory, e.Message));
}
if (File.Exists(destinationPath))
{
OnFileFailed(new FileEventArgs(inputFile.Name, subDirectory, $"{inputFile.Name} already exists in {subDirectory}"));
}
else
{
File.Copy(inputFile.FullName, destinationPath, false);
OnFileCopied(new FileEventArgs(inputFile.Name, subDirectory));
}
}
/// <summary>
/// アーカイブファイルからサムネイル用画像データを取得する
/// </summary>
/// <param name="path"></param>
/// <param name="thumWidth"></param>
/// <returns></returns>
public static async Task <BitmapImage> GetFirstImageFromArchive(string path, int thumWidth)
{
BitmapImage bitmap = null;
StorageFile zipFile = await StorageFile.GetFileFromPathAsync(path);
using (IRandomAccessStream randomStream = await zipFile.OpenReadAsync())
{
using (Stream stream = randomStream.AsStreamForRead())
{
using (ZipArchive zipArchive = new ZipArchive(stream))
{
foreach (ZipArchiveEntry entry in zipArchive.Entries)
{
if (FileKind.IsImageFile(entry.FullName))
{
bitmap = await BitmapUtils.CreateBitmap(entry, thumWidth);
break;
}
}
}
}
}
return(bitmap);
}
public ImageImporterTestFileDescription(string filename, DateTime dateDigitized, DateTime dateCreated, FileKind fileKind)
{
FileName = filename;
DateDigitized = dateDigitized;
DateCreated = dateCreated;
FileKind = fileKind;
}
/// <summary>
/// ZIPデータを読み込みファイル一覧を作成する
/// </summary>
/// <returns></returns>
public async Task LoadDataAsync()
{
this.Dispose();
this.m_dataList.Clear();
StorageFile zipFile = await StorageFile.GetFileFromPathAsync(m_imageParam.Path);
StorageHistoryManager.AddStorage(zipFile, StorageHistoryManager.DataType.Latest);
this.ParentStorage = zipFile;
IRandomAccessStream randomStream = await zipFile.OpenReadAsync();
Stream stream = randomStream.AsStreamForRead();
m_zipArchive = new ZipArchive(stream);
foreach (ZipArchiveEntry entry in m_zipArchive.Entries)
{
if (FileKind.IsImageFile(entry.FullName))
{
m_dataList.Add(entry);
}
}
sortList(m_dataList);
//名前の順に並び替え
foreach (ZipArchiveEntry entry in m_dataList)
{
Debug.WriteLine(entry.Name);
}
}
internal static FileEntry ToFile <T>(FileKind kind, T value)
{
var filename = FileEntry.GetFilenameForKind(kind);
string output;
if (Utilities.IsYamlFile(filename))
{
StringWriter tw = new StringWriter();
YamlPocoSerializer.CanonicalWrite(tw, value);
output = tw.ToString();
}
else
{
var jsonStr = JsonSerializer.Serialize(value, Utilities._jsonOpts);
output = JsonNormalizer.Normalize(jsonStr);
}
var bytes = Encoding.UTF8.GetBytes(output);
return(new FileEntry {
Name = filename, RawBytes = bytes
});
}
internal static FilePath GetFilenameForKind(FileKind kind)
{
string filename =
(from kv in _fileKinds
where kv.Value == kind
select kv.Key).FirstOrDefault();
return(FilePath.FromMsAppPath(filename));
}
internal static string GetFilenameForKind(FileKind kind)
{
string filename =
(from kv in _fileKinds
where kv.Value == kind
select kv.Key).FirstOrDefault();
return(filename);
}
/// <summary>
/// Creates a concrete <see cref="IAsyncFile"/> instance. Throws on failure.
/// </summary>
/// <remarks>
/// TODO: Currently returns a platform specific concrete instance of <see cref="IAsyncFile"/>
/// </remarks>
public static IAsyncFile CreateAsyncFile(
SafeFileHandle handle,
FileDesiredAccess access,
bool ownsHandle,
IIOCompletionManager ioCompletionManager = null,
string path = null,
FileKind kind = FileKind.File)
{
return(OperatingSystemHelper.IsUnixOS
? (IAsyncFile) new AsyncFileUnix(handle, access, ownsHandle, path, kind)
: (IAsyncFile) new AsyncFileWin(handle, access, ownsHandle, ioCompletionManager, path, kind));
}
public string GetExpectedPath(FileKind requiredFileKind)
{
var path = System.IO.Path.Combine(
(requiredFileKind == FileKind.JpegImage || requiredFileKind == FileKind.RawImage ?
DateDigitized.Date.ToString("yyyy_MM_dd") :
DateCreated.Date.ToString("yyyy_MM_dd")),
requiredFileKind.GetAttributeOfType <DescriptionAttribute>().Description,
FileName
);
return(path);
}
public static string[] GetFiles(string fileName, FileKind fileKind)
{
string arguments = string.Format("{0} AND {1}", ParseFileKind(fileKind), ParseFileName(fileName));
List <string> files = new List <string>();
files.AddRange(GetFiles(arguments));
if (fileKind.HasFlag(FileKind.Apps))
{
files.AddRange(GetSystemFiles(fileName));
}
return(files.ToArray());
}
internal static FileEntry ToFile <T>(FileKind kind, T value)
{
var filename = FileEntry.GetFilenameForKind(kind);
var jsonStr = JsonSerializer.Serialize(value, Utilities._jsonOpts);
jsonStr = JsonNormalizer.Normalize(jsonStr);
var bytes = Encoding.UTF8.GetBytes(jsonStr);
return(new FileEntry {
Name = filename, RawBytes = bytes
});
}
public static async Task <BitmapImage> CreateBitmapFromArchiveCover(string path, int thumWidth)
{
StorageFolder folder = await EnvPath.GetArchiveCoverFolder();
string fileName = EnvPath.GetArchiveCoverFileName(path);
IStorageItem imageFile = await folder.TryGetItemAsync(fileName);
if (imageFile == null)
{
using (await m_asyncLock.LockAsync())
{
StorageFile coverFile = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
StorageFile zipFile = await StorageFile.GetFileFromPathAsync(path);
using (IRandomAccessStream randomStream = await zipFile.OpenReadAsync())
{
using (Stream stream = randomStream.AsStreamForRead())
{
using (ZipArchive zipArchive = new ZipArchive(stream))
{
foreach (ZipArchiveEntry entry in zipArchive.Entries)
{
if (FileKind.IsImageFile(entry.FullName))
{
/*
* WriteableBitmap writeableBitmap = await createWriteableBitmap(entry);
* await saveToJpegFile(writeableBitmap, coverFile);
* imageFile = await folder.GetFileAsync(fileName);
*/
imageFile = await SaveToFileFromZipEntry(entry, coverFile);
break;
}
}
}
}
}
}
}
if (imageFile != null)
{
return(await CreateThumbnailBitmap(imageFile, (uint)thumWidth));
}
else
{
return(null);
}
}
private static IEnumerable <LabeledText> SubRead(string file)
{
FileKind fileKind = FileKind.Unknown;
using (var rd = new StreamReader(file))
{
var line = rd.ReadLine();
//for (; ; )
while (line != null)
{
//if (line == null) break;
if (fileKind == FileKind.Unknown)
{
fileKind = line.Contains('\t') ? FileKind.LabeledTexts : FileKind.ListOfFiles;
}
if (fileKind == FileKind.ListOfFiles)
{
var langCode = line.Substring(0, line.IndexOf("_"));
using (var rd2 = new StreamReader(line))
{
for (; ;)
{
var text = rd2.ReadLine();
if (text == null)
{
break;
}
yield return(new LabeledText {
lang = langCode, text = text
});
}
}
}
else
{
var f = line.Split('\t');
//Debug.Assert(f.Length == 2);
yield return(new LabeledText {
lang = f[1], text = f[0]
});
}
line = rd.ReadLine();
}
}
}
/// <summary>
/// Creates an <see cref="AsyncFileWin"/> to wrap an existing native handle compatible with Windows based systems.
/// </summary>
public AsyncFileWin(
SafeFileHandle handle,
FileDesiredAccess access,
bool ownsHandle,
IIOCompletionManager ioCompletionManager = null,
string path = null,
FileKind kind = FileKind.File)
{
Contract.Requires(handle != null);
Contract.Requires(!handle.IsInvalid);
m_handle = handle;
m_kind = kind;
m_path = path;
m_ownsHandle = ownsHandle;
m_access = access;
m_ioCompletionManager = (IOCompletionManager)(ioCompletionManager ?? IOCompletionManager.Instance);
m_ioCompletionManager.BindFileHandle(handle);
}
/// <summary>
/// Provides a processor for a specified file kind
/// </summary>
/// <param name="fileKind">File kind to process</param>
/// <returns>File processor</returns>
public IFileProcessor ProvideProcessorForFile(FileKind fileKind)
{
switch (fileKind)
{
case FileKind.Unrecognized:
return(m_FileProcessors.OfType <GenericFileProcessor>().First());
case FileKind.RawImage:
case FileKind.JpegImage:
return(m_FileProcessors.OfType <ExifFileProcessor>().First());
case FileKind.Video:
return(m_FileProcessors.OfType <QuickTimeFileProcessor>().First());
default:
return(m_FileProcessors.OfType <NullFileProcessor>().First());
}
}
static string ParseFileKind(FileKind kind)
{
if (kind == FileKind.Unknown)
{
return("");
}
FileKind[] kinds = ((FileKind[])Enum.GetValues(typeof(FileKind))).Where(x => kind.HasFlag(x)).ToArray();
kinds = kinds.Where(x => x != FileKind.All).ToArray();
string parseKind = string.Empty;
for (int i = 0; i < kinds.Length; i++)
{
if (kinds[i] == FileKind.Apps)
{
parseKind += "kind:program";
}
else if (kinds[i] == FileKind.Documents)
{
parseKind += "kind:docs";
}
else if (kinds[i] == FileKind.Music)
{
parseKind += "kind:music";
}
else if (kinds[i] == FileKind.Photos)
{
parseKind += "kind:pics";
}
else if (kinds[i] == FileKind.Videos)
{
parseKind += "kind:video";
}
else if (kinds[i] == FileKind.Folder)
{
parseKind += "kind:folder";
}
if (i < kinds.Length - 1)
{
parseKind += " OR ";
}
}
return(parseKind);
}
public FileDescriptor GetDescriptorForRequest(Uri uri)
{
FileKind type = GetFileKindForUri(uri);
string fileName = GetFileNameForType(type);
string fullPath = Path.Combine(StoragePath, fileName);
if (type == FileKind.Index)
{
return(new FileDescriptor
{
FilePath = fullPath,
IsExist = _fileSystem.ExistsFile(fullPath),
MimeType = "text/html"
});
}
return(new FileDescriptor
{
FilePath = fullPath,
IsExist = _fileSystem.ExistsFile(fullPath),
MimeType = "application/octet-stream"
});
}
/// <inheritdoc />
public override string Process(FileInfo inputFile, FileKind fileKind, string outputDirectory)
{
DateTime dateTimeTaken = DateTime.Now;
try
{
var metadataDirectories = ImageMetadataReader.ReadMetadata(inputFile.FullName);
try
{
// try getting date and time from DateTimeDigitezed tag
var tagCollection = metadataDirectories.OfType <ExifSubIfdDirectory>().FirstOrDefault();
dateTimeTaken = tagCollection.GetDateTime(ExifSubIfdDirectory.TagDateTimeDigitized);
}
catch (MetadataException)
{
try
{
// if no DateTimeDigitized tag found - try getting date and time from DateTime tag
var tagCollection = metadataDirectories.OfType <ExifDirectoryBase>().FirstOrDefault();
dateTimeTaken = tagCollection.GetDateTime(ExifDirectoryBase.TagDateTime);
}
catch (MetadataException)
{
// if no DateTime tag found - try to guess the date from file name
var dateFileNamePart = inputFile.Name.Split('_')[0];
dateTimeTaken = DateTime.ParseExact(dateFileNamePart, "yyyyMMdd", CultureInfo.InvariantCulture);
}
}
catch (Exception)
{
throw;
}
return(CreateDestinationPath(outputDirectory, dateTimeTaken.Date.ToString("yyyy_MM_dd"), fileKind.GetAttributeOfType <DescriptionAttribute>().Description, inputFile.Name));
}
catch (Exception e)
{
throw new FileProcessorException($"Cannot read EXIF metadata from {inputFile.FullName}", e);
}
}
public string GetFullFilePath(FileKind fileKind, string heroName, string fileSuffix = "")//, string fileName)
{
if (fileKind == FileKind.Options)
{
return(GamePath);
}
List <string> parts = new List <string>();
var path = GetFilesPath(heroName);
parts.Add(path);
//if (supportManyLevels && fileKind == FileKind.GameLevel)
if (GameLevelsFolder.Any() && fileKind == FileKind.GameLevel)
{
parts.Add(GameLevelsFolder);
}
var fileName = fileKind.ToString() + fileSuffix + extension;
parts.Add(fileName);
return(Path.Combine(parts.ToArray()));
}
private static string GetUriForFileType(FileKind type)
{
switch (type)
{
case FileKind.Client:
return(ClientUri);
case FileKind.NetFramework:
return(NetFrameworkUri);
case FileKind.GoogleChrome:
return(ChromeUri);
case FileKind.ExamBrowser:
return(ExambroUri);
case FileKind.Index:
return("");
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
private string GetFileNameForType(FileKind type)
{
switch (type)
{
case FileKind.Client:
return("UNBKGoClient.zip");
case FileKind.NetFramework:
return("NetFxSetup.exe");
case FileKind.GoogleChrome:
return("ChromeSetup.exe");
case FileKind.ExamBrowser:
return("Exambro.zip");
case FileKind.Index:
return("index.html");
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
/// <summary>
/// Creates an <see cref="AsyncFileUnix"/> to wrap an existing native handle compatible with Unix based systems.
/// </summary>
public AsyncFileUnix(
SafeFileHandle handle,
FileDesiredAccess access,
bool ownsHandle,
string path = null,
FileKind kind = FileKind.File)
{
Contract.Requires(handle != null);
Contract.Requires(!handle.IsInvalid);
m_handle = handle;
m_kind = kind;
m_path = path;
m_ownsHandle = ownsHandle;
m_access = access;
m_fileStream = new FileStream(
m_path,
FileMode.Open,
FileDesiredAccessToFileAccess(access),
FileShare.ReadWrite,
DefaultBufferSize,
FileOptions.Asynchronous);
}
public FilePathEffect(string path, FileKind kind)
{
Path = path;
Kind = kind;
}
public void WriteAllJson <T>(string subdir, FileKind kind, T obj)
{
var filename = FileEntry.GetFilenameForKind(kind);
WriteAllJson(subdir, filename, obj);
}
public DeleteFileEffect(string path, FileKind kind) : base(path, kind)
{
}
public GetFileLastWriteTimeEffect(string path, FileKind kind) : base(path, kind)
{
}
public GetFileCreationTimeEffect(string path, FileKind kind) : base(path, kind)
{
}
public GetFileExistsEffect(string path, FileKind kind) : base(path, kind)
{
}
public GetPhysicalPathEffect(string path, FileKind kind) : base(path, kind)
{
}
