/// <summary>
/// Get data for build expression.
/// </summary>
/// <param name="searchInfo">The search info.</param>
/// <returns></returns>
private void GetDataForBuildExpression(SearchInfo searchInfo)
{
var properties = searchInfo.GetType().GetProperties();
foreach (var property in properties)
{
var expressionBuilderAttribute = (ExpressionBuilderAttribute)property.GetCustomAttribute(typeof(ExpressionBuilderAttribute));
if (expressionBuilderAttribute != null)
{
var value = property.GetValue(searchInfo);
if (value != null)
{
var filterStatement = new FilterStatement
{
PropertyName = expressionBuilderAttribute.PropertyName,
Operation = expressionBuilderAttribute.Operation,
Value = value
};
_statements.Add(filterStatement);
}
}
}
}
/// <summary>
/// Aggiunge il filtro alla request di ricerca degli emendamenti
/// </summary>
/// <param name="model"></param>
/// <param name="gruppi"></param>
public static void AddFilter_Groups(ref BaseRequest <EmendamentiDto> model, string gruppi)
{
if (string.IsNullOrEmpty(gruppi))
{
return;
}
var gruppi_split = gruppi.Split(',');
if (gruppi_split.Length <= 0)
{
return;
}
foreach (var groupId in gruppi_split)
{
var filtro = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.id_gruppo),
Operation = Operation.EqualTo,
Value = groupId,
Connector = FilterStatementConnector.Or
};
model.filtro.Add(filtro);
}
}
public void SerializeFilterStatementWithEnumValue()
{
var serializer = new XmlSerializer(typeof(FilterStatement <PersonGender>));
StringBuilder sb = new StringBuilder();
using (var writer = new StringWriter())
{
var statement = new FilterStatement <PersonGender>
(
"Gender",
Operation.EqualTo,
PersonGender.Male,
default(PersonGender),
Connector.And
);
serializer.Serialize(writer, statement);
writer.Flush();
sb = writer.GetStringBuilder();
}
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(sb.ToString());
//Checking the statements list
var root = xmlDoc.DocumentElement;
Assert.That(root.Attributes["Type"].Value, Does.StartWith("ExpressionBuilder.Test.Models.PersonGender"));
Assert.That(root.SelectSingleNode("PropertyId").InnerText, Is.EqualTo("Gender"));
Assert.That(root.SelectSingleNode("Operation").InnerText, Is.EqualTo("EqualTo"));
Assert.That(root.SelectSingleNode("Value").InnerText, Is.EqualTo("Male"));
Assert.That(root.SelectSingleNode("Connector").InnerText, Is.EqualTo("0"));
}
public void DeserializeXmlIntoFilterStatementObjectWithEnumValue()
{
var sb = new StringBuilder();
sb.Append(" <FilterStatementOfPersonGender Type=\"ExpressionBuilder.Test.Models.PersonGender, ExpressionBuilder.Test, Version=1.0.6330.24179, Culture=neutral, PublicKeyToken=null\">");
sb.Append(" <PropertyId>Gender</PropertyId>");
sb.Append(" <Operation>EqualTo</Operation>");
sb.Append(" <Value>Male</Value>");
sb.Append(" <Connector>0</Connector>");
sb.Append(" </FilterStatementOfPersonGender>");
FilterStatement <PersonGender> statement = null;
var serializer = new XmlSerializer(typeof(FilterStatement <PersonGender>));
using (var reader = new StringReader(sb.ToString()))
{
statement = serializer.Deserialize(reader) as FilterStatement <PersonGender>;
}
Assert.That(statement, Is.Not.Null);
Assert.That(statement.PropertyId, Is.EqualTo("Gender"));
Assert.That(statement.Operation, Is.EqualTo(Operation.EqualTo));
Assert.That(statement.Value, Is.EqualTo(PersonGender.Male));
Assert.That(statement.Connector, Is.EqualTo(Connector.And));
}
public void SerializeFilterStatementWithNumericValue()
{
var serializer = new XmlSerializer(typeof(FilterStatement <int>));
StringBuilder sb;
using (var writer = new StringWriter())
{
var statement = new FilterStatement <int>
(
"Id",
Operation.GreaterThanOrEqualTo,
2,
0,
Connector.Or
);
serializer.Serialize(writer, statement);
writer.Flush();
sb = writer.GetStringBuilder();
}
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(sb.ToString());
//Checking the statements list
var root = xmlDoc.DocumentElement;
Assert.That(root.Attributes["Type"].Value, Does.StartWith("System.Int32"));
Assert.That(root.SelectSingleNode("PropertyId").InnerText, Is.EqualTo("Id"));
Assert.That(root.SelectSingleNode("Operation").InnerText, Is.EqualTo("GreaterThanOrEqualTo"));
Assert.That(root.SelectSingleNode("Value").InnerText, Is.EqualTo("2"));
Assert.That(root.SelectSingleNode("Connector").InnerText, Is.EqualTo("1"));
}
public void SerializeFilterStatementWithDateTimeValue()
{
var serializer = new XmlSerializer(typeof(FilterStatement <DateTime>));
StringBuilder sb = new StringBuilder();
using (var writer = new StringWriter())
{
var statement = new FilterStatement <DateTime>
(
"Birth.Date",
Operation.GreaterThan,
new DateTime(1980, 1, 1),
default(DateTime),
Connector.And
);
serializer.Serialize(writer, statement);
writer.Flush();
sb = writer.GetStringBuilder();
}
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(sb.ToString());
//Checking the statements list
var root = xmlDoc.DocumentElement;
Assert.That(root.Attributes["Type"].Value, Does.StartWith("System.DateTime"));
Assert.That(root.SelectSingleNode("PropertyId").InnerText, Is.EqualTo("Birth.Date"));
Assert.That(root.SelectSingleNode("Operation").InnerText, Is.EqualTo("GreaterThan"));
var value = DateTime.Parse(root.SelectSingleNode("Value").InnerText);
Assert.That(value, Is.EqualTo(new DateTime(1980, 1, 1)).Within(0).Days);
Assert.That(root.SelectSingleNode("Connector").InnerText, Is.EqualTo("0"));
}
public void DeserializeXmlIntoFilterStatementObjectWithNumericValue()
{
var sb = new StringBuilder();
sb.Append(" <FilterStatementOfInt32 Type=\"System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\">");
sb.Append(" <PropertyId>Id</PropertyId>");
sb.Append(" <Operation>GreaterThanOrEqualTo</Operation>");
sb.Append(" <Value>2</Value>");
sb.Append(" <Connector>1</Connector>");
sb.Append(" </FilterStatementOfInt32>");
FilterStatement <int> statement = null;
var serializer = new XmlSerializer(typeof(FilterStatement <int>));
using (var reader = new StringReader(sb.ToString()))
{
statement = serializer.Deserialize(reader) as FilterStatement <int>;
}
Assert.That(statement, Is.Not.Null);
Assert.That(statement.PropertyId, Is.EqualTo("Id"));
Assert.That(statement.Operation, Is.EqualTo(Operation.GreaterThanOrEqualTo));
Assert.That(statement.Value, Is.EqualTo(2));
Assert.That(statement.Connector, Is.EqualTo(Connector.Or));
}
/// <summary>
/// Aggiunge il filtro alla request di ricerca degli emendamenti
/// </summary>
/// <param name="model"></param>
/// <param name="firmatari"></param>
public static void AddFilter_Signers(ref BaseRequest <EmendamentiDto> model, string firmatari)
{
if (string.IsNullOrEmpty(firmatari))
{
return;
}
var firma_split = firmatari.Split(',');
if (firma_split.Length <= 0)
{
return;
}
foreach (var personaUId in firma_split)
{
var filtro = new FilterStatement <EmendamentiDto>
{
PropertyId = "Firmatario",
Operation = Operation.EqualTo,
Value = personaUId
};
model.filtro.Add(filtro);
}
}
/// <summary>
/// Aggiunge il filtro alla request di ricerca degli emendamenti
/// </summary>
/// <param name="model"></param>
/// <param name="stringa1"></param>
/// <param name="stringa2"></param>
/// <param name="connettore"></param>
public static void AddFilter_ByText(ref BaseRequest <EmendamentiDto> model, string stringa1, string stringa2 = "", int connettore = 0)
{
if (!string.IsNullOrEmpty(stringa1))
{
var filtro1 = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.TestoEM_originale),
Operation = Operation.Contains,
Value = stringa1
};
if (connettore > 0)
{
filtro1.Connector = (FilterStatementConnector)connettore;
}
model.filtro.Add(filtro1);
}
if (!string.IsNullOrEmpty(stringa2))
{
var filtro2 = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.TestoEM_originale),
Operation = Operation.Contains,
Value = stringa2
};
if (connettore > 0)
{
filtro2.Connector = (FilterStatementConnector)connettore;
}
model.filtro.Add(filtro2);
}
}
/// <summary>
/// Aggiunge il filtro alla request di ricerca degli emendamenti
/// </summary>
/// <param name="model"></param>
/// <param name="proponenti"></param>
public static void AddFilter_Proponents(ref BaseRequest <EmendamentiDto> model, string proponenti)
{
if (string.IsNullOrEmpty(proponenti))
{
return;
}
var prop_split = proponenti.Split(',');
if (prop_split.Length <= 0)
{
return;
}
foreach (var personaUId in prop_split)
{
var filtro = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.UIDPersonaProponente),
Operation = Operation.EqualTo,
Value = personaUId,
Connector = FilterStatementConnector.Or
};
model.filtro.Add(filtro);
}
}
public IFilterStatementConnection <TClass> By <TPropertyType>(string propertyName, Operation operation, TPropertyType value, FilterStatementConnector connector = FilterStatementConnector.And)
{
IFilterStatement statement = null;
statement = new FilterStatement <TPropertyType>(propertyName, operation, value, connector);
_statements.Add(statement);
return(new FilterStatementConnection <TClass>(this, statement));
}
public IFilterStatementConnection <TClass> By <TPropertyType>(string propertyName, Operation operation, TPropertyType value, FilterStatementConnector connector = FilterStatementConnector.And, bool?isReplaceAllSpace = false)
{
_isReplaceAllSpace = isReplaceAllSpace;
IFilterStatement statement = null;
statement = new FilterStatement <TPropertyType>(propertyName, operation, value, connector);
_statements.Add(statement);
return(new FilterStatementConnection <TClass>(this, statement));
}
public void GetSchemaMethodOfFilterStatementClassShouldReturnNull()
{
var statement = new FilterStatement <PersonGender>
(
"Gender",
Operation.EqualTo,
PersonGender.Male,
Connector.And
);
Assert.That(statement.GetSchema(), Is.Null);
}
/// <summary>
/// Aggiunge il filtro alla request di ricerca degli emendamenti
/// </summary>
/// <param name="model"></param>
/// <param name="solo_effetti_finanziari"></param>
public static void AddFilter_Financials(ref BaseRequest <EmendamentiDto> model, string solo_effetti_finanziari)
{
if (solo_effetti_finanziari != "on")
{
return;
}
var filtro1 = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.EffettiFinanziari),
Operation = Operation.EqualTo,
Value = 1,
Connector = FilterStatementConnector.And
};
model.filtro.Add(filtro1);
}
/// <summary>
/// Aggiunge il filtro alla request di ricerca degli emendamenti
/// </summary>
/// <param name="model"></param>
/// <param name="personaUID"></param>
/// <param name="solo_miei"></param>
public static void AddFilter_My(ref BaseRequest <EmendamentiDto> model, Guid personaUID, string solo_miei)
{
if (solo_miei != "on")
{
return;
}
var filtro1 = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.IDStato),
Operation = Operation.NotEqualTo,
Value = (int)StatiEnum.Bozza_Riservata,
Connector = FilterStatementConnector.Or
};
model.filtro.Add(filtro1);
var filtro2 = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.IDStato),
Operation = Operation.EqualTo,
Value = (int)StatiEnum.Bozza_Riservata,
Connector = FilterStatementConnector.And
};
model.filtro.Add(filtro2);
var filtro3 = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.UIDPersonaProponente),
Operation = Operation.EqualTo,
Value = personaUID,
Connector = FilterStatementConnector.Or
};
model.filtro.Add(filtro3);
var filtro4 = new FilterStatement <EmendamentiDto>
{
PropertyId = nameof(EmendamentiDto.UIDPersonaCreazione),
Operation = Operation.EqualTo,
Value = personaUID,
Connector = FilterStatementConnector.Or
};
model.filtro.Add(filtro4);
}
[Test] public void BuildExpression_WhenPropertyNull_ShouldReturnFail()
{
//Arrange
FilterStatement <EventModel> filterStatement = TestsFacade.FilterStatementFacade.BuildFilterStatement <EventModel>();
filterStatement.PropertyName = null;
IEnumerable <FilterStatement <EventModel> > filterStatements = new List <FilterStatement <EventModel> >()
{
filterStatement
};
FiltersService <EventModel> service = new FiltersService <EventModel>(filterStatements);
//Act
ResultService <Expression <Func <EventModel, bool> > > result = service.BuildExpression();
//Assert
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.IsNull(result.Value);
Assert.IsTrue(result.ErrorCode == ErrorCode.EntityNotValid);
}
public ResultHandler <Expression <Func <EventModel, bool> > > BuildExpression(FilterStatement <EventModel> filterStatement)
{
try
{
ExpressionStarter <EventModel> result = PredicateBuilder.New <EventModel>();
switch (filterStatement.PropertyName)
{
case "Audience":
var values = JsonConvert.DeserializeObject <IEnumerable <int> >(filterStatement.ValueJson);
foreach (var value in values)
{
result.Or(x => x.Audience == value);
}
break;
default:
throw new NotImplementedException("No filter support for this property");
}
return(ResultHandler.Ok <Expression <Func <EventModel, bool> > >(result));
}
catch (Exception ex)
{
this._logger.LogError(ex, "MultiCheckboxFilter.BuildExpression Failure");
return(ResultHandler.Fail <Expression <Func <EventModel, bool> > >(ex));
}
}
