public static JsonEntityQueryResult GetJsonEntityQueryResult(ICollection <EntityRef> entityRefs, ICollection <string> requests)
{
#pragma warning disable 618
var svc = new EntityInfoService( );
#pragma warning restore 618
var entityDataList = new List <EntityData>( );
for (int i = 0; i < entityRefs.Count; ++i)
{
EntityRef entityRef = entityRefs.ElementAt(i);
string request = i < requests.Count ? requests.ElementAt(i) : requests.Last( );
var rqObj = Factory.RequestParser.ParseRequestQuery(request);
EntityData entityData = svc.GetEntityData(entityRef, rqObj);
entityDataList.Add(entityData);
}
if (entityDataList.Count(p => p != null) == 0)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var result = new JsonEntityQueryResult(entityDataList);
return(result);
}
/// <summary>
/// Decodes the entity.
/// </summary>
/// <param name="entityNugget">The entity nugget.</param>
/// <param name="persistChanges">If true, the nugget is intended to be persisted.</param>
/// <returns></returns>
public static IEntity DecodeEntity(EntityNugget entityNugget, bool persistChanges = false)
{
if (entityNugget == null)
{
return(null);
}
if (entityNugget.DataV1 == null)
{
return(null);
}
// Recover EntityData
JsonEntityQueryResult jeqr = entityNugget.DataV1;
jeqr.ResolveIds( );
long id = jeqr.Ids.FirstOrDefault( );
EntityData entityData = jeqr.GetEntityData(id);
// Bulk-check security (to fill security cache)
var entitiesToCheck = jeqr.Entities.Where(je => je.Id > 0).Select(je => new EntityRef(je.Id)).ToList( );
Factory.EntityAccessControlService.Check(entitiesToCheck, new[] { Permissions.Read });
// Load as a modified entity structure
#pragma warning disable 618
var svc = new EntityInfoService( );
#pragma warning restore 618
IEntity entity = svc.DecodeEntity(entityData, persistChanges);
return(entity);
}
public EntityPackageContext()
{
EntitiesVisited = new HashSet <long>();
Svc = new EntityInfoService();
;
Result = new JsonQueryResult();
}
public void TestTempDeletedChildItemIgnored( )
{
var svc = new EntityInfoService( );
EntityRef orgRef = null;
try
{
var o = new Report
{
Name = "org rpt",
Alias = "shared:a" + Guid.NewGuid( )
};
var b = new ReportColumn
{
Name = "bob",
Alias = "shared:a" + Guid.NewGuid( ),
ColumnForReport = o
};
EntityData result = svc.GetEntityData(b, EntityRequestHelper.BuildRequest("name, columnForReport.name"));
result.Relationships[0].Instances[0].DataState = DataState.Delete;
orgRef = svc.CreateEntity(result);
}
finally
{
if (orgRef != null)
{
Entity.Delete(orgRef);
}
}
}
/// <summary>
/// Creates a new image
/// </summary>
/// <param name="imageFileUploadId">The image file upload identifier.</param>
/// <param name="imageEntityData">The image entity data.</param>
/// <returns>The requested data.</returns>
/// <exception cref="System.ArgumentNullException">@imageEntityData</exception>
/// <exception cref="System.ArgumentException">@imageEntityData</exception>
public EntityRef CreateImageFromExistingFile(long imageFileUploadId, EntityData imageEntityData)
{
if (imageEntityData == null)
{
throw new ArgumentNullException(@"imageEntityData");
}
// Create a new image entity
#pragma warning disable 618
var entityInfoService = new EntityInfoService( );
#pragma warning restore 618
var imageFile = entityInfoService.CreateEntity(imageEntityData).Entity.AsWritable <ImageFileType>( );
int width;
int height;
using (Stream stream = GetImageDataStream(imageFileUploadId))
{
using (Image image = Image.FromStream(stream))
{
width = image.Width;
height = image.Height;
}
}
var existingImage = Entity.Get <ImageFileType>(imageFileUploadId);
imageFile.FileDataHash = existingImage.FileDataHash;
imageFile.FileExtension = existingImage.FileExtension;
imageFile.ImageWidth = width;
imageFile.ImageHeight = height;
imageFile.Save( );
return(imageFile);
}
public void CreateInstance( )
{
// 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")
});
// 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");
EntityData result = svc.GetEntityData(id, request);
// Verify results
Assert.AreEqual("Isaac Newton", result.Fields[0].Value.Value);
svc.DeleteEntity(id);
}
public void TestChangeType( )
{
// Note: refer to additional tests directly on Entity.ChangeType.
var svc = new EntityInfoService( );
IEntity e = null;
try
{
e = Entity.Create(new EntityRef("test:person"));
var ed = new EntityData
{
Id = e.Id
};
ed.TypeIds.Add(new EntityRef("test:manager"));
svc.UpdateEntityType(ed);
}
catch
{
if (e != null)
{
e.Delete( );
}
}
}
#pragma warning restore 618
/// <summary>
/// Initializes a new instance of the <see cref="EntityPackage" /> class.
/// </summary>
public EntityPackage( )
{
_entitiesVisited = new HashSet <long>( );
#pragma warning disable 618
_svc = new EntityInfoService( );
#pragma warning restore 618
_result = new JsonQueryResult( );
}
public void Test_GetFieldsRelationshipsControlsStructuredQueryString( )
{
EntityMemberRequest request = EntityRequestHelper.BuildRequest("k:context.name");
var svc = new EntityInfoService( );
EntityData result = svc.GetEntityData(new EntityRef("console", "singleLineTextControl"), request);
Assert.IsNotNull(FindEntity(result, new EntityRef("console", "uiContextHtml").Id));
}
public void TestCloneAndUpdateUpdateFields()
{
var svc = new EntityInfoService();
string initialName = "Initial name" + Guid.NewGuid();
string initialDescription = "Initial description" + Guid.NewGuid();
string newName = "New name" + Guid.NewGuid();
string newDescription = "New description" + Guid.NewGuid();
IEntity e = Entity.Create(new EntityRef("test:person"));
e.SetField("core:name", initialName);
e.SetField("core:description", initialDescription);
e.Save();
Assert.AreEqual(initialName, e.GetField("core:name"));
Assert.AreEqual(initialDescription, e.GetField("core:description"));
var data = new EntityData
{
Id = e.Id,
Fields = new List <FieldData>()
{
new FieldData
{
FieldId = new EntityRef("name"),
Value = new TypedValue(newName)
},
new FieldData
{
FieldId = new EntityRef("description"),
Value = new TypedValue(newDescription)
}
},
DataState = DataState.Update
};
var cloneIdsMap = svc.CloneAndUpdateEntity(data);
long cloneId;
Assert.IsTrue(cloneIdsMap.TryGetValue(e.Id, out cloneId), "The initial entity is not found.");
// Check the fields were cloned
IEntity clonedEntity = Entity.Get(cloneId);
Assert.AreEqual(newName, clonedEntity.GetField("core:name"));
Assert.AreEqual(newDescription, clonedEntity.GetField("core:description"));
// Check initial entity is not touched
IEntity initialEntity = Entity.Get(e.Id);
Assert.AreEqual(initialName, initialEntity.GetField("core:name"));
Assert.AreEqual(initialDescription, initialEntity.GetField("core:description"));
}
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 TestCloneAndUpdateTemporaryEntity()
{
var svc = new EntityInfoService();
IEntity e = Entity.Create(new EntityRef("test:person"));
var ed = new EntityData
{
Id = e.Id
};
Assert.Throws <InvalidOperationException>(() => svc.CloneAndUpdateEntity(ed));
}
/// <summary>
/// Creates a form entity for a given type.
/// </summary>
/// <param name="alias">The alias given to the form.</param>
/// <param name="name">The name given to the form.</param>
/// <param name="description">The description given to the form.</param>
/// <param name="type">The type to create the form for.</param>
/// <param name="isDefault">Whether the form should be the default for the type.</param>
/// <returns>The created form entity.</returns>
public static CustomEditForm CreateForm(string alias, string name, string description, EntityType type, bool isDefault)
{
var generator = new DefaultLayoutGenerator(CurrentUiContext.Html, new EntityRef(type), false);
var formEntityData = generator.GetLayoutAsEntityData(FormQuery);
var form = new EntityInfoService().CreateEntity(formEntityData).Entity.AsWritable <CustomEditForm>();
form.Alias = alias;
form.Name = name;
form.Description = description;
if (isDefault)
{
form.IsDefaultForEntityType = type;
}
return(form);
}
public HttpResponseMessage <long> Delete([FromUri] IEnumerable <long> id)
{
if (id == null)
{
throw new WebArgumentException("No id was specified");
}
long[] ids = id as long[] ?? id.ToArray( );
var refs = ids.Distinct().Select(i => new EntityRef(i));
EventLog.Application.WriteInformation(string.Format("webapi- deleting {0} entities", ids.Length));
#pragma warning disable 618
var svc = new EntityInfoService();
#pragma warning restore 618
svc.DeleteEntities(refs);
EventLog.Application.WriteInformation(string.Format("webapi- deleting complete"));
return(new HttpResponseMessage <long>(HttpStatusCode.OK));
}
public void GetFieldInstanceDbType( )
{
/////
// Define a new entity
/////
var data = new EntityData
{
Fields = new List <FieldData>( ),
TypeIds = new EntityRef("test", "person").ToEnumerable( ).ToList( )
};
/////
// Create it
/////
var svc = new EntityInfoService( );
EntityRef id = svc.CreateEntity(data);
/////
// Verify it was created
/////
Assert.IsTrue(id.Id > 0, "Positive Id");
EntityMemberRequest fieldRequest = EntityRequestHelper.BuildRequest(@"
fields.isOfType.name,
fields.isOfType.alias,
fields.isOfType.dbType,
fields.isOfType.dbTypeFull,
fields.isOfType.readiNowType,
fields.isOfType.xsdType" );
EntityData result = svc.GetEntityData(data.TypeIds.First( ), fieldRequest);
/////
// Verify results
/////
Assert.AreEqual(1, result.Relationships.Count);
svc.DeleteEntity(id);
}
/// <summary>
/// Handles cloning data.
/// </summary>
/// <param name="entityData">The entity data.</param>
/// <returns>The id of the cloned entity</returns>
private IHttpActionResult HandleCloneAndUpdate(JsonEntityQueryResult entityData)
{
// resolve all entity ids above our 'known id hi watermark' that actually do exist
entityData.ResolveIds();
long id = entityData.Ids.FirstOrDefault();
long cloneId = -1;
if (id >= JsonEntityQueryResult.BaseNewId)
{
return(BadRequest("Cannot clone a temporary entity."));
}
EventLog.Application.WriteTrace("Cloning entity " + id);
EntityData newEntityData = entityData.GetEntityData(id);
DatabaseContext.RunWithRetry(() =>
{
using (DatabaseContext context = DatabaseContext.GetContext(true))
{
#pragma warning disable 618
var svc = new EntityInfoService();
#pragma warning restore 618
var clonedIds = svc.CloneAndUpdateEntity(newEntityData);
if (!clonedIds.TryGetValue(id, out cloneId))
{
cloneId = -1;
}
context.CommitTransaction();
}
});
return(Ok(cloneId));
}
public void TestLoopsDontBreakCreate( )
{
// Define a new entity
var data1 = new EntityData
{
Fields = new List <FieldData>( ),
TypeIds = new EntityRef("test", "person").ToEnumerable( ).ToList( )
};
data1.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;
data1.Relationships = new List <RelationshipData>
{
new RelationshipData
{
RelationshipTypeId = new EntityRef("test", "reportsTo"),
IsReverse = false,
Instances = new List <RelationshipInstanceData>
{
new RelationshipInstanceData
{
Entity = data2,
DataState = DataState.Create
}
},
}
};
data2.Relationships = new List <RelationshipData>
{
new RelationshipData
{
RelationshipTypeId = new EntityRef("test", "reportsTo"),
IsReverse = false,
Instances = new List <RelationshipInstanceData>
{
new RelationshipInstanceData
{
Entity = data1,
DataState = DataState.Create
}
},
}
};
// Create it
var svc = new EntityInfoService( );
EntityRef id = svc.CreateEntity(data1);
// Verify it was created
Assert.IsTrue(id.Id > 0, "Positive Id");
svc.DeleteEntity(id);
}
public void TestCloneAndUpdateCloneByEntityRelationships()
{
var svc = new EntityInfoService();
EntityType type1 = new EntityType();
type1.Save();
EntityType type2 = new EntityType();
type2.Save();
Relationship rel = new Relationship
{
FromType = type1,
ToType = type2,
CloneAction_Enum = CloneActionEnum_Enumeration.CloneEntities,
Cardinality_Enum = CardinalityEnum_Enumeration.ManyToMany
};
rel.Save();
string initialName = Guid.NewGuid().ToString();
IEntity entityRelated = Entity.Create(type2.Id);
entityRelated.SetField("core:name", initialName);
entityRelated.Save();
IEntity entity1 = Entity.Create(type1.Id);
entity1.SetRelationships(rel, new EntityRelationshipCollection <IEntity> {
entityRelated
}, Direction.Forward);
entity1.Save();
string newEntityName = Guid.NewGuid().ToString();
var data = new EntityData
{
Id = entity1.Id,
Relationships = new List <RelationshipData>
{
new RelationshipData
{
RelationshipTypeId = new EntityRef(rel),
Instances = new List <RelationshipInstanceData>
{
new RelationshipInstanceData
{
DataState = DataState.Unchanged,
Entity = new EntityData
{
DataState = DataState.Update,
Id = new EntityRef(entityRelated.Id),
Fields = new List <FieldData>()
{
new FieldData
{
FieldId = new EntityRef("name"),
Value = new TypedValue(newEntityName)
}
}
}
}
}
}
},
DataState = DataState.Update
};
var cloneIdsMap = svc.CloneAndUpdateEntity(data);
long cloneId1, cloneIdRelated;
Assert.IsTrue(cloneIdsMap.TryGetValue(entity1.Id, out cloneId1), "The initial entity is not found.");
Assert.IsTrue(cloneIdsMap.TryGetValue(entityRelated.Id, out cloneIdRelated), "The related entity is not found.");
// Check the relationships were cloned
IEntity clonedEntity = Entity.Get(cloneId1);
var clonedRelationships = clonedEntity.GetRelationships(rel, Direction.Forward);
Assert.AreEqual(1, clonedRelationships.Count);
Assert.IsTrue(clonedRelationships.Any(r => r.Id == cloneIdRelated));
Assert.IsTrue(clonedRelationships.Any(r => (string)r.GetField("core:name") == newEntityName));
// Check initial entity is not touched
IEntity initialEntity = Entity.Get(entity1.Id);
var initialRelationships = initialEntity.GetRelationships(rel, Direction.Forward);
Assert.AreEqual(1, initialRelationships.Count);
Assert.IsTrue(initialRelationships.Any(r => r.Id == entityRelated.Id));
Assert.IsTrue(initialRelationships.Any(r => (string)r.GetField("core:name") == initialName));
}
/// <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);
}
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>
/// Creates a new image
/// </summary>
/// <param name="imageFileUploadId">The image file upload id.</param>
/// <param name="imageEntityData">The image entity data.</param>
/// <param name="fileExtension">The file extension.</param>
/// <returns>
/// The requested data.
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
public EntityRef CreateImageFromUploadedFile(string imageFileUploadId, EntityData imageEntityData, string fileExtension)
{
if (string.IsNullOrEmpty(imageFileUploadId))
{
throw new ArgumentException(@"The imageFileUploadId is empty.", "imageFileUploadId");
}
if (imageEntityData == null)
{
throw new ArgumentNullException(@"imageEntityData");
}
if (string.IsNullOrEmpty(fileExtension))
{
throw new ArgumentNullException(@"fileExtension");
}
ImageFileType imageFile;
string filePath = string.Empty;
try
{
// Create a new image entity
#pragma warning disable 618
var entityInfoService = new EntityInfoService( );
#pragma warning restore 618
imageFile = entityInfoService.CreateEntity(imageEntityData).Entity.AsWritable <ImageFileType>( );
var fileManagerService = new FileManagerService( );
FileDetail fileDetails = fileManagerService.GetFileDetails(imageFileUploadId);
filePath = fileDetails.FullName;
int width;
int height;
using (Image image = Image.FromFile(fileDetails.FullName))
{
width = image.Width;
height = image.Height;
}
string token;
using (var source = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
token = FileRepositoryHelper.AddTemporaryFile(source);
}
imageFile.FileDataHash = token;
imageFile.FileExtension = FileHelper.GetFileExtension(filePath);
imageFile.ImageWidth = width;
imageFile.ImageHeight = height;
imageFile.Save( );
}
finally
{
// Delete the underlying temp file
if (!string.IsNullOrEmpty(filePath))
{
File.Delete(filePath);
}
}
return(imageFile);
}
public void GetFormActionsForForm()
{
var personType = Entity.Get <Definition>("core:person");
var personForm = Entity.Get <CustomEditForm>(personType.DefaultEditForm.Id, true);
// fetch action for the person type
var request = new ActionRequestExtended
{
EntityTypeId = personType.Id,
FormId = personType.DefaultEditForm.Id,
ActionDisplayContext = ActionContext.All
};
var actionSvc = new ActionService();
actionSvc.FlushCaches();
var result = actionSvc.GetFormActionsMenuState(request);
result.Should().NotBeNull();
result.Actions.Should().NotBeNull().And.NotBeEmpty();
result.Actions.Count.Should().Be(2);
result.Actions.Count(a => a.Name == "Assign Data to App").Should().Be(1);
result.Actions.Count(a => a.Name == "Person Name Update").Should().Be(1);
// create new action item and assign it to the form
// form action
var actionInfo = result.Actions.Find(a => a.Name == "Person Name Update");
var wf = Entity.Get <Workflow>(actionInfo.EntityId);
// create workflow action item
var wfActionMenuItem = new WorkflowActionMenuItem
{
Name = actionInfo.Name,
MenuIconUrl = actionInfo.Icon,
MenuOrder = actionInfo.Order,
IsActionButton = actionInfo.IsButton,
IsMenuSeparator = actionInfo.IsSeparator,
IsContextMenu = actionInfo.IsContextMenu,
IsActionItem = actionInfo.IsMenu,
IsSystem = actionInfo.IsSystem,
AppliesToSelection = true,
AppliesToMultiSelection = false,
HtmlActionMethod = actionInfo.HtmlActionMethod,
HtmlActionState = actionInfo.HtmlActionState,
ActionMenuItemToWorkflow = wf
};
var cb = new ConsoleBehavior
{
Name = $"DeleteMe_PersonForm_rcb {DateTime.Now}",
BehaviorActionMenu = new ActionMenu
{
Name = $"DeleteMe_PersonForm_rcb_menu {DateTime.Now}",
IncludeActionsAsButtons = new EntityCollection <ActionMenuItem>()
{
(ActionMenuItem)wfActionMenuItem
},
MenuItems = new EntityCollection <ActionMenuItem>()
{
(ActionMenuItem)wfActionMenuItem
}
}
};
personForm.ResourceConsoleBehavior = cb;
personForm.Save();
var formActionQuery = @"{ k:resourceConsoleBehavior }
.k:behaviorActionMenu.{
{ k:menuItems, k:suppressedActions, k:includeActionsAsButtons }.{
{ name,
description,
k:menuIconUrl,
htmlActionState,
htmlActionMethod,
k:isActionButton,
k:appliesToSelection,
k:isMenuSeparator,
k:menuOrder,
{ isOfType }.{ alias,name },
{ k:actionMenuItemToWorkflow }.{ name },
{ k:actionMenuItemToReportTemplate }.{ name }
}
},
{ k:includeTypesForNewButtons, k:suppressedTypesForNewMenu }.id
}";
// fetch form actions and check there is only one action button assigned to the form
var entitySvc = new EntityInfoService();
EntityMemberRequest req = EntityRequestHelper.BuildRequest(formActionQuery);
var result2 = entitySvc.GetEntityData(personForm.Id, req);
result2.Should().NotBeNull();
var rcb = result2.Relationships.Find(a => a.RelationshipTypeId.Alias == "resourceConsoleBehavior");
rcb.Should().NotBeNull();
var actionMenu = rcb.Entities.First().Relationships.Find(a => a.RelationshipTypeId.Alias == "behaviorActionMenu");
actionMenu.Should().NotBeNull();
var actionButtons = actionMenu.Entities.First().Relationships.Find(a => a.RelationshipTypeId.Alias == "includeActionsAsButtons");
actionButtons.Should().NotBeNull();
var nameValue = actionButtons.Entities.First().Fields.Find(f => f.FieldId.Alias == "name").Value.Value;
nameValue.Should().Be("Person Name Update");
// delete console behavior
Entity.Delete(cb.Id);
}
/// <summary>
/// Add a request for a set of entities and queries.
/// </summary>
/// <param name="batch">The batch.</param>
/// <param name="hintText">A hint about what this query is doing. Use for logging/diagnostics only.</param>
/// <exception cref="System.ArgumentException">
/// </exception>
/// <exception cref="System.Exception">Internal error: batch query mismatch.</exception>
public void AddEntityRequestBatch(JsonQueryBatchRequest batch, string hintText = null)
{
JsonQueryResult result = _result;
#pragma warning disable 618
EntityInfoService svc = _svc;
#pragma warning restore 618
var memberRequests = new EntityMemberRequest[batch.Queries.Length];
foreach (JsonQuerySingleRequest request in batch.Requests)
{
string requestHintText = request.Hint ?? hintText;
_entitiesVisited.Clear( );
var singleResult = new JsonSingleQueryResult
{
Hint = request.Hint, Ids = new List <long>( )
};
try
{
EntityMemberRequest memberRequest;
// Do not require access to the individual query components
using (PerformanceCounters.Measure(EntityInfoServicePerformanceCounters.CategoryName, EntityInfoServicePerformanceCounters.RequestCountersPrefix))
using (new SecurityBypassContext( ))
{
// Get/parse the request query. (Either parse, or load from previous cache as part of this request).
if (request.QueryIndex < 0 || request.QueryIndex >= batch.Queries.Length)
{
EventLog.Application.WriteError("Cannot locate query string.");
singleResult.Code = HttpStatusCode.BadRequest;
continue;
}
memberRequest = memberRequests[request.QueryIndex];
if (memberRequest == null)
{
string queryString = batch.Queries[request.QueryIndex];
//// Parse the request
try
{
memberRequest = Factory.RequestParser.ParseRequestQuery(queryString);
}
catch (Exception ex)
{
EventLog.Application.WriteError(ex.ToString( ));
singleResult.Code = HttpStatusCode.BadRequest;
continue;
}
memberRequests[request.QueryIndex] = memberRequest;
}
}
// Get the entityRefs
IEnumerable <EntityRef> ids = Enumerable.Empty <EntityRef>( );
if (request.Aliases != null && request.Aliases.Length > 0)
{
ids = ids.Union(request.Aliases.Select(ConvertId));
}
if (request.Ids != null && request.Ids.Length > 0)
{
ids = ids.Union(request.Ids.Select(ConvertId));
}
IList <EntityRef> entityRefs = ids.ToList( );
if (entityRefs.All(er => er == null))
{
singleResult.Code = HttpStatusCode.NotFound;
continue;
}
// Run the request
IEnumerable <EntityData> entitiesData;
try
{
if (BulkRequestHelper.IsValidForBulkRequest(memberRequest))
{
var entityRequest = new EntityRequest
{
QueryType = request.QueryType,
RequestString = memberRequest.RequestString,
Hint = requestHintText,
Entities = entityRefs,
Filter = request.Filter,
Isolated = request.Isolated
};
// Run the request
entitiesData = BulkRequestRunner.GetEntities(entityRequest);
singleResult.Cached = entityRequest.ResultFromCache;
}
else
{
EventLog.Application.WriteWarning(
"Request cannot be handled by BulkRequest. Hint: {0}\n{1}",
requestHintText, memberRequest.RequestString);
switch (request.QueryType)
{
case QueryType.Instances:
entitiesData = svc.GetEntitiesByType(entityRefs.Single( ), true, memberRequest);
break;
case QueryType.ExactInstances:
entitiesData = svc.GetEntitiesByType(entityRefs.Single( ), false, memberRequest);
break;
case QueryType.Basic:
case QueryType.BasicWithDemand:
entitiesData = svc.GetEntitiesData(entityRefs, memberRequest);
break;
default:
throw new ArgumentException(string.Format("Unknown query type {0}", request.QueryType));
}
}
}
catch (ArgumentException ex)
{
// sorry world!
if (ex.Message.Contains("does not represent a known entity"))
{
singleResult.Code = HttpStatusCode.BadRequest;
continue;
}
throw;
}
// Skip results where access is denied
foreach (EntityData entityData in entitiesData.Where(ed => ed != null))
{
AppendEntityToResult(result, entityData);
singleResult.Ids.Add(entityData.Id.Id);
}
// Set the result to NotFound for Basic and BasicWithDemand only
if (request.QueryType == QueryType.Basic || request.QueryType == QueryType.BasicWithDemand)
{
singleResult.Code = singleResult.Ids.Count > 0
? HttpStatusCode.OK
: HttpStatusCode.NotFound;
}
else
{
singleResult.Code = HttpStatusCode.OK;
}
}
catch (PlatformSecurityException ex)
{
EventLog.Application.WriteWarning(ex.ToString( ));
singleResult.Ids.Clear( );
singleResult.Code = HttpStatusCode.Forbidden;
}
catch (Exception ex)
{
EventLog.Application.WriteError(ex.ToString( ));
singleResult.Code = HttpStatusCode.InternalServerError;
}
finally
{
// Place in the finally block so we are certain that it gets run exactly once per iteration
result.Results.Add(singleResult);
}
}
if (result.Results.Count != batch.Requests.Length)
{
// We are indexing by ID, so we must always ensure that request position matches result position.
throw new Exception("Internal error: batch query mismatch.");
}
}
public void Test_NewDefinitionOnRelated_GetEntitiesUsingInstancesOfType()
{
EntityMemberRequest request = EntityRequestHelper.BuildRequest("instancesOfType.{alias,name,description}");
var svc = GetService();
// Check before create
var result = svc.GetEntityData(new EntityRef("core:definition"), request);
int count = result.Relationships[0].Instances.Count;
Assert.IsTrue(count > 1);
// Define a new form & definition
var defn = new EntityData
{
Fields = new List <FieldData>(),
TypeIds = new EntityRef("core", "definition").ToEnumerable().ToList(),
DataState = DataState.Create
};
defn.Fields.Add(new FieldData
{
FieldId = new EntityRef("name"),
Value = new TypedValue("TestDefnT " + Guid.NewGuid().ToString())
});
var form = new EntityData
{
Fields = new List <FieldData>(),
TypeIds = new EntityRef("console", "customEditForm").ToEnumerable().ToList(),
DataState = DataState.Create
};
form.Fields.Add(new FieldData
{
FieldId = new EntityRef("name"),
Value = new TypedValue("TestFormT " + Guid.NewGuid().ToString())
});
form.Relationships = new List <RelationshipData> {
new RelationshipData
{
RelationshipTypeId = new EntityRef("console", "typeToEditWithForm"),
RemoveExisting = true
}
};
form.Relationships[0].Instances = new List <RelationshipInstanceData> {
new RelationshipInstanceData
{
Entity = defn,
DataState = DataState.Create
}
};
var svcWrite = new EntityInfoService();
using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true))
{
EntityRef id = svcWrite.CreateEntity(form);
ctx.CommitTransaction();
}
// Check after create
var result2 = svc.GetEntityData(new EntityRef("core:definition"), request);
int count2 = result2.Relationships[0].Instances.Count;
Assert.AreEqual(count + 1, count2);
}
