private static TableDefinition CourseTableDefinition()
{
TableDefinition table = new TableDefinition("Course")
{
Plural = "Courses"
};
table.AddField(new IntFieldDefinition("CourseID")
{
Key = 1,
DisplayName = "Number"
});
table.AddField(new StringFieldDefinition("Title")
{
Length = 50,
MinimumLength = 3
});
table.AddField(new IntFieldDefinition("Credits")
{
Minimum = 0,
Maximum = 5
});
table.AddField(new ParentFieldDefinition("Department")
{
ParentTable = "Department"
});
return(table);
}
public void EditFieldsTest()
{
const string fieldName1 = "field1";
const ColumnTypes fieldType1 = ColumnTypes.String;
const string fieldName2 = "field2";
const ColumnTypes fieldType2 = ColumnTypes.Numeric;
Collection<FieldDefinition> fields = null;
var parentTD = new TableDefinition("Parent Table Definition");
var td = new TableDefinition("Test Table Definition");
td.AddField(fieldName1, fieldType1);
td.AddField(fieldName2, fieldType2, parentTD);
Assert.AreEqual(td[fieldName1].ColumnType, fieldType1);
Assert.AreEqual(td[fieldName2].ColumnType, fieldType2);
fields = td.GetFields();
Assert.AreEqual(fields.Count, 2);
td.RemoveField(fields.FirstOrDefault(f => f.SystemName.Equals(fieldName1)));
fields = td.GetFields();
Assert.AreEqual(fields.Count, 1);
Assert.AreEqual(fields[0].ColumnType, fieldType2);
}
internal TableDefinition GetTableDefinition()
{
TableDefinition tableDefinition = new TableDefinition(TableName);
foreach (NormalizeFieldInfo field in Fields)
{
tableDefinition.AddField(new FieldDefinition(field.Name, field.Type, field.IsUnique, field.IsNotNull));
}
foreach (NormalizeInfo childDirectory in ChildDirectories)
{
tableDefinition.AddField(new FieldDefinition(childDirectory.GetAsFk(), SqlDbType.BigInt, true, false));
}
if (!string.IsNullOrEmpty(this._tableIndexFields))
{
string[] tableIndexFieldsList = this._tableIndexFields.Split(',')
.Select(x => x.Trim())
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToArray();
tableDefinition.Indexes.Add(
new IndexDefinition(
tableDefinition,
"idx_" + this.TableName + "_config_fields",
false,
tableIndexFieldsList
)
);
}
return(tableDefinition);
}
private static TableDefinition EnrollmentTableDefinition()
{
TableDefinition table = new TableDefinition("Enrollment")
{
Plural = "Enrollments"
};
table.AddField(new IntFieldDefinition("EnrollmentID")
{
Key = 1
});
EnumerationFieldDefinition grade = table.AddField(new EnumerationFieldDefinition("Grade")
{
EmptyText = "No Grade",
EnumerationName = "Grade"
});
table.AddField(new ParentFieldDefinition("Course")
{
ParentTable = "Course"
});
table.AddField(new ParentFieldDefinition("Student")
{
ParentTable = "Student"
});
return(table);
}
private static TableDefinition DepartmentTableDefinition()
{
TableDefinition table = new TableDefinition("Department")
{
Plural = "Departments"
};
table.AddField(new IntFieldDefinition("DepartmentID")
{
Key = 1
});
table.AddField(new StringFieldDefinition("Name")
{
Length = 50,
MinimumLength = 3
});
table.AddField(new DecimalFieldDefinition("Budget")
{
Type = NumberType.Currency
});
table.AddField(new DateTimeFieldDefinition("StartDate")
{
Type = DateTimeType.Date,
DisplayName = "Start Date"
});
table.AddField(new ParentFieldDefinition("Administrator")
{
ParentTable = "Instructor"
});
return(table);
}
private static TableDefinition InstructorTableDefinition()
{
TableDefinition table = new TableDefinition("Instructor")
{
ParentTable = "Person",
Plural = "Instructors",
Abstract = false,
DisplayName = "Instructor"
};
table.AddField(new DateTimeFieldDefinition("HireDate")
{
Required = true,
Type = DateTimeType.Date,
DisplayName = "Hire Date"
});
table.AddField(new MultipleFieldDefinition("Courses")
{
ParentTable = "Courses"
});
table.AddField(new ParentFieldDefinition("OfficeAssignment")
{
ParentTable = "OfficeAssignment"
});
return(table);
}
public static void ModifyTableDefinitionAddOptionField(
TableDefinition tableDefinition,
string optFieldName,
SqlDbType sqlType,
bool addFieldIndex
)
{
tableDefinition.AddField(
new FieldDefinition(
optFieldName,
sqlType,
false,
false
)
);
if (addFieldIndex)
{
tableDefinition.Indexes.Add(
new IndexDefinition(
tableDefinition,
optFieldName + "_indx",
false,
optFieldName
)
);
}
}
public void GetPrefixedFieldListShouldIncludeOnlyInResultFileColumns()
{
var stub = new SearchQueryGeneratorStub();
var rootTable = new TableDefinition("test");
stub.RootTable = rootTable;
rootTable.AddField("File", ColumnTypes.File);
Assert.IsTrue(stub.GetPrefixedFieldListPublic(0, true).Contains("[File]"));
Assert.IsTrue(stub.GetPrefixedFieldListPublic(0, true).Contains("[FileUrl]"));
stub.ResultColumns.Add("None");
stub.LimitResultColumns = true;
Assert.IsFalse(stub.GetPrefixedFieldListPublic(0, true).Contains("[File]"));
Assert.IsFalse(stub.GetPrefixedFieldListPublic(0, true).Contains("[FileUrl]"));
stub.ResultColumns.Add("FileUrl");
Assert.IsFalse(stub.GetPrefixedFieldListPublic(0, true).Contains("[File]"));
Assert.IsTrue(stub.GetPrefixedFieldListPublic(0, true).Contains("[FileUrl]"));
stub.ResultColumns.Add("File");
Assert.IsTrue(stub.GetPrefixedFieldListPublic(0, true).Contains("[File]"));
Assert.IsTrue(stub.GetPrefixedFieldListPublic(0, true).Contains("[FileUrl]"));
}
public void GetFieldReturnsRootTableField()
{
// Arrange.
var rootTable = new TableDefinition("TestTable");
var field = rootTable.AddField("TestField", ColumnTypes.String);
var processDefinition = new ProcessDefinition();
processDefinition.TableList.Add(rootTable);
// Act.
Assert.AreSame(field, processDefinition.GetField("TestField"));
}
private static TableDefinition OfficeAssignmentTableDefinition()
{
TableDefinition table = new TableDefinition("OfficeAssignment")
{
Plural = "OfficeAssignments"
};
table.AddField(new ParentFieldDefinition("Instructor")
{
Key = 1,
ParentTable = "Instructor"
});
table.AddField(new StringFieldDefinition("Name")
{
Length = 50,
DisplayName = "Office Location"
});
return(table);
}
private static TableDefinition PersonTableDefinition()
{
TableDefinition table = new TableDefinition("Person")
{
Plural = "People",
Abstract = true,
DisplayName = "Person"
};
table.AddField(new IntFieldDefinition("ID")
{
Key = 1,
});
table.AddField(new StringFieldDefinition("LastName")
{
Required = true,
Length = 50,
DisplayName = "Last name"
});
table.AddField(new StringFieldDefinition("FirstMidName")
{
Required = true,
Length = 50,
LengthErrorMessage = "First name cannot be longer than 50 characters.",
DisplayName = "First Name",
ColumnName = "FirstName"
});
table.AddField(new CalculatedFieldDefinition("FullName")
{
DisplayName = "Full Name"
});
return(table);
}
public void CloneTest()
{
const string fieldName1 = "field1";
const ColumnTypes fieldType1 = ColumnTypes.String;
const string fieldName2 = "field2";
const ColumnTypes fieldType2 = ColumnTypes.Numeric;
Collection<FieldDefinition> fields = null;
const string tableName = "Test Table Definition";
const string tablePrefix = "prefix";
const string parentTableName = "Parent Table Definition";
const string parentTablePrefix = "parentPrefix";
var parentTD = new TableDefinition(parentTableName) { Prefix = parentTablePrefix};
var td = new TableDefinition(tableName) {BaseTable = parentTD, Prefix = tablePrefix};
td.AddField(fieldName1, fieldType1);
td.AddField(fieldName2, fieldType2, parentTD);
var clone = td.Clone();
Assert.AreEqual(td.GetFields(), clone.GetFields());
Assert.AreEqual(td.Name, clone.Name);
Assert.AreEqual(td.Prefix, clone.Prefix);
Assert.AreEqual(td.BaseTable.Name, clone.BaseTable.Name);
Assert.AreEqual(td.BaseTable.GetFields(), clone.BaseTable.GetFields());
Assert.AreEqual(td.BaseTable.Prefix, clone.BaseTable.Prefix);
fields = clone.GetFields();
Assert.AreEqual(fields.Count, 2);
Assert.IsTrue(fields.Any(f => f.SystemName.Equals(fieldName1)));
Assert.IsTrue(fields.Any(f => f.SystemName.Equals(fieldName2)));
var fieldWithParent = fields.FirstOrDefault(f => f.SystemName.Equals(fieldName2));
Assert.IsTrue(fieldWithParent != null && fieldWithParent.ParentTable != null);
Assert.AreEqual(fieldWithParent.ParentTable.Name, parentTableName);
}
private static TableDefinition StudentTableDefinition()
{
TableDefinition table = new TableDefinition("Student")
{
ParentTable = "Person",
Plural = "Students",
Abstract = false,
DisplayName = "Student"
};
table.AddField(new DateTimeFieldDefinition("EnrollmentDate")
{
Required = true,
Type = DateTimeType.Date,
DisplayName = "Enrollment Date"
});
return(table);
}
public void AddFiltersAndReplacePredefinedValuesTests()
{
// arrange
const string columnSystemName = "CreatedBy";
const string userFullName = "James Bond";
var sourceFilterList = new List<IFilterDescriptor>
{
new FilterDescriptor(LogicalOperators.And, new MobileObservableCollection<IFilterDescriptor>())
{
ColumnName = columnSystemName,
Value = new FilterValue
{
DisplayName = "Current User",
SystemName = "user",
Type = FilterValueType.SystemVariable
}
}
};
var destinationFilterList = new List<IFilterDescriptor>();
var queryGenerator = new SearchQueryGenerator();
var tb = new TableDefinition(columnSystemName);
tb.AddField(columnSystemName, ColumnTypes.String);
queryGenerator.RootTable = tb;
var identityMock = Mock.Create<IMQ1Identity>();
var principalMock = Mock.Create<IPrincipal>();
Mock.Arrange(() => principalMock.Identity).Returns(identityMock);
Mock.Arrange(() => identityMock.FullName).Returns(userFullName);
Csla.ApplicationContext.User = principalMock;
// act
QueryGeneratorExtensions.AddFilters(sourceFilterList, destinationFilterList, tb, queryGenerator);
// assert
Assert.AreEqual(userFullName, destinationFilterList.First().Value);
}
public void QueryShouldContainJoinToBinaryContentTableIfTableHasImageFields()
{
var stub = new SearchQueryGeneratorStub();
var rootTable = new TableDefinition("test");
stub.RootTable = rootTable;
rootTable.AddField("Image", ColumnTypes.Image);
var query = stub.GenerateQuery();
Assert.IsTrue(query.Contains(Constants.BinaryContentTableName));
Assert.IsTrue(query.Contains("[bc0]"));
}
public void GetPrefixedFieldListShouldIncludeOnlyInResultRichStringColumns()
{
var stub = new SearchQueryGeneratorStub();
var rootTable = new TableDefinition("test");
stub.RootTable = rootTable;
rootTable.AddField("String", ColumnTypes.String, isRichText: true);
Assert.IsTrue(stub.GetPrefixedFieldListPublic(0, true).Contains("[String]"));
stub.ResultColumns.Add("None");
stub.LimitResultColumns = true;
Assert.IsFalse(stub.GetPrefixedFieldListPublic(0, true).Contains("[String]"));
stub.ResultColumns.Add("String");
Assert.IsTrue(stub.GetPrefixedFieldListPublic(0, true).Contains("[String]"));
}
/// <summary>
/// Adds the filters.
/// </summary>
/// <param name="sourceFilterList">The source filter list.</param>
/// <param name="destinationFilterList">The destination filter list.</param>
/// <param name="rootTable">The root table.</param>
/// <param name="queryGenerator">The query generator.</param>
public static void AddFilters(IEnumerable<IFilterDescriptor> sourceFilterList, IList<IFilterDescriptor> destinationFilterList, TableDefinition rootTable, SearchQueryGenerator queryGenerator)
{
if (sourceFilterList == null || destinationFilterList == null || queryGenerator == null)
return;
foreach (var filter in sourceFilterList)
{
if (filter.FilterDescriptors != null && filter.FilterDescriptors.Count > 0)
{
var list = new List<IFilterDescriptor>();
destinationFilterList.Add(new SharedTypes.QueryGenerator.FilterDescriptor(filter.LogicalOperator, list));
AddFilters(filter.FilterDescriptors, list, rootTable, queryGenerator);
}
else
{
var column = queryGenerator.FindColumn(filter.ColumnName, true, false);
if (column != null)
destinationFilterList.Add(new SharedTypes.QueryGenerator.FilterDescriptor(column, filter.ColumnName, filter.Operator, filter.Value, filter.MemberType));
else
{
if (!string.IsNullOrWhiteSpace(filter.ColumnName))
if (filter.ColumnName.Contains('.'))
{
var parts = filter.ColumnName.Split('.');
if (parts.Count() < 3)
return;
var t = new TableDefinition(parts[0]);
t.AddField(parts[1], ColumnTypes.Reference);
queryGenerator.AddBaseTable(t);
}
else
destinationFilterList.Add(new SharedTypes.QueryGenerator.FilterDescriptor(filter.ColumnName, filter.ColumnName, filter.Operator, filter.Value, filter.MemberType));
}
}
}
}
public void AddBaseTable_ShouldUpdateIsFilterableProperty()
{
#region Arrange
var visibleFields = new[] { BaseField1Name, BaseField3Name };
var queryGenerator = new SearchQueryGeneratorTest();
queryGenerator.SetNonFilteredColumns(null);
queryGenerator.ResultColumns.AddRange(visibleFields);
queryGenerator.LimitResultColumns = true;
var baseProcessdefinition = new ProcessDefinition();
var baseTableDefinition = new TableDefinition("TestBaseProcess");
baseProcessdefinition.TableList.Insert(0, baseTableDefinition);
baseTableDefinition.AddField(BaseField1Name, ColumnTypes.Numeric, null, true, true);
baseTableDefinition.AddField(BaseField2Name, ColumnTypes.Object, null, true, true);
baseTableDefinition.AddField(BaseField3Name, ColumnTypes.Object, null, true, false);
#endregion Arrange
// Act
queryGenerator.AddBaseTable(baseProcessdefinition);
// Assert
Assert.IsTrue(queryGenerator.BaseFieldIsFilterable(BaseField1Name));
Assert.IsFalse(queryGenerator.BaseFieldIsFilterable(BaseField2Name));
Assert.IsFalse(queryGenerator.BaseFieldIsFilterable(BaseField3Name));
}
public void RemoveBuildInColumnsTest()
{
#region Arrange
const string FieldName = "Field1";
const string CrFieldName = "CrossRef1";
const string McrFieldName = "MultiCrossRef1";
var processdefinition = new ProcessDefinition();
var tableDefinition = new TableDefinition("TestProcess");
processdefinition.TableList.Insert(0, tableDefinition);
tableDefinition.AddField(FieldName, ColumnTypes.String, null, true, true);
processdefinition.SingleCrossReferenceFields.Add(
new ReferenceFieldDefinition
{
ColumnType = ColumnTypes.Reference,
SystemName = Constants.CurrentStateColumnName
});
processdefinition.SingleCrossReferenceFields.Add(
new ReferenceFieldDefinition
{
ColumnType = ColumnTypes.Reference,
SystemName = CrFieldName
});
processdefinition.MultiCrossReferenceFields.Add(
new ReferenceFieldDefinition
{
ColumnType = ColumnTypes.MultiReference,
SystemName = McrFieldName
});
processdefinition.MultiCrossReferenceFields.Add(
new ReferenceFieldDefinition
{
ColumnType = ColumnTypes.MultiReference,
SystemName = Constants.PaperclipsColumnName
});
#endregion Arrange
// Act
processdefinition.RemoveBuildInColumns();
// Assert
Assert.AreEqual(processdefinition.TableList.Count, 1);
Assert.AreEqual(processdefinition.TableList[0].GetFields().Count, 1);
Assert.AreEqual(processdefinition.SingleCrossReferenceFields.Count, 1);
Assert.AreEqual(processdefinition.SingleCrossReferenceFields[0].SystemName, CrFieldName);
Assert.AreEqual(processdefinition.MultiCrossReferenceFields.Count, 1);
Assert.AreEqual(processdefinition.MultiCrossReferenceFields[0].SystemName, McrFieldName);
}
