public void TestErrorExpression <T>(string value, object memory = null)
{
var ep = new ExpressionProperty <T>(value);
var(result, error) = ep.TryGetValue(memory ?? new object());
Assert.NotNull(error);
}
private void RefreshForm()
{
if (!entityReference.IsEmpty)
{
entityReference.Context = RegistryContext;
Entity entity = entityReference.Value;
Image.ImageUrl = String.Format("~/Icons/Small/{0}.gif", entity.EntityType);
Image.Visible = true;
if (expression == null)
{
HyperLink.Text = entity.Name;
}
else
{
HyperLink.Text = ExpressionProperty.ResolveExpression(EntityReference.Value, expression);
}
HyperLink.NavigateUrl = entity.GetDetailsUrl();
}
else
{
Image.Visible = false;
HyperLink.Text = Resources.Labels.NotApplicable;
HyperLink.NavigateUrl = string.Empty;
}
}
/// <summary>
/// Generates create table commands for the supplied type
/// </summary>
internal static void CreateManyToManyTable(Type type, ExpressionProperty pi, StringBuilder manyToManyTables, StringBuilder foreignKeys)
{
var nameOwner = type.Name;
var nameChild = pi.PropertyType.GetGenericArguments()[0].Name;
var tableName = ManyToManyAttribute.GetTableName(type, pi.ContainedProperty);
if (manyToManyTables.ToString().Contains("CREATE TABLE [" + tableName + "] ( "))
{
return;
}
manyToManyTables.AppendLine("CREATE TABLE [" + tableName + "] ( ");
manyToManyTables.AppendLine("[" + nameOwner + "Id] [uniqueidentifier] NOT NULL, ");
manyToManyTables.AppendLine("[" + nameChild + "Id] [uniqueidentifier] NOT NULL, ");
manyToManyTables.AppendLine("CONSTRAINT [PK_" + tableName + "] PRIMARY KEY (" + nameOwner + "Id, " + nameChild + "Id)");
manyToManyTables.AppendLine(")");
manyToManyTables.AppendLine();
var ownerConstraintName = "FK_" + tableName + "_" + nameOwner;
var childConstraintName = "FK_" + tableName + "_" + nameChild;
foreignKeys.AppendLine("ALTER TABLE [" + tableName + "] ADD CONSTRAINT [" + ownerConstraintName + "Id] FOREIGN KEY (" + nameOwner + "Id) REFERENCES [" + nameOwner + "] (Id) ON DELETE CASCADE ");
foreignKeys.AppendLine("ALTER TABLE [" + tableName + "] ADD CONSTRAINT [" + childConstraintName + "Id] FOREIGN KEY (" + nameChild + "Id) REFERENCES [" + nameChild + "] (Id) ON DELETE CASCADE ");
}
/// <summary>
/// Default Constructor
/// </summary>
public DwarfList()
{
if (typeof(T).Implements <IDwarf>())
{
sortProperty = DwarfHelper.GetOrderByProperty <T>();
sortAsc = DwarfHelper.GetOrderByDirection <T>().IsNullOrEmpty();
}
}
public override void WriteJson(JsonWriter writer, ExpressionProperty <T> value, JsonSerializer serializer)
{
if (value.ExpressionText != null)
{
serializer.Serialize(writer, value.ToString());
}
else
{
serializer.Serialize(writer, value.Value);
}
}
public void TestValueAccess()
{
var foo = new Foo()
{
Name = "Test",
Age = 22
};
var ep = new ExpressionProperty <Foo>(foo);
var result = ep.GetValue(new object());
Assert.AreEqual("Test", result.Name);
Assert.AreEqual(22, result.Age);
}
public void TestJObjectAccess()
{
var foo = new Foo()
{
Name = "Test",
Age = 22
};
var ep = new ExpressionProperty <Foo>(JObject.FromObject(foo));
var(result, error) = ep.TryGetValue(new object());
Assert.Equal("Test", result.Name);
Assert.Equal(22, result.Age);
}
public void TestValidate(Type type, string propertyName, string input, bool expectedValid)
{
// Arrange
Assert.IsNotNull(type);
var pi = type.GetProperty(propertyName);
var p = new ExpressionProperty($"{type.Name}.{propertyName}", propertyName, pi);
// Act
var result = p.Validate(input);
// Assert
Assert.AreEqual(expectedValid, result);
}
public void TestExpressionPropertyWithValue <T>(string value, T expected, object memory = null)
{
var ep = new ExpressionProperty <T>(value);
var(result, error) = ep.TryGetValue(memory ?? new object());
if (result is ICollection)
{
Assert.Equal((ICollection)expected, (ICollection)result);
}
else
{
Assert.Equal(expected, result);
}
Assert.Null(error);
}
public void TestExpressionAccess()
{
var state = new
{
test = new Foo()
{
Name = "Test",
Age = 22
}
};
var ep = new ExpressionProperty <Foo>("test");
var(result, error) = ep.TryGetValue(state);
Assert.Equal("Test", result.Name);
Assert.Equal(22, result.Age);
}
protected void UpdateResolvedNames()
{
if (!Item.IsExisting)
{
Item.SliceReference.Guid = new Guid(Slice.SelectedValue);
Item.DatabaseVersionReference.Guid = new Guid(DatabaseVersion.SelectedValue);
Item.ServerInstanceReference.Guid = new Guid(ServerInstance.SelectedValue);
try
{
Item.Name = ExpressionProperty.ResolveExpression(Item, Item.DatabaseDefinition.DatabaseInstanceNamePattern);
Item.DatabaseName = ExpressionProperty.ResolveExpression(Item, Item.DatabaseDefinition.DatabaseNamePattern);
}
catch (ArgumentNullException)
{
Item.Name = String.Empty;
Item.DatabaseName = String.Empty;
}
}
}
private Expression GetPropertyExpression <T>(ExpressionProperty expressionProperty)
{
var typeParam = Expression.Parameter(typeof(T));
var leftExpression = GetPropertyValueExpression(expressionProperty.LeftPropertyValue, typeParam);
var righExpression = GetPropertyValueExpression(expressionProperty.RightPropertyValue, typeParam);
Expression currentExpression;
switch (expressionProperty.Comparer)
{
case Comparer.Less:
currentExpression = Expression.LessThan(leftExpression, righExpression);
break;
case Comparer.Equal:
currentExpression = Expression.Equal(leftExpression, righExpression);
break;
case Comparer.Greater:
currentExpression = Expression.GreaterThan(leftExpression, righExpression);
break;
case Comparer.LessOrEqual:
currentExpression = Expression.LessThanOrEqual(leftExpression, righExpression);
break;
case Comparer.GreaterOrEqual:
currentExpression = Expression.GreaterThanOrEqual(leftExpression, righExpression);
break;
default:
currentExpression = Expression.Equal(leftExpression, righExpression);
break;
}
return(currentExpression);
}
public void TestConvertInput(Type type, string propertyName, string input, bool expectedValid)
{
// Arrange
Assert.IsNotNull(type);
var pi = type.GetProperty(propertyName);
var p = new ExpressionProperty($"{type.Name}.{propertyName}", propertyName, pi);
// Act
var result = p.ConvertInput(input, out var isValid);
// Assert
Assert.AreEqual(expectedValid, isValid);
if (isValid)
{
Assert.IsNotNull(result);
}
else
{
Assert.IsNull(result);
}
}
/// <summary>
/// Extracts the column name from the supplied property
/// </summary>
internal static object TypeToColumnName(ExpressionProperty pi)
{
return(TypeToColumnName(pi.ContainedProperty));
}
public static void ReplaceEmailTokens(ref string template, Entity entity)
{
// TODO: this fails if there are still tokens in the template that refer
// to invalid properties of the entity
template = ExpressionProperty.ResolveExpression(entity, template);
}
public Expression <Func <T, bool> > Build <T>(ExpressionProperty expressionProperty)
{
return(Expression.Lambda <Func <T, bool> >(GetPropertyExpression <T>(expressionProperty)));
}
internal static bool RequiresAppendedId(ExpressionProperty ep)
{
return(IsFK(ep) || ep.PropertyType.Implements <IGem>());
}
/// <summary>
/// Returns true if the supplied PropertyInfo references an type that implements IDwarf, ergo a Foreign Key
/// </summary>
public static bool IsFK(ExpressionProperty ep)
{
return(ep.PropertyType.Implements <IDwarf>());
}
/// <summary>
/// Returns the DwarfPropertyAttribute attribute exists
/// </summary>
public static DwarfPropertyAttribute GetAttribute(ExpressionProperty propertyInfo)
{
return(GetAttribute(propertyInfo.ContainedProperty));
}
public DatabaseInstance GenerateDatabaseInstance(ServerInstance serverInstance, List <DiskVolume> dataDiskVolumes, List <DiskVolume> logDiskVolumes, Slice slice, DatabaseVersion databaseVersion, string namePattern, string databaseNamePattern, double sizeFactor, bool generateFileGroups)
{
// --- Create the new database instance and set name
DatabaseInstance ndi = new DatabaseInstance(databaseDefinition);
ndi.ServerInstanceReference.Guid = serverInstance.Guid;
ndi.SliceReference.Guid = slice.Guid;
ndi.DatabaseVersionReference.Guid = databaseVersion.Guid;
ndi.Name = ExpressionProperty.ResolveExpression(ndi, namePattern);
ndi.DatabaseName = ExpressionProperty.ResolveExpression(ndi, databaseNamePattern);
ndi.Save();
if (generateFileGroups)
{
ndi.ServerInstance.Machine.LoadDiskVolumes(false);
databaseDefinition.LoadFileGroups(false);
slice.LoadPartitions(false);
List <Partition> partitions = new List <Partition>(slice.Partitions.Values.OrderBy(i => i.Number));
List <FileGroup> filegroups = new List <FileGroup>(databaseDefinition.FileGroups.Values.OrderBy(i => i.Number));
for (int fi = 0; fi < filegroups.Count; fi++)
{
// --- Create data and "log" file groups ---
if (filegroups[fi].LayoutType == FileGroupLayoutType.Monolithic ||
filegroups[fi].FileGroupType == FileGroupType.Log)
{
DatabaseInstanceFileGroup nfg = new DatabaseInstanceFileGroup(ndi);
nfg.FileGroupType = filegroups[fi].FileGroupType;
nfg.FileGroupName = nfg.Name = filegroups[fi].FileGroupName;
nfg.FileGroupReference.Guid = filegroups[fi].Guid;
nfg.PartitionReference.Guid = Guid.Empty;
nfg.AllocatedSpace = (long)(filegroups[fi].AllocatedSpace * sizeFactor);
nfg.Save();
nfg.GenerateInstanceFiles(dataDiskVolumes, sizeFactor);
}
else if (filegroups[fi].LayoutType == FileGroupLayoutType.Sliced)
{
for (int pi = 0; pi < partitions.Count; pi++)
{
DatabaseInstanceFileGroup nfg = new DatabaseInstanceFileGroup(ndi);
nfg.FileGroupType = filegroups[fi].FileGroupType;
nfg.FileGroupName = nfg.Name = string.Format("{0}_{1}", filegroups[fi].FileGroupName, pi);
nfg.FileGroupReference.Guid = filegroups[fi].Guid;
nfg.PartitionReference.Guid = partitions[pi].Guid;
nfg.AllocatedSpace = (long)(filegroups[fi].AllocatedSpace * sizeFactor);
nfg.Save();
nfg.GenerateInstanceFiles(dataDiskVolumes, sizeFactor);
}
}
else
{
throw new NotImplementedException();
}
}
}
return(ndi);
}
public override ExpressionProperty <T> ReadJson(JsonReader reader, Type objectType, ExpressionProperty <T> existingValue, bool hasExistingValue, JsonSerializer serializer)
{
if (reader.ValueType == typeof(string))
{
return(new ExpressionProperty <T>((string)reader.Value));
}
else
{
return(new ExpressionProperty <T>(JToken.Load(reader)));
}
}
set => SetValue(ExpressionProperty, value);
