protected InMemoryFile Package(string wrapName, string version, params string[] wrapdescLines)
{
var file = new InMemoryFile(wrapName + "-" + version + ".wrap");
Packager.NewWithDescriptor(file, wrapName, version, wrapdescLines);
return(file);
}
public async Task <FileResult> Zip(string id)
{
ProjeDetailDto model = await _ProjeServis.GetDetailAsync(id);
List <InMemoryFile> files = new List <InMemoryFile>();
foreach (var karakter in model.ProjeKarakterleri)
{
foreach (var oyuncu in karakter.Oyuncular)
{
foreach (var resim in oyuncu.OyuncuResimleri)
{
string dosyaYeri = FileHelper._WebRootPath + resim.Replace("/", "\\");
if (System.IO.File.Exists(dosyaYeri))
{
string filename = $"{oyuncu.Adi} {oyuncu.Soyadi}_{oyuncu.OyuncuResimleri.IndexOf(resim) + 1}{Path.GetExtension(resim)}";
InMemoryFile file = new InMemoryFile
{
FileName = filename,
Content = System.IO.File.ReadAllBytes(dosyaYeri)
};
files.Add(file);
}
}
}
}
return(File(GetZipArchive(files), System.Net.Mime.MediaTypeNames.Application.Zip, $"{model.ProjeAdi.Replace(" ", "")}.zip"));
}
IPackageInfo Publish(IPackageRepository source, string packageFileName, Stream packageStream)
{
var fileWithoutExtension = packageFileName.Trim().ToLowerInvariant().EndsWith(".wrap")
? System.IO.Path.GetFileNameWithoutExtension(packageFileName)
: packageFileName;
if (Packages.Any(x => x.FullName.EqualsNoCase(fileWithoutExtension)))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = inMemoryFile.OpenWrite())
IO.StreamExtensions.CopyTo(packageStream, stream);
var tempFolder = new ZipPackage(inMemoryFile);
var package = new InMemoryPackage(tempFolder)
{
Source = this
};
Packages.Add(package);
return(package);
}
public static InMemoryFile ToInMemoryFile(HarEntry entry)
{
try {
var fileUri = new Uri(entry.Request.Url);
var filename = $"{fileUri.Host}{fileUri.LocalPath}";
if (!string.IsNullOrEmpty(fileUri.Query))
{
var path = Path.GetExtension(fileUri.LocalPath);
filename += $"{fileUri.Query}{path}";
}
var content = Unpack(entry.Response.Content);
var memfile = new InMemoryFile()
{
FileName = Friendly(filename),
Content = content
};
return(memfile);
}
catch (Exception ex) {
Console.WriteLine("Unable to create in-memory file from entry: ");
Console.WriteLine(JsonSerializer.Serialize(entry));
Console.WriteLine(ex.Message);
Environment.Exit(3);
}
return(null);
}
public IResource CreateFile(FilePath path, byte[]?content = null)
{
var comparison = StringComparison.InvariantCultureIgnoreCase;
if (path.IsAbsolute || path.IsDirectory)
{
throw new ArgumentException("File path cannot be an absolute or a directory");
}
InMemoryDirectory curDir = root;
foreach (var nextDirName in path.Parts.SkipLast(1))
{
var nextDir = curDir.Directories.FirstOrDefault(d => d.Name.Equals(nextDirName, comparison)) as InMemoryDirectory;
if (nextDir == null)
{
nextDir = new InMemoryDirectory(this, curDir, curDir.Path.Combine(nextDirName));
curDir.directories.Add(nextDir);
}
curDir = nextDir;
}
var fileName = path.Parts.Last();
if (curDir.Any(r => r.Name.Equals(fileName, comparison)))
{
throw new ArgumentException($"Resource at path {path} already exists");
}
var newFile = new InMemoryFile(curDir, curDir.Path.Combine(fileName), content); // recombine for case preservation
curDir.files.Add(newFile);
return(newFile);
}
private void SaveManifest(ReleaseDTO release)
{
var manifestLocation = ReleaseLocation.SetName(ReleaseManifestDTO.FileName);
var file = new InMemoryFile(manifestLocation, release.Manifest.ToByteArray());
this.fileSystemService.SaveFile(file);
}
protected InMemoryFile Package(string name, string version, IEnumerable <PackageContent> content, params string[] descriptorLines)
{
var file = new InMemoryFile(name + "-" + version + ".wrap");
Packager.NewWithDescriptor(file, name, version, content, descriptorLines);
return(file);
}
public Stream OpenStream()
{
var package = new InMemoryFile(@"c:\test.wrap");
Packager.NewWithDescriptor(package, Name, Version.ToString(), Dependencies.Select(x => "depends: " + x).ToArray());
return(package.OpenRead());
}
IPackageInfo Publish(string packageFileName, Stream packageStream)
{
var fileWithoutExtension = packageFileName.Trim().ToLowerInvariant().EndsWith(".wrap")
? Path.GetFileNameWithoutExtension(packageFileName)
: packageFileName;
if (Packages.Any(x => x.FullName.EqualsNoCase(fileWithoutExtension)))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = FileExtensions.OpenWrite(inMemoryFile))
packageStream.CopyTo(stream);
var tempFolder = new CachedZipPackage(null, inMemoryFile, null);
var package = new InMemoryPackage
{
Name = PackageNameUtility.GetName(fileWithoutExtension),
Version = PackageNameUtility.GetVersion(fileWithoutExtension),
Source = this,
Dependencies = tempFolder.Dependencies.ToList(),
Anchored = tempFolder.Anchored
};
Packages.Add(package);
return(package);
}
internal static MultipartFormDataContent ToMultipartFormDataContent(this InMemoryFile source, string controllerParameterName)
{
var multiPartFormData = new MultipartFormDataContent();
multiPartFormData.Add(new ByteArrayContent(source.FileContent), controllerParameterName, source.Name);
multiPartFormData.Add(new StringContent("ResourceName"), "Estell-Test");
return(multiPartFormData);
}
public File AddFileToRelease(File file)
{
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
File toSave = new InMemoryFile(GetLocation(file.Location), file.GetContent());
return(this.fileSystemService.SaveFile(toSave));
}
private List <InMemoryFile> ExtractFilesInTarFile(Stream stream, bool fileNamesOnly)
{
var buffer = new byte[100];
var outFileList = new List <InMemoryFile>();
while (true)
{
var file = new InMemoryFile();
// Get file name (100 bytes)
stream.Read(buffer, 0, 100);
file.FilePath = Encoding.ASCII.GetString(buffer).Trim('\0');
if (string.IsNullOrWhiteSpace(file.FilePath))
{
break; // End of file reached
}
// Ignore the file mode, owners and group ID (8 bytes each)
stream.Seek(24, SeekOrigin.Current);
// Get file size (12 bytes)
stream.Read(buffer, 0, 12);
string sizeString = Encoding.ASCII.GetString(buffer, 0, 12).Trim();
var size = Convert.ToInt64(sizeString.TrimEnd('\0'), 8);
// Ignore remaining header fields
stream.Seek(376L, SeekOrigin.Current);
// Read file contents
var fileContentsBuffer = new byte[size];
stream.Read(fileContentsBuffer, 0, fileContentsBuffer.Length);
if (!fileNamesOnly)
{
file.FileContents = fileContentsBuffer;
}
if (stream.Position > stream.Length)
{
throw new ArchiveException("There was an error processing the tar ball.");
}
var offset = 512 - (stream.Position % 512);
if (offset == 512)
{
offset = 0;
}
stream.Seek(offset, SeekOrigin.Current);
outFileList.Add(file);
}
return(outFileList);
}
int ReceiveStream(MediaType streamType, Stream stream)
{
var memoryStream = new MemoryStream();
stream.CopyTo(memoryStream);
var file = new InMemoryFile(memoryStream)
{
ContentType = streamType
};
_files.Add(file);
return(_files.IndexOf(file));
}
private static IPackageFile CreatePackageFile(string name)
{
var file = new InMemoryFile();
file.Path = name;
file.Stream = new MemoryStream();
string effectivePath;
var fx = FrameworkNameUtility.ParseFrameworkNameFromFilePath(name, out effectivePath);
file.EffectivePath = effectivePath;
file.TargetFramework = fx;
return(file);
}
public async Task <FileResult> KimliklerDosya(string id)
{
ProjeDetailDto model = await _ProjeServis.GetDetailAsync(id);
List <InMemoryFile> files = new List <InMemoryFile>();
foreach (var karakter in model.ProjeKarakterleri)
{
foreach (var oyuncu in karakter.Oyuncular)
{
if (oyuncu.KarakterDurumu == EnuKarakterDurumu.KabulEdildi)
{
if (oyuncu.KimlikOn.IsNotNull())
{
string dosyaYeri = FileHelper._WebRootPath + oyuncu.KimlikOn.Replace("/", "\\");
if (System.IO.File.Exists(dosyaYeri))
{
string filename = $"{oyuncu.Adi} {oyuncu.Soyadi}_{oyuncu.Tc}_On{Path.GetExtension(oyuncu.KimlikOn)}";
InMemoryFile file = new InMemoryFile
{
FileName = filename,
Content = System.IO.File.ReadAllBytes(dosyaYeri)
};
files.Add(file);
}
dosyaYeri = FileHelper._WebRootPath + oyuncu.KimlikArka.Replace("/", "\\");
if (System.IO.File.Exists(dosyaYeri))
{
string filename = $"{oyuncu.Adi} {oyuncu.Soyadi}_{oyuncu.Tc}_Arka{Path.GetExtension(oyuncu.KimlikArka)}";
InMemoryFile file = new InMemoryFile
{
FileName = filename,
Content = System.IO.File.ReadAllBytes(dosyaYeri)
};
files.Add(file);
}
}
}
}
}
return(File(GetZipArchive(files), System.Net.Mime.MediaTypeNames.Application.Zip, $"{model.ProjeAdi.Replace(" ", "")}.zip"));
}
public override bool Create(ITreeNode parent, string name)
{
if (name != null)
{
try
{
Diagram dia = Diagram.CreateNew();
var mfile = new InMemoryFile("tmp.dia");
dia.Save(mfile);
parent.CreateChildTextFile(name + ".dia", mfile.GetText());
return(true);
}
catch (Exception e)
{
Errors.Report(e);
}
}
return(false);
}
public override bool Create(ITreeNode parent, string name)
{
if (name != null)
{
try
{
var vdv = new VariantDef();
var mfile = new InMemoryFile("tmp.vdv");
vdv.Save(mfile);
parent.CreateChildTextFile(name + ".vdv", mfile.GetText());
return(true);
}
catch (Exception e)
{
Errors.Report(e);
}
}
return(false);
}
public async Task <ApiGatewayResponse> FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
List <InMemoryFile> fileList = new List <InMemoryFile>();
var unprintedTags = await _tagService.GetUnprintedTags();
Dictionary <Tags, InMemoryFile> filesDictionary = new Dictionary <Tags, InMemoryFile>();
foreach (var val in unprintedTags)
{
var qrArray = QrCodeCreator.CreateQrArray($"https://petzfinder.net/tag/{val.TagId}");
var file = new InMemoryFile()
{
Content = qrArray,
FileName = $"{val.TagId}.png"
};
filesDictionary.Add(val, file);
}
var timeStamp = DateTime.Now.ToString("yyyy_MM_dd_mm");
_AwsService.UploadZipFileToS3(ZipFile.GetZipArchive(filesDictionary.Values.ToList()), timeStamp);
foreach (var tag in unprintedTags)
{
tag.Printed = "true";
tag.FileDestination = timeStamp.Replace("_mm_ss", "");
await _tagService.UpdateTag(tag);
}
//_AwsService.UploadQRFileListToS3(filesDictionary);
ApiGatewayResponse response = new ApiGatewayResponse()
{
StatusCode = 200
//Body = Base64UrlEncoder.Encode(ZipFile.GetZipArchive(filesDictionary.Values.ToList())),
//IsBase64Encoded = true
};
//var zip = ZipFile.GetZipArchive(filesDictionary.Values.ToList());
return(response);
}
private static IPackageFile CreatePackageFile(string name)
{
var file = new InMemoryFile
{
Path = name,
Stream = new MemoryStream()
};
string effectivePath;
var fx = FrameworkNameUtility.ParseNuGetFrameworkFromFilePath(name, out effectivePath);
file.EffectivePath = effectivePath;
if (fx != null)
{
file.NuGetFramework = fx;
if (fx.Version.Major < 5)
{
file.TargetFramework = new FrameworkName(fx.DotNetFrameworkName);
}
}
return(file);
}
public void Save(string container, string fileName, Stream content)
{
if (this.files.ContainsKey(container) == false)
{
this.files.Add(container, new List <InMemoryFile>());
}
var list = this.files[container];
var memoryStream = new MemoryStream();
content.CopyTo(memoryStream);
var data = memoryStream.ToArray();
var item = new InMemoryFile
{
Name = fileName,
Data = data
};
list.Add(item);
}
void Publish(IPackageRepository source, string packageFileName, Stream packageStream)
{
var name = PackageNameUtility.GetName(packageFileName);
var version = PackageNameUtility.GetVersion(packageFileName);
if (Packages.Any(x => x.Name.EqualsNoCase(name) && x.SemanticVersion == version))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = inMemoryFile.OpenWrite())
IO.StreamExtensions.CopyTo(packageStream, stream);
var tempFolder = new ZipFilePackage(inMemoryFile);
var package = new InMemoryPackage(tempFolder)
{
Source = this
};
Packages.Add(package);
}
protected InMemoryFile Package(string wrapName, string version, params string[] wrapdescLines)
{
var file = new InMemoryFile(wrapName + "-" + version + ".wrap");
PackageBuilder.NewWithDescriptor(file, wrapName, version, wrapdescLines);
return file;
}
private static bool EncryptDecrypt(
DataType startType, DataType interType, DataType endType,
DataFormat startFormat, DataFormat interFormat, DataFormat endFormat,
string password,
int saltLength, int keyIterations, int keySize,
int messageLength
)
{
if ((interType == DataType.Console && interFormat == DataFormat.Raw) || (endType == DataType.Console && endFormat == DataFormat.Raw))
{
return(false);
}
string startInputArg;
string startOutputArg = string.Empty;
byte[] originalClearMessage;
if (startType == DataType.Console)
{
do
{
originalClearMessage = GenerateRandom(messageLength, true);
if (startFormat == DataFormat.Base64)
{
startInputArg = Convert.ToBase64String(originalClearMessage);
}
else if (startFormat == DataFormat.Hexa)
{
startInputArg = ToHexString(originalClearMessage);
}
else
{
startInputArg = Encoding.ASCII.GetString(originalClearMessage);
}
} while (startInputArg.StartsWith("-"));
}
else
{
originalClearMessage = GenerateRandom(messageLength, false);
string startFilename = Utils.EnsureFilename("tests/clear.bin");
#if IN_MEMORY
if (InMemoryFile.Exists(startFilename))
{
InMemoryFile.Delete(startFilename);
}
if (startFormat == DataFormat.Base64)
{
InMemoryFile.WriteAllText(startFilename, Convert.ToBase64String(originalClearMessage));
}
else if (startFormat == DataFormat.Hexa)
{
InMemoryFile.WriteAllText(startFilename, ToHexString(originalClearMessage));
}
else
{
InMemoryFile.WriteAllBytes(startFilename, originalClearMessage);
}
#else
if (File.Exists(startFilename))
{
File.Delete(startFilename);
}
if (startFormat == DataFormat.Base64)
{
File.WriteAllText(startFilename, Convert.ToBase64String(originalClearMessage));
}
else if (startFormat == DataFormat.Hexa)
{
File.WriteAllText(startFilename, ToHexString(originalClearMessage));
}
else
{
File.WriteAllBytes(startFilename, originalClearMessage);
}
#endif
startInputArg = startFilename;
}
StringBuilder interStringBuilder = null;
if (interType == DataType.Console)
{
interStringBuilder = new StringBuilder();
Console.SetOut(new StringWriter(interStringBuilder));
}
else
{
string interFilename = Utils.EnsureFilename("tests/encrypted.aes");
#if IN_MEMORY
if (InMemoryFile.Exists(interFilename))
{
InMemoryFile.Delete(interFilename);
}
#else
if (File.Exists(interFilename))
{
File.Delete(interFilename);
}
#endif
startOutputArg = interFilename;
}
var startArgs = new string[]
{
"-e",
"--input-type", startType.ToString().ToLowerInvariant(),
"--input-format", startFormat.ToString().ToUpperInvariant(),
"--output-type", interType.ToString().ToLowerInvariant(),
"--output-format", interFormat.ToString().ToLowerInvariant(),
"--password", password,
"--key-salt-length", saltLength.ToString(),
"--key-iterations", keyIterations.ToString(),
"--key-size", keySize.ToString(),
"--skip-bytes", "0",
startInputArg,
startOutputArg
};
new Aes.Program().Run(startArgs);
// ==================================================
string endInputArg;
string endOutputArg = string.Empty;
if (interType == DataType.Console)
{
endInputArg = ConsoleOutStream.TrimConsoleDataMarkers(interStringBuilder.ToString());
}
else
{
endInputArg = Utils.EnsureFilename("tests/encrypted.aes");
}
StringBuilder endStringBuilder = null;
if (endType == DataType.Console)
{
endStringBuilder = new StringBuilder();
Console.SetOut(new StringWriter(endStringBuilder));
}
else
{
string endFilename = Utils.EnsureFilename("tests/decrypted.bin");
#if IN_MEMORY
if (InMemoryFile.Exists(endFilename))
{
InMemoryFile.Delete(endFilename);
}
#else
if (File.Exists(endFilename))
{
File.Delete(endFilename);
}
#endif
endOutputArg = endFilename;
}
var endArgs = new string[]
{
"-d",
"--input-type", interType.ToString().ToLowerInvariant(),
"--input-format", interFormat.ToString().ToUpperInvariant(),
"--output-type", endType.ToString().ToLowerInvariant(),
"--output-format", endFormat.ToString().ToLowerInvariant(),
"--password", password,
"--key-salt-length", saltLength.ToString(),
"--key-iterations", keyIterations.ToString(),
"--key-size", keySize.ToString(),
"--skip-bytes", "0",
endInputArg,
endOutputArg
};
new Aes.Program().Run(endArgs);
byte[] resultMessage = null;
if (endType == DataType.Console)
{
resultMessage = Encoding.ASCII.GetBytes(ConsoleOutStream.TrimConsoleDataMarkers(endStringBuilder.ToString()));
}
else
{
#if IN_MEMORY
resultMessage = InMemoryFile.ReadAllBytes(Utils.EnsureFilename("tests/decrypted.bin"));
#else
resultMessage = File.ReadAllBytes(Utils.EnsureFilename("tests/decrypted.bin"));
#endif
}
if (endFormat == DataFormat.Base64)
{
resultMessage = Convert.FromBase64String(Encoding.ASCII.GetString(resultMessage));
}
else if (endFormat == DataFormat.Hexa)
{
resultMessage = FromHexStringAsBytes(resultMessage);
}
string info = $"{startType} {interType} {endType}, {startFormat} {interFormat} {endFormat}, {password}, {saltLength}, {keyIterations}, {keySize}, {messageLength}";
if (originalClearMessage.Length != resultMessage.Length)
{
throw new Exception($"Length mismatch. [{info}]");
}
for (int i = 0; i < originalClearMessage.Length; i++)
{
if (originalClearMessage[i] != resultMessage[i])
{
throw new Exception($"Data mismatch at position '{i}'. [{info}]");
}
}
return(true);
}
protected InMemoryFile Package(string wrapName, string version)
{
var file = new InMemoryFile(wrapName + "-" + version + ".wrap");
PackageBuilder.New(file, wrapName, version);
return file;
}
internal void CreateManifest(ItemLocation folder, SiteManifest manifest)
{
var file = new InMemoryFile(folder, new MemoryStream(manifest.ToByteArray()));
fileSystemService.SaveFile(file);
}
private int ReceiveStream(MediaType streamType, Stream stream)
{
var memoryStream = new MemoryStream();
stream.CopyTo(memoryStream);
var file = new InMemoryFile(memoryStream) { ContentType = streamType };
Files.Add(file);
return Files.IndexOf(file);
}
protected void when_publishing_package(InMemoryFile package)
{
using (var stream = package.OpenRead())
using (var publisher = Repository.Publisher())
publisher.Publish(package.Name, stream);
}
protected void when_publishing_package(InMemoryFile package)
{
using (var stream = package.OpenRead())
Repository.Publish(package.Name, stream);
}
void given_entity(InMemoryFile file)
{
file.OpenStream().Write(Encoding.UTF8.GetBytes("Test data"));
_entity = file;
}
protected InMemoryFile Package(string name, string version, IEnumerable<PackageContent> content, params string[] descriptorLines)
{
var file = new InMemoryFile(name + "-" + version + ".wrap");
Packager.NewWithDescriptor(file, name, version, content, descriptorLines);
return file;
}
