public async Task <IActionResult> UploadEquipmentMediaAsync(DetailsViewModel model) { foreach (IFormFile file in model.UploadMedia.MediaFiles) { string blobName = $"{Guid.NewGuid()}_{file.FileName}"; string uri = await __BlobService.UploadFormFile(file, blobName); if (!string.IsNullOrWhiteSpace(uri)) { BlobResponse _BlobResponse = await __BlobManager.CreateAsync(new CreateBlobRequest { Name = blobName, Path = uri }); await __EquipmentBlobManager.CreateAsync(new CreateEquipmentBlobRequest { EquipmentUID = model.UploadMedia.EquipmentUID, BlobUID = _BlobResponse.UID }); } } return(Redirect(Request.Headers["Referer"].ToString())); }
/// <summary> /// Gets the page ranges impl. /// </summary> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="setResult">The set result.</param> /// <returns>A <see cref="TaskSequence"/> for getting the page ranges.</returns> private TaskSequence GetPageRangesImpl(BlobRequestOptions options, Action <IEnumerable <PageRange> > setResult) { CommonUtils.AssertNotNull("options", options); var webRequest = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.GetPageRanges(this.TransformedAddress, timeout, this.SnapshotTime, null)); BlobRequest.AddMetadata(webRequest, this.Metadata); this.ServiceClient.Credentials.SignRequest(webRequest); var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout); yield return(task); using (var webResponse = task.Result as HttpWebResponse) { var getPageRangesResponse = BlobResponse.GetPageRanges(webResponse); List <PageRange> pageRanges = new List <PageRange>(); // materialize response as we need to close the webResponse pageRanges.AddRange(getPageRangesResponse.PageRanges.ToList()); setResult(pageRanges); this.ParseSizeAndLastModified(webResponse); } }
/// <summary> /// Sets the content stream of the given Document instance ID /// </summary> /// <param name="blob">Information about the given blob</param> /// <returns>the newly created Blob instance</returns> public BlobResponse SetBlobStream(BlobMessage blob) { using (Logging.Facade.DebugTraceMethodCall("SetBlobStream")) { if (blob == null) { throw new ArgumentNullException("blob"); } try { DebugLogIdentity(); using (IZetboxContext ctx = _ctxFactory()) { var result = _sohFactory .GetServerDocumentHandler() .SetBlobStream(blob.Version, ctx, blob.Stream, blob.FileName, blob.MimeType); BlobResponse resp = new BlobResponse(); resp.ID = result.ID; resp.BlobInstance = SendObjects(new IDataObject[] { result }, true); return(resp); } } catch (Exception ex) { Helper.ThrowFaultException(ex); // Never called, Handle errors throws an Exception return(null); } } }
public Zetbox.App.Base.Blob SetBlobStream(IZetboxContext ctx, Stream stream, string filename, string mimetype) { Zetbox.App.Base.Blob result = null; BlobResponse response = null; BlobMessage msg = new BlobMessage() { Version = ZetboxGeneratedVersionAttribute.Current, FileName = filename, MimeType = mimetype, Stream = stream }; MakeRequest(() => { // Rewind stream to ensure complete files, e.g. after a fault if (msg.Stream.Position != 0) { msg.Stream.Seek(0, SeekOrigin.Begin); } response = _service.SetBlobStream(msg); }); using (var sr = _readerFactory(new BinaryReader(response.BlobInstance))) { // ignore auxObjects for blobs, which should not have them result = ReceiveObjectList(ctx, sr).Cast <Zetbox.App.Base.Blob>().Single(); } return(result); }
/// <summary> /// Set the event handler. /// </summary> /// <param name="req">The request.</param> /// <param name="webResponse">The web response.</param> /// <param name="eventHandler">The event handler.</param> /// <param name="sender">The sender.</param> /// <param name="e">The exception.</param> private static void OnResponseReceived( WebRequest req, WebResponse webResponse, EventHandler <ResponseReceivedEventArgs> eventHandler, object sender, Exception e) { // Get a Thread safe refence. May be not necessary given that its a function argument. EventHandler <ResponseReceivedEventArgs> temp = eventHandler; if (temp != null) { if (webResponse != null) { HttpWebResponse response = webResponse as HttpWebResponse; if (response != null) { string requestId = BlobResponse.GetRequestId(response); var eventArgs = new ResponseReceivedEventArgs() { RequestId = requestId, RequestHeaders = req.Headers, RequestUri = req.RequestUri, ResponseHeaders = response.Headers, StatusCode = response.StatusCode, StatusDescription = response.StatusDescription, Exception = e }; temp(sender, eventArgs); } } } }
public Zetbox.App.Base.Blob SetBlobStream(IZetboxContext ctx, Stream stream, string filename, string mimetype) { Zetbox.App.Base.Blob result = null; var handler = _memoryFactory.GetServerDocumentHandler(); var serverBlob = handler.SetBlobStream(ZetboxGeneratedVersionAttribute.Current, _backingStore, stream, filename, mimetype); BlobResponse resp = new BlobResponse(); resp.ID = serverBlob.ID; resp.BlobInstance = SendObjects(new IDataObject[] { serverBlob }, true); using (var sr = new ZetboxStreamReader(_map, new BinaryReader(resp.BlobInstance))) { result = ReceiveObjectList(ctx, sr).Cast <Zetbox.App.Base.Blob>().Single(); } return(result); }
private async Task UploadEquipmentMediaAsync(IFormFile file, Guid equipmentUID) { string blobName = $"{Guid.NewGuid()}_{file.FileName}"; string uri = await __BlobService.UploadFormFile(file, blobName); if (!string.IsNullOrWhiteSpace(uri)) { BlobResponse _BlobResponse = await __BlobManager.CreateAsync(new CreateBlobRequest { Name = blobName, Path = uri }); await __EquipmentBlobManager.CreateAsync(new CreateEquipmentBlobRequest { EquipmentUID = equipmentUID, BlobUID = _BlobResponse.UID }); } }