/// <summary>
/// Gets attachment stream.
/// </summary>
/// <returns>Returns attachment stream.</returns>
internal Stream GetStream()
{
if (m_pStream == null)
{
m_pStream = File.OpenRead(m_FileName);
}
if (m_ZipCompress)
{
MemoryStreamEx retVal = new MemoryStreamEx();
using (ZipArchive archive = new ZipArchive(retVal, ZipArchiveMode.Create)){
ZipArchiveEntry entry = archive.CreateEntry(m_Name, CompressionLevel.Optimal);
using (Stream zipStream = entry.Open()){
Net_Utils.StreamCopy(m_pStream, zipStream, 64000);
}
}
retVal.Position = 0;
CloseStream();
return(retVal);
}
return(m_pStream);
}
public void InputStreamOwnership()
{
MemoryStreamEx memStream = new MemoryStreamEx();
GZipInputStream s = new GZipInputStream(memStream);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
s.Close();
Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
memStream = new MemoryStreamEx();
s = new GZipInputStream(memStream);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
s.IsStreamOwner = false;
s.Close();
Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
}
/// <summary>
/// Gets attachment stream.
/// </summary>
/// <returns>Returns attachment stream.</returns>
internal Stream GetStream()
{
if (m_pStream == null)
{
m_pStream = File.OpenRead(m_FileName);
}
if (m_ZipCompress)
{
#if NET20 || NET35 || NET40
throw new InvalidOperationException("Not supported lower framework version than 4.5.");
#else
MemoryStreamEx retVal = new MemoryStreamEx();
using (ZipArchive archive = new ZipArchive(retVal, ZipArchiveMode.Create)){
ZipArchiveEntry entry = archive.CreateEntry(m_Name, CompressionLevel.Optimal);
using (Stream zipStream = entry.Open()){
Net_Utils.StreamCopy(m_pStream, zipStream, 64000);
}
}
retVal.Position = 0;
CloseStream();
return(retVal);
#endif
}
return(m_pStream);
}
/// <summary>
/// Sets body data from the specified stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <param name="transferEncoding">Specifies content-transfer-encoding to use to encode data.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> or <b>transferEncoding</b> is null reference.</exception>
/// <exception cref="InvalidOperationException">Is raised when this method is accessed and this body is not bounded to any entity.</exception>
public void SetData(Stream stream, string transferEncoding)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (transferEncoding == null)
{
throw new ArgumentNullException("transferEncoding");
}
if (String2.Equals(transferEncoding, MIME_TransferEncodings.QuotedPrintable, StringComparison2.InvariantCultureIgnoreCase))
{
using (MemoryStreamEx fs = new MemoryStreamEx())
{
QuotedPrintableStream encoder = new QuotedPrintableStream(new SmartStream(fs, false), FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, 84000);
encoder.Flush();
fs.Position = 0;
SetEncodedData(transferEncoding, fs);
}
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.Base64, StringComparison2.InvariantCultureIgnoreCase))
{
using (MemoryStreamEx fs = new MemoryStreamEx())
{
Base64Stream encoder = new Base64Stream(fs, false, true, FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, 84000);
encoder.Finish();
fs.Position = 0;
SetEncodedData(transferEncoding, fs);
}
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.Binary, StringComparison2.InvariantCultureIgnoreCase))
{
SetEncodedData(transferEncoding, stream);
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.EightBit, StringComparison2.InvariantCultureIgnoreCase))
{
SetEncodedData(transferEncoding, stream);
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.SevenBit, StringComparison2.InvariantCultureIgnoreCase))
{
SetEncodedData(transferEncoding, stream);
}
else
{
throw new NotSupportedException("Not supported Content-Transfer-Encoding '" + transferEncoding + "'.");
}
}
public void MoveStream(int startIndex)
{
MemoryStreamEx activedStream = GetActivedStream();
if (startIndex > 0)
{
if (startIndex < activedStream.Length)
{
activedStreamIndex = (activedStreamIndex + 1) % streamArr.Length;
MemoryStreamEx newActivedStream = GetActivedStream();
newActivedStream.Clear();
activedStream.Write(activedStream.GetBuffer(), startIndex, ((int)activedStream.Length - startIndex));
activedStream.Clear();
}
else
{
activedStream.Clear();
}
}
}
public bool Execute(WorkFlowCommand command, Context context)
{
if (!CheckCondition(command, context))
{
return(true);
}
switch (command.Properties["Action"].Value)
{
case "ShowView":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.ShowView,
command.Properties["ViewName"].ToString(context)));
break;
case "FinishSession":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.SessionFinished, context));
break;
case "SaveVariables":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.SaveVariables, context));
break;
case "CancelSession":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.SessionCanceled, context));
break;
case "PreviousView":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.PreviousView, context));
break;
case "UpdateThumb":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.ThumbCreate, context));
break;
case "NextPhoto":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.NextPhoto, context));
break;
case "PrevPhoto":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.PrevPhoto, context));
break;
case "DeletePhoto":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.DeletePhoto, context));
break;
case "ClearPhotos":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.ClearPhotos, context));
break;
case "ShowHelp":
WorkflowManager.Instance.OnMessage(new MessageEventArgs(Messages.ShowHelp, context));
break;
case "LoadImage":
{
try
{
var stream = new MemoryStreamEx();
var buffer = File.ReadAllBytes(context.FileItem.TempFile);
stream.Write(buffer, 0, buffer.Length);
stream.Seek(0, SeekOrigin.Begin);
context.ImageStream = stream;
Log.Debug("LoadImage executed");
}
catch (Exception e)
{
Log.Debug("Error unload image", e);
}
}
break;
case "UnLoadImage":
{
try
{
context.ImageStream?.Close();
Log.Debug("UnLoadImage executed");
}
catch (Exception e)
{
Log.Debug("Error unload image", e);
}
}
break;
}
return(true);
}
public void DoReadData()
{
MemoryStreamEx stream = bufferStream.GetActivedStream();
int streamLength = (int)stream.Length;
if (streamLength >= MessageConst.MESSAGE_MIN_LENGTH)
{
int startIndex = 0;
while (true)
{
if (!stream.ReadInt(startIndex, out int totalLength))
{
break;
}
totalLength = IPAddress.NetworkToHostOrder(totalLength);
if (streamLength - startIndex < totalLength)
{
break;
}
int offsetIndex = startIndex;
offsetIndex += sizeof(int);
if (!stream.ReadByte(offsetIndex, out byte serialNum))
{
MessageError?.Invoke(MessageErrorCode.Reader_ReadSerialNumberError);
break;
}
if (serialNumber + 1 != serialNum)
{
MessageError?.Invoke(MessageErrorCode.Reader_CompareSerialNumberError);
break;
}
offsetIndex += sizeof(byte);
if (!stream.ReadInt(offsetIndex, out int messageID))
{
MessageError?.Invoke(MessageErrorCode.Reader_ReadMessageIDError);
break;
}
messageID = IPAddress.NetworkToHostOrder(messageID);
offsetIndex += sizeof(int);
if (offsetIndex < totalLength + startIndex)
{
int messageDataLength = totalLength + startIndex - offsetIndex;
byte[] messageDatas = new byte[messageDataLength];
if (stream.Read(messageDatas, 0, messageDataLength) != messageDataLength)
{
MessageError?.Invoke(MessageErrorCode.Reader_CompareMessageDataLengthError);
break;
}
MessageReceived?.Invoke(messageID, messageDatas);
}
else
{
MessageReceived?.Invoke(messageID, null);
}
startIndex += totalLength;
serialNumber = serialNum;
}
bufferStream.MoveStream(startIndex);
}
}
public void OnDataReceived(byte[] bytes, int size)
{
MemoryStreamEx stream = bufferStream.GetActivedStream();
stream.Write(bytes, 0, size);
}
