public void EnsureMetadata_Invalidates_WhenCalculationChanged()
{
EntityType type = null;
Field field = null;
Field calcField = null;
try
{
// Create scenario
type = new EntityType();
type.Name = "CFType";
field = new StringField().As <Field>();
field.Name = "CFField";
field.Save();
calcField = new StringField().As <Field>();
calcField.Name = "CFCalcField";
calcField.FieldCalculation = "'A'+CFField";
calcField.IsCalculatedField = true;
calcField.Save();
type.Fields.Add(field);
type.Fields.Add(calcField);
type.Save();
// Get provider
ICalculatedFieldMetadataProvider provider = Factory.CalculatedFieldMetadataProvider;
// Run
CalculatedFieldMetadata res1 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
CalculatedFieldMetadata res2 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure same instance was returned (came from cache)
Assert.That(res2, Is.SameAs(res1));
// Delete the field
calcField.FieldCalculation = "'B'+CFField";
calcField.Save();
// Rerun
CalculatedFieldMetadata res3 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure different instance was returned (not from cache)
Assert.That(res3, Is.Not.SameAs(res1));
Assert.That(res3.Calculation, Is.EqualTo("'B'+CFField")); // because the script is now invalid
}
finally
{
if (field != null)
{
field.Delete();
}
if (calcField != null)
{
calcField.Delete();
}
if (type != null)
{
type.Delete();
}
}
}
public void IsCalculatedField_Saved()
{
StringField field = new StringField();
field.FieldCalculation = "'abc'+123";
field.Save();
bool result = Factory.CalculatedFieldMetadataProvider.IsCalculatedField(field.Id);
}
public void TestCreateEntityType( )
{
EntityType newType = null;
FieldGroup group = null;
StringField field1 = null;
try
{
newType = Entity.Create <EntityType>( );
newType.Name = "TestEntityType";
newType.Description = "Test new EntityType";
newType.Save( );
long typeId = newType.Id;
group = new FieldGroup
{
Name = "TestGroup1"
};
newType.FieldGroups.Add(group);
group.Save( );
field1 = new StringField
{
Name = "TestField1",
AllowMultiLines = true,
FieldInGroup = @group,
FieldIsOnType = newType
};
field1.Save( );
var savedEntityType = Entity.Get <EntityType>(new EntityRef(typeId), true);
Assert.IsTrue(savedEntityType.Name == "TestEntityType");
savedEntityType.Delete( );
}
finally
{
if (field1 != null)
{
field1.Delete( );
}
if (group != null)
{
group.Delete( );
}
if (newType != null)
{
newType.Delete( );
}
}
}
public void FieldNameChangeDoesNotBreakExistingPolicy()
{
var toDelete = new List <long>();
try
{
var newField = new StringField {
Name = "test field"
}.As <Field>();
newField.Save();
toDelete.Add(newField.Id);
var policy = new RecordChangeAuditPolicy()
{
Name = "TEST ResourceAuditEventHandlerTests LogCreate", TriggeredOnType = Person.Person_Type, TriggerEnabled = true
};
policy.UpdatedFieldsToTriggerOn.Add(newField);
policy.Save();
toDelete.Add(policy.Id);
newField = newField.AsWritable <Field>();
newField.Name = "Renamed field";
newField.Save();
var log = RunAndLog(() =>
{
var person = Entity.Create <Person>();
person.SetField(newField, "bob");
person.Save();
});
Assert.That(log.Count, Is.EqualTo(1));
var logEntry = log[0].As <RecordChangeLogEntry>();
Assert.That(logEntry.Description, Is.EqualTo("[Renamed field] set to 'bob'"));
}
finally
{
Entity.Delete(toDelete);
}
}
public void StringFieldMaxLengthNotOver10k()
{
var tooLargeStringLength = ReadiNow.Model.FieldTypes.StringFieldHelper.RealMaximumStringFieldLength + 1;
StringField field = new StringField();
field.Name = "f1";
field.IsRequired = true;
field.Pattern = Entity.Get <StringPattern>("emailPattern");
field.IsRequired = false;
field.MaxLength = tooLargeStringLength;
field.Save();
}
public void Test_Invalidated_FieldName(string name1, string sname1, string name2, string sname2, string search, bool expect1, bool expect2)
{
EntityType type = null;
try
{
type = new EntityType();
type.Name = Guid.NewGuid().ToString();
Field field = new StringField().As <Field>();
field.Name = name1;
field.FieldScriptName = sname1;
type.Fields.Add(field);
type.Save();
MemberInfo member = Resolver.GetMemberOfType(search, type.Id, MemberType.Any);
Assert.That(member != null, Is.EqualTo(expect1), "First check");
if (name2 != name1)
{
field.Name = name2;
}
if (sname2 != sname1)
{
field.FieldScriptName = sname2;
}
if (name2 == "Delete")
{
field.Delete();
}
else
{
field.Save();
}
member = Resolver.GetMemberOfType(search, type.Id, MemberType.Any);
Assert.That(member != null, Is.EqualTo(expect2), "Second check");
}
finally
{
if (type != null)
{
type.Delete();
}
}
}
public static EntityType CreateDefinition(string name)
{
var sourceDefn = new EntityType
{
Name = name
};
//add a string field to the definition
var strField = new StringField
{
Name = "String field"
};
strField.Save( );
//// cast to type to "Add" field & save definition
sourceDefn.Fields.Add(strField.As <Field>( ));
sourceDefn.Save( );
return(sourceDefn);
}
public void Setup( )
{
// Getting Forbidden? Or ConnectorConfigException?
// Maybe there's duplicate copies of these objects in the DB.
// Define key and user
using (new TenantAdministratorContext(TenantName))
{
// Define schema
type = new EntityType( );
type.Inherits.Add(UserResource.UserResource_Type);
type.Name = "Test type " + Guid.NewGuid( );
type.Save( );
type2 = new EntityType();
type2.Inherits.Add(UserResource.UserResource_Type);
type2.Name = "Test type2 " + Guid.NewGuid();
type2.Save();
stringField = new StringField( );
stringField.Name = "Field 1";
stringField.FieldIsOnType = type;
stringField.Save( );
lookup = new Relationship();
lookup.Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne;
lookup.FromType = type;
lookup.ToType = type2;
// Define API
mapping = new ApiResourceMapping( );
mapping.Name = "Test mapping " + Guid.NewGuid( );;
mapping.MappedType = type;
mapping.Save( );
lookupMapping = new ApiRelationshipMapping();
lookupMapping.Name = "lookup1";
lookupMapping.MappedRelationship = lookup;
lookupMapping.MemberForResourceMapping = mapping;
lookupMapping.Save();
fieldMapping = new ApiFieldMapping( );
fieldMapping.Name = "field1";
fieldMapping.MappedField = stringField.As <Field>( );
fieldMapping.MemberForResourceMapping = mapping;
fieldMapping.Save( );
endpoint = new ApiResourceEndpoint( );
endpoint.Name = "Test endpoint " + Guid.NewGuid( );
endpoint.ApiEndpointAddress = EndpointAddress;
endpoint.EndpointResourceMapping = mapping;
endpoint.ApiEndpointEnabled = true;
endpoint.EndpointCanCreate = true;
endpoint.EndpointCanDelete = true;
endpoint.EndpointCanUpdate = true;
endpoint.Save( );
api = new Api( );
api.Name = "Test API " + Guid.NewGuid( );;
api.ApiAddress = ApiAddress;
api.ApiEnabled = true;
api.ApiEndpoints.Add(endpoint.As <ApiEndpoint>( ));
api.Save( );
// Define access
userAccount = new UserAccount( );
userAccount.Name = "Test user " + Guid.NewGuid( );
userAccount.AccountStatus_Enum = UserAccountStatusEnum_Enumeration.Active;
userAccount.Password = "******";
userAccount.Save( );
key = new ApiKey( );
key.Name = ApiKey;
key.ApiKeyUserAccount = userAccount;
key.ApiKeyEnabled = true;
key.KeyForApis.Add(api);
key.Save( );
updateInstance = Entity.Create(type).AsWritable <Resource>( );
updateInstance.Name = updateInstanceName = "ResourceToUpdate" + Guid.NewGuid( );
updateInstance.Description = updateInstanceDesc = "ResourceToUpdate" + Guid.NewGuid( );
updateInstance.Save( );
updateInstanceGuid = updateInstance.UpgradeId;
IAccessRuleFactory accessControlHelper = new AccessRuleFactory( );
accessRule = accessControlHelper.AddAllowCreate(userAccount.As <Subject>( ), type.As <SecurableEntity>( ));
accessRule = accessControlHelper.AddAllowByQuery(userAccount.As <Subject>( ), type.As <SecurableEntity>( ), new[] { Permissions.Read, Permissions.Modify, Permissions.Delete }, TestQueries.Entities(type).ToReport( ));
}
cleanup = new List <IEntity> {
userAccount, key, api, type, mapping, endpoint, fieldMapping, stringField, accessRule, updateInstance
};
}
public void EnsureMetadata_Invalidates_WhenFieldRenamedToCorrectName()
{
EntityType type = null;
Field field = null;
Field calcField = null;
try
{
// Create scenario
type = new EntityType();
type.Name = "CFType";
field = new StringField().As <Field>();
field.Name = "CFFieldWrongName";
field.Save();
calcField = new StringField().As <Field>();
calcField.Name = "CFCalcField";
calcField.FieldCalculation = "'A'+CFFieldRightName";
calcField.IsCalculatedField = true;
calcField.Save();
type.Fields.Add(field);
type.Fields.Add(calcField);
type.Save();
// Get provider
ICalculatedFieldMetadataProvider provider = Factory.CalculatedFieldMetadataProvider;
// Run
CalculatedFieldMetadata res1 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
CalculatedFieldMetadata res2 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure same instance was returned (came from cache)
Assert.That(res1.Exception, Is.Not.Null, "res1 should have error"); // because the script is invalid
Assert.That(res2, Is.SameAs(res1), "res2 should be same as res1");
// Rename the field
field.Name = "CFFieldRightName";
field.Save();
// Rerun
CalculatedFieldMetadata res3 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure different instance was returned (not from cache)
Assert.That(res3, Is.Not.SameAs(res1), "res3 should be != res1");
Assert.That(res3.Exception, Is.Null, "res3 should not have error"); // because the script is now fixed
Assert.That(res3.Expression, Is.Not.Null, "res3 should have expression"); // because the script is now fixed
}
finally
{
if (field != null)
{
field.Delete();
}
if (calcField != null)
{
calcField.Delete();
}
if (type != null)
{
type.Delete();
}
}
}
private void CreateScenarioImpl(string testInstanceName, Func <EntityRef[]> permissionsCallback)
{
// Define key and user
using (new TenantAdministratorContext(TenantName))
{
// Define schema
type = new EntityType( );
type.Inherits.Add(UserResource.UserResource_Type);
type.Name = "Test type " + Guid.NewGuid( );
type.Save( );
type2 = new EntityType( );
type2.Inherits.Add(UserResource.UserResource_Type);
type2.Name = "Test type2 " + Guid.NewGuid( );
type2.Save( );
stringField = new StringField( );
stringField.Name = "Field 1";
stringField.FieldIsOnType = type;
stringField.MaxLength = 50;
stringField.Save( );
lookup = new Relationship( );
lookup.Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne;
lookup.FromType = type;
lookup.ToType = type2;
relationship = new Relationship( );
relationship.Cardinality_Enum = CardinalityEnum_Enumeration.ManyToMany;
relationship.FromType = type;
relationship.ToType = type2;
// Define API
mapping = new ApiResourceMapping( );
mapping.Name = "Test mapping " + Guid.NewGuid( );;
mapping.MappedType = type;
mapping.Save( );
fieldMapping = new ApiFieldMapping( );
fieldMapping.Name = "field1";
fieldMapping.MappedField = stringField.As <Field>( );
fieldMapping.MemberForResourceMapping = mapping;
fieldMapping.Save( );
lookupMapping = new ApiRelationshipMapping( );
lookupMapping.Name = "lookup1";
lookupMapping.MappedRelationship = lookup;
lookupMapping.MemberForResourceMapping = mapping;
lookupMapping.Save( );
relationshipMapping = new ApiRelationshipMapping( );
relationshipMapping.Name = "rel1";
relationshipMapping.MappedRelationship = relationship;
relationshipMapping.MemberForResourceMapping = mapping;
relationshipMapping.Save( );
endpoint = new ApiResourceEndpoint( );
endpoint.Name = "Test endpoint " + Guid.NewGuid( );;
endpoint.ApiEndpointAddress = EndpointAddress;
endpoint.EndpointResourceMapping = mapping;
endpoint.ApiEndpointEnabled = true;
endpoint.EndpointCanCreate = true;
endpoint.EndpointCanUpdate = true;
endpoint.EndpointCanDelete = true;
endpoint.Save( );
api = new Api( );
api.Name = "Test API " + Guid.NewGuid( );;
api.ApiAddress = ApiAddress;
api.ApiEnabled = true;
api.ApiEndpoints.Add(endpoint.As <ApiEndpoint>( ));
api.Save( );
// Define access
userAccount = new UserAccount( );
userAccount.Name = "Test user " + Guid.NewGuid( );
userAccount.AccountStatus_Enum = UserAccountStatusEnum_Enumeration.Active;
userAccount.Password = "******";
userAccount.Save( );
key = new ApiKey( );
key.Name = ApiKey;
key.ApiKeyUserAccount = userAccount;
key.ApiKeyEnabled = true;
key.KeyForApis.Add(api);
key.Save( );
if (testInstanceName != null)
{
scenarioInstance = Entity.Create(type);
scenarioInstance.SetField("core:name", testInstanceName);
scenarioInstance.Save( );
}
foreignName = "Foreign" + Guid.NewGuid( ).ToString( );
foreignInstance = Entity.Create(type2);
foreignInstance.SetField("core:name", foreignName);
foreignInstance.Save( );
// Grant create
var permissions = permissionsCallback( );
IAccessRuleFactory accessControlHelper = new AccessRuleFactory( );
if (permissions [0] == Permissions.Create)
{
accessControlHelper.AddAllowCreate(userAccount.As <Subject>( ), type.As <SecurableEntity>( ));
}
else if (permissions.Length > 0)
{
accessControlHelper.AddAllowByQuery(userAccount.As <Subject>( ), type.As <SecurableEntity>( ), permissions, TestQueries.Entities(type).ToReport( ));
}
accessControlHelper.AddAllowByQuery(userAccount.As <Subject>( ), type2.As <SecurableEntity>( ), new [] { Permissions.Read, Permissions.Modify }, TestQueries.Entities(type2).ToReport( ));
}
}
