protected void Page_Load(object sender, EventArgs e)
{
try
{
string rmaNo = Convert.ToString(Request.QueryString["RMANo"]);
Title = rmaNo + ".pdf";
RMAInstructionsPDF createPDF = new RMAInstructionsPDF();
MemStream = createPDF.CreatePDF(rmaNo);
Response.Clear();
Response.ContentType = "application/pdf";
Response.OutputStream.Write(MemStream.GetBuffer(), 0, MemStream.GetBuffer().Length);
Response.OutputStream.Flush();
Response.OutputStream.Close();
}
catch (Exception ex)
{
Log.Error(ex.Message, ex);
Session["Error"] = ex.Message;
Response.Redirect("../ErrorForm.aspx");
}
finally
{
Response.End();
}
}
public override void Deserialize(MyObjectBuilder_EntityComponent bbase)
{
var ob = (MyObjectBuilder_ConstructableComponent)bbase;
if (!string.IsNullOrEmpty(ob.SPacked))
{
try
{
var stream = new MemStream(Convert.FromBase64String(ob.SPacked));
if (_stockpile == null)
{
_stockpile = new ConstructionStockpile();
}
_stockpile.Items.Clear();
var count = (int)stream.Read7BitEncoded();
for (var i = 0; i < count; i++)
{
_stockpile.AddItem(Controller.Decode((int)stream.Read7BitEncoded()),
(int)stream.Read7BitEncoded());
}
}
catch (Exception e)
{
this.GetLogger().Warning($"Failed to deserialize packed stockpile data {e}");
}
}
else
{
_stockpile?.Clear();
}
BuildIntegrity = ob.BInteg;
}
public override MyObjectBuilder_EntityComponent Serialize(bool copy = false)
{
var ob = new MyObjectBuilder_ConstructableComponent()
{
BInteg = BuildIntegrity,
SPacked = ""
};
if (_stockpile == null || _stockpile.IsEmpty())
{
return(ob);
}
var stream = new MemStream(_stockpile.Items.Count * 2 + 1);
stream.Write7BitEncoded((ulong)_stockpile.Items.Count);
foreach (var k in _stockpile.Items)
{
stream.Write7BitEncoded((ulong)Controller.EncodeExisting(k.Key));
stream.Write7BitEncoded((ulong)k.Value);
}
ob.SPacked = stream.ToBase64();
return(ob);
}
//to receive the socket response from iflytek server
public static async void ReceiveWebSocketData(ClientWebSocket webSocket)
{
int ReceiveChunkSize = 5000;
byte[] Buffer = new byte[ReceiveChunkSize];
ArraySegment <byte> ar = new ArraySegment <byte>(Buffer);
while (webSocket.State == System.Net.WebSockets.WebSocketState.Open)
{
WebSocketReceiveResult res = null;
MemoryStream MemStream = new MemoryStream();
do
{
try
{
res = await webSocket.ReceiveAsync(new ArraySegment <byte>(Buffer),
CancellationToken.None);
if (res.Count > 0)
{
MemStream = new MemoryStream();
MemStream.Write(ar.Array, 0, res.Count);
}
if (res.MessageType == WebSocketMessageType.Close)
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
string.Empty, CancellationToken.None);
}
}
catch (Exception ex)
{
Console.WriteLine(DateTime.Now.ToString("ss.fff") + "\t Websocket disconnected now: server closes websocket after sending all results.");
}
} while (res != null && !res.EndOfMessage);
byte[] ResBuffer = MemStream.GetBuffer();
String ServerResponse = Encoding.UTF8.GetString(ResBuffer, 0, (int)MemStream.Length);
//parse the iflytek server resoponse data
Parse(ServerResponse);
}
}
public void Dispose()
{
MemStream.Dispose();
}
/// <summary>
/// Iterate through each sequence and for each position, record the number of occurrences
/// of each base quality score.
/// </summary>
public override void ContentByPosition()
{
if (Sequences == null)
{
throw new ArgumentNullException("Sequences");
}
// Open a MemoryStream to store the quality scores.
// We are bulding the MemStream such that each consecutive block
// of size this.Count contains all quality scores at position i, where i = [1, this.Count].
// This way, we can extract each block and calculate statistics for each base position
// (as needed in order to generate a boxplot)
// e.g.
// i.e. Let qx,y be the quality score q at position y of sequence x
// then the stream is represented as follows:
// [q1,1][q2,1][q3,1]....[q1,(length(sequence 1))][q1,2][q2,2]...etc...[q(total # of reads),(length(sequence x))]
// <------- position 1 qualities ----------------><--- pos 2 qualities ---><etc.>
//using (Stream s = new FileStream(this.StreamFileName, FileMode.Create))
//{
this.MemStream = new MemoryStream((int)(this.ReadLengthMax * this.Count));
if (MemStream.CanWrite)
{
// Keep track of the number of reads processed
int readNumber = 0;
// Keep track of the number of bases processed (for calculating mean)
int bases = 0;
byte[] bytesToWrite = new byte[this.ReadLengthMax];
foreach (QualitativeSequence seqObj in Sequences)
{
if (Worker != null && WorkerArgs != null && Worker.CancellationPending)
{
WorkerArgs.Cancel = true;
break;
}
MemStream.Position = (int)readNumber;
// Copy quality scores to a byte array.
byte[] quals = ConvertToPhred(((QualitativeSequence)seqObj).QualityScores.ToArray(), this.FormatType);
for (int i = 0; i < this.ReadLengthMax; i++)
{
if (Worker != null && WorkerArgs != null && Worker.CancellationPending)
{
WorkerArgs.Cancel = true;
break;
}
// If the read is shorter than the max read length, fill
// the remaining space with zeroes.
byte qual = (i < quals.Length) ? quals[i] : (byte)0;
MemStream.WriteByte(qual);
var qualDouble = Convert.ToDouble(qual);
// Determine minimum base quality score
if (qualDouble < this.BaseQualityScoreMin)
{
this.BaseQualityScoreMin = qualDouble;
}
// Determine maximum base quality score
if (qualDouble > this.BaseQualityScoreMax)
{
this.BaseQualityScoreMax = qualDouble;
}
// Tally the sum for calculating the mean afterwards
this.BaseQualityScoreMean += qualDouble;
if (i != this.ReadLengthMax - 1)
{
// advance cursor to the next position by moving down x positions,
// where x is the total number of sequences
if (MemStream.CanSeek)
{
MemStream.Seek(this.Count - 1, SeekOrigin.Current);
}
else
{
throw new NotSupportedException("Unable to write to FileStream");
}
}
bases++;
}
readNumber++;
}
this.BaseQualityScoreMean /= bases;
}
//}
this.HasRunContentByPosition = true;
}
