/// <exclude /> public static Dictionary<string, string> PreparePiggybag(this Dictionary<string, string> piggybag, TreeNode parentNode, EntityToken parentEntityToken) { var newPiggybag = new Dictionary<string, string>(); foreach (KeyValuePair<string, string> kvp in piggybag) { if (kvp.Key.StartsWith(ParentEntityTokenPiggybagString)) { int generation = int.Parse(kvp.Key.Substring(ParentEntityTokenPiggybagString.Length)); generation += 1; newPiggybag.Add(string.Format("{0}{1}", ParentEntityTokenPiggybagString, generation), kvp.Value); } else if (kvp.Key.StartsWith(ParentNodeIdPiggybagString)) { int generation = int.Parse(kvp.Key.Substring(ParentNodeIdPiggybagString.Length)); generation += 1; newPiggybag.Add(string.Format("{0}{1}", ParentNodeIdPiggybagString, generation), kvp.Value); } else { newPiggybag.Add(kvp.Key, kvp.Value); } } newPiggybag.Add(string.Format("{0}1", ParentEntityTokenPiggybagString), EntityTokenSerializer.Serialize(parentEntityToken)); newPiggybag.Add(string.Format("{0}1", ParentNodeIdPiggybagString), parentNode.Id.ToString()); return newPiggybag; }
private bool IsInParentTree(TreeNode treeNode) { TreeNode searchTreeNode = treeNode.ParentNode; while (searchTreeNode != null) { var node = searchTreeNode as DataElementsTreeNode; if (node != null) { if (node.InterfaceType == this.OwnerNode.InterfaceType) { // Found in parent tree. return true; } searchTreeNode = searchTreeNode.ParentNode; } else { searchTreeNode = searchTreeNode.ParentNode; } } return false; }
/// <exclude /> public void SetOwnerNode(TreeNode treeNode) { this.OwnerNode = (DataElementsTreeNode)treeNode; }
/// <summary> /// /// </summary> /// <param name="ownerTreeNode">This is only used to add validation errors</param> private void Initialize_DataFieldValueHelper(TreeNode ownerTreeNode) { if (DataFieldValueHelper.ContainsDataField(this.Template) == false) return; this.DataFieldValueHelper = new DataFieldValueHelper(this.Template); this.DataFieldValueHelper.Initialize(ownerTreeNode); }
/// <summary> /// /// </summary> /// <param name="ownerTreeNode">This is only used to add validation errors</param> public void Initialize(TreeNode ownerTreeNode) { Initialize_DataFieldValueHelper(ownerTreeNode); }
internal bool IsDescendant(TreeNode treeNode) { return this.ChildNodes.Any(childNode => childNode.Id == treeNode.Id || childNode.IsDescendant(treeNode)); }
internal bool IsAncestor(TreeNode treeNode) { TreeNode ancestorNode = this.ParentNode; while (ancestorNode != null) { if (ancestorNode.Id == treeNode.Id) return true; ancestorNode = ancestorNode.ParentNode; } return false; }
internal void RemoveChildTreeNode(TreeNode treeNode) { _childNodes.Remove(treeNode); }
internal TreeNode AddChildTreeNode(TreeNode treeNode) { treeNode.ParentNode = this; _childNodes.Add(treeNode); return this; }
/// <exclude /> public AncestorResult(TreeNode treeNode, EntityToken entityToken) { this.TreeNode = treeNode; this.EntityToken = entityToken; }
/// <summary> /// /// </summary> /// <param name="ownerTreeNode">This is only used to add validation errors</param> public void Initialize(TreeNode ownerTreeNode) { foreach (Match match in TemplateRegex.Matches(this.Template)) { if (match.Value.StartsWith(PreFix) == false) continue; string value = match.Groups["string"].Value; string[] values = value.Split(':'); if (values.Length != 4) { ownerTreeNode.AddValidationError("TreeValidationError.DataFieldValueHelper.WrongFormat", match.Value, string.Format(@"{0}[InterfaceType]:[FieldName]}}", PreFix)); return; } string typeName = values[2]; Type interfaceType = TypeManager.TryGetType(typeName); if (interfaceType == null) { ownerTreeNode.AddValidationError("TreeValidationError.Common.UnknownInterfaceType", typeName); return; } if (typeof(IData).IsAssignableFrom(interfaceType) == false) { ownerTreeNode.AddValidationError("TreeValidationError.Common.NotImplementingIData", interfaceType, typeof(IData)); return; } string fieldName = values[3]; PropertyInfo propertyInfo = interfaceType.GetPropertiesRecursively(f => f.Name == fieldName).SingleOrDefault(); if (propertyInfo == null) { ownerTreeNode.AddValidationError("TreeValidationError.Common.MissingProperty", interfaceType, fieldName); return; } bool possibleAttachmentPointsExist = ownerTreeNode.Tree.PossibleAttachmentPoints.OfType<IDataItemAttachmentPoint>().Any(f => f.InterfaceType == interfaceType); bool attachmentPointsExist = ownerTreeNode.Tree.AttachmentPoints.OfType<IDataItemAttachmentPoint>().Any(f => f.InterfaceType == interfaceType); if (!possibleAttachmentPointsExist && !attachmentPointsExist && !ownerTreeNode.SelfAndParentsHasInterface(interfaceType)) { ownerTreeNode.AddValidationError("TreeValidationError.DataFieldValueHelper.InterfaceNotInParentTree", interfaceType); return; } bool isReferencingProperty = DataReferenceFacade.GetForeignKeyProperties(interfaceType).Any(f => f.SourcePropertyInfo.Equals(propertyInfo)); DataFieldValueHelperEntry entry = new DataFieldValueHelperEntry( match.Value, interfaceType, propertyInfo, isReferencingProperty ); if (_entries.Contains(entry) == false) { _entries.Add(entry); } } }
/// <summary> /// This method finds the callers tree node own entity token by searching up/down using filters. /// In some cases this can be expensive. /// </summary> /// <param name="treeNode"></param> /// <param name="entityToken"></param> /// <param name="dynamicContext"></param> /// <returns></returns> private EntityToken FindOwnEntityToken(TreeNode treeNode, EntityToken entityToken, TreeNodeDynamicContext dynamicContext) { DataElementsTreeNode dataElementsTreeNode = treeNode as DataElementsTreeNode; if (dataElementsTreeNode != null) { if (dataElementsTreeNode.InterfaceType == this.OwnerNode.InterfaceType) // We found it :) { return entityToken; } } TreeDataFieldGroupingElementEntityToken dataFieldGroupingElementEntityToken = entityToken as TreeDataFieldGroupingElementEntityToken; if (dataFieldGroupingElementEntityToken != null) // Search 'downwards' { ParameterExpression parameterExpression = Expression.Parameter(this.OwnerNode.InterfaceType, "data"); DataKeyPropertyCollection dataKeyPropertyCollection = new DataKeyPropertyCollection(); dataKeyPropertyCollection.AddKeyProperty("Id", dataFieldGroupingElementEntityToken.ChildGeneratingDataElementsReferenceValue); Type dataType = dataFieldGroupingElementEntityToken.ChildGeneratingDataElementsReferenceType; IData parentData = DataFacade.GetDataByUniqueKey(dataType, dataKeyPropertyCollection); TreeNodeDynamicContext dummyContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down); dummyContext.CustomData.Add("ParentData", parentData); IData resultData; if (this.OwnerNode.InterfaceType == TypeManager.GetType(dataFieldGroupingElementEntityToken.Type)) { Expression filterExpression = this.CreateDownwardsFilterExpression(parameterExpression, dummyContext); Expression whereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(this.OwnerNode.InterfaceType).Expression, parameterExpression, filterExpression); resultData = (IData)DataFacade.GetData(this.OwnerNode.InterfaceType).Provider.CreateQuery(whereExpression).ToEnumerableOfObjects().First(); } else { resultData = parentData; } return resultData.GetDataEntityToken(); } AncestorResult ancestorResult = treeNode.GetParentEntityToken(entityToken, this.ParentFilterType, dynamicContext); if ((this.OwnerNode.Id == ancestorResult.TreeNode.Id) || (this.OwnerNode.IsDescendant(ancestorResult.TreeNode))) // Search upwards { return FindOwnEntityToken(ancestorResult.TreeNode, ancestorResult.EntityToken, dynamicContext); } // Search 'downwards' by using the parent datas key value to get DataElementsTreeNode parentDataElementsTreeNode = (DataElementsTreeNode)ancestorResult.TreeNode; if (this.ParentFilterType == parentDataElementsTreeNode.InterfaceType) { DataEntityToken dataEntityToken = (DataEntityToken)ancestorResult.EntityToken; ParameterExpression parameterExpression = Expression.Parameter(this.OwnerNode.InterfaceType, "data"); TreeNodeDynamicContext dummyContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down); dummyContext.CustomData.Add("ParentData", dataEntityToken.Data); Expression filterExpression = this.CreateDownwardsFilterExpression(parameterExpression, dummyContext); Expression whereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(this.OwnerNode.InterfaceType).Expression, parameterExpression, filterExpression); IData resultData = (IData)DataFacade.GetData(this.OwnerNode.InterfaceType).Provider.CreateQuery(whereExpression).ToEnumerableOfObjects().First(); return resultData.GetDataEntityToken(); } throw new InvalidOperationException("Missing parent id filtering or try to simplify the parent id filterings (Unable to find own entity token)"); }
private object Find(TreeNode currentTreeNode, EntityToken currentEntityToken) { if (this.OwnerNode.IsAncestor(currentTreeNode)) // Is parent { return currentTreeNode; } if (this.OwnerNode.Id != currentTreeNode.Id) // Is child { IEnumerable<ParentIdFilterNode> parentIdFilterNodes = currentTreeNode.FilterNodes.OfType<ParentIdFilterNode>(); foreach (ParentIdFilterNode parentIdFilterNode in parentIdFilterNodes) { Find(parentIdFilterNode.ParentFilterTypeTreeNode, null); } } foreach (TreeNode childTreeNode in this.OwnerNode.ChildNodes) { object res = Find(childTreeNode, null); if (res != null) { return res; } } return null; }