/// <summary>
/// 속성 중 Attribute Node로 표현해야 한다.
/// </summary>
/// <param name="writer"></param>
public override void GenerateXmlAttributes(System.Xml.XmlWriter writer)
{
base.GenerateXmlAttributes(writer);
if (MinValue.HasValue)
{
writer.WriteAttributeString("MinValue", MinValue.ToString());
}
if (MaxValue.HasValue)
{
writer.WriteAttributeString("MaxValue", MaxValue.ToString());
}
if (Action.HasValue)
{
writer.WriteAttributeString("Action", Action.ToString());
}
if (Param.IsNotWhiteSpace())
{
writer.WriteAttributeString("Param", Param);
}
if (OccurOnce.HasValue)
{
writer.WriteAttributeString("OccurOnce", OccurOnce.ToString());
}
}
public void calculateTestEmptyList()
{
MinValue value = new MinValue();
List <double> list_values = new List <double>();
Assert.AreEqual(0, value.calculate(list_values));
}
public override void VerifySettings()
{
base.VerifySettings();
if (MinValue.CompareTo(MaxValue) >= 0)
{
throw new ArgumentException(TextResource.MinPropertyMustBeLessThenMaxProperty.FormatWith("Min", "Max"));
}
if (SelectionStart != null && SelectionEnd != null)
{
if (SelectionStart.Value.CompareTo(SelectionEnd.Value) > 0)
{
throw new ArgumentException(TextResource.FirstPropertyShouldNotBeBiggerThenSecondProperty.FormatWith("SelectionStart", "SelectionEnd"));
}
}
if (SmallStep.CompareTo(LargeStep) > 0)
{
throw new ArgumentException(TextResource.FirstPropertyShouldNotBeBiggerThenSecondProperty.FormatWith("SmallStep", "LargeStep"));
}
if (SmallStep.CompareTo((T)Convert.ChangeType(0, typeof(T))) <= 0)
{
throw new ArgumentException(TextResource.PropertyMustBeBiggerThenZero.FormatWith("SmallStep"));
}
}
/// <summary>
/// 속성들을 Xml Attribute로 생성합니다.
/// </summary>
/// <param name="writer">Attribute를 쓸 Writer</param>
public override void GenerateXmlAttributes(XmlWriter writer)
{
base.GenerateXmlAttributes(writer);
if (MinValue.HasValue)
{
writer.WriteAttributeString("minValue", MinValue.ToString());
}
if (MaxValue.HasValue)
{
writer.WriteAttributeString("maxValue", MaxValue.ToString());
}
if (Label.IsNotWhiteSpace())
{
writer.WriteAttributeString("label", Label);
}
if (Code.HasValue)
{
writer.WriteAttributeString("Code", Code.Value.ToHexString());
}
if (Alpha.HasValue)
{
writer.WriteAttributeString("Alpha", Alpha.ToString());
}
if (BorderColor.HasValue)
{
writer.WriteAttributeString("BorderColor", BorderColor.Value.ToHexString());
}
if (BorderAlpha.HasValue)
{
writer.WriteAttributeString("BorderAlpha", BorderAlpha.ToString());
}
}
/// <summary>
/// OnPreRender
/// </summary>
/// <param name="e"></param>
protected override void OnPreRender(EventArgs e)
{
if (this.Attributes["MaxValue"] == null)
{
this.Attributes.Add("MaxValue", MaxValue.ToString());
}
else
{
this.Attributes["MaxValue"] = MaxValue.ToString();
}
if (this.Attributes["MinValue"] == null)
{
this.Attributes.Add("MinValue", MinValue.ToString());
}
else
{
this.Attributes["MinValue"] = MinValue.ToString();
}
if (MaxValue < MinValue)
{
throw new ArgumentOutOfRangeException(string.Format("控件的最大值不能小于最小值，当前为：{0} - {1}", MinValue, MaxValue));
}
base.OnPreRender(e);
}
public override bool IsValid()
{
return(base.IsValid() &&
MinValue != null &&
MaxValue != null &&
MinValue.GetType() == MaxValue.GetType());
}
protected override int?GetNumericPrecision()
{
switch (PrecisionSource.GetValueOrDefault())
{
// When the precision is set to zero (0), the MoneyAttributeMetadata.Precision value is used.
case 0:
var numericPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault();
return(numericPrecision);
// When the precision is set to one (1), the Organization.PricingDecimalPrecision value is used.
case 1:
// todo need to support grabbing this info from the organization. For now just always using metadata.
var orgPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault();
return(orgPrecision);
// When the precision is set to two (2), the TransactionCurrency.CurrencyPrecision value is used.
case 2:
// todo: need to grab this information from the transaction currency itself..!
var currencyPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault();
return(currencyPrecision);
default:
var defaultPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault();
return(defaultPrecision);
}
}
/// <summary>
/// マウスクリックイベントオーバーライド
/// </summary>
protected override bool InputValue()
{
bool res = false;
KeyboardDialog kdlg = new KeyboardDialog();
kdlg.ValLower = MinValue;
kdlg.ValUpper = MaxValue;
kdlg.DispMode = KeyboardDialog.KB_MODE.NUMBER;
string strrange = MaxValue.ToString(strForm);
int digits = strrange.IndexOf('.');
kdlg.LengthInt = (digits < 0) ? strrange.Length : digits;
kdlg.LengthDec = (digits < 0) ? 0 : (strrange.Length - digits - 1);
kdlg.AllLength = strrange.Length;
string msgfmt = CommonProc.MessageText("G001");
msgfmt = msgfmt.Replace("%param", paramName);
msgfmt = msgfmt.Replace("%min", MinValue.ToString(strForm));
msgfmt = msgfmt.Replace("%max", MaxValue.ToString(strForm));
kdlg.Message_Text = msgfmt;
kdlg.InputArea = Text;
if (kdlg.ShowDialog() == DialogResult.OK)
{
Value = double.Parse(kdlg.InputArea);
res = true;
}
kdlg.Dispose();
Invalidate();
return(res);
}
protected override void Render(HtmlTextWriter writer)
{
CssClass = "form-control " + CssClass;
Attributes.Add("data-control", "Spinner");
Attributes.Add("data-control-required", campoobrigatorio.ToString());
if (MaxValue > int.MinValue)
{
Attributes.Add("data-control-maxvalue", MaxValue.ToString());
}
if (MinValue > int.MinValue)
{
Attributes.Add("data-control-minvalue", MinValue.ToString());
}
if (montagroup)
{
writer.Write(ComponentUtils.RenderControlOpen(campoobrigatorio ? "*" + Label : Label, ID, TypeControl, true, false, ToolTip));
}
base.Render(writer);
writer.Write("<div class='input-group-addon input-group-btn-vertical'><a href='javascript:void(0)' class='btn btn-default'><i class='fa fa-caret-up'></i></a><a href='javascript:void(0)' class='btn btn-default'><i class='fa fa-caret-down'></i></a></div>");
if (montagroup)
{
writer.Write(ComponentUtils.RenderControlClose("", TypeControl, true));
}
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
if (value == null)
{
return(new ValidationResult(false, "Value cannot be empty!"));
}
var stringValue = value.ToString();
try
{
if ((type == typeof(int) &&
((int)value < (int)MinValue || (int)value > (int)MaxValue))
||
(type == typeof(decimal) &&
(decimal.Parse(stringValue, cultureInfo) < decimal.Parse(MinValue.ToString(), cultureInfo) || decimal.Parse(stringValue, cultureInfo) > decimal.Parse(MaxValue.ToString(), cultureInfo)))
||
(type == typeof(double) &&
((double)value < (double)MinValue || (double)value > (double)MaxValue)))
{
return(new ValidationResult(false, "Acceptable value range: [" + MinValue + ";" + MaxValue + "]"));
}
}
catch (Exception)
{
return(new ValidationResult(false, "Value is not correct! Should be numeric value!"));
}
return(ValidationResult.ValidResult);
}
protected sealed override void Calculate()
{
switch (BaseType)
{
case BaseValueType.Int64:
case BaseValueType.Single:
case BaseValueType.Double: {
double offset = MinValue.GetDouble();
double diff = MaxValue.GetDouble() - offset;
_SetDouble(offset + (diff * _rand.NextDouble()));
break;
}
//case BaseValueType.Int64: {
// byte[] b = new byte[sizeof(long)];
// _rand.NextBytes(b);
// _SetInt64(BitConverter.ToInt64(b, 0));
// break;
//}
case BaseValueType.Int32:
default: {
_SetInt32(_rand.Next(MinValue.GetInt32(), MaxValue.GetInt32()));
break;
}
}
if (!ManualRand)
{
SetDirty();
}
}
protected override void Render(HtmlTextWriter oWriter)
{
string cssClass = " mask-" + this.NumberType.ToString().ToLowerInvariant();
this.CssClass = this.CssClass.Replace(cssClass, "") + cssClass;
this.Attributes["data-v-min"] = MinValue.ToString().Replace(".", "").Replace(",", ".");
this.Attributes["data-v-max"] = MaxValue.ToString().Replace(".", "").Replace(",", ".");
this.Attributes["data-m-dec"] = this.NumberType == numberType.Int ? "0" : "2";
this.AddTooltip(string.Concat(SetText(MinValue), " - ", SetText(MaxValue)), false);
if (ShowSlider)
{
try
{
base.Render(oWriter);
oWriter.Write(string.Format(@" <span class='sliderleft'>{4}</span> <div class='slider slider-basic' data-xmin='{0}' data-xmax='{1}' data-xstep='{2}' data-xitem='{3}'></div> <span class='sliderright'>{5}</span>",
this.MinValue.ToString().Replace(".", "").Replace(",", "."),
this.MaxValue.ToString().Replace(".", "").Replace(",", "."),
this.NumberType == numberType.Int ? SliderStep.ToString() : SliderStep.ToString().Replace(",", "."),
this.ClientID,
this.NumberType == numberType.Int ? MinValue.ToString() : MinValue.ToString("N2"),
this.NumberType == numberType.Int ? MaxValue.ToString() : MaxValue.ToString("N2")));
}
catch (Exception ex)
{
ExceptionManager.Publish(ex);
}
}
else
{
base.Render(oWriter);
}
}
public QueryContainer ToFilter(QueryContainerDescriptor <T> queryContainerDescriptor)
{
QueryContainer query = null;
if ((MinValue != null && !string.IsNullOrEmpty(MinValue?.ToString())) || (MaxValue != null && !string.IsNullOrEmpty(MaxValue.ToString())))
{
var hasMin = double.TryParse(MinValue?.ToString(), out var minValue) && minValue > 0;
var hasMax = double.TryParse(MaxValue?.ToString(), out var maxValue) && maxValue > 0;
if (hasMin && minValue > 0 && hasMax && maxValue > 0)
{
return(queryContainerDescriptor.Bool(b => b.Must(m => (m.Exists(e => e.Field(MinField)) || m.Exists(e => e.Field(MaxField))) &&
(m.Range(r => r.Field(MinField).GreaterThanOrEquals(minValue)) ||
(!m.Exists(e => e.Field(MinField)) &&
(m.Range(r => r.Field(MaxField).LessThanOrEquals(maxValue)) ||
!m.Exists(e => e.Field(MaxField))))))));
}
else
{
if (hasMin && minValue > 0)
{
return(queryContainerDescriptor.Bool(b => b.Must(m => m.Range(r => r.Field(MinField).GreaterThanOrEquals(minValue)))));
}
else if (hasMax && maxValue > 0)
{
return(queryContainerDescriptor.Bool(b => b.Must(m => m.Range(r => r.Field(MaxField).LessThanOrEquals(maxValue)))));
}
}
}
return(query);
}
/// <summary>
/// Initializes the any option children defined for the instance.
/// </summary>
protected override void InitializeOptionalChildren(ISystemContext context)
{
base.InitializeOptionalChildren(context);
if (DisplayMaxValue != null)
{
DisplayMaxValue.Initialize(context, DisplayMaxValue_InitializationString);
}
if (DisplayMinValue != null)
{
DisplayMinValue.Initialize(context, DisplayMinValue_InitializationString);
}
if (Exponent != null)
{
Exponent.Initialize(context, Exponent_InitializationString);
}
if (MaxValue != null)
{
MaxValue.Initialize(context, MaxValue_InitializationString);
}
if (MinValue != null)
{
MinValue.Initialize(context, MinValue_InitializationString);
}
if (ProcedureCommand != null)
{
ProcedureCommand.Initialize(context, ProcedureCommand_InitializationString);
}
}
public DateTimeInput()
{
Title = "日期时间域";
//禁用输入法
InputMethod.SetIsInputMethodEnabled(tb_Host, false);
DateTimeFormatString = "yyyy年MM月dd日";
MinValue = DateTime.MinValue;
MaxValue = DateTime.MaxValue;
//获得焦点时，全选
GotFocus += (sender, e) => { tb_Host.SelectAll(); };
PreviewKeyDown += DateTimeInput_PreviewKeyDown;
this.PreviewFlowLeave += (sender, e) =>
{
var text = tb_Host.Text;
if (string.IsNullOrEmpty(text))
{
return;
}
var dt = GetDateTimeByString(tb_Host.Text, DateTimeFormatString);
if (dt == null)
{
this.ToastMessage("该输入项不是有效的日期时间！");
e.Handled = true;
}
else if (dt.Value.CompareTo(MinValue) < 0 || dt.Value.CompareTo(MaxValue) > 0)
{
this.ToastMessage(string.Format("该输入项不在有效的范围内！要求的范围是[{0}]-[{1}]",
MinValue.ToString(DateTimeFormatString), MaxValue.ToString(DateTimeFormatString)));
e.Handled = true;
}
};
}
public QueryContainer ToFilter(QueryContainerDescriptor <T> queryContainerDescriptor)
{
int.TryParse(MinValue?.ToString(), out var minValue);
int.TryParse(MaxValue?.ToString(), out var maxValue);
QueryContainer query = null;
if (minValue > 0 && maxValue > 0)
{
var values = new List <int>();
for (var i = minValue; i <= maxValue; i++)
{
values.Add(i);
}
return(queryContainerDescriptor.Terms(t => t.Field(Field).Terms(values)));
}
else
{
if (minValue > 0)
{
return(queryContainerDescriptor.Term(Field, minValue));
}
else if (maxValue > 0)
{
return(queryContainerDescriptor.Term(Field, maxValue));
}
}
return(query);
}
/// <summary>
/// Converts <see cref="AnalogChannel"/> to its string format.
/// </summary>
public override string ToString()
{
// An,ch_id,ph,ccbm,uu,a,b,skew,min,max
List <string> values = new List <string>
{
Index.ToString(),
Name,
PhaseID,
CircuitComponent,
Units,
Multiplier.ToString(CultureInfo.InvariantCulture),
Adder.ToString(CultureInfo.InvariantCulture),
Skew.ToString(CultureInfo.InvariantCulture),
MinValue.ToString(CultureInfo.InvariantCulture),
MaxValue.ToString(CultureInfo.InvariantCulture)
};
// ...,primary,secondary,PS
if (m_version >= 1999)
{
values.Add(PrimaryRatio.ToString(CultureInfo.InvariantCulture));
values.Add(SecondaryRatio.ToString(CultureInfo.InvariantCulture));
values.Add(ScalingIdentifier.ToString());
}
return(string.Join(",", values));
}
public override int GetHashCode()
{
var hashCode = -2125747154;
hashCode = hashCode * -1521134295 + Uid.GetHashCode();
hashCode = hashCode * -1521134295 + Ifnr.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Text);
hashCode = hashCode * -1521134295 + MinValue.GetHashCode();
hashCode = hashCode * -1521134295 + MaxValue.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Datatype);
hashCode = hashCode * -1521134295 + Group.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Modify);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Visible);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(FunctionPointer);
hashCode = hashCode * -1521134295 + PropertyBitMask.GetHashCode();
hashCode = hashCode * -1521134295 + ParentUserDirCode.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <ComboBoxInput> .Default.GetHashCode(ComboBox);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(TextBox);
return(hashCode);
}
int ParseValue(string str)
{
Debug.Assert(str != null);
if (str.Length == 0)
{
throw new CrontabException("A crontab field value cannot be empty.");
}
var firstChar = str[0];
if (firstChar >= '0' && firstChar <= '9')
{
return(int.Parse(str, CultureInfo.InvariantCulture));
}
if (_names == null)
{
throw new CrontabException(string.Format(
"'{0}' is not a valid [{3}] crontab field value. It must be a numeric value between {1} and {2} (all inclusive).",
str, MinValue.ToString(), MaxValue.ToString(), Kind.ToString()));
}
for (var i = 0; i < _names.Length; i++)
{
if (Comparer.IsPrefix(_names[i], str, CompareOptions.IgnoreCase))
{
return(i + MinValue);
}
}
var names = string.Join(", ", _names);
throw new CrontabException($"'{str}' is not a known value name. Use one of the following: {names}.");
}
public void calculateTestEmptystringArray()
{
MinValue value = new MinValue();
string[] values = new string[10];
Assert.AreEqual(0, value.calculate(values, 2));
}
private void DatePicker_LostFocus(object sender, RoutedEventArgs e)
{
if (MinValue.CompareTo(MaxValue) >= 0)
{
MinValue = MaxValue.AddDays(-1.0);
MinValDatePicker.SelectedDate = MinValue;
}
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Переустановка текста
/// </summary>
//---------------------------------------------------------------------------------------------------------
private void ResetText()
{
mIsDirectText = true;
TextField.Text = 0 < MinValue?MinValue.ToString() : "0";
mIsDirectText = false;
TextField.SelectAll();
}
public override void ToJSON(JObject ParentObject)
{
ParentObject[_ValueSubField.ToXmlNodeName(true)] = (!Double.IsNaN(Value)) ? Value.ToString() : string.Empty;
ParentObject["minvalue"] = MinValue.ToString();
ParentObject["maxvalue"] = MaxValue.ToString();
ParentObject["precision"] = Precision;
ParentObject["excludeRangeLimits"] = ExcludeRangeLimits;
}
public string ToRecoverable()
{
Dictionary <string, string> rec = new Dictionary <string, string>();
rec.Add(nameof(MinValue), MinValue.ToString());
rec.Add(nameof(MaxValue), MaxValue.ToString());
return(Utils.EncodeMultiple(rec));
}
/// <summary>
/// Creates the rule.
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public override RulePolicy CreateRule(object target)
{
if (!(target is IComparable))
{
throw new Exception("Cannot evaluate attribute and rule with a type that is not IComparable.");
}
Rule = new MinValue <IComparable>(RuleName, FailMessage, (IComparable)target, (IComparable)comparisonObject);
return(Rule);
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
unchecked
{
int hashCode = 17 + MaxValue.GetHashCode() ^ MinValue.GetHashCode() ^ AllowNull.GetHashCode() ^
ReadOnly.GetHashCode() + 31 * GetHashCode(PossibleValues);
return((DefaultValue == null) ? hashCode : hashCode * 32 + DefaultValue.GetHashCode());
}
}
public override void AddValidation(ClientModelValidationContext context)
{
if (MinValue != null)
{
MergeAttribute(context.Attributes, "data-val", "true");
MergeAttribute(context.Attributes, "data-val-minlength", GetErrorMessage(context));
MergeAttribute(context.Attributes, "data-val-minlength-min", MinValue.ToString());
}
}
public void calculateTestWithValuesinStringArrayWithPosOutOfRange()
{
MinValue value = new MinValue();
string[] values = new string[2];
values[0] = "sceneId";
values[1] = "10.2";
Assert.AreEqual(0, value.calculate(values, 3));
}
public void calculateTestWithValuesinStringArray()
{
MinValue value = new MinValue();
string[] values = new string[2];
values[0] = "10.2";
values[1] = "SceneId";
Assert.AreEqual(10.2, value.calculate(values, 0));
}
/// <summary>
/// Creates the rule.
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public override RulePolicy CreateRule(object target)
{
if(!(target is IComparable))
{
throw new Exception("Cannot evaluate attribute and rule with a type that is not IComparable.");
}
Rule = new MinValue<IComparable>(RuleName, FailMessage, (IComparable)target, (IComparable)comparisonObject);
return Rule;
}
/// <summary>
/// Perrform type-specific validation
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
protected override DateTime?OnValidate(object value)
{
DateTime?t = Convert(value);
if (MinValue.CompareTo(t) > 0 || MaxValue.CompareTo(t) < 0)
{
throw new PropertyValidationException("minmax");
}
return(t);
}
public void MinValueRuleDateTimeIsValid()
{
DateTime target = DateTime.Now.AddDays(1);
DateTime comparisonObject = DateTime.Now;
MinValue<DateTime> rule = new MinValue<DateTime>("MinValue", "The target value is not valid. Cannot be less than comparison value.", target, comparisonObject);
Result result = rule.Execute();
Assert.IsTrue(result.IsValid);
Assert.IsNotNullOrEmpty(result.Message);
Assert.IsNotNull(result.RulePolicy);
Assert.AreEqual(result.RulePolicy.Severity, Severity.Exception);
}
public void MinValueRuleIntIsValid()
{
int target = 10;
int comparisonObject = 1;
MinValue<int> rule = new MinValue<int>("MinValue", "The target value is not valid. Cannot be less than comparison value.", target, comparisonObject);
Result result = rule.Execute();
Assert.IsTrue(result.IsValid);
Assert.IsNotNullOrEmpty(result.Message);
Assert.IsNotNull(result.RulePolicy);
Assert.AreEqual(result.RulePolicy.Severity, Severity.Exception);
}
