示例#1
0
        /// <summary>
        ///     Gets the entity.
        /// </summary>
        /// <param name="entityRef">The entity reference.</param>
        /// <returns></returns>
        public JsonEntity GetEntity(EntityRef entityRef)
        {
            JsonEntity jsonEntity = Entities.FirstOrDefault(p => p.Id == entityRef.Id);

            if (jsonEntity == null)
            {
                jsonEntity = new JsonEntity(entityRef, this);
                Entities.Add(jsonEntity);
            }
            return(jsonEntity);
        }
示例#2
0
        /// <summary>
        ///     Initializes a new instance of the <see cref="JsonEntityData" /> class.
        /// </summary>
        /// <param name="entityData">The entity data.</param>
        /// <param name="context">The context.</param>
        public JsonEntityData(EntityData entityData, JsonEntityQueryResult context)
        {
            Id = 0;
            if (entityData == null)
            {
                return;
            }

            Id = entityData.Id.Id;

            JsonEntity jsonEntity = context.GetEntity(entityData.Id);

            jsonEntity.DataState = entityData.DataState;

            IEnumerable <EntityRef> newTypeIds = entityData.TypeIds.Where(p => !jsonEntity.TypeIds.Contains(p.Id));

            jsonEntity.TypeIds.AddRange(newTypeIds.Select(p => context.GetEntityRef(p).Id));

            foreach (FieldData f in entityData.Fields)
            {
                JsonFieldData existingField = jsonEntity.Fields.FirstOrDefault(p => p.FieldId == f.FieldId.Id);
                if (existingField == null)
                {
                    var jsonField = new JsonFieldData(f, context);
                    jsonEntity.Fields.Add(jsonField);
                }
            }

            foreach (RelationshipData r in entityData.Relationships)
            {
                JsonRelationshipData existing = jsonEntity.Relationships.FirstOrDefault(p => p.RelTypeId.Id == r.RelationshipTypeId.Id && p.RelTypeId.Alias == r.RelationshipTypeId.Alias && p.IsReverse == r.IsReverse);
                if (existing == null)
                {
                    // need to stick a placeholder relationship in place before recursively calling to set up the related entity data
                    var tempRel = new JsonRelationshipData(r, null);
                    jsonEntity.Relationships.Add(tempRel);                       // add this
                    var newRel = new JsonRelationshipData(r, context);           // before doing this

                    // now swap out the temp with the actual
                    jsonEntity.Relationships.Remove(tempRel);
                    jsonEntity.Relationships.Add(newRel);
                }
                else if (existing.Instances.Select(p => p.Entity).Except(r.Instances.Select(p => p.Entity.Id.Id)).Any( ))
                {
                    //throw new InvalidOperationException("Wasn't expecting diff relationship instances for same rel type on a given object....");
                    EventLog.Application.WriteWarning("Wasn't expecting diff relationship instances for same rel type on a given object....");
                }
            }
        }
示例#3
0
        /// <summary>
        ///     Gets the entity data.
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <param name="cache">The cache.</param>
        /// <param name="refsCache">The refs cache.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentException">
        /// </exception>
        public EntityData GetEntityData(long id, Dictionary <long, EntityData> cache = null, Dictionary <long, EntityRef> refsCache = null)
        {
            if (cache == null)
            {
                cache = new Dictionary <long, EntityData>( );
            }

            if (cache.ContainsKey(id))
            {
                return(cache[id]);
            }

            long entityId = id;

            Dictionary <long, EntityRef> refs = refsCache;

            if (refs == null)
            {
                refs = new Dictionary <long, EntityRef>( );
                foreach (JsonEntityRef er in  EntityRefs)
                {
                    if (!refs.ContainsKey(er.Id))
                    {
                        refs.Add(er.Id, er.ToEntityRef( ));
                    }
                }
            }

            var entityData = new EntityData( );

            if (refs.ContainsKey(entityId))
            {
                entityData.Id = refs[entityId];
            }
            cache[id] = entityData;

            JsonEntity entity = Entities.FirstOrDefault(p => p.Id == entityId);

            if (entity == null)
            {
                EventLog.Application.WriteTrace(DumpEntity(entityData));
                return(entityData);
            }

            entityData.DataState = entity.DataState;

            // Types
            if (entity.TypeIds.Any(p => !refs.ContainsKey(p)))
            {
                throw new ArgumentException(
                          string.Format("typeIds missing from entityRefs: {0}",
                                        string.Join(",", entity.TypeIds.Where(p => !refs.ContainsKey(p)))));
            }
            entityData.TypeIds = entity.TypeIds.Select(p => refs[p]).ToList( );

            // Fields
            if (entity.Fields.Any(p => !refs.ContainsKey(p.FieldId)))
            {
                throw new ArgumentException(
                          string.Format("fieldIds missing from entityRefs: {0}",
                                        string.Join(",", entity.Fields.Where(p => !refs.ContainsKey(p.FieldId)))));
            }
            entityData.Fields = entity.Fields.Select(p =>
                                                     new FieldData
            {
                FieldId = refs[p.FieldId],
                Value   = new TypedValue(p.Value)                         // TODO : Yikes! Use type-based string conversion, because this will break stuff
            }).ToList( );

            entityData.Relationships = new List <RelationshipData>( );
            foreach (JsonRelationshipData relationship in entity.Relationships)
            {
                var relData = new RelationshipData( );
                entityData.Relationships.Add(relData);

                relData.RelationshipTypeId = relationship.RelTypeId.ToEntityRef( );                 // refs[relationship.relTypeId.id];
                relData.IsReverse          = relationship.IsReverse;
                relData.RemoveExisting     = relationship.RemoveExisting;
                relData.DeleteExisting     = relationship.DeleteExisting;
                relData.AutoCardinality    = relationship.AutoCardinality;
                relData.Instances          = new List <RelationshipInstanceData>( );
                foreach (JsonRelationshipInstanceData inst in relationship.Instances)
                {
                    if (inst.Entity != 0)
                    {
                        relData.Instances.Add(new RelationshipInstanceData
                        {
                            Entity = GetEntityData(inst.Entity, cache, refs),
                            RelationshipInstanceEntity = inst.RelEntity != 0 ? GetEntityData(inst.RelEntity, cache, refs) : null,
                            DataState = inst.DataState
                        });
                    }
                }
            }

            //EventLog.Application.WriteTrace( DumpEntity( entityData ) );
            return(entityData);
        }