private void BtnPourUnits_Click(object sender, EventArgs e)
{
var filterDefinition = new BinaryFilterExpressionCollection();
if (checkBox_PUName.Checked && textBox_PUName != null && !string.IsNullOrEmpty(textBox_PUName.Text))
{
var filterExpression1 = new BinaryFilterExpression
(
new PourUnitFilterExpressions.Name(), StringOperatorType.IS_EQUAL,
new StringConstantFilterExpression(textBox_PUName.Text)
);
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression1, BinaryFilterOperatorType.BOOLEAN_AND));
}
var filterExpression2 = new BinaryFilterExpression
(
new ObjectFilterExpressions.Type(), NumericOperatorType.IS_EQUAL,
new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.DB_POUR_UNIT)
);
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression2));
var model = new Model();
var selector = model.GetModelObjectSelector();
var enumerator = selector.GetObjectsByFilter(filterDefinition);
if (enumerator != null)
{
filteredPU.Text = enumerator.GetSize().ToString();
}
}
//Example from official documentation: developer.tekla.com
public void CreateSelectionFilter()
{
// Creates the filter expressions
PartFilterExpressions.Name PartName = new PartFilterExpressions.Name();
StringConstantFilterExpression Beam1 = new StringConstantFilterExpression("BEAM1");
StringConstantFilterExpression Beam2 = new StringConstantFilterExpression("BEAM2");
StringConstantFilterExpression Beam3 = new StringConstantFilterExpression("BEAM3");
// Creates a custom part filter
PartFilterExpressions.CustomString PartComment = new PartFilterExpressions.CustomString("Comment");
StringConstantFilterExpression Test = new StringConstantFilterExpression("test");
// Creates the binary filter expressions
BinaryFilterExpression Expression1 = new BinaryFilterExpression(PartName, StringOperatorType.IS_EQUAL, Beam1);
BinaryFilterExpression Expression2 = new BinaryFilterExpression(PartName, StringOperatorType.IS_EQUAL, Beam2);
BinaryFilterExpression Expression3 = new BinaryFilterExpression(PartName, StringOperatorType.IS_EQUAL, Beam3);
BinaryFilterExpression Expression4 = new BinaryFilterExpression(PartComment, StringOperatorType.STARTS_WITH, Test);
// Creates the binary filter expression collection
BinaryFilterExpressionCollection ExpressionCollection = new BinaryFilterExpressionCollection();
ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression1, BinaryFilterOperatorType.BOOLEAN_OR));
ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression2, BinaryFilterOperatorType.BOOLEAN_OR));
ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression3, BinaryFilterOperatorType.BOOLEAN_OR));
ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression4));
var modelPath = new TSM.Model().GetInfo().ModelPath;
string AttributesPath = Path.Combine(modelPath, "attributes");
string FilterName = Path.Combine(AttributesPath, this.filterName);
Filter Filter = new Filter(ExpressionCollection);
// Generates the filter file
Filter.CreateFile(FilterExpressionFileType.OBJECT_GROUP_SELECTION, FilterName);
}
public void WhenIAddANewFilter()
{
var coll = ScenarioContext.Current.Get<FilterCollection<Student>>("coll");
var filter = new BinaryFilterExpression<Student>(e => e.FirstName == "foo");
coll.AddNewFilter(filter);
ScenarioContext.Current.Add("filter", filter);
}
public static dynamic GetTSObject(BinaryFilterExpression dynObject)
{
if (dynObject is null)
{
return(null);
}
return(dynObject.teklaObject);
}
public void ToString_NotOperatorEqualsExpression_GeneratesStringCorrectly()
{
var left = new MemberAccessFilterExpression(null, "TestMember");
var right = new ConstantFilterExpression("hello", typeof (string));
var expr = new BinaryFilterExpression(left, FilterExpressionOperator.Equal, right);
var notExpr = new UnaryFilterExpression(FilterExpressionOperator.Not, expr);
Assert.That(notExpr.ToString(), Is.EqualTo("(not((TestMember eq 'hello')))"));
}
public void ToString_NotOperatorEqualsExpression_GeneratesStringCorrectly()
{
var left = new MemberAccessFilterExpression(null, "TestMember");
var right = new ConstantFilterExpression("hello", typeof(string));
var expr = new BinaryFilterExpression(left, FilterExpressionOperator.Equal, right);
var notExpr = new UnaryFilterExpression(FilterExpressionOperator.Not, expr);
Assert.That(notExpr.ToString(), Is.EqualTo("(not((TestMember eq 'hello')))"));
}
/// <summary>Selects all objects which are on the phase</summary>
/// <param name="phaseNumber">Number of the phase</param>
/// <exception cref="Exceptions.FilteringToolTeklaSettingsException">When macro directory not exsists</exception>
public static void SelectObjects(int phaseNumber)
{
var assemblyPhase = new TemplateFilterExpressions.CustomString("ASSEMBLY.PHASE");
var phase = new StringConstantFilterExpression(phaseNumber.ToString());
var expresion1 = new BinaryFilterExpression(assemblyPhase, StringOperatorType.IS_EQUAL, phase);
var objectType = new ObjectFilterExpressions.Type();
var partF = new NumericConstantFilterExpression(Tekla.Structures.TeklaStructuresDatabaseTypeEnum.PART);
var expresion2 = new BinaryFilterExpression(objectType, NumericOperatorType.IS_EQUAL, partF);
var expresion = new BinaryFilterExpressionCollection();
expresion.Add(new BinaryFilterExpressionItem(expresion1, BinaryFilterOperatorType.BOOLEAN_AND));
expresion.Add(new BinaryFilterExpressionItem(expresion2, BinaryFilterOperatorType.BOOLEAN_AND));
var filter = new Filter(expresion);
var objects = new Tekla.Structures.Model.Model().GetModelObjectSelector().GetObjectsByFilter(expresion);
objects.SelectInstances = false;
var ar = new System.Collections.ArrayList();
while (objects.MoveNext())
{
var part = objects.Current as Tekla.Structures.Model.Part;
if (part != null)
{
var assembly = part.GetAssembly();
ar.Add(assembly);
break;
}
}
var mos = new Tekla.Structures.Model.UI.ModelObjectSelector();
mos.Select(new System.Collections.ArrayList());
mos.Select(ar);
if (Tekla.Structures.TeklaStructures.Connect())
{
TeklaMacroDirectory.CheckIfExists();
var akit = new Tekla.Structures.MacroBuilder();
akit.PushButton("butCancel", "diaPhaseManager");
akit.Callback("acmd_display_active_system_dialog", "", "main_frame");
akit.PushButton("butSelectPhases", "diaPhaseManager");
akit.PushButton("butSelectObjects", "diaPhaseManager");
akit.PushButton("butCancel", "diaPhaseManager");
akit.Run();
akit = null;
}
}
private void BtnPourObject_Click(object sender, EventArgs e)
{
var filterDefinition = new BinaryFilterExpressionCollection();
// CheckBox_PourNumber 가 체크됬고, textBox에 값이 존재할 때,
if (checkBox_pourNumber.Checked && textBox_pourNumber != null && !string.IsNullOrEmpty(textBox_pourNumber.Text))
{
var filterExpression1 = new BinaryFilterExpression
(
new PourObjectFilterExpressions.PourNumber(), StringOperatorType.IS_EQUAL,
new StringConstantFilterExpression(textBox_pourNumber.Text)
);
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression1, BinaryFilterOperatorType.BOOLEAN_AND));
}
if (checkBox_pourType.Checked && textBox_pourType != null && !string.IsNullOrEmpty(textBox_pourType.Text))
{
var filterExpression2 = new BinaryFilterExpression
(
new PourObjectFilterExpressions.PourType(), StringOperatorType.IS_EQUAL,
new StringConstantFilterExpression(textBox_pourType.Text)
);
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression2, BinaryFilterOperatorType.BOOLEAN_AND));
}
if (checkBox_pourCM.Checked && textBox_CM != null && !string.IsNullOrEmpty(textBox_CM.Text))
{
var filterExpression3 = new BinaryFilterExpression
(
new PourObjectFilterExpressions.ConcreteMixture(), StringOperatorType.IS_EQUAL,
new StringConstantFilterExpression(textBox_CM.Text)
);
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression3, BinaryFilterOperatorType.BOOLEAN_AND));
}
var filterExpression4 = new BinaryFilterExpression
(
new ObjectFilterExpressions.Type(), NumericOperatorType.IS_EQUAL,
new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.DB_POUR_OBJECT)
);
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression4));
var model = new Model();
var selector = model.GetModelObjectSelector();
var enumerator = selector.GetObjectsByFilter(filterDefinition);
if (enumerator != null)
{
filteredPours.Text = enumerator.GetSize().ToString();
}
}
/// <summary>
/// Convert a FilterDescriptorCollection to FilterExpression
/// </summary>
/// <param name="filterDescriptors"></param>
/// <returns></returns>
public static FilterExpression Convert(FilterDescriptorCollection filterDescriptors)
{
FilterExpression filter = null;
FilterExpression tmpFilter = null;
List <FilterExpression> tmpFilterExpressions = new List <FilterExpression>();
foreach (var f in filterDescriptors)
{
if (f.GetType() == typeof(CompositeFilterDescriptor))
{
CompositeFilterDescriptor compositeFilterDescriptor = (CompositeFilterDescriptor)f;
FilterExpression compositeFilter = null;
compositeFilter = Convert(compositeFilterDescriptor.FilterDescriptors);
if (compositeFilter != null)
{
if (filter != null)
{
tmpFilter = filter;
filter = BinaryFilterExpression.And(tmpFilter, compositeFilter);
}
else
{
filter = compositeFilter;
}
}
}
else
if (f.GetType() == typeof(FilterDescriptor))
{
FilterExpression fe = convert(f);
if (fe != null)
{
if (filter != null)
{
tmpFilter = filter;
filter = BinaryFilterExpression.And(tmpFilter, fe);
}
else
{
filter = fe;
}
}
}
}
return(filter);
}
protected virtual Expression TranslateBinary(BinaryFilterExpression binary)
{
var left = Translate(binary.Left);
var right = Translate(binary.Right);
if (left.Type != right.Type)
{
if (left.Type == typeof (object))
{
left = Expression.Convert(left, right.Type);
}
else if (right.Type == typeof (object))
{
right = Expression.Convert(right, left.Type);
}
else if (left.Type.IsAssignableFrom(right.Type))
{
right = Expression.Convert(right, left.Type);
}
else if (right.Type.IsAssignableFrom(left.Type))
{
left = Expression.Convert(left, right.Type);
}
// TODO: do we even need these branches?
//else if ((left.NodeType == ExpressionType.Constant) && (right.NodeType != ExpressionType.Constant))
//{
// left = Expression.Convert(left, right.Type);
//}
//else if ((left.NodeType != ExpressionType.Constant) && (right.NodeType == ExpressionType.Constant))
//{
// right = Expression.Convert(right, left.Type);
//}
else
{
CoerceTypes(ref left, ref right);
}
}
var expressionType = binary.Operator.GetDotNetExpressionType();
return Expression.MakeBinary(expressionType, left, right);
}
protected virtual Expression TranslateBinary(BinaryFilterExpression binary)
{
var left = Translate(binary.Left);
var right = Translate(binary.Right);
if (left.Type != right.Type)
{
if (left.Type == typeof(object))
{
left = Expression.Convert(left, right.Type);
}
else if (right.Type == typeof(object))
{
right = Expression.Convert(right, left.Type);
}
else if (left.Type.IsAssignableFrom(right.Type))
{
right = Expression.Convert(right, left.Type);
}
else if (right.Type.IsAssignableFrom(left.Type))
{
left = Expression.Convert(left, right.Type);
}
// TODO: do we even need these branches?
//else if ((left.NodeType == ExpressionType.Constant) && (right.NodeType != ExpressionType.Constant))
//{
// left = Expression.Convert(left, right.Type);
//}
//else if ((left.NodeType != ExpressionType.Constant) && (right.NodeType == ExpressionType.Constant))
//{
// right = Expression.Convert(right, left.Type);
//}
else
{
CoerceTypes(ref left, ref right);
}
}
var expressionType = binary.Operator.GetDotNetExpressionType();
return(Expression.MakeBinary(expressionType, left, right));
}
private void BtnFilterSurface_Click(object sender, EventArgs e)
{
var filterDefinition = new BinaryFilterExpressionCollection();
if (checkBox_surfaceName.Checked && textBox_surfaceName != null && !string.IsNullOrEmpty(this.textBox_surfaceName.Text))
{
var filterExpression1 = new BinaryFilterExpression(
new SurfaceFilterExpressions.Name(), StringOperatorType.IS_EQUAL,
new StringConstantFilterExpression(this.textBox_surfaceName.Text));
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression1, BinaryFilterOperatorType.BOOLEAN_AND));
}
if (checkBox_surfaceType.Checked && textBox_surfaceType != null && !string.IsNullOrEmpty(textBox_surfaceType.Text))
{
var filterExpression2 = new BinaryFilterExpression(
new SurfaceFilterExpressions.Type(), StringOperatorType.IS_EQUAL,
new StringConstantFilterExpression(textBox_surfaceType.Text));
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression2, BinaryFilterOperatorType.BOOLEAN_AND));
}
if (checkBox_surfaceClass.Checked && textBox_surfaceClass != null && !string.IsNullOrEmpty(textBox_surfaceClass.Text))
{
var filterExpression3 = new BinaryFilterExpression(
new SurfaceFilterExpressions.Class(), NumericOperatorType.IS_EQUAL,
new NumericConstantFilterExpression(Int32.Parse(textBox_surfaceClass.Text)));
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression3, BinaryFilterOperatorType.BOOLEAN_AND));
}
var filterExpression4 = new BinaryFilterExpression(new ObjectFilterExpressions.Type(),
NumericOperatorType.IS_EQUAL, new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.SURFACE_OBJECT));
filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression4));
var model = new Model();
var selector = model.GetModelObjectSelector();
var enumerator = selector.GetObjectsByFilter(filterDefinition);
if (enumerator != null)
{
filteredSurfaces.Text = enumerator.GetSize().ToString();
}
}
public static List <Part> GetParts(this Model model, bool autoFetch)
{
ObjectFilterExpressions.Type objectType = new ObjectFilterExpressions.Type();
NumericConstantFilterExpression type =
new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.PART);
var expression2 = new BinaryFilterExpression(objectType, NumericOperatorType.IS_EQUAL, type);
BinaryFilterExpressionCollection filterCollection =
new BinaryFilterExpressionCollection
{
new BinaryFilterExpressionItem(expression2, BinaryFilterOperatorType.BOOLEAN_AND),
};
//IMPORTANT!!!
ModelObjectEnumerator.AutoFetch = autoFetch;
return(model
.GetModelObjectSelector()
.GetObjectsByFilter(filterCollection)
.ToAList <Part>());
}
public void CreateAndExpressionForQueryingTest()
{
var dsHelper = new DatasetHelper();
StructuredDataStructure dataStructure = dsHelper.CreateADataStructure();
dataStructure.Should().NotBeNull("Failed to meet a precondition: a data strcuture is required.");
string var1Name = "var" + dataStructure.Variables.First().Id;
string var2Name = "var" + dataStructure.Variables.Skip(1).First().Id;
FilterExpression fex = BinaryFilterExpression
.And(
new FilterNumberItemExpression()
{
Field = new Field()
{
DataType = Utils.NH.Querying.DataType.Ineteger, Name = var1Name
}
,
Operator = NumberOperator.Operation.GreaterThan
,
Value = 12
}
,
new FilterStringItemExpression()
{
Field = new Field()
{
DataType = Utils.NH.Querying.DataType.String, Name = var2Name
}
,
Operator = StringOperator.Operation.EndsWith
,
Value = "Test"
}
);
fex.ToSQL().Should().Be($"(({var1Name}) > (12)) AND (({var2Name}) ILIKE ('%Test'))");
// this is to show how to apply a NOT operator on any other expression.
// It can be applied on Numeric, String, Date, and any other type of expression
FilterExpression notFex = UnaryFilterExpression.Not(fex);
notFex.ToSQL().Should().Be($"NOT ((({var1Name}) > (12)) AND (({var2Name}) ILIKE ('%Test')))");
notFex.ToSQL().Should().Be($"NOT ({fex.ToSQL()})");
OrderByExpression orderByExpr = new OrderByExpression(
new List <OrderItemExpression>()
{
new OrderItemExpression(var1Name),
new OrderItemExpression(var2Name, SortDirection.Descending)
});
orderByExpr.ToSQL().Should().Be($"{var1Name} ASC, {var2Name} DESC");
// create a dataset and test the filter, sorting, and projectgion
long numberOfTuples = 100;
var dm = new DatasetManager();
var rsm = new ResearchPlanManager();
var mdm = new MetadataStructureManager();
try
{
dataStructure.Should().NotBeNull("Failed to meet a precondition: a data strcuture is required.");
var rp = dsHelper.CreateResearchPlan();
rp.Should().NotBeNull("Failed to meet a precondition: a research plan is required.");
var mds = mdm.Repo.Query().First();
mds.Should().NotBeNull("Failed to meet a precondition: a metadata strcuture is required.");
Dataset dataset = dm.CreateEmptyDataset(dataStructure, rp, mds);
dataset = dsHelper.GenerateTuplesForDataset(dataset, dataStructure, numberOfTuples, "Javad");
dataset.Should().NotBeNull("The dataset tuple generation has failed!");
dm.CheckInDataset(dataset.Id, "for testing purposes 2", "Javad", ViewCreationBehavior.None);
dm.SyncView(dataset.Id, ViewCreationBehavior.Create | ViewCreationBehavior.Refresh);
dataset.Id.Should().BeGreaterThan(0, "Dataset was not persisted.");
dataset.LastCheckIOTimestamp.Should().NotBeAfter(DateTime.UtcNow, "The dataset's timestamp is wrong.");
dataset.DataStructure.Should().NotBeNull("Dataset must have a data structure.");
dataset.Status.Should().Be(DatasetStatus.CheckedIn, "Dataset must be in the CheckedIn status.");
dm.GetDatasetLatestVersionEffectiveTupleCount(dataset.Id).Should().Be(numberOfTuples);
// pass this filter to get a subset of dataset X
var dst = dm.GetLatestDatasetVersionTuples(dataset.Id, fex, null, null, 1, 10);
dst.Should().NotBeNull();
dst.Rows.Count.Should().BeLessOrEqualTo(10);
dm.DatasetVersionRepo.Evict();
dm.DataTupleRepo.Evict();
dm.DatasetRepo.Evict();
dm.PurgeDataset(dataset.Id, true);
dsHelper.PurgeAllDataStructures();
}
finally
{
dm.Dispose();
rsm.Dispose();
mdm.Dispose();
}
}
