Inheritance: Relation1
 public Relation defineRelation(string name, Types element_types)
 {
     if (null == name) name = ".R"+m_code.relations.Count;
     Relation r = new Relation(name, element_types);
     m_code.relations.Add(r);
     return r;
 }
Exemple #2
0
        internal static void MoveNode(int nodeId, int? oldParentId, int? newParentId)
        {
            using (CompAgriConnection ctx = new CompAgriConnection())
            {
                var relation = ctx.Relations.Where(o => o.Relation_Parent_Term_Id == oldParentId && o.Relation_Child_Term_Id == nodeId)
                    .FirstOrDefault();

                if (relation != null)
                {
                    relation.Relation_Parent_Term_Id = newParentId;
                }
                else
                {
                    relation = new Relation
                    {
                        Relation_Child_Term_Id = nodeId,
                        Relation_Parent_Term_Id = newParentId
                    };

                    ctx.Relations.Add(relation);
                }

                ctx.SaveChanges();
            }
        }
Exemple #3
0
        public static void GetRelationType(Relation rel, MethodReturnEventArgs<RelationType> e)
        {
            if (rel == null)
            {
                throw new ArgumentNullException("rel");
            }
            if (rel.A == null)
            {
                throw new ArgumentNullException("rel", "rel.A is null");
            }
            if (rel.B == null)
            {
                throw new ArgumentNullException("rel", "rel.B is null");
            }

            if ((rel.A.Multiplicity.UpperBound() == 1 && rel.B.Multiplicity.UpperBound() > 1)
                || (rel.A.Multiplicity.UpperBound() > 1 && rel.B.Multiplicity.UpperBound() == 1))
            {
                e.Result = RelationType.one_n;
            }
            else if (rel.A.Multiplicity.UpperBound() > 1 && rel.B.Multiplicity.UpperBound() > 1)
            {
                e.Result = RelationType.n_m;
            }
            else if (rel.A.Multiplicity.UpperBound() == 1 && rel.B.Multiplicity.UpperBound() == 1)
            {
                e.Result = RelationType.one_one;
            }
            else
            {
                throw new InvalidOperationException(String.Format("Unable to find out RelationType: {0}:{1}", rel.A.Multiplicity, rel.B.Multiplicity));
            }
        }
 public Relation FxnTypeToRelation(CatFxnType ft)
 {
     Vector cons = TypeVectorToConstraintVector(ft.GetCons());
     Vector prod = TypeVectorToConstraintVector(ft.GetProd());
     Relation r = new Relation(cons, prod);
     return r;
 }
Exemple #5
0
		private bool TryWriteContentRelation(Relation<ContentItem> relation)
		{
			if (relation == null)
				return false;
			writer.Write(relation.ID);
			return true;
		}
        protected virtual void ApplyIndexPropertyTemplate(Relation rel, RelationEndRole endRole)
        {
            if (rel.NeedsPositionStorage(endRole))
            {
                // provided by ObjectReferencePropertyTemplate
                string posBackingStore = "_" + endRole + Zetbox.API.Helper.PositionSuffix;

                // is serialized by the ObjectReferenceProperty
                //this.MembersToSerialize.Add(
                //    Serialization.SerializerType.All,
                //    relEnd.Type.Module.Namespace,
                //    endRole + Zetbox.API.Helper.PositionSuffix,
                //    posBackingStore);

                this.WriteObjects("        public int? ", endRole, "Index { get { return ",
                    posBackingStore, "; } set { ",
                    posBackingStore, " = value; } }");
                this.WriteLine();
            }
            else if (IsOrdered())
            {
                this.WriteLine("/// <summary>ignored implementation for INewListEntry</summary>");
                this.WriteObjects("public int? ", endRole, "Index { get { return null; } set { } }");
            }
        }
Exemple #7
0
 private void ApplyRememberToDeleteTemplate(Relation rel, RelationEnd relEnd)
 {
     if (rel.GetOtherEnd(relEnd).Multiplicity == Multiplicity.ZeroOrMore)
     {
         if (relEnd.Navigator != null)
         {
             var prop = relEnd.Navigator;
             this.WriteObjects("            // ", rel.GetAssociationName(), " ZeroOrMore\r\n");
             this.WriteObjects("            foreach(NHibernatePersistenceObject x in ", prop.Name, ") {\r\n");
             this.WriteObjects("                x.ParentsToDelete.Add(this);\r\n");
             this.WriteObjects("                ChildrenToDelete.Add(x);\r\n");
             this.WriteObjects("            }\r\n");
         }
         else
         {
             this.WriteObjects("            // should fetch && remember parent for ", relEnd.Parent.GetRelationClassName(), "\r\n");
         }
     }
     else
     {
         if (relEnd.Navigator != null)
         {
             var prop = relEnd.Navigator;
             this.WriteObjects("            // ", rel.GetAssociationName(), "\r\n");
             this.WriteObjects("            if (", prop.Name, " != null) {\r\n");
             this.WriteObjects("                ((NHibernatePersistenceObject)", prop.Name, ").ChildrenToDelete.Add(this);\r\n");
             this.WriteObjects("                ParentsToDelete.Add((NHibernatePersistenceObject)", prop.Name, ");\r\n");
             this.WriteObjects("            }\r\n");
         }
         else
         {
             this.WriteObjects("            // should fetch && remember children for ", relEnd.Parent.GetRelationClassName(), "\r\n");
         }
     }
 }
        ///// <summary>
        ///// 
        ///// </summary>
        ///// <returns></returns>
        //public override IEnumerable<Way> GetWays()
        //{
        //    return _ways.Values;
        //}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="relation"></param>
        public override void AddRelation(Relation relation)
        {
            if (relation == null) throw new ArgumentNullException("relation");
            if (relation.Id == null) throw new Exception("relation.Id is null");

            _relations[relation.Id.Value] = relation;
        }
Exemple #9
0
        protected override object ParseElements(XmlDocument xml)
        {
            List<Relation> relations = new List<Relation>();
            Relation rel;

            foreach (XmlNode node in xml.DocumentElement.ChildNodes)
            {
                rel = new Relation(node.Name);

                foreach (XmlNode auxNode in node.ChildNodes)
                {
                    if (auxNode.Name.Equals("Subject"))
                    {
                        rel.Subject = auxNode.InnerText;
                    }
                    else if (auxNode.Name.Equals("Target"))
                    {
                        rel.Target = auxNode.InnerText;
                    }
                    else if (auxNode.Name.Equals("Value"))
                    {
                        rel.Value = Convert.ToSingle(auxNode.InnerText, CultureInfo.InvariantCulture);
                    }
                }

                relations.Add(rel);
            }

            return relations;
        }
Exemple #10
0
	public Digraph(SymbolsGen s,Relation r,Func f1,Func f2,AddToFunc d)
	{
		sg=s; R=r; F1=f1; F2=f2; DF2=d;
		N = new int[sg.m_trans];
		for (int j=0;j<sg.m_trans;j++)
			N[j]=0;
	}
 /// <summary>
 /// Processes the given relation.
 /// </summary>
 /// <param name="relation"></param>
 public override void AddRelation(Relation relation)
 {
     if (relation.Tags != null)
     {
         _tagsIndex.Add(relation.Tags);
     }
 }
        public static void Call(Arebis.CodeGeneration.IGenerationHost host,
            IZetboxContext ctx,
            Templates.Serialization.SerializationMembersList serializationList,
            Relation rel, RelationEndRole endRole, string backingCollectionType)
        {
            if (host == null) { throw new ArgumentNullException("host"); }
            if (rel == null) { throw new ArgumentNullException("rel"); }

            RelationEnd relEnd = rel.GetEndFromRole(endRole);
            RelationEnd otherEnd = rel.GetOtherEnd(relEnd);

            string name = relEnd.Navigator.Name;
            string exposedCollectionInterface = rel.NeedsPositionStorage(otherEnd.GetRole()) ? "IList" : "ICollection";
            string referencedInterface = otherEnd.Type.GetDataTypeString();
            string backingName = "_" + name;

            string aSideType = rel.A.Type.GetDataTypeString();
            string bSideType = rel.B.Type.GetDataTypeString();
            string entryType = rel.GetRelationFullName() + host.Settings["extrasuffix"] + Zetbox.API.Helper.ImplementationSuffix;
            string providerCollectionType = (rel.NeedsPositionStorage(otherEnd.GetRole()) ? "IList<" : "ICollection<")
                + entryType + ">";

            bool eagerLoading = relEnd.Navigator != null && relEnd.Navigator.EagerLoading;
            bool serializeRelationEntries = rel.GetRelationType() == RelationType.n_m;

            string entryProxyType = entryType + "." + rel.GetRelationClassName() + "Proxy";

            string inverseNavigatorName = otherEnd.Navigator != null ? otherEnd.Navigator.Name : null;

            Call(host, ctx, serializationList, name, exposedCollectionInterface, referencedInterface, backingName, backingCollectionType, aSideType, bSideType, entryType, providerCollectionType, rel.ExportGuid, endRole, eagerLoading, serializeRelationEntries, entryProxyType, inverseNavigatorName);
        }
 public static bool IsMyGame(Relation relation)
 {
     return relation ==
         Relation.IamPlayingAndMyMove
         || relation ==
         Relation.IamPlayingAndMyOppsMove;
 }
        public RelationDebugTemplate(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, Relation rel)
            : base(_host)
        {
			this.ctx = ctx;
			this.rel = rel;

        }
        ///// <summary>
        ///// 
        ///// </summary>
        ///// <returns></returns>
        //public override IEnumerable<Way> GetWays()
        //{
        //    return _ways.Values;
        //}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="relation"></param>
        public override void AddRelation(Relation relation)
        {
            if (relation == null) throw new ArgumentNullException("relation");
            if (relation.Id == null) throw new Exception("relation.Id is null");

            this.Store(relation);
        }
Exemple #16
0
 public Condition(string firstVar, string secondVar, Relation goal)
 {
     FirstVariable = firstVar;
     SecondVariable = secondVar;
     FirstVariableModifier = 1.0;
     SecondVariableModifier = 1.0;
     Goal = goal;
 }
 public Association(Relation relation, string member, string sourceKey, string referenceKey, bool viewOnly)
 {
     Relationship = relation;
     m_sourceMember = member;
     m_sourceKey = sourceKey;
     m_referenceKey = referenceKey;
     ViewOnly = viewOnly;
 }
		public SQLSelectBusinessObjectByForeignKeyTemplate(ModelRoot model, Relation currentRelation, Table realTable)
		{
			_model = model;
			_currentRelation = currentRelation;
			_childTable = (Table)_currentRelation.ChildTableRef.Object;
			if (realTable.IsInheritedFrom(_childTable)) _childTable = realTable;
			_parentTable = (Table)_currentRelation.ParentTableRef.Object;
		}
Exemple #19
0
 public RelationViewModel(
     IViewModelDependencies appCtx, IZetboxContext dataCtx, ViewModel parent,
     Relation rel)
     : base(appCtx, dataCtx, parent, rel)
 {
     _relation = rel;
     _relation.PropertyChanged += (sender, args) => OnPropertyChanged(args.PropertyName);
 }
 public SqlFieldNameAttribute(string sqlFieldName, string sqlForeignClassName, string sqlForeignKeyFieldName, Relation relation)
 {
     this.IsKey = false;
     this.SqlFieldName = sqlFieldName;
     this.SqlForeignKeyFieldName = sqlForeignKeyFieldName;
     this.SqlForeignClassName = sqlForeignClassName;
     this.SqlRelation = relation;
 }
Exemple #21
0
        protected override void ApplyObjectReferenceProperty(Relation rel, RelationEndRole endRole, string propertyName)
        {
            // TODO: create/use ObjectReference*IMPLEMENTATION* instead (_fk* can already be made available)

            RelationEnd relEnd = rel.GetEndFromRole(endRole);
            RelationEnd otherEnd = rel.GetOtherEnd(relEnd);

            string moduleNamespace = rel.Module.Namespace;
            string implName = propertyName + Zetbox.API.Helper.ImplementationSuffix;
            string eventName = "On" + propertyName;

            string fkBackingName = "_fk_" + propertyName;
            string fkGuidBackingName = "_fk_guid_" + propertyName;

            string referencedInterface = relEnd.Type.GetDataTypeString();
            string referencedImplementation = referencedInterface
                + Host.Settings["extrasuffix"] + Zetbox.API.Helper.ImplementationSuffix;
            string associationName = rel.GetAssociationName() + "_" + endRole.ToString();
            string targetRoleName = relEnd.RoleName;

            string positionPropertyName = rel.NeedsPositionStorage(endRole)
                ? propertyName + Zetbox.API.Helper.PositionSuffix
                : null;

            string inverseNavigatorName = relEnd.Navigator != null
                ? relEnd.Navigator.Name + Zetbox.API.Helper.ImplementationSuffix
                : null;
            bool inverseNavigatorIsList = false;
            bool notifyInverseCollection = true;

            bool eagerLoading = relEnd.Navigator != null && relEnd.Navigator.EagerLoading;
            bool relDataTypeExportable = rel.A.Type.ImplementsIExportable() && rel.B.Type.ImplementsIExportable();
            bool callGetterSetterEvents = false;

            Templates.Properties.ObjectReferencePropertyTemplate.Call(Host,
                ctx,
                MembersToSerialize,
                moduleNamespace,
                "/* not member of an interface, 'ownInterface' should not be used */",
                propertyName,
                implName,
                eventName,
                fkBackingName,
                fkGuidBackingName,
                referencedInterface,
                referencedImplementation,
                associationName,
                targetRoleName,
                positionPropertyName,
                inverseNavigatorName,
                inverseNavigatorIsList,
                notifyInverseCollection,
                eagerLoading,
                relDataTypeExportable,
                callGetterSetterEvents,
                false, // ObjRef with relation cannot be calculated
                false);
        }
Exemple #22
0
 public ObjectListProperty(Arebis.CodeGeneration.IGenerationHost host,
     IZetboxContext ctx,
     Serialization.SerializationMembersList serializationList,
     Relation rel,
     RelationEndRole endRole)
     : this(host, ctx, serializationList, "name", "wrapperName", "wrapperClass", "exposedListType",
         rel, endRole, "positionPropertyName", "otherName", "referencedInterface")
 {
 }
        private static string ButtonBuilder(HtmlHelper helper, string innerHtml, IElement element, Relation relation, IIcon icon, object attributes)
        {
            SystemButtonBuilder buttonBuilder = new SystemButtonBuilder();
            buttonBuilder.SetIcon(icon);
            buttonBuilder.SetElement(new ButtonElement());
            buttonBuilder.SetRelation(relation);

            return buttonBuilder.CreateButton(innerHtml, "", attributes).ToString();
        }
Exemple #24
0
 public static void GetEnd(Relation rel, MethodReturnEventArgs<RelationEnd> e, ObjectReferenceProperty prop)
 {
     if (rel.A != null && rel.A.Navigator == prop)
         e.Result = rel.A;
     else if (rel.B != null && rel.B.Navigator == prop)
         e.Result = rel.B;
     else
         e.Result = null;
 }
Exemple #25
0
 public static void GetOtherEnd(Relation rel, MethodReturnEventArgs<RelationEnd> e, RelationEnd relEnd)
 {
     if (rel.A == relEnd)
         e.Result = rel.B;
     else if (rel.B == relEnd)
         e.Result = rel.A;
     else
         e.Result = null;
 }
        public CatFxnType CatFxnTypeFromRelation(Relation rel)
        {
            CatTypeVector cons = CatTypeVectorFromVec(rel.GetLeft());
            CatTypeVector prod = CatTypeVectorFromVec(rel.GetRight());

            // TODO: add the boolean as a third value in the vector.
            // it becomes a variable when unknown, and is resolved otherwise.
            return new CatFxnType(cons, prod, false);
        }
        public void Constructor_int_CreatesNewRelationAndInitializesProperties()
        {
            int id = 11;
            Relation target = new Relation(id);

            Assert.Equal(id, target.ID);
            Assert.Empty(target.Tags);
            Assert.Empty(target.Geometries);
        }
        public CollectionEntryListProperty(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, Zetbox.Generator.Templates.Serialization.SerializationMembersList serializationList, Relation rel, RelationEndRole endRole)
            : base(_host)
        {
			this.ctx = ctx;
			this.serializationList = serializationList;
			this.rel = rel;
			this.endRole = endRole;

        }
        public void Constructor_Relation_SetsProperties()
        {
            Relation relation = new Relation(100, new RelationMember[0], new TagsCollection()) { Metadata = new EntityMetadata() };

            RelationInfo target = new RelationInfo(relation);

            Assert.Equal(relation.ID, target.ID);
            Assert.Same(relation.Tags, target.Tags);
            Assert.Same(relation.Metadata, target.Metadata);
        }
 public override void AddRelation(string rule, int pageLeft, int pageRight)
 {
     Relation relation = new Relation();
     relation.PageIDLeft = pageLeft;
     relation.PageIDRight = pageRight;
     relation.RuleName = rule;
     Save(relation);
     UpdateLocalOnly();
     RaiseOnAddedRelation(new RelationEventArgs { CurrentRelation = relation, RelationName = relation.RuleName });
 }
        /// <summary>
        /// Moves to the next object.
        /// </summary>
        /// <returns></returns>
        public override bool MoveNext()
        {
            if (!_cachingDone)
            { // first seek & cache.
                this.Seek();
                this.CacheRelations();
                _cachingDone = true;
            }

            while (_simpleSource.MoveNext())
            { // there is data.
                OsmGeo currentSimple = _simpleSource.Current();

                if (currentSimple.Id == 198214128 || currentSimple.Id == 1014892489)
                {
                    System.Diagnostics.Debug.WriteLine("");
                }

                switch (currentSimple.Type)
                {
                case OsmGeoType.Node:
                    // create complete version.
                    _current = CompleteNode.CreateFrom(currentSimple as Node);
                    if (_nodesToInclude.Contains(currentSimple.Id.Value))
                    {     // node needs to be cached.
                        _dataCache.AddNode(currentSimple as Node);
                        _nodesToInclude.Remove(currentSimple.Id.Value);
                    }
                    break;

                case OsmGeoType.Way:
                    // create complete way.
                    _current = CompleteWay.CreateFrom(currentSimple as Way, _dataCache);

                    if (_waysToInclude.Contains(currentSimple.Id.Value))
                    {     // keep the way because it is needed later on.
                        _dataCache.AddWay(currentSimple as Way);
                        _waysToInclude.Remove(currentSimple.Id.Value);
                    }
                    else
                    {     // only report that the nodes have been used when the way can be let-go.
                        Way way = currentSimple as Way;
                        if (way.Nodes != null)
                        {     // report usage.
                            way.Nodes.ForEach(x => this.ReportNodeUsage(x));
                        }
                    }
                    break;

                case OsmGeoType.Relation:
                    // create complate relation.
                    _current = CompleteRelation.CreateFrom(currentSimple as Relation, _dataCache);

                    if (!_relationsToInclude.Contains(currentSimple.Id.Value))
                    {     // only report relation usage when the relation can be let go.
                        Relation relation = currentSimple as Relation;
                        if (relation.Members != null)
                        {
                            foreach (RelationMember member in relation.Members)
                            {
                                switch (member.MemberType.Value)
                                {
                                case OsmGeoType.Node:
                                    this.ReportNodeUsage(member.MemberId.Value);
                                    break;

                                case OsmGeoType.Way:
                                    this.ReportWayUsage(member.MemberId.Value);
                                    break;

                                case OsmGeoType.Relation:
                                    this.ReportRelationUsage(member.MemberId.Value);
                                    break;
                                }
                            }
                        }
                    }
                    break;
                }
                if (_current != null)
                { // only return complete objects.
                    return(true);
                }
            }
            return(false);
        }
Exemple #32
0
        public static Db Parse(string fileContent)
        {
            const RegexOptions options = RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline;

            Regex dbRgx      = new Regex("^[\\s\\t]*db\\s+(?<db>[\\w\\/]+)?", options);
            Regex tableRgx   = new Regex("^[\\s\\t]*t\\s+(?<table>[\\w\\/]+)?", options);
            Regex commandRgx = new Regex("^[\\s\\t]*(?<name>\\w+)\\s+(?<type>bi|bn|b|c|i|dtmo|dtm2|dtm|dt|d|nvc|tx|ntx|n|f|m|nc|si|sm|vb|ts|t|u|vc|v|x)(?<type_qual>[\\d\\.]+)?(?<nullable>\\s+(z))?(\\s+(?<asc><)?(?<key_index>k|i)(?<desc>>)?(\\s+(?<auto_key>a)(?<auto_key_qual>[\\d\\.]+))?)?(\\s+(?<foreign>f)\\s+(?<outer_table>[\\w\\/]+)(>)(?<outer_column>\\w+)(\\s+(?<update_action>uc|un|ud)?\\s+(?<delete_action>dc|dn|dd)?)?)?", options);

            Db    lastDb    = null;
            Table lastTable = null;

            string[] mkdbLines = fileContent.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);

            var length = mkdbLines.Length;

            for (int i = 0; i < length; i++)
            {
                var mkdbLine = mkdbLines[i];
                if (dbRgx.IsMatch(mkdbLine))             //IS DB
                {
                    var match  = dbRgx.Match(mkdbLine);
                    var dbName = match.Groups["db"].Value;
                    if (string.IsNullOrEmpty(dbName))
                    {
                        throw new InvalidMkdbParseException(string.Format("Invalid database definition. Database must contains Name"))
                              {
                                  Line = i
                              }
                    }
                    ;

                    lastDb = new Db()
                    {
                        Name = dbName
                    };
                }
                else if (tableRgx.IsMatch(mkdbLine)) //IS TABLE
                {
                    var match     = tableRgx.Match(mkdbLine);
                    var tableName = match.Groups["table"].Value;
                    if (string.IsNullOrEmpty(tableName))
                    {
                        throw new InvalidMkdbParseException(string.Format("Invalid table definition. Table must contains Name"))
                              {
                                  Line = i
                              }
                    }
                    ;

                    lastTable = new Table()
                    {
                        Name = GetSuccessTableName(tableName)
                    };
                    lastDb.Tables.Add(lastTable);
                }
                else if (commandRgx.IsMatch(mkdbLine)) // IS COLUMN
                {
                    var match      = commandRgx.Match(mkdbLine);
                    var columnName = match.Groups["name"].Value;
                    var columnType = match.Groups["type"].Value;

                    if (string.IsNullOrEmpty(columnName) || string.IsNullOrEmpty(columnType))
                    {
                        throw new InvalidMkdbParseException(string.Format("Invalid column definition. Column must contains Name and Type"))
                              {
                                  Line = i
                              }
                    }
                    ;

                    var columnTypeQualificator       = match.Groups["type_qual"].Value.Trim();
                    var columnNullable               = match.Groups["nullable"].Value.Trim();
                    var columnKeyIndex               = match.Groups["key_index"].Value.Trim();
                    var columnKeyIndexAsc            = match.Groups["asc"].Value.Trim();
                    var columnKeyIndexDesc           = match.Groups["desc"].Value.Trim();
                    var columnKeyAuto                = match.Groups["auto_key"].Value.Trim();
                    var columnKeyAutoQualificator    = match.Groups["auto_key_qual"].Value.Trim();
                    var columnForeignKey             = match.Groups["foreign"].Value.Trim();
                    var columnForeignKeyTable        = match.Groups["outer_table"].Value.Trim();
                    var columnForeignKeyColumn       = match.Groups["outer_column"].Value.Trim();
                    var columnForeignKeyUpdateAction = match.Groups["update_action"].Value.Trim();
                    var columnForeignKeyDeleteAction = match.Groups["delete_action"].Value.Trim();

                    var column = new Column();
                    column.CanBeNull = columnNullable == "z";
                    column.Name      = columnName;
                    column.Type      = ColumnTypesHelper.GetColumnTypeFromString(columnType);

                    if (!string.IsNullOrEmpty(columnTypeQualificator))
                    {
                        if (columnTypeQualificator.Contains("."))
                        {
                            var qp = columnTypeQualificator.Split('.');
                            column.IntegerPart   = int.Parse(qp[0]);
                            column.FactorialPart = int.Parse(qp[1]);
                        }
                        else
                        {
                            column.IntegerPart = int.Parse(columnTypeQualificator);
                            column.Length      = int.Parse(columnTypeQualificator);
                        }
                    }
                    lastTable.Columns.Add(column);

                    if (columnKeyIndex == "k")
                    {
                        var key = new Key();
                        key.UniqueColumn = column;
                        key.Sorting      = SortDirectory.Asc;

                        if (columnKeyIndexDesc == ">")
                        {
                            key.Sorting = SortDirectory.Desc;
                        }

                        if (columnKeyAuto == "a")
                        {
                            key.AutoGenerated  = true;
                            key.StartIncrement = 0;
                            key.IncrementStep  = 1;
                        }

                        if (!string.IsNullOrEmpty(columnKeyAutoQualificator))
                        {
                            if (!columnKeyAutoQualificator.Contains("."))
                            {
                                throw new ApplicationException("Autogenerate key step is not defined like '1.1'");
                            }

                            var qp = columnKeyAutoQualificator.Split('.');
                            key.StartIncrement = int.Parse(qp[0]);
                            key.IncrementStep  = int.Parse(qp[1]);
                        }

                        lastTable.Keys.Add(key);
                    }

                    if (columnKeyIndex == "i")
                    {
                        var index = new Index();
                        index.UniqueColumn = column;
                        index.Sorting      = SortDirectory.Asc;

                        if (columnKeyIndexDesc == ">")
                        {
                            index.Sorting = SortDirectory.Desc;
                        }

                        lastTable.Indexes.Add(index);
                    }

                    if (columnForeignKey == "f")
                    {
                        var relation = new Relation();
                        relation.UniqueColumnKey = column;

                        var outerTableName = GetSuccessTableName(columnForeignKeyTable);
                        var outerTable     = lastDb.Tables.Where(t => t.Name == outerTableName).FirstOrDefault();
                        relation.OuterTable     = outerTable;
                        relation.OuterColumnKey = outerTable.Columns.Where(c => c.Name == columnForeignKeyColumn).FirstOrDefault();

                        if (!string.IsNullOrEmpty(columnForeignKeyUpdateAction))
                        {
                            switch (columnForeignKeyUpdateAction)
                            {
                            case "u":
                                relation.ActionOnUpdate = UpdateDeleteAction.NoAction;
                                break;

                            case "uc":
                                relation.ActionOnUpdate = UpdateDeleteAction.Cascade;
                                break;

                            case "un":
                                relation.ActionOnUpdate = UpdateDeleteAction.SetNull;
                                break;

                            case "ud":
                                relation.ActionOnUpdate = UpdateDeleteAction.SetDefault;
                                break;
                            }
                        }

                        if (!string.IsNullOrEmpty(columnForeignKeyDeleteAction))
                        {
                            switch (columnForeignKeyDeleteAction)
                            {
                            case "d":
                                relation.ActionOnDelete = UpdateDeleteAction.NoAction;
                                break;

                            case "dc":
                                relation.ActionOnDelete = UpdateDeleteAction.Cascade;
                                break;

                            case "dn":
                                relation.ActionOnDelete = UpdateDeleteAction.SetNull;
                                break;

                            case "dd":
                                relation.ActionOnDelete = UpdateDeleteAction.SetDefault;
                                break;
                            }
                        }

                        lastTable.Relations.Add(relation);
                    }
                }
                else
                {
                    throw new InvalidMkdbFileStructureException()
                          {
                              Line = i
                          };
                }
            }

            return(lastDb);
        }
Exemple #33
0
        private void DrawPanel_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            Drawing.Select(e.Location, SemanticNetwork);

            if (SemanticNetwork.SelectedNode != null)
            {
                if (e.Button == MouseButtons.Left)
                {
                    NodeForm nf = new NodeForm();
                    nf.Info      = SemanticNetwork.SelectedNode.Concept;
                    nf.Converter = converter;
                    if (nf.ShowDialog() == DialogResult.OK)
                    {
                        NodeConfig nc = nf.NodeConfig;
                        SemanticNetwork.SelectedNode.Concept    = nf.Info;
                        SemanticNetwork.SelectedNode.NodeConfig = nc;
                    }
                }
                else if (e.Button == MouseButtons.Right)
                {
                    if (MessageBox.Show("Вы уверены?", "Подтвердите действие", MessageBoxButtons.YesNo,
                                        MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        SemanticNetwork.DeleteNode(SemanticNetwork.SelectedNode);
                    }
                }
            }
            else if (SemanticNetwork.SelectedEdge != null)
            {
                if (e.Button == MouseButtons.Left)
                {
                    EdgeForm addNewEdgeForm = new EdgeForm();
                    addNewEdgeForm.SetRelations = SemanticNetwork.Relations;
                    addNewEdgeForm.Relation     = SemanticNetwork.SelectedEdge.Relation;
                    addNewEdgeForm.Converter    = converter;
                    addNewEdgeForm.EdgeConfig   = SemanticNetwork.SelectedEdge.EdgeConfig;
                    if (addNewEdgeForm.ShowDialog() == DialogResult.OK)
                    {
                        Relation   relation = addNewEdgeForm.Relation;
                        EdgeConfig ec       = addNewEdgeForm.EdgeConfig;
                        ec.Selected = true;
                        SemanticNetwork.SelectedEdge.EdgeConfig = ec;
                        SemanticNetwork.SelectedEdge.Relation   = relation;
                        SemanticNetwork.DeSelectEditing();
                    }
                }
                else if (e.Button == MouseButtons.Right)
                {
                    if (MessageBox.Show("Вы уверены?", "Подтвердите действие", MessageBoxButtons.YesNo,
                                        MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        SemanticNetwork.DeleteEdge(SemanticNetwork.SelectedEdge);
                    }
                }
            }
            else
            {
                if (e.Button == MouseButtons.Left)
                {
                    NodeForm nf = new NodeForm();
                    nf.Converter = converter;
                    if (nf.ShowDialog() == DialogResult.OK)
                    {
                        NodeConfig nc = nf.NodeConfig;
                        SemanticNetwork.AddNode(new Node(nf.Info, converter.IJtoXY(e.Location), nc));
                    }
                }
            }
            DrawPanel.Invalidate();
        }
        /// <summary>
        /// Moves to the next object.
        /// </summary>
        /// <returns></returns>
        public override bool MoveNext()
        {
            if (!_cachingDone)
            { // first seek & cache.
                this.Seek();
                this.CacheRelations();
                _cachingDone = true;
            }

            if (this.Source.MoveNext())
            { // there is data.
                OsmGeo currentSimple = this.Source.Current();

                // make sure the object needs to be included.
                while (!this.IsChild(currentSimple) &&
                       !this.Include(currentSimple))
                {     // don't include this object!
                    if (!this.Source.MoveNext())
                    { // oeps no more data!
                        return(false);
                    }
                    currentSimple = this.Source.Current();
                }

                switch (currentSimple.Type)
                {
                case OsmGeoType.Node:
                    // create complete version.
                    _current = currentSimple;
                    if (_nodesToInclude.Contains(currentSimple.Id.Value))
                    {     // node needs to be cached.
                        _dataCache.AddNode(currentSimple as Node);
                        _nodesToInclude.Remove(currentSimple.Id.Value);
                    }
                    break;

                case OsmGeoType.Way:
                    // create complete way.
                    _current = currentSimple;

                    if (_waysToInclude.Contains(currentSimple.Id.Value))
                    {     // keep the way because it is needed later on.
                        _dataCache.AddWay(currentSimple as Way);
                        _waysToInclude.Remove(currentSimple.Id.Value);
                    }
                    else
                    {     // only report that the nodes have been used when the way can be let-go.
                        Way way = currentSimple as Way;
                        if (way.Nodes != null)
                        {     // report usage.
                            way.Nodes.ForEach(x => this.ReportNodeUsage(x));
                        }
                    }
                    break;

                case OsmGeoType.Relation:
                    // create complate relation.
                    _current = currentSimple;

                    if (!_relationsToInclude.Contains(currentSimple.Id.Value))
                    {     // only report relation usage when the relation can be let go.
                        Relation relation = currentSimple as Relation;
                        if (relation.Members != null)
                        {
                            foreach (RelationMember member in relation.Members)
                            {
                                switch (member.MemberType.Value)
                                {
                                case OsmGeoType.Node:
                                    this.ReportNodeUsage(member.MemberId.Value);
                                    break;

                                case OsmGeoType.Way:
                                    this.ReportWayUsage(member.MemberId.Value);
                                    break;

                                case OsmGeoType.Relation:
                                    this.ReportRelationUsage(member.MemberId.Value);
                                    break;
                                }
                            }
                        }
                    }
                    break;
                }
                return(true);
            }
            return(false);
        }
        private bool MoveNextRelation()
        {
            if (_relationReader == null)
            {
                OracleCommand relation_command = new OracleCommand("select * from relation order by id");
                relation_command.Connection = _connection;
                _relationReader             = relation_command.ExecuteReader();
                if (!_relationReader.Read())
                {
                    _relationReader.Close();
                }
                OracleCommand relation_tag_command = new OracleCommand("select * from relation_tags order by relation_id");
                relation_tag_command.Connection = _connection;
                _relationTagReader = relation_tag_command.ExecuteReader();
                if (!_relationTagReader.IsClosed && !_relationTagReader.Read())
                {
                    _relationTagReader.Close();
                }
                OracleCommand relation_node_command = new OracleCommand("select * from relation_members order by relation_id,sequence_id");
                relation_node_command.Connection = _connection;
                _relationMemberReader            = relation_node_command.ExecuteReader();
                if (!_relationMemberReader.IsClosed && !_relationMemberReader.Read())
                {
                    _relationMemberReader.Close();
                }
            }

            // read next relation.
            if (!_relationReader.IsClosed)
            {
                // load/parse data.
                long     id           = _relationReader.GetInt64(0);
                long     changeset_id = _relationReader.GetInt64(1);
                DateTime timestamp    = _relationReader.GetDateTime(2);
                bool     visible      = _relationReader.GetInt64(3) == 1;
                long     version      = _relationReader.GetInt64(4);
                string   user         = _relationReader.GetString(5);
                long     uid          = _relationReader.GetInt64(6);
                Relation relation     = new Relation();
                relation.Id          = id;
                relation.ChangeSetId = changeset_id;
                relation.TimeStamp   = timestamp;
                relation.UserId      = null;
                relation.UserName    = null;
                relation.Version     = (ulong)version;
                relation.Visible     = visible;
                relation.UserName    = user;
                relation.UserId      = uid;

                if (!_relationTagReader.IsClosed)
                {
                    long returned_id = _relationTagReader.GetInt64(0);
                    while (returned_id == relation.Id.Value)
                    {
                        if (relation.Tags == null)
                        {
                            relation.Tags = new SimpleTagsCollection();
                        }
                        string key   = _relationTagReader.GetString(1);
                        string value = _relationTagReader.GetString(2);

                        relation.Tags.Add(key, value);

                        if (!_relationTagReader.Read())
                        {
                            _relationTagReader.Close();
                            returned_id = -1;
                        }
                        else
                        {
                            returned_id = _relationTagReader.GetInt64(0);
                        }
                    }
                }
                if (!_relationMemberReader.IsClosed)
                {
                    long returned_id = _relationMemberReader.GetInt64(0);
                    while (returned_id == relation.Id.Value)
                    {
                        if (relation.Members == null)
                        {
                            relation.Members = new List <RelationMember>();
                        }
                        string member_type = _relationMemberReader.GetString(1);
                        long   member_id   = _relationMemberReader.GetInt64(2);
                        object member_role = _relationMemberReader.GetValue(3);

                        RelationMember member = new RelationMember();
                        member.MemberId = member_id;
                        if (member_role != DBNull.Value)
                        {
                            member.MemberRole = member_role as string;
                        }
                        switch (member_type)
                        {
                        case "Node":
                            member.MemberType = OsmGeoType.Node;
                            break;

                        case "Way":
                            member.MemberType = OsmGeoType.Way;
                            break;

                        case "Relation":
                            member.MemberType = OsmGeoType.Relation;
                            break;
                        }

                        relation.Members.Add(member);

                        if (!_relationMemberReader.Read())
                        {
                            _relationMemberReader.Close();
                            returned_id = -1;
                        }
                        else
                        {
                            returned_id = _relationMemberReader.GetInt64(0);
                        }
                    }
                }

                // set the current variable!
                _current = relation;

                // advance the reader(s).
                if (!_relationReader.Read())
                {
                    _relationReader.Close();
                }
                if (!_relationTagReader.IsClosed && !_relationTagReader.Read())
                {
                    _relationTagReader.Close();
                }
                if (!_relationMemberReader.IsClosed && !_relationMemberReader.Read())
                {
                    _relationMemberReader.Close();
                }
                return(true);
            }
            else
            {
                _relationReader.Close();
                _relationReader.Dispose();
                _relationReader = null;

                _relationTagReader.Close();
                _relationTagReader.Dispose();
                _relationTagReader = null;

                _current_type = OsmGeoType.Relation;

                return(false);
            }
        }
 /// <summary>
 /// Adds a relation.
 /// </summary>
 /// <param name="relation"></param>
 public override void AddRelation(Relation relation)
 {
     _stream.Append(relation);
 }
Exemple #37
0
        public override void PopulateForeignRelations(Entity entity)
        {
            Entity prntEnt;
            Entity frnEntity = null;

            DS.SchemaReader.ForeignRelationsDataTable tr = new DS.SchemaReader.ForeignRelationsDataTable();
            DS.SchemaReaderTableAdapters.ForeignRelationsTableAdapter tra = new DS.SchemaReaderTableAdapters.ForeignRelationsTableAdapter();
            tra.Connection = new System.Data.SqlClient.SqlConnection(base.ConnectionString);
            tra.FillBy(tr, entity.DBName);


            DS.SchemaReader.TABLE_CONSTRAINTSDataTable tc = new DS.SchemaReader.TABLE_CONSTRAINTSDataTable();
            DS.SchemaReaderTableAdapters.TABLE_CONSTRAINTSTableAdapter tca = new DS.SchemaReaderTableAdapters.TABLE_CONSTRAINTSTableAdapter();
            tca.Connection = new System.Data.SqlClient.SqlConnection(base.ConnectionString);
            tca.FillByTableName(tc, entity.DBName);
            System.Data.DataRow[] tcrows = tc.Select("CONSTRAINT_TYPE = 'FOREIGN KEY'");
            foreach (DS.SchemaReader.TABLE_CONSTRAINTSRow tcr in tcrows)
            {
                System.Data.DataRow[] trrows            = tr.Select("ConstraintName = '" + tcr.CONSTRAINT_NAME + "'");
                DS.SchemaReader.ForeignRelationsRow trr = (DS.SchemaReader.ForeignRelationsRow)trrows[0];
                string ftab = trr.RefTab;;
                prntEnt = entity.Model.EntityCollection.Find(delegate(Entity ent) { return(ent.DBName == ftab); });

                // this code assumes that the foreign keys' source is the primary key
                // allthough the source could be a unique key
                Constraint pk  = prntEnt.Constraints.Find(delegate(Constraint c) { return(c.Type == "PRIMARY KEY"); });
                Constraint fk  = entity.Constraints.Find(delegate(Constraint c) { return(c.Name == tcr.CONSTRAINT_NAME); });
                Relation   rel = new Relation();

                EntityReference child = new EntityReference();
                child.Entity   = entity;
                child.EntityID = entity.EntityID;
                // child.EntityName = entity.LogicalName;
                rel.ChildEntity = child;


                EntityReference parent = new EntityReference();
                parent.Entity   = prntEnt;
                parent.EntityID = prntEnt.EntityID;
                // parent.EntityName = prntEnt.LogicalName;
                rel.ParentEntity = parent;


                RelationReference relref = new RelationReference();
                relref.Relation = rel;
                relref.ID       = System.Guid.NewGuid().ToString();
                entity.ParentRelations.Add(relref);
                prntEnt.ChildRelations.Add(relref);

                rel.ID = relref.ID;

                foreach (FieldReference frf in pk.Fields)
                {
                    rel.RelatedFields.Add(frf);
                }
                foreach (FieldReference pkf in fk.Fields)
                {
                    rel.ForeignFields.Add(pkf);
                }
                //rel.RelatedEntityID = prntEnt.EntityID;
                rel.Type = new RelationType();

                rel.Type.Usage = TypeUsage.Parent;

                string logical = child.Entity.LogicalName + "." + fk.Fields[0].RelatedField.DBName;
                rel.LogicalName = logical;
                entity.Model.Relations.Add(rel);
            }
        }
Exemple #38
0
        //Recupera una propiedad del objeto
        public void getProperty(Object obj, String name)
        {
            Type  type = obj.GetType();
            Model m    = ModelManager.getModel(type.Name);

            List <Tuple <String, Object> > pks = fieldsToDatabasePairs(obj, m.PrimaryKeys);

            Relation r = m.getRelationByName(name);

            if (r != null)
            {
                List <String> relationFields = new List <String>();
                foreach (ForeignKey fk in r.ForeignKeys)
                {
                    relationFields.Add(fk.Name);
                }
                if (r.OneToMany == false)
                {
                    Database           db = DatabaseManager.getDatabase(m.PrimaryDatabase);
                    TransactionManager tr = startTransaction(db);

                    List <Tuple <String, Object> > foreingKeysAndValues = tr.getForeignKeysFromOneToOne(m.Name, pks, relationFields);

                    Type   ftype         = type.GetProperty(r.Name).PropertyType;
                    Object foreignObject = Activator.CreateInstance(ftype);

                    foreach (Tuple <String, Object> fkVal in foreingKeysAndValues)
                    {
                        String fPk = (from fk in r.ForeignKeys where fk.Name == fkVal.Item1 select fk.NameAsPk).First();

                        ftype.GetProperty(fPk).SetValue(foreignObject, fkVal.Item2);
                    }

                    try
                    {
                        get(foreignObject);
                        type.GetProperty(name).SetValue(obj, foreignObject);
                    } catch (GeneralORMException)
                    {
                        type.GetProperty(name).SetValue(obj, null);
                    }
                }
                else
                {
                    Model    fmodel = ModelManager.getModel(r.ModelName);
                    Database db     = DatabaseManager.getDatabase(fmodel.PrimaryDatabase);

                    List <Tuple <String, Object> > fields = new List <Tuple <String, Object> >();
                    foreach (ForeignKey fk in r.ForeignKeys)
                    {
                        String fieldValue = type.GetProperty(fk.NameAsPk).GetValue(obj).ToString();
                        fields.Add(new Tuple <String, Object>(fk.Name, fieldValue));
                    }

                    TransactionManager tr = startTransaction(db);

                    List <List <Tuple <String, Object> > > results = tr.getWhere(r.ModelName, fields);

                    Type fltype            = type.GetProperty(r.Name).PropertyType;
                    Type ftype             = fltype.GetGenericArguments()[0];
                    var  foreignObjectList = (System.Collections.IList)Activator.CreateInstance(fltype);
                    foreach (List <Tuple <String, Object> > result in results)
                    {
                        Object foreignObject = Activator.CreateInstance(ftype);

                        resPairToObject(foreignObject, result, ftype, fmodel);

                        foreignObjectList.Add(foreignObject);
                    }

                    type.GetProperty(name).SetValue(obj, foreignObjectList);
                }
            }
            else
            {
                Field f = m.getFieldByName(name);

                Database           db = DatabaseManager.getDatabase(f.DatabaseName);
                TransactionManager tr = startTransaction(db);

                Object result = tr.getField(m.Name, pks, f.Name);

                type.GetProperty(name).SetValue(obj, result);
            }
        }
Exemple #39
0
 public NumericRelationalExpression(NumericExpression _rhs, NumericExpression _lhs, Relation _rel)
 {
     // NOTE LHS AND RHS SWAPPED IN CONSTRUCTOR!
     LHS = _lhs;
     RHS = _rhs;
     rel = _rel;
 }
Exemple #40
0
        public static void Initialize(ApplicationDbContext context)
        {
            context.Database.EnsureCreated();
            string[]   departmentsArray = new string[] { "Design", "Development", "Offshore", "Sales" };
            Guid[]     departmentsIds   = new Guid[departmentsArray.Length];
            string[]   jobTitlesArray   = new string[] { "Developer", "Architect", "Manager", "Designer" };
            Guid[]     jobTitlesIds     = new Guid[jobTitlesArray.Length];
            string[]   statusArray      = new string[] { "Work", "Sick", "Holliday", "Free" };
            Guid[]     statusesIds      = new Guid[statusArray.Length];
            Status[]   statuses         = new Status[statusArray.Length];
            Employee[] employees        = new Employee[65];
            DateTime   startDate        = DateTime.UtcNow.AddDays(-60);

            #region Status
            if (!context.Status.Any())
            {
                for (int i = 0; i < statuses.Length; i++)
                {
                    statuses[i] = new Status
                    {
                        Id    = Guid.NewGuid(),
                        Title = statusArray[i]
                    };
                    statusesIds[i] = statuses[i].Id;
                }
                context.AddRange(statuses);
                context.SaveChanges();
            }

            #endregion

            #region Departments
            if (!context.Departments.Any())
            {
                Department[] departments = new Department[departmentsArray.Length];
                for (int i = 0; i < departments.Length; i++)
                {
                    departments[i] = new Department
                    {
                        Id    = Guid.NewGuid(),
                        Title = departmentsArray[i]
                    };
                    departmentsIds[i] = departments[i].Id;
                }
                context.AddRange(departments);
                context.SaveChanges();
            }



            #endregion

            #region JobTitle
            if (!context.JobTitles.Any())
            {
                JobTitle[] jobTitles = new JobTitle[jobTitlesArray.Length];
                for (int i = 0; i < jobTitles.Length; i++)
                {
                    jobTitles[i] = new JobTitle
                    {
                        Id    = Guid.NewGuid(),
                        Title = jobTitlesArray[i]
                    };
                    jobTitlesIds[i] = jobTitles[i].Id;
                }
                context.AddRange(jobTitles);
                context.SaveChanges();
            }

            #endregion

            #region Relations
            if (!context.Relations.Any())
            {
                Relation[] relations = new Relation[15];
                for (int i = 0; i < relations.Length; i++)
                {
                    relations[i] = new Relation
                    {
                        Id         = Guid.NewGuid(),
                        RelationId = rnd.Next(1, 99999).ToString(),
                        Title      = Faker.Company.Name(),
                        Address    = new Address
                        {
                            Id       = Guid.NewGuid(),
                            Street   = Faker.Address.StreetName(),
                            House    = rnd.Next(199).ToString(),
                            City     = Faker.Address.City(),
                            Country  = Faker.Address.Country(),
                            PostCode = Faker.Address.ZipCode()
                        },
                        Contact = new Contact
                        {
                            Id            = Guid.NewGuid(),
                            ContactPerson = Faker.Name.FullName(),
                            PhoneNumber   = Faker.Phone.Number(),
                            Email         = Faker.Internet.Email()
                        },
                        Note = new Note
                        {
                            Id    = Guid.NewGuid(),
                            Title = Faker.Lorem.Sentence(2)
                        }
                    };
                }
                context.AddRange(relations);
                context.SaveChanges();
            }
            #endregion

            #region Employees
            if (!context.Employees.Any())
            {
                var personGenerator = new PersonNameGenerator();

                var relation = context.Relations.Where(x => x.RelationType == RelationType.Subcontractor).FirstOrDefault();
                for (int i = 0; i < employees.Length; i++)
                {
                    employees[i] = new Employee
                    {
                        Id              = Guid.NewGuid(),
                        EmployeeID      = rnd.Next(1, 9999).ToString(),
                        FirstName       = personGenerator.GenerateRandomFirstName(),
                        LastName        = personGenerator.GenerateRandomLastName(),
                        DepartmentId    = departmentsIds[rnd.Next(4)],
                        JobTitleId      = jobTitlesIds[rnd.Next(4)],
                        IsSubcontractor = false,
                        //Subcontractor = relation,
                        Address = new Address
                        {
                            Id       = Guid.NewGuid(),
                            Street   = Faker.Address.StreetName(),
                            House    = rnd.Next(199).ToString(),
                            Flat     = rnd.Next(30).ToString(),
                            City     = Faker.Address.City(),
                            Country  = Faker.Address.Country(),
                            PostCode = Faker.Address.ZipCode()
                        },
                        Contact = new Contact
                        {
                            Id = Guid.NewGuid(),
                            //ContactPerson = Faker.Name.FullName(),
                            PhoneNumber = Faker.Phone.Number(),
                            Email       = Faker.Internet.Email()
                        },
                    };
                }
                context.AddRange(employees);
                context.SaveChanges();
            }
            #endregion

            #region Cars
            if (!context.Cars.Any())
            {
                Car[] cars = new Car[] {
                    new Car {
                        Id = Guid.NewGuid(), NumberPlate = "HHA015", Model = "Opel Astra"
                    },
                    new Car {
                        Id = Guid.NewGuid(), NumberPlate = "HHA012", Model = "Kia Ceed"
                    },
                    new Car {
                        Id = Guid.NewGuid(), NumberPlate = "OHB114", Model = "VW Gold"
                    },
                    new Car {
                        Id = Guid.NewGuid(), NumberPlate = "AHN336", Model = "Opel Vectra"
                    }
                };
                context.AddRange(cars);
                context.SaveChanges();
            }

            #endregion

            #region Tags
            if (!context.Tags.Any())
            {
                Tag[] tags = new Tag[] {
                    new Tag {
                        Id = Guid.NewGuid(), Title = "Java", Level = TagLevel.Level1, TagType = TagType.Employee
                    },
                    new Tag {
                        Id = Guid.NewGuid(), Title = "C#", Level = TagLevel.Level1, TagType = TagType.Employee
                    },
                    new Tag {
                        Id = Guid.NewGuid(), Title = "English", Level = TagLevel.Level2, TagType = TagType.Employee
                    },
                    new Tag {
                        Id = Guid.NewGuid(), Title = "Design", Level = TagLevel.Level3, TagType = TagType.Employee
                    },
                    new Tag {
                        Id = Guid.NewGuid(), Title = "Web", Level = TagLevel.Level1, TagType = TagType.Project
                    },
                    new Tag {
                        Id = Guid.NewGuid(), Title = "Mobile", Level = TagLevel.Level1, TagType = TagType.Project
                    },
                    new Tag {
                        Id = Guid.NewGuid(), Title = "India", Level = TagLevel.Level2, TagType = TagType.Project
                    }
                };
                context.AddRange(tags);
                context.SaveChanges();
            }

            #endregion

            /*
             * // event generator
             * if (!context.Events.Any())
             * {
             *  List<Event> events = new List<Event>();
             *
             *  for (int i = 0; i < employees.Length; i++)
             *  {
             *      var amount = rnd.Next(10);
             *      var date = startDate;
             *      for (int j = 0; j < amount; j++)
             *      {
             *          var e = EventGenerator(employees[i].Id, date);
             *          events.Add(e);
             *          date = e.Till;
             *          e = null;
             *      }
             *  }
             *  context.AddRange(events);
             *  context.SaveChanges();
             * }
             */

            #region Projects
            if (!context.Projects.Any())
            {
                var       client  = context.Relations.FirstOrDefault();
                Project[] project = new Project[] {
                    new Project {
                        Id = Guid.NewGuid(), Title = "GoBiGas", Manager = "Petras Kaufmanas", Client = client
                    },
                    new Project {
                        Id = Guid.NewGuid(), Title = "Piping installation", Manager = "Andris Parnu", Client = client
                    },
                    new Project {
                        Id = Guid.NewGuid(), Title = "Insulation Tanks", Manager = "Jeronimas Milius", Client = client
                    },
                };
                context.AddRange(project);
                context.SaveChanges();
            }
            #endregion

            #region Events
            if (!context.EmployeeEvents.Any())
            {
                var employee = context.Employees.FirstOrDefault();
                var project  = context.Projects.FirstOrDefault();

                EmployeeEvent[] employeeEvents = new EmployeeEvent[]
                {
                    new EmployeeEvent
                    {
                        Id       = Guid.NewGuid(),
                        Start    = DateTime.UtcNow.AddDays(-10),
                        End      = DateTime.UtcNow.AddDays(15),
                        Resource = employee.Id,
                        Project  = project,
                        Status   = statuses[0]
                    },
                    new EmployeeEvent
                    {
                        Id       = Guid.NewGuid(),
                        Start    = DateTime.UtcNow.AddDays(25),
                        End      = DateTime.UtcNow.AddDays(120),
                        Resource = employee.Id,
                        Project  = project,
                        Status   = statuses[1]
                    }
                };

                context.AddRange(employeeEvents);
                context.SaveChanges();
            }

            if (!context.CarEvents.Any())
            {
                var employee = context.Employees.FirstOrDefault();
                var car      = context.Cars.FirstOrDefault();

                CarEvent[] carEvents = new CarEvent[]
                {
                    new CarEvent
                    {
                        Id       = Guid.NewGuid(),
                        Start    = DateTime.UtcNow.AddDays(-10),
                        End      = DateTime.UtcNow.AddDays(15),
                        Resource = car.Id,
                        Employee = employee,
                        Status   = statuses[2]
                    },
                    new CarEvent
                    {
                        Id       = Guid.NewGuid(),
                        Start    = DateTime.UtcNow.AddDays(25),
                        End      = DateTime.UtcNow.AddDays(120),
                        Resource = car.Id,
                        Employee = employee,
                        Status   = statuses[0]
                    }
                };

                context.AddRange(carEvents);
                context.SaveChanges();
            }
            #endregion
        }
Exemple #41
0
 /// <summary>
 /// Extension method to get a relation from it's parent and child Ids
 /// </summary>
 /// <param name="relationType">an instance of umbraco.cms.businesslogic.relation.RelationType</param>
 /// <param name="parentId">parentId of relation</param>
 /// <param name="childId">child Id of relation</param>
 /// <returns>null or the Relation matching supplied parentId and childId</returns>
 public static Relation GetRelation(this RelationType relationType, int parentId, int childId)
 {
     return(Relation.GetRelations(parentId, relationType).Where(relation => relation.Child.Id == childId).First());
 }
Exemple #42
0
 public override IEnumerable <ITarget> GetOptions(Unit source, GameState gameState)
 {
     return(UnitZone.GetZone(gameState)
            .Where(Selfness.Getter(source))
            .Where(Relation.Getter(source)));
 }
Exemple #43
0
        public virtual void Initialize(IModelObject model)
        {
            try
            {
                _model = (ModelRoot)model;

                var hasMetaData = false;
                foreach (var table in (from x in _model.Database.Tables where x.Generated orderby x.Name select x))
                {
                    if (table.CreateMetaData)
                    {
                        hasMetaData = true;
                    }
                }

                Table projectItemDataType = null;
                if (hasMetaData)
                {
                    #region Create the PROPERTY_ITEM_DATA_TYPE table
                    projectItemDataType = _model.Database.Tables.Add("PROPERTY_ITEM_DATA_TYPE");
                    projectItemDataType.IsMetaDataMaster = true;

                    Column column = null;
                    column = _model.Database.Columns.Add("property_item_data_type_id");
                    column.ParentTableRef = projectItemDataType.CreateRef();
                    column.DataType       = System.Data.SqlDbType.Int;
                    column.PrimaryKey     = true;
                    column.Identity       = IdentityTypeConstants.None;
                    column.AllowNull      = false;
                    projectItemDataType.Columns.Add(column.CreateRef());

                    column = _model.Database.Columns.Add("name");
                    column.ParentTableRef = projectItemDataType.CreateRef();
                    column.DataType       = System.Data.SqlDbType.VarChar;
                    column.Length         = 50;
                    column.AllowNull      = false;
                    projectItemDataType.Columns.Add(column.CreateRef());
                    #endregion
                }

                foreach (var table in (from x in _model.Database.Tables where x.Generated orderby x.Name select x))
                {
                    if (table.CreateMetaData)
                    {
                        Column column = null;

                        #region Create the PROPERTY_ITEM_DEFINE table
                        var projectItemDefineTable = _model.Database.Tables.Add(table.DatabaseName + "_PROPERTY_ITEM_DEFINE");
                        projectItemDefineTable.IsMetaDataDefinition = true;

                        column = _model.Database.Columns.Add("property_item_define_id");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.Int;
                        column.PrimaryKey     = true;
                        column.Identity       = IdentityTypeConstants.Database;
                        column.AllowNull      = false;
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        column = _model.Database.Columns.Add("name");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.VarChar;
                        column.Length         = 50;
                        column.AllowNull      = false;
                        column.UIVisible      = true;
                        column.SortOrder      = 0;
                        column.FriendlyName   = "Name";
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        column                = _model.Database.Columns.Add("property_item_data_type");
                        column.EnumType       = "PropertyBagDataTypeConstants";
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.Int;
                        column.UIVisible      = true;
                        column.SortOrder      = 1;
                        column.FriendlyName   = "Data type";
                        column.AllowNull      = false;
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        //RELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATION
                        //Add a relation to from the datatype table to this one
                        var relation2 = _model.Database.Relations.Add();
                        relation2.ParentTableRef = projectItemDataType.CreateRef();
                        relation2.ChildTableRef  = projectItemDefineTable.CreateRef();
                        var relationship = new ColumnRelationship((INHydrateModelObject)relation2.Root);
                        relationship.ParentColumnRef = ((Column)projectItemDataType.Columns[0].Object).CreateRef();
                        relationship.ChildColumnRef  = column.CreateRef();
                        relation2.ColumnRelationships.Add(relationship);
                        projectItemDataType.Relationships.Add(relation2.CreateRef());
                        //RELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATIONRELATION

                        column = _model.Database.Columns.Add("group");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.VarChar;
                        column.Length         = 50;
                        column.AllowNull      = true;
                        column.UIVisible      = true;
                        column.SortOrder      = 2;
                        column.FriendlyName   = "Group";
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        column = _model.Database.Columns.Add("sort_index");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.Int;
                        column.AllowNull      = false;
                        column.UIVisible      = true;
                        column.SortOrder      = 3;
                        column.FriendlyName   = "Sort order";
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        column = _model.Database.Columns.Add("minimum_value");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.VarChar;
                        column.Length         = 50;
                        column.UIVisible      = true;
                        column.SortOrder      = 4;
                        column.FriendlyName   = "Minimum value";
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        column = _model.Database.Columns.Add("maximum_value");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.VarChar;
                        column.Length         = 50;
                        column.UIVisible      = true;
                        column.SortOrder      = 5;
                        column.FriendlyName   = "Maximum value";
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        column = _model.Database.Columns.Add("max_length");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.Int;
                        column.UIVisible      = true;
                        column.SortOrder      = 6;
                        column.FriendlyName   = "Maximum Length";
                        projectItemDefineTable.Columns.Add(column.CreateRef());


                        column = _model.Database.Columns.Add("is_required");
                        column.ParentTableRef = projectItemDefineTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.Bit;
                        column.AllowNull      = false;
                        column.UIVisible      = true;
                        column.SortOrder      = 7;
                        column.FriendlyName   = "Required";
                        projectItemDefineTable.Columns.Add(column.CreateRef());

                        #endregion

                        #region Create the PROPERTY_ITEM table
                        var projectItemValueTable = _model.Database.Tables.Add(table.DatabaseName + "_PROPERTY_ITEM");
                        projectItemValueTable.IsMetaData = true;

                        column = _model.Database.Columns.Add("property_item_id");
                        column.ParentTableRef = projectItemValueTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.Int;
                        column.PrimaryKey     = true;
                        column.AllowNull      = false;
                        column.Identity       = IdentityTypeConstants.Database;
                        projectItemValueTable.Columns.Add(column.CreateRef());

                        column = _model.Database.Columns.Add("property_item_define_id");
                        column.ParentTableRef = projectItemValueTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.Int;
                        column.AllowNull      = false;
                        projectItemValueTable.Columns.Add(column.CreateRef());

                        column = _model.Database.Columns.Add("item_value");
                        column.ParentTableRef = projectItemValueTable.CreateRef();
                        column.DataType       = System.Data.SqlDbType.VarChar;
                        column.Length         = 1024;
                        column.AllowNull      = false;
                        projectItemValueTable.Columns.Add(column.CreateRef());

                        //Create all primary keys
                        foreach (var pkColumn in table.PrimaryKeyColumns.OrderBy(x => x.Name))
                        {
                            column = _model.Database.Columns.Add(pkColumn.DatabaseName);
                            column.ParentTableRef = projectItemValueTable.CreateRef();
                            column.DataType       = pkColumn.DataType;
                            column.Length         = pkColumn.Length;
                            column.AllowNull      = false;
                            projectItemValueTable.Columns.Add(column.CreateRef());
                        }

                        //Add relationship between Definition and Value table
                        if (true)
                        {
                            var relation = new Relation(this._model);
                            relation.ParentTableRef = projectItemDefineTable.CreateRef();
                            relation.ChildTableRef  = projectItemValueTable.CreateRef();
                            var colRel = new ColumnRelationship(_model);
                            colRel.ParentColumnRef = projectItemDefineTable.Columns["property_item_define_id"];
                            colRel.ChildColumnRef  = projectItemValueTable.Columns["property_item_define_id"];
                            relation.ColumnRelationships.Add(colRel);
                            relation.RoleName = string.Empty;
                            _model.Database.Relations.Add(relation);
                            projectItemDefineTable.Relationships.Add(relation.CreateRef());
                        }

                        //Add relationship between Value table and primary table
                        if (true)
                        {
                            var relation = new Relation(this._model);
                            relation.ParentTableRef = table.CreateRef();
                            relation.ChildTableRef  = projectItemValueTable.CreateRef();
                            foreach (var pkColumn in table.PrimaryKeyColumns.OrderBy(x => x.Name))
                            {
                                var colRel = new ColumnRelationship(_model);
                                colRel.ParentColumnRef = table.Columns[pkColumn.DatabaseName];
                                colRel.ChildColumnRef  = projectItemValueTable.Columns[pkColumn.DatabaseName];
                                relation.RoleName      = string.Empty;
                                relation.ColumnRelationships.Add(colRel);
                                table.Relationships.Add(relation.CreateRef());
                            }
                            _model.Database.Relations.Add(relation);
                        }

                        #endregion
                    }
                }

                //_model = (ModelRoot)model;
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Exemple #44
0
 /// <summary>
 /// Gets the relations for the supplied id (wrapper for Relation.GetRelations)
 /// </summary>
 /// <param name="relationType">an instance of umbraco.cms.businesslogic.relation.RelationType</param>
 /// <param name="id">the id</param>
 /// <returns>relations for the id</returns>
 public static Relation[] GetRelations(this RelationType relationType, int id)
 {
     return(Relation.GetRelations(id, relationType));
 }
        /// <summary>
        /// Enlists an <see cref="IRelatableEntity"/> in a <see cref="RelationProxy"/> as a child of the <see cref="IRelatableEntity"/> which owns this collection.
        /// </summary>
        /// <param name="child">The child.</param>
        /// <param name="type">The type.</param>
        /// <param name="ordinal">The ordinal.</param>
        /// <param name="metaData">The meta data.</param>
        public void EnlistChild(IRelatableEntity child, AbstractRelationType type, int ordinal, params RelationMetaDatum[] metaData)
        {
            var newRelation = new Relation(type, _collectionOwner, child, ordinal, metaData);

            AddToChildrenWithLock(new RelationProxy(newRelation, RelationProxyStatus.ManuallyAdded));
        }
Exemple #46
0
            public PipeJunctionLabelingSolver2(NetworkNode nn,
                                               List <TextPosition> lblsNearNN)
            {
                this.nn         = nn;
                this.lblsNearNN = new List <TextPosition>(lblsNearNN);

                //Формирование списков приоритетных соотношений
                //между присоединениями к колодцу и подписями присоединений
                foreach (NetworkEdge ne in nn.AttachedEdges)
                {
                    bool start = ne.StartNode == nn;
                    NetworkEdgeWrapper newr = new NetworkEdgeWrapper(ne, start);
                    newrs.Add(ne, newr);

                    foreach (TextPosition txt in lblsNearNN)
                    {
                        Relation relation = new Relation(ne, start, txt);
                        newr.RelationsPriority.Add(relation);
                        TextPositionWrapper txtWr = null;
                        txtwrs.TryGetValue(txt, out txtWr);
                        if (txtWr == null)
                        {
                            txtWr       = new TextPositionWrapper(txt);
                            txtwrs[txt] = txtWr;
                        }
                        txtWr.RelationsPriority.Add(relation);
                    }

                    newr.RelationsPriority.Sort();
                }

                foreach (KeyValuePair <TextPosition, TextPositionWrapper> kvp in txtwrs)
                {
                    kvp.Value.RelationsPriority.Sort();
                }

                //Определить количество наиболее вероятных конкурирующих вариантов
                //Если обнаружено, что 1 текстовая метка является ближайшей к двум присоединениям,
                //то у этих присоединений количество конкурирующих вариантов подписей +1
                //Для текстовой метки количество конкурирующих вариантов равно количеству присоединений,
                //для которых она является ближайшей
                Dictionary <TextPosition, HashSet <NetworkEdgeWrapper> > txtPossibleOwners
                    = new Dictionary <TextPosition, HashSet <NetworkEdgeWrapper> >();

                foreach (NetworkEdgeWrapper newr in newrs.Values)
                {
                    //NetworkEdge edge = newr.NetworkEdge;

                    //
                    foreach (Relation relation in newr.RelationsPriority)
                    {
                        //принимать как конкурирующие все тексты на определеннном расстоянии,
                        //но не менее 1
                        if (relation.Distance > JUNCTION_LBL_COMPATITORS_DISTANCE && newr.CompCount > 0)
                        {
                            break;
                        }


                        newr.CompCount++;

                        TextPosition txtKey = relation.TextPosition;

                        HashSet <NetworkEdgeWrapper> possibleOwners = null;
                        txtPossibleOwners.TryGetValue(txtKey, out possibleOwners);
                        bool hasCompatitors = possibleOwners != null;
                        if (!hasCompatitors)
                        {
                            possibleOwners = new HashSet <NetworkEdgeWrapper>();
                            txtPossibleOwners.Add(txtKey, possibleOwners);
                        }

                        if (!possibleOwners.Contains(newr))
                        {
                            possibleOwners.Add(newr);
                        }

                        if (hasCompatitors)
                        {
                            txtwrs[txtKey].CompCount = possibleOwners.Count;

                            foreach (NetworkEdgeWrapper comp in possibleOwners)
                            {
                                comp.CompCount++;
                            }
                        }
                    }
                }


                //Поиск перебором сопоставления пар присоединение-текстовая метка,
                //которое дает наименьшее суммарное расстояние от текста до присоединения

                if (lblsNearNN.Count >= nn.AttachedEdges.Count)//зависит от того, чего больше: подписей или присоединений
                {
                    List <ISolverWrapper> edgeTxtSearchSeq
                        = newrs.Values.Cast <ISolverWrapper>().ToList();
                    edgeTxtSearchSeq.Sort();
                    invalidNumberCombinationResults = 0;
                    BruteForceSearch(edgeTxtSearchSeq, 0, new HashSet <NetworkEdge>(),
                                     new HashSet <TextPosition>(), new HashSet <int>(),
                                     new Dictionary <NetworkEdge, TextPosition>(), 0);
                }
                else
                {
                    List <ISolverWrapper> txtEdgeSearchSeq
                        = txtwrs.Values.Cast <ISolverWrapper>().ToList();
                    txtEdgeSearchSeq.Sort();
                    invalidNumberCombinationResults = 0;
                    BruteForceSearch(txtEdgeSearchSeq, 0, new HashSet <NetworkEdge>(),
                                     new HashSet <TextPosition>(), new HashSet <int>(),
                                     new Dictionary <NetworkEdge, TextPosition>(), 0);
                }
            }
 private void ValidateBookmarkRelation(Relation BookmarkRelation)
 {
     Assert.NotNull(BookmarkRelation);
 }
Exemple #48
0
 /// <summary>
 /// Processes a relation.
 /// </summary>
 /// <param name="block"></param>
 /// <param name="relation"></param>
 void IPBFOsmPrimitiveConsumer.ProcessRelation(PrimitiveBlock block, Relation relation)
 {
     this.QueuePrimitive(block, relation);
 }
Exemple #49
0
        public static Column BuildColumn(PropertyInfo propertyInfo, Type tableType, List <Type> tableTypes, ITypeMapper typeMapper)
        {
            // property that is present in the db and in the object but needs to be initialized later
            var      isShadowAttribute = false;
            var      manyToOneUsed     = false;
            var      constraints       = new HashSet <Constraint>();
            Relation relation          = null;

            // TODO: FK are not handled at all?!
            foreach (var propertyInfoCustomAttribute in propertyInfo.GetCustomAttributes())
            {
                if (propertyInfoCustomAttribute.GetType() == typeof(Pk))
                {
                    constraints.Add(propertyInfoCustomAttribute as Constraint);
                    var superClass = tableTypes.Where(tableType.IsSubclassOf).ToList();
                    // if its a primary key and it is a subclass then the teacher for example is also a person and needs a foreignkey on the personclass primary id
                    if (superClass.Any())
                    {
                        relation = new Fk(superClass.First());
                    }
                }
                else if (propertyInfoCustomAttribute.GetType() == typeof(ManyToMany))
                {
                    var manyToMany = propertyInfoCustomAttribute as ManyToMany;
                    manyToMany.ToPocoType = propertyInfo.PropertyType.GetGenericArguments()[0];
                    relation = manyToMany;
                }
                else if (propertyInfoCustomAttribute.GetType() == typeof(OneToMany))
                {
                    var oneToMany = propertyInfoCustomAttribute as OneToMany;
                    oneToMany.MappedByPocoType = propertyInfo.PropertyType.GetGenericArguments()[0];
                    relation = propertyInfoCustomAttribute as Relation;
                }
                else if (propertyInfoCustomAttribute.GetType() == typeof(ManyToOne))
                {
                    var manyToOne = propertyInfoCustomAttribute as ManyToOne;
                    manyToOne.ToPocoType = propertyInfo.PropertyType;
                    manyToOneUsed        = true;
                    relation             = manyToOne;
                    isShadowAttribute    = true;
                }
                else
                {
                    constraints.Add(propertyInfoCustomAttribute as Constraint);
                }
            }

            // TODO: think about avoiding checking by customattribute and naming separately (problem if no customattributes no loop)
            if ("id".Equals(propertyInfo.Name.ToLower()))
            {
                constraints.Add(new Pk());
                var superClass = tableTypes.Where(tableType.IsSubclassOf).ToList();
                if (superClass.Any())
                {
                    relation = new Fk(superClass.First());
                }
            }

            // now check if it is a regular 1-1 relationship
            // beware of doing this double later!
            // TODO: think about avoiding doing it like this too
            if (!manyToOneUsed)
            {
                var oneToOne = tableTypes.Where(tType => propertyInfo.PropertyType == tType).ToList();
                if (oneToOne.Any())
                {
                    relation = new Fk(oneToOne.First());
                }
            }

            return(new Column(
                       BuildColumnName(propertyInfo),
                       relation,
                       constraints,
                       propertyInfo,
                       DbType(propertyInfo.PropertyType, tableTypes, constraints, typeMapper),
                       isShadowAttribute
                       ));
        }
        /// <summary>
        /// Adds a relation.
        /// </summary>
        /// <param name="relation"></param>
        public override void AddRelation(Relation relation)
        {
            DataRow relation_row = _relationTable.NewRow();

            // format data and create parameters.
            long?id = relation.Id.Value;  // id should alrelations contain a value.

            relation_row["id"] = id.ConvertToDBValue <long>();

            long?changeset_id = relation.ChangeSetId;

            relation_row["changeset_id"] = changeset_id.ConvertToDBValue <long>();

            if (!relation.Visible.HasValue)
            {
                relation_row["visible"] = DBNull.Value;
            }
            else
            {
                relation_row["visible"] = relation.Visible.Value ? 1 : 0;
            }

            DateTime?timestamp = relation.TimeStamp;

            relation_row["timestamp"] = timestamp.ConvertToDBValue <DateTime>();

            ulong?version = relation.Version;

            relation_row["version"] = version.ConvertToDBValue <ulong>();

            // set the usr
            relation_row["usr"]    = relation.UserName;
            relation_row["usr_id"] = relation.UserId.ConvertToDBValue <long>();

            // add the node and it's tags.
            _relationTable.Rows.Add(relation_row);

            // tags.
            if (relation.Tags != null)
            {
                foreach (Tag tag in relation.Tags)
                {
                    string key   = tag.Key;
                    string value = tag.Value;

                    DataRow tag_row = _relationTagsTable.NewRow();
                    tag_row["relation_id"] = id;
                    tag_row["key"]         = key.Truncate(255);
                    tag_row["value"]       = value.Truncate(255);

                    _relationTagsTable.Rows.Add(tag_row);
                }
            }

            // member.
            if (relation.Members != null)
            {
                long relation_id = relation.Id.Value;

                for (int idx = 0; idx < relation.Members.Count; idx++)
                {
                    RelationMember member = relation.Members[idx];;

                    DataRow tag_row = _relationMembersTable.NewRow();
                    tag_row["relation_id"] = id;
                    tag_row["member_type"] = member.MemberType;
                    tag_row["member_id"]   = member.MemberId;
                    tag_row["member_role"] = member.MemberRole;
                    tag_row["sequence_id"] = idx;

                    _relationMembersTable.Rows.Add(tag_row);
                }
            }

            // bulk insert if needed.
            if (_relationTable.Rows.Count >= _batch_relations)
            {
                this.BulkCopy(_relationTable, "relation");
                this.BulkCopy(_relationTagsTable, "relation_tags");
                this.BulkCopy(_relationMembersTable, "relation_members");
                this.CreateRelationTables();
            }
        }
        private void ExtractFeature(FeatureFilter featureFilter, double[] centerPoint)
        {
            using (var fileStream = File.OpenRead(FeatureConfig.CityOSMData.GetPathInStreamingAssets()))
            {
                var source = new PBFOsmStreamSource(fileStream);

                var filtered = from osmGeo in source
                               where osmGeo.Type == OsmGeoType.Node ||
                               osmGeo.Type == OsmGeoType.Way ||
                               (osmGeo.Type == OsmGeoType.Relation && osmGeo.Tags != null && DoTagsMatch(osmGeo.Tags, featureFilter.Tags))
                               select osmGeo;

                var complete = filtered.ToComplete();

                var relationsCompleted = complete.Where(x => x.Type == OsmGeoType.Relation).ToArray();
                var relations          = new Relation[relationsCompleted.Length];
                var lines = new List <Line>();

                UnityEngine.Debug.Log(relationsCompleted.Length);

                for (int r = 0; r < relations.Length; r++)
                {
                    // Get RelationMembers
                    foreach (OsmGeo osmgeo in filtered)
                    {
                        var osmRelation = osmgeo as OsmSharp.Relation;
                        if (osmRelation == null || osmRelation.Id != relationsCompleted[r].Id)
                        {
                            continue;
                        }

                        var relationMembers = GetMembers(filtered.ToArray(), osmRelation, featureFilter.RelationMembers);
                        UnityEngine.Debug.Log(relationMembers.Length);

                        var relation = new Relation
                        {
                            Id   = osmRelation.Id.Value,
                            Type = Type.Relation,
                            Tags = featureFilter.Tags.AllOfTags.Select(tso => new Tag()
                            {
                                Key = tso.Key, Value = tso.Value
                            }).ToArray(),
                            Members = relationMembers
                        };

                        relations[r] = relation;
                    }

                    var relationMemberIds = relations[r].Members.Select(rm => rm.Id);

                    // Get Ids
                    Dictionary <long, long[]> memberNodes = new Dictionary <long, long[]>();
                    List <long> nodeIds = new List <long>();
                    foreach (OsmGeo osmgeo in filtered)
                    {
                        var way = osmgeo as Way;
                        if (way == null || !relationMemberIds.Contains(way.Id.Value))
                        {
                            continue;
                        }

                        memberNodes.Add(way.Id.Value, way.Nodes);
                        nodeIds.AddRange(way.Nodes);
                    }

                    // Get Nodes
                    List <Node> nodes = new List <Node>();
                    foreach (OsmGeo osmGeo in filtered)
                    {
                        var node = osmGeo as Node;
                        if (node == null || !nodeIds.Contains(node.Id.Value))
                        {
                            continue;
                        }
                        nodes.Add(node);
                    }

                    // Add Relation Member Points
                    for (int m = 0; m < relations[r].Members.Length; m++)
                    {
                        var member        = relations[r].Members[m];
                        var points        = new List <Point>();
                        var memberNodeIds = memberNodes.FirstOrDefault(mn => mn.Key == member.Id).Value;
                        for (int ni = 0; ni < memberNodeIds.Length; ni++)
                        {
                            var node = nodes.FirstOrDefault(n => n.Id.Value == memberNodeIds[ni]);
                            points.Add(ToPoint(node, centerPoint));
                        }

                        var line = new Line
                        {
                            Id     = member.Id,
                            Points = points.ToArray()
                        };

                        lines.Add(line);
                    }
                }

                var feature = new Feature
                {
                    Relations = relations,
                    Lines     = lines.ToArray()
                };

                var bytes = MessagePackSerializer.Serialize(feature);

                var featureFileName = FeatureConfig.CityName.Value + nameSeparator + featureFilter.Name + FeatureConfig.GeoFormat;
                var featureDataPath = Path.Combine(FeatureConfig.FeaturesDataPath.GetPathInStreamingAssets(), featureFileName);
                File.WriteAllBytes(featureDataPath, bytes);
            }
        }
Exemple #52
0
 /// <summary>
 /// Wrapper for Relation.IsRelated(int, int, RelationType)
 /// </summary>
 /// <param name="relationType">an instance of umbraco.cms.businesslogic.relation.RelationType</param>
 /// <param name="parentId">parentId to test</param>
 /// <param name="childId">childId to test</param>
 public static bool IsRelated(this RelationType relationType, int parentId, int childId)
 {
     return(Relation.IsRelated(parentId, childId, relationType));
 }
Exemple #53
0
 /// <summary>
 /// Adds a new relation
 /// </summary>
 public abstract void AddRelation(Relation relation);
Exemple #54
0
        /// <summary>
        /// Moves to the next object.
        /// </summary>
        /// <returns></returns>
        public override bool MoveNext()
        {
            if (!_cachingDone)
            { // first seek & cache.
                this.Seek();
                _cachingDone = true;
            }

            while (_simpleSource.MoveNext())
            { // there is data.
                OsmGeo currentSimple = _simpleSource.Current();

                switch (currentSimple.Type)
                {
                case OsmGeoType.Node:
                    // create complete version.
                    _current = currentSimple as Node;

                    if (_current != null && _current.Tags == null)
                    {     // make sure nodes have a default tag collection that is empty not null.
                        _current.Tags = new OsmSharp.Collections.Tags.TagsCollection();
                    }
                    if (_nodesToInclude.Contains(currentSimple.Id.Value))
                    {     // node needs to be cached.
                        _dataCache.AddNode(currentSimple as Node);
                        _nodesToInclude.Remove(currentSimple.Id.Value);
                    }
                    break;

                case OsmGeoType.Way:
                    // create complete way.
                    _current = CompleteWay.CreateFrom(currentSimple as Way, _dataCache);

                    if (_waysToInclude.Contains(currentSimple.Id.Value))
                    {     // keep the way because it is needed later on.
                        _dataCache.AddWay(currentSimple as Way);
                        _waysToInclude.Remove(currentSimple.Id.Value);
                    }
                    else
                    {     // only report that the nodes have been used when the way can be let-go.
                        Way way = currentSimple as Way;
                        if (way.Nodes != null)
                        {     // report usage.
                            way.Nodes.ForEach(x => this.ReportNodeUsage(x));
                        }
                    }
                    break;

                case OsmGeoType.Relation:
                    // create complate relation.
                    _current = CompleteRelation.CreateFrom(currentSimple as Relation, _dataCache);

                    if (!_relationsToInclude.Contains(currentSimple.Id.Value))
                    {     // only report relation usage when the relation can be let go.
                        Relation relation = currentSimple as Relation;
                        if (relation.Members != null)
                        {
                            foreach (RelationMember member in relation.Members)
                            {
                                switch (member.MemberType.Value)
                                {
                                case OsmGeoType.Node:
                                    this.ReportNodeUsage(member.MemberId.Value);
                                    break;

                                case OsmGeoType.Way:
                                    this.ReportWayUsage(member.MemberId.Value);
                                    break;

                                case OsmGeoType.Relation:
                                    this.ReportRelationUsage(member.MemberId.Value);
                                    break;
                                }
                            }
                        }
                    }
                    break;
                }
                if (_current != null)
                { // only return complete objects.
                    return(true);
                }
            }
            return(false);
        }
Exemple #55
0
 public Tuple <Node, Node> GetRelations(System.Linq.Expressions.Expression <Func <Node, bool> > query1, System.Linq.Expressions.Expression <Func <Node, bool> > query2, Relation relation)
 {
     throw new NotImplementedException();
 }
Exemple #56
0
 /// <summary>
 /// Tries to get the relation with the given id
 /// </summary>
 public abstract bool TryGetRelation(long id, out Relation relation);
Exemple #57
0
        void ProcessManyToManyRelation(Relation rel, object entity, EntityMap entityMap, InsertSqlInfo info, EntityAccessor entityAccessor, InsertSqlExecutionList executionList, ITypeConverterStore converterStore, ISession session)
        {
            if ((rel.RelationType != RelationshipType.ManyToMany) || !rel.Inverse)
            {
                return;
            }

            PropertyAccessor pinf;

            if (!entityAccessor.Properties.TryGetValue(rel.Name, out pinf))
            {
                throw new GoliathDataException("Property " + rel.Name + " not found in entity.");
            }

            var collection = pinf.GetMethod(entity) as System.Collections.IEnumerable;
            int counter    = 1;

            if (collection != null)
            {
                foreach (var relObj in collection)
                {
                    if (relObj == null)
                    {
                        continue;
                    }

                    var relEntityType  = relObj.GetType();
                    var relEntityMap   = session.SessionFactory.DbSettings.Map.GetEntityMap(relEntityType.FullName);
                    var relEntAccessor = entityAccessorStore.GetEntityAccessor(relEntityType, relEntityMap);
                    var paramName      = ParameterNameBuilderHelper.QueryParamName(entityMap, rel.MapColumn + counter);
                    var mapParamName   = ParameterNameBuilderHelper.QueryParamName(entityMap, rel.MapReferenceColumn + counter);

                    PropertyAccessor relPinf;
                    if (!relEntAccessor.Properties.TryGetValue(rel.ReferenceProperty, out relPinf))
                    {
                        throw new GoliathDataException("Reference " + rel.ReferenceProperty + " not found in entity.");
                    }

                    if (relEntityMap.PrimaryKey != null)
                    {
                        foreach (var pk in relEntityMap.PrimaryKey.Keys)
                        {
                            object pkValue;
                            if (HasUnsavedValue(pk, relPinf, relObj, converterStore, out pkValue))
                            {
                                Build(relObj, relEntityType, relEntityMap, executionList, session);
                            }

                            var manyToManyInfo = new InsertSqlInfo {
                                DelayExecute = true, TableName = rel.MapTableName
                            };

                            var param1 = new QueryParam(mapParamName, pk.Key.DbType)
                            {
                                Value = relPinf.GetMethod(relObj)
                            };
                            manyToManyInfo.Columns.Add(mapParamName, rel.MapReferenceColumn);
                            manyToManyInfo.Parameters.Add(mapParamName, param1);

                            PropertyAccessor mappedPinf;
                            if (!entityAccessor.Properties.TryGetValue(rel.MapPropertyName, out mappedPinf))
                            {
                                throw new GoliathDataException("Property " + rel.MapPropertyName + " not found in entity" + entityMap.FullName + ".");
                            }

                            var param2 = new QueryParam(paramName, rel.DbType)
                            {
                                Value = mappedPinf.GetMethod(entity)
                            };
                            manyToManyInfo.Columns.Add(paramName, rel.MapColumn);
                            manyToManyInfo.Parameters.Add(paramName, param2);

                            executionList.ExcuteStatement(session, manyToManyInfo, typeof(object));
                        }
                    }

                    counter++;
                }
            }
        }
Exemple #58
0
 public VORelation(Relation instance)
 {
     this.instance = instance;
 }
Exemple #59
0
 bool IsLoaded(IPersistentObject pc, Relation r)
 {
     return(((IPersistenceCapable)pc).NDOLoadState.RelationLoadState[GetOrdinal(r)]);
 }
Exemple #60
0
            private void BruteForceSearch(List <ISolverWrapper> searchSeq, int n,
                                          HashSet <NetworkEdge> edgesOut, HashSet <TextPosition> txtOut,
                                          HashSet <int> txtContentOut, Dictionary <NetworkEdge, TextPosition> result,
                                          double sumDist)
            {
                //NetworkEdgeWrapper newr = searchSeq[n];
                ISolverWrapper  w            = searchSeq[n];
                List <Relation> priorityList = w.RelationsPriority;

                bool possiblePairFound = false;
                int  i = 0;


                //перебрать все конкурирующие варианты,
                //если допустимая пара не найдена, то все оставшиеся
                //до тех пор пока допустимая пара не будет найдена
                while ((i < w.CompCount + invalidNumberCombinationResults && i < priorityList.Count) ||//если какие-то варианты были отбракованы из-за неправильного сочетания цифр, то прибавлять их количество к CompCount
                       (!possiblePairFound && i < priorityList.Count))
                {
                    Relation     relation   = priorityList[i];
                    NetworkEdge  edge       = relation.NetworkEdge;
                    TextPosition txt        = relation.TextPosition;
                    int          txtContent = Convert.ToInt32(txt.TextContent.Trim());
                    if (!txtOut.Contains(txt) && //не допускать один и тот же текст
                        !txtContentOut.Contains(txtContent) &&//не допускать 2 одинаковые цифры
                        !edgesOut.Contains(edge) //не допускать повторение ребер
                        )
                    {
                        possiblePairFound = true;
                        HashSet <NetworkEdge> edgesOutNextStep
                            = new HashSet <NetworkEdge>(edgesOut);
                        HashSet <TextPosition> txtOutNextStep
                            = new HashSet <TextPosition>(txtOut);
                        HashSet <int> txtContentOutNextStep
                            = new HashSet <int>(txtContentOut);
                        Dictionary <NetworkEdge, TextPosition> resultNextStep
                            = new Dictionary <NetworkEdge, TextPosition>(result);


                        edgesOutNextStep.Add(edge);
                        txtOutNextStep.Add(txt);
                        txtContentOutNextStep.Add(txtContent);
                        resultNextStep.Add(edge, txt);
                        double sumDistNextStep = sumDist + relation.Distance;

                        if (n != searchSeq.Count - 1)
                        {
                            BruteForceSearch(searchSeq, n + 1, edgesOutNextStep,
                                             txtOutNextStep, txtContentOutNextStep, resultNextStep, sumDistNextStep);
                        }
                        else
                        {
                            CheckCandidateResult(resultNextStep, sumDistNextStep);
                        }
                    }



                    i++;
                }

                if (!possiblePairFound)
                {
                    //данный проход завершен
                    CheckCandidateResult(result, sumDist);
                }
            }