static async void RunClient()
{
// Create an HttpClient instance
HttpClient client = new HttpClient();
// Create a push content so that we can use XDocument.Save to a stream
XDocument xDoc = XDocument.Load("Sample.xml", LoadOptions.None);
PushStreamContent xDocContent = new PushStreamContent(
(stream, content, context) =>
{
// After save we close the stream to signal that we are done writing.
xDoc.Save(stream);
stream.Close();
},
"application/xml");
// Send POST request to server and wait asynchronously for the response
Uri address = new Uri(_baseAddress, "/api/book");
HttpResponseMessage response = await client.PostAsync(address, xDocContent);
// Ensure we get a successful response.
response.EnsureSuccessStatusCode();
// Read the response using XDocument as well
Stream responseStream = await response.Content.ReadAsStreamAsync();
XDocument xResponseDoc = XDocument.Load(responseStream);
Console.WriteLine("Received response: {0}", xResponseDoc.ToString());
}
public HttpResponseMessage Get(HttpRequestMessage request, string id)
{
if (string.IsNullOrWhiteSpace(id))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
var parsedID = Guid.Parse(id);
var response = request.CreateResponse();
response.Headers.Add("Access-Control-Allow-Origin", "*");
response.Headers.Add("Cache-Control", "no-cache, must-revalidate");
var pushContent = new PushStreamContent((stream, content, context) =>
{
var streamwriter = new StreamWriter(stream);
var client = new Client(streamwriter, id);
lock (_clients)
{
if (_clients.ContainsKey(client.id))
{
_RemoveClient(client.id);
}
var isAdded = _clients.TryAdd(client.id, client);
if (isAdded)
{
++_clientCount;
}
}
_CheckCleanUpTimer();
}, "text/event-stream");
response.Content = pushContent;
return(response);
}
private PushStreamContent GetResponseContent(RecordQueryInputModel input, string delimiter)
{
RemovePagingParametersFromRecordQuery(input);
var responseContent = new PushStreamContent(
async(Stream stream, HttpContent content, TransportContext context) =>
{
using (stream)
{
var records = recordQueryer.Query(input).ToList();
var writeHeaders = true;
foreach (var record in records)
{
var writer = new StringWriter();
var exporter = new Exporter();
if (writeHeaders)
{
exporter.ExportHeader(writer, delimiter);
writeHeaders = false;
}
exporter.ExportRecord(Helpers.RemoveCollectionFromId(record), writer, delimiter);
var data = Encoding.UTF8.GetBytes(writer.ToString());
await stream.WriteAsync(data, 0, data.Length);
}
}
});
return(responseContent);
}
public async Task <HttpResponseMessage> Get(string taskId)
{
var msg = Request.CreateResponse(HttpStatusCode.OK);
var task = await _taskService.GetTaskAsync(taskId);
if (null == task || task.Status != TaskStatus.Success ||
task.DestinationFile == null || string.IsNullOrWhiteSpace(task.DestinationFile.BlobFileName))
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
var fileStream = await _fileStorageService.GetDestinationFileStreamAsync(task.DestinationFile.BlobFileName);
if (null == fileStream)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
var pushStream = new PushStreamContent((stream, content, context) =>
{
using (fileStream)
using (stream)
{
fileStream.CopyTo(stream);
}
});
msg.Content = pushStream;
return(msg);
}
private HttpRequestMessage UploadClientRequest(PushStreamContent content, File file)
{
//var urldata =
// new YadGetResourceUploadUrlRequest(HttpSettings, (YadWebAuth)Authent, file.FullPath, file.OriginalSize)
// .MakeRequestAsync()
// .Result;
//var url = urldata.Models[0].Data.UploadUrl;
var _ = new YaDCommonRequest(HttpSettings, (YadWebAuth)Authent)
.With(new YadGetResourceUploadUrlPostModel(file.FullPath, file.OriginalSize),
out YadResponceModel <ResourceUploadUrlData, ResourceUploadUrlParams> itemInfo)
.MakeRequestAsync().Result;
var url = itemInfo.Data.UploadUrl;
var request = new HttpRequestMessage
{
RequestUri = new Uri(url),
Method = HttpMethod.Put
};
request.Headers.Add("Accept", "*/*");
request.Headers.TryAddWithoutValidation("User-Agent", HttpSettings.UserAgent);
request.Content = content;
request.Content.Headers.ContentLength = file.OriginalSize;
return(request);
}
public HttpResponseMessage Fickle()
{
var options = new ServiceModelReflectionOptions
{
ControllersTypesToIgnore = controllersToIgnore
};
var reflector = new WebApiRuntimeServiceModelReflector(options, this.Configuration, this.GetType().Assembly, Request.RequestUri.Host);
var serviceModel = reflector.Reflect();
var content = new PushStreamContent(
(stream, httpContent, transportContext) =>
{
using (var streamWriter = new StreamWriter(stream))
{
var writer = new FicklefileWriter(streamWriter);
writer.Write(serviceModel);
}
},
new MediaTypeHeaderValue("text/fickle"));
var response = new HttpResponseMessage
{
Content = content
};
return(response);
}
protected HttpResponseMessage ZipContentResult(ZipFile zipFile)
{
Boolean bCorretto = true;
var pushStreamContent = new PushStreamContent((stream, content, context) =>
{
try {
zipFile.Save(stream);
stream.Close();
}
catch (Exception e)
{
bCorretto = false;
}
}, "application/zip");
if (bCorretto == false)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
var esito = new HttpResponseMessage(HttpStatusCode.OK);
esito.Content = pushStreamContent;
// esito.Headers.Add("Content-Disposition", "attachment; filename=" + zipFile.Name);
esito.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = "DO_Files_" + DateTime.Now.ToShortDateString()
};
return(esito);
}
/// <summary>
/// Initializes a new instance of the System.IO.StreamWriter class for the specified stream by using UTF-8 encoding and the default buffer size.
/// </summary>
/// <returns></returns>
public HttpContent GetContent()
{
var content = new PushStreamContent((stream, httpContent, transportContext) =>
{
using (var tw = new StreamWriter(stream))
{
var ser = new JsonSerializer()
{
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore,
Formatting = Newtonsoft.Json.Formatting.None,
FloatFormatHandling = Newtonsoft.Json.FloatFormatHandling.DefaultValue,
FloatParseHandling = Newtonsoft.Json.FloatParseHandling.Double,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore,
DateFormatString = "yyyy-MM-ddTHH:mm:ss",
ContractResolver = new ProxyContractResolver(),
PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None,
};
ser.Converters.Add(new StringEnumConverter());
ser.Serialize(tw, this);
}
});
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(content);
}
public HttpResponseMessage Pull(long id, string connection)
{
Database.Subscriptions.AssertOpenSubscriptionConnection(id, connection);
OneTimeAcknowledgement anotherProcessingInfo;
if (Database.Subscriptions.allowedOneTimeAcknowledgements.TryGetValue(id, out anotherProcessingInfo))
{
var timeToTimeout = anotherProcessingInfo.ValidUntil - SystemTime.UtcNow;
if (timeToTimeout > TimeSpan.Zero)
{
anotherProcessingInfo.AckDelivered.Wait(timeToTimeout);
// assert open subscription one more time, as it might changed during wait
Database.Subscriptions.AssertOpenSubscriptionConnection(id, connection);
}
Database.Subscriptions.allowedOneTimeAcknowledgements.TryRemove(id, out anotherProcessingInfo);
}
var pushStreamContent = new PushStreamContent((stream, content, transportContext) => StreamToClient(id, Database.Subscriptions, stream))
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
{
CharSet = "utf-8"
}
}
};
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = pushStreamContent
});
}
public static PushStreamContent Create(string fileName, ITracer tracer, Action <ZipArchive> onZip)
{
var content = new PushStreamContent((outputStream, httpContent, transportContext) =>
{
using (tracer.Step("ZipStreamContent.OnZip"))
{
try
{
using (var zip = new ZipArchive(new StreamWrapper(outputStream), ZipArchiveMode.Create, leaveOpen: false))
{
onZip(zip);
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
throw;
}
}
});
content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
content.Headers.ContentDisposition.FileName = fileName;
return(content);
}
private PushStreamContent GetResponseContent(RecordQueryInputModel input, string delimiter)
{
RemovePagingParametersFromRecordQuery(input);
using (var adb = db.Advanced.DocumentStore.OpenAsyncSession())
{
var responseContent = new PushStreamContent(
async(stream, content, context) =>
{
using (stream)
using (var enumerator =
await adb.Advanced.StreamAsync(recordQueryer.AsyncQuery(adb, input)))
{
var writeHeaders = true;
while (await enumerator.MoveNextAsync())
{
var writer = new StringWriter();
var exporter = new Exporter();
if (writeHeaders)
{
exporter.ExportHeader(writer, delimiter);
writeHeaders = false;
}
exporter.ExportRecord(enumerator.Current.Document, writer, delimiter);
var data = UTF8Encoding.UTF8.GetBytes(writer.ToString());
await stream.WriteAsync(data, 0, data.Length);
}
}
});
return(responseContent);
}
}
public async Task <HttpResponseMessage> Export()
{
var filesJson = await ReadJsonAsync().ConfigureAwait(false);
var fileNames = filesJson.Value <RavenJArray>("FileNames").Values <string>().ToArray();
var pushStreamContent = new PushStreamContent((stream, content, transportContext) => StreamExportToClient(stream, fileNames))
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
{
CharSet = "utf-8",
},
ContentEncoding = { "gzip" }
}
};
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = pushStreamContent
});
}
public static HttpContent AsHttpContent(this IWritable w, string mediaType)
{
var content = new PushStreamContent((s, c, tc) => Push(w, s));
content.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
return(content);
}
public void AsyncClientStreamingCall_DeadlineDuringSend_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
PushStreamContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline: DateTime.UtcNow.AddSeconds(0.5)));
// Assert
var responseTask = call.ResponseAsync;
Assert.IsFalse(responseTask.IsCompleted, "Response not returned until client stream is complete.");
var ex = Assert.ThrowsAsync <RpcException>(async() => await responseTask.DefaultTimeout());
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.Status.StatusCode);
}
private HttpRequestMessage CreateUploadClientRequest(PushStreamContent content, File file)
{
var hash = (FileHashYad?)file.Hash;
var _ = new YaDCommonRequest(HttpSettings, (YadWebAuth)Authent)
.With(new YadGetResourceUploadUrlPostModel(file.FullPath, file.OriginalSize,
hash?.HashSha256.Value ?? string.Empty,
hash?.HashMd5.Value ?? string.Empty),
out YadResponseModel <ResourceUploadUrlData, ResourceUploadUrlParams> itemInfo)
.MakeRequestAsync().Result;
var url = itemInfo.Data.UploadUrl;
var request = new HttpRequestMessage
{
RequestUri = new Uri(url),
Method = HttpMethod.Put
};
request.Headers.Add("Accept", "*/*");
request.Headers.TryAddWithoutValidation("User-Agent", HttpSettings.UserAgent);
request.Content = content;
request.Content.Headers.ContentLength = file.OriginalSize;
return(request);
}
public Task <HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
{
var content = new PushStreamContent(async(strm, _, __) =>
{
using (strm)
{
await _blob.DownloadToStreamAsync(strm);
}
});
content.Headers.ContentType = MediaTypeHeaderValue.Parse(_blob.Properties.ContentType);
if (!String.IsNullOrEmpty(_blob.Properties.ContentEncoding))
{
content.Headers.ContentEncoding.Add(_blob.Properties.ContentEncoding);
}
if (!String.IsNullOrEmpty(_blob.Properties.ContentLanguage))
{
content.Headers.ContentLanguage.Add(_blob.Properties.ContentLanguage);
}
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = content
};
if (!String.IsNullOrEmpty(_blob.Properties.ETag))
{
response.Headers.ETag = EntityTagHeaderValue.Parse(_blob.Properties.ETag);
}
return(Task.FromResult(response));
}
public Task Get2()
{
Response.ContentType = "video/mp4";
Response.Headers["Content-Accept"] = Response.ContentType;
var sourceStream = new PushStreamContent((Action <Stream, HttpContent, TransportContext>)WriteContentToStream);// get the source stream
return(sourceStream.CopyToAsync(HttpContext.Response.Body));
}
private PushStreamContent ToGeoJsonStream(List <Permit> permits, FieldChoices choice)
{
PushStreamContent geoJsonContent = new PushStreamContent(
(stream, content, context) =>
{
TextWriter writer = new StreamWriter(stream);
JsonWriter jsonWriter = new JsonTextWriter(writer);
jsonWriter.Formatting = Formatting.None;
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("type");
jsonWriter.WriteValue("FeatureCollection");
jsonWriter.WritePropertyName("features");
jsonWriter.WriteStartArray();
foreach (var permit in permits)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("type");
jsonWriter.WriteValue("Feature");
jsonWriter.WritePropertyName("id");
jsonWriter.WriteValue(permit.PermitNum);
jsonWriter.WritePropertyName("geometry");
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("type");
jsonWriter.WriteValue("Point");
jsonWriter.WritePropertyName("coordinates");
jsonWriter.WriteStartArray();
jsonWriter.WriteValue(permit.Longitude);
jsonWriter.WriteValue(permit.Latitude);
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
if ((choice & FieldChoices.Recommended) > 0)
{
// TODO Serialize required fields
}
if ((choice & FieldChoices.Optional) > 0)
{
// TODO Serialize optional fields
}
if ((choice & FieldChoices.All) > 0)
{
// TODO Serialize all
}
jsonWriter.WriteEndObject();
}
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
jsonWriter.Flush();
jsonWriter.Close();
});
return(geoJsonContent);
}
public async Task Read_File_Chunks_Success()
{
// This tests reading file chunks and pushing them to the output stream
// Arrange
var moqFilesRepo = new Mock <IFilesRepository>();
var moqConfigRepo = new Mock <IConfigRepository>();
int fileChunkSize = 125;
var contentString = GetRandomString(125);
// set the size of the content to force two loops to retrieve total of 250 bytes
byte[] fileStreamContent = Encoding.UTF8.GetBytes(contentString + contentString);
var file = new File
{
FileId = new Guid("22222222-2222-2222-2222-222222222222"),
FileName = "Test2.txt",
StoredTime = I18NHelper.DateTimeParseExactInvariant("2015-09-05T22:57:31.7824054-04:00", "o"),
FileType = "application/octet-stream",
FileSize = fileStreamContent.Length,
ChunkCount = 2
};
var moqDbConnection = new Mock <DbConnection>();
moqFilesRepo.Setup(t => t.CreateConnection()).Returns(moqDbConnection.Object);
moqFilesRepo.Setup(t => t.GetFileHead(It.IsAny <Guid>())).ReturnsAsync(file);
moqFilesRepo.Setup(t => t.ReadChunkContent(moqDbConnection.Object, It.IsAny <Guid>(), It.IsAny <int>())).Returns(fileStreamContent.Take <byte>(125).ToArray <byte>());
moqConfigRepo.Setup(t => t.LegacyFileChunkSize).Returns(fileChunkSize);
moqFilesRepo.Setup(t => t.GetFileInfo(It.IsAny <Guid>())).Returns(file);
// Act
SqlPushStream sqlPushStream = new SqlPushStream();
sqlPushStream.Initialize(moqFilesRepo.Object, file.FileId);
HttpContent responseContent = new PushStreamContent(sqlPushStream.WriteToStream, new MediaTypeHeaderValue(file.ContentType));
Stream response = await responseContent.ReadAsStreamAsync();
string originalContent = Encoding.UTF8.GetString(fileStreamContent);
string resultContent = string.Empty;
using (var memoryStream = new MemoryStream())
{
response.CopyTo(memoryStream);
resultContent = Encoding.UTF8.GetString(memoryStream.ToArray());
}
// Assert
Assert.IsTrue(originalContent.Equals(resultContent));
}
public async Task <UploadFileResult> DoUpload(HttpClient client, PushStreamContent content, File file)
{
var request = UploadClientRequest(content, file);
var responseMessage = await client.SendAsync(request);
var ures = responseMessage.ToUploadPathResult();
return(ures);
}
public async Task UploadPush(string path)
{
using (var fileStream = File.OpenRead(path))
using (var bufferedStream = new ProgressStream(fileStream, ))
{
var httpContent = new PushStreamContent((stream, content, context) =>
{
});
}
}
public HttpResponseMessage Get()
{
var content = new PushStreamContent(PushWave);
content.Headers.ContentType = new MediaTypeWithQualityHeaderValue("audio/x-wav");
return(new HttpResponseMessage()
{
Content = content
});
}
private void PushImage(Stream stream, HttpContent cont, TransportContext ctx)
{
Trace.TraceInformation("pushing new frame");
var content = new PushStreamContent(PushImage);
content.Headers.ContentType = new MediaTypeWithQualityHeaderValue("image/jpeg");
_content.Add(content);
ScreenCapturer.GetEncodedBytesInto(stream);
Thread.Sleep(2 * 1000);
stream.Close();
}
/// <summary>
/// POST附件
/// </summary>
/// <param name="url">POST地址</param>
/// <param name="attachmentList">附件元数据列表</param>
/// <returns></returns>
public static async Task <string> HttpPostMultipartFormDataAsync(string url, List <BaseAttachmentInfoModel> attachmentList)
{
string html = string.Empty;
using (var httpClient = HttpClientFactory.Create())
{
using (var httpContent = new MultipartFormDataContent())
{
foreach (var attachmentInfoModel in attachmentList)
{
if (attachmentInfoModel is StringAttachmentInfoModel stringAttachmentInfoModel)
{
httpContent.Add(new StringContent(stringAttachmentInfoModel.AttachmentData), stringAttachmentInfoModel.KeyName);
}
else if (attachmentInfoModel is FileAttachmentInfoModel fileAttachmentInfoModel)
{
var fileFullPath = fileAttachmentInfoModel.AttachmentData;
var pushFileStreamModel = new PushFileStreamModel(fileFullPath);
var pushStreamContent = new PushStreamContent(pushFileStreamModel.WriteFileToPushStream);
httpContent.Add(pushStreamContent, fileAttachmentInfoModel.KeyName, Path.GetFileName(fileFullPath));
}
}
var httpResponseMessage = await httpClient.PostAsync(url, httpContent);
html = await GetResponseContentStringAsync(httpResponseMessage);
//var content = new MultipartFormDataContent();
////添加字符串参数，参数名为qq
//string path = Path.Combine(System.Environment.CurrentDirectory, "1.png");
////添加文件参数，参数名为files，文件名为123.png
//content.Add(new ByteArrayContent(System.IO.File.ReadAllBytes(path)), "file", "123.png");
////using (var httpContent = new StringContent(postJson))
////{
//// httpContent.Headers.ContentType = new MediaTypeHeaderValue(HttpContentTypeKeys.APPLICATION_JSON);
//// var httpResponseMessage = await httpClient.PostAsync(url, httpContent);
//// //data = await GetResponseContentDataAsync<TReturnDataModel>(httpResponseMessage);
//// html = await GetResponseContentStringAsync(httpResponseMessage);
////}
}
}
return(html);
}
public HttpResponseMessage Get()
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
//response.Headers.TransferEncodingChunked = true;
//var content = new PushStreamContent(new Action<Stream, HttpContent, TransportContext>(WriteContent2), "application/json");
var content = new PushStreamContent(new Action <Stream, HttpContent, TransportContext>(WriteContent), "text/plain");
response.Content = content;
return(response);
}
public HttpResponseMessage Get()
{
Trace.TraceInformation("Get");
var content = new PushStreamContent(PushImage);
content.Headers.ContentType = new MediaTypeWithQualityHeaderValue("image/jpeg");
_content.Add(content);
return(new HttpResponseMessage()
{
Content = _content
});
}
public async Task <UploadFileResult> DoUpload(HttpClient client, PushStreamContent content, File file)
{
var request = CreateUploadClientRequest(content, file);
var responseMessage = await client.SendAsync(request);
var ures = responseMessage.ToUploadPathResult();
ures.NeedToAddFile = false;
//Thread.Sleep(1_000);
return(ures);
}
public async Task AsyncClientStreamingCall_Success_RequestContentSent()
{
// Arrange
PushStreamContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
// Assert
Assert.IsNotNull(call);
Assert.IsNotNull(content);
var responseTask = call.ResponseAsync;
Assert.IsFalse(responseTask.IsCompleted, "Response not returned until client stream is complete.");
var streamTask = content.ReadAsStreamAsync();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var requestContent = await streamTask.DefaultTimeout();
var requestMessage = await requestContent.ReadStreamedMessageAsync(NullLogger.Instance, TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage.Name);
requestMessage = await requestContent.ReadStreamedMessageAsync(NullLogger.Instance, TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage.Name);
var responseMessage = await responseTask.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
}
protected HttpResponseMessage ZipContentResult(ZipFile zipFile)
{
var pushStreamContent = new PushStreamContent((stream, content, context) =>
{
zipFile.Save(stream);
stream.Close();
}, "application/zip");
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = pushStreamContent
});
}
//GET CUAHSI/HydroClient/WaterOneFlowArchive/{id}
public async Task <HttpResponseMessage> Get(string fileName, string fileExtension)
{
HttpResponseMessage response = new HttpResponseMessage();
//Validate/initialize input parameters
if (String.IsNullOrWhiteSpace(fileName) || String.IsNullOrWhiteSpace(fileExtension))
{
response.StatusCode = HttpStatusCode.BadRequest; //Missing/invalid parameter(s) - return early
response.ReasonPhrase = "Invalid parameter(s)";
return(response);
}
string fileNameAndExtension = String.Format("{0}.{1}", fileName, fileExtension).ToString();
MemoryStream ms = new MemoryStream();
bool bFound = await _ac.RetrieveBlobAsync(fileNameAndExtension, CancellationToken.None, ms);
if (!bFound)
{
response.StatusCode = HttpStatusCode.NotFound; //Blob not found - return early
response.ReasonPhrase = String.Format("Requested archive file: ({0}) not found.", fileNameAndExtension.ToString());
return(response);
}
//Blob found - stream to client...
ms.Seek(0, SeekOrigin.Begin);
var pushStreamContent = new PushStreamContent((stream, content, context) =>
{
try
{
ms.CopyTo(stream);
stream.Close(); // After save we close the stream to signal that we are done writing.
ms.Close();
}
catch (Exception ex)
{
int n = 5;
++n;
}
}, "application/zip");
response.StatusCode = HttpStatusCode.OK;
response.Content = pushStreamContent;
response.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
{
FileName = fileNameAndExtension.ToString()
};
return(response);
}
public async Task<string> ConvertToHtml5Async(byte[] swf)
{
if (swf == null) throw new ArgumentNullException(nameof(swf));
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add("Host", "www.googleapis.com");
httpClient.DefaultRequestHeaders.Add("Cache-Control", "no-cache");
httpClient.Timeout = TimeSpan.FromMilliseconds(Options.MillisecondsTimeout);
var base64Data = Convert.ToBase64String(swf)
.Replace('+', '-')
.Replace('/', '_');
var requestModel = new GoogleApiRequest
{
ApiVersion = "v1",
Method = "swiffy.convertToHtml",
Params = new SwiffyParams
{
Client = "Swiffy Flash Extension",
Input = base64Data
}
};
using (var streamContent = new PushStreamContent(stream => Task.Run(() => _requestSerializer.Value.WriteObject(stream, requestModel))))
{
using (var response = await httpClient.PostAsync(GOOGLE_API_URL, streamContent).ConfigureAwait(false))
{
var responseJson = (GoogleApiResponse)_responseSerializer.Value.ReadObject(await response.Content.ReadAsStreamAsync().ConfigureAwait(false));
if(responseJson.Error != null)
{
throw new Exception($"Conversion error. {responseJson.Error.Message}.");
}
if (responseJson.Result?.Response?.Status == "SUCCESS")
{
var base64 = responseJson.Result.Response.Output.Replace('-', '+')
.Replace('_', '/');
base64 = base64.PadRight(base64.Length + (4 - base64.Length % 4) % 4, '=');
var gzip = Convert.FromBase64String(base64);
using (var memoryStream = new MemoryStream(gzip))
{
using (var gzipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
{
using (var streamReader = new StreamReader(gzipStream))
{
return await streamReader.ReadToEndAsync().ConfigureAwait(false);
}
}
}
}
else
{
throw new Exception($"Status error. Статус: {responseJson.Result?.Response?.Status}");
}
}
}
}
}
