public ManifestContentChangesFetcher(ISourceFolder folder, MapiFolder mapiFolder, MailboxProviderBase mailbox, bool isPagedEnumeration) { this.folder = folder; this.mapiFolder = mapiFolder; this.mailbox = mailbox; this.isPagedEnumeration = isPagedEnumeration; }
public int GetQueueLength() { MrsTracer.Common.Function("RequestJobProvider.GetQueueLength", new object[0]); RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(this.SystemMailbox); Restriction restriction = Restriction.EQ(requestJobNamedPropertySet.PropTags[4], true); Restriction restriction2 = Restriction.BitMaskNonZero(requestJobNamedPropertySet.PropTags[10], 256); Restriction restriction3 = Restriction.EQ(requestJobNamedPropertySet.PropTags[0], RequestStatus.Completed); Restriction restriction4 = Restriction.EQ(requestJobNamedPropertySet.PropTags[0], RequestStatus.CompletedWithWarning); Restriction restriction5 = Restriction.Or(new Restriction[] { restriction, restriction2, restriction3, restriction4 }); Restriction restriction6 = Restriction.Not(restriction5); int result; using (MapiFolder requestJobsFolder = RequestJobXML.GetRequestJobsFolder(this.SystemMailbox)) { using (MapiTable contentsTable = requestJobsFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { contentsTable.Restrict(restriction6); int rowCount = contentsTable.GetRowCount(); MrsTracer.Common.Debug("Queue length is {0}", new object[] { rowCount }); result = rowCount; } } return(result); }
public static FolderRec Create(MapiFolder folder, PropTag[] additionalPtagsToLoad) { PropTag[] array; if (additionalPtagsToLoad == null) { array = FolderRec.PtagsToLoad; } else { List <PropTag> list = new List <PropTag>(); list.AddRange(FolderRec.PtagsToLoad); list.AddRange(additionalPtagsToLoad); array = list.ToArray(); } PropValue[] props = folder.GetProps(array); byte[] array2 = null; for (int i = 0; i < array.Length; i++) { PropTag propTag = array[i]; PropTag propTag2 = propTag; if (propTag2 != PropTag.EntryId) { if (propTag2 == PropTag.LTID) { props[i] = new PropValue(PropTag.LTID, folder.MapiStore.GlobalIdFromId(folder.MapiStore.GetFidFromEntryId(array2))); } } else { array2 = (byte[])props[i].Value; } } return(FolderRec.Create(props)); }
internal void SaveToMailbox(MapiStore mailbox, int maxMoveHistoryLength) { MrsTracer.Common.Function("MoveHistoryEntryInternal.SaveToMailbox(maxHistoryLength={0})", new object[] { maxMoveHistoryLength }); List <byte[]> list = new List <byte[]>(); using (MapiFolder folder = MapiUtils.OpenFolderUnderRoot(mailbox, MoveHistoryEntryInternal.MHEFolderName, true)) { using (MapiTable contentsTable = folder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { contentsTable.SortTable(new SortOrder(PropTag.LastModificationTime, SortFlags.Ascend), SortTableFlags.None); PropValue[][] array = MapiUtils.QueryAllRows(contentsTable, null, new PropTag[] { PropTag.EntryId }); foreach (PropValue[] array3 in array) { list.Add(array3[0].GetBytes()); } } MrsTracer.Common.Debug("Move history contains {0} items.", new object[] { list.Count }); List <byte[]> list2 = new List <byte[]>(); while (list.Count >= maxMoveHistoryLength && list.Count > 0) { list2.Add(list[0]); list.RemoveAt(0); } if (list2.Count > 0) { MrsTracer.Common.Debug("Clearing {0} entries from move history", new object[] { list2.Count }); MapiUtils.ProcessMapiCallInBatches <byte[]>(list2.ToArray(), delegate(byte[][] batch) { folder.DeleteMessages(DeleteMessagesFlags.ForceHardDelete, batch); }); } } if (maxMoveHistoryLength <= 0) { MrsTracer.Common.Debug("Move history saving is disabled.", new object[0]); return; } DateTime dateTime = this.TimeTracker.GetTimestamp(RequestJobTimestamp.Creation) ?? DateTime.MinValue; string subject = string.Format("MoveHistoryEntry {0}", dateTime.ToString()); byte[] bytes = BitConverter.GetBytes(dateTime.ToBinary()); MoveObjectInfo <MoveHistoryEntryInternal> moveObjectInfo = new MoveObjectInfo <MoveHistoryEntryInternal>(Guid.Empty, mailbox, null, MoveHistoryEntryInternal.MHEFolderName, MoveHistoryEntryInternal.MHEMessageClass, subject, bytes); using (moveObjectInfo) { moveObjectInfo.SaveObject(this); } }
internal virtual void Config(byte[] folderId, MapiFolder folder, MapiMailbox mailbox) { this.folderId = folderId; this.folder = folder; this.mailbox = mailbox; this.contentsRestriction = null; }
private byte[] FindMessageId() { using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(this.store, this.folderName, false)) { if (mapiFolder == null) { return(null); } this.FolderId = mapiFolder.GetProp(PropTag.EntryId).GetBytes(); using (MapiTable contentsTable = mapiFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { PropTag propTag = PropTag.ReplyTemplateID; contentsTable.SetColumns(new PropTag[] { PropTag.EntryId }); contentsTable.SortTable(new SortOrder(propTag, SortFlags.Ascend), SortTableFlags.None); if (contentsTable.FindRow(Restriction.EQ(propTag, this.searchKey), BookMark.Beginning, FindRowFlag.None)) { PropValue[][] array = contentsTable.QueryRows(1); if (array == null || array.Length == 0 || array[0].Length == 0) { return(null); } return(array[0][0].GetBytes()); } } } return(null); }
public static byte[] GetSignatureBytes(MapiStore systemMailbox) { byte[] result = null; using (MapiFolder rootFolder = systemMailbox.GetRootFolder()) { result = (rootFolder.GetProp(PropTag.MappingSignature).Value as byte[]); } return(result); }
internal static List <MoveHistoryEntryInternal> LoadMoveHistory(MapiStore mailbox) { MrsTracer.Common.Function("MoveHistoryEntryInternal.LoadMoveHistory", new object[0]); List <MoveHistoryEntryInternal> list = new List <MoveHistoryEntryInternal>(); using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(mailbox, MoveHistoryEntryInternal.MHEFolderName, false)) { if (mapiFolder == null) { return(list); } using (MapiTable contentsTable = mapiFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { PropValue[][] array = MapiUtils.QueryAllRows(contentsTable, null, new PropTag[] { PropTag.EntryId }); foreach (PropValue[] array3 in array) { byte[] bytes = array3[0].GetBytes(); string subject = string.Format("MoveHistoryEntry {0}", TraceUtils.DumpEntryId(bytes)); MoveObjectInfo <MoveHistoryEntryInternal> moveObjectInfo = new MoveObjectInfo <MoveHistoryEntryInternal>(Guid.Empty, mailbox, bytes, MoveHistoryEntryInternal.MHEFolderName, MoveHistoryEntryInternal.MHEMessageClass, subject, null); using (moveObjectInfo) { MoveHistoryEntryInternal moveHistoryEntryInternal = null; try { moveHistoryEntryInternal = moveObjectInfo.ReadObject(ReadObjectFlags.DontThrowOnCorruptData); } catch (MailboxReplicationPermanentException ex) { MrsTracer.Common.Warning("Failed to read move history entry: {0}", new object[] { ex.ToString() }); } if (moveHistoryEntryInternal != null) { list.Add(moveHistoryEntryInternal); } else if (moveObjectInfo.CreationTimestamp < DateTime.UtcNow - TimeSpan.FromDays(365.0)) { MrsTracer.Common.Warning("Removing old corrupt MHEI entry {0}", new object[] { TraceUtils.DumpEntryId(bytes) }); moveObjectInfo.DeleteMessage(); } } } } } list.Sort(); return(list); }
protected override ICollection <ServiceIssue> RunFullIssueScan() { ICollection <ServiceIssue> collection = new List <ServiceIssue>(); foreach (Guid mdbGuid in MapiUtils.GetDatabasesOnThisServer()) { using (new DatabaseSettingsContext(mdbGuid, null).Activate()) { try { DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.None); string databaseName = databaseInformation.DatabaseName; if (!databaseInformation.IsOnThisServer) { return(null); } using (MapiStore systemMailbox = MapiUtils.GetSystemMailbox(mdbGuid, false)) { using (MapiFolder requestJobsFolder = RequestJobXML.GetRequestJobsFolder(systemMailbox)) { using (MapiTable contentsTable = requestJobsFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { if (contentsTable.GetRowCount() > 0) { RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(systemMailbox); contentsTable.SetColumns(requestJobNamedPropertySet.PropTags); Restriction restriction = Restriction.GT(requestJobNamedPropertySet.PropTags[23], ConfigBase <MRSConfigSchema> .GetConfig <int>("PoisonLimit")); List <MoveJob> allMoveJobs = SystemMailboxJobs.GetAllMoveJobs(restriction, null, contentsTable, mdbGuid, null); if (allMoveJobs != null) { foreach (MoveJob job in allMoveJobs) { collection.Add(new MRSPoisonedJobIssue(job)); } } } } } } } catch (LocalizedException lastScanError) { base.LastScanError = lastScanError; } } } return(collection); }
public static MapiFolder OpenFolderUnderRoot(MapiStore mailbox, string folderName, bool createIfMissing) { MapiFolder result; using (MapiFolder nonIpmSubtreeFolder = mailbox.GetNonIpmSubtreeFolder()) { MapiFolder mapiFolder = null; try { mapiFolder = nonIpmSubtreeFolder.OpenSubFolderByName(folderName); } catch (MapiExceptionNotFound) { } if (mapiFolder == null && createIfMissing) { MrsTracer.Common.Debug("Folder '{0}' does not exist, creating it.", new object[] { folderName }); try { mapiFolder = nonIpmSubtreeFolder.CreateFolder(folderName, null, false); MrsTracer.Common.Debug("Created '{0}' folder.", new object[] { folderName }); } catch (MapiExceptionCollision) { MrsTracer.Common.Debug("Somebody beat us to creating the folder. Will attempt to open it.", new object[0]); } if (mapiFolder == null) { mapiFolder = nonIpmSubtreeFolder.OpenSubFolderByName(folderName); MrsTracer.Common.Debug("Opened '{0}' folder.", new object[] { folderName }); } } result = mapiFolder; } return(result); }
void IDestinationMailbox.DeleteFolder(FolderRec folderRec) { MrsTracer.Provider.Function("MapiDestinationMailbox.DeleteFolder(\"{0}\")", new object[] { folderRec.FolderName }); base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None); OpenEntryFlags flags = OpenEntryFlags.DeferredErrors | OpenEntryFlags.Modify; using (base.RHTracker.Start()) { using (MapiFolder mapiFolder = (MapiFolder)base.MapiStore.OpenEntry(folderRec.ParentId, flags)) { mapiFolder.AllowWarnings = true; mapiFolder.DeleteFolder(folderRec.EntryId); } } }
void IDestinationMailbox.MoveFolder(byte[] folderId, byte[] oldParentId, byte[] newParentId) { MrsTracer.Provider.Function("MapiDestinationMailbox.MoveFolder", new object[0]); base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None); OpenEntryFlags flags = OpenEntryFlags.DeferredErrors | OpenEntryFlags.Modify; using (base.RHTracker.Start()) { using (MapiFolder mapiFolder = (MapiFolder)base.MapiStore.OpenEntry(oldParentId, flags)) { using (MapiFolder mapiFolder2 = (MapiFolder)base.MapiStore.OpenEntry(newParentId, flags)) { mapiFolder.AllowWarnings = true; mapiFolder.CopyFolder(CopyFolderFlags.FolderMove, mapiFolder2, folderId, null); } } } }
public void DeleteOldMessages() { using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(this.store, this.folderName, false)) { if (mapiFolder != null) { for (int i = 0; i < 100; i++) { byte[] array = this.FindMessageId(); if (array == null) { break; } mapiFolder.DeleteMessages(DeleteMessagesFlags.None, new byte[][] { array }); } } } }
public void DeleteMessage() { if (this.MessageId != null) { using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(this.store, this.folderName, false)) { if (mapiFolder != null) { mapiFolder.DeleteMessages(DeleteMessagesFlags.ForceHardDelete, new byte[][] { this.MessageId }); } } if (this.message != null) { this.message.Dispose(); this.message = null; } this.MessageId = null; this.FolderId = null; } }
public LocalizedString ComputePositionInQueue(Guid requestGuid) { int crows = 1000; int num = 0; int num2 = 0; if (requestGuid.Equals(Guid.Empty)) { return(MrsStrings.ErrorEmptyMailboxGuid); } using (MapiFolder requestJobsFolder = RequestJobXML.GetRequestJobsFolder(this.SystemMailbox)) { using (MapiTable contentsTable = requestJobsFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(this.SystemMailbox); contentsTable.SetColumns(requestJobNamedPropertySet.PropTags); SortOrder sortOrder = new SortOrder(requestJobNamedPropertySet.PropTags[7], SortFlags.Ascend); contentsTable.SortTable(sortOrder, SortTableFlags.None); Restriction restriction = Restriction.EQ(requestJobNamedPropertySet.PropTags[0], RequestStatus.Queued); contentsTable.Restrict(restriction); contentsTable.SeekRow(BookMark.Beginning, 0); PropValue[][] array = contentsTable.QueryRows(crows); bool flag = false; while (array != null && array.Length > 0) { int num3 = 0; if (!flag) { foreach (PropValue[] array3 in array) { num3++; if (num2 + num3 >= 10000) { break; } Guid value = MapiUtils.GetValue <Guid>(array3[26], Guid.Empty); if (requestGuid.Equals(value)) { flag = true; num = num2 + num3; break; } } } num2 += array.Length; if (num2 >= 10000) { break; } array = contentsTable.QueryRows(crows); } } } LocalizedString value2 = LocalizedString.Empty; LocalizedString value3 = LocalizedString.Empty; if (num == 0) { if (num2 < 10000) { value2 = MrsStrings.MoveRequestNotFoundInQueue; value3 = MrsStrings.PositionInteger(num2); } else { value2 = MrsStrings.PositionIntegerPlus(10000); value3 = MrsStrings.PositionIntegerPlus(10000); } } else { value2 = MrsStrings.PositionInteger(num); if (num2 < 10000) { value3 = MrsStrings.PositionInteger(num2); } else { value3 = MrsStrings.PositionIntegerPlus(num2); } } return(MrsStrings.PositionOfMoveRequestInSystemMailboxQueue(value2, value3)); }
void IDestinationMailbox.CreateFolder(FolderRec sourceFolder, CreateFolderFlags createFolderFlags, out byte[] newFolderId) { MrsTracer.Provider.Function("MapiDestinationMailbox.CreateFolder(\"{0}\")", new object[] { sourceFolder.FolderName }); base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None); if (createFolderFlags.HasFlag(CreateFolderFlags.InternalAccess)) { throw new InternalAccessFolderCreationIsNotSupportedException(); } FolderRec folderRec = null; newFolderId = null; using (base.RHTracker.Start()) { if (!createFolderFlags.HasFlag(CreateFolderFlags.FailIfExists) && sourceFolder.EntryId != null) { OpenEntryFlags flags = OpenEntryFlags.DontThrowIfEntryIsMissing; using (MapiFolder mapiFolder = (MapiFolder)base.MapiStore.OpenEntry(sourceFolder.EntryId, flags)) { if (mapiFolder != null) { folderRec = FolderRec.Create(mapiFolder, null); newFolderId = folderRec.EntryId; } } } if (newFolderId == null) { OpenEntryFlags flags2 = OpenEntryFlags.DeferredErrors | OpenEntryFlags.Modify; using (MapiFolder mapiFolder2 = (MapiFolder)base.MapiStore.OpenEntry(sourceFolder.ParentId, flags2)) { using (MapiFolder mapiFolder3 = mapiFolder2.CreateFolder(sourceFolder.FolderName, null, false, sourceFolder.FolderType == FolderType.Search, sourceFolder.EntryId)) { newFolderId = mapiFolder3.GetProp(PropTag.EntryId).GetBytes(); } goto IL_160; } } if (!CommonUtils.IsSameEntryId(folderRec.ParentId, sourceFolder.ParentId)) { MrsTracer.Provider.Debug("Existing folder is under the wrong parent. Moving it.", new object[0]); ((IDestinationMailbox)this).MoveFolder(folderRec.EntryId, folderRec.ParentId, sourceFolder.ParentId); } IL_160: PropTag[] promotedProperties = sourceFolder.GetPromotedProperties(); if ((promotedProperties != null && promotedProperties.Length > 0) || (sourceFolder.Restrictions != null && sourceFolder.Restrictions.Length > 0) || (sourceFolder.Views != null && sourceFolder.Views.Length > 0) || (sourceFolder.ICSViews != null && sourceFolder.ICSViews.Length > 0)) { using (MapiDestinationFolder folder = base.GetFolder <MapiDestinationFolder>(newFolderId)) { ICSViewData[] icsViews = null; if (this.ServerVersion >= Server.E15MinVersion) { icsViews = sourceFolder.ICSViews; } folder.SetExtendedProps(promotedProperties, sourceFolder.Restrictions, sourceFolder.Views, icsViews); } } } }
public TitaniumContentChangesFetcher(ISourceFolder folder, MapiFolder mapiFolder, MailboxProviderBase mailbox) { this.folder = folder; this.mapiFolder = mapiFolder; this.mailbox = mailbox; }
protected override MapiFxProxyPool.FolderEntry OpenFolder(byte[] folderID) { MapiFolder folder = (MapiFolder)this.destMailbox.OpenMapiEntry(folderID, folderID, OpenEntryFlags.Modify | OpenEntryFlags.DontThrowIfEntryIsMissing); return(MapiFxProxyPool.FolderEntry.Wrap(folder)); }
public void PickupJobs(out string failure) { string dbName = null; string scanFailure = null; failure = null; using (new DatabaseSettingsContext(this.MdbGuid, null).Activate()) { CommonUtils.CatchKnownExceptions(delegate { DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(this.MdbGuid, null, null, FindServerFlags.None); dbName = databaseInformation.DatabaseName; if (!databaseInformation.IsOnThisServer) { scanFailure = string.Format("MDB is mounted on remote server {0}", databaseInformation.ServerFqdn); MRSQueue.RemoveQueue(this.MdbGuid); return; } MrsTracer.Service.Debug("Picking up jobs from '{0}' ({1})", new object[] { dbName, this.MdbGuid }); using (MapiStore systemMailbox = MapiUtils.GetSystemMailbox(this.MdbGuid, false)) { using (MapiFolder requestJobsFolder = RequestJobXML.GetRequestJobsFolder(systemMailbox)) { using (MapiTable contentsTable = requestJobsFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { if (contentsTable.GetRowCount() > 0) { RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(systemMailbox); contentsTable.SetColumns(requestJobNamedPropertySet.PropTags); this.ProcessJobs(systemMailbox, contentsTable, requestJobNamedPropertySet); } } } } MrsTracer.Service.Debug("Pick up jobs from Mdb: '{0}' - complete.", new object[] { dbName }); }, delegate(Exception f) { if (dbName == null) { dbName = MrsStrings.MissingDatabaseName(this.MdbGuid).ToString(); } MrsTracer.Service.Debug("PickupJobs() failed for mdb '{0}'. Error: {1}", new object[] { dbName, CommonUtils.FullExceptionMessage(f) }); scanFailure = CommonUtils.FullExceptionMessage(f, true); MRSService.LogEvent(MRSEventLogConstants.Tuple_UnableToProcessJobsInDatabase, new object[] { dbName, CommonUtils.FullExceptionMessage(f) }); }); } failure = scanFailure; }
public static List <T> LoadAll(byte[] searchKey, Restriction additionalRestriction, Guid mdbGuid, MapiStore store, string folderName, MoveObjectInfo <T> .IsSupportedObjectTypeDelegate isSupportedObjectType, MoveObjectInfo <T> .EmptyTDelegate emptyT) { List <T> list = new List <T>(); using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(store, folderName, false)) { if (mapiFolder == null) { return(list); } using (MapiTable contentsTable = mapiFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { PropTag propTag = PropTag.ReplyTemplateID; contentsTable.SortTable(new SortOrder(propTag, SortFlags.Ascend), SortTableFlags.None); List <PropTag> list2 = new List <PropTag>(); list2.Add(PropTag.EntryId); list2.Add(propTag); Restriction restriction = null; if (searchKey != null) { restriction = Restriction.EQ(propTag, searchKey); } if (additionalRestriction != null) { if (restriction == null) { restriction = additionalRestriction; } else { restriction = Restriction.And(new Restriction[] { restriction, additionalRestriction }); } } foreach (PropValue[] array2 in MapiUtils.QueryAllRows(contentsTable, restriction, list2)) { byte[] bytes = array2[0].GetBytes(); byte[] bytes2 = array2[1].GetBytes(); OpenEntryFlags flags = OpenEntryFlags.Modify | OpenEntryFlags.DontThrowIfEntryIsMissing; using (MapiMessage mapiMessage = (MapiMessage)store.OpenEntry(bytes, flags)) { if (mapiMessage != null) { T t = default(T); if (isSupportedObjectType != null) { if (isSupportedObjectType(mapiMessage, store)) { t = MoveObjectInfo <T> .ReadObjectFromMessage(mapiMessage, false); } if (t == null && emptyT != null) { t = emptyT(bytes2); } } else { t = MoveObjectInfo <T> .ReadObjectFromMessage(mapiMessage, false); } if (t != null) { list.Add(t); } else { MrsTracer.Common.Error("Unable to deserialize message '{0}'.", new object[] { bytes }); } } } } } } return(list); }
public void SaveObjectChunks(List <T> chunks, int maxChunks, MoveObjectInfo <T> .GetAdditionalProperties getAdditionalPropertiesCallback) { if (chunks.Count > maxChunks) { MrsTracer.Common.Warning("Too many chunks supplied, truncating", new object[0]); chunks.RemoveRange(0, chunks.Count - maxChunks); } bool flag = false; if (this.message == null) { using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(this.store, this.folderName, true)) { this.FolderId = mapiFolder.GetProp(PropTag.EntryId).GetBytes(); this.message = mapiFolder.CreateMessage(); } this.message.SetProps(new PropValue[] { new PropValue(PropTag.MessageClass, this.messageClass), new PropValue(PropTag.Subject, this.subject), new PropValue(PropTag.ReplyTemplateID, this.searchKey) }); flag = true; } if (chunks.Count > 1) { using (MapiTable attachmentTable = this.message.GetAttachmentTable()) { if (attachmentTable != null) { int num = attachmentTable.GetRowCount() - (maxChunks - chunks.Count); if (num > 0) { attachmentTable.SetColumns(MoveObjectInfo <T> .AttachmentTagsToLoad); PropValue[][] array = attachmentTable.QueryRows(num); for (int i = 0; i < num; i++) { this.message.DeleteAttach(array[i][0].GetInt()); } } } } for (int j = 0; j < chunks.Count - 1; j++) { int num2; using (MapiAttach mapiAttach = this.message.CreateAttach(out num2)) { using (MapiStream mapiStream = mapiAttach.OpenStream(PropTag.AttachDataBin, OpenPropertyFlags.Create)) { MoveObjectInfo <T> .SerializeToStream(chunks[j], mapiStream); } mapiAttach.SetProps(new PropValue[] { new PropValue(PropTag.AttachFileName, string.Format("MOI_Chunk_{0:yyyymmdd_HHmmssfff}", DateTime.UtcNow)), new PropValue(PropTag.AttachMethod, AttachMethods.ByValue) }); mapiAttach.SaveChanges(); } } } T obj = chunks[chunks.Count - 1]; if (getAdditionalPropertiesCallback != null) { this.message.SetProps(getAdditionalPropertiesCallback(this.store)); } using (MapiStream mapiStream2 = this.message.OpenStream(PropTag.Body, OpenPropertyFlags.Create)) { MoveObjectInfo <T> .SerializeToStream(obj, mapiStream2); } this.message.SaveChanges(); if (flag) { this.MessageId = this.message.GetProp(PropTag.EntryId).GetBytes(); } }
internal override void Config(byte[] folderId, MapiFolder folder, MapiMailbox mailbox) { base.Config(folderId, folder, mailbox); base.Folder.AllowWarnings = true; }