private async Task <string> ReadFileAsStringAsync(IFileInput source, string path)
{
using (var inputStream = await source.OpenStreamAsync(path))
using (var streamReader = new StreamReader(inputStream))
{
return(streamReader.ReadToEnd());
}
}
public Input(InputType inputType, String filename, IStandardMessages standardMessages, IConsoleInput consoleInput, IFileInput fileInput)
{
_inputType = inputType;
_filename = filename;
_standardMessages = standardMessages;
_consoleInput = consoleInput;
_fileInput = fileInput;
}
private async Task <object[]> ParseDataAsync(IFileInput source, InputFile file)
{
using (var inputStream = await source.OpenStreamAsync(file.Path))
{
return(container
.ResolveDataReader(file.Section, file.ContentType)
.ReadData(inputStream));
}
}
private async Task <TMetadata> ParseMetadataAsync <TMetadata>(IFileInput source, InputFile file)
{
using (var inputStream = await source.OpenStreamAsync(file.Path))
{
return(container
.ResolveDeserializer(file.Section, file.ContentType)
.Deserialize <TMetadata>(inputStream));
}
}
public async Task ValidateAsync(string userId, IFileInput file)
{
if (!await IsValidSizeAsync(userId, file.Length))
{
throw new ImageMaxLengthExceededException();
}
string extension = Path.GetExtension(file.FileName);
if (!await IsValidExtensionAsync(userId, extension))
{
throw new ImageNotSupportedExtensionException();
}
}
public async Task <Dictionary <string, object> > GetDatasourcesAsync(IFileInput source, string path)
{
var datasources = new Dictionary <string, object>();
var files = await source.GetFilesAsync(path);
var data = files
.Select(p => new InputFile(p))
.Where(f => f.InputType == InputType.Data)
.ToList();
foreach (var file in data)
{
datasources.Add(file.Section, await ParseDataAsync(source, file));
}
return(datasources);
}
public void Encode(IFileInput input)
{
// Initialization and encoding the tree
_buffer = new byte[BUFFER_LENGTH + 1];
WriteEncodingHeader();
WriteTree(_tree);
_output.Write(new byte[8], 0, 8);
CreatePaths(_tree, new byte[0], 0);
int c;
while ((c = input.ReadByte()) != -1)
{
EncodeByte((byte)c);
}
}
/// <summary>
/// Reads the input stream and encodes it to the output stream.
/// </summary>
public void Encode(IFileInput input, IFileOutput output)
{
int symbol;
// Getting the frequencies
while ((symbol = input.ReadByte()) != -1)
{
_analyzer.ProcessSymbol(symbol);
}
long[] data = _analyzer.GetAnalysis();
Node root = _creator.CreateTree(data);
var encoder = new HuffmanEncoder(output, root);
input.GoToStart();
encoder.Encode(input);
encoder.Finish();
}
public async Task <Image> CreateAsync(Entry entry, IFileInput file)
{
Ensure.NotNull(entry, "entry");
Ensure.NotNull(file, "file");
await validator.ValidateAsync(entry.UserId, file);
(int width, int height)size = default;
using (Stream imageContent = file.OpenReadStream())
size = resizeService.GetSize(imageContent);
string imageId = Guid.NewGuid().ToString();
Image entity = new Image()
{
Id = imageId,
Name = Path.GetFileNameWithoutExtension(file.FileName),
FileName = imageId + Path.GetExtension(file.FileName),
Created = DateTime.Now,
When = entry.When,
Entry = entry,
OriginalWidth = size.width,
OriginalHeight = size.height
};
await dataContext.Images.AddAsync(entity);
bool isOriginalStored = await freeLimits.IsOriginalImageStoredAsync(entry.UserId);
if (isOriginalStored)
{
await CopyFileAsync(file, entry, entity);
}
using (Stream imageContent = file.OpenReadStream())
SetProperties(entity, imageContent);
await dataContext.SaveChangesAsync();
using (Stream imageContent = file.OpenReadStream())
await ComputeOtherSizesAsync(entry, entity, imageContent, true);
return(entity);
}
public UnpicklerObject(CodeContext context, object file) {
this._file = file as IFileInput ?? new PythonFileInput(context, file);
_memo = new PythonDictionary();
_dispatch = new Dictionary<string, LoadFunction>();
_dispatch[""] = LoadEof;
_dispatch[Opcode.Append] = LoadAppend;
_dispatch[Opcode.Appends] = LoadAppends;
_dispatch[Opcode.BinFloat] = LoadBinFloat;
_dispatch[Opcode.BinGet] = LoadBinGet;
_dispatch[Opcode.BinInt] = LoadBinInt;
_dispatch[Opcode.BinInt1] = LoadBinInt1;
_dispatch[Opcode.BinInt2] = LoadBinInt2;
_dispatch[Opcode.BinPersid] = LoadBinPersid;
_dispatch[Opcode.BinPut] = LoadBinPut;
_dispatch[Opcode.BinString] = LoadBinString;
_dispatch[Opcode.BinUnicode] = LoadBinUnicode;
_dispatch[Opcode.Build] = LoadBuild;
_dispatch[Opcode.Dict] = LoadDict;
_dispatch[Opcode.Dup] = LoadDup;
_dispatch[Opcode.EmptyDict] = LoadEmptyDict;
_dispatch[Opcode.EmptyList] = LoadEmptyList;
_dispatch[Opcode.EmptyTuple] = LoadEmptyTuple;
_dispatch[Opcode.Ext1] = LoadExt1;
_dispatch[Opcode.Ext2] = LoadExt2;
_dispatch[Opcode.Ext4] = LoadExt4;
_dispatch[Opcode.Float] = LoadFloat;
_dispatch[Opcode.Get] = LoadGet;
_dispatch[Opcode.Global] = LoadGlobal;
_dispatch[Opcode.Inst] = LoadInst;
_dispatch[Opcode.Int] = LoadInt;
_dispatch[Opcode.List] = LoadList;
_dispatch[Opcode.Long] = LoadLong;
_dispatch[Opcode.Long1] = LoadLong1;
_dispatch[Opcode.Long4] = LoadLong4;
_dispatch[Opcode.LongBinGet] = LoadLongBinGet;
_dispatch[Opcode.LongBinPut] = LoadLongBinPut;
_dispatch[Opcode.Mark] = LoadMark;
_dispatch[Opcode.NewFalse] = LoadNewFalse;
_dispatch[Opcode.NewObj] = LoadNewObj;
_dispatch[Opcode.NewTrue] = LoadNewTrue;
_dispatch[Opcode.NoneValue] = LoadNoneValue;
_dispatch[Opcode.Obj] = LoadObj;
_dispatch[Opcode.PersId] = LoadPersId;
_dispatch[Opcode.Pop] = LoadPop;
_dispatch[Opcode.PopMark] = LoadPopMark;
_dispatch[Opcode.Proto] = LoadProto;
_dispatch[Opcode.Put] = LoadPut;
_dispatch[Opcode.Reduce] = LoadReduce;
_dispatch[Opcode.SetItem] = LoadSetItem;
_dispatch[Opcode.SetItems] = LoadSetItems;
_dispatch[Opcode.ShortBinstring] = LoadShortBinstring;
_dispatch[Opcode.String] = LoadString;
_dispatch[Opcode.Tuple] = LoadTuple;
_dispatch[Opcode.Tuple1] = LoadTuple1;
_dispatch[Opcode.Tuple2] = LoadTuple2;
_dispatch[Opcode.Tuple3] = LoadTuple3;
_dispatch[Opcode.Unicode] = LoadUnicode;
}
public Unpickler(IFileInput file)
{
this.file = file;
memo = new Dict();
dispatch = new Dictionary<string, LoadFunction>();
dispatch[""] = LoadEof;
dispatch[Opcode.Append] = LoadAppend;
dispatch[Opcode.Appends] = LoadAppends;
dispatch[Opcode.BinFloat] = LoadBinFloat;
dispatch[Opcode.BinGet] = LoadBinGet;
dispatch[Opcode.BinInt] = LoadBinInt;
dispatch[Opcode.BinInt1] = LoadBinInt1;
dispatch[Opcode.BinInt2] = LoadBinInt2;
dispatch[Opcode.BinPersid] = LoadBinPersid;
dispatch[Opcode.BinPut] = LoadBinPut;
dispatch[Opcode.BinString] = LoadBinString;
dispatch[Opcode.BinUnicode] = LoadBinUnicode;
dispatch[Opcode.Build] = LoadBuild;
dispatch[Opcode.Dict] = LoadDict;
dispatch[Opcode.Dup] = LoadDup;
dispatch[Opcode.EmptyDict] = LoadEmptyDict;
dispatch[Opcode.EmptyList] = LoadEmptyList;
dispatch[Opcode.EmptyTuple] = LoadEmptyTuple;
dispatch[Opcode.Ext1] = LoadExt1;
dispatch[Opcode.Ext2] = LoadExt2;
dispatch[Opcode.Ext4] = LoadExt4;
dispatch[Opcode.Float] = LoadFloat;
dispatch[Opcode.Get] = LoadGet;
dispatch[Opcode.Global] = LoadGlobal;
dispatch[Opcode.Inst] = LoadInst;
dispatch[Opcode.Int] = LoadInt;
dispatch[Opcode.List] = LoadList;
dispatch[Opcode.Long] = LoadLong;
dispatch[Opcode.Long1] = LoadLong1;
dispatch[Opcode.Long4] = LoadLong4;
dispatch[Opcode.LongBinGet] = LoadLongBinGet;
dispatch[Opcode.LongBinPut] = LoadLongBinPut;
dispatch[Opcode.Mark] = LoadMark;
dispatch[Opcode.NewFalse] = LoadNewFalse;
dispatch[Opcode.NewObj] = LoadNewObj;
dispatch[Opcode.NewTrue] = LoadNewTrue;
dispatch[Opcode.NoneValue] = LoadNoneValue;
dispatch[Opcode.Obj] = LoadObj;
dispatch[Opcode.PersId] = LoadPersId;
dispatch[Opcode.Pop] = LoadPop;
dispatch[Opcode.PopMark] = LoadPopMark;
dispatch[Opcode.Proto] = LoadProto;
dispatch[Opcode.Put] = LoadPut;
dispatch[Opcode.Reduce] = LoadReduce;
dispatch[Opcode.SetItem] = LoadSetItem;
dispatch[Opcode.SetItems] = LoadSetItems;
dispatch[Opcode.ShortBinstring] = LoadShortBinstring;
dispatch[Opcode.String] = LoadString;
dispatch[Opcode.Tuple] = LoadTuple;
dispatch[Opcode.Tuple1] = LoadTuple1;
dispatch[Opcode.Tuple2] = LoadTuple2;
dispatch[Opcode.Tuple3] = LoadTuple3;
dispatch[Opcode.Unicode] = LoadUnicode;
}
private async Task CopyFileAsync(IFileInput file, Entry entry, Image image)
{
using (Stream source = file.OpenReadStream())
await fileStorage.SaveAsync(entry, image, source, ImageType.Original);
}
public async Task <Page <TMetadata> > ParsePageAsync <TMetadata>(IFileInput source, string path, string kind)
{
var paths = await source.GetFilesAsync(path);
var files = paths.Select(p => new InputFile(p)).OrderBy(f => f.Section).ThenBy(f => f.Order);
var slug = GetSlug(path);
var page = new Page <TMetadata>()
{
Kind = kind,
Slug = slug,
Thumbnail = new Media()
{
Sources = files
.Where(f => f.InputType == InputType.Media && f.Section == "thumbnail")
.Select(mapFileToSource)
.ToArray()
},
Sections = new Dictionary <string, Section>()
};
var metadataFile = files.Where(f => f.Section == "metadata").FirstOrDefault();
if (metadataFile != null)
{
page.Metadata = await ParseMetadataAsync <TMetadata>(source, metadataFile);
}
var ignoreList = new string[] { "metadata", "thumbnail", "thumbs", "icon" };
foreach (var sectionGroup in files.Where(s => !ignoreList.Contains(s.Section)).GroupBy(f => f.Section))
{
Section section;
// section metadata
var sectionMetadataFile = sectionGroup.Where(f => f.InputType == InputType.Metadata).FirstOrDefault();
if (sectionMetadataFile != null)
{
section = await ParseMetadataAsync <Section>(source, sectionMetadataFile);
}
else
{
section = new Section();
}
// section html or markdown content
var contentPath = sectionGroup.Where(f => f.InputType == InputType.Content).Select(f => f.Path).FirstOrDefault();
if (contentPath != null)
{
section.Content = await ReadFileAsStringAsync(source, contentPath);
}
// section media
var media = sectionGroup
.Where(s => s.InputType == InputType.Media)
.GroupBy(s => s.Order)
.Select(g => new Media()
{
Sources = g.Select(mapFileToSource).ToList()
})
.ToList();
if (section.Media != null)
{
section.Media = MergeMediaLists(media, section.Media);
}
else
{
section.Media = media;
}
page.Sections.Add(sectionGroup.Key, section);
}
return(page);
}
public XmlTransformer(IFileInput input, IFileOutput output)
{
this.input = input;
this.output = output;
}
public static TextReader OpenText(this IFileInput self, string path) => new StreamReader(self.OpenRead(path));
public FileResult(IFileInput result)
{
this.result = result;
}
