public void Prepare()
{
_techLevelText = Label;
_techLevelOptions = Data.TechLevels.Values.Where(i => i != TechLevel.Undefined)
.Select(
i => new FloatMenuOption(
$"TechLevel_{i}".TranslateSimple(),
() =>
{
_techLevel = i;
Dirty.Set(true);
}
)
)
.ToList();
_comparisonOptions = Data.ComparisonTypes.Values.Select(
i => new FloatMenuOption(
i.AsOperator(),
() =>
{
_comparison = i;
Dirty.Set(true);
}
)
)
.ToList();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Builds a match criteria that will match on an empty object.
/// </summary>
/// ------------------------------------------------------------------------------------
public void SetEmptyObjectMatchCriteria()
{
m_comparisonType = ComparisonTypes.kEmpty;
m_matchValue = 0;
m_matchSubitems = false;
m_matchEmpty = true;
SaveObjectMatchCriteria(null);
}
public static ComparisonReportObjects ReportObjects(Instance a, Instance b, ComparisonTypes comparisons, BasicComparisons basicSelection)
{
var report = new ComparisonReportObjects();
if (comparisons.HasFlag(ComparisonTypes.Basic))
{
report.Basics = BasicComparison(a, b, basicSelection).ToList();
}
if (comparisons.HasFlag(ComparisonTypes.Contexts))
{
report.Contexts = ScenarioComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.Facts))
{
report.Facts = FactComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.DomainNamespaces))
{
report.DomainNamespaces = DomainNamespaceComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.Units))
{
report.Units = UnitComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.Entity))
{
report.Entities = EntityComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.Entity))
{
report.Periods = PeriodComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.TaxonomyVersion))
{
report.TaxonomyVersions = TaxonomyVersionComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.SchemaReference))
{
report.SchemaReferences = SchemaReferenceComparison(a, b);
}
if (comparisons.HasFlag(ComparisonTypes.FilingIndicators))
{
report.FilingIndicators = FilingIndicatorComparison(a, b);
}
report.Result = GetResultForReport(report);
return(report);
}
public void Add(Func <TCalcOutput, double> property, ComparisonTypes ComparisonType, double value)
{
Lines.Add(new MeritFunctionLine <CalculationOutput>
{
property = property,
value = value,
comparisonType = ComparisonType
});
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Save this set of match criteria.
/// </summary>
/// <param name="matchVal">Match value</param>
/// <param name="fIncludeSubitems">Indicates whether to include the subitems of the
/// given <paramref name="matchVal"/> when looking for a match</param>
/// <param name="fMatchEmpty">Indicates whether an empty collection should be counted
/// as a match</param>
/// ------------------------------------------------------------------------------------
public void SetObjectMatchCriteria(ICmPossibility matchVal, bool fIncludeSubitems,
bool fMatchEmpty)
{
m_comparisonType = ComparisonTypes.kMatches;
m_matchValue = matchVal == null ? 0 : matchVal.Hvo;
m_matchSubitems = fIncludeSubitems;
m_matchEmpty = fMatchEmpty;
SaveObjectMatchCriteria(matchVal);
}
public static ComparisonReport Report(Instance a, Instance b, ComparisonTypes comparisonTypes)
{
var messages = ComparisonMethods.
Where(c => comparisonTypes.HasFlag(c.Key)).
SelectMany(c => c.Value(a, b)).
ToList();
return(new ComparisonReport(!messages.Any(), messages));
}
public static ComparisonReport Report(Instance a, Instance b, ComparisonTypes comparisonTypes, BasicComparisons basicComparisons)
{
var messages = new List <string>();
if (comparisonTypes.HasFlag(ComparisonTypes.Basic))
{
messages.AddRange(BasicComparison(a, b, basicComparisons));
}
messages.AddRange(ComparisonMethods.
Where(c => comparisonTypes.HasFlag(c.Key)).
SelectMany(c => c.Value(a, b)));
return(new ComparisonReport(!messages.Any(), messages));
}
/// <summary>
/// Registers the startup script.
/// </summary>
private void RegisterStartupScript()
{
string errorMessage;
if (!string.IsNullOrWhiteSpace(RequiredErrorMessage))
{
errorMessage = RequiredErrorMessage;
}
else if (!string.IsNullOrWhiteSpace(Label))
{
errorMessage = Label + " Is Required";
}
else
{
errorMessage = "Filter Field Is Required";
}
var comparisionTypeList = ComparisonTypes.GetFlags <Model.ComparisonType>().OrderBy(v => v)
.Select(v => new
{
Value = ( int )v,
Text = v.Humanize(LetterCasing.Title)
})
.ToList();
var script = string.Format(
@"
Rock.controls.valueFilter.initialize({{
controlId: '{0}',
required: {1},
requiredMessage: '{2}',
btnToggleOnClass: '{3}',
btnToggleOffClass: '{4}',
hideFilterMode: {5},
comparisonTypes: {6}
}});
",
this.ClientID, // {0}
this.Required.ToString().ToLower(), // {1}
errorMessage.Replace("'", "\\'"), // {2}
"btn-info", // {3}
"btn-default", // {4}
this.HideFilterMode.ToString().ToLower(), // {5}
comparisionTypeList.ToJson() // {6}
);
ScriptManager.RegisterStartupScript(this, this.GetType(), "ValueFilterInitialization_" + this.ClientID, script, true);
}
public void Prepare()
{
_weightText = "TKUtils.Fields.Weight".TranslateSimple();
_comparisonOptions = Data.ComparisonTypes.Values.Select(
i => new FloatMenuOption(
i.AsOperator(),
() =>
{
_comparison = i;
Dirty.Set(true);
}
)
)
.ToList();
}
public void Prepare()
{
_priceText = Label;
_comparisonOptions = Data.ComparisonTypes.Values.Select(
i => new FloatMenuOption(
i.AsOperator(),
() =>
{
_comparison = i;
Dirty.Set(true);
}
)
)
.ToList();
}
private void CompareValues(ref bool valid, ComparisonTypes comparison, long originalValue, long testValue)
{
bool result = true;
switch (comparison)
{
case ComparisonTypes.Equal: result = originalValue == testValue; break;
case ComparisonTypes.NotEqual: result = originalValue != testValue; break;
case ComparisonTypes.GreaterThan: result = originalValue > testValue; break;
case ComparisonTypes.LessThan: result = originalValue < testValue; break;
}
if (!result)
{
valid = false;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Parse the existing Contents to determine the object match criteria and set member
/// data needed by MatchesCriteria.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ParseObjectMatchCriteria()
{
lock (SyncRoot)
{
string criteria = Contents.Text;
m_comparisonType = ComparisonTypes.kUndefined;
m_matchValue = 0;
m_matchSubitems = criteria.IndexOf("+subitems", StringComparison.Ordinal) >= 0;
m_matchEmpty = criteria.IndexOf("Empty", StringComparison.Ordinal) >= 0;
if (criteria.IndexOf("Matches", StringComparison.Ordinal) >= 0)
{
m_comparisonType = ComparisonTypes.kMatches;
}
else if (m_matchEmpty)
{
m_comparisonType = ComparisonTypes.kEmpty;
}
Debug.Assert(m_comparisonType != ComparisonTypes.kUndefined);
m_matchValues = null;
// Check to see whether the criteria specifies a specific (default) object.
if (criteria.IndexOf(StringUtils.kChObject) >= 0)
{
ITsTextProps ttp = Contents.get_Properties(1); //assume second run
string objData = ttp.GetStrPropValue((int)FwTextPropType.ktptObjData);
if (objData[0] == (char)FwObjDataTypes.kodtNameGuidHot)
{
Guid guid = MiscUtils.GetGuidFromObjData(objData.Substring(1));
ICmPossibility poss;
ICmPossibilityRepository repo = Cache.ServiceLocator.GetInstance <ICmPossibilityRepository>();
if (repo.TryGetObject(guid, out poss))
{
m_matchValue = poss.Hvo;
}
}
InitializeMatchValuesArray();
}
}
}
private bool CompareFileCore(FileInfo firstFileInfo, FileInfo secondFileInfo)
{
if (ComparisonTypes.HasFlag(FileComparisonTypes.Hash))
{
if (!CompareByHash(firstFileInfo, secondFileInfo))
{
return(false);
}
}
if (ComparisonTypes.HasFlag(FileComparisonTypes.Size))
{
if (firstFileInfo.Length != secondFileInfo.Length)
{
return(false);
}
}
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Parse the existing Contents to determine the integer match criteria and set member
/// data needed by MatchesCriteria.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ParseIntegerMatchCriteria()
{
lock (SyncRoot)
{
m_comparisonType = ComparisonTypes.kUndefined;
string filterCellContents = Contents.Text;
int iSpace = filterCellContents.IndexOf(' ');
string strOperator = filterCellContents.Substring(0, iSpace).Trim();
string strMatchValue = filterCellContents.Substring(iSpace).Trim();
switch (strOperator)
{
case "=":
m_comparisonType = ComparisonTypes.kEquals;
break;
case ">=":
m_comparisonType = ComparisonTypes.kGreaterThanEqual;
break;
case "<=":
m_comparisonType = ComparisonTypes.kLessThanEqual;
break;
default:
Debug.Fail("Unexpected operator!");
break;
}
if (string.IsNullOrEmpty(strMatchValue))
{
m_comparisonType = ComparisonTypes.kUndefined;
}
else
{
m_matchValue = Int32.Parse(strMatchValue);
}
}
}
public static string AsOperator(this ComparisonTypes type)
{
switch (type)
{
case ComparisonTypes.Greater:
return(">");
case ComparisonTypes.Equal:
return("==");
case ComparisonTypes.Less:
return("<");
case ComparisonTypes.GreaterEqual:
return(">=");
case ComparisonTypes.LessEqual:
return("<=");
default:
return(null);
}
}
public void CompareValues(ref bool valid, ComparisonTypes comparison, long[] originalValues, long testValue, bool all)
{
bool result = all;
bool result2 = false;
if (originalValues.Length > 0)
{
foreach (long originalValue in originalValues)
{
switch (comparison)
{
case ComparisonTypes.Equal: result2 = originalValue == testValue; break;
case ComparisonTypes.NotEqual: result2 = originalValue != testValue; break;
case ComparisonTypes.GreaterThan: result2 = originalValue > testValue; break;
case ComparisonTypes.LessThan: result2 = originalValue < testValue; break;
}
if (result2 && !all)
{
result = true;
break;
}
else if (!result2 && all)
{
result = false;
break;
}
}
}
if (!result)
{
valid = false;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Builds a match criteria that will match on an empty object.
/// </summary>
/// ------------------------------------------------------------------------------------
public void SetEmptyObjectMatchCriteria()
{
m_comparisonType = ComparisonTypes.kEmpty;
m_matchValue = 0;
m_matchSubitems = false;
m_matchEmpty = true;
SaveObjectMatchCriteria(null);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Parse the existing Contents to determine the integer match criteria and set member
/// data needed by MatchesCriteria.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ParseIntegerMatchCriteria()
{
lock (SyncRoot)
{
m_comparisonType = ComparisonTypes.kUndefined;
string filterCellContents = Contents.Text;
int iSpace = filterCellContents.IndexOf(' ');
string strOperator = filterCellContents.Substring(0, iSpace).Trim();
string strMatchValue = filterCellContents.Substring(iSpace).Trim();
switch (strOperator)
{
case "=":
m_comparisonType = ComparisonTypes.kEquals;
break;
case ">=":
m_comparisonType = ComparisonTypes.kGreaterThanEqual;
break;
case "<=":
m_comparisonType = ComparisonTypes.kLessThanEqual;
break;
default:
Debug.Fail("Unexpected operator!");
break;
}
if (string.IsNullOrEmpty(strMatchValue))
m_comparisonType = ComparisonTypes.kUndefined;
else
m_matchValue = Int32.Parse(strMatchValue);
}
}
public static ComparisonReport Report(Instance a, Instance b, ComparisonTypes comparisonTypes) => Report(a, b, comparisonTypes, BasicComparisons.All);
public static ComparisonReport Report(Stream a, Stream b, ComparisonTypes comparisonTypes) => Report(Instance.FromStream(a), Instance.FromStream(b), comparisonTypes);
public static ComparisonReport Report(string a, string b, ComparisonTypes comparisonTypes) => Report(Instance.FromFile(a), Instance.FromFile(b), comparisonTypes);
/// ------------------------------------------------------------------------------------
/// <summary>
/// Parse the existing Contents to determine the object match criteria and set member
/// data needed by MatchesCriteria.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ParseObjectMatchCriteria()
{
lock (SyncRoot)
{
string criteria = Contents.Text;
m_comparisonType = ComparisonTypes.kUndefined;
m_matchValue = 0;
m_matchSubitems = criteria.IndexOf("+subitems") >= 0;
m_matchEmpty = criteria.IndexOf("Empty") >= 0;
if (criteria.IndexOf("Matches") >= 0)
m_comparisonType = ComparisonTypes.kMatches;
else if (m_matchEmpty)
m_comparisonType = ComparisonTypes.kEmpty;
Debug.Assert(m_comparisonType != ComparisonTypes.kUndefined);
m_matchValues = null;
// Check to see whether the criteria specifies a specific (default) object.
if (criteria.IndexOf(StringUtils.kChObject) >= 0)
{
ITsTextProps ttp = Contents.get_Properties(1); //assume second run
string objData = ttp.GetStrPropValue((int)FwTextPropType.ktptObjData);
if (objData[0] == (char)FwObjDataTypes.kodtNameGuidHot)
{
Guid guid = MiscUtils.GetGuidFromObjData(objData.Substring(1));
ICmPossibility poss;
ICmPossibilityRepository repo = Cache.ServiceLocator.GetInstance<ICmPossibilityRepository>();
if (repo.TryGetObject(guid, out poss))
m_matchValue = poss.Hvo;
}
InitializeMatchValuesArray();
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Save this set of match criteria.
/// </summary>
/// <param name="comparisonType">Type of camparison</param>
/// <param name="min">Minimum (or only) match value</param>
/// ------------------------------------------------------------------------------------
public void SetIntegerMatchCriteria(ComparisonTypes comparisonType, int min)
{
m_comparisonType = comparisonType;
m_matchValue = min;
SaveIntegerMatchCriteria();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Save this set of match criteria.
/// </summary>
/// <param name="comparisonType">Type of camparison</param>
/// <param name="min">Minimum (or only) match value</param>
/// ------------------------------------------------------------------------------------
public void SetIntegerMatchCriteria(ComparisonTypes comparisonType, int min)
{
m_comparisonType = comparisonType;
m_matchValue = min;
SaveIntegerMatchCriteria();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Save this set of match criteria.
/// </summary>
/// <param name="matchVal">Match value</param>
/// <param name="fIncludeSubitems">Indicates whether to include the subitems of the
/// given <paramref name="matchVal"/> when looking for a match</param>
/// <param name="fMatchEmpty">Indicates whether an empty collection should be counted
/// as a match</param>
/// ------------------------------------------------------------------------------------
public void SetObjectMatchCriteria(ICmPossibility matchVal, bool fIncludeSubitems,
bool fMatchEmpty)
{
m_comparisonType = ComparisonTypes.kMatches;
m_matchValue = matchVal == null ? 0 : matchVal.Hvo;
m_matchSubitems = fIncludeSubitems;
m_matchEmpty = fMatchEmpty;
SaveObjectMatchCriteria(matchVal);
}