void RemoveTerritoriesInHierarchy(RemoveContentContext context, TerritoryHierarchyPart part)
{
// I need to only invoke this on the first level. Those TerritoryPart will Remove their children.
foreach (var item in part.TopLevel)
{
_contentManager.Remove(item);
}
}
public TerritoryHierarchyTerritoryManagerViewModel(
TerritoryHierarchyPart part)
{
Part = part;
ContentItem = part.ContentItem;
TerritoriesCount = part.Territories?.Count() ?? 0;
}
/// <summary>
/// This method verifies that neither the passed territory is valid. In case it's not, it will
/// throw the corresponding exception.
/// </summary>
/// <param name="hierarchy">The TerritoryHierarchyPart argument to validate.</param>
/// <param name="name">The name of the argument being validated.</param>
/// <exception cref="ArgumentNullException">Throws an ArgumentNullException if the TerritoryHierarchyPart
/// argument is null.</exception>
/// <exception cref="ArgumentException">Throws an ArgumentException if the TerritoryHierarchyPart
/// argument has a null underlying record.</exception>
public static void ValidateArgument(TerritoryHierarchyPart hierarchy, string name)
{
if (hierarchy == null)
{
throw new ArgumentNullException(name);
}
if (hierarchy.Record == null)
{
throw new ArgumentException(T("Part record cannot be null.").Text, name);
}
}
private void Invalidate(TerritoryHierarchyPart part)
{
// if the hierarchy is the one selected or one of its localizations
// we invalidate the cache
if (!_addressConfigurationSettingsService.ShippingCountriesHierarchies.Any() ||
_addressConfigurationSettingsService.ShippingCountriesHierarchies
.Select(thp => thp.Id)
.Contains(part.Id))
{
Invalidate();
}
}
public void AddTerritory(TerritoryPart territory, TerritoryHierarchyPart hierarchy)
{
TerritoriesUtilities.ValidateArgument(territory, nameof(territory));
TerritoriesUtilities.ValidateArgument(hierarchy, nameof(hierarchy));
// check that types are correct
if (territory.ContentItem.ContentType != hierarchy.TerritoryType)
{
var territoryTypeText = territory.ContentItem
.TypeDefinition.DisplayName;
var hierarchyTerritoryTypeText = _contentDefinitionManager
.GetTypeDefinition(hierarchy.TerritoryType).DisplayName;
throw new ArrayTypeMismatchException(
T("The ContentType for the Territory ({0}) does not match the expected TerritoryType for the hierarchy ({1})",
territoryTypeText, hierarchyTerritoryTypeText).Text);
}
// The territory may come from a different hierarchy
if (territory.Record.Hierarchy != null &&
territory.Record.Hierarchy.Id != hierarchy.Record.Id)
{
// Verify that the TerritoryInternalRecords in the territory or its children can be moved there
var internalRecords = new List <int>();
if (territory.Record.TerritoryInternalRecord != null)
{
internalRecords.Add(territory.Record.TerritoryInternalRecord.Id);
}
if (territory.Record.Children != null)
{
internalRecords.AddRange(territory
.Record
.Children
.Where(tpr => tpr.TerritoryInternalRecord != null)
.Select(tpr => tpr.TerritoryInternalRecord.Id));
}
if (internalRecords.Any())
{
if (hierarchy.Record
.Territories
.Select(tpr => tpr.TerritoryInternalRecord.Id)
.Any(tir => internalRecords.Contains(tir)))
{
throw new TerritoryInternalDuplicateException(T("The territory being moved is already assigned in the current hierarchy."));
}
}
}
// remove parent: This method always puts the territory at the root level of the hierarchy
territory.Record.ParentTerritory = null;
// set hierarchy and also set the hierarchy for all children: we need to move all levels of children,
// and record.Children only contains the first level.
AssignHierarchyToChildren(territory.Record, hierarchy.Record);
}
void LazyLoadHandlers(TerritoryHierarchyPart part)
{
part.TerritoriesField.Loader(() => {
if (part.Record.Territories != null && part.Record.Territories.Any())
{
return(_contentManager
.GetMany <ContentItem>(part.Record.Territories.Select(tpr => tpr.ContentItemRecord.Id),
VersionOptions.Latest, QueryHints.Empty));
}
else
{
return(Enumerable.Empty <ContentItem>());
}
});
}
private void UpdateTerritoryPosition(
TerritoryPart territoryPart, TerritoryHierarchyPart hierarchyPart, TerritoryPart parentPart = null)
{
var context = new UpdateContentContext(territoryPart.ContentItem);
_handlers.Invoke(handler => handler.Updating(context), Logger);
if (parentPart == null)
{
_territoriesHierarchyService.AddTerritory(territoryPart, hierarchyPart); // move to root
}
else
{
_territoriesHierarchyService.AssignParent(territoryPart, parentPart);
}
_handlers.Invoke(handler => handler.Updated(context), Logger);
}
static void PropertySetHandlers(
InitializingContentContext context, TerritoryHierarchyPart part)
{
part.TerritoriesField.Setter(value => {
var actualItems = value.Where(ci => ci.As <TerritoryPart>() != null);
part.Record.Territories = actualItems.Any() ?
actualItems.Select(ci => ci.As <TerritoryPart>().Record).ToList() :
new List <TerritoryPartRecord>();
return(actualItems);
});
//call the setter in case a value had already been set
if (part.TerritoriesField.Value != null)
{
part.TerritoriesField.Value = part.TerritoriesField.Value;
}
}
public IContentQuery <TerritoryPart, TerritoryPartRecord> GetTerritoriesQuery(
TerritoryHierarchyPart hierarchyPart, TerritoryPart territoryPart, VersionOptions versionOptions)
{
var baseQuery = GetTerritoriesQuery(hierarchyPart, versionOptions)
.WithQueryHints(new QueryHints().ExpandRecords("TerritoryPartRecord"));
if (territoryPart == null)
{
return(baseQuery
.Where(tpr => tpr.ParentTerritory == null));
}
else
{
return(baseQuery
.Where(tpr => tpr.ParentTerritory.Id == territoryPart.Record.Id));
}
}
private HierarchyIndexEntry CreateEntry(TerritoryHierarchyPart part)
{
var hierarchyType = _contentDefinitionManager.GetTypeDefinition(part.ContentItem.ContentType);
var typeDisplayName = hierarchyType != null ?
hierarchyType.DisplayName : T("ERROR: impossible to find hierarchy type.").Text;
var territoryType = _contentDefinitionManager.GetTypeDefinition(part.TerritoryType);
var territoryDisplayName = territoryType != null ?
territoryType.DisplayName : T("ERROR: impossible to find territory type.").Text;
return(new HierarchyIndexEntry {
Id = part.ContentItem.Id,
DisplayText = _contentManager.GetItemMetadata(part.ContentItem).DisplayText,
ContentItem = part.ContentItem,
TypeDisplayName = typeDisplayName,
IsDraft = !part.ContentItem.IsPublished(),
TerritoriesCount = part.Territories.Count(),
TerritoryTypeDisplayName = territoryDisplayName
});
}
private IEnumerable <TerritoryInternalRecord> _availableTerritoryInternals; // cache results of following method
public IEnumerable <TerritoryInternalRecord> GetAvailableTerritoryInternals(TerritoryHierarchyPart hierarchyPart)
{
TerritoriesUtilities.ValidateArgument(hierarchyPart, nameof(hierarchyPart));
if (_availableTerritoryInternals == null)
{
_availableTerritoryInternals = _territoriesRepositoryService
.GetTerritories()
.Where(tir => !hierarchyPart
.Record.Territories //.Territories
.Where(tpr => tpr.TerritoryInternalRecord != null)
//.Where(ci => ci.As<TerritoryPart>()
// .Record
// .TerritoryInternalRecord != null)
.Select(tpr => tpr.TerritoryInternalRecord.Id)
//.Select(ci => ci.As<TerritoryPart>()
// .Record
// .TerritoryInternalRecord
// .Id)
.Contains(tir.Id)
);
}
return(_availableTerritoryInternals);
}
public IContentQuery <TerritoryPart, TerritoryPartRecord> GetTerritoriesQuery(
TerritoryHierarchyPart hierarchyPart, TerritoryPart territoryPart)
{
return(GetTerritoriesQuery(hierarchyPart, territoryPart, null));
}
public IContentQuery <TerritoryPart, TerritoryPartRecord> GetTerritoriesQuery(TerritoryHierarchyPart hierarchyPart, VersionOptions versionOptions)
{
TerritoriesUtilities.ValidateArgument(hierarchyPart, nameof(hierarchyPart));
versionOptions = versionOptions ??
(hierarchyPart.ContentItem.IsPublished() ? VersionOptions.Published : VersionOptions.Latest);
return(_contentManager
.Query <TerritoryPart, TerritoryPartRecord>()
.WithQueryHints(new QueryHints().ExpandRecords("TerritoryHierarchyPartRecord"))
.ForVersion(versionOptions)
.Where(tpr => tpr.Hierarchy.Id == hierarchyPart.Record.Id));
}
public IContentQuery <TerritoryPart, TerritoryPartRecord> GetTerritoriesQuery(TerritoryHierarchyPart hierarchyPart)
{
return(GetTerritoriesQuery(hierarchyPart, versionOptions: null));
}
