private static PartDefinition[] CollectFacetParts(
FacetDefinition facet,
bool noRoles)
{
List <PartDefinition> defs = new List <PartDefinition>();
if (facet != null)
{
foreach (PartDefinition def in facet.PartDefinitions)
{
if (noRoles && defs.Any(d => d.TypeId == def.TypeId))
{
continue;
}
if (noRoles)
{
def.RoleId = null;
}
defs.Add(def);
}
}
return(defs.OrderBy(d => d.SortKey)
.ThenBy(d => d.TypeId)
.ThenBy(d => d.RoleId).ToArray());
}
private string GetFacetName(FacetDefinition facetDefinition, string value)
{
if (facetDefinition is ReferenceFacetDefinition)
{
var referenceFacetDefinition = facetDefinition as ReferenceFacetDefinition;
Guid id;
if (Guid.TryParse(value, out id))
{
if (id == Guid.Empty)
{
return(String.Empty);
}
var item = Context.Database.GetItem(id.ToID());
if (item != null && referenceFacetDefinition.ValueTitleAccessor != null && referenceFacetDefinition.ValueTitleAccessor.FacetTitleField != null)
{
var field = item.Fields[referenceFacetDefinition.ValueTitleAccessor.FacetTitleField.Name];
if (field != null)
{
return(!String.IsNullOrWhiteSpace(field.Value) ? field.Value : item.Name);
}
}
}
}
if (facetDefinition is TextFacetDefenition)
{
return(value);
}
return(value);
}
private FacetGroupOption CreateFacetGroup(FacetDefinition searchFilter)
{
return(new FacetGroupOption
{
GroupFieldName = searchFilter.FieldName,
GroupName = searchFilter.DisplayName,
Facets = new List <FacetOption>()
});
}
public ActionResult <PartDefinition[]> GetFacetParts(string database,
[FromRoute] string id,
[FromQuery] bool noRoles = false)
{
ICadmusRepository repository =
_repositoryProvider.CreateRepository(database);
FacetDefinition facet = repository.GetFacetDefinition(id);
PartDefinition[] result = CollectFacetParts(facet, noRoles);
return(Ok(result));
}
/// <summary>
/// Get a <see cref="FacetDefinition"/> from this object.
/// </summary>
/// <returns>Facet definition.</returns>
public FacetDefinition ToFacetDefinition()
{
FacetDefinition definition = new FacetDefinition
{
Id = Id,
Label = Label,
Description = Description,
ColorKey = ColorKey
};
definition.PartDefinitions.AddRange(PartDefinitions);
return(definition);
}
/// <summary>
/// Initializes a new instance of the <see cref="MongoFacetDefinition"/> class.
/// </summary>
/// <param name="facet">The facet.</param>
/// <exception cref="ArgumentNullException">null facet</exception>
public MongoFacetDefinition(FacetDefinition facet)
{
if (facet == null)
{
throw new ArgumentNullException(nameof(facet));
}
Id = facet.Id;
Label = facet.Label;
Description = facet.Description;
ColorKey = facet.ColorKey;
PartDefinitions = new List <PartDefinition>(facet.PartDefinitions);
}
public ActionResult <PartDefinition> GetFacet(
string database,
[FromRoute] string id)
{
ICadmusRepository repository =
_repositoryProvider.CreateRepository(database);
FacetDefinition facet = repository.GetFacetDefinition(id);
if (facet == null)
{
return(NotFound());
}
return(Ok(facet));
}
/// <summary>
/// Iterates the list of facets and populates the facets with the
/// result of the facet search from Find
/// </summary>
/// <param name="productFacetsResult">The product facets result.</param>
/// <param name="facetList">The facet list.</param>
/// <returns></returns>
private List <FacetValues> GetFacetsAndValues(SearchResults <FindProduct> productFacetsResult, List <FacetValues> facetList)
{
foreach (var facetValues in facetList)
{
FacetDefinition definition = facetValues.Definition;
Facet facet = productFacetsResult.Facets.FirstOrDefault(f => f.Name.Equals(definition.FieldName));
if (facet != null)
{
// The definition must also keep track
// of what facets are selected
definition.PopulateFacet(facet);
}
}
return(facetList);
}
public void Read_Profile_Ok()
{
string json = LoadProfile("SampleProfile.json");
IDataProfileSerializer serializer = new JsonDataProfileSerializer();
DataProfile profile = serializer.Read(json);
// facets
Assert.Single(profile.Facets);
FacetDefinition facetDef = profile.Facets[0];
Assert.Equal("facet-default", facetDef.Id);
Assert.Equal("default", facetDef.Label);
Assert.Equal("The default facet", facetDef.Description);
Assert.Equal("FF0000", facetDef.ColorKey);
Assert.Equal(7, facetDef.PartDefinitions.Count);
// TODO: check each facet definition
// flags
Assert.Single(profile.Flags);
FlagDefinition flagDef = profile.Flags[0];
Assert.Equal(1, flagDef.Id);
Assert.Equal("to revise", flagDef.Label);
Assert.Equal("The item must be revised.", flagDef.Description);
Assert.Equal("F08080", flagDef.ColorKey);
// thesauri
Assert.Equal(2, profile.Thesauri.Length);
Thesaurus thesaurus = Array.Find(profile.Thesauri,
t => t.Id == "categories@en");
Assert.NotNull(thesaurus);
Assert.Equal(16, thesaurus.GetEntries().Count);
// TODO: check each entry
thesaurus = Array.Find(profile.Thesauri,
t => t.Id == "languages@en");
Assert.NotNull(thesaurus);
Assert.Equal(8, thesaurus.GetEntries().Count);
// TODO: check each entry
}
public ActionResult <PartDefinition> GetFacetFromItemId(
string database,
[FromRoute] string id)
{
ICadmusRepository repository =
_repositoryProvider.CreateRepository(database);
IItem item = repository.GetItem(id, false);
if (item?.FacetId == null)
{
return(NotFound());
}
FacetDefinition facet = repository.GetFacetDefinition(item.FacetId);
if (facet == null)
{
return(NotFound());
}
return(Ok(facet));
}
public ActionResult <PartDefinition[]> GetFacetPartsFromItem(
string database,
[FromRoute] string id,
[FromQuery] bool noRoles = false)
{
ICadmusRepository repository =
_repositoryProvider.CreateRepository(database);
IItem item = repository.GetItem(id, false);
PartDefinition[] result;
if (item?.FacetId != null)
{
FacetDefinition facet = repository.GetFacetDefinition(item.FacetId);
result = CollectFacetParts(facet, noRoles);
}
else
{
result = Array.Empty <PartDefinition>();
}
return(Ok(result));
}
internal MaxLengthFacet(FacetDefinition Definition)
: base(Definition)
{
}
internal MaxLengthFacet(FacetDefinition Definition)
: base(Definition)
{
}
internal WhiteSpaceFacet(FacetDefinition Definition)
: base(Definition)
{
}
internal WhiteSpaceFacet(FacetDefinition Definition)
: base(Definition)
{
}
/// <summary>
/// Gets the items.
/// </summary>
/// <param name="count">The desired count of items to get.</param>
/// <returns>The items.</returns>
public IEnumerable <IItem> GetItems(int count)
{
if (count < 1 ||
_options.FacetDefinitions == null ||
_options.FacetDefinitions.Length == 0)
{
yield break;
}
// init
if (_options.Seed.HasValue)
{
Randomizer.Seed = new Random(_options.Seed.Value);
}
ItemSeeder itemSeeder = _factory.GetItemSeeder();
_partSeeders = _factory.GetPartSeeders();
IItemSortKeyBuilder sortKeyBuilder = _factory.GetItemSortKeyBuilder();
// generate items
for (int n = 1; n <= count; n++)
{
// pick a facet
FacetDefinition facet = _options.FacetDefinitions[
_options.FacetDefinitions.Length == 1
? 0
: Randomizer.Seed.Next(0, _options.FacetDefinitions.Length)];
// get item
IItem item = itemSeeder.GetItem(n, facet.Id);
// add parts: first non layer parts, then the others.
// This ensures that the item already has the base text part
// before adding the layer parts, which refer to it.
// 1) non-layer parts, required
AddParts(facet.PartDefinitions
.Where(def => !IsLayerPart(def) && def.IsRequired),
item,
false);
// 2) non-layer parts, optional
AddParts(facet.PartDefinitions
.Where(def => !IsLayerPart(def) && !def.IsRequired),
item,
true);
// 3) layer-parts
// we must have a base text definition to have layers
PartDefinition baseTextDef = facet.PartDefinitions.Find(
def => def.RoleId == PartBase.BASE_TEXT_ROLE_ID);
if (baseTextDef != null && Randomizer.Seed.Next(0, 2) == 1)
{
// ensure there is a base text. This is required for
// the text layer part seeder, which must rely on a base text.
IPart baseTextPart = item.Parts.Find(
p => p.TypeId == baseTextDef.TypeId);
// add a base text if none found
if (baseTextPart == null)
{
baseTextPart = GetPart(item, baseTextDef);
if (baseTextPart != null)
{
item.Parts.Add(baseTextPart);
}
}
// once we have one, eventually add layer(s)
if (baseTextPart != null)
{
// 3) layer parts, required
AddParts(facet.PartDefinitions
.Where(def => IsLayerPart(def) && def.IsRequired),
item,
false);
// 4) layer parts, optional
AddParts(facet.PartDefinitions
.Where(def => IsLayerPart(def) && !def.IsRequired),
item,
true);
}
}
// once all the parts are in place, override the item's sort key
// if requested in the config.
// Note that we do not provide a repository, as while seeding
// there might be no database, and all the item's parts are
// in the item itself.
if (sortKeyBuilder != null)
{
item.SortKey = sortKeyBuilder.BuildKey(item, null);
}
yield return(item);
}
}
internal PatternFacet(FacetDefinition Definition)
: base(Definition)
{
}
internal EnumerationFacet(FacetDefinition Definition)
: base(Definition)
{
}
