protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
actionAdder(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.GenericDeleteDataWorkflow"), this.PermissionTypes)))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
protected override IEnumerable<Element> OnGetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
var entityToken = new TreeSimpleElementEntityToken(
this.Id,
this.Tree.TreeId,
EntityTokenSerializer.Serialize(parentEntityToken));
Element element = new Element(new ElementHandle(
dynamicContext.ElementProviderName,
entityToken,
dynamicContext.Piggybag.PreparePiggybag(this.ParentNode, parentEntityToken)
));
if (parentEntityToken is TreePerspectiveEntityToken)
{
element.ElementHandle.Piggyback[StringConstants.PiggybagTreeId] = Tree.TreeId;
}
var replaceContext = new DynamicValuesHelperReplaceContext(parentEntityToken, dynamicContext.Piggybag);
element.VisualData = new ElementVisualizedData
{
Label = this.LabelDynamicValuesHelper.ReplaceValues(replaceContext),
ToolTip = this.ToolTipDynamicValuesHelper.ReplaceValues(replaceContext),
HasChildren = ChildNodes.Any(),
Icon = this.Icon,
OpenedIcon = this.OpenIcon
};
yield return element;
}
/// <summary>
/// Depending on dynamicContext's Direction creates either filter expression for finding child elements or
/// a filter expression to find current element based on children elements
/// </summary>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="dynamicContext">The dynamic context.</param>
/// <param name="filtersToSkip">The filters to skip.</param>
/// <returns></returns>
internal virtual Expression CreateFilterExpression(ParameterExpression parameterExpression, TreeNodeDynamicContext dynamicContext, IList<int> filtersToSkip = null)
{
Expression expression = null;
var filterNodes = dynamicContext.Direction == TreeNodeDynamicContextDirection.Down
? this.FilterNodes
: dynamicContext.CurrentTreeNode.FilterNodes;
foreach (FilterNode filterNode in filterNodes)
{
if (filtersToSkip != null && filtersToSkip.Contains(filterNode.Id)) continue;
Expression filterExpression;
if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Down)
{
filterExpression = filterNode.CreateDownwardsFilterExpression(parameterExpression, dynamicContext);
}
else
{
filterExpression = filterNode.CreateUpwardsFilterExpression(parameterExpression, dynamicContext);
}
if (filterExpression == null) continue;
expression = expression.NestedAnd(filterExpression);
}
return expression;
}
/// <summary>
/// Creates the accumulated filter expression from current tree definition node, and all the nearest ancestor DataFolderElement-s that
/// are related to the same data type.
/// </summary>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="affectedInterfaceType">Type of the affected interface.</param>
/// <param name="dynamicContext">The dynamic context.</param>
/// <param name="filtersToSkip">The filters to skip.</param>
/// <returns></returns>
internal Expression CreateAccumulatedFilterExpression(ParameterExpression parameterExpression, Type affectedInterfaceType, TreeNodeDynamicContext dynamicContext, IList<int> filtersToSkip = null)
{
TreeNode treeNode = this;
Expression currentExpression = null;
while (treeNode != null)
{
DataFilteringTreeNode dataFilteringTreeNode = treeNode as DataFilteringTreeNode;
if (dataFilteringTreeNode != null
&& (dataFilteringTreeNode == this || dataFilteringTreeNode is DataFolderElementsTreeNode)
&& (dataFilteringTreeNode.CurrentDataInterfaceType == affectedInterfaceType))
{
Expression filterExpression = dataFilteringTreeNode.CreateFilterExpression(parameterExpression, dynamicContext, filtersToSkip);
if (filterExpression != null)
{
currentExpression = currentExpression.NestedAnd(filterExpression);
}
}
else
{
break;
}
treeNode = treeNode.ParentNode;
}
//currentExpression.DebugLogExpression("DataFileringTreeNode", "Accumulated Filter Expression");
return currentExpression;
}
private AncestorMatch GetAncestorFromParentFilter(TreeNodeDynamicContext dynamicContext)
{
var treeNode = dynamicContext.CurrentTreeNode;
if (treeNode is DataElementsTreeNode)
{
var parentIdFilter = treeNode.FilterNodes.OfType <ParentIdFilterNode>().FirstOrDefault();
if (parentIdFilter == null)
{
return(null);
}
Type ancestorType = parentIdFilter.ParentFilterType;
object key = parentIdFilter.FindParentKeyValue(dynamicContext);
return(key == null ? null : new AncestorMatch {
InterfaceType = ancestorType, KeyValue = key
});
}
if (treeNode is DataFolderElementsTreeNode &&
dynamicContext.CurrentEntityToken is TreeDataFieldGroupingElementEntityToken groupEntityToken &&
groupEntityToken.ChildGeneratingDataElementsReferenceValue != null)
{
return(new AncestorMatch
{
InterfaceType = groupEntityToken.ChildGeneratingDataElementsReferenceType,
KeyValue = groupEntityToken.ChildGeneratingDataElementsReferenceValue
});
}
return(null);
}
protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
string url = this.UrlDynamicValuesHelper.ReplaceValues(dynamicValuesHelperReplaceContext);
this.External = url.Contains("://");
if(!External)
{
url = UrlUtils.ResolvePublicUrl(url);
}
CustomUrlActionNodeActionToken actionToken = new CustomUrlActionNodeActionToken(
url,
this.External,
(this.External ? "externalview" : "documentview"),
this.ViewLabelDynamicValuesHelper.ReplaceValues(dynamicValuesHelperReplaceContext),
this.ViewToolTipDynamicValuesHelper.ReplaceValues(dynamicValuesHelperReplaceContext),
this.Serialize(),
this.PermissionTypes);
ElementAction elementAction = new ElementAction(new ActionHandle(actionToken))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
};
actionAdder(elementAction);
}
public string CustomFormMarkupPath { get; internal set; } // Optional
/// <exclude />
protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
var payload = new StringBuilder();
this.Serialize(payload);
StringConversionServices.SerializeKeyValuePair(payload, "_IconResourceName_", Icon.ResourceName);
if (!String.IsNullOrEmpty(CustomFormMarkupPath))
{
StringConversionServices.SerializeKeyValuePair(payload, "_CustomFormMarkupPath_", CustomFormMarkupPath);
actionAdder(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.GenericEditDataWorkflow"), this.PermissionTypes)
{
Payload = payload.ToString()
}))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
else
{
actionAdder(new ElementAction(new ActionHandle(new ProxyDataActionToken(ActionIdentifier.Edit, this.PermissionTypes)))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
}
private static Expression CreateInnerExpression(TreeNodeDynamicContext dynamicContext, ParentIdFilterNode parentIdFilterNode, DataElementsTreeNode dataElementsTreeNode, bool includeJoin = true)
{
Type interfaceType = dataElementsTreeNode.CurrentDataInterfaceType;
ParameterExpression parameterExpression = Expression.Parameter(interfaceType, "innerData");
List <int> filtersToSkip = new List <int>()
{
parentIdFilterNode.Id
};
foreach (ParentIdFilterNode childParentIdFilterNode in dataElementsTreeNode.FilterNodes.OfType <ParentIdFilterNode>().Where(f => f.Id != parentIdFilterNode.Id))
{
if (childParentIdFilterNode.ParentFilterTypeTreeNode.IsAncestor(parentIdFilterNode.ParentFilterTypeTreeNode))
{
filtersToSkip.Add(childParentIdFilterNode.Id);
}
}
Expression filterExpression = dataElementsTreeNode.CreateAccumulatedFilterExpression(parameterExpression, interfaceType, dynamicContext, filtersToSkip);
Expression whereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(interfaceType).Expression, parameterExpression, filterExpression);
if ((includeJoin) && (dataElementsTreeNode.JoinDataElementsTreeNode != null))
{
//MRJ: Multiple Parent Filter: Recursive call, so we would have to make multiple recursive calls
Expression innerInnerExpression = CreateInnerExpression(dynamicContext, dataElementsTreeNode.JoinParentIdFilterNode, dataElementsTreeNode.JoinDataElementsTreeNode);
// Create join lambda expressions
PropertyInfo outerKeyPropertyInfo = dataElementsTreeNode.KeyPropertyInfo;
LambdaExpression outerKeySelectorExpression = Expression.Lambda(Expression.Property(parameterExpression, outerKeyPropertyInfo), parameterExpression);
Type innerKeyType = TypeHelpers.FindElementType(innerInnerExpression);
ParameterExpression innerKeySelectorParameterExpression = Expression.Parameter(innerKeyType, "innerKeyParam");
LambdaExpression innerKeySelectorExpression = Expression.Lambda(innerKeySelectorParameterExpression, innerKeySelectorParameterExpression);
ParameterExpression parameterExpression1 = Expression.Parameter(dataElementsTreeNode.CurrentDataInterfaceType, "param1");
ParameterExpression parameterExpression2 = Expression.Parameter(outerKeyPropertyInfo.PropertyType, "param2");
LambdaExpression resultSelector = Expression.Lambda(parameterExpression1, parameterExpression1, parameterExpression2);
Expression joinExpression = ExpressionHelper.CreateJoinExpression(
whereExpression,
innerInnerExpression,
outerKeySelectorExpression,
innerKeySelectorExpression,
resultSelector);
whereExpression = joinExpression;
}
Expression selectExpression = ExpressionHelper.CreateSelectExpression(whereExpression, ExpressionHelper.CreatePropertyExpression(parentIdFilterNode.ReferenceFieldName, parameterExpression), parameterExpression);
Expression distinctExpression = ExpressionHelper.CreateDistinctExpression(selectExpression);
return(distinctExpression);
}
private Expression GetObjectsExpression(TreeNodeDynamicContext dynamicContext, bool includeAllGroupingFields = false)
{
ParameterExpression parameterExpression = Expression.Parameter(this.InterfaceType, "data");
Expression filterExpression = CreateAccumulatedFilterExpression(parameterExpression, this.InterfaceType, dynamicContext);
Expression whereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(this.InterfaceType).Expression, parameterExpression, filterExpression);
Expression fieldExpression = ExpressionHelper.CreatePropertyExpression(this.InterfaceType, this.PropertyInfo.DeclaringType, this.FieldName, parameterExpression);
var keySelector = Expression.Lambda(fieldExpression, parameterExpression);
Expression orderByExpression = this.SortDirection == SortDirection.Ascending
? ExpressionHelper.CreateOrderByExpression(whereExpression, keySelector)
: ExpressionHelper.CreateOrderByDescendingExpression(whereExpression, keySelector);
Expression selectBodyExpression;
List <LambdaExpression> orderByExpressions = null;
if (!includeAllGroupingFields)
{
selectBodyExpression = CreateSelectBodyExpression(parameterExpression, fieldExpression, out orderByExpressions);
}
else
{
List <Expression> bodyExpressions = new List <Expression>();
foreach (DataFolderElementsTreeNode dataFolderElementsTreeNode in this.AllGroupingNodes)
{
List <LambdaExpression> innerOrderByExpressions;
Expression groupFieldExpression = ExpressionHelper.CreatePropertyExpression(dataFolderElementsTreeNode.InterfaceType, dataFolderElementsTreeNode.PropertyInfo.DeclaringType, dataFolderElementsTreeNode.FieldName, parameterExpression);
Expression bodyExpression = dataFolderElementsTreeNode.CreateSelectBodyExpression(parameterExpression, groupFieldExpression, out innerOrderByExpressions);
bodyExpressions.Add(bodyExpression);
}
selectBodyExpression = Expression.New(this.AllGroupingsTupleConstructor, bodyExpressions);
// TODO: proper processing of innerOrderByExpressions
}
Expression selectExpression = ExpressionHelper.CreateSelectExpression(
orderByExpression,
selectBodyExpression,
parameterExpression);
Expression distinctExpression = ExpressionHelper.CreateDistinctExpression(selectExpression);
// Sorting after calling "DISTINCT" to fix LINQ2SQL issue. No need to sort while resolving security
if (orderByExpressions != null && dynamicContext.Direction == TreeNodeDynamicContextDirection.Down)
{
distinctExpression = ApplyOrder(distinctExpression, orderByExpressions);
}
return(distinctExpression);
}
/// <exclude />
protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
Icon = new ResourceHandle(BuildInIconProviderName.ProviderName, "copy");
actionAdder(new ElementAction(new ActionHandle(new ProxyDataActionToken(ActionIdentifier.Duplicate,this.PermissionTypes)))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
/// <exclude />
public override AncestorResult GetParentEntityToken(EntityToken ownEntityToken, Type parentInterfaceOfInterest, TreeNodeDynamicContext dynamicContext)
{
if (this.ParentFilteringHelpers == null)
{
throw new InvalidOperationException(string.Format("Failed to find parent, are you missing a parent filter for the type '{0}'", this.InterfaceType));
}
ParentFilterHelper helper;
if (this.ParentFilteringHelpers.TryGetValue(parentInterfaceOfInterest, out helper) == false)
{
// We cant find the interface of interest directly, so we will give 'some' parent entity token
// by using 'one' of our own parent id filters
helper = this.ParentFilteringHelpers.First().Value;
}
DataEntityToken dataEntityToken = (DataEntityToken)ownEntityToken;
IData data = dataEntityToken.Data;
Verify.ArgumentCondition(data != null, "ownEntityToken", "Failed to get data");
object parentFieldValue = helper.ParentReferencedPropertyInfo.GetValue(data, null);
ParameterExpression parameterExpression = Expression.Parameter(helper.ParentIdFilterNode.ParentFilterType, "data");
Expression expression = Expression.Equal(
ExpressionHelper.CreatePropertyExpression(helper.ParentRefereePropertyName, parameterExpression),
Expression.Constant(parentFieldValue, helper.ParentReferencedPropertyInfo.PropertyType)
);
Expression whereExpression = ExpressionHelper.CreateWhereExpression(
DataFacade.GetData(helper.ParentIdFilterNode.ParentFilterType).Expression,
parameterExpression, expression
);
IData parentDataItem = ExpressionHelper.GetCastedObjects<IData>(helper.ParentIdFilterNode.ParentFilterType, whereExpression)
.FirstOrDefault();
Verify.IsNotNull(parentDataItem, "Failed to get parent data item. Check if there's a broken parent reference.");
DataEntityToken parentEntityToken = parentDataItem.GetDataEntityToken();
TreeNode parentTreeNode = this.ParentNode;
var dataElementsTreeNode = parentTreeNode as DataElementsTreeNode;
while (dataElementsTreeNode == null ||
dataElementsTreeNode.InterfaceType != parentEntityToken.InterfaceType)
{
parentTreeNode = parentTreeNode.ParentNode;
}
return new AncestorResult(parentTreeNode, parentEntityToken);
}
private AncestorMatch GetAncestorFromParentFilter(TreeNodeDynamicContext dynamicContext)
{
var dataNode = dynamicContext.CurrentTreeNode as DataElementsTreeNode;
if(dataNode == null) return null;
var parentIdFilter = dynamicContext.CurrentTreeNode.FilterNodes.OfType<ParentIdFilterNode>().FirstOrDefault();
if (parentIdFilter == null) return null;
Type ancestorType = parentIdFilter.ParentFilterType;
object key = parentIdFilter.FindParentKeyValue(dynamicContext);
return key == null ? null : new AncestorMatch { InterfaceType = ancestorType, KeyValue = key};
}
private IEnumerable <T> GetCurrentAndLocalizableObjects <T>(TreeNodeDynamicContext dynamicContext, bool includeAllGroupingFields = false)
{
IEnumerable <T> objects = GetObjects <T>(dynamicContext, includeAllGroupingFields);
if (!this.LocalizationEnabled)
{
return(objects);
}
using (new DataScope(UserSettings.ForeignLocaleCultureInfo))
{
var foreignObjects = GetObjects <T>(dynamicContext, includeAllGroupingFields);
return(objects.Concat(foreignObjects).Distinct());
}
}
/// <exclude />
protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
var payload = new StringBuilder();
this.Serialize(payload);
if (this.ParentIdEntries.Count > 0)
{
List<EntityToken> entityTokens = dynamicContext.Piggybag.GetParentEntityTokens().ToList();
entityTokens.Reverse();
entityTokens.Add(dynamicContext.CurrentEntityToken);
entityTokens.Add(entityToken);
entityTokens.Reverse();
foreach (ParentIdEntry parentIdEntry in this.ParentIdEntries)
{
DataEntityToken dataEntityToken = entityTokens.FindDataEntityToken(parentIdEntry.TargetInterface);
if (dataEntityToken == null) continue;
IData data = dataEntityToken.Data;
object keyValue = parentIdEntry.TargetPropertyInfo.GetValue(data, null);
StringConversionServices.SerializeKeyValuePair(payload, parentIdEntry.SourcePropertyName, keyValue);
}
}
StringConversionServices.SerializeKeyValuePair(payload, "_InterfaceType_", InterfaceType);
StringConversionServices.SerializeKeyValuePair(payload, "_IconResourceName_", Icon.ResourceName);
if (!String.IsNullOrEmpty(CustomFormMarkupPath))
{
StringConversionServices.SerializeKeyValuePair(payload, "_CustomFormMarkupPath_", CustomFormMarkupPath);
}
actionAdder(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.GenericAddDataWorkflow"), this.PermissionTypes)
{
Payload = payload.ToString(),
DoIgnoreEntityTokenLocking = true,
ExtraPayload = PiggybagSerializer.Serialize(dynamicContext.Piggybag.PreparePiggybag(dynamicContext.CurrentTreeNode, dynamicContext.CurrentEntityToken))
}))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
private NodeDataSet GetDataset(TreeNodeDynamicContext dynamicContext, bool returnJoinedTableKeys = true)
{
List <object> innerKeys = null;
Expression expression;
if (this.Display == LeafDisplayMode.Compact && this.JoinDataElementsTreeNode != null)
{
expression = CreateJoinExpression(dynamicContext);
}
else if (this.Display == LeafDisplayMode.Auto && this.JoinDataElementsTreeNode != null)
{
expression = CreateSimpleExpression(dynamicContext);
if (returnJoinedTableKeys)
{
//MRJ: Multiple Parent Filter: Not a real problem here as we just make a request for every filter
Expression innerExpression = CreateInnerExpression(dynamicContext, this.JoinParentIdFilterNode, this.JoinDataElementsTreeNode, false);
if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Down)
{
innerExpression.DebugLogExpression("DataElementTreeNode", label: "Parent ids with children expression:");
}
innerKeys = DataFacade.GetData(this.JoinDataElementsTreeNode.CurrentDataInterfaceType).Provider
.CreateQuery(innerExpression)
.ToEnumerableOfObjects()
.ToList();
}
}
else
{
expression = CreateSimpleExpression(dynamicContext);
}
if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Down)
{
expression.DebugLogExpression("DataElementTreeNode");
}
return(new NodeDataSet
{
DataItems = ExpressionHelper.GetCastedObjects <IData>(this.InterfaceType, expression),
JoinedKeys = innerKeys
});
}
public override IEnumerable<EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext)
{
IEntityTokenContainingParentEntityToken containingParentEnitytToken = childEntityToken as IEntityTokenContainingParentEntityToken;
if (containingParentEnitytToken != null)
{
childEntityToken = containingParentEnitytToken.GetParentEntityToken();
}
foreach (EntityToken entityToken in this.ParentNode.GetEntityTokens(childEntityToken, dynamicContext))
{
foreach (var kvp in GetFunctionResult())
{
yield return new TreeFunctionElementGeneratorEntityToken(this.Id, this.Tree.TreeId, EntityTokenSerializer.Serialize(entityToken), kvp.Key);
}
}
}
public Type WorkflowType { get; internal set; } // Requried
protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
WorkflowActionToken actionToken = new WorkflowActionToken(
WorkflowFacade.GetWorkflowType(TypeManager.SerializeType(this.WorkflowType)),
this.PermissionTypes)
{
Payload = this.Serialize(),
ExtraPayload = PiggybagSerializer.Serialize(dynamicContext.Piggybag.PreparePiggybag(dynamicContext.CurrentTreeNode, dynamicContext.CurrentEntityToken)),
DoIgnoreEntityTokenLocking = true
};
actionAdder(new ElementAction(new ActionHandle(actionToken))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
public override IEnumerable<EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext)
{
EntityToken possibleCurrentEntityToken;
TreeSimpleElementEntityToken treeSimpleElementEntityToken = childEntityToken as TreeSimpleElementEntityToken;
if (treeSimpleElementEntityToken != null) {
possibleCurrentEntityToken = treeSimpleElementEntityToken.ParentEntityToken;
}
else
{
possibleCurrentEntityToken = childEntityToken;
}
foreach (EntityToken entityToken in this.ParentNode.GetEntityTokens(possibleCurrentEntityToken, dynamicContext))
{
yield return new TreeSimpleElementEntityToken(this.Id, this.Tree.TreeId, EntityTokenSerializer.Serialize(entityToken));
}
}
protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
ActionToken actionToken = new MessageBoxActionNodeActionToken(
this.TitleDynamicValuesHelper.ReplaceValues(dynamicValuesHelperReplaceContext),
this.MessageDynamicValuesHelper.ReplaceValues(dynamicValuesHelperReplaceContext),
this.Serialize(),
this.PermissionTypes
);
ElementAction elementAction = new ElementAction(new ActionHandle(actionToken))
{
VisualData = this.CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
};
elementAction.VisualData.ActionLocation = this.Location;
actionAdder(elementAction);
}
public IEnumerable <Element> GetElementsByTreeId(string treeId, EntityToken parentEntityToken, Dictionary <string, string> piggybag)
{
Tree tree = GetTree(treeId);
if (tree == null)
{
return new Element[] { }
}
;
var dynamicContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down)
{
Piggybag = piggybag,
CurrentEntityToken = parentEntityToken,
CurrentTreeNode = tree.RootTreeNode
};
return(tree.RootTreeNode.GetElements(parentEntityToken, dynamicContext));
}
private Expression CreateSimpleExpression(TreeNodeDynamicContext dynamicContext)
{
ParameterExpression parameterExpression = Expression.Parameter(this.InterfaceType, "data");
Expression filterExpression = CreateAccumulatedFilterExpression(parameterExpression, this.InterfaceType, dynamicContext);
Expression whereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(this.InterfaceType).Expression, parameterExpression, filterExpression);
Expression resultExpression = whereExpression;
bool isFirst = true;
foreach (OrderByNode orderByNode in this.OrderByNodes)
{
resultExpression = orderByNode.CreateOrderByExpression(resultExpression, parameterExpression, isFirst);
isFirst = false;
}
return(resultExpression);
}
public override Expression CreateUpwardsFilterExpression(ParameterExpression parameterExpression, TreeNodeDynamicContext dynamicContext)
{
DataEntityToken currentEntityToken = dynamicContext.CurrentEntityToken as DataEntityToken;
IData filteredDataItem = null;
Func<IData, bool> upwardsFilter = dataItem =>
{
var ancestorEntityToken = dataItem.GetDataEntityToken();
var replaceContext = new DynamicValuesHelperReplaceContext
{
CurrentDataItem = dataItem,
CurrentEntityToken = ancestorEntityToken,
PiggybagDataFinder = new PiggybagDataFinder(dynamicContext.Piggybag, ancestorEntityToken)
};
XElement markup = this.FunctionMarkupDynamicValuesHelper.ReplaceValues(replaceContext);
BaseRuntimeTreeNode baseRuntimeTreeNode = FunctionTreeBuilder.Build(markup);
LambdaExpression expression = GetLambdaExpression(baseRuntimeTreeNode);
if (expression.Parameters.Count != 1)
{
throw new InvalidOperationException("Only 1 parameter lamdas supported when calling function: " + markup);
}
Delegate compiledExpression = expression.Compile();
if (filteredDataItem == null)
{
filteredDataItem = currentEntityToken.Data;
}
return (bool)compiledExpression.DynamicInvoke(filteredDataItem);
};
return upwardsFilter.Target != null
? Expression.Call(Expression.Constant(upwardsFilter.Target), upwardsFilter.Method, parameterExpression)
: Expression.Call(upwardsFilter.Method, parameterExpression);
}
public override Expression CreateDownwardsFilterExpression(ParameterExpression parameterExpression, TreeNodeDynamicContext dynamicContext)
{
IData parentDataItem = GetParentDataItem(this.ParentFilterType, dynamicContext.CurrentEntityToken, dynamicContext);
if (parentDataItem == null) return null;
object parentFieldValue = this.KeyPropertyInfo.GetValue(parentDataItem, null);
Expression expression = Expression.Equal(ExpressionHelper.CreatePropertyExpression(this.ReferenceFieldName, parameterExpression), Expression.Constant(parentFieldValue, this.ReferencePropertyInfo.PropertyType));
if (ReferencePropertyInfo.PropertyType.IsGenericType && ReferencePropertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
{
PropertyInfo propertyInfo = ReferencePropertyInfo.PropertyType.GetProperty("HasValue");
Expression hasValueExpression = Expression.Property(Expression.Property(parameterExpression, this.ReferenceFieldName), propertyInfo);
expression = Expression.AndAlso(hasValueExpression, expression);
}
return expression;
}
internal object FindParentKeyValue(TreeNodeDynamicContext dynamicContext)
{
if ((dynamicContext.CurrentEntityToken is DataEntityToken))
{
DataEntityToken currentDataEntityToken = dynamicContext.CurrentEntityToken as DataEntityToken;
if (currentDataEntityToken.InterfaceType == this.ParentFilterType)
{
return(this.KeyPropertyInfo.GetValue(currentDataEntityToken.Data, null));
}
}
EntityToken ownFilterEntityToken = FindOwnEntityToken(dynamicContext.CurrentTreeNode, dynamicContext.CurrentEntityToken, dynamicContext);
DataEntityToken dataEntityToken = (DataEntityToken)ownFilterEntityToken;
IData data = dataEntityToken.Data;
object parentFieldValue = this.ReferencePropertyInfo.GetValue(data, null);
return(parentFieldValue);
}
public override Expression CreateDownwardsFilterExpression(ParameterExpression parameterExpression, TreeNodeDynamicContext dynamicContext)
{
var replaceContext = new DynamicValuesHelperReplaceContext(dynamicContext.CurrentEntityToken, dynamicContext.Piggybag);
XElement markup = this.FunctionMarkupDynamicValuesHelper.ReplaceValues(replaceContext);
BaseRuntimeTreeNode baseRuntimeTreeNode = FunctionTreeBuilder.Build(markup);
LambdaExpression expression = GetLambdaExpression(baseRuntimeTreeNode);
if (expression.Parameters.Count != 1)
{
throw new InvalidOperationException("Only 1 parameter lamdas supported when calling function: " + markup);
}
ParameterChangerExpressionVisitor expressionVisitor = new ParameterChangerExpressionVisitor(expression.Parameters.Single(), parameterExpression);
Expression resultExpression = expressionVisitor.Visit(expression.Body);
return resultExpression;
}
/// <exclude />
protected override void OnAddAction(Action<ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
StringBuilder payload = new StringBuilder();
StringConversionServices.SerializeKeyValuePair(payload, "TreeId", this.OwnerNode.Tree.TreeId);
StringConversionServices.SerializeKeyValuePair(payload, "ActionId", this.Id);
WorkflowActionToken actionToken = new WorkflowActionToken(
WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.ReportFunctionActionWorkflow"),
this.PermissionTypes)
{
Payload = this.Serialize(),
ExtraPayload = PiggybagSerializer.Serialize(dynamicContext.Piggybag.PreparePiggybag(dynamicContext.CurrentTreeNode, dynamicContext.CurrentEntityToken)),
DoIgnoreEntityTokenLocking = true
};
actionAdder(new ElementAction(new ActionHandle(actionToken))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
private Expression CreateFilterExpression(ParameterExpression parameterExpression, TreeNodeDynamicContext dynamicContext)
{
object value = ValueTypeConverter.Convert(this.FieldValue, this.PropertyInfo.PropertyType);
Expression valueExpression = Expression.Constant(value, this.PropertyInfo.PropertyType);
Expression expression;
switch (this.Operator)
{
case FieldFilterNodeOperator.Equal:
expression = Expression.Equal(ExpressionHelper.CreatePropertyExpression(this.FieldName, parameterExpression), valueExpression);
break;
case FieldFilterNodeOperator.Inequal:
expression = Expression.NotEqual(ExpressionHelper.CreatePropertyExpression(this.FieldName, parameterExpression), valueExpression);
break;
case FieldFilterNodeOperator.Greater:
expression = Expression.GreaterThan(ExpressionHelper.CreatePropertyExpression(this.FieldName, parameterExpression), valueExpression);
break;
case FieldFilterNodeOperator.GreaterEqual:
expression = Expression.GreaterThanOrEqual(ExpressionHelper.CreatePropertyExpression(this.FieldName, parameterExpression), valueExpression);
break;
case FieldFilterNodeOperator.Lesser:
expression = Expression.LessThan(ExpressionHelper.CreatePropertyExpression(this.FieldName, parameterExpression), valueExpression);
break;
case FieldFilterNodeOperator.LesserEqual:
expression = Expression.LessThanOrEqual(ExpressionHelper.CreatePropertyExpression(this.FieldName, parameterExpression), valueExpression);
break;
default:
throw new NotImplementedException();
}
return expression;
}
private Expression CreateJoinExpression(TreeNodeDynamicContext dynamicContext)
{
//MRJ: Multiple Parent Filter: Here we have to make either multiple calls or create a multiple inner join, kinda hard
// Create inner expression tree
Expression innerDistinctExpression = CreateInnerExpression(dynamicContext, this.JoinParentIdFilterNode, this.JoinDataElementsTreeNode);
// Create outer expression tree
ParameterExpression outerParameterExpression = Expression.Parameter(this.InterfaceType, "outerData");
Expression outerFilterExpression = CreateAccumulatedFilterExpression(outerParameterExpression, this.InterfaceType, dynamicContext);
Expression outerWhereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(this.InterfaceType).Expression, outerParameterExpression, outerFilterExpression);
Expression outerResultExpression = outerWhereExpression;
bool isFirst = true;
foreach (OrderByNode orderByNode in this.OrderByNodes)
{
outerResultExpression = orderByNode.CreateOrderByExpression(outerResultExpression, outerParameterExpression, isFirst);
isFirst = false;
}
// Create join lambda expressions
PropertyInfo outerKeyPropertyInfo = this.KeyPropertyInfo;
LambdaExpression outerKeySelectorExpression = Expression.Lambda(Expression.Property(outerParameterExpression, outerKeyPropertyInfo), outerParameterExpression);
ParameterExpression innerKeySelectorParameterExpression = Expression.Parameter(this.JoinInnerKeyReferencePropertyInfo.PropertyType, "innerKeyParam");
LambdaExpression innerKeySelectorExpression = Expression.Lambda(innerKeySelectorParameterExpression, innerKeySelectorParameterExpression);
ParameterExpression parameterExpression1 = Expression.Parameter(this.InterfaceType, "param1");
ParameterExpression parameterExpression2 = Expression.Parameter(outerKeyPropertyInfo.PropertyType, "param2");
LambdaExpression resultSelector = Expression.Lambda(parameterExpression1, parameterExpression1, parameterExpression2);
Expression joinExpression = ExpressionHelper.CreateJoinExpression(outerResultExpression, innerDistinctExpression, outerKeySelectorExpression, innerKeySelectorExpression, resultSelector);
return(joinExpression);
}
protected override IEnumerable<Element> OnGetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
foreach (var kvp in GetFunctionResult())
{
Element element = new Element(new ElementHandle(
dynamicContext.ElementProviderName,
new TreeFunctionElementGeneratorEntityToken(this.Id.ToString(), this.Tree.TreeId, EntityTokenSerializer.Serialize(parentEntityToken), kvp.Key),
dynamicContext.Piggybag.PreparePiggybag(this.ParentNode, parentEntityToken)
));
element.VisualData = new ElementVisualizedData
{
Label = kvp.Value,
ToolTip = kvp.Value,
HasChildren = ChildNodes.Count() > 0,
Icon = Core.ResourceSystem.ResourceHandle.BuildIconFromDefaultProvider("folder"),
OpenedIcon = Core.ResourceSystem.ResourceHandle.BuildIconFromDefaultProvider("folder")
};
yield return element;
}
}
internal override IEnumerable<EntityToken> FilterParentGeneretedEntityTokens(EntityToken selfEntityToken, IEnumerable<EntityToken> parentGeneretedEntityTokens, TreeNodeDynamicContext dynamicContext)
{
// Check below ensures that the parent EntityToken actually present in a tree and not been filtered out
TreeSimpleElementEntityToken treeSimpleElementEntityToken = (TreeSimpleElementEntityToken) selfEntityToken;
EntityToken parentEntityToken = treeSimpleElementEntityToken.ParentEntityToken;
foreach (EntityToken entityToken in parentGeneretedEntityTokens)
{
if (parentEntityToken.Equals(entityToken))
{
return new[] { parentEntityToken };
}
TreeSimpleElementEntityToken castedEntityToken = entityToken as TreeSimpleElementEntityToken;
if ((castedEntityToken != null) &&
(parentEntityToken.Equals(castedEntityToken.ParentEntityToken)))
{
return new [] { parentEntityToken };
}
}
return new EntityToken[0];
}
private AncestorMatch GetAncestorFromParentFilter(TreeNodeDynamicContext dynamicContext)
{
var dataNode = dynamicContext.CurrentTreeNode as DataElementsTreeNode;
if (dataNode == null)
{
return(null);
}
var parentIdFilter = dynamicContext.CurrentTreeNode.FilterNodes.OfType <ParentIdFilterNode>().FirstOrDefault();
if (parentIdFilter == null)
{
return(null);
}
Type ancestorType = parentIdFilter.ParentFilterType;
object key = parentIdFilter.FindParentKeyValue(dynamicContext);
return(key == null ? null : new AncestorMatch {
InterfaceType = ancestorType, KeyValue = key
});
}
/// <exclude />
public IEnumerable <Element> GetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
IEnumerable <Element> elements = OnGetElements(parentEntityToken, dynamicContext);
var localizeDataWorkflow = WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.LocalizeDataWorkflow");
foreach (Element element in elements)
{
bool isForeignLocaleDataItem = element.Actions
.Any(x => x.ActionHandle.ActionToken is WorkflowActionToken &&
((WorkflowActionToken)x.ActionHandle.ActionToken).WorkflowType == localizeDataWorkflow);
if (!isForeignLocaleDataItem)
{
foreach (ActionNode actionNode in this.ActionNodes)
{
actionNode.AddAction(element.AddAction, element.ElementHandle.EntityToken, dynamicContext);
}
}
yield return(element);
}
}
public override IEnumerable<EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext)
{
TreeSimpleElementEntityToken treeSimpleElementEntityToken = childEntityToken as TreeSimpleElementEntityToken;
if (treeSimpleElementEntityToken != null)
{
yield return treeSimpleElementEntityToken.ParentEntityToken;
}
else
{
AncestorMatch ancestorFromFilter = GetAncestorFromParentFilter(dynamicContext);
foreach (IAttachmentPoint attachmentPoint in this.Tree.AttachmentPoints)
{
if(attachmentPoint is DynamicDataItemAttachmentPoint
&& ancestorFromFilter != null)
{
var dynamicAttachmentPoint = attachmentPoint as DynamicDataItemAttachmentPoint;
if (ancestorFromFilter.InterfaceType == dynamicAttachmentPoint.InterfaceType)
{
if (dynamicAttachmentPoint.KeyValue.Equals(ancestorFromFilter.KeyValue))
{
foreach (var e in dynamicAttachmentPoint.GetEntityTokens(null, null)) {
yield return e;
}
}
continue;
}
}
foreach (EntityToken entityToken in attachmentPoint.GetEntityTokens(childEntityToken, dynamicContext))
{
yield return entityToken;
}
}
}
}
/// <summary> /// This is call when this nodes entity tokens are needed to climb up the tree. /// If this tree nodes elements dont have any children, then this method will not be called. /// </summary> /// <param name="childEntityToken">The child entity token.</param> /// <param name="dynamicContext">The dynamic context.</param> /// <returns></returns> public abstract IEnumerable<EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext);
private static void DoInitialize(string elementAttachingProviderName)
{
var sharedRootFolders = new Dictionary<string, CustomTreePerspectiveInfo>();
var treeNodeDynamicContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down);
treeNodeDynamicContext.Piggybag = new Dictionary<string, string>();
foreach (var tree in TreeFacade.AllTrees)
{
if (!tree.ShareRootElementById) continue;
IEnumerable<NamedAttachmentPoint> namedAttachmentPoints =
tree.AttachmentPoints.
OfType<NamedAttachmentPoint>();
if (namedAttachmentPoints.Count() != 1) continue;
if (tree.RootTreeNode.ChildNodes.Count() != 1) continue;
SimpleElementTreeNode childTreeNode = tree.RootTreeNode.ChildNodes.Single() as SimpleElementTreeNode;
if (childTreeNode == null) continue;
NamedAttachmentPoint namedAttachmentPoint = namedAttachmentPoints.Single();
EntityToken perspectiveEntityToken;
if (!sharedRootFolders.ContainsKey(childTreeNode.Id))
{
perspectiveEntityToken = new TreePerspectiveEntityToken(childTreeNode.Id);
var dynamicValuesHelperReplaceContext = new DynamicValuesHelperReplaceContext(
namedAttachmentPoint.AttachingPoint.EntityToken,
null);
// MRJ: Collection actions
Element element = new Element(new ElementHandle(elementAttachingProviderName, perspectiveEntityToken))
{
VisualData = new ElementVisualizedData
{
Label = childTreeNode.LabelDynamicValuesHelper.ReplaceValues(dynamicValuesHelperReplaceContext),
ToolTip = childTreeNode.ToolTipDynamicValuesHelper.ReplaceValues(dynamicValuesHelperReplaceContext),
HasChildren = true,
Icon = childTreeNode.Icon,
OpenedIcon = childTreeNode.OpenIcon
}
};
sharedRootFolders.Add(childTreeNode.Id, new CustomTreePerspectiveInfo
{
AttachmentPoint = new NamedAttachmentPoint
{
AttachingPoint = new AttachingPoint(namedAttachmentPoint.AttachingPoint),
Position = namedAttachmentPoint.Position
},
Element = element,
Trees = new List<Tree> { tree }
});
}
else
{
perspectiveEntityToken = sharedRootFolders[childTreeNode.Id].Element.ElementHandle.EntityToken;
sharedRootFolders[childTreeNode.Id].Trees.Add(tree);
}
namedAttachmentPoint.AttachingPoint = new AttachingPoint(perspectiveEntityToken);
tree.RootTreeNode = childTreeNode;
}
_sharedRootFolders = sharedRootFolders;
}
public Dictionary <EntityToken, IEnumerable <EntityToken> > GetParents(IEnumerable <EntityToken> entityTokens)
{
Dictionary <EntityToken, IEnumerable <EntityToken> > result = new Dictionary <EntityToken, IEnumerable <EntityToken> >();
foreach (EntityToken entityToken in entityTokens)
{
TreeNodeDynamicContext dynamicContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Up)
{
CurrentEntityToken = entityToken
};
if (entityToken is TreeSimpleElementEntityToken ||
entityToken is TreeFunctionElementGeneratorEntityToken)
{
var parentEntityTokenSource = entityToken as IEntityTokenContainingParentEntityToken;
try
{
result.Add(entityToken, new[] { parentEntityTokenSource.GetParentEntityToken() });
}
catch (Exception ex)
{
string treeId;
if (entityToken is TreeSimpleElementEntityToken)
{
treeId = (entityToken as TreeSimpleElementEntityToken).TreeNodeId;
}
else if (entityToken is TreeFunctionElementGeneratorEntityToken)
{
treeId = (entityToken as TreeFunctionElementGeneratorEntityToken).TreeNodeId;
}
else
{
throw new InvalidOperationException("This code should not be reachable.");
}
Log.LogError("TreeFacade", "The tree '{0}' failed to return parent entity tokens and are ignored", treeId);
Log.LogError("TreeFacade", ex);
}
}
else if (entityToken is TreeDataFieldGroupingElementEntityToken)
{
TreeDataFieldGroupingElementEntityToken treeDataFieldGroupingElementEntityToken = entityToken as TreeDataFieldGroupingElementEntityToken;
string treeId = entityToken.Source;
try
{
Tree tree = TreeFacade.GetTree(treeId);
string treeNodeId = treeDataFieldGroupingElementEntityToken.TreeNodeId;
TreeNode treeNode = tree.GetTreeNode(treeNodeId);
dynamicContext.FieldGroupingValues = treeDataFieldGroupingElementEntityToken.GroupingValues;
dynamicContext.FieldFolderRangeValues = treeDataFieldGroupingElementEntityToken.FolderRangeValues;
dynamicContext.CurrentTreeNode = treeNode;
result.Add(entityToken, treeNode.ParentNode.GetEntityTokens(entityToken, dynamicContext));
}
catch (Exception ex)
{
Log.LogError("TreeFacade", $"The tree '{treeId}' failed to return parent entity tokens and are ignored");
Log.LogError("TreeFacade", ex);
}
}
else if (entityToken is DataEntityToken)
{
DataEntityToken dataEntityToken = entityToken as DataEntityToken;
Type interfaceType = dataEntityToken.InterfaceType;
foreach (Tree tree in TreeFacade.AllTrees)
{
List <TreeNode> treeNodes;
if (!tree.BuildProcessContext.DataInteraceToTreeNodes.TryGetValue(interfaceType, out treeNodes))
{
continue;
}
IEnumerable <EntityToken> concatList = null;
foreach (TreeNode treeNode in treeNodes)
{
try
{
dynamicContext.CurrentTreeNode = treeNode;
concatList = concatList.ConcatOrDefault(treeNode.ParentNode.GetEntityTokens(entityToken, dynamicContext));
}
catch (Exception ex)
{
Log.LogError("TreeFacade", $"The tree '{treeNode.Tree.TreeId}' failed to return parent entity tokens and are ignored");
Log.LogError("TreeFacade", ex);
}
}
if (concatList != null)
{
// Filtering the current element to avoid loops while resolving security
concatList = concatList.Where(e => !entityToken.Equals(e));
IEnumerable <EntityToken> existingList;
if (result.TryGetValue(entityToken, out existingList))
{
result[entityToken] = existingList.Concat(concatList);
}
else
{
result.Add(entityToken, concatList);
}
}
}
}
else if (entityToken is TreePerspectiveEntityToken)
{
result.Add(entityToken, new[] { TreeSharedRootsFacade.SharedRootFolders[entityToken.Id].AttachmentPoint.AttachingPoint.EntityToken });
}
}
return(result);
}
/// <exclude />
public override IEnumerable <EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext)
{
IEnumerable <IData> dataset = GetDataset(dynamicContext, false).DataItems;
return(dataset.Select(f => (EntityToken)f.GetDataEntityToken()).Evaluate());
}
internal override IEnumerable <EntityToken> FilterParentGeneretedEntityTokens(EntityToken selfEntityToken, IEnumerable <EntityToken> parentGeneretedEntityTokens, TreeNodeDynamicContext dynamicContext)
{
// Check below ensures that the parent EntityToken actually present in a tree and not been filtered out
TreeSimpleElementEntityToken treeSimpleElementEntityToken = (TreeSimpleElementEntityToken)selfEntityToken;
EntityToken parentEntityToken = treeSimpleElementEntityToken.ParentEntityToken;
foreach (EntityToken entityToken in parentGeneretedEntityTokens)
{
if (parentEntityToken.Equals(entityToken))
{
return(new[] { parentEntityToken });
}
TreeSimpleElementEntityToken castedEntityToken = entityToken as TreeSimpleElementEntityToken;
if ((castedEntityToken != null) &&
(parentEntityToken.Equals(castedEntityToken.ParentEntityToken)))
{
return(new [] { parentEntityToken });
}
}
return(new EntityToken[0]);
}
/// <exclude />
protected override void OnAddAction(Action <ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
var payload = new StringBuilder();
this.Serialize(payload);
if (this.ParentIdEntries.Count > 0)
{
List <EntityToken> entityTokens = dynamicContext.Piggybag.GetParentEntityTokens().ToList();
entityTokens.Reverse();
entityTokens.Add(dynamicContext.CurrentEntityToken);
entityTokens.Add(entityToken);
entityTokens.Reverse();
foreach (ParentIdEntry parentIdEntry in this.ParentIdEntries)
{
DataEntityToken dataEntityToken = entityTokens.FindDataEntityToken(parentIdEntry.TargetInterface);
if (dataEntityToken == null)
{
continue;
}
IData data = dataEntityToken.Data;
object keyValue = parentIdEntry.TargetPropertyInfo.GetValue(data, null);
StringConversionServices.SerializeKeyValuePair(payload, parentIdEntry.SourcePropertyName, keyValue);
}
}
StringConversionServices.SerializeKeyValuePair(payload, "_InterfaceType_", InterfaceType);
StringConversionServices.SerializeKeyValuePair(payload, "_IconResourceName_", Icon.ResourceName);
if (!String.IsNullOrEmpty(CustomFormMarkupPath))
{
StringConversionServices.SerializeKeyValuePair(payload, "_CustomFormMarkupPath_", CustomFormMarkupPath);
}
actionAdder(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.GenericAddDataWorkflow"), this.PermissionTypes)
{
Payload = payload.ToString(),
DoIgnoreEntityTokenLocking = true,
ExtraPayload = PiggybagSerializer.Serialize(dynamicContext.Piggybag.PreparePiggybag(dynamicContext.CurrentTreeNode, dynamicContext.CurrentEntityToken))
}))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
protected override IEnumerable <Element> OnGetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
var entityToken = new TreeSimpleElementEntityToken(
this.Id,
this.Tree.TreeId,
EntityTokenSerializer.Serialize(parentEntityToken));
Element element = new Element(new ElementHandle(
dynamicContext.ElementProviderName,
entityToken,
dynamicContext.Piggybag.PreparePiggybag(this.ParentNode, parentEntityToken)
));
if (parentEntityToken is TreePerspectiveEntityToken)
{
element.ElementHandle.Piggyback[StringConstants.PiggybagTreeId] = Tree.TreeId;
}
var replaceContext = new DynamicValuesHelperReplaceContext(parentEntityToken, dynamicContext.Piggybag);
element.VisualData = new ElementVisualizedData
{
Label = this.LabelDynamicValuesHelper.ReplaceValues(replaceContext),
ToolTip = this.ToolTipDynamicValuesHelper.ReplaceValues(replaceContext),
HasChildren = ChildNodes.Any(),
Icon = this.Icon,
OpenedIcon = this.OpenIcon
};
yield return(element);
}
public override AncestorResult GetParentEntityToken(EntityToken childEntityToken, Type parentInterfaceOfInterest, TreeNodeDynamicContext dynamicContext)
{
throw new NotImplementedException("Should never get called");
}
private List <T> GetObjects <T>(TreeNodeDynamicContext dynamicContext)
{
Expression expression = GetObjectsExpression(dynamicContext);
return(ExpressionHelper.GetCastedObjects <T>(this.InterfaceType, expression));
}
/// <summary> /// This is called when this nodes elements are needed to create next sub level of tree elements. /// </summary> /// <param name="parentEntityToken"></param> /// <param name="dynamicContext"></param> /// <returns></returns> protected abstract IEnumerable<Element> OnGetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext);
/// <exclude />
public override AncestorResult GetParentEntityToken(EntityToken ownEntityToken, Type parentInterfaceOfInterest, TreeNodeDynamicContext dynamicContext)
{
if (this.ParentFilteringHelpers == null)
{
throw new InvalidOperationException(string.Format("Failed to find parent, are you missing a parent filter for the type '{0}'", this.InterfaceType));
}
ParentFilterHelper helper;
if (this.ParentFilteringHelpers.TryGetValue(parentInterfaceOfInterest, out helper) == false)
{
// We cant find the interface of interest directly, so we will give 'some' parent entity token
// by using 'one' of our own parent id filters
helper = this.ParentFilteringHelpers.First().Value;
}
DataEntityToken dataEntityToken = (DataEntityToken)ownEntityToken;
IData data = dataEntityToken.Data;
Verify.ArgumentCondition(data != null, "ownEntityToken", "Failed to get data");
object parentFieldValue = helper.ParentReferencedPropertyInfo.GetValue(data, null);
ParameterExpression parameterExpression = Expression.Parameter(helper.ParentIdFilterNode.ParentFilterType, "data");
Expression expression = Expression.Equal(
ExpressionHelper.CreatePropertyExpression(helper.ParentRefereePropertyName, parameterExpression),
Expression.Constant(parentFieldValue, helper.ParentReferencedPropertyInfo.PropertyType)
);
Expression whereExpression = ExpressionHelper.CreateWhereExpression(
DataFacade.GetData(helper.ParentIdFilterNode.ParentFilterType).Expression,
parameterExpression, expression
);
IData parentDataItem = ExpressionHelper.GetCastedObjects <IData>(helper.ParentIdFilterNode.ParentFilterType, whereExpression)
.FirstOrDefault();
Verify.IsNotNull(parentDataItem, "Failed to get parent data item. Check if there's a broken parent reference.");
DataEntityToken parentEntityToken = parentDataItem.GetDataEntityToken();
TreeNode parentTreeNode = this.ParentNode;
var dataElementsTreeNode = parentTreeNode as DataElementsTreeNode;
while (dataElementsTreeNode == null ||
dataElementsTreeNode.InterfaceType != parentEntityToken.InterfaceType)
{
parentTreeNode = parentTreeNode.ParentNode;
}
return(new AncestorResult(parentTreeNode, parentEntityToken));
}
/// <exclude />
protected override void OnAddAction(Action <ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
StringBuilder payload = new StringBuilder();
StringConversionServices.SerializeKeyValuePair(payload, "TreeId", this.OwnerNode.Tree.TreeId);
StringConversionServices.SerializeKeyValuePair(payload, "ActionId", this.Id);
WorkflowActionToken actionToken = new WorkflowActionToken(
WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.ReportFunctionActionWorkflow"),
this.PermissionTypes)
{
Payload = this.Serialize(),
ExtraPayload = PiggybagSerializer.Serialize(dynamicContext.Piggybag.PreparePiggybag(dynamicContext.CurrentTreeNode, dynamicContext.CurrentEntityToken)),
DoIgnoreEntityTokenLocking = true
};
actionAdder(new ElementAction(new ActionHandle(actionToken))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
} // Requried
protected override void OnAddAction(Action <ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
WorkflowActionToken actionToken = new WorkflowActionToken(
WorkflowFacade.GetWorkflowType(TypeManager.SerializeType(this.WorkflowType)),
this.PermissionTypes)
{
Payload = this.Serialize(),
ExtraPayload = PiggybagSerializer.Serialize(dynamicContext.Piggybag.PreparePiggybag(dynamicContext.CurrentTreeNode, dynamicContext.CurrentEntityToken)),
DoIgnoreEntityTokenLocking = true
};
actionAdder(new ElementAction(new ActionHandle(actionToken))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
public override IEnumerable <EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext)
{
TreeSimpleElementEntityToken treeSimpleElementEntityToken = childEntityToken as TreeSimpleElementEntityToken;
if (treeSimpleElementEntityToken != null)
{
yield return(treeSimpleElementEntityToken.ParentEntityToken);
}
else
{
AncestorMatch ancestorFromFilter = GetAncestorFromParentFilter(dynamicContext);
foreach (IAttachmentPoint attachmentPoint in this.Tree.AttachmentPoints)
{
if (attachmentPoint is DynamicDataItemAttachmentPoint &&
ancestorFromFilter != null)
{
var dynamicAttachmentPoint = attachmentPoint as DynamicDataItemAttachmentPoint;
if (ancestorFromFilter.InterfaceType == dynamicAttachmentPoint.InterfaceType)
{
if (dynamicAttachmentPoint.KeyValue.Equals(ancestorFromFilter.KeyValue))
{
foreach (var e in dynamicAttachmentPoint.GetEntityTokens(null, null))
{
yield return(e);
}
}
continue;
}
}
foreach (EntityToken entityToken in attachmentPoint.GetEntityTokens(childEntityToken, dynamicContext))
{
yield return(entityToken);
}
}
}
}
public override Expression CreateUpwardsFilterExpression(ParameterExpression parameterExpression, TreeNodeDynamicContext dynamicContext)
{
return CreateFilterExpression(parameterExpression, dynamicContext);
}
private List <object> GetObjects(TreeNodeDynamicContext dynamicContext, bool includeAllGroupingFields = false)
{
Expression expression = GetObjectsExpression(dynamicContext, includeAllGroupingFields);
return(ExpressionHelper.GetObjects(this.InterfaceType, expression));
}
public override AncestorResult GetParentEntityToken(EntityToken ownEntityToken, Type parentInterfaceOfInterest, TreeNodeDynamicContext dynamicContext)
{
return(new AncestorResult(this.ParentNode, ((TreeSimpleElementEntityToken)ownEntityToken).ParentEntityToken));
}
protected override IEnumerable <Element> OnGetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
foreach (TreeNode childTreeNode in this.ChildNodes)
{
foreach (Element element in childTreeNode.GetElements(parentEntityToken, dynamicContext))
{
element.ElementHandle.Piggyback[StringConstants.PiggybagTreeId] = this.Tree.TreeId;
yield return(element);
}
}
}
public IEnumerable<ElementAction> GetActions(EntityToken entityToken)
{
if (TreeFacade.HasPossibleAttachmentPoints(entityToken))
{
yield return new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.AddApplicationWorkflow"), AddPermissionTypes) { DoIgnoreEntityTokenLocking = true }))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "AddApplicationWorkflow.AddApplication.Label"),
ToolTip = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "AddApplicationWorkflow.AddApplication.ToolTip"),
Icon = AddApplicationIcon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Other,
IsInFolder = false,
IsInToolbar = false,
ActionGroup = ApplicationsActionGroup
}
}
};
yield return new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.RemoveApplicationWorkflow"), RemovePermissionTypes) { DoIgnoreEntityTokenLocking = true }))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "RemoveApplicationWorkflow.RemoveApplication.Label"),
ToolTip = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "RemoveApplicationWorkflow.RemoveApplication.ToolTip"),
Icon = RemoveApplicationIcon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Other,
IsInFolder = false,
IsInToolbar = false,
ActionGroup = ApplicationsActionGroup
}
}
};
}
List<ElementAction> elementActions = new List<ElementAction>();
foreach (Tree tree in TreeFacade.GetTreesByEntityToken(entityToken))
{
TreeNodeDynamicContext dynamicContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down)
{
CurrentTreeNode = tree.RootTreeNode,
CurrentEntityToken = entityToken,
Piggybag = new Dictionary<string, string>()
};
foreach (ActionNode actionNode in tree.RootTreeNode.ActionNodes)
{
actionNode.AddAction(f => elementActions.Add(f), entityToken, dynamicContext);
}
}
foreach (ElementAction elementAction in elementActions)
{
yield return elementAction;
}
}
/// <exclude />
public IEnumerable<Element> GetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
IEnumerable<Element> elements = OnGetElements(parentEntityToken, dynamicContext);
var localizeDataWorkflow = WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.LocalizeDataWorkflow");
foreach (Element element in elements)
{
bool isForeignLocaleDataItem = element.Actions
.Any(x => x.ActionHandle.ActionToken is WorkflowActionToken
&& ((WorkflowActionToken)x.ActionHandle.ActionToken).WorkflowType == localizeDataWorkflow);
if (!isForeignLocaleDataItem)
{
foreach (ActionNode actionNode in this.ActionNodes)
{
actionNode.AddAction(element.AddAction, element.ElementHandle.EntityToken, dynamicContext);
}
}
yield return element;
}
}
private IData GetParentDataItem(Type parentType, EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
if (dynamicContext.CustomData.ContainsKey("ParentData"))
{
return((IData)dynamicContext.CustomData["ParentData"]);
}
IData parentDataItem = null;
if (parentEntityToken is DataEntityToken)
{
DataEntityToken dataEntityToken = parentEntityToken as DataEntityToken;
Type type = dataEntityToken.InterfaceType;
if (type == parentType)
{
return(dataEntityToken.Data);
}
}
if (parentDataItem == null)
{
foreach (EntityToken entityToken in dynamicContext.Piggybag.GetParentEntityTokens())
{
DataEntityToken dataEntityToken = entityToken as DataEntityToken;
if (dataEntityToken == null)
{
continue;
}
Type type = dataEntityToken.InterfaceType;
if (type != parentType)
{
continue;
}
return(dataEntityToken.Data);
}
}
throw new InvalidOperationException();
}
/// <exclude />
protected override IEnumerable <Element> OnGetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
bool localizationEnabled = this.ShowForeignItems && !UserSettings.ActiveLocaleCultureInfo.Equals(UserSettings.ForeignLocaleCultureInfo);
NodeDataSet dataset = GetDataset(dynamicContext);
var itemKeys = new List <object>();
IEnumerable <IData> dataItems;
IEnumerable <object> keysJoinedByParentFilters = dataset.JoinedKeys;
if (localizationEnabled && UserSettings.ForeignLocaleCultureInfo != null)
{
NodeDataSet foreignDataset;
using (new DataScope(UserSettings.ForeignLocaleCultureInfo))
{
foreignDataset = GetDataset(dynamicContext);
}
ParameterExpression parameterExpression = Expression.Parameter(this.InterfaceType, "data");
IEnumerable combinedData = dataset.DataItems.Concat(foreignDataset.DataItems).ToCastedDataEnumerable(this.InterfaceType);
Expression orderByExpression = this.CreateOrderByExpression(combinedData.AsQueryable().Expression, parameterExpression);
dataItems = combinedData.AsQueryable().Provider.CreateQuery <IData>(orderByExpression);
foreach (IData data in dataset.DataItems)
{
Verify.IsNotNull(data, "Fetching data for data interface '{0}' with expression '{1}' yielded an null element".FormatWith(this.InterfaceType, orderByExpression));
object keyValue = this.KeyPropertyInfo.GetValue(data, null);
itemKeys.Add(keyValue);
}
keysJoinedByParentFilters = keysJoinedByParentFilters.ConcatOrDefault(foreignDataset.JoinedKeys);
}
else
{
dataItems = dataset.DataItems;
itemKeys = new List <object>();
}
var replaceContext = new DynamicValuesHelperReplaceContext(parentEntityToken, dynamicContext.Piggybag);
var elements = new List <Element>();
foreach (IData data in dataItems)
{
Verify.IsNotNull(data, "Fetching data for data interface '{0}' yielded an null element".FormatWith(this.InterfaceType));
var element = BuildElement(data, replaceContext, dynamicContext, localizationEnabled, itemKeys, ref keysJoinedByParentFilters, parentEntityToken);
if (element == null)
{
continue;
}
elements.Add(element);
}
if (!this.OrderByNodes.Any())
{
return(elements.OrderBy(f => f.VisualData.Label));
}
return(elements);
}
public override AncestorResult GetParentEntityToken(EntityToken childEntityToken, Type parentInterfaceOfInterest, TreeNodeDynamicContext dynamicContext)
{
throw new NotImplementedException("Should never get called");
}
internal override Expression CreateFilterExpression(ParameterExpression parameterExpression, TreeNodeDynamicContext dynamicContext, IList <int> filtersToSkip = null)
{
var dataEntityToken = dynamicContext.CurrentEntityToken as DataEntityToken;
var treeSimpleElementEntityToken = dynamicContext.CurrentEntityToken as TreeSimpleElementEntityToken;
Expression fieldExpression = ExpressionHelper.CreatePropertyExpression(this.InterfaceType, this.PropertyInfo.DeclaringType, this.FieldName, parameterExpression);
object value;
Func <Expression> resultFilterExpressionFactory = () =>
this.UseChildGeneratingFilterExpression
? this.ChildGeneratingDataElementsTreeNode.CreateFilterExpression(parameterExpression, dynamicContext)
: null;
if (this.FolderRanges == null)
{
if (dynamicContext.FieldGroupingValues.ContainsKey(this.GroupingValuesFieldName))
{
value = dynamicContext.FieldGroupingValues[this.GroupingValuesFieldName];
}
else if (dataEntityToken != null)
{
if (CreateFilterExpression_GetValueFromDataEntityToken(dataEntityToken, out value) == false)
{
return(resultFilterExpressionFactory());
}
}
else if (treeSimpleElementEntityToken != null &&
treeSimpleElementEntityToken.ParentEntityToken is DataEntityToken)
{
var parentDataEntityToken = treeSimpleElementEntityToken.ParentEntityToken as DataEntityToken;
if (CreateFilterExpression_GetValueFromDataEntityToken(parentDataEntityToken, out value) == false)
{
return(resultFilterExpressionFactory());
}
}
else if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Down)
{
// We shall not create filter for our self when unfolding
return(resultFilterExpressionFactory());
}
else if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Up)
{
// At this point we are going upwards, building the filter and one or
// more of the parent elements has not been opened, so we are not able to
// create a filter.
// This will happen if a parent filter is below us
return(null);
}
else
{
// This will only happen if we are searching up and are given another entity token that
// TreeDataFieldGroupingElementEntityToken and DataEntityToken or TreeSimpleElementEntityToken
throw new NotImplementedException(string.Format("Unsupported child entity token type '{0}'", dynamicContext.CurrentEntityToken.GetType()));
}
}
else
{
if (dynamicContext.FieldFolderRangeValues.ContainsKey(this.FieldName))
{
value = dynamicContext.FieldFolderRangeValues[this.FieldName];
}
else if (dataEntityToken != null)
{
if (CreateFilterExpression_GetFolderIndexFromDataEntityToken(dataEntityToken, parameterExpression, fieldExpression, out value) == false)
{
return(resultFilterExpressionFactory());
}
}
else if (treeSimpleElementEntityToken != null &&
treeSimpleElementEntityToken.ParentEntityToken is DataEntityToken)
{
DataEntityToken parentDataEntityToken = treeSimpleElementEntityToken.ParentEntityToken as DataEntityToken;
if (CreateFilterExpression_GetFolderIndexFromDataEntityToken(parentDataEntityToken, parameterExpression, fieldExpression, out value) == false)
{
return(resultFilterExpressionFactory());
}
}
else if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Down)
{
// We shall not create filter for our self when unfolding
return(resultFilterExpressionFactory());
}
else if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Up)
{
// At this point we are going upwards, building the filter and one or
// more of the parent elements has not been opened, so we are not able to
// create a filter.
// This will happen if a parent filter is below us
return(null);
}
else
{
// This will only happen if we are searching up and are given another entity token that
// TreeDataFieldGroupingElementEntityToken and DataEntityToken or TreeSimpleElementEntityToken
throw new NotImplementedException(string.Format("Unsupported child entity token type '{0}'", dynamicContext.CurrentEntityToken.GetType()));
}
}
Expression filterExpression;
if (this.FolderRanges != null)
{
int folderRangeIndex = (int)value;
filterExpression = CreateFolderRangeFilterExpression(folderRangeIndex, fieldExpression);
}
else if (this.FirstLetterOnly)
{
filterExpression = CreateFirstLetterOnlyFilterExpression(value, fieldExpression);
}
else
{
filterExpression = CreateSimpleFilterExpression(value, fieldExpression);
}
if (dynamicContext.Direction == TreeNodeDynamicContextDirection.Down)
{
if (this.UseChildGeneratingFilterExpression)
{
Expression childFilerExpression = this.ChildGeneratingDataElementsTreeNode.CreateFilterExpression(parameterExpression, dynamicContext);
filterExpression = filterExpression.NestedAnd(childFilerExpression);
}
}
return(filterExpression);
}
private Element BuildElement(IData data,
DynamicValuesHelperReplaceContext replaceContext,
TreeNodeDynamicContext dynamicContext,
bool localizationEnabled,
List <object> itemKeys,
ref IEnumerable <object> keysJoinedByParentFilters,
EntityToken parentEntityToken
)
{
replaceContext.CurrentDataItem = data;
object keyValue = this.KeyPropertyInfo.GetValue(data, null);
bool itemLocalizationEnabledAndForeign = localizationEnabled && !data.DataSourceId.LocaleScope.Equals(UserSettings.ActiveLocaleCultureInfo);
if (itemLocalizationEnabledAndForeign && itemKeys.Contains(keyValue))
{
return(null);
}
var currentEntityToken = data.GetDataEntityToken();
var element = new Element(new ElementHandle
(
dynamicContext.ElementProviderName,
currentEntityToken,
dynamicContext.Piggybag.PreparePiggybag(this.ParentNode, parentEntityToken)
));
bool hasChildren;
bool isDisabled = false;
ResourceHandle icon, openedIcon;
if (itemLocalizationEnabledAndForeign)
{
hasChildren = false;
isDisabled = !data.IsTranslatable();
if (this.Icon != null)
{
icon = this.Icon;
openedIcon = this.OpenedIcon;
}
else
{
icon = data.GetForeignIcon();
openedIcon = icon;
}
}
else
{
if (this.Display != LeafDisplayMode.Auto)
{
hasChildren = ChildNodes.Any();
}
else
{
hasChildren = ChildNodes.OfType <SimpleElementTreeNode>().Any();
if (!hasChildren)
{
if (keysJoinedByParentFilters != null)
{
keysJoinedByParentFilters = keysJoinedByParentFilters.Evaluate();
hasChildren = keysJoinedByParentFilters.Contains(keyValue);
}
}
// Checking children filtered by FunctionFilters
if (!hasChildren)
{
foreach (var childNode in this.ChildNodes.OfType <DataElementsTreeNode>()
.Where(n => n.FilterNodes.OfType <FunctionFilterNode>().Any()))
{
var newDynamicContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down)
{
ElementProviderName = dynamicContext.ElementProviderName,
Piggybag = dynamicContext.Piggybag.PreparePiggybag(this.ParentNode, parentEntityToken),
CurrentEntityToken = currentEntityToken
};
if (childNode.GetDataset(newDynamicContext, false).DataItems.Any())
{
hasChildren = true;
break;
}
}
}
}
if (this.Icon != null)
{
icon = this.Icon;
openedIcon = this.OpenedIcon;
}
else
{
openedIcon = icon = data.GetIcon();
}
}
string label = this.Label.IsNullOrEmpty()
? data.GetLabel()
: this.LabelDynamicValuesHelper.ReplaceValues(replaceContext);
string toolTip = this.ToolTip.IsNullOrEmpty()
? label
: this.ToolTipDynamicValuesHelper.ReplaceValues(replaceContext);
if (itemLocalizationEnabledAndForeign)
{
label = string.Format("{0} ({1})", label, DataLocalizationFacade.GetCultureTitle(UserSettings.ForeignLocaleCultureInfo));
if (!data.IsTranslatable())
{
toolTip = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeDataWorkflow.DisabledData");
}
else
{
toolTip = string.Format("{0} ({1})", toolTip, DataLocalizationFacade.GetCultureTitle(UserSettings.ForeignLocaleCultureInfo));
}
}
element.VisualData = new ElementVisualizedData
{
Label = label,
ToolTip = toolTip,
HasChildren = hasChildren,
Icon = icon,
OpenedIcon = openedIcon,
IsDisabled = isDisabled
};
if (InternalUrls.DataTypeSupported(data.DataSourceId.InterfaceType))
{
var dataReference = data.ToDataReference();
if (DataUrls.CanBuildUrlForData(dataReference))
{
string internalUrl = InternalUrls.TryBuildInternalUrl(dataReference);
if (internalUrl != null)
{
element.PropertyBag.Add("Uri", internalUrl);
}
}
}
if (itemLocalizationEnabledAndForeign)
{
var actionToken = new WorkflowActionToken(
WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.LocalizeDataWorkflow"),
LocalizeDataPermissionTypes);
element.AddAction(new ElementAction(new ActionHandle(actionToken))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeDataWorkflow.LocalizeDataLabel"),
ToolTip = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeDataWorkflow.LocalizeDataToolTip"),
Icon = LocalizeDataTypeIcon,
Disabled = false,
ActionLocation = ActionLocation.OtherPrimaryActionLocation
}
});
}
return(element);
}
protected override IEnumerable<Element> OnGetElements(EntityToken parentEntityToken, TreeNodeDynamicContext dynamicContext)
{
foreach (TreeNode childTreeNode in this.ChildNodes)
{
foreach (Element element in childTreeNode.GetElements(parentEntityToken, dynamicContext))
{
element.ElementHandle.Piggyback[StringConstants.PiggybagTreeId] = this.Tree.TreeId;
yield return element;
}
}
}
public override IEnumerable <EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext)
{
EntityToken possibleCurrentEntityToken;
TreeSimpleElementEntityToken treeSimpleElementEntityToken = childEntityToken as TreeSimpleElementEntityToken;
if (treeSimpleElementEntityToken != null)
{
possibleCurrentEntityToken = treeSimpleElementEntityToken.ParentEntityToken;
}
else
{
possibleCurrentEntityToken = childEntityToken;
}
foreach (EntityToken entityToken in this.ParentNode.GetEntityTokens(possibleCurrentEntityToken, dynamicContext))
{
yield return(new TreeSimpleElementEntityToken(this.Id, this.Tree.TreeId, EntityTokenSerializer.Serialize(entityToken)));
}
}
