public void SendData(ISerializable serializedData)
{
Debug.WriteLine("Send Data:" + serializedData.Serialize());
if (socket != null)
{
try {
lock (lockObject) {
{
if (dataWriter == null)
{
dataWriter = new DataWriter(socket.OutputStream);
}
// Serialize the Data
byte[] dataToSend = serializedData.Serialize();
// Send it out
dataWriter.WriteInt32(dataToSend.Length);
dataWriter.StoreAsync();
dataWriter.WriteBytes(dataToSend);
dataWriter.StoreAsync();
}
}
}
catch (Exception ex) {
Debug.WriteLine("SendMessage: " + ex.Message);
}
}
}
public static async Task <bool> SaveToStorage(string fileName, ISerializable content)
{
if (Consts.isApplicationClosing)
{
return(false);
}
isSavingComplete = false;
try {
Debug.WriteLine("SaveToStorage(): Saving to Storage");
byte[] data = content.Serialize();
StorageFolder folder = ApplicationData.Current.LocalFolder;
StorageFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
using (Stream s = await file.OpenStreamForWriteAsync()) {
await s.WriteAsync(data, 0, data.Length);
}
Debug.WriteLine("Storage Saved: " + fileName);
isSavingComplete = true;
return(true);
}
catch (Exception) { isSavingComplete = true; return(false); }
}
protected virtual Boolean ImplSerializeObject <RetvalType, ContextType> (
out RetvalType retVal,
ISerializable <RetvalType> serMgr,
Action contextPrologDlg,
Action contextEpilogDlg,
Object objValue,
ContextType context)
where ContextType : ISerializationContext
{
retVal = default(RetvalType);
if (objValue == null)
{
return(false);
}
if (serMgr == null)
{
return(false);
}
//ISerializable<RetvalType> serMgr = null;
//if ( !objValue.GetSerializationManager ( ref serMgr, context ) )
// return false;
contextPrologDlg?.Invoke();
try { retVal = serMgr.Serialize(objValue, context); }
finally { contextEpilogDlg?.Invoke(); }
return(true);
} // End of ImplSerializeObject<...> (...)
public Item(string name, float price, uint quantity, ISerializable commodity)
{
Name = name;
Price = price;
Quantity = quantity;
Commodity = commodity.Serialize();
}
public void SerializeObject(string name, ISerializable serObject)
{
XElement subElem = new XElement(name);
serObject.Serialize(new XmlSerializer(subElem));
elem.Add(subElem);
}
public bool SaveFile(IFileable f)
{
if (f == null)
{
return(false);
}
ISerializable iser = f as ISerializable;
if (iser == null)
{
return(false);
}
object jobj = new JObject();
if (iser.Serialize(ref jobj) == false)
{
return(false);
}
var setting = new JsonSerializerSettings();
setting.Formatting = Formatting.Indented; // 들여쓰기, 줄내림(None : 용량 반으로 줄어듬)
setting.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; // 순환 참조 객체 무시
string json = JsonConvert.SerializeObject(jobj, setting);
File.WriteAllText(f.FileInfo.FullFileName, json);
return(true);
}
internal void Serialize_Internal(MyStream stream, object target)
{
Type targetType = target.GetType();
ISerializable ser = serializeMap[targetType];
ser.Serialize(stream, target);
}
public void SendUdp(Player player, EMsgSC type, ISerializable body, bool isNeedDebugSize = false)
{
var writer = new Serializer();
body.Serialize(writer);
player?.SendUdp(type, writer.CopyData());
}
public void Serialize(ISerializable serializable, Stream output)
{
var bw = new BinaryWriter(output);
serializable.Serialize(new BinaryTypeWriter(bw));
bw.Flush();
}
public static void SaveToFile(this ISerializable obj, string filePath, bool wrapfile)
{
using (BinaryWriter writer = new BinaryWriter(OpenFileWrap(filePath, FileMode.Create, wrapfile)))
{
obj.Serialize(writer);
}
}
virtual public void Serialize(Stream stream, Encoding encoding)
{
foreach (DictionaryEntry de in m_object.Properties)
{
Property p = (Property)de.Value;
ISerializable serializer = SerializerFactory.Create(p);
if (serializer != null)
{
serializer.Serialize(stream, encoding);
}
}
foreach (DictionaryEntry de in m_object.Parameters)
{
Parameter p = (Parameter)de.Value;
ISerializable serializer = SerializerFactory.Create(p);
if (serializer != null)
{
serializer.Serialize(stream, encoding);
}
}
foreach (DDay.iCal.Objects.iCalObject obj in m_object.Children)
{
ISerializable serializer = SerializerFactory.Create(obj);
if (serializer != null)
{
serializer.Serialize(stream, encoding);
}
}
}
public void SendUdp(EMsgSC msgId, ISerializable body)
{
Serializer serializer = new Serializer();
body.Serialize(serializer);
_netUdp?.SendMessage(msgId, serializer.CopyData());
}
public bool SaveFile(IFileable f)
{
if (f == null)
{
return(false);
}
ISerializable iser = f as ISerializable;
if (iser == null)
{
return(false);
}
FileStream fs = new FileStream(f.FileInfo.FullFileName, FileMode.Create, FileAccess.Write);
object writer = new BinaryWriter(fs);
bool success = iser.Serialize(ref writer);
BinaryWriter bw = writer as BinaryWriter;
bw.Close();
fs.Close();
return(success);
}
protected object transmitPacket(ISerializable request, IDeserializable reply = null)
{
MemoryStream stream = new MemoryStream();
request.Serialize(stream);
byte[] rawRequest = stream.ToArray();
if (reply == null)
{
DebugWrite("transmit: ", request);
spiWrite(rawRequest);
return(null);
}
else
{
byte[] rawReply = spiReadWrite(rawRequest);
stream = new MemoryStream(rawReply);
reply.Deserialize(stream);
DebugWrite("received: ", reply);
if (!((IValidate)reply).IsValid)
{
throw new CheckSumException();
}
return(reply);
}
}
private byte[] Serialize(ISerializable packet, uint objectId, bool reliable, uint packetId)
{
PacketHeader header = new PacketHeader();
MemoryStream stream = new MemoryStream();
header.id = packetId;
header.objectId = objectId;
header.senderId = ConnectionManager.instance.ClientId;
header.packetType = packet.packetType;
header.reliable = reliable;
header.Serialize(stream);
packet.Serialize(stream);
stream.Close();
PacketSecurity security = new PacketSecurity();
Crc32 crc = new Crc32();
MemoryStream packetStream = new MemoryStream();
byte[] hash = crc.ComputeHash(stream.ToArray());
security.data = stream.ToArray();
security.hash = hash;
security.Serialize(packetStream);
packetStream.Close();
return(packetStream.ToArray());
}
public void SendUdp(EMsgSC msgId, ISerializable body)
{
var writer = new Serializer();
writer.PutInt16((short)msgId);
body?.Serialize(writer);
_netUdp?.SendMessage(EMsgSC.C2G_UdpMessage, writer.CopyData(), EDeliveryMethod.Unreliable);
}
/// <summary>
/// Writes a given block to stream.
/// </summary>
/// <param name="blocktype">type of given block</param>
/// <param name="block">block, to write</param>
public void Write(BlockType blocktype, ISerializable block)
{
stream.WriteByte((byte)blocktype);
if (block != null)
{
block.Serialize(this);
}
}
private void WriteSerializable(ISerializable sData)
{
if (sData == null)
{
throw new ArgumentNullException(nameof(sData));
}
sData.Serialize(this);
}
public Serializer Write(ISerializable v)
{
A("o{");
v.Serialize(this);
A("};");
return(this);
}
public void Write(ISerializable obj)
{
DataBuffer buffer = new DataBuffer();
obj.Serialize(buffer);
Write(buffer.StringFromBytes);
}
public static void Write(this IWriteableBuffer w, ISerializable v)
{
w.Write(v != null ? true : false);
if (v != null)
{
v.Serialize(w);
}
}
///
/// <param name="name"></param>
/// <param name="v"></param>
public override ISerializable Inout <T>(string name, ISerializable v)
{
string types = readBuf.ReadString(); // Skip string for non virtual objects, type is known by T
ISerializable newSer = (ISerializable) new T();
newSer.Serialize(this);
return(newSer);
}
/// <summary>
/// Converts an <see cref="ISerializable"/> object to a byte array.
/// </summary>
/// <param name="value">The <see cref="ISerializable"/> object to be converted.</param>
/// <returns>The converted byte array.</returns>
public static byte[] ToArray(this ISerializable value)
{
using MemoryStream ms = new();
using BinaryWriter writer = new(ms, Utility.StrictUTF8, true);
value.Serialize(writer);
writer.Flush();
return(ms.ToArray());
}
public void SendMsgLobby(EMsgCL msgId, ISerializable body)
{
var writer = new Serializer();
writer.PutByte((byte)msgId);
body.Serialize(writer);
_netProxyLobby.Send(Compressor.Compress(writer));
}
public byte[] Serialize(ISerializable serializable)
{
using (var stream = new MemoryStream())
{
var writer = new BinaryWriter(stream);
serializable.Serialize(writer, new Dictionary <object, int>(), 0);
return(stream.ToArray());
}
}
public void SendMsgRoom(EMsgCS msgId, ISerializable body)
{
var writer = new Serializer();
writer.Put(_playerID);
writer.Put((byte)msgId);
body.Serialize(writer);
_netProxyRoom.Send(Compressor.Compress(writer));
}
public void TestSerialize()
{
MemoryStream stream = new MemoryStream();
ECPoint point = new ECPoint(null, null, ECCurve.Secp256k1);
ISerializable serializable = point;
serializable.Serialize(new BinaryWriter(stream));
stream.ToArray().Should().BeEquivalentTo(new byte[] { 0 });
}
/// <summary>
/// Write an object value.
/// </summary>
/// <param name="name">Name of member.</param>
/// <param name="value">Value of member.</param>
/// <param name="nullable">If this member can be null.</param>
public void Write(string name, ISerializable value, bool nullable)
{
this.WriteNullableFlag(value, nullable);
if (value != null)
{
value.Serialize(this);
}
}
public KeyBuilder Add(ISerializable key)
{
using (BinaryWriter writer = new BinaryWriter(stream, Utility.StrictUTF8, true))
{
key.Serialize(writer);
writer.Flush();
}
return(this);
}
public static bool TrySerialize(this ISerializable value, out float[] serialized)
{
serialized = new float[value.SerializedSize];
var position = 0;
var success = true;
success &= value.Serialize(ref serialized, ref position);
return(success);
}
/// <summary>
/// Serializes an object to a new <see cref="MemoryStream"/> using the class specified by <typeparamref name="TFormatter"/>.
/// </summary>
/// <typeparam name="TFormatter">The <see cref="Type"/> used to serialize the <paramref name="instance"/>.</typeparam>
/// <param name="instance">The instance to serialize.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"> thrown if the <paramref name="instance"/> or <paramref name="stream"/> is <c>Null</c>.</exception>
/// <exception cref="ArgumentException"> thrown if the <typeparamref name="TFormatter"/> is not a valid Serialization formatter <see cref="Type"/>.</exception>
public static MemoryStream Serialize <TFormatter>(this ISerializable instance)
where TFormatter : class, new()
{
MemoryStream stream = new MemoryStream();
instance.Serialize <TFormatter>(stream);
return(stream);
}
/// <summary>
/// Identify whether the Rop request contains more than one server object handle. Refers to [MS-OXCROPS] for more details.
/// </summary>
/// <param name="ropRequest">ROP request objects.</param>
/// <returns>Return true if the Rop request contains more than one server object handle, otherwise return false.</returns>
public static bool IsOutputHandleInRopRequest(ISerializable ropRequest)
{
byte ropId = (byte)BitConverter.ToInt16(ropRequest.Serialize(), 0);
switch (ropId)
{
case 0x01: // RopRelease ROP
case 0x07: // RopGetPropertiesSpecific ROP
case 0x08: // RopGetPropertiesAll ROP
case 0x09: // RopGetPropertiesList ROP
case 0x0A: // RopSetProperties ROP
case 0x0B: // RopDeleteProperties ROP
case 0x0D: // RopRemoveAllRecipients ROP
case 0x0E: // RopModifyRecipients ROP
case 0x0F: // RopReadRecipients ROP
case 0x10: // RopReloadCachedInformation ROP
case 0x12: // RopSetColumns ROP
case 0x13: // RopSortTable ROP
case 0x14: // RopRestrict ROP
case 0x15: // RopQueryRows ROP
case 0x16: // RopGetStatus ROP
case 0x17: // RopQueryPosition ROP
case 0x18: // RopSeekRow ROP
case 0x19: // RopSeekRowBookmark ROP
case 0x1A: // RopSeekRowFractional ROP
case 0x1B: // RopCreateBookmark ROP
case 0x1D: // RopDeleteFolder ROP
case 0x1E: // RopDeleteMessages ROP
case 0x1F: // RopGetMessageStatus ROP
case 0x20: // RopSetMessageStatus ROP
case 0x24: // RopDeleteAttachment ROP
case 0x26: // RopSetReceiveFolder ROP
case 0x27: // RopGetReceiveFolder ROP
case 0x2A: // RopNotify ROP
case 0x2C: // RopReadStream ROP
case 0x2D: // RopWriteStream ROP
case 0x2E: // RopSeekStream ROP
case 0x2F: // RopSetStreamSize ROP
case 0x30: // RopSetSearchCriteria ROP
case 0x31: // RopGetSearchCriteria ROP
case 0x32: // RopSubmitMessage ROP
case 0x34: // RopAbortSubmit ROP
case 0x37: // RopQueryColumnsAll ROP
case 0x38: // RopAbort ROP
case 0x40: // RopModifyPermissions ROP
case 0x41: // RopModifyRules ROP
case 0x42: // RopGetOwningServers ROP
case 0x43: // RopLongTermIdFromId ROP
case 0x44: // RopIdFromLongTermId ROP
case 0x45: // RopPublicFolderIsGhosted ROP
case 0x47: // RopSetSpooler ROP
case 0x48: // RopSpoolerLockMessage ROP
case 0x49: // RopGetAddressTypes ROP
case 0x4A: // RopTransportSend ROP
case 0x4E: // RopFastTransferSourceGetBuffer ROP
case 0x4F: // RopFindRow ROP
case 0x50: // RopProgress ROP
case 0x51: // RopTransportNewMail ROP
case 0x52: // RopGetValidAttachments ROP
case 0x54: // RopFastTransferDestinationPutBuffer ROP
case 0x55: // RopGetNamesFromPropertyIds ROP
case 0x56: // RopGetPropertyIdsFromNames ROP
case 0x57: // RopUpdateDeferredActionMessages ROP
case 0x58: // RopEmptyFolder ROP
case 0x59: // RopExpandRow ROP
case 0x5A: // RopCollapseRow ROP
case 0x5B: // RopLockRegionStream ROP
case 0x5C: // RopUnlockRegionStream ROP
case 0x5D: // RopCommitStream ROP
case 0x5E: // RopGetStreamSize ROP
case 0x5F: // RopQueryNamedProperties ROP
case 0x60: // RopGetPerUserLongTermIds ROP
case 0x61: // RopGetPerUserGuid ROP
case 0x63: // RopReadPerUserInformation ROP
case 0x64: // RopWritePerUserInformation ROP
case 0x66: // RopSetReadFlags ROP
case 0x68: // RopGetReceiveFolderTable ROP
case 0x6B: // RopGetCollapseState ROP
case 0x6C: // RopSetCollapseState ROP
case 0x6D: // RopGetTransportFolder ROP
case 0x6E: // RopPending ROP
case 0x6F: // RopOptionsData ROP
case 0x73: // RopSynchronizationImportHierarchyChange ROP
case 0x74: // RopSynchronizationImportDeletes ROP
case 0x75: // RopSynchronizationUploadStateStreamBegin ROP
case 0x76: // RopSynchronizationUploadStateStreamContinue ROP
case 0x77: // RopSynchronizationUploadStateStreamEnd ROP
case 0x78: // RopSynchronizationImportMessageMove ROP
case 0x79: // RopSetPropertiesNoReplicate ROP
case 0x7A: // RopDeletePropertiesNoReplicate ROP
case 0x7B: // RopGetStoreState ROP
case 0x7F: // RopGetLocalReplicaIds ROP
case 0x80: // RopSynchronizationImportReadStateChanges ROP
case 0x81: // RopResetTable ROP
case 0x86: // RopTellVersion ROP
case 0x89: // RopFreeBookmark ROP
case 0x90: // RopWriteAndCommitStream ROP
case 0x91: // RopHardDeleteMessages ROP
case 0x92: // RopHardDeleteMessagesAndSubfolders ROP
case 0x93: // RopSetLocalReplicaMidsetDeleted ROP
case 0xF9: // RopBackoff ROP
case 0xFE: // RopLogon ROP
return false;
case 0x02: // RopOpenFolder ROP
case 0x03: // RopOpenMessage ROP
case 0x04: // RopGetHierarchyTable ROP
case 0x05: // RopGetContentsTable ROP
case 0x06: // RopCreateMessage ROP
case 0x0C: // RopSaveChangesMessage ROP
case 0x11: // RopSetMessageReadFlag ROP
case 0x1C: // RopCreateFolder ROP
case 0x21: // RopGetAttachmentTable ROP
case 0x22: // RopOpenAttachment ROP
case 0x23: // RopCreateAttachment ROP
case 0x25: // RopSaveChangesAttachment ROP
case 0x29: // RopRegisterNotification ROP
case 0x2B: // RopOpenStream ROP
case 0x33: // RopMoveCopyMessages ROP
case 0x35: // RopMoveFolder ROP
case 0x36: // RopCopyFolder ROP
case 0x39: // RopCopyTo ROP
case 0x3A: // RopCopyToStream ROP
case 0x3B: // RopCloneStream ROP
case 0x3E: // RopGetPermissionsTable ROP
case 0x3F: // RopGetRulesTable ROP
case 0x46: // RopOpenEmbeddedMessage ROP
case 0x4B: // RopFastTransferSourceCopyMessages ROP
case 0x4C: // RopFastTransferSourceCopyFolder ROP
case 0x4D: // RopFastTransferSourceCopyTo ROP
case 0x53: // RopFastTransferDestinationConfigure ROP
case 0x67: // RopCopyProperties ROP
case 0x69: // RopFastTransferSourceCopyProperties ROP
case 0x70: // RopSynchronizationConfigure ROP
case 0x72: // RopSynchronizationImportMessageChange ROP
case 0x7E: // RopSynchronizationOpenCollector ROP
case 0x82: // RopSynchronizationGetTransferState ROP
return true;
default:
return true;
}
}
/// <summary>
/// Send ROP request with single operation.
/// </summary>
/// <param name="ropRequest">ROP request objects.</param>
/// <param name="insideObjHandle">Server object handle in request.</param>
/// <param name="response">ROP response objects.</param>
/// <param name="rawData">The ROP response payload.</param>
/// <param name="getPropertiesFlag">The flag indicate the test cases expect to get which object type's properties(message's properties or attachment's properties).</param>
/// <param name="returnValue">An unsigned integer value indicates the return value of call EcDoRpcExt2 method.</param>
/// <returns>Server objects handles in response.</returns>
public List<List<uint>> DoRopCall(ISerializable ropRequest, uint insideObjHandle, ref object response, ref byte[] rawData, GetPropertiesFlags getPropertiesFlag, out uint returnValue)
{
List<ISerializable> requestRops = new List<ISerializable>
{
ropRequest
};
List<uint> requestSOH = new List<uint>
{
insideObjHandle
};
if (Common.IsOutputHandleInRopRequest(ropRequest))
{
// Add an element for server output object handle, set default value to 0xFFFFFFFF
requestSOH.Add(DefaultOutputHandle);
}
List<IDeserializable> responseRops = new List<IDeserializable>();
List<List<uint>> responseSOHs = new List<List<uint>>();
// 0x10008 specifies the maximum size of the rgbOut buffer to place in Response.
uint ret = this.oxcropsClient.RopCall(requestRops, requestSOH, ref responseRops, ref responseSOHs, ref rawData, 0x10008);
returnValue = ret;
if (ret == OxcRpcErrorCode.ECRpcFormat)
{
this.Site.Assert.Fail("Error RPC Format");
}
if (ret != 0)
{
return responseSOHs;
}
if (responseRops != null)
{
if (responseRops.Count > 0)
{
response = responseRops[0];
}
}
else
{
response = null;
}
if (ropRequest.GetType() == typeof(RopReleaseRequest))
{
return responseSOHs;
}
byte ropId = (byte)BitConverter.ToInt16(ropRequest.Serialize(), 0);
List<PropertyObj> pts = null;
switch (ropId)
{
case (byte)RopId.RopOpenMessage:
RopOpenMessageResponse openMessageResponse = (RopOpenMessageResponse)response;
// This check is for the open specification expectation for a particular request with some valid input parameters.
if (openMessageResponse.ReturnValue == 0x00000000)
{
this.VerifyRopOpenMessageResponse(openMessageResponse);
}
break;
case (byte)RopId.RopGetPropertiesSpecific:
// RopGetPropertiesSpecificRequest
pts = PropertyHelper.GetPropertyObjFromBuffer(((RopGetPropertiesSpecificRequest)ropRequest).PropertyTags, (RopGetPropertiesSpecificResponse)response);
foreach (PropertyObj pitem in pts)
{
// Verify capture code for MS-OXCMSG.
this.VerifyMessageSyntaxDataType(pitem);
}
PropertyObj propertyObjPidTagSubjectPrefix = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagSubjectPrefix);
PropertyObj propertyObjPidTagNormalizedSubject = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagNormalizedSubject);
// Verify the message of PidTagSubjectPrefixAndPidTagNormalizedSubject
if (PropertyHelper.IsPropertyValid(propertyObjPidTagSubjectPrefix) || PropertyHelper.IsPropertyValid(propertyObjPidTagNormalizedSubject))
{
this.VerifyMessageSyntaxPidTagSubjectPrefixAndPidTagNormalizedSubject(propertyObjPidTagSubjectPrefix, propertyObjPidTagNormalizedSubject);
}
// Verify the requirements of PidTagAttachmentLinkId and PidTagAttachmentFlags.
PropertyObj pidTagAttachmentLinkId = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagAttachmentLinkId);
if (PropertyHelper.IsPropertyValid(pidTagAttachmentLinkId))
{
this.VerifyMessageSyntaxPidTagAttachmentLinkIdAndPidTagAttachmentFlags(pidTagAttachmentLinkId);
}
PropertyObj pidTagAttachmentFlags = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagAttachmentFlags);
if (PropertyHelper.IsPropertyValid(pidTagAttachmentFlags))
{
this.VerifyMessageSyntaxPidTagAttachmentLinkIdAndPidTagAttachmentFlags(pidTagAttachmentFlags);
}
// Verify the requirements of PidTagDisplayName
PropertyObj pidTagDisplayName = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagDisplayName);
PropertyObj pidTagAttachLongFilename = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagAttachLongFilename);
if (PropertyHelper.IsPropertyValid(pidTagDisplayName) && PropertyHelper.IsPropertyValid(pidTagAttachLongFilename))
{
this.VerifyMessageSyntaxPidTagDisplayName(pidTagDisplayName, pidTagAttachLongFilename);
}
PropertyObj pidTagObjectType = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagObjectType);
PropertyObj pidTagRecordKey = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagRecordKey);
this.VerifyPidTagObjectTypeAndPidTagRecordKey(pidTagObjectType, pidTagRecordKey);
break;
case (byte)RopId.RopGetPropertiesAll:
RopGetPropertiesAllResponse getPropertiesAllResponse = (RopGetPropertiesAllResponse)response;
pts = PropertyHelper.GetPropertyObjFromBuffer(getPropertiesAllResponse);
foreach (PropertyObj pitem in pts)
{
// Verify capture code for MS-OXCMSG.
this.VerifyMessageSyntaxDataType(pitem);
}
// Verify the requirements of PidTagArchiveDate
PropertyObj pidTagArchiveDateObj = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagArchiveDate);
PropertyObj pidTagStartDateEtc = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagStartDateEtc);
if (PropertyHelper.IsPropertyValid(pidTagArchiveDateObj))
{
if (PropertyHelper.IsPropertyValid(pidTagStartDateEtc))
{
byte[] byteDest = new byte[8];
Array.Copy((byte[])pidTagStartDateEtc.Value, 6, byteDest, 0, 8);
this.VerifyMessageSyntaxPidTagArchiveDate(pidTagArchiveDateObj, DateTime.FromFileTimeUtc(BitConverter.ToInt64(byteDest, 0)));
}
}
PropertyObj pidTagAccessLevel = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagAccessLevel);
pidTagRecordKey = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagRecordKey);
if (getPropertiesFlag == GetPropertiesFlags.MessageProperties)
{
PropertyObj pidTagAccess = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagAccess);
PropertyObj pidTagChangeKey = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagChangeKey);
PropertyObj pidTagCreationTime = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagCreationTime);
PropertyObj pidTagLastModificationTime = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagLastModificationTime);
PropertyObj pidTagLastModifierName = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagLastModifierName);
PropertyObj pidTagSearchKey = PropertyHelper.GetPropertyByName(pts, PropertyNames.PidTagSearchKey);
// Verify properties PidTagAccess, PidTagAccessLevel, PidTagChangeKey, PidTagCreationTime, PidTagLastModificationTime, PidTagLastModifierName and PidTagSearchKey exist on all Message objects.
this.VerifyPropertiesExistOnAllMessageObject(pidTagAccess, pidTagAccessLevel, pidTagChangeKey, pidTagCreationTime, pidTagLastModificationTime, pidTagLastModifierName, pidTagSearchKey);
}
if (getPropertiesFlag == GetPropertiesFlags.AttachmentProperties)
{
// Verify properties PidTagAccessLevel and PidTagRecordKey exist on any Attachment object.
this.VerifyPropertiesExistOnAllAttachmentObject(pidTagAccessLevel, pidTagRecordKey);
}
break;
case (byte)RopId.RopCreateMessage:
RopCreateMessageResponse createMessageResponse = (RopCreateMessageResponse)response;
// Adapter requirements related with RopCreateMessage will be verified if the response is a successful one.
if (createMessageResponse.ReturnValue == 0x00000000)
{
int hasMessageId = createMessageResponse.HasMessageId;
this.VerifyMessageSyntaxHasMessageId(hasMessageId);
}
break;
case (byte)RopId.RopReadRecipients:
RopReadRecipientsResponse readRecipientsResponse = (RopReadRecipientsResponse)response;
// Adapter requirements related with RopReadRecipients will be verified if the response is a successful one.
if (readRecipientsResponse.ReturnValue == 0x00000000)
{
this.VerifyMessageSyntaxRowCount(readRecipientsResponse);
}
break;
case (byte)RopId.RopSetMessageStatus:
RopSetMessageStatusResponse setMessageStatusResponse = (RopSetMessageStatusResponse)response;
// Adapter requirements related with RopSetMessageStatus will be verified if the response is a successful one.
if (setMessageStatusResponse.ReturnValue == 0x00000000)
{
this.VerifyMessageSyntaxMessageStatusFlags(setMessageStatusResponse);
}
break;
case (byte)RopId.RopCreateAttachment:
RopCreateAttachmentResponse createAttachmentResponse = (RopCreateAttachmentResponse)response;
// Adapter requirements related with RopCreateAttachment will be verified if the response is a successful one.
if (createAttachmentResponse.ReturnValue == 0x00000000)
{
int id = (int)createAttachmentResponse.AttachmentID;
this.VerifyDataStructureRopCreateAttachmentResponse(createAttachmentResponse, id);
}
break;
case (byte)RopId.RopOpenEmbeddedMessage:
RopOpenEmbeddedMessageResponse openEmbeddedMessageResponse = (RopOpenEmbeddedMessageResponse)response;
// Adapter requirements related with RopOpenEmbeddedMessage will be verified if the response is a successful one.
if (openEmbeddedMessageResponse.ReturnValue == 0x00000000)
{
ulong mid = openEmbeddedMessageResponse.MessageId;
this.VerifyDataStructureRopOpenEmbeddedMessageResponse(openEmbeddedMessageResponse, mid);
}
break;
case (byte)RopId.RopSetMessageReadFlag:
RopSetMessageReadFlagResponse setMessageReadFlagResponse = (RopSetMessageReadFlagResponse)response;
// Adapter requirements related with RopSetMessageReadFlag will be verified if the response is a successful one.
if (setMessageReadFlagResponse.ReturnValue == 0x00000000)
{
this.VerifyMessageSyntaxReadStatusChanged(setMessageReadFlagResponse, (RopSetMessageReadFlagRequest)ropRequest);
}
break;
case (byte)RopId.RopSetReadFlags:
// Adapter requirements related with RopSetReadFlags will be verified if the response is a successful one.
if (((RopSetReadFlagsResponse)response).ReturnValue == 0x00000000)
{
this.VerifyRopSetReadFlagsResponse((RopSetReadFlagsResponse)response);
}
break;
case (byte)RopId.RopGetMessageStatus:
// Adapter requirements related with RopGetMessageStatus will be verified if the response is a successful one.
if (((RopSetMessageStatusResponse)response).ReturnValue == 0x00000000)
{
this.VerifyGetMessageStatusResponse((RopSetMessageStatusResponse)response);
}
break;
default:
break;
}
this.VerifyMAPITransport();
return responseSOHs;
}
public void Write(ISerializable structure)
{
structure.Serialize(this);
}
/// <summary>
/// Check whether the default invalid handle is needed.
/// </summary>
/// <param name="ropRequest">ROP request objects.</param>
/// <param name="expectedRopResponseType">The expected ROP response type.</param>
/// <returns>Return true if the default handle is needed in the request, otherwise return false.</returns>
private bool IsInvalidInputHandleNeeded(ISerializable ropRequest, RopResponseType expectedRopResponseType)
{
if (!Common.IsOutputHandleInRopRequest(ropRequest) && expectedRopResponseType == RopResponseType.FailureResponse)
{
byte[] request = ropRequest.Serialize();
// The default handle is also needed by some cases to verify the failure response caused by an invalid input handle.
// The input handle index is the third byte and its value is 1 in this test suite for this situation.
byte inputHandleIndex = request[2];
if (inputHandleIndex == 1)
{
return true;
}
}
return false;
}
