public void UpdateField( ) { var rq = new EntityMemberRequest( ); rq.Fields.Add(new EntityRef("description")); var svc = new EntityInfoService( ); EntityData entity = svc.GetEntityData(new EntityRef("test", "person"), rq); entity.Fields[0].Value.Value = "Hello world"; svc.UpdateEntity(entity); }
public void UpdateRelationships(string cardinality, string options, string expect) { var type1 = Create <EntityType>(true); var type2 = Create <EntityType>(true); var rel = Create <Relationship>( ); rel.FromType = type1; rel.ToType = type2; rel.Cardinality = Entity.Get <CardinalityEnum>(new EntityRef("core:" + cardinality)); rel.Save( ); var inst1 = Entity.Create(type1.Id); var inst2a = Entity.Create(type2.Id); var inst2b = Entity.Create(type2.Id); var inst3 = Entity.Create(type2.Id); SetRel(inst1, inst2a, rel); if (options.Contains("rel3")) { SetRel(inst3, inst2b, rel); } EntityData data = new EntityData { Id = new EntityRef(inst1.Id), Relationships = new List <RelationshipData> { new RelationshipData { RemoveExisting = options.Contains("removeExisting"), DeleteExisting = options.Contains("deleteExisting"), AutoCardinality = options.Contains("autoCardinality"), RelationshipTypeId = new EntityRef(rel.Id), Instances = new List <RelationshipInstanceData> { new RelationshipInstanceData { DataState = DataState.Create, Entity = new EntityData { Id = new EntityRef(inst2b.Id) } } } } } }; // Call service var svc = new EntityInfoService( ); svc.UpdateEntity(data); Assert.That(Entity.Exists(inst1.Id), Is.EqualTo(expect.Contains("ent1")), "ent1"); Assert.That(Entity.Exists(inst2a.Id), Is.EqualTo(expect.Contains("ent2a")), "ent2a"); Assert.That(Entity.Exists(inst2b.Id), Is.EqualTo(expect.Contains("ent2b")), "ent2b"); var values = inst1.GetRelationships(rel).Select(r => r.Entity.Id).ToList( ); Assert.That(values.Contains(inst2a.Id), Is.EqualTo(expect.Contains("rel2a")), "rel2a"); Assert.That(values.Contains(inst2b.Id), Is.EqualTo(expect.Contains("rel2b")), "rel2b"); var values2 = inst3.GetRelationships(rel).Select(r => r.Entity.Id).ToList( ); Assert.That(values2.Contains(inst2b.Id), Is.EqualTo(expect.Contains("rel3")), "rel3"); }
public void UpdateFieldOnRelatedInstance( ) { // Define a new entity var data = new EntityData { Fields = new List <FieldData>( ), TypeIds = new EntityRef("test", "person").ToEnumerable().ToList() }; data.Fields.Add(new FieldData { FieldId = new EntityRef("name"), Value = new TypedValue("Isaac Newton") }); // Define a new related entity var data2 = new EntityData { Fields = new List <FieldData>( ), TypeIds = new EntityRef("test", "employee").ToEnumerable().ToList() }; data2.Fields.Add(new FieldData { FieldId = new EntityRef("name"), Value = new TypedValue("Isaac Newtons Emmployer") }); data2.DataState = DataState.Create; data.Relationships = new List <RelationshipData> { new RelationshipData { RelationshipTypeId = new EntityRef("test", "reportsTo"), IsReverse = false, Instances = new List <RelationshipInstanceData> { new RelationshipInstanceData { Entity = data2, DataState = DataState.Create } }, } }; // Create it var svc = new EntityInfoService( ); EntityRef id = svc.CreateEntity(data); // Verify it was created Assert.IsTrue(id.Id > 0, "Positive Id"); // Select the data EntityMemberRequest request = EntityRequestHelper.BuildRequest("name, test:reportsTo.name"); EntityData result = svc.GetEntityData(id, request); // Verify results Assert.AreEqual("Isaac Newton", result.Fields[0].Value.Value); EntityData employee = result.Relationships[0].Instances[0].Entity; FieldData employersNameField = employee.Fields[0]; Assert.AreEqual("Isaac Newtons Emmployer", employersNameField.Value.Value); // Update employees name employersNameField.Value.Value = "bob"; employee.DataState = DataState.Update; svc.UpdateEntity(result); // comfirm it changed EntityData resultAfterUpdate = svc.GetEntityData(id, request); employee = resultAfterUpdate.Relationships[0].Instances[0].Entity; employersNameField = employee.Fields[0]; Assert.AreEqual("bob", employersNameField.Value.Value); // delete the referenced Entity leaving the data state of the top entity unchanged employee.DataState = DataState.Delete; svc.UpdateEntity(resultAfterUpdate); // comfirm it deleted EntityData resultAfterDelete = svc.GetEntityData(id, request); Assert.AreEqual(0, resultAfterDelete.Relationships[0].Instances.Count, "There should be no manager"); // clean up svc.DeleteEntity(id); }
public void UpdateEntityRemoveExistingFromCascadeDeleted() { ///////////////////////////////////////////////////////////////////////////////////////// // Arrange ///////////////////////////////////////////////////////////////////////////////////////// var typeA = Create <EntityType>(true); var typeB = Create <EntityType>(true); var typeC = Create <EntityType>(true); var rel1 = Create <Relationship>(); rel1.FromType = typeA; rel1.ToType = typeB; rel1.Cardinality_Enum = CardinalityEnum_Enumeration.OneToMany; rel1.Save(); var rel2 = Create <Relationship>(); rel2.FromType = typeB; rel2.ToType = typeC; rel2.Cardinality_Enum = CardinalityEnum_Enumeration.OneToMany; rel2.CascadeDeleteTo = true; rel2.Save(); var aInstance = Entity.Create(typeA.Id); var bInstance = Entity.Create(typeB.Id); var cInstance = Entity.Create(typeC.Id); SetRel(aInstance, bInstance, rel1); SetRel(bInstance, cInstance, rel2); aInstance.IsTemporaryId.Should().BeFalse(); bInstance.IsTemporaryId.Should().BeFalse(); cInstance.IsTemporaryId.Should().BeFalse(); Entity.Exists(aInstance.Id).Should().BeTrue(); Entity.Exists(bInstance.Id).Should().BeTrue(); Entity.Exists(cInstance.Id).Should().BeTrue(); var children = bInstance.GetRelationships(rel2); children.Should().NotBeNull().And.NotBeEmpty(); children.Count.Should().Be(1); children.Select(c => c.Id).Should().Contain(cInstance.Id); var data = new EntityData { // top level node is the "update" Id = new EntityRef(aInstance.Id), DataState = DataState.Update, Relationships = new List <RelationshipData> { new RelationshipData { RelationshipTypeId = new EntityRef(rel1.Id), Instances = new List <RelationshipInstanceData> { new RelationshipInstanceData { Entity = new EntityData { // this is the node we are deleting and removing from Id = new EntityRef(bInstance.Id), DataState = DataState.Delete, Relationships = new List <RelationshipData> { new RelationshipData { RemoveExisting = true, RelationshipTypeId = new EntityRef(rel2.Id), Instances = new List <RelationshipInstanceData>() } } } } } } } }; ///////////////////////////////////////////////////////////////////////////////////////// // Act ///////////////////////////////////////////////////////////////////////////////////////// var svc = new EntityInfoService(); Action callUpdate = () => svc.UpdateEntity(data); callUpdate.ShouldNotThrow(); ///////////////////////////////////////////////////////////////////////////////////////// // Assert ///////////////////////////////////////////////////////////////////////////////////////// Entity.Exists(aInstance.Id).Should().BeTrue(); Entity.Exists(bInstance.Id).Should().BeFalse(); // should not have been cascade deleted if it was removed from the relationship Entity.Exists(cInstance.Id).Should().BeTrue(); }
public void UpdateEntityDeleteItemFromSecuresToRelationship() { // this case requires that the entity to be delete ONLY receives its access for read/delete through // the relationship with the entity being updated. // (I.e. activityPrompts removed from promptForArguments relationship with promptUserActivity) ///////////////////////////////////////////////////////////////////////////////////////// // Arrange ///////////////////////////////////////////////////////////////////////////////////////// var parentType = Create <EntityType>(); parentType.Inherits.Add(UserResource.UserResource_Type); parentType.Save(); var childType = Create <EntityType>(); childType.Inherits.Add(UserResource.UserResource_Type); childType.Save(); var rel = Create <Relationship>(); rel.FromType = parentType; rel.ToType = childType; rel.Cardinality_Enum = CardinalityEnum_Enumeration.OneToMany; rel.SecuresTo = true; rel.Save(); var parentInstance = Entity.Create(parentType.Id); var childInstance = Entity.Create(childType.Id); SetRel(parentInstance, childInstance, rel); parentInstance.IsTemporaryId.Should().BeFalse(); childInstance.IsTemporaryId.Should().BeFalse(); Entity.Exists(parentInstance.Id).Should().BeTrue(); Entity.Exists(childInstance.Id).Should().BeTrue(); var user = Create <UserAccount>(true); user.Name = "UpdateEntityDeleteItemFromSecuresToRelationship"; user.Save(); using (new SetUser(user)) { Action getParentNoPermission = () => Entity.Get(parentInstance.Id); getParentNoPermission.ShouldThrow <PlatformSecurityException>().WithMessage("*does not have view access to*"); Action getChildNoPermission = () => Entity.Get(childInstance.Id); getChildNoPermission.ShouldThrow <PlatformSecurityException>().WithMessage("*does not have view access to*"); } // grant access via parent var query = TestQueries.Entities(parentType); var queryResult = Factory.QueryRunner.ExecuteQuery(query, new QuerySettings { SecureQuery = true }); queryResult.Should().NotBeNull(); queryResult.DataTable.Rows.Count.Should().Be(1); queryResult.DataTable.Rows[0].ItemArray.Should().Contain(parentInstance.Id); new AccessRuleFactory().AddAllowByQuery(user.As <Subject>(), parentType.As <SecurableEntity>(), new[] { Permissions.Read, Permissions.Modify, Permissions.Delete }, query.ToReport()); Factory.EntityAccessControlService.ClearCaches(); using (new SetUser(user)) { IEntity p = null; Action getParentPermission = () => p = Entity.Get(parentInstance.Id); getParentPermission.ShouldNotThrow(); p.Should().NotBeNull(); p.Id.ShouldBeEquivalentTo(parentInstance.Id); IEntity c = null; Action getChildPermission = () => c = Entity.Get(childInstance.Id); getChildPermission.ShouldNotThrow(); c.Should().NotBeNull(); c.Id.ShouldBeEquivalentTo(childInstance.Id); } var data = new EntityData { Id = new EntityRef(parentInstance.Id), Relationships = new List <RelationshipData> { new RelationshipData { RelationshipTypeId = new EntityRef(rel.Id), Instances = new List <RelationshipInstanceData> { new RelationshipInstanceData { Entity = new EntityData { Id = new EntityRef(childInstance.Id), DataState = DataState.Delete } } } } } }; ///////////////////////////////////////////////////////////////////////////////////////// // Act ///////////////////////////////////////////////////////////////////////////////////////// using (new SetUser(user)) { var svc = new EntityInfoService(); Action callUpdate = () => svc.UpdateEntity(data); callUpdate.ShouldNotThrow(); } ///////////////////////////////////////////////////////////////////////////////////////// // Assert ///////////////////////////////////////////////////////////////////////////////////////// Entity.Exists(parentInstance.Id).Should().BeTrue(); Entity.Exists(childInstance.Id).Should().BeFalse(); }
/// <summary> /// Handles post data. /// </summary> /// <param name="entityData">The entity data.</param> /// <param name="returnMap">if set to <c>true</c> [return map].</param> /// <returns></returns> private HttpResponseMessage HandlePost(JsonEntityQueryResult entityData, bool returnMap) { Stopwatch sw = Stopwatch.StartNew( ); long t1; // resolve all entity ids above our 'known id hi watermark' that actually do exist entityData.ResolveIds( ); long id = entityData.Ids.FirstOrDefault( ); IDictionary <long, IEntity> map = null; if (id >= JsonEntityQueryResult.BaseNewId) { // create EventLog.Application.WriteTrace("Creating entity " + id); EntityData newEntityData = entityData.GetEntityData(id); t1 = sw.ElapsedMilliseconds; DatabaseContext.RunWithRetry(() => { using (DatabaseContext context = DatabaseContext.GetContext(true)) { #pragma warning disable 618 var svc = new EntityInfoService(); #pragma warning restore 618 map = svc.CreateEntityGetMap(newEntityData); IEntity entity = map[newEntityData.Id.Id]; id = entity == null ? -1 : entity.Id; context.CommitTransaction(); } }); EventLog.Application.WriteTrace("EntityPost create took {0} msec ({1} to de-json)", sw.ElapsedMilliseconds, t1); } else { map = new Dictionary <long, IEntity>( ); EventLog.Application.WriteTrace("Updating entity " + id); EntityData newEntityData = entityData.GetEntityData(id); t1 = sw.ElapsedMilliseconds; DatabaseContext.RunWithRetry(() => { using (DatabaseContext context = DatabaseContext.GetContext(true)) { #pragma warning disable 618 var svc = new EntityInfoService(); #pragma warning restore 618 svc.UpdateEntity(newEntityData); context.CommitTransaction(); } }); EventLog.Application.WriteTrace("EntityPost update took {0} msec ({1} to de-json)", sw.ElapsedMilliseconds, t1); } HttpResponseMessage httpResponseMessage; if (returnMap) { ///// // Create a custom response message so the infrastructure framework doesn't serialize it twice. ///// httpResponseMessage = new HttpResponseMessage { Content = new StringContent(DictionaryToJson(map)) }; httpResponseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } else { httpResponseMessage = new HttpResponseMessage <long>(id); } return(httpResponseMessage); }