public static CompareTypes Parse(string code)
{
CompareTypes type = CompareTypes.Undefined;
if (code.Equals("=", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.Equal;
}
else if (code.Equals(">", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.Greater;
}
else if (code.Equals(">=", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.GreaterOrEqual;
}
else if (code.Equals("<", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.Less;
}
else if (code.Equals("<=", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.LessOrEqual;
}
else if (code.Equals("in", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.In;
}
else if (code.Equals("like", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.Like;
}
else if (code.Equals("between", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.Between;
}
else if (code.Equals("is", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.Is;
}
else if (code.Equals("in", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.In;
}
else if (code.Equals("as", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.As;
}
else if (code.Equals("using", StringComparison.OrdinalIgnoreCase))
{
type = CompareTypes.Using;
}
return(type);
}
public void TestCompareTwo()
{
//Arrange
CompareTypes compareTypes = new CompareTypes();
bool expectedValue = true;
//Act
bool actual = compareTypes.CompareTwo <string>("John", "John");
//Assert
Assert.AreEqual(expectedValue, actual);
}
public Expression <Func <TTarget, bool> > CreateWhereExpression(TFilter filter)
{
var properties = typeof(TFilter).GetProperties().AsQueryable()
.Where(p => p.IsDefined(typeof(FilterPropertyAttribute)) &&
p.GetValue(filter, null) != null);
var param = Expression.Parameter(typeof(TTarget), "t");
Expression <Func <TTarget, bool> > result = null;
foreach (var property in properties)
{
var attribute = property.GetCustomAttribute <FilterPropertyAttribute>();
string propName = attribute.CompareProperty;
CompareTypes compareType = attribute.CompareType;
PropertyInfo targetProperty = typeof(TTarget).GetProperty(propName);
if (targetProperty == null)
{
throw new Exception();
}
Type type = targetProperty.PropertyType;
object value = property.GetValue(filter, null);
if (typeof(IComparable <>).MakeGenericType(value.GetType()).IsAssignableFrom(targetProperty.PropertyType))
{
var prop = GetMemberExpression(param, propName);
var constant = Expression.Constant(value);
var body = Expressions[compareType].Invoke(prop, constant);
var expression = Expression.Lambda <Func <TTarget, bool> >(body, param);
result = result == null
? expression
: result.AndAlso(expression);
}
else
{
throw new Exception();
}
}
return(result);
}
public static string Format(CompareTypes type, bool Not = false)
{
switch (type)
{
case (CompareTypes.Equal):
return(Not ? "!=" : "=");
case (CompareTypes.In):
return(Not ? "not in" : "in");
case (CompareTypes.Is):
return(Not ? "is not" : "is");
case (CompareTypes.Like):
return(Not ? "not like" : "like");
case (CompareTypes.Between):
return(Not ? "not between" : "between");
case (CompareTypes.Greater):
return(">");
case (CompareTypes.GreaterOrEqual):
return(">=");
case (CompareTypes.Less):
return("<");
case (CompareTypes.LessOrEqual):
return("<=");
case (CompareTypes.As):
return("as");
case (CompareTypes.Using):
return("using");
case (CompareTypes.Distinct):
return("distinct");
}
return("");
}
private static void WriteConditionOper(StringWriter writer, CompareTypes compareType)
{
switch (compareType)
{
case CompareTypes.Equal:
writer.Write("==");
break;
case CompareTypes.Not:
writer.Write("!");
break;
case CompareTypes.NotEqual:
writer.Write("!=");
break;
case CompareTypes.LargerThan:
writer.Write(">");
break;
case CompareTypes.LargerEqual:
writer.Write(">=");
break;
case CompareTypes.SmallerThan:
writer.Write("<");
break;
case CompareTypes.SmallEqual:
writer.Write("<=");
break;
case CompareTypes.And:
writer.Write("&&");
break;
case CompareTypes.Or:
writer.Write("||");
break;
}
}
public float ComparePrevious(CompareTypes compare)
{
var last = SavedTraining.GetTrainingHistory().FindLast(t => t.Sets.Any(s => s.Exercise.Name == this.Exercise.Name)).Sets[0];
float result = 0;
switch (compare)
{
case CompareTypes.Repeats:
result = this.Repeats - (last?.Repeats ?? 0);
break;
case CompareTypes.WeightDistance:
result = this.WeightDistance - (last?.WeightDistance ?? 0);
break;
case CompareTypes.Progress:
result = CompareProgress(last);
break;
}
return(result);
}
public QComparer(CompareTypes comp)
{
Type = comp;
}
public CompareType(CompareTypes type = CompareTypes.Undefined, bool not = false)
{
Type = type;
Not = not;
}
public CompareType(CompareTypes type, bool not = false)
{
Type = type;
Not = not;
}
public FilterPropertyAttribute(CompareTypes compareType, string compareProperty)
{
CompareType = compareType;
CompareProperty = compareProperty;
}
