public void Send(string remoteUrl, IDictionary<string, string> headers, Stream data) { var request = WebRequest.Create(remoteUrl); request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded"; request.Headers = Encode(headers); request.UseDefaultCredentials = true; request.ContentLength = data.Length; using (var stream = request.GetRequestStream()) { data.CopyTo(stream); } HttpStatusCode statusCode; //todo make the receiver send the md5 back so that we can double check that the transmission went ok using (var response = (HttpWebResponse) request.GetResponse()) { statusCode = response.StatusCode; } Logger.Debug("Got HTTP response with status code " + statusCode); if (statusCode != HttpStatusCode.OK) { Logger.Warn("Message not transferred successfully. Trying again..."); throw new Exception("Retrying"); } }
/// <summary> /// Write - this write routine for mdat is used only when writing out an MP4 file. /// (See MP4StreamWriter.) /// </summary> /// <param name="writer"></param> public void Write(BoxWriter writer, Stream reader) { if (base.Size == 0UL) { base.Write(writer); reader.CopyTo(writer.BaseStream); } else using (new SizeCalculator(this, writer)) { base.Write(writer); reader.CopyTo(writer.BaseStream); } }
public void CreateOrAppendToFile(string fileLocation, Stream stream) { var sourcePath = Path.Combine(DebugConfig.LocalStoragePath, fileLocation); var fileInfo = new FileInfo(sourcePath); if (fileInfo.Exists) { using (var streamWrite = fileInfo.Open(FileMode.Append, FileAccess.Write)) stream.CopyTo(streamWrite); } else { using (var streamWrite = fileInfo.Open(FileMode.Create, FileAccess.Write)) stream.CopyTo(streamWrite); } }
public void Transform(Stream stream) { if (mHash == null) return; stream.CopyTo(mCryptoStream); }
private static TemporaryFile Deploy(Stream stream) { var tempFile = new TemporaryFile("0install-unit-tests"); using (var fileStream = File.Create(tempFile)) stream.CopyTo(fileStream); return tempFile; }
public static byte[] ReadFully(Stream input) { using (MemoryStream ms = new MemoryStream()) { input.CopyTo(ms); return ms.ToArray(); } }
public static HttpWebRequest ConstructWebRequest(this Uri uri, string method, Stream contentStream, IDictionary<string, string> headers, int timeout = 0) { if (headers != null) headers.FilterHeaders(); HttpWebRequest request = WebRequest.Create(uri) as HttpWebRequest; var t = timeout == 0 ? NFX.Web.WebSettings.WebDavDefaultTimeoutMs : timeout; if (t > 0) request.Timeout = t; request.Method = method; request.ContentType = "text/plain"; if (method == "PUT") request.ContentLength = contentStream.Length; foreach (var kvp in headers) request.Headers.Add(kvp.Key, kvp.Value); if (method == "PUT") { using (Stream requestStream = request.GetRequestStream()) { contentStream.Position = 0; contentStream.CopyTo(requestStream); requestStream.Flush(); requestStream.Close(); } } return request; }
private static Stream Clone(Stream source) { var cloned = new MemoryStream(); #if NET35 // Copy up to 2048 bytes at a time byte[] buffer = new byte[2048]; // Maintains how many bytes were read int copiedBytes; // Read bytes and copy them into a buffer making sure not to trigger the dispose while ((copiedBytes = source.Read(buffer, 0, buffer.Length)) > 0) { // Write the copied bytes from the buffer into the cloned stream cloned.Write(buffer, 0, copiedBytes); } #else source.CopyTo(cloned); #endif // Move the stream pointers back to the original start locations if (source.CanSeek) { source.Seek(0, 0); } cloned.Seek(0, 0); return cloned; }
public static Stream Resize(int width, int height, Stream image, string fileName) { Stream fileStream = new MemoryStream(); Image tempImage = Bitmap.FromStream(image); long maxFactor = width * height; long imageFactor = tempImage.Width * tempImage.Height; if (maxFactor < imageFactor) { using (ImageResizer resizer = new ImageResizer()) { resizer.MimeType = Path.GetExtension(fileName); resizer.SourceImage = tempImage; resizer.Background = ColorTranslator.FromHtml("#fff"); resizer.Mode = ImageResizer.ResizeMode.KeepOriginalAspect; resizer.Width = width; resizer.Height = height; resizer.Process(); resizer.ResultImage.Save(fileStream, tempImage.RawFormat); } } else { image.Seek(0, SeekOrigin.Begin); image.CopyTo(fileStream); } return fileStream; }
public static void WriteFile(string FilePath, Stream FileContent) { using (FileStream outStream = new FileStream(FilePath, FileMode.Create, FileAccess.Write, FileShare.None)) { FileContent.CopyTo(outStream); } }
public string Store (string id, Stream stream) { EnsureOutput (); SetupEntry (zipOutput, ref id); stream.CopyTo (zipOutput); return id; }
//public JsonFormatter() //{ // SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/json")); // SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json")); //} public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var task = new TaskCompletionSource<object>(); using (var ms = new MemoryStream()) { readStream.CopyTo(ms); //ms.Seek(0, SeekOrigin.Begin); //var result = JsonSchemaValidator.Instance().Validate(ms, type); //if (!string.IsNullOrWhiteSpace(result)) // task.SetResult(result); //else { ms.Seek(0, SeekOrigin.Begin); using (var reader = new JsonTextReader(new StreamReader(ms))) { var serializer = new JsonSerializer(); task.SetResult(serializer.Deserialize(reader, type)); } } } return task.Task; }
public static MemoryStream Decrypt(Stream ciphertext) { var process = new Process { EnableRaisingEvents = false, StartInfo = new ProcessStartInfo { FileName = @"C:\Program Files (x86)\GNU\GnuPG\pub\gpg2.exe", Arguments = @"--decrypt", WindowStyle = ProcessWindowStyle.Hidden, CreateNoWindow = true, UseShellExecute = false, RedirectStandardInput = true, RedirectStandardOutput = true } }; process.Start(); var stdin = process.StandardInput; ciphertext.CopyTo(stdin.BaseStream); stdin.Close(); var stdout = new MemoryStream(); process.WaitForExit(); process.StandardOutput.BaseStream.CopyTo(stdout); return stdout; }
// ------------------------------------------ // Audio Management // ------------------------------------------ public override void BeforeSpeechRecognition(string device, string text, double confidence, XPathNavigator xnav, string grammar, Stream stream, IDictionary<string, string> options) { base.BeforeSpeechRecognition(device, text, confidence, xnav, grammar, stream, options); byte[] audioBytes = null; stream.Position = 0; using (MemoryStream audioStream = new MemoryStream()) { stream.CopyTo(audioStream); audioStream.Position = 0; audioBytes = audioStream.ToArray(); } float[] audioBuffer = new float[audioBytes.Length / 2]; for (int i = 0, j = 0; i < audioBytes.Length / 2; i += 2, j++) { // convert two bytes to one short short s = BitConverter.ToInt16(audioBytes, i); // convert to range from -1 to (just below) 1 audioBuffer[j] = s / 32768.0f; } // Reset tracker.Reset(); pitch.Clear(); // Process tracker.ProcessBuffer(audioBuffer); // Notify AddOnManager.GetInstance().HandleProfile(device, "pitch", pitch.Mean()); }
public void PushPackage(string packageFileName, Stream packageStream) { packageFileName = PackageNameUtility.NormalizeFileName(packageFileName); var packageFile = _directory.GetFile(packageFileName); using (var destinationStream = packageFile.OpenWrite()) packageStream.CopyTo(destinationStream); #pragma warning disable 612,618 var zipPackage = new ZipFilePackage(packageFile); IndexDocument.Document.Root.Add( new XElement("wrap", new XAttribute("name", zipPackage.Name), new XAttribute("version", zipPackage.Version), new XAttribute("semantic-version", zipPackage.SemanticVersion), new XElement("link", new XAttribute("rel", "package"), new XAttribute("href", packageFile.Name)), zipPackage.Dependencies.Select(x => new XElement("depends", x.ToString())) )); #pragma warning restore 612,618 SaveIndex(IndexDocument); return; }
private static IList<Bitmap> ProcessInputFrames(Stream input, string text, out int delay) { // default delay = 50; using (var copiedInput = new MemoryStream()) { input.CopyTo(copiedInput); using (var gifImage = Image.FromStream(copiedInput)) { var frameCount = gifImage.GetFrameCount(FrameDimension.Time); var frames = new List<Bitmap>(); for (var index = 0; index < frameCount; index++) { Console.WriteLine("Processing frame #{0}/{1}", index + 1, frameCount); gifImage.SelectActiveFrame(FrameDimension.Time, index); var bitmap = gifImage.Clone() as Bitmap; if (index == 0) { delay = BitConverter.ToInt32(gifImage.GetPropertyItem(20736).Value, index) * 10; } frames.Add(RenderOverlay(bitmap, text)); } return frames; } } }
private static string HashWithLibGit2Sharp(Stream file) { var repository = new Repository(Environment.CurrentDirectory); var temp = new FileStream(Path.GetTempFileName(),FileMode.Open); file.CopyTo(temp); return repository.ObjectDatabase.CreateBlob(temp.Name).Sha.ToString(); }
public static string UploadFileToS3(IServices services, string fileName, Stream file, string folderName) { string s3FilePath = string.Empty; if (file != null) { byte[] bFile = null; MemoryStream memoryStream = new MemoryStream(); try { file.CopyTo(memoryStream); bFile = memoryStream.ToArray(); s3FilePath = services.Image.SaveImage(fileName, bFile, folderName); } catch (Exception ex) { Log.Error("FileHelper_UploadFileToS3_error: " + fileName, ex); } finally { memoryStream.Close(); memoryStream.Dispose(); } } file.Close(); file.Dispose(); return s3FilePath; }
public VTFGenerator(Stream inputStream, Stream outputStream) { processDelegate = new ProcessAsync(this.Process); _output = new VTFOutput(outputStream); _smallInputFile = new MemoryStream(); inputStream.CopyTo(_smallInputFile); }
/// <summary> /// Requests the HTTP headers from a stream. /// </summary> /// <param name="stream">A stream.</param> public void RequestHeaders(Stream stream) { var tempStream = new MemoryStream(); stream.CopyTo(tempStream); tempStream.Seek(0, SeekOrigin.Begin); using (var streamReader = new StreamReader(tempStream)) { var headers = new Dictionary<string, string>(); while (true) { var line = streamReader.ReadLine(); if (String.IsNullOrWhiteSpace(line)) { break; } if (line.StartsWith("HTTP/1.")) { continue; } var header = line.Substring(0, line.IndexOf(':')).Trim(); var value = line.Substring(line.IndexOf(':') + 1).Trim(); headers.Add(header, value); } stream.Seek(0, SeekOrigin.Begin); this.OnHeadersAvailable(headers); } }
public async Task<bool> Save(Stream stream, string path) { var api = await GetApi(); var tempFilename = Path.GetTempFileName(); using (var fileStream = File.Create(tempFilename)) { stream.Seek(0, SeekOrigin.Begin); stream.CopyTo(fileStream); } //var memoryStream = new MemoryStream(); //var bytes = stream.ToArray(); //File.WriteAllBytes(tempFilename, bytes); var directory = Path.GetDirectoryName(path); var filename = Path.GetFileName(path); var uploadedItem = await api.UploadFileAs(tempFilename, filename, directory); File.Delete(tempFilename); return uploadedItem != null; }
public static void WriteStreamToFile(string filePath, Stream networkStream) { using (var fileStream = new FileStream(filePath, FileMode.Create)) { networkStream.CopyTo(fileStream); } }
public DownloadResult( ILog logger, Stream zipContent ) { File = new TemporaryFile( ".zip" ); using( zipContent ) using( var sw = System.IO.File.Open( File.Path, FileMode.Open ) ) zipContent.CopyTo( sw ); try { // open the zip file using( ZipFile zip = ZipFile.Read( File.Path ) ) { var manifestEntry = zip.Where( z => z.FileName == "manifest.xml" ).FirstOrDefault(); if( manifestEntry != null ) { var ms = new MemoryStream(); manifestEntry.Extract( ms ); try { Manifest = HelpManifestData.Deserialize( ms ); } catch( Exception ex ) { logger.Error( "Unable to parse manifest", ex ); throw; } } } } catch( Exception ex ) { logger.Error( "Unable to read downloaded help content as a zip file", ex ); throw; } }
public void onPost(string light, string hum, string temp, Stream fileCont) { // save POST content as BMP file ... string docname = (DateTime.Now.ToLongTimeString() + "." + light + "_" + hum + "_" + temp + ".bmp").Replace(":", "_"); string strdocPath; strdocPath = System.Web.Hosting.HostingEnvironment.MapPath("~/pics/") + docname; // Save Stream to local memory stream for later distrbution ... var ms = new MemoryStream(); fileCont.CopyTo(ms); ms.Position = 0; FileStream fs = new FileStream(strdocPath, FileMode.Create, FileAccess.ReadWrite); ms.CopyTo(fs); ms.Position = 0; fs.Close(); ; Byte[] bytes = new Byte[ms.Length]; ms.Read(bytes, 0, bytes.Length); var objContext = new TDataEntities(); var newData = new TDataItem(); newData.lightSENS = int.Parse(light); newData.humSENS = int.Parse(hum); newData.tempSENS = decimal.Parse(temp); newData.Date = DateTime.Now; newData.Transacto = bytes; objContext.TDataItems.AddObject(newData); objContext.SaveChanges(); }
public static RSResponse StoreFile(RSRequest rsRequest, Stream entity) { string extensionToAdd = ""; //If file extension was not specified, make a good guess if (Path.GetExtension(rsRequest.LocalPath) == String.Empty) { extensionToAdd = rsRequest.ContentType.GetFileExtensionCandidates()[0]; } //Add extension to the target file name (or don't) string newFileName = rsRequest.LocalPath + extensionToAdd; try { using (FileStream fs = File.OpenWrite(newFileName)) { entity.CopyTo(fs); } } catch (Exception ex) { return new StatusCodeResponse(HttpStatusCode.InternalServerError, ex.Message); } return new StatusCodeResponse(HttpStatusCode.Created); }
public void Encrypt(Stream streamIn, Stream streamOut, Stream streamKey) { using (Rijndael rij = Rijndael.Create()) { key = rij.Key; iv = rij.IV; using (ICryptoTransform encryptor = rij.CreateEncryptor(key, iv)) { using (CryptoStream cryptoStream = new CryptoStream(streamOut, encryptor, CryptoStreamMode.Write)) { streamIn.CopyTo(cryptoStream); StringBuilder builder = new StringBuilder(); builder.AppendLine(Convert.ToBase64String(iv)); builder.AppendLine(Convert.ToBase64String(key)); byte[] keyfile = System.Text.Encoding.Default.GetBytes(builder.ToString()); streamKey.Write(keyfile, 0, keyfile.Length); } } } }
public Task<SmtpCommandReply> HandleData(Stream stream) { stream.CopyTo(Body); Body.Seek(0, SeekOrigin.Begin); return SmtpCommandReply.CreateDefault250SuccessTask(); }
private static Stream GenerateThumbinail(Stream origImageStream, Size maxSize, out Size resultSize) { var resizedImageStream = new MemoryStream(); using (Image rawImage = Image.FromStream(origImageStream)) { int targetWidth = rawImage.Width; int targetHeight = rawImage.Height; if (rawImage.Width > maxSize.Width || rawImage.Height > maxSize.Height) { CalcTargetSize(rawImage.Width, rawImage.Height, maxSize, out targetWidth, out targetHeight); resultSize = new Size(targetWidth, targetHeight); return GenerateThumbinailExact(origImageStream, resultSize); } else // image already with allowed size { origImageStream.Seek(0, SeekOrigin.Begin); origImageStream.CopyTo(resizedImageStream); resizedImageStream.Seek(0, SeekOrigin.Begin); resultSize = new Size(rawImage.Width, rawImage.Height); return resizedImageStream; } } }
public Etag AddAttachment(string key, Etag etag, Stream data, RavenJObject headers) { Api.JetSetCurrentIndex(session, Files, "by_name"); Api.MakeKey(session, Files, key, Encoding.Unicode, MakeKeyGrbit.NewKey); var isUpdate = Api.TrySeek(session, Files, SeekGrbit.SeekEQ); if (isUpdate) { var existingEtag = Etag.Parse(Api.RetrieveColumn(session, Files, tableColumnsCache.FilesColumns["etag"])); if (existingEtag != etag && etag != null) { throw new ConcurrencyException("PUT attempted on attachment '" + key + "' using a non current etag") { ActualETag = existingEtag, ExpectedETag = etag }; } } else { if (data == null) throw new InvalidOperationException("When adding new attachment, the attachment data must be specified"); if (Api.TryMoveFirst(session, Details)) Api.EscrowUpdate(session, Details, tableColumnsCache.DetailsColumns["attachment_count"], 1); } Etag newETag = uuidGenerator.CreateSequentialUuid(UuidType.Attachments); using (var update = new Update(session, Files, isUpdate ? JET_prep.Replace : JET_prep.Insert)) { Api.SetColumn(session, Files, tableColumnsCache.FilesColumns["name"], key, Encoding.Unicode); if (data != null) { long written; using (var columnStream = new ColumnStream(session, Files, tableColumnsCache.FilesColumns["data"])) { if (isUpdate) columnStream.SetLength(0); using (var stream = new BufferedStream(columnStream)) { data.CopyTo(stream); written = stream.Position; stream.Flush(); } } if (written == 0) // empty attachment { Api.SetColumn(session, Files, tableColumnsCache.FilesColumns["data"], new byte[0]); } } Api.SetColumn(session, Files, tableColumnsCache.FilesColumns["etag"], newETag.TransformToValueForEsentSorting()); Api.SetColumn(session, Files, tableColumnsCache.FilesColumns["metadata"], headers.ToString(Formatting.None), Encoding.Unicode); update.Save(); } logger.Debug("Adding attachment {0}", key); return newETag; }
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { return Task.Factory.StartNew(() => { MemoryStream stream = new MemoryStream(); readStream.CopyTo(stream); IEnumerable<string> xContentHeader; var success = content.Headers.TryGetValues("X-Content-Type", out xContentHeader); if (!success) { throw Error.BadRequest("POST to binary must provide a Content-Type header"); } string contentType = xContentHeader.FirstOrDefault(); Binary binary = new Binary(); binary.Content = stream.ToArray(); binary.ContentType = contentType; //ResourceEntry entry = ResourceEntry.Create(binary); //entry.Tags = content.Headers.GetFhirTags(); return (object)binary; }); }
static public int CopyTo__Stream(IntPtr l) { try { System.IO.Stream self = (System.IO.Stream)checkSelf(l); System.IO.Stream a1; checkType(l, 2, out a1); self.CopyTo(a1); pushValue(l, true); return(1); } catch (Exception e) { return(error(l, e)); } }
static void Ex1() { Task.Run(async() => { string uri = "https://github.com/K38104011/DataStructureLearning"; System.Net.WebRequest req = System.Net.WebRequest.Create(uri); using (System.Net.WebResponse res = await req.GetResponseAsync()) using (System.IO.Stream stream = res.GetResponseStream()) using (System.IO.FileStream fs = System.IO.File.Create("code.html")) { stream?.CopyTo(fs); Console.WriteLine(res.ContentLength); } System.Diagnostics.Process.Start("code.html"); }); }
static void CopyStream(System.IO.Stream input, System.IO.Stream output) { input.CopyTo(output); output.Flush(); }
protected override void _Rollback() { if (ExecutionMode == ExecuteOn.ForwardExecution) { foreach (string d in _FilesActioned.Keys) { try { string s = _FilesActioned[d]; if (Action == ActionType.Move) { if (Direction == AzureDirection.ToAzureContainer) { CloudBlockBlob blob = Authentication.GetCloudBlockBlob(s, false); if (blob == null) { throw new Exception("File does not exist or can not be reached: " + s); } System.Threading.Tasks.Task <System.IO.Stream> streamResult = blob.OpenReadAsync(); streamResult.Wait(); string tmp = ""; try { tmp = Path.Combine(STEM.Sys.IO.Path.GetDirectoryName(d), "TEMP"); if (!Directory.Exists(tmp)) { Directory.CreateDirectory(tmp); } tmp = Path.Combine(tmp, STEM.Sys.IO.Path.GetFileName(d)); using (System.IO.Stream sStream = streamResult.Result) { using (System.IO.Stream dStream = System.IO.File.Open(tmp, System.IO.FileMode.CreateNew, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None)) { sStream.CopyTo(dStream); } } File.Move(tmp, STEM.Sys.IO.Path.AdjustPath(d)); } finally { try { if (File.Exists(tmp)) { File.Delete(tmp); } } catch { } } File.SetLastWriteTimeUtc(STEM.Sys.IO.Path.AdjustPath(d), blob.Properties.LastModified.Value.UtcDateTime); } else { CloudBlockBlob blob = Authentication.GetCloudBlockBlob(d, true); blob.StreamWriteSizeInBytes = 16777216; System.Threading.Tasks.Task <CloudBlobStream> streamResult = blob.OpenWriteAsync(); streamResult.Wait(); using (System.IO.Stream sStream = System.IO.File.Open(STEM.Sys.IO.Path.AdjustPath(s), System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.None)) { using (System.IO.Stream dStream = streamResult.Result) { sStream.CopyTo(dStream); } } } } if (Direction == AzureDirection.ToAzureContainer) { Authentication.DeleteFile(s); } else { STEM.Sys.IO.File.STEM_Delete(s, false, Retry, RetryDelaySeconds); } } catch { } } } else { Execute(); } }
bool Execute() { try { if (Direction == AzureDirection.ToAzureContainer) { ExpandDestination = false; } else { ExpandSource = false; } List <string> sources = new List <string>(); if (ExpandSource) { sources = STEM.Sys.IO.Path.ExpandRangedPath(SourcePath); } else { sources.Add(SourcePath); } List <string> destinations = new List <string>(); if (ExpandDestination) { destinations = STEM.Sys.IO.Path.ExpandRangedPath(DestinationPath); } else { destinations.Add(DestinationPath); } List <string> sourceFiles = new List <string>(); int filesActioned = 0; foreach (string src in sources) { List <IListBlobItem> items = new List <IListBlobItem>(); if (Direction == AzureDirection.ToAzureContainer) { sourceFiles = STEM.Sys.IO.Directory.STEM_GetFiles(src, FileFilter, DirectoryFilter, (RecurseSource ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly), false); } else { string container = Authentication.ContainerFromPath(src); string prefix = Authentication.PrefixFromPath(src); items = Authentication.ListObjects(container, prefix, Sys.IO.Listing.ListingType.File, RecurseSource, DirectoryFilter, FileFilter); sourceFiles = items.Select(i => Authentication.ToString(i)).ToList(); } foreach (string s in sourceFiles) { try { bool success = false; Exception lastEX = null; foreach (string d in destinations) { try { string dFile = ""; try { if (PopulatePostMortemMeta) { PostMortemMetaData["SourceIP"] = STEM.Sys.IO.Path.IPFromPath(s); PostMortemMetaData["DestinationIP"] = STEM.Sys.IO.Path.IPFromPath(d); if (Direction == AzureDirection.ToAzureContainer) { PostMortemMetaData["FileSize"] = new FileInfo(s).Length.ToString(); } else { PostMortemMetaData["FileSize"] = Authentication.GetFileInfo(s).Size.ToString(); } } } catch { } string dPath = STEM.Sys.IO.Path.AdjustPath(d); if (RecurseSource && RecreateTree) { dPath = System.IO.Path.Combine(dPath, STEM.Sys.IO.Path.GetDirectoryName(s).Replace(STEM.Sys.IO.Path.AdjustPath(src), "").Trim(System.IO.Path.DirectorySeparatorChar)); } dPath = System.IO.Path.Combine(dPath, DestinationFilename); if (dPath.Contains("*.*")) { dPath = dPath.Replace("*.*", STEM.Sys.IO.Path.GetFileName(s)); } if (dPath.Contains("*")) { dPath = dPath.Replace("*", STEM.Sys.IO.Path.GetFileNameWithoutExtension(s)); } if (Direction == AzureDirection.ToAzureContainer) { if (!Authentication.DirectoryExists(STEM.Sys.IO.Path.GetDirectoryName(dPath))) { Authentication.CreateDirectory(STEM.Sys.IO.Path.GetDirectoryName(dPath)); } if (Authentication.FileExists(dPath)) { switch (ExistsAction) { case Sys.IO.FileExistsAction.Overwrite: Authentication.DeleteFile(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.OverwriteIfNewer: if (Authentication.GetFileInfo(dPath).LastWriteTimeUtc >= File.GetLastWriteTimeUtc(STEM.Sys.IO.Path.AdjustPath(s))) { continue; } Authentication.DeleteFile(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.Skip: continue; case Sys.IO.FileExistsAction.Throw: throw new IOException("Destination file exists. (" + dPath + ")"); case Sys.IO.FileExistsAction.MakeUnique: dFile = Authentication.UniqueFilename(dPath); break; } } else { dFile = dPath; } CloudBlockBlob blob = Authentication.GetCloudBlockBlob(dPath, true); blob.StreamWriteSizeInBytes = 16777216; System.Threading.Tasks.Task <CloudBlobStream> streamResult = blob.OpenWriteAsync(); streamResult.Wait(); using (System.IO.Stream sStream = System.IO.File.Open(STEM.Sys.IO.Path.AdjustPath(s), System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.None)) { using (System.IO.Stream dStream = streamResult.Result) { sStream.CopyTo(dStream); } } } else { if (File.Exists(dPath)) { switch (ExistsAction) { case Sys.IO.FileExistsAction.Overwrite: File.Delete(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.OverwriteIfNewer: if (File.GetLastWriteTimeUtc(STEM.Sys.IO.Path.AdjustPath(dPath)) >= Authentication.GetFileInfo(s).LastWriteTimeUtc) { continue; } File.Delete(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.Skip: continue; case Sys.IO.FileExistsAction.Throw: throw new IOException("Destination file exists. (" + dPath + ")"); case Sys.IO.FileExistsAction.MakeUnique: dFile = STEM.Sys.IO.File.UniqueFilename(dPath); break; } } else { dFile = dPath; } if (!Directory.Exists(STEM.Sys.IO.Path.GetDirectoryName(dFile))) { Directory.CreateDirectory(STEM.Sys.IO.Path.GetDirectoryName(dFile)); } CloudBlockBlob blob = Authentication.GetCloudBlockBlob(s, false); if (blob == null) { throw new Exception("File does not exist or can not be reached: " + s); } System.Threading.Tasks.Task <System.IO.Stream> streamResult = blob.OpenReadAsync(); streamResult.Wait(); string tmp = ""; try { tmp = Path.Combine(STEM.Sys.IO.Path.GetDirectoryName(dFile), "TEMP"); if (!Directory.Exists(tmp)) { Directory.CreateDirectory(tmp); } tmp = Path.Combine(tmp, STEM.Sys.IO.Path.GetFileName(dFile)); using (System.IO.Stream sStream = streamResult.Result) { using (System.IO.Stream dStream = System.IO.File.Open(tmp, System.IO.FileMode.CreateNew, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None)) { sStream.CopyTo(dStream); } } try { File.SetLastWriteTimeUtc(tmp, blob.Properties.LastModified.Value.UtcDateTime); } catch { } File.Move(tmp, STEM.Sys.IO.Path.AdjustPath(dFile)); } finally { try { if (File.Exists(tmp)) { File.Delete(tmp); } } catch { } } } if (!String.IsNullOrEmpty(dFile)) { filesActioned++; _FilesActioned[s] = dFile; if (Action == ActionType.Move) { AppendToMessage(s + " moved to " + dFile); } else { AppendToMessage(s + " copied to " + dFile); } } success = true; if (DestinationActionRule == DestinationRule.FirstSuccess) { break; } } catch (Exception ex) { lastEX = ex; if (DestinationActionRule == DestinationRule.AllOrNone) { throw ex; } } } if (!success) { throw new Exception("No successful actions taken for " + s, lastEX); // + "\r\n" + ((lastEX == null) ? "No additional information." : lastEX.ToString())); } if (Action == ActionType.Move) { if (Direction == AzureDirection.ToAzureContainer) { File.Delete(s); } else { Authentication.DeleteFile(s); } } } catch (AggregateException ex) { foreach (Exception e in ex.InnerExceptions) { AppendToMessage(e.Message); Exceptions.Add(e); } } catch (Exception ex) { AppendToMessage(ex.Message); Exceptions.Add(ex); } } } if (PopulatePostMortemMeta) { PostMortemMetaData["FilesActioned"] = filesActioned.ToString(); } } catch (AggregateException ex) { foreach (Exception e in ex.InnerExceptions) { AppendToMessage(e.Message); Exceptions.Add(e); } } catch (Exception ex) { AppendToMessage(ex.Message); Exceptions.Add(ex); } if (_FilesActioned.Count == 0) { switch (ZeroFilesAction) { case FailureAction.SkipRemaining: SkipRemaining(); return(true); case FailureAction.SkipNext: SkipNext(); return(true); case FailureAction.SkipToLabel: SkipForwardToFlowControlLabel(FailureActionLabel); return(true); case FailureAction.Rollback: RollbackAllPreceedingAndSkipRemaining(); break; case FailureAction.Continue: return(true); } Message = "0 Files Actioned\r\n" + Message; } return(Exceptions.Count == 0); }
/// <summary> /// Take a photo async with specified options /// </summary> /// <param name="options">Camera Media Options</param> /// <param name="token">Cancellation token</param> /// <returns>Media file of photo or null if canceled</returns> public async Task <MediaFile> TakePhotoAsync(StoreCameraMediaOptions options, CancellationToken token = default(CancellationToken)) { if (!IsCameraAvailable) { throw new NotSupportedException(); } if (!(await RequestCameraPermissions())) { throw new MediaPermissionException(Permission.Camera); } VerifyOptions(options); var media = await TakeMediaAsync("image/*", MediaStore.ActionImageCapture, options, token); if (string.IsNullOrWhiteSpace(media?.Path)) { return(media); } if (options.SaveToAlbum) { try { var fileName = System.IO.Path.GetFileName(media.Path); var publicUri = MediaPickerActivity.GetOutputMediaFile(context, options.Directory ?? "temp", fileName, true, true); using (System.IO.Stream input = File.OpenRead(media.Path)) using (System.IO.Stream output = File.Create(publicUri.Path)) input.CopyTo(output); media.AlbumPath = publicUri.Path; var f = new Java.IO.File(publicUri.Path); //MediaStore.Images.Media.InsertImage(context.ContentResolver, // f.AbsolutePath, f.Name, null); try { MediaScannerConnection.ScanFile(context, new[] { f.AbsolutePath }, null, context as MediaPickerActivity); var values = new ContentValues(); values.Put(MediaStore.Images.Media.InterfaceConsts.Title, System.IO.Path.GetFileNameWithoutExtension(f.AbsolutePath)); values.Put(MediaStore.Images.Media.InterfaceConsts.Description, string.Empty); values.Put(MediaStore.Images.Media.InterfaceConsts.DateTaken, Java.Lang.JavaSystem.CurrentTimeMillis()); values.Put(MediaStore.Images.ImageColumns.BucketId, f.ToString().ToLowerInvariant().GetHashCode()); values.Put(MediaStore.Images.ImageColumns.BucketDisplayName, f.Name.ToLowerInvariant()); values.Put("_data", f.AbsolutePath); var cr = context.ContentResolver; cr.Insert(MediaStore.Images.Media.ExternalContentUri, values); } catch (Exception ex1) { Console.WriteLine("Unable to save to scan file: " + ex1); } var contentUri = Android.Net.Uri.FromFile(f); var mediaScanIntent = new Intent(Intent.ActionMediaScannerScanFile, contentUri); context.SendBroadcast(mediaScanIntent); } catch (Exception ex2) { Console.WriteLine("Unable to save to gallery: " + ex2); } } //check to see if we need to rotate if success try { var exif = new ExifInterface(media.Path); if (options.RotateImage) { await FixOrientationAndResizeAsync(media.Path, options, exif); } else { await ResizeAsync(media.Path, options, exif); } if (options.SaveMetaData && IsValidExif(exif)) { SetMissingMetadata(exif, options.Location); try { exif?.SaveAttributes(); } catch (Exception ex) { Console.WriteLine($"Unable to save exif {ex}"); } } exif?.Dispose(); } catch (Exception ex) { Console.WriteLine("Unable to check orientation: " + ex); } return(media); }
private void ProcessRequest(HttpListenerContext context) { HttpListenerRequest request = context.Request; // Are they trying to upload a file? if (request.HttpMethod == "PUT") { System.IO.Stream input = request.InputStream; string test = GolemBuildService.Instance.BuildPath; string test2 = Path.GetFileNameWithoutExtension(request.RawUrl) + ".zip"; string zipName = Path.Combine(test, test2); FileStream fileStream = File.Create(zipName); input.CopyTo(fileStream); fileStream.Close(); input.Close(); // Send back OK HttpListenerResponse response = context.Response; response.Headers.Clear(); response.SendChunked = false; response.StatusCode = 201; response.AddHeader("Content-Location", zipName); //response.AddHeader("Server", String.Empty); //response.AddHeader("Date", String.Empty); response.Close(); ZipFile.ExtractToDirectory(zipName, Path.GetDirectoryName(zipName)); } else // They are trying to download a file { // Obtain a response object. HttpListenerResponse response = context.Response; //let's check ranges long offset = 0; long size = -1; foreach (string header in request.Headers.AllKeys) { if (header == "Range") { string[] values = request.Headers.GetValues(header); string[] tokens = values[0].Split('=', '-'); offset = int.Parse(tokens[1]); size = (int)(int.Parse(tokens[2]) - offset + 1); } } try { // Are they requesting a CompilerPackage? if (request.RawUrl.StartsWith("/requestID/compiler/")) { string compilerHash = request.RawUrl.Replace("/requestID/compiler/", ""); byte[] data; if (GolemCache.GetCompilerPackageData(compilerHash, out data)) { response.AddHeader("ETag", "SHA1:" + compilerHash); if (size == -1) { size = data.Length; } response.ContentLength64 = size; Stream output = response.OutputStream; output.Write(data, (int)offset, (int)size); output.Close(); } } // Or are they requesting a tasks package? else if (request.RawUrl.StartsWith("/requestID/tasks/")) { string tasksPackageHash = request.RawUrl.Replace("/requestID/tasks/", ""); byte[] data; if (GolemCache.GetTasksPackage(tasksPackageHash, out data)) { response.AddHeader("ETag", "SHA1:" + tasksPackageHash); if (size == -1) { size = data.Length; } response.ContentLength64 = size; Stream output = response.OutputStream; output.Write(data, (int)offset, (int)size); output.Close(); } } } catch (HttpListenerException ex) { Logger.LogMessage(ex.Message); } } }
/// <summary> /// Adds the file. /// </summary> /// <param name="path">The path.</param> /// <param name="stream">The stream.</param> public void AddFile(string path, System.IO.Stream stream) { Contract.Requires(stream != null, "Stream could not be null"); this.AddFileCore(path, x => stream.CopyTo(x)); }
public FilterStatus Filter(System.IO.Stream dataIn, out long dataInRead, System.IO.Stream dataOut, out long dataOutWritten) { try { if (dataIn == null) { dataInRead = 0; dataOutWritten = 0; return(FilterStatus.Done); } dataInRead = dataIn.Length; dataOutWritten = Math.Min(dataInRead, dataOut.Length); dataIn.CopyTo(dataOut); dataIn.Seek(0, SeekOrigin.Begin); byte[] bs = new byte[dataIn.Length]; dataIn.Read(bs, 0, bs.Length); string str = System.Text.Encoding.Default.GetString(bs); NotifyData(str); //if (dataAll.Count == this.contentLength) //{ // // 通过这里进行通知 // NotifyData(dataAll.ToArray()); // return FilterStatus.Done; //} //else if (dataAll.Count < this.contentLength) //{ // dataInRead = dataIn.Length; // dataOutWritten = dataIn.Length; // return FilterStatus.NeedMoreData; //} //else //{ // return FilterStatus.Error; //} } catch (Exception ex) { LoggerFactory.GetLog().Error("CustomResponseFilter-Filter 出错!", ex); dataInRead = dataIn.Length; dataOutWritten = dataIn.Length; return(FilterStatus.Done); } //if (dataIn == null) //{ // dataInRead = 0; // dataOutWritten = 0; // return FilterStatus.Done; //} //dataInRead = dataIn.Length; //dataOutWritten = Math.Min(dataInRead, dataOut.Length); //dataIn.CopyTo(dataOut); return(FilterStatus.Done); }
/// <summary> /// Copies an stream to another stream using the buffer with specified size. /// </summary> /// <param name="source">source stream</param> /// <param name="destination">destination stream</param> /// <param name="bufferLen">length of buffer to create</param> /// <returns>number of bytes copied</returns> public static long CopyTo(this System.IO.Stream source, System.IO.Stream destination, int bufferLen) { return(source.CopyTo(destination, new byte[bufferLen])); }
public override void Serialization(Request request, object data, PipeStream stream) { if (data == null) { return; } if (data is IDictionary <string, object> dictionary) { foreach (var item in dictionary) { stream.Write("--"); stream.WriteLine(request.Boundary); if (item.Value is UploadFile uploadFile) { stream.WriteLine($"Content-Disposition: form-data; name=\"{item.Key}\"; filename=\"{uploadFile.Name}\""); stream.WriteLine($"Content-Type: binary"); stream.WriteLine(""); stream.Write(uploadFile.Data.Array, uploadFile.Data.Offset, uploadFile.Data.Count); stream.WriteLine(""); } else if (item.Value is FileInfo file) { stream.WriteLine($"Content-Disposition: form-data; name=\"{item.Key}\"; filename=\"{file.Name}\""); stream.WriteLine($"Content-Type: binary"); stream.WriteLine(""); using (System.IO.Stream open = file.OpenRead()) { open.CopyTo(stream); } stream.WriteLine(""); } else { stream.WriteLine($"Content-Disposition: form-data; name=\"{item.Key}\""); stream.WriteLine(""); if (item.Value is IEnumerable subitems) { List <string> values = new List <string>(); foreach (var v in subitems) { values.Add(v.ToString()); } stream.Write(string.Join(",", values)); } else { stream.Write(item.Value.ToString()); } stream.WriteLine(""); } } if (dictionary.Count > 0) { stream.Write("--"); stream.Write(request.Boundary); stream.WriteLine("--"); } } else { throw new HttpClientException($"post data must be IDictionary<string, object>!"); } }
private void DownloadFile() { if ( (CurrentPage != null) && (sharedFile != null) ) { string virtualPath = "~/Data/Sites/" + this.CurrentPage.SiteId.ToInvariantString() + "/SharedFiles/" + sharedFile.ServerFileName; if (fileSystem.FileExists(virtualPath)) { //FileInfo fileInfo = new System.IO.FileInfo(downloadPath); WebFile fileInfo = fileSystem.RetrieveFile(virtualPath); Page.Response.AppendHeader("Content-Length", fileInfo.Size.ToString(CultureInfo.InvariantCulture)); } else { log.Error("Shared File Not Found. User tried to download file " + virtualPath); return; } string fileType = Path.GetExtension(sharedFile.FriendlyName).Replace(".", string.Empty); string mimeType = SiteUtils.GetMimeType(fileType); //Page.Response.ContentType = mimeType; Page.Response.ContentType = "application/" + fileType; if ((!SharedFilesConfiguration.TreatPdfAsAttachment) && (SiteUtils.IsNonAttacmentFileType(fileType))) { //this will display the pdf right in the browser // and the file may be cached by the web browser Page.Response.AddHeader("Content-Disposition", "filename=\"" + HttpUtility.UrlEncode(sharedFile.FriendlyName, Encoding.UTF8) + "\""); if (SharedFilesConfiguration.NonAttachmentDownloadExpireDays != 0) { Page.Response.AddHeader("Expires", DateTime.Now.AddDays(SharedFilesConfiguration.NonAttachmentDownloadExpireDays).ToUniversalTime().ToString("R")); } } else { // other files just use file save dialog Page.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + HttpUtility.UrlEncode(sharedFile.FriendlyName, Encoding.UTF8) + "\""); // 0 is the default so we should not be settings a cache header here // attachments are not stored in the web browser cache if (SharedFilesConfiguration.AttachmentDownloadExpireDays != 0) { Page.Response.AddHeader("Expires", DateTime.Now.AddDays(SharedFilesConfiguration.AttachmentDownloadExpireDays).ToUniversalTime().ToString("R")); } } //Page.Response.AddHeader("Content-Length", documentFile.DocumentImage.LongLength.ToString()); try { Page.Response.Buffer = false; Page.Response.BufferOutput = false; if (Page.Response.IsClientConnected) { //Page.Response.TransmitFile(downloadPath); using (System.IO.Stream stream = fileSystem.GetAsStream(virtualPath)) { stream.CopyTo(Page.Response.OutputStream); SharedFile.IncrementDownloadCount(sharedFile.ItemId); } try { Page.Response.End(); } catch (System.Threading.ThreadAbortException) { } } } catch (HttpException) { } } }
public void readFromStream(System.IO.Stream stream) { stream.CopyTo(this.getRawStream()); }
private UpLoadFileResult UpLoadPicture(System.IO.Stream file, string dirPath, string fileName = "") { UpLoadFileResult upLoadFileResult = new UpLoadFileResult(); string encodingName = "utf-8"; string imgType = string.Empty; List <string> typeList = new List <string>() { "JPG", "BMP", "PNG", "JPEG" }; using (MemoryStream ms = new MemoryStream()) { file.CopyTo(ms); ms.Position = 0; var encoding = Encoding.GetEncoding(encodingName); var reader = new StreamReader(ms, encoding); var headerLength = 0L; //读取第一行 var firstLine = reader.ReadLine(); //计算偏移(字符串长度+回车换行2个字符) headerLength += encoding.GetBytes(firstLine).LongLength + 2; //读取第二行 var secondLine = reader.ReadLine(); //计算偏移(字符串长度+回车换行2个字符) headerLength += encoding.GetBytes(secondLine).LongLength + 2; //解析文件名 string orgFileName = new System.Text.RegularExpressions.Regex("filename=\"(?<fn>.*)\"").Match(secondLine).Groups["fn"].Value; if (string.IsNullOrEmpty(fileName)) { fileName = orgFileName; } else { fileName = orgFileName.Replace(orgFileName.Substring(0, orgFileName.LastIndexOf('.')), fileName); } //判断图片格式 imgType = fileName.Substring(fileName.LastIndexOf('.') + 1).ToUpper(); if (!typeList.Contains(imgType)) { upLoadFileResult.FileName = "errorType"; upLoadFileResult.success = false; return(upLoadFileResult); } //一直读到空行为止 while (true) { //读取一行 var line = reader.ReadLine(); //若到头,则直接返回 if (line == null) { break; } //若未到头,则计算偏移(字符串长度+回车换行2个字符) headerLength += encoding.GetBytes(line).LongLength + 2; if (line == "") { break; } } //设置偏移,以开始读取文件内容 ms.Position = headerLength; ////减去末尾的字符串:“/r/n--/r/n” ms.SetLength(ms.Length - encoding.GetBytes(firstLine).LongLength - 3 * 2); if (!Directory.Exists(dirPath)) { Directory.CreateDirectory(dirPath); } string path = Path.Combine(dirPath, fileName); using (FileStream fileToupload = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read)) { ms.CopyTo(fileToupload); fileToupload.Flush(); } upLoadFileResult.FileName = fileName; upLoadFileResult.success = true; } return(upLoadFileResult); }
bool Execute() { try { if (Direction == FtpDirection.ToFtpServer) ExpandDestination = false; else ExpandSource = false; List<string> sources = new List<string>(); if (ExpandSource) { sources = STEM.Sys.IO.Path.ExpandRangedPath(SourcePath); } else { sources.Add(SourcePath); } List<string> destinations = new List<string>(); if (ExpandDestination) { destinations = STEM.Sys.IO.Path.ExpandRangedPath(DestinationPath); } else { destinations.Add(DestinationPath); } List<string> sourceFiles = new List<string>(); int filesActioned = 0; FtpClient conn = Authentication.OpenClient(_Address, Int32.Parse(Port)); try { foreach (string src in sources) { List<FtpListItem> items = new List<FtpListItem>(); if (Direction == FtpDirection.ToFtpServer) { sourceFiles = STEM.Sys.IO.Directory.STEM_GetFiles(src, FileFilter, DirectoryFilter, (RecurseSource ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly), false); } else { items = Authentication.ListDirectory(_Address, Int32.Parse(Port), src, FTPListType.File, RecurseSource, DirectoryFilter, FileFilter); sourceFiles = items.Select(i => i.FullName).ToList(); } foreach (string s in sourceFiles) { try { bool success = false; Exception lastEX = null; foreach (string d in destinations) { try { string dFile = ""; try { if (PopulatePostMortemMeta) { if (Direction == FtpDirection.ToFtpServer) { PostMortemMetaData["SourceIP"] = STEM.Sys.IO.Path.IPFromPath(s); PostMortemMetaData["FileSize"] = new FileInfo(s).Length.ToString(); PostMortemMetaData["DestinationIP"] = _Address; } else { PostMortemMetaData["SourceIP"] = _Address; PostMortemMetaData["FileSize"] = conn.GetFileSize(s).ToString(); PostMortemMetaData["DestinationIP"] = STEM.Sys.IO.Path.IPFromPath(d); } } } catch { } string dPath = STEM.Sys.IO.Path.AdjustPath(d); if (RecurseSource && RecreateTree) { dPath = System.IO.Path.Combine(dPath, STEM.Sys.IO.Path.GetDirectoryName(s).Replace(STEM.Sys.IO.Path.AdjustPath(src), "").Trim(System.IO.Path.DirectorySeparatorChar)); } dPath = System.IO.Path.Combine(dPath, DestinationFilename); if (dPath.Contains("*.*")) dPath = dPath.Replace("*.*", STEM.Sys.IO.Path.GetFileName(s)); if (dPath.Contains("*")) dPath = dPath.Replace("*", STEM.Sys.IO.Path.GetFileNameWithoutExtension(s)); if (Direction == FtpDirection.ToFtpServer) { dPath = Authentication.AdjustPath(_Address, dPath); string directory = Authentication.AdjustPath(_Address, STEM.Sys.IO.Path.GetDirectoryName(dPath)); if (!conn.DirectoryExists(directory)) conn.CreateDirectory(directory); if (conn.FileExists(dPath)) { switch (ExistsAction) { case Sys.IO.FileExistsAction.Overwrite: conn.DeleteFile(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.OverwriteIfNewer: if (conn.GetModifiedTime(dPath, FtpDate.UTC) >= File.GetLastWriteTimeUtc(s)) continue; conn.DeleteFile(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.Skip: continue; case Sys.IO.FileExistsAction.Throw: throw new IOException("Destination file exists. (" + dPath + ")"); case Sys.IO.FileExistsAction.MakeUnique: dFile = Authentication.UniqueFilename(_Address, Int32.Parse(Port), dPath); break; } } else { dFile = dPath; } DateTime mt = File.GetLastWriteTimeUtc(s); using (System.IO.Stream sStream = System.IO.File.Open(STEM.Sys.IO.Path.AdjustPath(s), System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.None)) { using (System.IO.Stream dStream = conn.OpenWrite(dFile, FtpDataType.Binary)) { sStream.CopyTo(dStream); } FtpReply reply = conn.GetReply(); if (!reply.Success) throw new Exception("There was an error writing to the FTP server: " + reply.Message); } try { conn.SetModifiedTime(dFile, mt, FtpDate.UTC); } catch { } } else { if (File.Exists(dPath)) { switch (ExistsAction) { case Sys.IO.FileExistsAction.Overwrite: File.Delete(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.OverwriteIfNewer: if (File.GetLastWriteTimeUtc(dPath) >= conn.GetModifiedTime(s, FtpDate.UTC)) continue; File.Delete(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.Skip: continue; case Sys.IO.FileExistsAction.Throw: throw new IOException("Destination file exists. (" + dPath + ")"); case Sys.IO.FileExistsAction.MakeUnique: dFile = STEM.Sys.IO.File.UniqueFilename(dPath); break; } } else { dFile = dPath; } if (!Directory.Exists(STEM.Sys.IO.Path.GetDirectoryName(dFile))) Directory.CreateDirectory(STEM.Sys.IO.Path.GetDirectoryName(dFile)); string tmp = ""; try { tmp = Path.Combine(STEM.Sys.IO.Path.GetDirectoryName(dFile), "TEMP"); if (!Directory.Exists(tmp)) Directory.CreateDirectory(tmp); tmp = Path.Combine(tmp, STEM.Sys.IO.Path.GetFileName(dFile)); using (System.IO.Stream sStream = conn.OpenRead(s, FtpDataType.Binary)) { using (System.IO.Stream dStream = System.IO.File.Open(tmp, System.IO.FileMode.CreateNew, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None)) { sStream.CopyTo(dStream); } } try { File.SetLastWriteTimeUtc(tmp, conn.GetModifiedTime(s, FtpDate.UTC)); } catch { } File.Move(tmp, STEM.Sys.IO.Path.AdjustPath(dFile)); } finally { try { if (File.Exists(tmp)) File.Delete(tmp); } catch { } } } if (!String.IsNullOrEmpty(dFile)) { filesActioned++; _FilesActioned[s] = dFile; if (Action == ActionType.Move) AppendToMessage(s + " moved to " + dFile); else AppendToMessage(s + " copied to " + dFile); } success = true; if (DestinationActionRule == DestinationRule.FirstSuccess) break; } catch (Exception ex) { lastEX = ex; if (DestinationActionRule == DestinationRule.AllOrNone) throw ex; } } if (!success) throw new Exception("No successful actions taken for " + s, lastEX); // + "\r\n" + ((lastEX == null) ? "No additional information." : lastEX.ToString())); if (Action == ActionType.Move) { if (Direction == FtpDirection.ToFtpServer) { File.Delete(s); } else { conn.DeleteFile(s); } } } catch (Exception ex) { AppendToMessage(ex.Message); Exceptions.Add(ex); } } } } finally { Authentication.RecycleClient(conn); } if (PopulatePostMortemMeta) { PostMortemMetaData["FilesActioned"] = filesActioned.ToString(); } } catch (Exception ex) { AppendToMessage(ex.Message); Exceptions.Add(ex); } if (_FilesActioned.Count == 0) { switch (ZeroFilesAction) { case FailureAction.SkipRemaining: SkipRemaining(); return true; case FailureAction.SkipNext: SkipNext(); return true; case FailureAction.SkipToLabel: SkipForwardToFlowControlLabel(FailureActionLabel); return true; case FailureAction.Rollback: RollbackAllPreceedingAndSkipRemaining(); break; case FailureAction.Continue: return true; } Message = "0 Files Actioned\r\n" + Message; } return Exceptions.Count == 0; }
protected override void LoadInternal(OpenedFile file, System.IO.Stream stream) { wasChangedInDesigner = false; Debug.Assert(file == this.PrimaryFile); SD.AnalyticsMonitor.TrackFeature(typeof(WpfViewContent), "Load"); _stream = new MemoryStream(); stream.CopyTo(_stream); stream.Position = 0; if (designer == null) { // initialize designer on first load designer = new DesignSurface(); this.UserContent = designer; InitPropertyEditor(); InitWpfToolbox(); } this.UserContent = designer; if (outline != null) { outline.Root = null; } using (XmlTextReader r = new XmlTextReader(stream)) { XamlLoadSettings settings = new XamlLoadSettings(); settings.DesignerAssemblies.Add(typeof(WpfViewContent).Assembly); settings.CustomServiceRegisterFunctions.Add( delegate(XamlDesignContext context) { context.Services.AddService(typeof(IUriContext), new FileUriContext(this.PrimaryFile)); context.Services.AddService(typeof(IPropertyDescriptionService), new PropertyDescriptionService(this.PrimaryFile)); context.Services.AddService(typeof(IEventHandlerService), new SharpDevelopEventHandlerService(this)); context.Services.AddService(typeof(ITopLevelWindowService), new WpfAndWinFormsTopLevelWindowService()); context.Services.AddService(typeof(ChooseClassServiceBase), new IdeChooseClassService()); }); settings.TypeFinder = MyTypeFinder.Create(this.PrimaryFile); settings.CurrentProjectAssemblyName = SD.ProjectService.CurrentProject.AssemblyName; try { if (WpfEditorOptions.EnableAppXamlParsing) { var appXaml = SD.ProjectService.CurrentProject.Items.FirstOrDefault(x => x.FileName.GetFileName().ToLower() == ("app.xaml")); if (appXaml != null) { var f = appXaml as FileProjectItem; OpenedFile a = SD.FileService.GetOrCreateOpenedFile(f.FileName); var xml = XmlReader.Create(a.OpenRead()); var doc = new XmlDocument(); doc.Load(xml); var node = doc.FirstChild.ChildNodes.Cast <XmlNode>().FirstOrDefault(x => x.Name == "Application.Resources"); foreach (XmlAttribute att in doc.FirstChild.Attributes.Cast <XmlAttribute>().ToList()) { if (att.Name.StartsWith("xmlns")) { foreach (var childNode in node.ChildNodes.OfType <XmlNode>()) { childNode.Attributes.Append(att); } } } var appXamlXml = XmlReader.Create(new StringReader(node.InnerXml)); var appxamlContext = new XamlDesignContext(appXamlXml, settings); //var parsed = XamlParser.Parse(appXamlXml, appxamlContext.ParserSettings); var dict = (ResourceDictionary)appxamlContext.RootItem.Component; // parsed.RootInstance; designer.DesignPanel.Resources.MergedDictionaries.Add(dict); } } } catch (Exception ex) { LoggingService.Error("Error in loading app.xaml", ex); } try { settings.ReportErrors = UpdateTasks; designer.LoadDesigner(r, settings); designer.DesignPanel.ContextMenuHandler = (contextMenu) => { var newContextmenu = new ContextMenu(); var sdContextMenuItems = MenuService.CreateMenuItems(newContextmenu, designer, "/AddIns/WpfDesign/Designer/ContextMenu", "ContextMenu"); foreach (var entry in sdContextMenuItems) { newContextmenu.Items.Add(entry); } newContextmenu.Items.Add(new Separator()); var items = contextMenu.Items.Cast <Object>().ToList(); contextMenu.Items.Clear(); foreach (var entry in items) { newContextmenu.Items.Add(entry); } designer.DesignPanel.ContextMenu = newContextmenu; }; if (outline != null && designer.DesignContext != null && designer.DesignContext.RootItem != null) { outline.Root = OutlineNode.Create(designer.DesignContext.RootItem); } propertyGridView.PropertyGrid.SelectedItems = null; designer.DesignContext.Services.Selection.SelectionChanged += OnSelectionChanged; designer.DesignContext.Services.GetService <UndoService>().UndoStackChanged += OnUndoStackChanged; } catch (Exception e) { this.UserContent = new WpfDocumentError(e); } } }
/// <inheritdoc /> public override void ForwardProcessDataStream(System.IO.Stream inStream, System.IO.Stream outStream, Dictionary <string, string> options, out long writtenBytes) { if (options == null) { throw new ArgumentNullException("options"); } else if (!options.ContainsKey(PasswordOption)) { throw new ArgumentException("Options must contain encryption key", "options"); } if (outStream == null) { throw new ArgumentNullException("outStream"); } #if NETFX_CORE inStream.Seek(0, 0); outStream.Seek(0, 0); IBuffer pwBuffer = CryptographicBuffer.ConvertStringToBinary(options[PasswordOption], BinaryStringEncoding.Utf8); IBuffer saltBuffer = CryptographicBuffer.CreateFromByteArray(SALT); // Derive key material for password size 32 bytes for AES256 algorithm KeyDerivationAlgorithmProvider keyDerivationProvider = Windows.Security.Cryptography.Core.KeyDerivationAlgorithmProvider.OpenAlgorithm("PBKDF2_SHA1"); // using salt and 1000 iterations KeyDerivationParameters pbkdf2Parms = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, 1000); // create a key based on original key and derivation parmaters CryptographicKey keyOriginal = keyDerivationProvider.CreateKey(pwBuffer); IBuffer keyMaterial = CryptographicEngine.DeriveKeyMaterial(keyOriginal, pbkdf2Parms, 32); CryptographicKey derivedPwKey = keyDerivationProvider.CreateKey(pwBuffer); // derive buffer to be used for encryption salt from derived password key IBuffer saltMaterial = CryptographicEngine.DeriveKeyMaterial(derivedPwKey, pbkdf2Parms, 16); // display the buffers - because KeyDerivationProvider always gets cleared after each use, they are very similar unforunately string keyMaterialString = CryptographicBuffer.EncodeToBase64String(keyMaterial); string saltMaterialString = CryptographicBuffer.EncodeToBase64String(saltMaterial); SymmetricKeyAlgorithmProvider symProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7"); // create symmetric key from derived password key CryptographicKey symmKey = symProvider.CreateSymmetricKey(keyMaterial); using (MemoryStream ms = new MemoryStream()) { inStream.CopyTo(ms); // encrypt data buffer using symmetric key and derived salt material IBuffer resultBuffer = CryptographicEngine.Encrypt(symmKey, WindowsRuntimeBufferExtensions.GetWindowsRuntimeBuffer(ms), saltMaterial); resultBuffer.AsStream().CopyTo(outStream); writtenBytes = outStream.Position; } #else Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(options[PasswordOption], SALT); var key = pdb.GetBytes(32); pdb.Reset(); var iv = pdb.GetBytes(16); using (var transform = encrypter.CreateEncryptor(key, iv)) { using (MemoryStream internalStream = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(internalStream, transform, CryptoStreamMode.Write)) { StreamTools.Write(inStream, csEncrypt); inStream.Flush(); csEncrypt.FlushFinalBlock(); internalStream.Seek(0, 0); StreamTools.Write(internalStream, outStream); writtenBytes = outStream.Position; } } } #endif }
protected override void _Rollback() { if (ExecutionMode == ExecuteOn.ForwardExecution) { foreach (string d in _FilesActioned.Keys) { try { string s = _FilesActioned[d]; if (Action == ActionType.Move) { if (Direction == FtpDirection.ToFtpServer) { FtpClient conn = Authentication.OpenClient(_Address, Int32.Parse(Port)); string tmp = ""; try { tmp = Path.Combine(STEM.Sys.IO.Path.GetDirectoryName(d), "TEMP"); if (!Directory.Exists(tmp)) Directory.CreateDirectory(tmp); tmp = Path.Combine(tmp, STEM.Sys.IO.Path.GetFileName(d)); using (System.IO.Stream sStream = conn.OpenRead(s, FtpDataType.Binary)) { using (System.IO.Stream dStream = System.IO.File.Open(tmp, System.IO.FileMode.CreateNew, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None)) { sStream.CopyTo(dStream); } } FtpReply reply = conn.GetReply(); if (!reply.Success) throw new Exception("There was an error reading from the FTP server: " + reply.Message); try { File.SetLastWriteTimeUtc(tmp, conn.GetModifiedTime(s, FtpDate.UTC)); } catch { } File.Move(tmp, STEM.Sys.IO.Path.AdjustPath(d)); } finally { try { if (File.Exists(tmp)) File.Delete(tmp); } catch { } Authentication.RecycleClient(conn); } } else { FtpClient conn = Authentication.OpenClient(_Address, Int32.Parse(Port)); try { DateTime mt = File.GetLastWriteTimeUtc(STEM.Sys.IO.Path.AdjustPath(s)); using (System.IO.Stream sStream = System.IO.File.Open(STEM.Sys.IO.Path.AdjustPath(s), System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.None)) { using (System.IO.Stream dStream = conn.OpenWrite(d, FtpDataType.Binary)) { sStream.CopyTo(dStream); } FtpReply reply = conn.GetReply(); if (!reply.Success) throw new Exception("There was an error writing to the FTP server: " + reply.Message); } try { conn.SetModifiedTime(d, mt, FtpDate.UTC); FtpReply reply = conn.GetReply(); if (!reply.Success) throw new Exception("There was an error in SetModifiedTime on the FTP server: " + reply.Message); } catch { } } finally { Authentication.RecycleClient(conn); } } } if (Direction == FtpDirection.ToFtpServer) { FtpClient conn = Authentication.OpenClient(_Address, Int32.Parse(Port)); try { conn.DeleteFile(s); FtpReply reply = conn.GetReply(); if (!reply.Success) throw new Exception("There was an error deleting a file from the FTP server: " + reply.Message); } finally { Authentication.RecycleClient(conn); } } else { STEM.Sys.IO.File.STEM_Delete(s, false, Retry, RetryDelaySeconds); } } catch { } } } else { int r = Retry; while (r-- >= 0) { _Address = Authentication.NextAddress(ServerAddress); if (_Address == null) { Exception ex = new Exception("No valid address. (" + ServerAddress + ")"); Exceptions.Add(ex); AppendToMessage(ex.Message); return; } Exceptions.Clear(); Message = ""; bool success = Execute(); if (success) return; System.Threading.Thread.Sleep(RetryDelaySeconds * 1000); } } }
public static void CopyTo(this Stream me, Stream destination) { me.CopyTo(destination, 4096); }
public FakeStream(SIO.Stream stream) { stream.CopyTo(this); Stream = stream; Position = 0; }
public MACRSTable() { string tmp = @"SFACalcEngine.DeprMethods.macrpcts.tbl"; //string tmp = @"C:\GitSrc\sfa-daas\daas\CalcEngine\SFACalcEngine\DeprMethods\macrpcts.tbl"; //string tmp = @"..\SFACalcEngine\DeprMethods\macrpcts.tbl"; try { Assembly a = Assembly.GetEntryAssembly(); string[] resources = a.GetManifestResourceNames(); System.IO.Stream s = a.GetManifestResourceStream(tmp); var memoryStream = new MemoryStream(); s.CopyTo(memoryStream); m_macrsTable = memoryStream.ToArray(); } catch (Exception e) { string t = Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location); //string s = AppDomain.CurrentDomain.BaseDirectory; //s = e.Message; } m_macrsTableCount = m_macrsTable[0]; //tmp = @"C:\GitSrc\sfa-daas\daas\CalcEngine\SFACalcEngine\DeprMethods\macrs2.tbl"; tmp = @"SFACalcEngine.DeprMethods.macrs2.tbl"; try { Assembly a = Assembly.GetEntryAssembly(); string[] resources = a.GetManifestResourceNames(); System.IO.Stream s = a.GetManifestResourceStream(tmp); var memoryStream = new MemoryStream(); s.CopyTo(memoryStream); m_apolloMacrsTable = memoryStream.ToArray(); } catch (Exception e) { string t = Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location); //string s = AppDomain.CurrentDomain.BaseDirectory; //s = e.Message; } //m_apolloMacrsTable = File.ReadAllBytes(tmp); m_apolloMacrsTableCount = m_apolloMacrsTable[0]; m_dAdjustedCost = 0; m_dPostUsedDeduction = 0; m_dSalvageDeduction = 0; m_dPriorAccum = 0; m_dYearElapsed = 0; m_dLife = 0; m_dDBPercent = 0; m_dFiscalYearFraction = 0; m_dtDeemedStartDate = DateTime.MinValue; m_dtDeemedEndDate = DateTime.MinValue; m_iYearNum = 0; m_dAnuualRate = 0; m_iSwitchYearNum = 0; m_bSwitchRequired = true; m_bIsShortYear = false; m_pObjSwitchMethod = null; m_lPeriod = 0; m_parentFlags = ""; }
private async Task StartDownload(DownloadGroup group, DownloadItem item, AccountProfile profile) { Log("State Downloading - " + item.ID.ToString() + " - " + item.Name); item.State = DownloadItem.States.Downloading; queryUpdate.Add(item); Log("Start Download " + item.ID); _lastReadList = new List <double>(); _lastCurrent = 0; System.IO.Stream s = null; IDownloader downloader = DownloadHelper.GetDownloader(item); try { s = await downloader.GetDownloadStream(item, profile); } catch (Exception e) { Log("State Error - " + item.ID.ToString() + " - " + item.Name); item.State = DownloadItem.States.Error; queryUpdate.Add(item); queryAdd.Add(new DownloadError(3, item, e)); await SocketHandler.Instance.SendIDError(item); _isDownloading = false; Log("Stream Problem"); Log("DOWNLOAD FALSE"); return; } Log("Got Stream " + item.ID); string groupDir = System.IO.Path.Combine(_settings.DownloadFolder, group.Name); string filesDir = System.IO.Path.Combine(_settings.DownloadFolder, group.Name, "files"); string extractDir = System.IO.Path.Combine(_settings.DownloadFolder, group.Name, "extracted"); try { if (!System.IO.Directory.Exists(groupDir)) { System.IO.Directory.CreateDirectory(groupDir); } if (!System.IO.Directory.Exists(filesDir)) { System.IO.Directory.CreateDirectory(filesDir); } if (!System.IO.Directory.Exists(extractDir)) { System.IO.Directory.CreateDirectory(extractDir); } } catch (Exception e) { Log("State Error - " + item.ID.ToString() + " - " + item.Name); item.State = DownloadItem.States.Error; queryUpdate.Add(item); await SocketHandler.Instance.SendIDError(item); queryAdd.Add(new DownloadError(4, item, e)); Log("Error happened: " + e.Message); _isDownloading = false; return; } Log("Folders Checked " + item.ID + " - " + item.Name); string filePath = System.IO.Path.Combine(filesDir, item.Name); if (System.IO.File.Exists(filePath)) { System.IO.File.Delete(filePath); } System.IO.FileStream fs = new System.IO.FileStream(filePath, System.IO.FileMode.OpenOrCreate); _state = new Timer(CheckStatus, new GroupItemModel() { Group = group, Item = item }, 0, 1000); Log("Timer started " + item.ID); try { s.CopyTo(fs); } catch (Exception e) { await SocketHandler.Instance.SendIDError(item); item.State = DownloadItem.States.Error; Log("State Error - " + item.ID.ToString() + " - " + item.Name); queryUpdate.Add(item); queryAdd.Add(new DownloadError(5, item, e)); _isDownloading = false; return; } fs.Close(); fs.Dispose(); _state.Dispose(); _state = null; Log("fs + state disposed"); if (_stopRequested) { _stopRequested = false; Log("Cancel requested"); item.State = DownloadItem.States.Waiting; Log("State Waiting - " + item.ID.ToString() + " - " + item.Name); queryUpdate.Add(item); _isDownloading = false; return; } Log("Download finished " + item.ID); if (item.MD5 == null) { await SocketHandler.Instance.SendIDDownloaded(item); Log("State Downloaded - " + item.ID.ToString() + " - " + item.Name); item.State = DownloadItem.States.Downloaded; Log("Md5 not set " + item.ID); queryUpdate.Add(item); _isDownloading = false; return; } await SocketHandler.Instance.SendIDCheck(item); Log("Check MD5 " + item.ID); string hash = ""; using (var md5 = MD5.Create()) using (var stream = System.IO.File.OpenRead(filesDir + System.IO.Path.DirectorySeparatorChar + item.Name)) hash = BitConverter.ToString(md5.ComputeHash(stream)).Replace("-", string.Empty).ToLowerInvariant(); if (item.MD5 == hash) { await SocketHandler.Instance.SendIDDownloaded(item); item.State = DownloadItem.States.Downloaded; } else { await SocketHandler.Instance.SendIDError(item); item.State = DownloadItem.States.Error; Log("MD5 Error - " + item.ID.ToString() + " - " + item.Name); queryAdd.Add(new DownloadError(6, item, new Exception("MD5 Check failed"))); } Log("Md5 checked " + item.ID); try { queryUpdate.Add(item); } catch (Exception e) { Log("Update Error - " + e.Message + " - " + item.Name); } _isDownloading = false; Log("Added to query download completed " + item.ID); }
private void Download(HttpContext context) { try { if (OnFileDownloading(virtualPath)) { WebFile file = fileSystem.RetrieveFile(virtualPath); if (file != null) { if (!fileSystem.Permission.IsExtAllowed(VirtualPathUtility.GetExtension(file.Name))) { RenderJsonResult(context, OpResult.FileTypeNotAllowed); //context.Response.StatusCode = 500; return; } if (file.Path != null) { context.Response.AppendHeader("Content-Length", file.Size.ToString(CultureInfo.InvariantCulture)); context.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + file.Name.Trim() + "\""); try { if (WebConfigSettings.DownloadScriptTimeout > -1) { context.Server.ScriptTimeout = WebConfigSettings.DownloadScriptTimeout; } context.Response.Buffer = false; context.Response.BufferOutput = false; // this won't work for Azure storage //context.Response.TransmitFile(file.Path); // so we use this approach using (System.IO.Stream stream = fileSystem.GetAsStream(virtualPath)) { stream.CopyTo(context.Response.OutputStream); } context.Response.End(); } catch (System.Threading.ThreadAbortException) { } // can happen with Response.End catch (HttpException ex) { log.Error(ex); context.Response.StatusCode = 500; } return; } } } } catch (Exception ex) { log.Error(ex); //context.Response.StatusCode = 500; } // Requested file not found context.Response.StatusCode = 404; }
private void DownloadFile() { ProductFile productFile = null; if (downloadTicket != null) { productFile = new ProductFile(downloadTicket.ProductGuid); } else if (userCanEdit && (productGuid != Guid.Empty)) { productFile = new ProductFile(productGuid); } if (productFile == null) { return; } string fileType = Path.GetExtension(productFile.FileName).Replace(".", string.Empty).ToLowerInvariant(); string mimeType = SiteUtils.GetMimeType(fileType); Page.Response.ContentType = mimeType; if (WebConfigSettings.DownloadScriptTimeout > -1) { Server.ScriptTimeout = WebConfigSettings.DownloadScriptTimeout; } if (SiteUtils.IsNonAttacmentFileType(fileType)) { Page.Response.AddHeader("Content-Disposition", "filename=" + productFile.FileName); } else { Page.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + HttpUtility.UrlEncode(productFile.FileName, Encoding.UTF8) + "\""); } //Page.Response.AddHeader("Content-Length", documentFile.DocumentImage.LongLength.ToString()); Page.Response.ContentType = "application/" + fileType; Page.Response.Buffer = false; Page.Response.BufferOutput = false; //Page.Response.TransmitFile(upLoadPath + productFile.ServerFileName); if (Page.Response.IsClientConnected) { using (System.IO.Stream stream = fileSystem.GetAsStream(upLoadPath + productFile.ServerFileName)) { stream.CopyTo(Page.Response.OutputStream); } if (downloadTicket != null) { downloadTicket.RecordDownloadHistory(SiteUtils.GetIP4Address()); } } try { Page.Response.End(); } catch (System.Threading.ThreadAbortException) { } }
public string UploadSPFile(SharePointContext spContext, HttpPostedFileBase tempFile, string documentFolder, string siteUrl, string prefix) { log.Info("- OutboxDocs - UploadSPFile"); var result = string.Empty; using (var clientContext = spContext.CreateAppOnlyClientContextForSPHost()) { if (clientContext != null) { try { var relativeSite = clientContext.Url.Substring(clientContext.Url.IndexOf('/', 10)); var folder = clientContext.Web.GetFolderByServerRelativeUrl(documentFolder); clientContext.Load(folder); clientContext.ExecuteQuery(); FileCreationInformation fci = new FileCreationInformation(); if (tempFile.ContentLength < 1000000) // ~1MB { using (System.IO.Stream inputStream = tempFile.InputStream) { var memoryStream = inputStream as System.IO.MemoryStream; if (memoryStream == null) { memoryStream = new System.IO.MemoryStream(); inputStream.CopyTo(memoryStream); } fci.Content = memoryStream.ToArray(); } fci.Url = documentFolder + "/" + prefix + tempFile.FileName; fci.Overwrite = true; Microsoft.SharePoint.Client.File fileToUpload = folder.Files.Add(fci); clientContext.Load(fileToUpload); clientContext.ExecuteQuery(); Uri hostUrl = new Uri(siteUrl); result = "https://" + hostUrl.Host + fileToUpload.ServerRelativeUrl; } else if (tempFile.ContentLength < 5000000) // ~5MB { fci.ContentStream = tempFile.InputStream; fci.Url = documentFolder + "/" + prefix + tempFile.FileName; fci.Overwrite = true; Microsoft.SharePoint.Client.File fileToUpload = folder.Files.Add(fci); clientContext.Load(fileToUpload); clientContext.ExecuteQuery(); Uri hostUrl = new Uri(siteUrl); result = "https://" + hostUrl.Host + fileToUpload.ServerRelativeUrl; } if (tempFile.ContentLength >= 5000000) // > ~5MB { Guid uploadId = Guid.NewGuid(); Microsoft.SharePoint.Client.File uploadFile; int blockSize = 4 * 1024 * 1024; // 5MB blocks ClientResult <long> bytesUploaded = null; byte[] buffer = new byte[blockSize]; Byte[] lastBuffer = null; long fileoffset = 0; long totalBytesRead = 0; int bytesRead; bool first = true; bool last = false; using (BinaryReader br = new BinaryReader(tempFile.InputStream)) { while ((bytesRead = br.Read(buffer, 0, buffer.Length)) > 0) { totalBytesRead = totalBytesRead + bytesRead; // You've reached the end of the file. if (totalBytesRead == tempFile.ContentLength) { last = true; // Copy to a new buffer that has the correct size. lastBuffer = new byte[bytesRead]; Array.Copy(buffer, 0, lastBuffer, 0, bytesRead); } if (first) { using (MemoryStream contentStream = new MemoryStream()) { // Add an empty file. FileCreationInformation fileInfo = new FileCreationInformation(); fileInfo.ContentStream = contentStream; fileInfo.Url = prefix + tempFile.FileName; fileInfo.Overwrite = true; uploadFile = folder.Files.Add(fileInfo); // Start upload by uploading the first slice. using (MemoryStream s = new MemoryStream(buffer)) { // Call the start upload method on the first slice. bytesUploaded = uploadFile.StartUpload(uploadId, s); clientContext.ExecuteQuery(); // fileoffset is the pointer where the next slice will be added. fileoffset = bytesUploaded.Value; } // You can only start the upload once. first = false; } } else { // Get a reference to your file. uploadFile = clientContext.Web.GetFileByServerRelativeUrl(folder.ServerRelativeUrl + System.IO.Path.AltDirectorySeparatorChar + prefix + tempFile.FileName); if (last) { // Is this the last slice of data? using (MemoryStream s = new MemoryStream(lastBuffer)) { // End sliced upload by calling FinishUpload. uploadFile = uploadFile.FinishUpload(uploadId, fileoffset, s); clientContext.Load(uploadFile); clientContext.ExecuteQuery(); // Return the file object for the uploaded file. Uri hostUrl = new Uri(siteUrl); result = "https://" + hostUrl.Host + uploadFile.ServerRelativeUrl; } } else { using (MemoryStream s = new MemoryStream(buffer)) { // Continue sliced upload. bytesUploaded = uploadFile.ContinueUpload(uploadId, fileoffset, s); clientContext.ExecuteQuery(); // Update fileoffset for the next slice. fileoffset = bytesUploaded.Value; } } } } // while ((bytesRead = br.Read(buffer, 0, buffer.Length)) > 0) } } } catch (Exception ex) { log.Error(ex.ToString()); } } } return(result); }
public ActionResult Editar(AtividadeLink item) { //if(item.atividadeArq.MudançaArq == 1 && item.atividadeArq.caminhoArquivo != null) //{ // return BadRequest("Impossivel enviar duas escolhas ao mesmo tempo"); //} string arquivoAntigo = item.atividade.caminhoArquivo; if (ModelState.IsValid) { if (item == null) { return(new BadRequestResult()); } string nomedoArquivo = null; if (item.atividade.Arquivo != null) { string arquivosPasta = Path.Combine(hostingEnvironment.ContentRootPath, "arquivos"); if (item.atividade.caminhoArquivo != null) { List <string> tiposArquivos = new List <string>(); tiposArquivos.Add(MediaTypeNames.Application.Pdf); tiposArquivos.Add(MediaTypeNames.Application.Rtf); tiposArquivos.Add(MediaTypeNames.Image.Jpeg); tiposArquivos.Add(MediaTypeNames.Image.Tiff); tiposArquivos.Add("image/png"); tiposArquivos.Add("image/jpg"); tiposArquivos.Add("image/bmp"); /*Os tipos de formatos de arquivo de certificado usados podem basear-se em uma combinação de questões de segurança e de compatibilidade. Nesta versão do Windows, você pode importar e exportar certificados nestes formatos: * Troca de Informações Pessoais (PKCS #12) * Padrão de Sintaxe de Mensagens Criptografadas (PKCS #7) * X.509 binário codificado por DER * X.509 codificado na Base64 * * Trata-se de um método de codificação desenvolvido para uso com extensões multipropósito do Internet Mail protegidas (S/MIME), que é um método padrão popular para transferência de anexos binários pela Internet. * Como todos os clientes compatíveis com MIME podem decodificar arquivos Base64, esse formato pode ser usado por autoridades de certificação que não estão em computadores com o Windows Server 2003, para que seja permitida a interoperabilidade. Os arquivos de certificado na Base64 usam a extensão .cer.*/ int tipos = 0; while (tipos <= tiposArquivos.Count) { if (tipos == tiposArquivos.Count) { TempData["erroTiposArquivo"] = true; return(RedirectToAction("Index")); } else if (tiposArquivos[tipos] == item.atividade.Arquivo.ContentType) { break; } tipos++; } if (item.atividade.Arquivo.Length > 2000000) { TempData["erroTamanhoArquivo"] = true; return(RedirectToAction("Index")); } //ESSE TAMANHO FOI ESCOLHIDO, POIS UM ARQUIVO PDF DE 2MBS, TEM CERCA DE 30 PÁGINAS. Logo, um "simples" arquivo de atividade, não é necessário passar disso. nomedoArquivo = Guid.NewGuid().ToString() + "_" + item.atividade.Arquivo.FileName; string caminhoArquivo = Path.Combine(arquivosPasta, nomedoArquivo); using (System.IO.Stream a = item.atividade.Arquivo.OpenReadStream()) { a.CopyTo(new FileStream(caminhoArquivo, FileMode.CreateNew)); a.Close(); } item.atividade.caminhoArquivo = nomedoArquivo; } else { nomedoArquivo = Guid.NewGuid().ToString() + "_" + item.atividade.Arquivo.FileName; string caminhoArquivo = Path.Combine(arquivosPasta, nomedoArquivo); using (System.IO.Stream a = item.atividade.Arquivo.OpenReadStream()) { a.CopyTo(new FileStream(caminhoArquivo, FileMode.CreateNew)); a.Close(); } item.atividade.caminhoArquivo = nomedoArquivo; } } try { context.TBAtividades.Update(item.atividade); context.SaveChanges(); if (System.IO.File.Exists(arquivoAntigo)) { System.IO.File.Delete(arquivoAntigo); } } catch (Exception e) { //erro na hora de salvar return(BadRequest("É impossível enviar o arquivo:" + e)); } TempData["EditarAtividade"] = true; return(RedirectToAction("Index")); } else { TempData["EditarAtividade"] = false; return(RedirectToAction("Index")); } }