/// <summary>
/// Run a filter based on the user inputs from the Filter page including the version key values for the selected version,
/// the list of allowed content class names, the filters and a paging spec
/// </summary>
/// <param name="versionFilter">list of version keys in the order they appear in VersionManager.SelectionViewModel</param>
/// <param name="classFilter">List of content class names</param>
/// <param name="filters">List of filters</param>
/// <param name="pagingSpec">Specification of paging</param>
/// <returns>A list of container x summary tuples which are the results of filtering</returns>
public List <Tuple <object, Summary> > RunFilter(List <string> versionFilter, string[] classFilter, List <ListFilter> filters, PagingSpec pagingSpec)
{
if (filters == null)
{
filters = new List <ListFilter>();
}
var reqVersion = new ItemVersion();
var u = LyniconSecurityManager.Current.User;
var v = VersionManager.Instance.CurrentVersion;
var vsvms = VersionManager.Instance.SelectionViewModel(u, v);
int vIdx = 0;
foreach (var vsvm in vsvms)
{
object vVal = JsonConvert.DeserializeObject(versionFilter[vIdx]);
reqVersion.Add(vsvm.VersionKey, vVal is Int64 ? Convert.ToInt32(vVal) : vVal);
vIdx++;
}
VersionManager.Instance.PushState(VersioningMode.Specific, reqVersion);
List <Tuple <object, Summary> > pagedResult = null;
try
{
var types = (classFilter ?? new string[0]).Select(c => ContentTypeHierarchy.GetAnyType(c)).ToList();
var vm = new ItemListerViewModel();
for (var i = 0; i < filters.Count; i++)
{
filters[i].MergeOriginal(vm.Filters[filters[i].Idx]);
}
var containerFilters = filters.Where(f => (f.Active || f.Sort != 0) && !typeof(Summary).IsAssignableFrom(f.ApplicableType)).ToList();
var summaryFilters = filters.Where(f => (f.Active || f.Sort != 0) && typeof(Summary).IsAssignableFrom(f.ApplicableType)).ToList();
var filterResult = FilterManager.Instance.GetFilterSummaries(types, containerFilters, summaryFilters);
pagingSpec.Total = filterResult.Count;
pagedResult = filterResult.ApplyPaging(pagingSpec).ToList();
//var resultView = pagedResult.Select(t => new List<string> { t.Item2.Url, t.Item2.Title }).ToList();
//foreach (var filt in filters.Where(f => f.Show))
//{
// for (int i = 0; i < resultView.Count; i++)
// resultView[i].Add(filt.GetShowText(pagedResult[i]));
//}
}
finally
{
VersionManager.Instance.PopState();
}
return(pagedResult);
}
/// <summary>
/// Create an ItemVersion with null values for all the keys applicable to a type
/// </summary>
/// <param name="type">The type for which to create the ItemVersion</param>
/// <returns>ItemVersion with null values for all the keys applicable</returns>
public ItemVersion VersionForType(Type type)
{
var iv = new ItemVersion();
foreach (var versioner in Versioners)
if (versioner.Versionable(type))
iv.Add(versioner.VersionKey, null);
return iv;
}
/// <summary>
/// Make the ItemVersion applicable to a given type by removing any inapplicable keys
/// </summary>
/// <param name="version">The original ItemVersion</param>
/// <param name="t">The type to which to make it applicable</param>
/// <returns>The modified, applicable ItemVersion</returns>
public ItemVersion GetApplicableVersion(ItemVersion version, Type t)
{
ItemVersion res = new ItemVersion();
foreach (var versioner in Versioners)
{
if (!version.ContainsKey(versioner.VersionKey))
continue;
if (versioner.Versionable(t))
res.Add(versioner.VersionKey, version[versioner.VersionKey]);
}
return res;
}
/// <summary>
/// Expand the abstract version to a list of fully-specified versions
/// with all the keys of all the registered versions
/// </summary>
/// <param name="iv">Abstract version to expand</param>
/// <returns>List of fully-specified versions</returns>
public List<ItemVersion> ContainingVersions(ItemVersion iv)
{
var expIv = new ItemVersion(iv);
foreach (var versioner in Versioners)
{
if (!iv.ContainsKey(versioner.VersionKey))
expIv.Add(versioner.VersionKey, null);
}
return expIv.Expand();
}
public void ItemVersionOperations()
{
// means published English vsn
var iv1 = new ItemVersion {
{ "Published", true }, { "Locale", "en-GB" }
};
// means unpublished vsn used for all locales
var iv2 = new ItemVersion {
{ "Published", false }, { "Locale", null }
};
// means Spanish vsn of type which is not versionable for publishing
var iv3 = new ItemVersion {
{ "Locale", "es-ES" }
};
var iv4 = iv1.GetAddressablePart();
Assert.AreEqual(new ItemVersion {
{ "Locale", "en-GB" }
}, iv4);
var iv5 = iv1.GetUnaddressablePart();
Assert.AreEqual(new ItemVersion {
{ "Published", true }
}, iv5);
var iv6 = iv1.GetApplicablePart(typeof(TestContent));
Assert.AreEqual(new ItemVersion {
{ "Locale", "en-GB" }
}, iv6);
var iv7 = iv1.Superimpose(new ItemVersion {
{ "Published", false }, { "A", "x" }
});
Assert.AreEqual(true, iv1["Published"]); // does not mutate iv1
Assert.AreEqual(new ItemVersion {
{ "Published", false }, { "Locale", "en-GB" }, { "A", "x" }
}, iv7);
var iv9 = new ItemVersion(iv1);
iv9.Add("X", null);
var iv8 = iv9.Overlay(new ItemVersion {
{ "Published", false }, { "Locale", null }
});
Assert.AreEqual(new ItemVersion {
{ "Published", false }, { "Locale", null }, { "X", null }
}, iv8);
Assert.AreEqual("en-GB", iv9["Locale"]); // does not mutate iv1
var iv10 = iv9.Mask(new ItemVersion {
{ "Published", null }, { "Locale", "es-ES" }
});
Assert.AreEqual(new ItemVersion {
{ "Published", true }, { "Locale", "es-ES" }
}, iv10);
Assert.AreEqual("es-ES", iv10["Locale"]);
}
