Example #1
0
 public ChooseTypeForm(IDictionary <String, TypeVisualUnit> units, string rootTypeName)
 {
     InitializeComponent();
     this.rootTypeName = rootTypeName;
     this.units        = new Dictionary <String, TypeVisualUnit>(units);
     TypeVisualUtilities.GetChildrenAndParentsDictonaryOfTypes(this.units, out childrenDictionary, out parentsDictionary);
     showRootType();
 }
        /// <summary>
        /// Returns the Id of the node type with the specified name. It looks in the types pointed by the TypesRoot node.
        /// </summary>
        /// <param name="typeName">Type name to compare possible results to.</param>
        /// <returns>The Id of the node pointing to the type. Empty if node is not found</returns>
        private Guid GetIdFromTypeName(string typeName)
        {
            foreach (var edge in provider.GetNode(Constants.TypesNodeId, NodeAccess.Read).Edges.Values)
            {
                if (edge.Data.Semantic.Equals(EdgeType.Contains))
                {
                    var    node     = provider.GetNode(edge.ToNodeId, NodeAccess.Read);
                    string nodeData = TypeVisualUtilities.GetTypeNameFromAssemblyName((string)node.Data);
                    if (typeName.Equals(nodeData))
                    {
                        return(edge.ToNodeId);
                    }
                }
            }

            return(Guid.Empty);
        }
        /// <summary>
        /// Returns the name of the type that represents the root of the database (the representation of the Data Model)
        /// </summary>
        /// <returns></returns>
        public string getRootTypeName()
        {
            var typeNode = provider.GetNode(GetRootTypeId(), NodeAccess.Read);

            return(TypeVisualUtilities.GetTypeNameFromAssemblyName((string)typeNode.Data));
        }
        /// <summary>
        /// Recursively fills the units dictionary with a TypeVisualisationUnit of the Guid - typeNodeId.
        /// </summary>
        /// <param name="typeNodeId"></param>
        /// <param name="units"></param>
        /// <param name="ignoreTypeNames"></param>
        private void GetTypeVisualUnitsRecursive(Guid typeNodeId, IDictionary <String, TypeVisualUnit> units, ICollection <string> ignoreTypeNames)
        {
            TypeVisualUnit unit     = null;
            string         typeName = null;
            ICollection <TypeVisualProperty> scalarProperties    = new List <TypeVisualProperty>();
            ICollection <TypeVisualProperty> nonScalarProperties = new List <TypeVisualProperty>();

            if (!typeNodeId.Equals(Guid.Empty))
            {
                var typeNode = provider.GetNode(typeNodeId, NodeAccess.Read);
                typeName = TypeVisualUtilities.GetTypeNameFromAssemblyName((string)typeNode.Data);
                if (!ignoreTypeNames.Contains(typeName))
                {
                    ignoreTypeNames.Add(typeName);
                    foreach (var edge in typeNode.Edges.Values)
                    {
                        if (edge.Data.Semantic.Equals(EdgeType.Property))
                        {
                            //setting name and type
                            bool   isScalar;
                            var    nodeProperty     = provider.GetNode(edge.ToNodeId, NodeAccess.Read);
                            var    nodePropertyType = provider.GetNode(nodeProperty.Edges.Values[0].ToNodeId, NodeAccess.Read);
                            string propertyTypeName = TypeVisualUtilities.GetTypeNameFromAssemblyName((string)nodePropertyType.Data);

                            string collectionKey, collectionValue;
                            PropertyCollectionType collectionType = TypeVisualUtilities.CheckIfCollectionOrDictionary(propertyTypeName,
                                                                                                                      out collectionKey, out collectionValue);

                            //checking if property is a collection and if property is scalar.
                            if (collectionType != PropertyCollectionType.NotACollection)
                            {
                                if (!typesService.IsSupportedScalarTypeName(collectionValue))
                                {
                                    Guid genericArgumentTypeId = GetIdFromTypeName(collectionValue);
                                    if (!genericArgumentTypeId.Equals(Guid.Empty))
                                    {
                                        //ignoreTypeNames.Add(typeName);
                                        GetTypeVisualUnitsRecursive(genericArgumentTypeId, units, ignoreTypeNames);
                                    }
                                    isScalar = false;
                                }
                                else
                                {
                                    isScalar = true;
                                }
                                propertyTypeName = collectionValue;
                            }
                            else if (!typesService.IsSupportedScalarTypeName(propertyTypeName))
                            {
                                //ignoreTypeNames.Add(typeName);
                                GetTypeVisualUnitsRecursive(nodeProperty.Edges.Values[0].ToNodeId, units, ignoreTypeNames);
                                isScalar = false;
                            }
                            else
                            {
                                isScalar = true;
                            }

                            //setting additional property attributes
                            bool isImmutable, isPrimaryKey;
                            PropertyAttribute propAttribute;
                            isImmutable  = edge.Data.Flags.Equals(EdgeFlags.Permanent);
                            isPrimaryKey = nodeProperty.Values.ContainsKey(Constants.TypeMemberPrimaryKeyId);
                            if (isImmutable && isPrimaryKey)
                            {
                                propAttribute = PropertyAttribute.PrimaryKeyAndImmutableProperty;
                            }
                            else if (isImmutable)
                            {
                                propAttribute = PropertyAttribute.ImmutableProperty;
                            }
                            else if (isPrimaryKey)
                            {
                                propAttribute = PropertyAttribute.PrimaryKeyProperty;
                            }
                            else
                            {
                                propAttribute = PropertyAttribute.None;
                            }

                            //adding the property to either scalar or non-scalar lists.
                            TypeVisualProperty property = new TypeVisualProperty((string)nodeProperty.Data, propertyTypeName,
                                                                                 propAttribute, collectionType, collectionKey);

                            if (isScalar)
                            {
                                scalarProperties.Add(property);
                            }
                            else
                            {
                                nonScalarProperties.Add(property);
                            }
                        }
                        else if (edge.Data.Semantic.Equals(EdgeType.Contains))
                        {
                            var nodeProperty            = provider.GetNode(edge.ToNodeId, NodeAccess.Read);
                            TypeVisualProperty property = new TypeVisualProperty((string)nodeProperty.Data, TypeVisualProperty.EnumType,
                                                                                 PropertyAttribute.None, PropertyCollectionType.NotACollection, "");
                            scalarProperties.Add(property);
                        }
                    }
                    unit = new TypeVisualUnit(typeName, scalarProperties, nonScalarProperties);
                    units.Add(unit.Name, unit);
                }
            }
        }