private void browser_Navigating(object sender, WebBrowserNavigatingEventArgs e)
{
//e.Cancel = true;
string urlString = e.Url.ToString();
int i = urlString.IndexOf("#link");
if (i >= 0)
{
string link = urlString.Substring(i);
Console.WriteLine(link);
e.Cancel = true;
RuleValue rv = links[link];
DPModifyControl modifyControl = rv.DataProvider.GetModifyUserInterface();
var form = DPControlContainerModifyForm.CreateForm(modifyControl);
WinForms.SetFormRelativePosition(form, this, FormRelativePosition.LEFT);
DialogResult dialogResult = form.ShowDialog(this);
if (dialogResult == DialogResult.OK)
{
rv.DataProvider.UpdateProviderFromPropertyValues();
DisplayTradeDescription();
}
}
}
public bool CompareTo(RuleValue value1, RuleValue value2)
{
if (value1.IsNumeric && value2.IsNumeric)
{
return((double)value1 < (double)value2);
}
else if (value1.IsText && value2.IsText)
{
return(value1.ToString().CompareTo(value2.ToString()) < 0);
}
else if (value1.IsTime && value2.IsTime)
{
return(((DateTime)value1).CompareTo((DateTime)value2) < 0);
}
else if (value1.IsTimeSpan && value2.IsTimeSpan)
{
TimeSpan ts1 = (TimeSpan)value1;
TimeSpan ts2 = (TimeSpan)value2;
return(ts1.CompareTo(ts2) < 0);
}
else
{
throw new ArgumentException("CompareTo does not work with the value types provided.");
}
}
public static TradeRule LoadRule(string ruleFileName)
{
TradeRule rule = null;
try
{
XmlSaveRule xsr = (XmlSaveRule)EZAPI.Toolbox.Serialization.Xml.Deserialize(typeof(XmlSaveRule), ruleFileName);
rule = new TradeRule(xsr.Name, xsr.RuleCombination, xsr.RuleType);
rule.Active = xsr.Active;
foreach (var xsrc in xsr.RuleConditions)
{
IDataProvider dataProvider1 = MonkeyFactory.CreateDataProviderInstance(xsrc.Value1.Name);
IDataProvider dataProvider2 = MonkeyFactory.CreateDataProviderInstance(xsrc.Value2.Name);
dataProvider1.SaveData = xsrc.Value1;
dataProvider2.SaveData = xsrc.Value2;
RuleValue value1 = new RuleValue(dataProvider1);
RuleValue value2 = new RuleValue(dataProvider2);
IRuleComparison compare = MonkeyFactory.CreateRuleComparisonInstance(xsrc.Compare.Name);
RuleCondition condition = new RuleCondition(value1, compare, value2);
rule.AddRuleCondition(condition);
}
}
catch (Exception ex)
{
// If there is a problem loading the rule, then we return null (not some partial rule).
rule = null;
ExceptionHandler.TraceException(ex);
}
return(rule);
}
public double?GetNumericValue(string name, SearchOptions searchOptions)
{
var v = new RuleValue(GetValue(name, searchOptions));
double?nv;
v.TryGetNumericValue(out nv);
return(nv);
}
public List <RuleValue> GetDiscount(QuoteParameter quoteParameter)
{
//decimal totalDiscount = 0;
var quoteItems = new List <RuleValue>();
var employeeQuoteItem = new RuleValue()
{
ParameterValue = quoteParameter.EmployeeName,
Description = _discountName,
Cost = _baseAnnualCostPerEmployee,
DiscountAmount = 0
};
// 10% discount rule
if (quoteParameter.EmployeeName.Trim().ToLower().StartsWith("a"))
{
decimal discountAmount = _baseAnnualCostPerEmployee * _discountPercent;
//totalDiscount += discountAmount;
employeeQuoteItem.IsDiscountApplied = true;
employeeQuoteItem.DiscountAmount = discountAmount;
}
quoteItems.Add(employeeQuoteItem);
if (quoteParameter.Dependents != null)
{
foreach (string name in quoteParameter.Dependents)
{
var quoteItem = new RuleValue()
{
ParameterValue = name,
Description = _discountName,
Cost = _annualCostPerDependent,
DiscountAmount = 0
};
if (name.Trim().ToLower().StartsWith("a"))
{
decimal discountAmount = _annualCostPerDependent * _discountPercent;
//totalDiscount += discountAmount;
quoteItem.IsDiscountApplied = true;
quoteItem.DiscountAmount = discountAmount;
}
quoteItems.Add(quoteItem);
}
// var numberOfDependentsEligibleForDiscount = quoteParameter.Dependents
// .Count(name => name.Trim().ToLower().StartsWith("a"));
//
// totalDiscount += (_annualCostPerDependent * _discountPercent) * (decimal) numberOfDependentsEligibleForDiscount;
}
return(quoteItems);
}
public bool IsValid(RuleValue value1, RuleValue value2)
{
bool result = false;
if (value1.IsTime && value2.IsTimeRange)
{
result = true;
}
return(result);
}
public bool CompareTo(RuleValue value1, RuleValue value2)
{
if (value1.IsTime && value2.IsTimeRange)
{
ITimeRange tr = value2.Value as ITimeRange;
DateTime dt = Convert.ToDateTime(value1.Value);
SimpleTime st = SimpleTime.FromDateTime(dt);
return(tr.ContainsTime(st));
}
else
{
throw new ArgumentException("CompareTo does not work with the value types provided.");
}
}
public bool TryGetValue(string name, SearchOptions searchOptions, out RuleValue value, out string error)
{
error = "";
try
{
value = new RuleValue(GetAttributeValue(name, searchOptions));
}
catch (Exception e)
{
value = null;
error = e.Message;
return(false);
}
return(true);
}
public RuleConditionForm(RuleCondition condition) : this()
{
this.condition = condition;
RuleValue v1 = condition.Value1;
RuleValue v2 = condition.Value2;
IRuleComparison compare = condition.Comparison;
throw new NotImplementedException();
/*if (v1.IsNumeric)
* {
* comboValue1.SelectedItem = "USER_NUMBER";
* numericValue1.Value = v1;
* }
* else if (v1.ValueType == RuleValueType.TEXT)
* {
* comboValue1.SelectedItem = "USER_TEXT";
* textValue1.Text = v1;
* }
*
* if (v2.IsNumeric)
* {
* comboValue2.SelectedItem = "USER_NUMBER";
* numericValue2.Value = v2;
* }
* else if (v2.ValueType == RuleValueType.TEXT)
* {
* comboValue2.SelectedItem = "USER_TEXT";
* textValue2.Text = v2;
* }
*
* for (int i=0; i<comboCompare.Items.Count; i++)
* {
* if (comboCompare.Items[i].ToString().StartsWith(compare.Name))
* {
* comboCompare.SelectedIndex = i;
* break;
* }
* }*/
}
public bool IsValid(RuleValue value1, RuleValue value2)
{
bool result = false;
if (value1.IsNumeric && value2.IsNumeric)
{
result = true;
}
else if (value1.IsText && value2.IsText)
{
result = true;
}
else if (value1.IsTime && value2.IsTime)
{
result = true;
}
else if (value1.IsTimeSpan && value2.IsTimeSpan)
{
result = true;
}
return(result);
}
public static FilterRule CreateFilterRule(FieldConfig parentFieldConfig, string cultureCode, string field, OperatorEnum fieldOperator, RuleValue lowerValue, RuleValue upperValue)
{
var fieldConfig = GetField(parentFieldConfig, field);
var cultureSuffix = fieldConfig != null && fieldConfig.MultiLanguage ? "." + cultureCode : string.Empty;
var indexType = GetFieldType(fieldConfig != null ? fieldConfig.IndexType : string.Empty);
if (fieldConfig == null || fieldConfig.Index == false)
{
// throw new Exception($"You want me to search in field {field} but it is not indexed. Please fix your index.json.");
}
var rule = new FilterRule()
{
Field = field + cultureSuffix,
FieldOperator = fieldOperator,
FieldType = indexType,
LowerValue = lowerValue,
UpperValue = upperValue
};
return(rule);
}
private void SolveOverlapValue(RuleSet rule, RuleValue value)
{
if (value.IsSolved())
return;
int range = (value.maxIndex - value.minIndex) + 1;
if (range < value.mValue * 2) // we have some overlap, and therefore some guaranteed squares
{
int offset = range - value.mValue;
for (int idx = offset; idx < value.mValue; ++idx)
{
if (rule.mID == RuleID.RI_ROW)
SetBoardValue(idx + value.minIndex, rule.mIndex, SquareType.ST_BLACK);
else
SetBoardValue(rule.mIndex, idx + value.minIndex, SquareType.ST_BLACK);
}
}
}
private void comboValue2_SelectedIndexChanged(object sender, EventArgs e)
{
if (settingComboValue == true)
{
return;
}
ShowTrueFalseBox(false);
string dataProviderName = comboValue2.Text;
dataProvider2 = (IDataProvider)Activator.CreateInstance(dataProviders[dataProviderName]);
txtDescription.Text = dataProvider2.Name + ": " + dataProvider2.Description;
DialogResult dialogResult = System.Windows.Forms.DialogResult.Cancel;
// See if we need to display a UI for this data provider.
if (dataProvider2.GetModifyUserInterface() != null)
{
DPModifyControl modifyControl = dataProvider2.GetModifyUserInterface();
Size controlSize = modifyControl.Size;
var dpModifyForm = new DPControlContainerModifyForm();
dpModifyForm.Width = controlSize.Width + 16;
dpModifyForm.Height = controlSize.Height + 112;
Panel panel = dpModifyForm.Controls["panelControl"] as Panel;
panel.Controls.Add(modifyControl);
modifyControl.Dock = DockStyle.Fill;
WinForms.SetFormRelativePosition(dpModifyForm, this, FormRelativePosition.RIGHT);
dialogResult = dpModifyForm.ShowDialog(this);
if (dialogResult == DialogResult.OK)
{
dataProvider2.UpdateProviderFromPropertyValues();
}
else
{
ResetComboValue2();
}
}
if (dataProvider2.GetModifyUserInterface() == null || dialogResult == System.Windows.Forms.DialogResult.OK)
{
previousComboValue2 = comboValue2.SelectedIndex;
ruleValue2 = new RuleValue(dataProvider2);
ruleValue2.ValueUpdated += ruleValue_ValueUpdated;
DPDisplayControl displayControl = ruleValue2.DataProvider.GetDisplayUserInterface();
panelValue2UI.Controls.Clear();
panelValue2UI.Controls.Add(displayControl);
displayControl.Dock = DockStyle.Fill;
dataProvider2.UpdateProviderFromPropertyValues();
if (dataProvider2.GetModifyUserInterface() == null)
{
displayControl.Cursor = Cursors.Default;
}
else
{
displayControl.Cursor = Cursors.Hand;
displayControl.Click += displayControl2_Click;
}
CheckConditionEnableTest();
}
}
public static FilterRule CreateFilterRule(FieldConfig config, string cultureCode, string field, OperatorEnum fieldOperator, RuleValue lowerValue, RuleValue upperValue)
{
var fieldConfig = GetField(config, field);
var cultureSuffix = fieldConfig != null && fieldConfig.MultiLanguage ? "." + cultureCode : string.Empty;
var indexType = GetFieldType(fieldConfig != null ? fieldConfig.IndexType : string.Empty);
var rule = new FilterRule()
{
Field = field + cultureSuffix,
FieldOperator = fieldOperator,
FieldType = indexType,
LowerValue = lowerValue,
UpperValue = upperValue
};
return(rule);
}
public bool TryGetValue(string name, SearchOptions searchOptions, out RuleValue value, out string error)
{
throw new NotImplementedException();
}
private void RedeuceValues(RuleSet rule, RuleValue value, Direction dir)
{
}
private void RedeuceValuesMinMax(RuleSet rule, RuleValue value)
{
int x, y;
//if (rule.mID == RuleID.RI_ROW)
//{
// RedeuceValues
// x = direction == Direction.RIGHT ? value.minIndex : value.maxIndex;
// y = rule.mIndex;
//}
//else
//{
// x = rule.mIndex;
// y = direction == Direction.DOWN ? value.minIndex : value.maxIndex;
//}
//int idx = GetIndex(x, y);
}
private bool BleedValue(RuleSet rule, RuleValue value, Direction direction)
{
int x, y;
if(rule.mID == RuleID.RI_ROW)
{
x = direction == Direction.RIGHT ? value.minIndex : value.maxIndex;
y = rule.mIndex;
}
else
{
x = rule.mIndex;
y = direction == Direction.DOWN ? value.minIndex : value.maxIndex;
}
int idx = GetIndex(x, y);
// Have we already found our start position?
if (mBoard[idx] == SquareType.ST_BLACK)
{
bool canContinue = false;
for (int i = 0; i < value.mValue; ++i)
{
SetBoardValue(idx, SquareType.ST_BLACK);
value.AddIndex(idx);
canContinue = ShiftIndex(ref idx, direction);
}
if (canContinue)
SetBoardValue(idx, SquareType.ST_WHITE);
value.ClampMinMax(rule.GetBleedValue(x, y), value.mValue - 1, direction);
return true;
}
bool foundPortion = false;
bool isValid = false;
for (int i = 0; i < value.mValue; ++i)
{
if (mBoard[idx] == SquareType.ST_UNKNOWN)
{
if (foundPortion) // If we already found a portion of ourselves, it's impossible for this to not be black
{
SetBoardValue(idx, SquareType.ST_BLACK);
//if (direction == Direction.RIGHT || direction == Direction.DOWN)
//value.ClampMinMax(i + (value.mValue - 1));
value.ClampMinMax(rule.GetBleedValue(x, y), i + (value.mValue - 1), direction);
//else
// value.ClampMinMax(value.maxIndex - i - (value.mValue - 1));
}
isValid = ShiftIndex(ref idx, direction);
continue;
}
if (mBoard[idx] == SquareType.ST_WHITE) // It's not possible to fit in this space. Blank it out, and move ourselves forward
{
Debug.Assert(foundPortion == false); // It shouldn't be possible to have found a portion of ourselves, and then run out of room.
int initIdx = GetIndex(x, y);
for (int j = 0; j < i; ++j)
{
SetBoardValue(initIdx, SquareType.ST_WHITE);
ShiftIndex(ref initIdx, direction);
}
if (direction == Direction.RIGHT || direction == Direction.DOWN)
value.minIndex += (i + 1);
else
value.maxIndex -= (i+1);
return BleedValue(rule, value, direction);
}
if (mBoard[idx] == SquareType.ST_BLACK)
{
if (!foundPortion) // special case. We can sometimes reduce our max range by 1 if this would make two black runs collide
{
int p;
if (GetIndexOffset(idx, value.mValue, direction, rule, out p))
{
if (mBoard[p] == SquareType.ST_BLACK)
{
value.ClampMinMax(rule.GetBleedValue(x, y), i + (value.mValue - 2), direction);
}
}
}
foundPortion = true;
//if (direction == Direction.RIGHT || direction == Direction.DOWN)
// value.SetMaxIndex(value.minIndex + i + (value.mValue - 1));
//else
// value.SetMinIndex(value.maxIndex - i - (value.mValue - 1));
value.ClampMinMax(rule.GetBleedValue(x, y), i + (value.mValue - 1), direction);
}
isValid = ShiftIndex(ref idx, direction);
}
if (isValid)
{
if (foundPortion && mBoard[idx] == SquareType.ST_WHITE)
{
SetBoardValue(x, y, SquareType.ST_BLACK);
BleedValue(rule, value, direction);
}
else if (mBoard[idx] == SquareType.ST_BLACK)
{
int initIdx = GetIndex(x, y);
while (isValid && mBoard[idx] == SquareType.ST_BLACK)
{
SetBoardValue(initIdx, SquareType.ST_WHITE);
if (direction == Direction.RIGHT || direction == Direction.DOWN)
++value.minIndex;
else
--value.maxIndex;
ShiftIndex(ref initIdx, direction);
isValid = ShiftIndex(ref idx, direction);
}
}
}
return false;
}
