/// <summary>
/// Returns the total number of entities that correspond to the specified filter criteria.
/// </summary>
/// <param name="containerTitle"></param>
/// <param name="path"></param>
/// <param name="criteria"></param>
/// <returns></returns>
public virtual int CountEntities(string containerTitle, string path, EntityFilterCriteria criteria)
{
SPSite site;
var web = GetDocumentStoreWeb(out site);
SPList list;
SPFolder folder;
if (SPDocumentStoreHelper.TryGetFolderFromPath(web, containerTitle, out list, out folder, path) == false)
{
return(0);
}
ContentIterator.EnsureContentTypeIndexed(list);
var documentStoreEntityContentTypeId = list.ContentTypes.BestMatch(new SPContentTypeId(Constants.DocumentStoreEntityContentTypeId));
var camlQuery = @"<Where>
<Eq>
<FieldRef Name=""ContentTypeId"" />
<Value Type=""ContentTypeId"">" + documentStoreEntityContentTypeId + @"</Value>
</Eq>
</Where>";
var viewFields = SPDocumentStoreHelper.GetDocumentStoreEntityViewFieldsXml();
var filteredListItems = new List <SPListItem>();
var itemsIterator = new ContentIterator();
itemsIterator.ProcessListItems(list, camlQuery + ContentIterator.ItemEnumerationOrderByPath + viewFields, ContentIterator.MaxItemsPerQueryWithViewFields, true, folder,
spListItems =>
{
var listItems = FilterListItemEntities(spListItems.OfType <SPListItem>(),
criteria);
// ReSharper disable AccessToModifiedClosure
filteredListItems.AddRange(listItems);
// ReSharper restore AccessToModifiedClosure
},
null);
return(filteredListItems.Count);
}
public IList <Entity> ListEntities(string containerTitle, EntityFilterCriteria criteria)
{
var targetPath = GetContainerPath(containerTitle);
if (criteria.Path.IsNullOrWhiteSpace() == false)
{
targetPath = Path.Combine(targetPath, criteria.Path);
}
var entities = new List <Entity>();
foreach (var entityFileName in Directory.GetFiles(targetPath, "*.dse", SearchOption.AllDirectories))
{
using (var package = EntityPackage.Open(entityFileName))
{
if (package == null)
{
continue;
}
var entity = package.MapEntityFromPackage(criteria.IncludeData);
entities.Add(entity);
}
}
IEnumerable <Entity> result = entities;
if (criteria.Top.HasValue)
{
result = result.Take((int)criteria.Top.Value);
}
if (criteria.Skip.HasValue)
{
result = result.Skip((int)criteria.Skip.Value);
}
return(result.ToList());
}
/// <summary>
/// When overridden in a subclass, allows custom processing to occur on the SPListItemCollection/IList<Entity/> that is retrieved from SharePoint.
/// </summary>
/// <param name="containerTitle"></param>
/// <param name="path"></param>
/// <param name="criteria"></param>
/// <param name="folder"></param>
/// <param name="entities"></param>
protected virtual void ProcessEntityList(string containerTitle, string path, EntityFilterCriteria criteria, SPFolder folder, IList <Entity> entities)
{
//Does nothing in the base implementation.
}
/// <summary>
/// Filters the specified collection of Entity List Items according to the specified criteria.
/// </summary>
/// <param name="listItems"></param>
/// <param name="criteria"></param>
/// <returns></returns>
protected IEnumerable <SPListItem> FilterListItemEntities(IEnumerable <SPListItem> listItems, EntityFilterCriteria criteria)
{
if (criteria == null)
{
return(listItems);
}
if (String.IsNullOrEmpty(criteria.Namespace) == false)
{
switch (criteria.NamespaceMatchType)
{
case NamespaceMatchType.Equals:
listItems = listItems
.Where(li => ((string)li[Constants.NamespaceFieldId]) == criteria.Namespace);
break;
case NamespaceMatchType.StartsWith:
listItems = listItems.Where(li => ((string)li[Constants.NamespaceFieldId])
.StartsWith(criteria.Namespace))
.ToList();
break;
case NamespaceMatchType.EndsWith:
listItems = listItems
.Where(li => ((string)li[Constants.NamespaceFieldId]).EndsWith(criteria.Namespace));
break;
case NamespaceMatchType.Contains:
listItems = listItems
.Where(li => ((string)li[Constants.NamespaceFieldId]).Contains(criteria.Namespace));
break;
case NamespaceMatchType.StartsWithMatchAllQueryPairs:
{
listItems = listItems.Where(li =>
{
var ns = li[Constants.NamespaceFieldId] as string;
Uri namespaceUri;
if (Uri.TryCreate(ns, UriKind.Absolute, out namespaceUri) == false)
{
return(false);
}
var qs = new QueryString(namespaceUri.Query);
return
(criteria.QueryPairs.All(
qp =>
qs.AllKeys.Contains(qp.Key, StringComparer.CurrentCultureIgnoreCase) &&
String.Compare(qs[qp.Key], qp.Value, StringComparison.CurrentCultureIgnoreCase) == 0));
});
}
break;
case NamespaceMatchType.StartsWithMatchAllQueryPairsContainsValue:
{
listItems = listItems.Where(li =>
{
var ns = li[Constants.NamespaceFieldId] as string;
Uri namespaceUri;
if (Uri.TryCreate(ns, UriKind.Absolute, out namespaceUri) == false)
{
return(false);
}
var qs = new QueryString(namespaceUri.Query);
return
(criteria.QueryPairs.All(
qp =>
qs.AllKeys.Contains(qp.Key, StringComparer.CurrentCultureIgnoreCase) &&
qs[qp.Key].ToLower().Contains(qp.Value.ToLower())));
});
}
break;
case NamespaceMatchType.StartsWithMatchAnyQueryPairs:
{
listItems = listItems.Where(li =>
{
var ns = li[Constants.NamespaceFieldId] as string;
Uri namespaceUri;
if (Uri.TryCreate(ns, UriKind.Absolute, out namespaceUri) == false)
{
return(false);
}
var qs = new QueryString(namespaceUri.Query);
return
(criteria.QueryPairs.Any(
qp =>
qs.AllKeys.Contains(qp.Key, StringComparer.CurrentCultureIgnoreCase) &&
String.Compare(qs[qp.Key], qp.Value, StringComparison.CurrentCultureIgnoreCase) == 0));
});
}
break;
case NamespaceMatchType.StartsWithMatchAnyQueryPairsContainsValue:
{
listItems = listItems.Where(li =>
{
var ns = li[Constants.NamespaceFieldId] as string;
Uri namespaceUri;
if (Uri.TryCreate(ns, UriKind.Absolute, out namespaceUri))
{
return(false);
}
var qs = new QueryString(namespaceUri.Query);
return
(criteria.QueryPairs.Any(
qp =>
qs.AllKeys.Contains(qp.Key, StringComparer.CurrentCultureIgnoreCase) &&
qs[qp.Key].ToLower().Contains(qp.Value.ToLower())));
});
}
break;
}
}
return(listItems);
}
/// <summary>
/// Lists the entities.
/// </summary>
/// <param name="containerTitle">The container title.</param>
/// <param name="path">The path.</param>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
public virtual IList <Entity> ListEntities(string containerTitle, string path, EntityFilterCriteria criteria)
{
SPSite site;
var web = GetDocumentStoreWeb(out site);
SPList list;
SPFolder folder;
if (SPDocumentStoreHelper.TryGetFolderFromPath(web, containerTitle, out list, out folder, path) == false)
{
return(null);
}
ContentIterator.EnsureContentTypeIndexed(list);
var documentStoreEntityContentTypeId = list.ContentTypes.BestMatch(new SPContentTypeId(Constants.DocumentStoreEntityContentTypeId));
var camlQuery = @"<Where>
<Eq>
<FieldRef Name=""ContentTypeId"" />
<Value Type=""ContentTypeId"">" + documentStoreEntityContentTypeId + @"</Value>
</Eq>
</Where>";
var viewFields = SPDocumentStoreHelper.GetDocumentStoreEntityViewFieldsXml();
var filteredListItems = new List <SPListItem>();
var itemsIterator = new ContentIterator();
itemsIterator.ProcessListItems(list, camlQuery + ContentIterator.ItemEnumerationOrderByPath + viewFields, ContentIterator.MaxItemsPerQueryWithViewFields, true, folder,
spListItems =>
{
var listItems = FilterListItemEntities(spListItems.OfType <SPListItem>(),
criteria);
// ReSharper disable AccessToModifiedClosure
filteredListItems.AddRange(listItems);
// ReSharper restore AccessToModifiedClosure
},
null);
var result = new List <Entity>();
if (criteria == null || criteria.IncludeData)
{
result.AddRange(
filteredListItems
.Select(li =>
{
// ReSharper disable AccessToDisposedClosure
var listItemFolder = li.Folder ?? web.GetFolder(SPUtility.GetUrlDirectory(li.Url));
// ReSharper restore AccessToDisposedClosure
return(SPDocumentStoreHelper.MapEntityFromDocumentSet(
DocumentSet.GetDocumentSet(listItemFolder), null));
})
.Where(entity => entity != null)
);
ProcessEntityList(containerTitle, path, criteria, folder, result);
}
else
{
if (criteria.Skip.HasValue)
{
filteredListItems = filteredListItems.Skip((int)criteria.Skip.Value).ToList();
}
if (criteria.Top.HasValue)
{
filteredListItems = filteredListItems.Take((int)criteria.Top.Value).ToList();
}
result.AddRange(
filteredListItems
.Select(
li =>
SPDocumentStoreHelper.MapEntityFromDocumentSet(DocumentSet.GetDocumentSet(li.Folder), null, null))
.Where(entity => entity != null)
);
ProcessEntityList(containerTitle, path, criteria, folder, result);
}
return(result);
}
/// <summary>
/// Lists all entities contained in the container with the specified criteria.
/// </summary>
/// <param name="containerTitle">The container title.</param>
/// <param name="criteria"></param>
/// <returns></returns>
public int CountEntities(string containerTitle, EntityFilterCriteria criteria)
{
return(CountEntities(containerTitle, criteria.Path, criteria));
}
/// <summary>
/// Lists all entities contained in the container with the specified criteria.
/// </summary>
/// <param name="containerTitle">The container title.</param>
/// <param name="criteria"></param>
/// <returns></returns>
public IList <Entity> ListEntities(string containerTitle, EntityFilterCriteria criteria)
{
return(ListEntities(containerTitle, criteria.Path, criteria));
}
public int CountEntities(string containerTitle, EntityFilterCriteria criteria)
{
return(ListEntities(containerTitle, criteria).Count);
}
public int CountEntities(string containerTitle, string path, EntityFilterCriteria criteria)
{
throw new NotImplementedException();
}
public System.Collections.Generic.IList <Entity> ListEntities(string containerTitle, string path, EntityFilterCriteria criteria)
{
throw new NotImplementedException();
}
