public static AggregateOperationResult DeleteOutlookSearchFolder(DeleteItemFlags deleteItemFlags, MailboxSession session, StoreId outlookSearchFolderId)
{
EnumValidator.ThrowIfInvalid <DeleteItemFlags>(deleteItemFlags);
VersionedId versionedId;
using (OutlookSearchFolder outlookSearchFolder = OutlookSearchFolder.Bind(session, outlookSearchFolderId))
{
versionedId = OutlookSearchFolder.FindAssociatedMessageId((MailboxSession)outlookSearchFolder.Session, (Guid)outlookSearchFolder[InternalSchema.OutlookSearchFolderClsId]);
}
StoreId[] ids;
if (versionedId != null)
{
ids = new StoreId[]
{
outlookSearchFolderId,
versionedId
};
}
else
{
ids = new StoreId[]
{
outlookSearchFolderId
};
}
return(session.Delete(deleteItemFlags, ids));
}
public override void Delete(StoreId id, DeleteItemFlags flags)
{
using (ICalendarGroup calendarGroup = this.Bind(id))
{
CalendarGroupType groupType = calendarGroup.GroupType;
if (groupType == CalendarGroupType.MyCalendars || groupType == CalendarGroupType.OtherCalendars)
{
throw new CannotDeleteSpecialCalendarGroupException(calendarGroup.Id, calendarGroup.GroupClassId, calendarGroup.GroupName);
}
ReadOnlyCollection <CalendarGroupEntryInfo> childCalendars = calendarGroup.GetChildCalendars();
List <StoreId> list = new List <StoreId>();
foreach (CalendarGroupEntryInfo calendarGroupEntryInfo in childCalendars)
{
if (calendarGroupEntryInfo is LocalCalendarGroupEntryInfo)
{
throw new CalendarGroupIsNotEmptyException(calendarGroup.Id, calendarGroup.GroupClassId, calendarGroup.GroupName, childCalendars.Count);
}
list.Add(calendarGroupEntryInfo.Id);
}
foreach (StoreId id2 in list)
{
base.Delete(id2, flags);
}
}
base.Delete(id, flags);
}
public override void Delete(StoreId id, DeleteItemFlags flags)
{
base.Delete(id, flags);
StoreObjectId storeObjectId = StoreId.GetStoreObjectId(id);
if (storeObjectId is OccurrenceStoreObjectId)
{
this.TryLogCalendarEventActivity(ActivityId.UpdateCalendarEvent, storeObjectId);
}
}
protected virtual bool CleanUpDeclinedEvent(StoreId id)
{
if (this.Parameters.Response == ResponseType.Declined)
{
DeleteItemFlags deleteItemFlags = DeleteItemFlags.MoveToDeletedItems;
deleteItemFlags |= (this.Parameters.SendResponse ? DeleteItemFlags.DeclineCalendarItemWithResponse : DeleteItemFlags.DeclineCalendarItemWithoutResponse);
this.Scope.EventDataProvider.Delete(id, deleteItemFlags);
return(true);
}
return(false);
}
public override void Delete(StoreId id, DeleteItemFlags flags)
{
try
{
base.Delete(id, flags);
}
catch (CannotMoveDefaultFolderException innerException)
{
throw new CannotDeleteDefaultCalendarException(innerException);
}
}
public static void DeleteCalendarItem(StoreObjectId calendarItemId, DeleteItemFlags deleteFlag)
{
if (calendarItemId == null)
{
throw new ArgumentNullException("calendarItemId");
}
UserContext userContext = UserContextManager.GetUserContext();
using (CalendarItemBase calendarItemBase = (CalendarItemBase)Item.Bind(userContext.MailboxSession, calendarItemId, ItemBindOption.LoadRequiredPropertiesOnly))
{
calendarItemBase.DeleteMeeting(deleteFlag);
}
}
// Token: 0x06001565 RID: 5477 RVA: 0x0007DE00 File Offset: 0x0007C000
protected void DeleteMessage(MessageItem message, DeleteItemFlags deletedItemFlag = DeleteItemFlags.HardDelete)
{
message.Load();
if (message.Id != null)
{
AggregateOperationResult aggregateOperationResult = base.MailboxSession.Delete(deletedItemFlag, new StoreId[]
{
message.Id.ObjectId
});
if (OperationResult.Succeeded != aggregateOperationResult.OperationResult)
{
AirSyncDiagnostics.TraceDebug <MessageItem>(ExTraceGlobals.RequestsTracer, this, "Failed to delete {0}", message);
}
}
}
private static void ProcessCalendarItemAfterResponse(ResponseType responseType, CalendarItemBase calendarItemBase, bool intendToSendResponse)
{
UserContext userContext = UserContextManager.GetUserContext();
if (responseType != ResponseType.Decline)
{
if (Utilities.IsItemInDefaultFolder(calendarItemBase, DefaultFolderType.DeletedItems))
{
StoreObjectId[] ids = new StoreObjectId[]
{
calendarItemBase.Id.ObjectId
};
userContext.MailboxSession.Move(userContext.CalendarFolderId, ids);
}
if (Globals.ArePerfCountersEnabled)
{
OwaSingleCounters.ItemsUpdated.Increment();
return;
}
}
else
{
try
{
DeleteItemFlags deleteItemFlags = intendToSendResponse ? DeleteItemFlags.DeclineCalendarItemWithResponse : DeleteItemFlags.DeclineCalendarItemWithoutResponse;
if (Utilities.IsItemInDefaultFolder(calendarItemBase, DefaultFolderType.DeletedItems))
{
deleteItemFlags |= DeleteItemFlags.SoftDelete;
}
else
{
deleteItemFlags |= DeleteItemFlags.MoveToDeletedItems;
}
Utilities.Delete(userContext, deleteItemFlags, new OwaStoreObjectId[]
{
OwaStoreObjectId.CreateFromStoreObject(calendarItemBase)
});
}
catch (StoragePermanentException ex)
{
ExTraceGlobals.CalendarTracer.TraceDebug <string>(0L, "Exception on delete calendar item: {0}'", ex.Message);
throw;
}
}
}
public void ItemOperation(COWSettings settings, IDumpsterItemOperations dumpster, COWTriggerAction operation, COWTriggerActionState state, StoreSession session, StoreObjectId itemId, CoreItem item, CoreFolder folder, bool onBeforeNotification, OperationResult result, CallbackContext callbackContext)
{
Util.ThrowOnNullArgument(session, "session");
EnumValidator.ThrowIfInvalid <COWTriggerAction>(operation, "operation");
EnumValidator.ThrowIfInvalid <COWTriggerActionState>(state, "state");
EnumValidator.ThrowIfInvalid <OperationResult>(result, "result");
Util.ThrowOnNullArgument(item, "item");
MailboxSession mailboxSession = session as MailboxSession;
ExDateTime now = ExDateTime.Now;
try
{
item.PropertyBag.Load(COWSiteMailboxMessageDedup.PropsForMessageRemoval);
if (item.Id != null && item.Id.ObjectId != null)
{
StoreObjectId storeObjectId = item.PropertyBag.TryGetProperty(StoreObjectSchema.ParentItemId) as StoreObjectId;
if (storeObjectId != null)
{
using (CoreFolder coreFolder = CoreFolder.Bind(session, storeObjectId))
{
DeleteItemFlags deleteItemFlags = DeleteItemFlags.HardDelete | DeleteItemFlags.SuppressReadReceipt;
coreFolder.DeleteItems(deleteItemFlags, new StoreObjectId[]
{
item.Id.ObjectId
});
}
COWSiteMailboxMessageDedup.Tracer.TraceDebug <StoreObjectId, string, double>((long)this.GetHashCode(), "COWSiteMailboxMessageDedup.ItemOperation: deleting message {0} from site mailbox {1} used {2} milliseconds", itemId, mailboxSession.DisplayName, (ExDateTime.Now - now).TotalMilliseconds);
}
}
}
catch (StoragePermanentException arg)
{
COWSiteMailboxMessageDedup.Tracer.TraceError <StoragePermanentException>((long)this.GetHashCode(), "COWSiteMailboxMessageDedup.ItemOperation: got store permanent exception: {0}", arg);
}
catch (StorageTransientException arg2)
{
COWSiteMailboxMessageDedup.Tracer.TraceError <StorageTransientException>((long)this.GetHashCode(), "COWSiteMailboxMessageDedup.ItemOperation: got store transient exception: {0}", arg2);
}
callbackContext.SiteMailboxMessageDedupState = COWProcessorState.Processed;
}
internal virtual void Delete(DeleteItemFlags deleteItemFlags)
{
ExTraceGlobals.DefaultFoldersTracer.TraceDebug <DefaultFolder>((long)this.GetHashCode(), "DefaultFolder::Delete. The default folder is about to be deleted. defaultFolder = {0}.", this);
EnumValidator.ThrowIfInvalid <DeleteItemFlags>(deleteItemFlags, "deleteItemFlags");
EnumValidator.ThrowIfInvalid <DefaultFolderType>(this.defaultFolderInfo.DefaultFolderType, DefaultFolder.DefaultFoldersThatCanBeDeleted);
StoreObjectId storeObjectId;
if (!this.TryGetFolderId(out storeObjectId))
{
throw new InvalidOperationException(string.Format("Cannot delete the default folder {0}, because it does not exist.", this.defaultFolderInfo.DefaultFolderType));
}
this.defaultFolderInfo.EntryIdStrategy.UnsetEntryId(this.context);
DefaultFolderData defaultFolderData = this.GetDefaultFolderData();
AggregateOperationResult aggregateOperationResult = this.defaultFolderInfo.FolderCreator.Delete(this.context, deleteItemFlags, defaultFolderData.FolderId);
if (aggregateOperationResult.OperationResult != OperationResult.Succeeded)
{
throw new AggregateOperationFailedException(ServerStrings.ExFailedToDeleteDefaultFolder, aggregateOperationResult);
}
this.defaultFolderInfo.EntryIdStrategy.UnsetEntryId(this.context);
this.SetDefaultFolderData(new DefaultFolderData(null));
}
public override void Delete(StoreId id, DeleteItemFlags flags)
{
AggregateOperationResult aggregateOperationResult;
try
{
TSession session = base.Session;
aggregateOperationResult = session.Delete(flags, new StoreId[]
{
id
});
}
catch (ObjectNotFoundException innerException)
{
throw new AccessDeniedException(Strings.ErrorAccessDenied, innerException);
}
if (aggregateOperationResult.OperationResult == OperationResult.Failed)
{
GroupOperationResult groupOperationResult = aggregateOperationResult.GroupOperationResults.First((GroupOperationResult singleResult) => singleResult.OperationResult == OperationResult.Failed);
throw groupOperationResult.Exception;
}
}
public void EmptyFolder()
{
OwaStoreObjectId owaStoreObjectId = (OwaStoreObjectId)base.GetParameter("id");
if (Utilities.IsDefaultFolderId(base.UserContext, owaStoreObjectId, DefaultFolderType.SearchFolders))
{
throw new OwaInvalidRequestException("Cannot perform empty folder on Search Folder Root");
}
using (Folder folderForContent = Utilities.GetFolderForContent <Folder>(base.UserContext, owaStoreObjectId, new PropertyDefinition[]
{
FolderSchema.IsOutlookSearchFolder
}))
{
if (!Utilities.IsOutlookSearchFolder(folderForContent))
{
DeleteItemFlags flags = owaStoreObjectId.IsPublic ? DeleteItemFlags.SoftDelete : DeleteItemFlags.MoveToDeletedItems;
OperationResult operationResult = folderForContent.DeleteAllItems(flags).OperationResult;
if (operationResult != OperationResult.Succeeded)
{
throw new OwaAccessDeniedException(LocalizedStrings.GetNonEncoded(166628739));
}
}
}
}
internal void ImportDeletes(DeleteItemFlags deleteItemFlags, byte[][] sourceKeys)
{
this.CheckDisposed(null);
Util.ThrowOnNullArgument(sourceKeys, "sourceKeys");
ImportDeletionFlags importDeletionFlags = ((deleteItemFlags & DeleteItemFlags.HardDelete) == DeleteItemFlags.HardDelete) ? ImportDeletionFlags.HardDelete : ImportDeletionFlags.None;
PropValue[] array = new PropValue[sourceKeys.Length];
for (int i = 0; i < sourceKeys.Length; i++)
{
array[i] = new PropValue(PropTag.SourceKey, sourceKeys[i]);
}
StoreSession session = this.Session;
bool flag = false;
try
{
if (session != null)
{
session.BeginMapiCall();
session.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
this.MapiImportDeletes(importDeletionFlags, array);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotImportDeletion, ex, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("Import of object deletions failed", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotImportDeletion, ex2, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("Import of object deletions failed", new object[0]),
ex2
});
}
finally
{
try
{
if (session != null)
{
session.EndMapiCall();
if (flag)
{
session.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
}
public void DeleteDefaultFolder(DefaultFolderType defaultFolderType, DeleteItemFlags deleteItemFlags)
{
throw new NotImplementedException();
}
public AggregateOperationResult Delete(StoreObjectId contextFolderId, DateTime?actionTime, DeleteItemFlags deleteFlags)
{
return(this.Delete(contextFolderId, actionTime, deleteFlags, false));
}
internal override AggregateOperationResult Delete(DefaultFolderContext context, DeleteItemFlags deleteItemFlags, StoreObjectId id)
{
throw new NotSupportedException("The defaultFolder does not support deletion.");
}
internal virtual AggregateOperationResult Delete(DefaultFolderContext context, DeleteItemFlags deleteItemFlags, StoreObjectId id)
{
if (this.storeObjectType == StoreObjectType.OutlookSearchFolder)
{
return(OutlookSearchFolder.DeleteOutlookSearchFolder(deleteItemFlags, context.Session, id));
}
return(context.Session.Delete(deleteItemFlags, new StoreId[]
{
id
}));
}
// Token: 0x06001575 RID: 5493 RVA: 0x0007E438 File Offset: 0x0007C638
internal override Command.ExecutionState ExecuteCommand()
{
MessageItem messageItem = null;
bool flag = false;
DeleteItemFlags deletedItemFlag = DeleteItemFlags.HardDelete;
try
{
base.ValidateBody();
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts);
messageItem = MessageItem.Create(base.MailboxSession, defaultFolderId);
base.ParseMimeToMessage(messageItem);
Guid guid;
if (base.IsIrmOperation(out guid))
{
RmsTemplate rmsTemplate = RmsTemplateReaderCache.LookupRmsTemplate(base.User.OrganizationId, guid);
if (rmsTemplate == null)
{
AirSyncDiagnostics.TraceError <Guid>(ExTraceGlobals.RequestsTracer, this, "Template {0} not found in cache", guid);
throw new AirSyncPermanentException(StatusCode.IRM_InvalidTemplateID, false)
{
ErrorStringForProtocolLogger = "smcEInvalidTemplateID"
};
}
messageItem = RightsManagedMessageItem.Create(messageItem, AirSyncUtility.GetOutboundConversionOptions());
RightsManagedMessageItem rightsManagedMessageItem = messageItem as RightsManagedMessageItem;
rightsManagedMessageItem.SetRestriction(rmsTemplate);
rightsManagedMessageItem.Sender = new Participant(base.MailboxSession.MailboxOwner);
}
Command.CurrentCommand.ProtocolLogger.SetValue(ProtocolLoggerData.ClassName, messageItem.ClassName);
if (!GlobalSettings.OnlyOrganizersCanSendMeetingChanges || !this.IsMeetingRelatedMessage(messageItem))
{
base.SendMessage(messageItem);
flag = true;
}
else
{
bool flag2 = this.CanSendMessage(messageItem);
if (GlobalSettings.GetGoidFromCalendarItemForMeetingResponse && base.Version < 160 && this.IsResponseMessageToSingleMeeting(messageItem))
{
GlobalObjectId goidFromItem = this.GetGoidFromItem(messageItem);
try
{
ResponseType valueOrDefault = messageItem.GetValueOrDefault <ResponseType>(MeetingResponseSchema.ResponseType);
DefaultFolderType defaultFolderType = (valueOrDefault == ResponseType.Decline) ? DefaultFolderType.DeletedItems : DefaultFolderType.Calendar;
List <PropertyBag> list = this.QueryRelatedCalendarItems(defaultFolderType, goidFromItem);
if (list.Count == 0 && valueOrDefault == ResponseType.Decline)
{
list = this.QueryRelatedCalendarItems(DefaultFolderType.Calendar, goidFromItem);
if (list.Count == 0)
{
list = this.QueryRelatedCalendarItems(DefaultFolderType.DeletedItems, goidFromItem);
}
}
this.FindAndSetMessageGoid(list, messageItem, goidFromItem);
}
catch (Exception ex)
{
AirSyncDiagnostics.TraceError <Exception>(ExTraceGlobals.RequestsTracer, this, "GetRelatedCalendarItemGoid threw exception {0}", ex);
AirSyncDiagnostics.SendInMemoryTraceWatson(ex);
}
}
if (flag2)
{
base.SendMessage(messageItem);
flag = true;
}
else
{
AirSyncDiagnostics.TraceDebug <Participant>(ExTraceGlobals.RequestsTracer, this, "Attempt to send meeting cancellation by attendee. Sender {0}", messageItem.Sender);
messageItem.ClassName = "IPM.Note";
messageItem.Save(SaveMode.NoConflictResolution);
deletedItemFlag = DeleteItemFlags.MoveToDeletedItems;
Command.CurrentCommand.ProtocolLogger.SetValue(ProtocolLoggerData.SkipSend, true.ToString());
}
}
}
finally
{
if (messageItem != null)
{
if (!flag)
{
base.DeleteMessage(messageItem, deletedItemFlag);
}
messageItem.Dispose();
}
}
return(Command.ExecutionState.Complete);
}
public AggregateOperationResult Delete(StoreObjectId contextFolderId, DateTime?actionTime, DeleteItemFlags deleteFlags, bool returnNewItemIds)
{
EnumValidator.ThrowIfInvalid <DeleteItemFlags>(deleteFlags, "deleteFlags");
List <StoreObjectId> filteredItemIds = this.GetFilteredItemIds(contextFolderId, actionTime, null);
return(this.session.Delete(deleteFlags, returnNewItemIds, filteredItemIds.ToArray()));
}
internal static void DeleteRelatedMessage(this IEventInternal entity, string messageId, DeleteItemFlags flags, IXSOFactory xsoFactory, IdConverter idConverter, IStoreSession session, bool markAsReadBeforeDelete)
{
StoreObjectId storeObjectId = idConverter.ToStoreObjectId(messageId);
using (IMeetingMessage meetingMessage = xsoFactory.BindToMeetingMessage(session, storeObjectId))
{
if (meetingMessage == null || meetingMessage.GlobalObjectId == null || meetingMessage.GlobalObjectId.ToString() != entity.GlobalObjectId)
{
throw new InvalidRequestException(CalendaringStrings.ErrorMeetingMessageNotFoundOrCantBeUsed);
}
if (markAsReadBeforeDelete)
{
meetingMessage.OpenAsReadWrite();
meetingMessage.IsRead = true;
meetingMessage.Save(SaveMode.NoConflictResolutionForceSave);
}
}
session.Delete(flags, new StoreId[]
{
storeObjectId
});
}
internal void DeleteDefaultFolder(DefaultFolderType defaultFolderType, DeleteItemFlags deleteItemFlags)
{
this.GetDefaultFolder(defaultFolderType).Delete(deleteItemFlags);
}
public override void Delete(string attachmentId, DeleteItemFlags flags)
{
this.Delete(attachmentId, null);
}
public abstract void Delete(TId id, DeleteItemFlags flags);
public void Delete()
{
ExTraceGlobals.CalendarCallTracer.TraceDebug((long)this.GetHashCode(), "CalendarViewEventHandler.Delete");
OwaStoreObjectId owaStoreObjectId = (OwaStoreObjectId)base.GetParameter("Id");
OwaStoreObjectId owaStoreObjectId2 = (OwaStoreObjectId)base.GetParameter("fId");
Item item = null;
CalendarItemBase calendarItemBase = null;
bool flag = true;
try
{
item = Utilities.GetItem <Item>(base.UserContext, owaStoreObjectId, new PropertyDefinition[]
{
StoreObjectSchema.EffectiveRights,
CalendarItemBaseSchema.MeetingRequestWasSent,
CalendarItemBaseSchema.IsOrganizer
});
calendarItemBase = (item as CalendarItemBase);
if (calendarItemBase != null)
{
if (!CalendarUtilities.UserCanDeleteCalendarItem(calendarItemBase) || Utilities.IsItemInExternalSharedInFolder(base.UserContext, calendarItemBase))
{
base.ResponseContentType = OwaEventContentType.Html;
this.Writer.Write("<div id=divOp _sOp=np></div>");
flag = false;
}
else if (!base.IsParameterSet("FD") && calendarItemBase.IsMeeting && calendarItemBase.MeetingRequestWasSent && calendarItemBase.IsOrganizer())
{
base.ResponseContentType = OwaEventContentType.Html;
this.Writer.Write("<div id=divOp _sOp=sc></div>");
flag = false;
}
else if (!base.IsParameterSet("FD") && !calendarItemBase.IsOrganizer() && !calendarItemBase.IsCancelled && !MeetingUtilities.IsCalendarItemEndTimeInPast(calendarItemBase))
{
base.ResponseContentType = OwaEventContentType.Html;
this.Writer.Write("<div id=divOp _sOp=sr></div>");
flag = false;
}
else if (!base.IsParameterSet("FD") && (owaStoreObjectId2.IsOtherMailbox || owaStoreObjectId2.IsGSCalendar))
{
base.ResponseContentType = OwaEventContentType.Html;
this.Writer.Write("<div id=divOp _sOp=sn></div>");
flag = false;
}
}
else if (!ItemUtility.UserCanDeleteItem(item))
{
base.ResponseContentType = OwaEventContentType.Html;
this.Writer.Write("<div id=divOp _sOp=np></div>");
flag = false;
}
if (flag)
{
bool flag2 = false;
if (base.IsParameterSet("Ntfy"))
{
flag2 = (bool)base.GetParameter("Ntfy");
}
if (flag2)
{
PrincipalNotificationMessage principalNotificationMessage = new PrincipalNotificationMessage(owaStoreObjectId.ToBase64String(), owaStoreObjectId2, base.UserContext, this.HttpContext, PrincipalNotificationMessage.ActionType.Delete, false, calendarItemBase.IsMeeting);
principalNotificationMessage.SendNotificationMessage();
}
bool flag3 = false;
if (base.IsParameterSet("Prm"))
{
flag3 = (bool)base.GetParameter("Prm");
}
DeleteItemFlags deleteItemFlags = DeleteItemFlags.None;
if (!owaStoreObjectId2.IsPublic)
{
if (calendarItemBase.IsOrganizer())
{
if (calendarItemBase.IsMeeting)
{
goto IL_269;
}
deleteItemFlags = DeleteItemFlags.CancelCalendarItem;
MeetingCancellation meetingCancellation = null;
try
{
try
{
calendarItemBase.OpenAsReadWrite();
meetingCancellation = calendarItemBase.CancelMeeting(null, null);
}
catch (ObjectNotFoundException)
{
}
catch (AccessDeniedException)
{
}
goto IL_269;
}
finally
{
if (meetingCancellation != null)
{
meetingCancellation.Dispose();
}
meetingCancellation = null;
}
}
deleteItemFlags = DeleteItemFlags.DeclineCalendarItemWithoutResponse;
}
IL_269:
calendarItemBase.DeleteMeeting((flag3 ? DeleteItemFlags.SoftDelete : DeleteItemFlags.MoveToDeletedItems) | deleteItemFlags);
this.RenderPayload(new OwaStoreObjectId[]
{
owaStoreObjectId2
});
}
}
catch (ObjectNotFoundException)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug((long)this.GetHashCode(), "Calendar item could not be found.");
throw;
}
finally
{
if (item != null)
{
item.Dispose();
item = null;
}
}
}
public virtual AggregateOperationResult DeleteObjects(DeleteItemFlags deleteFlags, params StoreId[] ids)
{
throw new NotImplementedException();
}
