/// <summary> /// Adds stream properties to structural value. /// </summary> /// <param name="entity">The target structural value.</param> /// <param name="payload">The payload with the entity values.</param> /// <param name="xmlBaseAnnotations">The xml base annotations ancestors and local element</param> private void AddStreamProperties(QueryStructuralValue entity, EntityInstance payload, IEnumerable <XmlBaseAnnotation> xmlBaseAnnotations) { ExceptionUtilities.CheckArgumentNotNull(entity, "entity"); ExceptionUtilities.CheckArgumentNotNull(payload, "payload"); var xmlBaseAnnotationsList = xmlBaseAnnotations.ToList(); if (payload.IsMediaLinkEntry()) { string editLink = this.NormalizeLinkFromPayload(payload.StreamEditLink, xmlBaseAnnotationsList); string selfLink = this.NormalizeLinkFromPayload(payload.StreamSourceLink, xmlBaseAnnotationsList); entity.SetStreamValue(null, payload.StreamContentType, payload.StreamETag, editLink, selfLink, new byte[0]); } foreach (var stream in payload.Properties.OfType <NamedStreamInstance>()) { string contentType = stream.SourceLinkContentType; if (contentType == null) { contentType = stream.EditLinkContentType; } string editLink = this.NormalizeLinkFromPayload(stream.EditLink, xmlBaseAnnotationsList); string selfLink = this.NormalizeLinkFromPayload(stream.SourceLink, xmlBaseAnnotationsList); entity.SetStreamValue(stream.Name, contentType, stream.ETag, editLink, selfLink, new byte[0]); } }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { var epmTrees = payloadElement.Annotations.OfType<XmlTreeAnnotation>().ToList(); if (epmTrees.Count > 0) { var entityType = payloadElement.Annotations .OfType<DataTypeAnnotation>() .Select(d => d.DataType) .OfType<EntityDataType>() .Select(d => d.Definition) .SingleOrDefault(); ExceptionUtilities.CheckObjectNotNull(entityType, "Could not get entity type from payload annotations"); } // do EPM first so that in-content values win base.Visit(payloadElement); if (epmTrees.Count > 0) { // When deep EPM is involved, we can generate named values for mapped properties of a complex // property that has null value. So, trim any child paths of null values. var nullValueList = this.valuesByName.Where(v => v.Value.Value == null).ToList(); foreach (var nullValue in nullValueList) { var nullChildPaths = this.orderedNames.Where(n => n.StartsWith(nullValue.Key + ".", StringComparison.OrdinalIgnoreCase)).ToList(); foreach (var nullChildPath in nullChildPaths) { this.RemoveValue(nullChildPath); } } } }
public override Object Evaluate(EntityInstance entityInstance, object[] objects) { string text = (string)objects[0]; StringBuilder result = new StringBuilder(); bool capitalizeNext = true; for (int i = 0; i < text.Length; i++) { char c = text[i]; if (char.IsLetter(c) && capitalizeNext) { result.Append(char.ToUpper(c)); capitalizeNext = false; } else { result.Append(c); if (char.IsWhiteSpace(c)) { capitalizeNext = true; } } } return(result.ToString()); }
/// <summary> /// Matches an actual entity instance of a person against. /// </summary> /// <param name="actualEntityInstance">The actual entity instance to verify.</param> /// <param name="expectedId">The expected id of the Person.</param> /// <param name="expectedName">The expected name of the Person.</param> /// <param name="expectedDateOfBirth">The expected date of birth of the person.</param> /// <param name="expectedETag">The expected ETag of the entity instance.</param> internal static void MatchEntityInstanceOfPerson(EntityInstance <Person> actualEntityInstance, string expectedId, string expectedName, string expectedDateOfBirth, string expectedETag) { Assert.AreEqual(expectedId, actualEntityInstance.Entity.Id); Assert.AreEqual(ValueUtilities.GetNullableString(expectedName), actualEntityInstance.Entity.Name); Assert.AreEqual(ValueUtilities.GetNullableDateTimeOffset(expectedDateOfBirth), actualEntityInstance.Entity.DateOfBirth); Assert.AreEqual(ValueUtilities.GetNullableString(expectedETag), actualEntityInstance.ETag); }
public override Object Evaluate(EntityInstance entityInstance, object[] objects) { string propertyList = ((string)objects[0]).Trim(); string keyName = ((string)objects[1]).Trim();; string delimiter = (string)objects[2]; string[] propertyArray; string keyFound; if (delimiter.Length == 0) { delimiter = ":"; } propertyArray = propertyList.Split(delimiter.ToCharArray()); foreach (string e in propertyArray) { keyFound = e.Split('=')[0].Trim(); if (keyFound.Equals(keyName, StringComparison.CurrentCultureIgnoreCase)) { return(e.Split('=')[1].Trim()); } } return(null); }
public override void Visit(EntityInstance payloadElement) { base.Visit(payloadElement); // Remove the actions and functions payloadElement.ServiceOperationDescriptors.Clear(); }
/// <summary> /// Entries might come with MLE annotation but might not satisfy all the conditions for MLEs. /// This method removes the MLE annotation if it is not an MLE or adds it if absent /// </summary> /// <param name="payloadElement">payloadElement to fix MLE annotation for</param> private void FixMleAnnotation(EntityInstance payloadElement) { // validate that if IsMediaLinkEntry returns true then indeed it is a valid MLE if (payloadElement.IsMediaLinkEntry()) { var isMLEann = payloadElement.Annotations.OfType <IsMediaLinkEntryAnnotation>().Single(); // MLE should have both of these, if not make it not an MLE if (payloadElement.StreamSourceLink == null || payloadElement.StreamContentType == null) { if (isMLEann != null) { payloadElement.Annotations.Remove(isMLEann); } payloadElement.StreamSourceLink = null; ExceptionUtilities.Assert(!payloadElement.IsMediaLinkEntry(), "should not be a media link entry"); } else { payloadElement.StreamSourceLink = FixUris(payloadElement.StreamSourceLink); payloadElement.StreamEditLink = FixUris(payloadElement.StreamEditLink); if (isMLEann == null) { payloadElement = payloadElement.AsMediaLinkEntry(); } } } }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var properties = new List<PropertyInstance>(); var navprops = new List<PropertyInstance>(); foreach (var propertyInstance in payloadElement.Properties) { this.Recurse(propertyInstance); var isnavprop = propertyInstance as NavigationPropertyInstance; if (isnavprop != null) { navprops.Add(propertyInstance); } else { properties.Add(propertyInstance); } } payloadElement.Properties = navprops.Concat(properties); foreach (var serviceOperationDescriptor in payloadElement.ServiceOperationDescriptors) { this.Recurse(serviceOperationDescriptor); } }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public virtual void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); this.VisitEnumerable(payloadElement.Properties); this.VisitEnumerable(payloadElement.ServiceOperationDescriptors); }
/// <summary> /// Normalizes navigation property. /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { base.Visit(payloadElement); // Inject an empty $select projection for top-level entries (if no projection exists) this.InjectEmptyContextUriProjection(payloadElement); }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); payloadElement.WithContentType("application/xml"); base.Visit(payloadElement); }
public static bool IsDerivedOf(ComputationContext ctx, FunctionParameter derivedParam, FunctionParameter baseParam, EntityInstance baseTemplate) { // unlike the result type, for parameters we check strict matching, this is because // we could have overloaded function in base type, and then figuring out // which function in derived type inherits from which base function would take longer // when we allowed more relaxed matching (i.e. allowing to have supertypes as arguments when deriving) // note we use names comparison because we need to check for Self if (!baseParam.TypeName.IsExactlySame(derivedParam.TypeName, baseTemplate, jokerMatchesAll: true)) { return(false); } if (baseParam.IsVariadic != derivedParam.IsVariadic) { return(false); } if (baseParam.IsVariadic) { if (!baseParam.Variadic.IsWithinLimits(derivedParam.Variadic.MinLimit) || !baseParam.Variadic.IsWithinLimits(derivedParam.Variadic.Max1Limit)) { return(false); } } return(true); }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { var epmTrees = payloadElement.Annotations.OfType <XmlTreeAnnotation>().ToList(); if (epmTrees.Count > 0) { var entityType = payloadElement.Annotations .OfType <DataTypeAnnotation>() .Select(d => d.DataType) .OfType <EntityDataType>() .Select(d => d.Definition) .SingleOrDefault(); ExceptionUtilities.CheckObjectNotNull(entityType, "Could not get entity type from payload annotations"); } // do EPM first so that in-content values win base.Visit(payloadElement); if (epmTrees.Count > 0) { // When deep EPM is involved, we can generate named values for mapped properties of a complex // property that has null value. So, trim any child paths of null values. var nullValueList = this.valuesByName.Where(v => v.Value.Value == null).ToList(); foreach (var nullValue in nullValueList) { var nullChildPaths = this.orderedNames.Where(n => n.StartsWith(nullValue.Key + ".", StringComparison.OrdinalIgnoreCase)).ToList(); foreach (var nullChildPath in nullChildPaths) { this.RemoveValue(nullChildPath); } } } }
public static bool IsSame(ComputationContext ctx, FunctionParameter derivedParam, FunctionParameter baseParam, EntityInstance baseTemplate) { // unlike the result type, for parameters we check strict matching, this is because // we could have overloaded function in base type, and then figuring out // which function in derived type inherits from which base function would take longer // when we allowed more relaxed matching (i.e. allowing to have supertypes as arguments when deriving) IEntityInstance base_param_type = baseParam.Evaluation.Components.TranslateThrough(baseTemplate); if (!base_param_type.IsExactlySame(derivedParam.Evaluation.Components, jokerMatchesAll: true)) { return(false); } if (baseParam.IsVariadic != derivedParam.IsVariadic) { return(false); } if (baseParam.IsVariadic) { if (baseParam.Variadic.MinLimit != derivedParam.Variadic.MinLimit || baseParam.Variadic.Max1Limit != derivedParam.Variadic.Max1Limit) { return(false); } } return(true); }
/// <summary> /// Annotates the entry with app:edited values. /// </summary> /// <param name="entry">The entry to annotate.</param> /// <param name="editedDate">The value of the app:edited element.</param> /// <returns>The entry with the annotation applied.</returns> public static EntityInstance AppEdited(this EntityInstance entry, string editedDate) { ExceptionUtilities.CheckArgumentNotNull(entry, "entry"); entry.AddAnnotation(CreateAppElement(TestAtomConstants.AtomPublishingEditedElementName, editedDate)); return(entry); }
/// <summary> /// Annotates the entry with atom:published values. /// </summary> /// <param name="entry">The entry to annotate.</param> /// <param name="publishedDate">The value of the atom:published element.</param> /// <returns>The feed with the annotation applied.</returns> public static EntityInstance AtomPublished(this EntityInstance entry, string publishedDate) { ExceptionUtilities.CheckArgumentNotNull(entry, "entry"); entry.AddAnnotation(XmlTreeAnnotation.Atom(TestAtomConstants.AtomPublishedElementName, publishedDate)); return(entry); }
/// <summary> /// Builds an instance of QueryStructureValue from an entity instance. /// </summary> /// <param name="instance">The entity instance</param> /// <param name="type">The QueryEntityType of the entity</param> /// <param name="xmlBaseAnnotations">The xml base annotations from parent elements, if any</param> /// <returns>The converted structural value of entity instance.</returns> private QueryStructuralValue BuildFromEntityInstance(EntityInstance instance, QueryEntityType type, IEnumerable<XmlBaseAnnotation> xmlBaseAnnotations) { QueryStructuralValue entity; // Helpful for debugging purposes to understand when things fail, on which entity they fail on this.Logger.WriteLine(LogLevel.Trace, "Build From Entity Instance with Id: {0}", instance.Id); // handle MEST. var queryEntityType = type; if (type.EntityType.FullName != instance.FullTypeName) { queryEntityType = type.DerivedTypes.Cast<QueryEntityType>().SingleOrDefault(t => t.EntityType.FullName == instance.FullTypeName); ExceptionUtilities.CheckObjectNotNull(queryEntityType, "Cannot find query entity type for entity type {0}.", instance.FullTypeName); } if (!instance.Annotations.OfType<DataTypeAnnotation>().Any()) { instance.Annotations.Add(new DataTypeAnnotation() { DataType = DataTypes.EntityType.WithDefinition(queryEntityType.EntityType) }); } // remove navigation properties so that they can be added after var navigationProperties = instance.Properties.OfType<NavigationPropertyInstance>().ToList(); navigationProperties.ForEach(n => instance.Remove(n)); // convert to query value entity = (QueryStructuralValue)this.PayloadElementToQueryValueConverter.Convert(instance, queryEntityType); // add expanded navigation properties. this.AddNavigationProperties(entity, navigationProperties.Where(p => p.IsExpanded), xmlBaseAnnotations); // add stream properties this.AddStreamProperties(entity, instance, xmlBaseAnnotations); return entity; }
public HarvestInteraction(EntityInstance target, EntityData targetData, Func <bool> onHarvest, IInventory inventory, ushort harvestTickTime) : base(target, true) { _targetData = targetData; _onHarvest = onHarvest; _initiatorInventory = inventory; _ticksPerHarvest = _ticksUntilNextHarvest = harvestTickTime; }
public static Texture2D GetEntityImageAndRect(EntityInstance entityData, string assetPath, out Rect rect) { rect = Rect.zero; EntityInstanceTile tile = entityData.Tile; if (tile == null) { return(null); } LDtkRelativeGetterTilesetTexture textureGetter = new LDtkRelativeGetterTilesetTexture(); Texture2D tex = textureGetter.GetRelativeAsset(tile.TilesetDefinition, assetPath); if (tex == null) { return(null); } Rect src = tile.UnitySourceRect; Vector2Int pos = new Vector2Int((int)src.position.x, (int)src.position.y); Vector2Int correctPos = LDtkCoordConverter.ImageSliceCoord(pos, tex.height, (int)src.height); Rect actualRect = new Rect(src) { position = correctPos, }; rect = actualRect; return(tex); }
public PayloadReaderTestDescriptor ToTestDescriptor(PayloadReaderTestDescriptor.Settings settings, IEdmModel model, bool throwOnUndeclaredPropertyForNonOpenType) { var cityType = model.FindDeclaredType("TestModel.CityType").ToTypeReference(); var cities = model.EntityContainer.FindEntitySet("Cities"); EntityInstance entity = PayloadBuilder.Entity("TestModel.CityType").PrimitiveProperty("Id", 1) .ExpectedEntityType(cityType, cities) .JsonRepresentation( "{" + "\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#TestModel.DefaultContainer.Cities()/$entity\"," + "\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataTypeAnnotationName + "\":\"TestModel.CityType\"," + "\"Id\":1," + this.Json + "}"); foreach (PropertyInstance property in this.ExpectedEntity.Properties) { entity.Add(property.DeepCopy()); } ExpectedException expectedException = this.ExpectedException; if (throwOnUndeclaredPropertyForNonOpenType) { expectedException = ODataExpectedExceptions.ODataException("ValidationUtils_PropertyDoesNotExistOnType", "UndeclaredProperty", "TestModel.CityType"); } return new PayloadReaderTestDescriptor(settings) { DebugDescription = this.DebugDescription, PayloadElement = entity, PayloadEdmModel = model, ExpectedException = expectedException }; }
private IDataEntity SetupMapToOpDataEntity() { var mapToDataEntity = new OPADataEntityBuilder(new DateTime(2017, 8, 1)); EntityInstance entityInstance = TestEntityInstance(); return(mapToDataEntity.MapOpaToEntity(entityInstance, null)); }
/// <summary> /// Removes the MLE annotation from an EntityInstance /// <param name="payloadElement">The entity instance to be modified</param> /// </summary> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var annotation = payloadElement.Annotations.Where(a => a is IsMediaLinkEntryAnnotation).SingleOrDefault(); payloadElement.Annotations.Remove(annotation); base.Visit(payloadElement); }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var properties = new List <PropertyInstance>(); var navprops = new List <PropertyInstance>(); foreach (var propertyInstance in payloadElement.Properties) { this.Recurse(propertyInstance); var isnavprop = propertyInstance as NavigationPropertyInstance; if (isnavprop != null) { navprops.Add(propertyInstance); } else { properties.Add(propertyInstance); } } payloadElement.Properties = navprops.Concat(properties); foreach (var serviceOperationDescriptor in payloadElement.ServiceOperationDescriptors) { this.Recurse(serviceOperationDescriptor); } }
private IDataEntity GetOutputEntity() { IOPADataEntityBuilder createDataEntity = new OPADataEntityBuilder(new DateTime(2017, 8, 1)); EntityInstance entityInstance = TestEntityInstance(); return(createDataEntity.CreateOPADataEntity(entityInstance, null)); }
/// <summary> /// Pretty prints for an EntityInstance /// </summary> /// <param name="payloadElement">Entity Instance to print</param> public override void Visit(EntityInstance payloadElement) { var indentString = this.GenerateIndent(); string id = payloadElement.Id.Replace(this.AstoriaServiceDescriptor.ServiceUri.AbsoluteUri, string.Empty); this.builder.AppendLine(string.Format(CultureInfo.InvariantCulture, "{0}Id:{1}", indentString, id)); base.Visit(payloadElement); }
public PayloadReaderTestDescriptor ToTestDescriptor(PayloadReaderTestDescriptor.Settings settings, IEdmModel model, bool withMetadataAnnotation = false) { IEdmEntityContainer container = model.FindEntityContainer("DefaultContainer"); IEdmEntitySet citiesEntitySet = container.FindEntitySet("Cities"); IEdmType cityType = model.FindType("TestModel.CityType"); EntityInstance entity = PayloadBuilder.Entity("TestModel.CityType") .ExpectedEntityType(cityType, citiesEntitySet) .JsonRepresentation( "{" + (withMetadataAnnotation ? ("\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://http://odata.org/test/$metadata#DefaultContainer.Cities/$entity\",") : string.Empty) + "\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataTypeAnnotationName + "\":\"TestModel.CityType\"," + this.Json + ",\"Id\":1" + "}"); foreach (PropertyInstance property in this.ExpectedEntity.Properties) { entity.Add(property.DeepCopy()); } entity.Add(PayloadBuilder.PrimitiveProperty("Id", 1)); return(new NavigationLinkTestCaseDescriptor(settings) { DebugDescription = this.DebugDescription, PayloadElement = entity, PayloadEdmModel = model, ExpectedException = this.ExpectedException, ExpectedIsCollectionValues = this.ExpectedIsCollectionValues, }); }
/// <summary> /// Create an entity without any given data /// </summary> /// <param name="entitySO">The entity base SO</param> /// <returns></returns> public EntityEntry CreateEmptyEntity(EntityTypeSO entitySO) { int id = EntityIDCounter; EntityData data = new EntityData() { EntityName = entitySO.EntityDefaultName, EntitySO = entitySO, BehaviourDatas = new List <BehaviourData>() }; // Create new entity instance EntityInstance newInstance = Instantiate(data.EntitySO.EntityPrefab, EntityRoot); newInstance.gameObject.name = data.EntityName; // Register entry to the list EntityEntry entry = new EntityEntry() { Data = data, Instance = newInstance }; m_EntityEntries.Add(entry); m_EntityEntryLookUpTable.Add(id, entry); newInstance.OnInstantiate(id); EntityIDCounter++; return(entry); }
public override void Fire(InstantWeapon weapon, EquippedItem item, EntityInstance source, EntityInstance target) { var p = ProjectilePrototype.Instantiate <Projectile>(); var hp = source.Entity.Hardpoints[item.Position.x, item.Position.y]; var barrel = source.GetBarrel(hp); var angle = weapon.Spread / 2; p.SourceEntity = source.Entity; p.Velocity = Quaternion.Euler( Random.Range(-angle, angle), Random.Range(-angle, angle), Random.Range(-angle, angle)) * barrel.forward * weapon.Velocity; p.StartPosition = p.transform.position = barrel.position + p.Velocity * (Random.value * Time.deltaTime); if (InheritVelocity) { p.Velocity += new Vector3(source.Entity.Velocity.x, 0, source.Entity.Velocity.y); } p.Damage = weapon.Damage; p.Range = weapon.Range; p.Penetration = weapon.Penetration; p.Spread = weapon.DamageSpread; p.DamageType = weapon.WeaponData.DamageType; p.Zone = source.Entity.Zone; p.AirburstDistance = target != null?length(source.Entity.Position - target.Entity.Position) : (weapon.Range * .75f); p.Trail.Clear(); }
public async Task AddEntityAsync(EntityInstance entity) { string cmdString = "INSERT INTO [EntityInstances] ([ModifiedByUserId], [Name], [Normal], [Position], [UpdatedTimestamp], [Uv])\r\nVALUES (@p0, @p1, @p2, @p3, @p4, @p5);"; //string connString = "Data Source=vnpmosa65\\aie;Initial Catalog=WebPlantRVM;Integrated Security=True;"; string connString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=Web3D;Integrated Security=True;"; using (SqlConnection conn = new SqlConnection(connString)) { using (SqlCommand comm = new SqlCommand()) { comm.Connection = conn; comm.CommandText = cmdString; comm.Parameters.AddWithValue("@p0", entity.ModifiedByUserId); comm.Parameters.AddWithValue("@p1", entity.Name); comm.Parameters.AddWithValue("@p2", (entity.Normal != null) ? entity.Normal : ""); comm.Parameters.AddWithValue("@p3", (entity.Position != null) ? entity.Position : ""); comm.Parameters.AddWithValue("@p4", DateTime.Now); comm.Parameters.AddWithValue("@p5", (entity.Uv != null) ? entity.Uv : ""); try { conn.Open(); comm.ExecuteNonQuery(); } catch (SqlException e) { Console.WriteLine(e.ToString()); // do something with the exception // don't hide it } } } //await _context.EntityInstances.AddAsync(entity); // await _context.SaveChangesAsync(); }
/// <summary> /// Visits an entity instance and fixes its annotations, type name, and property ordering/typing /// </summary> /// <param name="payloadElement">The entity instance</param> public override void Visit(EntityInstance payloadElement) { base.Visit(payloadElement); if (payloadElement.FullTypeName == null && this.contextData.ResolveName != null) { payloadElement.FullTypeName = this.contextData.ResolveName(this.typeStack.Peek()); } this.SortAndNormalizeProperties(payloadElement); payloadElement.WithContentType(MimeTypes.ApplicationXml); if (payloadElement.IsMediaLinkEntry()) { payloadElement.Annotations.RemoveAll(a => a is ContentTypeAnnotation); } // need to fix-up any places we've mapped an empty string to an element, as these are indistinguishable from null var epmQueue = new Queue <XmlTreeAnnotation>(payloadElement.Annotations.OfType <XmlTreeAnnotation>()); while (epmQueue.Count > 0) { var tree = epmQueue.Dequeue(); if (!tree.IsAttribute && string.IsNullOrEmpty(tree.PropertyValue)) { tree.PropertyValue = null; } tree.Children.ForEach(c => epmQueue.Enqueue(c)); } }
/// <summary> /// Create a new entity from the given entity data /// </summary> /// <param name="data">The data used to create an entity</param> /// <returns></returns> public EntityEntry CreateEntity(EntityData fromData) { int id = EntityIDCounter; EntityData data = fromData.Clone(); // Create new entity instance EntityInstance newInstance = Instantiate(data.EntitySO.EntityPrefab, EntityRoot); // Attach behaviours and setup parameters for (int i = 0; i < data.BehaviourDatas.Count; i++) { var behaviourData = data.BehaviourDatas[i]; var behaviourInstance = behaviourData.BehaviourSO.AddBehaviourToEntity(newInstance); behaviourInstance.UpdateAllParameters(behaviourData.ParamDatas); } // Register entry to the list EntityEntry entry = new EntityEntry() { Data = data, Instance = newInstance }; m_EntityEntries.Add(entry); m_EntityEntryLookUpTable.Add(id, entry); newInstance.OnInstantiate(id); EntityIDCounter++; return(entry); }
public void JsonDeserializeEntityInstance() { TextAsset jsonProject = TestJsonLoader.LoadJson(TestJsonLoader.MOCK_ENTITY_INSTANCE); //try deserializing entity EntityInstance entity = JsonConvert.DeserializeObject <EntityInstance>(jsonProject.text); }
/// <summary> /// Generates the next link for an expanded feed. /// </summary> /// <param name="containingEntity">The containing entity.</param> /// <param name="navigation">The expanded navigation property.</param> /// <param name="lastEntityValue">The last entity value.</param> /// <returns> /// The expected next link /// </returns> public string GenerateExpandedNextLink(EntityInstance containingEntity, NavigationPropertyInstance navigation, QueryStructuralValue lastEntityValue) { ExceptionUtilities.CheckArgumentNotNull(containingEntity, "containingEntity"); ExceptionUtilities.CheckArgumentNotNull(navigation, "navigation"); ExceptionUtilities.CheckArgumentNotNull(lastEntityValue, "lastEntityValue"); var navigationUriString = ((ExpandedLink)navigation.Value).UriString; if (string.IsNullOrEmpty(navigationUriString)) { navigationUriString = UriHelpers.ConcatenateUriSegments(containingEntity.EditLink, navigation.Name); } var skipTokenValues = new List <object>(); foreach (var keyProperty in lastEntityValue.Type.Properties.Where(p => p.IsPrimaryKey)) { skipTokenValues.Add(lastEntityValue.GetScalarValue(keyProperty.Name).Value); } var skiptoken = this.BuildSkipTokenFromValues(skipTokenValues); var nextLinkUri = new ODataUri(new UnrecognizedSegment(navigationUriString)); nextLinkUri.SkipToken = skiptoken; return(this.UriToStringConverter.ConvertToString(nextLinkUri)); }
private void WriteMetadataProperty(EntityInstance payloadElement) { if (payloadElement.ETag == null && payloadElement.FullTypeName == null && payloadElement.Id == null) { return; } this.writer.WriteName("__metadata"); this.writer.StartObjectScope(); if (payloadElement.Id != null) { this.writer.WriteName("uri"); this.writer.WriteString(payloadElement.Id); } if (payloadElement.FullTypeName != null) { this.writer.WriteName("type"); this.writer.WriteString(payloadElement.FullTypeName); } if (payloadElement.ETag != null) { this.writer.WriteName("etag"); this.writer.WriteString(payloadElement.ETag); } this.WriteServiceOperationDescriptorAnnotations("actions", payloadElement.ServiceOperationDescriptors.Where(s => s.IsAction)); this.WriteServiceOperationDescriptorAnnotations("functions", payloadElement.ServiceOperationDescriptors.Where(s => s.IsFunction)); this.writer.EndScope(); }
/// <summary> /// Visits the entity instance. /// </summary> /// <param name="payloadElement">The payload element being visited.</param> public override void Visit(EntityInstance payloadElement) { base.Visit(payloadElement); foreach (var namedStreamProperty in payloadElement.Properties.OfType<NamedStreamInstance>().ToArray()) { payloadElement.Remove(namedStreamProperty); } }
/// <summary> /// Normalizes entity. /// </summary> /// <param name="payloadElement">The payload element to normalize.</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); // First recurse to children so that we get those normalized and then normalize the parent entity. base.Visit(payloadElement); this.DeduplicateProperties(payloadElement); }
/// <summary> /// Converts the ATOM metadata annotation of stream properties and assocation links /// into XmlTree annotations and removes the stream properties/association links from the payload. /// </summary> /// <param name="payloadElement">The entity instance to visit.</param> public override void Visit(EntityInstance payloadElement) { IEnumerable<PropertyInstance> properties = payloadElement.Properties; if (properties != null) { // First remove all the stream properties in request payloads if (this.readerTestConfiguration.IsRequest) { List<NamedStreamInstance> streamProperties = properties.OfType<NamedStreamInstance>().ToList(); foreach (var streamProperty in streamProperties) { // Edit link string editRelationValue = TestAtomConstants.ODataStreamPropertyEditMediaRelatedLinkRelationPrefix + streamProperty.Name; XmlTreeAnnotation annotation = GetStreamPropertyLinkXmlTreeAnnotation(streamProperty, editRelationValue); if (annotation != null) { payloadElement.AddAnnotation(annotation); } // Self link string sourceRelationValue = TestAtomConstants.ODataStreamPropertyMediaResourceRelatedLinkRelationPrefix + streamProperty.Name; annotation = GetStreamPropertyLinkXmlTreeAnnotation(streamProperty, sourceRelationValue); if (annotation != null) { payloadElement.AddAnnotation(annotation); } payloadElement.Remove(streamProperty); } } // Then also convert the association links of navigation properties and // remove all navigation properties that do not have a URI - for request if (this.readerTestConfiguration.IsRequest) { List<NavigationPropertyInstance> navigationProperties = properties.OfType<NavigationPropertyInstance>().ToList(); foreach (var navProperty in navigationProperties) { XmlTreeAnnotation annotation = GetAssociationLinkXmlTreeAnnotation(navProperty.AssociationLink); navProperty.AssociationLink = null; if (navProperty.Value == null) { payloadElement.Remove(navProperty); } if (annotation != null) { payloadElement.AddAnnotation(annotation); } } } } base.Visit(payloadElement); }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); if (payloadElement.Id == null) { payloadElement.Id = String.Empty; } base.Visit(payloadElement); }
/// <summary> /// Converts the complex instance into an entity instance based on the metadata /// </summary> /// <param name="payloadElement">The payload element to potentially replace</param> /// <returns>The original element or a copy to replace it with</returns> public override ODataPayloadElement Visit(ComplexInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); if (payloadElement.Annotations.OfType<EntitySetAnnotation>().Any()) { var entityInstance = new EntityInstance(payloadElement.FullTypeName, payloadElement.IsNull); entityInstance.Properties = this.VisitCollection(payloadElement.Properties); return payloadElement.ReplaceWith(entityInstance); } return base.Visit(payloadElement); }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var selflink = payloadElement.Annotations.OfType<SelfLinkAnnotation>().SingleOrDefault(); if (selflink != null) { if (payloadElement.EditLink == null) { payloadElement.EditLink = selflink.Value; } payloadElement.Annotations.Remove(selflink); } base.Visit(payloadElement); }
/// <summary> /// Visits the entity instance and removes any complex with no properties as this will not be written. /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); foreach (var property in payloadElement.Properties.ToList()) { ComplexProperty complex = property as ComplexProperty; if (complex != null && complex.Value.Properties.Count() == 0) { payloadElement.Remove(complex); } } base.Visit(payloadElement); }
/// <summary> /// Normalizes property order on an entry. /// </summary> /// <param name="payloadElement">The payload element to normalize.</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); // First recurse to children so that we get those normalized and then normalize the parent entity. base.Visit(payloadElement); // When we write properties into JSON we write them all in the original order except for association links. // Since association links are matched against nav. properties, most of the time that is not visible // but if there's an association link without its nav. link portion that one will be reported last. payloadElement.Properties = payloadElement.Properties.Where(p => !p.IsAssociationLinkOnly()) .Concat(payloadElement.Properties.Where(p => p.IsAssociationLinkOnly())) .ToList(); }
/// <summary> /// Visits the entity instance. /// </summary> /// <param name="payloadElement">The payload element being visited.</param> public override void Visit(EntityInstance payloadElement) { base.Visit(payloadElement); foreach (var navPropWithAssociationLink in payloadElement.Properties.OfType<NavigationPropertyInstance>().Where(p => p.AssociationLink != null).ToArray()) { if (navPropWithAssociationLink.Value == null) { payloadElement.Remove(navPropWithAssociationLink); } else { navPropWithAssociationLink.AssociationLink = null; } } }
/// <summary> /// Tracks a pending update to the given descriptor based on values read from a response payload /// </summary> /// <param name="data">The descriptor data to update</param> /// <param name="payload">The payload that was read</param> /// <param name="baseUri">The base uri of the context</param> public void TrackUpdateFromPayload(EntityDescriptorData data, EntityInstance payload, Uri baseUri) { ExceptionUtilities.CheckArgumentNotNull(data, "data"); var update = new PayloadUpdate() { Descriptor = data, Payload = payload, BaseUri = baseUri }; if (!this.IgnoreAllUpdates) { if (this.ApplyUpdatesImmediately) { Apply(update); } else { this.payloadUpdates.Add(update); } } }
/// <summary> /// Visits the entity instance. /// </summary> /// <param name="payloadElement">The payload element being visited.</param> public override void Visit(EntityInstance payloadElement) { base.Visit(payloadElement); if (format == ODataFormat.Atom) { if (!IsMLE(payloadElement)) { payloadElement.RemoveAnnotations(typeof(IsMediaLinkEntryAnnotation)); } payloadElement.RemoveAnnotations(typeof(SelfLinkAnnotation)); payloadElement.EditLink = null; payloadElement.StreamEditLink = null; payloadElement.StreamSourceLink = null; payloadElement.StreamETag = null; } }
/// <summary> /// Builds an entity instance of the given type out of the given anonymous object /// </summary> /// <param name="entityType">The metadata type information for the entity</param> /// <param name="anonymous">The data as an anonymous type</param> /// <returns>An entity instance with the given values</returns> public EntityInstance EntityInstance(EntityType entityType, object anonymous) { ExceptionUtilities.CheckArgumentNotNull(entityType, "entityType"); EntityInstance instance = new EntityInstance(entityType.FullName, anonymous == null); if (entityType.GetBaseTypesAndSelf().Any(t => t.HasStream())) { instance.AsMediaLinkEntry(); } // TODO: id? if (anonymous != null) { this.PopulatePropertiesFromObject(instance, entityType.AllProperties, anonymous); // TODO: populate navigation properties } return instance; }
/// <summary> /// Normalizes property order on an entry. /// </summary> /// <param name="payloadElement">The payload element to normalize.</param> public override void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); // First recurse to children so that we get those normalized and then normalize the parent entity. base.Visit(payloadElement); // When we write properties into ATOM we write them in this order: // - Navigation properties // - Named stream properties // - All other properties (simple properties) // Inside each group the original order is maintained. // Also note that the association link order is lost due to the way we report it through the API, so put those after all the properties // (only pure association links, otherwise we match them against the nav. links) payloadElement.Properties = payloadElement.Properties.Where(p => p.ElementType == ODataPayloadElementType.NavigationPropertyInstance && !p.IsAssociationLinkOnly()) .Concat(payloadElement.Properties.Where(p => p.ElementType == ODataPayloadElementType.NamedStreamInstance)) .Concat(payloadElement.Properties.Where(p => p.ElementType != ODataPayloadElementType.NavigationPropertyInstance && p.ElementType != ODataPayloadElementType.NamedStreamInstance)) .Concat(payloadElement.Properties.Where(p => p.IsAssociationLinkOnly())) .ToList(); }
/// <summary> /// Normalizes the given entity payload element /// </summary> /// <param name="entityPayload">The entity payload element</param> /// <param name="entityDescriptorData">The descriptor data for the entity</param> public void Normalize(EntityInstance entityPayload, EntityDescriptorData entityDescriptorData) { ExceptionUtilities.CheckArgumentNotNull(entityPayload, "entityPayload"); ExceptionUtilities.CheckArgumentNotNull(entityDescriptorData, "entityDescriptorData"); this.typeStack.Push(entityDescriptorData.EntityClrType); // do this before recursing because it could be over-written by the visit method entityPayload.FullTypeName = entityDescriptorData.ServerTypeName; entityPayload.Id = string.Empty; if (entityDescriptorData.Identity != null) { entityPayload.Id = entityDescriptorData.Identity.OriginalString; } entityPayload.Accept(this); }
private bool IsMLE(EntityInstance entity) { return entity.StreamSourceLink != null || HasDefaultStream(entity) || HasPropertiesOnEntryChildLevel(entity); }
private bool HasDefaultStream(EntityInstance entity) { if (entity.FullTypeName == null) { return false; } if (payloadEdmModel != null) { var edmEntityType = payloadEdmModel.GetEntityType(entity.FullTypeName); return edmEntityType != null && edmEntityType.HasStream; } return false; }
private bool HasPropertiesOnEntryChildLevel(EntityInstance entity) { var xmlPayloadAnnotation = entity.Annotations.OfType<XmlPayloadElementRepresentationAnnotation>().SingleOrDefault(); return xmlPayloadAnnotation != null && xmlPayloadAnnotation .XmlNodes .OfType<XElement>() .Single(e => e.Name == TestAtomConstants.AtomXNamespace + "entry") .Elements(TestAtomConstants.ODataMetadataXNamespace + "properties") .Any(); }
/// <summary> /// Visits a payload element whose root is a EntityInstance. /// </summary> /// <param name="payloadElement">The root node of payload element being visited.</param> public void Visit(EntityInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); this.isRootElement = false; if (payloadElement.IsNull) { this.writer.WriteNull(); } else { this.writer.StartObjectScope(); this.WriteMetadataProperty(payloadElement); foreach (var property in payloadElement.Properties) { this.Recurse(property); } this.writer.EndScope(); } }
/// <summary> /// Removes ATOM metadata annotations from an <see cref="EntityInstance"/>. /// </summary> /// <param name="payloadElement">The entity instance to visit.</param> public override void Visit(EntityInstance payloadElement) { payloadElement.RemoveAnnotations(typeof(NamedStreamAtomLinkMetadataAnnotation)); base.Visit(payloadElement); }
private void AddFoldedLinksToEntityInsertPayload(DataServiceContextData contextData, EntityDescriptorData entityDescriptorData, EntityInstance payload) { var entityType = this.ModelSchema.EntityTypes.Single(t => t.FullName == entityDescriptorData.EntityClrType.FullName); foreach (var linkDescriptor in contextData.LinkDescriptorsData.Where(l => l.SourceDescriptor == entityDescriptorData)) { if (linkDescriptor.TargetDescriptor.State == EntityStates.Added) { continue; } var navigationProperty = entityType.AllNavigationProperties.Single(n => n.Name == linkDescriptor.SourcePropertyName); string contentType = MimeTypes.ApplicationAtomXml + ";type="; if (navigationProperty.ToAssociationEnd.Multiplicity == EndMultiplicity.Many) { contentType += "feed"; } else { contentType += "entry"; } // note: the edit-link is used rather than identity because the server needs to be able to query for the target entity // and the identity may not be an actual uri var link = new DeferredLink() { UriString = linkDescriptor.TargetDescriptor.EditLink.OriginalString } .WithContentType(contentType).WithTitleAttribute(linkDescriptor.SourcePropertyName); payload.Add(new NavigationPropertyInstance(linkDescriptor.SourcePropertyName, link)); } }
/// <summary> /// Construct expected relationship link value. /// </summary> /// <param name="entity">entity that the link belongs to</param> /// <param name="navigation">navigation property instance for the relationship link</param> /// <returns>expected relationship link value</returns> private string BuildExpectedAssociationUri(EntityInstance entity, NavigationPropertyInstance navigation) { return UriHelpers.ConcatenateUriSegments(entity.GetEditLink(), Endpoints.Ref, Uri.EscapeDataString(navigation.Name)); }
/// <summary> /// Visits an entity instance and fixes its annotations, type name, and property ordering/typing /// </summary> /// <param name="payloadElement">The entity instance</param> public override void Visit(EntityInstance payloadElement) { base.Visit(payloadElement); if (payloadElement.FullTypeName == null && this.contextData.ResolveName != null) { payloadElement.FullTypeName = this.contextData.ResolveName(this.typeStack.Peek()); } this.SortAndNormalizeProperties(payloadElement); payloadElement.WithContentType(MimeTypes.ApplicationXml); if (payloadElement.IsMediaLinkEntry()) { payloadElement.Annotations.RemoveAll(a => a is ContentTypeAnnotation); } // need to fix-up any places we've mapped an empty string to an element, as these are indistinguishable from null var epmQueue = new Queue<XmlTreeAnnotation>(payloadElement.Annotations.OfType<XmlTreeAnnotation>()); while (epmQueue.Count > 0) { var tree = epmQueue.Dequeue(); if (!tree.IsAttribute && string.IsNullOrEmpty(tree.PropertyValue)) { tree.PropertyValue = null; } tree.Children.ForEach(c => epmQueue.Enqueue(c)); } }