internal static ConversationActionItem Create(MailboxSession session, ConversationId conversationId, string conversationTopic)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(conversationId, "conversationId");
Util.ThrowOnNullArgument(conversationTopic, "conversationTopic");
return(ConversationActionItem.InternalCreate(session, conversationId, conversationTopic));
}
public static StoreId QueryConversationActionsFolder(MailboxSession session, ConversationId conversationId)
{
IList <StoreId> list = ConversationActionItem.QueryConversationActionsFolder(session, conversationId, 1);
if (list == null)
{
return(null);
}
return(list[0]);
}
private int UpdateItems(IConversationTree conversationTree, List <GroupOperationResult> results)
{
int num = 0;
foreach (IConversationTreeNode conversationTreeNode in conversationTree)
{
for (int i = 0; i < conversationTreeNode.StorePropertyBags.Count; i++)
{
if (!this.CanSkipProcessing(conversationTreeNode.StorePropertyBags[i]))
{
StoreId storeId = conversationTreeNode.StorePropertyBags[i].TryGetProperty(ItemSchema.Id) as StoreId;
List <string> list = null;
if (ConversationActionItem.MergeCategories(conversationTreeNode.StorePropertyBags[i].TryGetProperty(ItemSchema.Categories) as string[], this.AlwaysCategorizeValue, this.ConversationActionLastCategorySet, out list))
{
try
{
using (Item item = Microsoft.Exchange.Data.Storage.Item.Bind(base.Session, storeId, null))
{
num++;
item.OpenAsReadWrite();
if (list.Count == 0)
{
item.Delete(ItemSchema.Categories);
}
else
{
item[ItemSchema.Categories] = list.ToArray();
}
item.Save(SaveMode.ResolveConflicts);
results.Add(new GroupOperationResult(OperationResult.Succeeded, new StoreObjectId[]
{
StoreId.GetStoreObjectId(storeId)
}, null));
}
}
catch (LocalizedException storageException)
{
results.Add(new GroupOperationResult(OperationResult.Failed, new StoreObjectId[]
{
StoreId.GetStoreObjectId(storeId)
}, storageException));
}
}
}
}
}
if (ConversationActionItem.NeedToAddCategory(this.ConversationActionLastCategorySet, this.AlwaysCategorizeValue))
{
this.ConversationActionLastCategorySet = this.AlwaysCategorizeValue;
}
return(num);
}
private static bool MergeCategories(IList <string> messageCategories, IList <string> categoriesCurrent, IList <string> categoriesPrev, out List <string> mergedCategories)
{
mergedCategories = null;
categoriesCurrent = ((categoriesCurrent == null) ? new List <string>() : categoriesCurrent);
categoriesPrev = ((categoriesPrev == null) ? new List <string>() : categoriesPrev);
messageCategories = ((messageCategories == null) ? new List <string>() : messageCategories);
IEnumerable <string> second = categoriesCurrent.Except(categoriesPrev, Category.NameComparer);
IEnumerable <string> second2 = categoriesPrev.Except(categoriesCurrent, Category.NameComparer);
IEnumerable <string> collection = messageCategories.Except(second2).Union(second);
mergedCategories = new List <string>(collection);
return(ConversationActionItem.NeedToAddCategory(mergedCategories, messageCategories));
}
private ConversationActionItem GetAssociatedActionItem()
{
ConversationActionItem result = null;
try
{
result = ConversationActionItem.Bind(this.session, this.ConversationId);
}
catch (ObjectNotFoundException)
{
string conversationTopic = (this.Topic == null) ? string.Empty : this.Topic;
result = ConversationActionItem.Create(this.session, this.ConversationId, conversationTopic);
}
return(result);
}
public AggregateOperationResult AlwaysClutterOrUnclutter(bool?clutterOrUnclutter, bool processItems)
{
AggregateOperationResult result = null;
using (ConversationActionItem associatedActionItem = this.GetAssociatedActionItem())
{
associatedActionItem.AlwaysClutterOrUnclutterValue = clutterOrUnclutter;
if (clutterOrUnclutter != null && processItems)
{
result = associatedActionItem.ProcessItems(ConversationAction.AlwaysClutterOrUnclutter, this);
}
associatedActionItem.Save(SaveMode.ResolveConflicts);
}
return(result);
}
public AggregateOperationResult AlwaysCategorize(string[] categories, bool processItems)
{
AggregateOperationResult result = null;
using (ConversationActionItem associatedActionItem = this.GetAssociatedActionItem())
{
associatedActionItem.AlwaysCategorizeValue = categories;
if (categories != null && processItems)
{
result = associatedActionItem.ProcessItems(ConversationAction.AlwaysCategorize, this);
}
associatedActionItem.Save(SaveMode.ResolveConflicts);
}
return(result);
}
public AggregateOperationResult AlwaysMove(StoreObjectId folderId, bool processItems)
{
AggregateOperationResult result = null;
using (ConversationActionItem associatedActionItem = this.GetAssociatedActionItem())
{
associatedActionItem.AlwaysMoveValue = folderId;
if (folderId != null && processItems)
{
result = associatedActionItem.ProcessItems(ConversationAction.AlwaysMove, this);
}
associatedActionItem.Save(SaveMode.ResolveConflicts);
}
return(result);
}
public AggregateOperationResult AlwaysDelete(bool enable, bool processItems)
{
AggregateOperationResult result = null;
using (ConversationActionItem associatedActionItem = this.GetAssociatedActionItem())
{
associatedActionItem.AlwaysDeleteValue = enable;
associatedActionItem.ConversationActionMaxDeliveryTime = ExDateTime.MinValue;
if (enable && processItems)
{
result = associatedActionItem.ProcessItems(ConversationAction.AlwaysDelete, this);
}
associatedActionItem.Save(SaveMode.ResolveConflicts);
}
return(result);
}
private static ConversationActionItem InternalCreate(MailboxSession session, ConversationId conversationId, string conversationTopic)
{
StoreId conversationActionsFolderId = ConversationActionItem.GetConversationActionsFolderId(session, true);
if (conversationActionsFolderId == null)
{
throw new NotSupportedException("Failed to get conversation actions folder");
}
ConversationActionItem conversationActionItem = ItemBuilder.CreateNewItem <ConversationActionItem>(session, conversationActionsFolderId, ItemCreateInfo.ConversationActionInfo, CreateMessageType.Associated);
conversationActionItem[ItemSchema.ConversationTopic] = conversationTopic;
conversationActionItem[ItemSchema.Subject] = conversationTopic;
conversationActionItem[StoreObjectSchema.ItemClass] = "IPM.ConversationAction";
conversationActionItem[ItemSchema.ConversationId] = conversationId;
conversationActionItem.SetExpiration();
conversationActionItem[ConversationActionItemSchema.ConversationActionVersion] = ConversationActionItem.MakeVersion();
return(conversationActionItem);
}
public static ConversationActionItem Bind(MailboxSession session, StoreId itemId)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(itemId, "itemId");
StoreId storeId = itemId;
if (storeId is ConversationId)
{
storeId = ConversationActionItem.QueryConversationActionsFolder(session, (ConversationId)storeId);
if (storeId == null)
{
throw new ObjectNotFoundException(ServerStrings.ExConversationActionItemNotFound);
}
}
ConversationActionItem conversationActionItem = ItemBuilder.ItemBind <ConversationActionItem>(session, storeId, ConversationActionItemSchema.Instance, null);
if (!conversationActionItem.IsCorrectVersion())
{
conversationActionItem.Dispose();
throw new ObjectNotFoundException(new LocalizedString("Invalid Conversation Action Item Version"));
}
return(conversationActionItem);
}
public static IList <StoreId> QueryConversationActionsFolder(MailboxSession session, ConversationId conversationId, int maxRowCount, out int totalActionItemCount)
{
totalActionItemCount = 0;
StoreId conversationActionsFolderId = ConversationActionItem.GetConversationActionsFolderId(session, false);
if (conversationActionsFolderId == null)
{
return(null);
}
IList <StoreId> result;
try
{
using (Folder folder = Folder.Bind(session, conversationActionsFolderId))
{
int?valueAsNullable = folder.GetValueAsNullable <int>(FolderSchema.AssociatedItemCount);
if (valueAsNullable != null && valueAsNullable <= 0)
{
result = null;
}
else
{
totalActionItemCount = ((valueAsNullable != null) ? valueAsNullable.Value : 0);
if (conversationId == null)
{
result = null;
}
else
{
SortBy[] sortColumns = new SortBy[]
{
new SortBy(ItemSchema.ConversationIndex, SortOrder.Ascending),
new SortBy(StoreObjectSchema.LastModifiedTime, SortOrder.Descending)
};
ConversationIndex conversationIndex = ConversationActionItem.GetConversationIndex(conversationId);
using (QueryResult queryResult = folder.ItemQuery(ItemQueryType.Associated, null, sortColumns, new PropertyDefinition[]
{
ItemSchema.ConversationIndex,
ItemSchema.Id,
ConversationActionItemSchema.ConversationActionVersion
}))
{
if (queryResult.SeekToCondition(SeekReference.OriginBeginning, new ComparisonFilter(ComparisonOperator.Equal, ItemSchema.ConversationIndex, conversationIndex.ToByteArray())))
{
IStorePropertyBag[] propertyBags = queryResult.GetPropertyBags(maxRowCount);
if (propertyBags.Length >= 1)
{
List <StoreId> list = new List <StoreId>();
for (int i = 0; i < propertyBags.Length; i++)
{
byte[] array = propertyBags[i][ItemSchema.ConversationIndex] as byte[];
if (array != null)
{
ConversationIndex conversationIndex2;
bool flag = ConversationIndex.TryCreate(array, out conversationIndex2);
if (flag)
{
if (!conversationIndex2.Equals(conversationIndex))
{
break;
}
if (!(propertyBags[i].TryGetProperty(ConversationActionItemSchema.ConversationActionVersion) is PropertyError))
{
int version = (int)propertyBags[i].TryGetProperty(ConversationActionItemSchema.ConversationActionVersion);
if (ConversationActionItem.GetMajorVersion(version) >= 4)
{
list.Add(propertyBags[i][ItemSchema.Id] as VersionedId);
}
}
}
}
}
return((list.Count == 0) ? null : list);
}
}
result = null;
}
}
}
}
}
catch (ObjectNotFoundException)
{
result = null;
}
return(result);
}
public static IList <StoreId> QueryConversationActionsFolder(MailboxSession session, ConversationId conversationId, int maxRowCount)
{
int num;
return(ConversationActionItem.QueryConversationActionsFolder(session, conversationId, maxRowCount, out num));
}
protected override void OnBeforeSave()
{
base.OnBeforeSave();
this[ConversationActionItemSchema.ConversationActionVersion] = ConversationActionItem.MakeVersion();
this.SetExpiration();
}
