public Order GetOrder()
{
DBExpression _exp = Loader.BaseFactory.Instance.GetInstance <DBExpression>();
ExpressionHelper <TEntity> _expHelper = _exp.GetHelper <TEntity>();
switch (SortDirection)
{
case ListSortDirection.Ascending:
return(_expHelper.OrderAsc <TType>(Property));
case ListSortDirection.Descending:
return(_expHelper.OrderDes <TType>(Property));
}
return(null);
}
public Expression Expression()
{
DBExpression _exp = Loader.BaseFactory.Instance.GetInstance <DBExpression>();
ExpressionHelper <TEntity> _expHelper = _exp.GetHelper <TEntity>();
switch (Operator)
{
case DBFilterOperator.IsLessThan:
return(_expHelper.LT(Property, Value));
case DBFilterOperator.IsLessThanOrEqualTo:
return(_expHelper.Lte(Property, Value));
case DBFilterOperator.IsEqualTo:
return(_expHelper.Eq(Property, Value));
case DBFilterOperator.IsNotEqualTo:
return(!_expHelper.Eq(Property, Value));
case DBFilterOperator.IsGreaterThanOrEqualTo:
return(_expHelper.Gre(Property, Value));
case DBFilterOperator.IsGreaterThan:
return(_expHelper.Gr(Property, Value));
case DBFilterOperator.StartsWith:
return(_expHelper.Like(Property, Value + "%"));
case DBFilterOperator.EndsWith:
return(_expHelper.Like(Property, "%" + Value));
case DBFilterOperator.Contains:
return(_expHelper.Like(Property, "%" + Value + "%"));
case DBFilterOperator.IsContainedIn:
return(_expHelper.In(Property, Value));
}
return(null);
}
/// <summary>
/// Loads and compile Parsing Expressions and String Replacements
/// </summary>
/// <returns></returns>
public static bool reLoadExpressions()
{
// build a list of all the regular expressions to apply
bool error = false;
try
{
logger.Info("Compiling Parsing Expressions");
sExpressions.Clear();
regularExpressions.Clear();
replacementRegexAfter.Clear();
replacementRegexBefore.Clear();
tags.Clear();
List <DBExpression> expressions = DBExpression.GetAll();
// Bit of a frig here, for some reason the expression gets reversed during the
// save process - check here and reverse if that is the case
if (expressions[0].ID != 1)
{
expressions.Reverse();
}
foreach (DBExpression expression in expressions)
{
if (expression.Expression == mvCentralCore.albumRegex && mvCentralCore.Settings.IgnoreFoldersWhenParsing)
{
expression.Enabled = false;
expression.Commit();
}
if (expression.Expression == mvCentralCore.albumRegex && !mvCentralCore.Settings.IgnoreFoldersWhenParsing)
{
expression.Enabled = true;
expression.Commit();
}
if (expression.Enabled)
{
String sExpression = String.Empty;
switch (expression.Type)
{
case DBExpression.cType_Simple:
sExpression = ConvertSimpleExpressionToRegEx(expression.Expression);
break;
case DBExpression.cType_Regexp:
sExpression = expression.Expression;
break;
}
sExpression = sExpression.ToLower();
sExpression = sExpression.Replace("<artist>", "<" + MusicVideoImporter.cArtist + ">");
sExpression = sExpression.Replace("<album>", "<" + MusicVideoImporter.cAlbum + ">");
sExpression = sExpression.Replace("<track>", "<" + MusicVideoImporter.cTrack + ">");
// we precompile the expressions here which is faster in the end
try
{
regularExpressions.Add(new Regex(sExpression, RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture | RegexOptions.Compiled));
sExpressions.Add(sExpression);
}
catch (Exception e)
{
// wrong regex
logger.Info("Cannot use the following Expression: " + e.Message);
}
}
}
logger.Info("Finished Compiling Parsing Expressions, found " + sExpressions.Count.ToString() + " valid expressions");
}
catch (Exception ex)
{
logger.Info("Error loading Parsing Expressions: " + ex.Message);
error = true;
}
//
// now go for the replacements
//
try
{
logger.Info("Compiling Replacement Expressions");
foreach (DBReplacements replacement in DBReplacements.GetAll())
{
try
{
if (replacement.Enabled)
{
String searchString = replacement.ToReplace;
searchString = searchString.Replace("<space>", " ");
string regexSearchString = searchString;
if (!replacement.IsRegex)
{
regexSearchString = Regex.Escape(searchString);
}
String replaceString = replacement.With;
replaceString = replaceString.Replace("<space>", " ").Replace("<empty>", string.Empty);
var replaceRegex = new Regex(regexSearchString, RegexOptions.Compiled | RegexOptions.IgnoreCase);
if (replacement.Before)
{
replacementRegexBefore.Add(replaceRegex, replaceString);
}
else
{
replacementRegexAfter.Add(replaceRegex, replaceString);
}
if (replacement.TagEnabled)
{
tags.Add(searchString);
}
}
}
catch (Exception e)
{
logger.ErrorException("Cannot use the following Expression: ", e);
}
}
return(error);
}
catch (Exception ex)
{
logger.ErrorException("Error loading String Replacements: ", ex);
return(false);
}
}
