private static IClauseCollection Add(this IClauseCollection clauseCollection, string @operator, string sql)
{
Clause clause = new Clause(sql, clauseCollection.Parameters);
clauseCollection.Add(@operator, clause);
return(clauseCollection);
}
public void OrIsNull_calls_And_with_arguments()
{
IClauseCollection <TestClass> clauseCollection = A.Fake <IClauseCollection <TestClass> >();
IClauseCollectionExtensions.OrIsNull(clauseCollection, x => x.Title);
A.CallTo(() => clauseCollection.Or("Title", SqlOperator.Is, "null")).MustHaveHappened();
}
public void And_calls_And_with_arguments()
{
IClauseCollection clauseCollection = A.Fake <IClauseCollection>();
IClauseCollectionExtensions.And(clauseCollection, "foo", 2);
A.CallTo(() => clauseCollection.And("foo", SqlOperator.Equal, 2)).MustHaveHappened();
}
public static IClauseCollection <T> Or <T, TProp>(this IClauseCollection <T> clauseCollection, Expression <Func <T, TProp> > property, SqlOperator sqlOperator, TProp value, Func <TProp, bool> applyPredicate)
{
if (applyPredicate(value))
{
clauseCollection.Or(property, sqlOperator, value);
}
return(clauseCollection);
}
public static IClauseCollection <T> And <T, TProp>(this IClauseCollection <T> clauseCollection, Expression <Func <T, TProp> > property, TProp value, Func <TProp, bool> applyPredicate)
{
if (applyPredicate(value))
{
And(clauseCollection, property, value);
}
return(clauseCollection);
}
public static void Add(this IClauseCollection clauseCollection, Clause clause)
{
if (clauseCollection.Count > 0)
{
clauseCollection.Add(Clause.SqlAnd, clause);
}
else
{
clauseCollection.Add(null, clause);
}
}
public void Or_calls_Add_with_arguments()
{
IClauseCollection clauseCollection = A.Fake <IClauseCollection>();
IClauseCollectionExtensions.Or(clauseCollection, "1=1");
// assert the 2nd argument of Add() was called with the clause argument where the sql matches and with the correct operator
A.CallTo(() => clauseCollection.Add("And", A <Clause> .Ignored))
.WhenArgumentsMatch(x =>
{
return
(x.Get <string>(0) == "Or" &&
x.Get <Clause>(1).Sql() == "1=1");
}).MustHaveHappened();
}
public Select CreateSelect(PropertyQuery query, bool getCount = false)
{
Select <DataModel.VProperty> select = _modelDataProvider.NewSelect();
IClauseCollection <DataModel.VProperty> where = select
.Where(x => x.Type, (byte)query.ListingType)
.And(x => x.PropertyType, query.PropertyType, x => x != PropertyType.All)
.And(x => x.BedroomCount, SqlOperator.GreaterThanOrEqual, query.MinBedrooms, x => x.HasValue)
.And(x => x.BedroomCount, SqlOperator.LessThanOrEqual, query.MaxBedrooms, x => x.HasValue)
.And(x => x.Cost, SqlOperator.GreaterThanOrEqual, query.MinCost, x => x.HasValue)
.And(x => x.Cost, SqlOperator.LessThanOrEqual, query.MaxCost, x => x.HasValue)
.And(x => x.PostCode, SqlOperator.Like, query.PostCode, x => !string.IsNullOrEmpty(x))
.And(x => x.IsCommercial, query.IsCommercial, x => x.GetValueOrDefault(false));
if (!query.Status.HasFlag(PropertyStatus.Archived))
{
where.And(x => x.Status, SqlOperator.NotEqual, PropertyStatus.Archived);
}
where.And(x => x.Status, PropertyStatus.Available, x => query.ExcludeUnavailable);
if (!string.IsNullOrEmpty(query.Keywords))
{
where.And()
.Or(x => x.Address01, SqlOperator.Like, query.Keywords)
.Or(x => x.Address02, SqlOperator.Like, query.Keywords)
.Or(x => x.PostCode, SqlOperator.Like, query.Keywords)
.Or(x => x.Title, SqlOperator.Like, query.Keywords);
}
select.IncludeCount(getCount);
select.Paging(query.Page, query.MaxPerPage);
return(select);
}
public static IClauseCollection <T> OrIsNull <T, TProp>(this IClauseCollection <T> clauseCollection, Expression <Func <T, TProp> > property)
{
clauseCollection.Or(property.MemberName(), SqlOperator.Is, "null");
return(clauseCollection);
}
public static IClauseCollection And(this IClauseCollection clauseCollection, string column, object value)
{
return(clauseCollection.And(column, SqlOperator.Equal, value));
}
public static IClauseCollection <T> Or <T, TProp>(this IClauseCollection <T> clauseCollection, Expression <Func <T, TProp> > property, TProp value)
{
return(clauseCollection.Or(property, SqlOperator.Equal, value));
}
public static IClauseCollection Or(this IClauseCollection clauseCollection, string sql)
{
return(Add(clauseCollection, Clause.SqlOr, sql));
}
public static void Add(this IClauseCollection clauseCollection, string column, SqlOperator sqlOperator, object value)
{
Add(clauseCollection, null, column, sqlOperator, value);
}
public static void Add(this IClauseCollection clauseCollection, string @operator, string column, SqlOperator sqlOperator, object value)
{
Clause clause = new Clause(clauseCollection.Parameters, column, sqlOperator, value);
clauseCollection.Add(@operator, clause);
}
