public static void WithRetry([NotNull] Action action, int retries = 1, int milliSecondTimeBetweenExecutions = 0, CancellationToken token = default(CancellationToken))
{
if (retries < 1)
{
throw new ArgumentOutOfRangeException(nameof(retries));
}
int remaining = retries + 1;
while (!token.IsCancellationRequested)
{
try
{
action();
}
catch
{
remaining--;
if (remaining == 0)
{
throw;
}
if (milliSecondTimeBetweenExecutions > 0)
{
TimeSpanHelper.WasteTime(milliSecondTimeBetweenExecutions, token);
}
}
}
}
public ActionResult Edit(Guid?id)
{
var model = new EditModel()
{
ModalMode = Request.IsAjaxRequest()
};
if (id.HasValue)
{
var metricType = GetMetricTypeById(id.Value);
model.Id = metricType.Id;
model.SystemName = metricType.SystemName;
model.DisplayName = metricType.DisplayName;
model.NoSignalColor = ColorStatusSelectorValue.FromColor(metricType.NoSignalColor);
model.ActualTime = TimeSpanHelper.FromSeconds(metricType.ActualTimeSecs);
model.ConditionRed = metricType.ConditionAlarm;
model.ConditionYellow = metricType.ConditionWarning;
model.ConditionGreen = metricType.ConditionSuccess;
model.ElseColor = ColorStatusSelectorValue.FromColor(metricType.ConditionElseColor);
}
else
{
// значения по умолчанию
model.NoSignalColor = new ColorStatusSelectorValue()
{
RedChecked = true
};
model.ElseColor = new ColorStatusSelectorValue()
{
RedChecked = true
};
}
return(View(model));
}
public bool Send([NotNull] string value)
{
ThrowIfDisposed();
if (!IsConnected)
{
throw new NotConnectedException();
}
if (value.Length == 0)
{
return(false);
}
TimeSpan dif = _lastSent.Elapsed();
if (dif < __timeBetweenActions)
{
TimeSpanHelper.WasteTime(dif);
}
int s = _client.Send(Encoding.GetBytes($"{value}\r\n\r\n"));
_lastSent = DateTime.Now;
if (__timeBetweenActions > TimeSpan.Zero)
{
TimeSpanHelper.WasteTime(__timeBetweenActions);
}
return(s > 0);
}
private void snapshotsTextBox_Validating(object sender, CancelEventArgs e)
{
if (SuppressEvents)
{
return;
}
e.Cancel = false;
errorProvider.SetError(snapshotsTextBox, null);
var snapshotTimes = new ObservableList <TimeSpan>();
var matches = Regex.Matches(snapshotsTextBox.Text, @"(\d+[ ;,\t]*\w+)");
foreach (Match m in matches)
{
TimeSpan value;
if (!TimeSpanHelper.TryGetFromNaturalFormat(m.Value, out value))
{
e.Cancel = !snapshotsTextBox.ReadOnly && snapshotsTextBox.Enabled; // don't cancel an operation that cannot be edited
errorProvider.SetError(snapshotsTextBox, "Error parsing " + m.Value + ", please provide a valid time span, e.g. 20 seconds ; 45s ; 4min ; 1h ; 3 hours ; 2 days ; 4d");
return;
}
else
{
snapshotTimes.Add(value);
}
}
Content.SnapshotTimes = snapshotTimes;
}
private void OnEnter(object sender, EventArgs e)
{
var context = ((HttpApplication)sender).Context;
if (context.Error != null ||
context.CurrentHandler == null ||
context.CurrentHandler is DefaultHttpHandler)
{
return;
}
var cache = new WebCache(context.Cache);
var request = context.Request;
foreach (var ip in request.UserHosts())
{
var key = KeyPrefix + ip;
if (cache.Increment(key, ThrottlePeriod) >= RateQuota)
{
if (NoExceptionPathRegex == null ||
!NoExceptionPathRegex.IsMatch(request.RawUrl))
{
throw new LimitExceededException(string.Format(CultureInfo.InvariantCulture,
"The maximum quota for incoming requests ({0} queries per {1}) has been exceeded.",
RateQuota,
TimeSpanHelper.ToLongTimeString(ThrottlePeriod).ToLowerInvariant()));
}
}
}
}
public UnitTest CreateEf()
{
return(new UnitTest()
{
Id = Id,
ErrorColor = ErrorColor,
Enable = Enable,
DisplayName = DisplayName,
DisableToDate = DisableToDate,
DisableComment = DisableComment,
CreateDate = CreateDate,
ComponentId = ComponentId,
IsDeleted = IsDeleted,
NextExecutionDate = NextDate,
ParentEnable = ParentEnable,
PeriodSeconds = PeriodSeconds,
SimpleMode = SimpleMode,
StatusDataId = StatusDataId,
SystemName = SystemName,
TypeId = TypeId,
NoSignalColor = NoSignalColor,
ActualTimeSecs = TimeSpanHelper.GetSeconds(ActualTime),
LastExecutionDate = LastExecutionDate
});
}
public void Load(Guid?id, Guid?componentId)
{
if (id.HasValue)
{
var test = GetUnitTest(id.Value);
CheckName = test.DisplayName;
ComponentId = test.ComponentId;
Period = TimeSpan.FromSeconds(test.PeriodSeconds ?? 0);
ActualTime = TimeSpanHelper.FromSeconds(test.ActualTimeSecs);
NoSignalColor = ColorStatusSelectorValue.FromColor(test.NoSignalColor);
ErrorColor = ColorStatusSelectorValue.FromUnitTestResultStatus(test.ErrorColor);
if (ErrorColor.NotChecked)
{
ErrorColor.RedChecked = true;
}
}
else
{
Period = TimeSpan.FromMinutes(10);
ActualTime = TimeSpan.FromMinutes(20);
ComponentId = componentId;
CheckName = DefaultCheckName;
ErrorColor = ColorStatusSelectorValue.FromUnitTestResultStatus(UnitTestResult.Alarm);
NoSignalColor = ColorStatusSelectorValue.FromUnitTestResultStatus(UnitTestResult.Alarm);
}
}
public void SetTodayTest()
{
TimeSpan _actual = TimeSpanHelper.ParseTimeString("12:12:00").SetToday();
TimeSpan _expected = new TimeSpan(DateTime.Now.Day, 12, 12, 0);
Assert.AreEqual(_expected, _actual);
}
public ActionResult Edit(EventTypeEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var dispatcher = GetDispatcherClient();
var data = new UpdateEventTypeRequestData()
{
EventTypeId = model.Id,
DisplayName = model.DisplayName,
SystemName = model.SystemName,
OldVersion = model.OldVersion,
JoinIntervalSeconds = TimeSpanHelper.GetSeconds(model.JoinInterval),
ImportanceForOld = model.ImportanceForOld,
ImportanceForNew = model.ImportanceForNew,
UpdateActualEvents = true
};
var response = dispatcher.UpdateEventType(CurrentUser.AccountId, data);
response.Check();
this.SetTempMessage(TempMessageType.Success, "Тип события сохранён");
return(RedirectToAction("Show", new { id = model.Id }));
}
public void Select(TimeSpan begin, TimeSpan end)
{
DMSentence first = null;
DMSentence last = null;
foreach (var sentence in this.Dictation.Sentences)
{
if (TimeSpanHelper.Intersect(begin, end, sentence.BeginTime, sentence.EndTime))
{
if (first == null)
{
first = sentence;
}
last = sentence;
}
else if (first != null)
{
break;
}
}
if (first != null && last != null)
{
this.SelectElement(first, last);
}
}
public static WebResponse GetResponse([NotNull] this WebRequest thisValue, IOResponseSettings settings = null)
{
if (settings == null)
{
return(thisValue.GetResponse());
}
WebResponse response = null;
int retries = 0;
int maxRetries = settings.Retries;
int timeBeforeRetries = settings.TimeBeforeRetries.TotalIntMilliseconds();
while (response == null && retries < maxRetries)
{
if (retries > 0 && timeBeforeRetries > 0)
{
TimeSpanHelper.WasteTime(timeBeforeRetries);
}
try
{
response = thisValue.GetResponse();
}
catch (Exception ex)
{
retries++;
if (retries >= maxRetries)
{
settings.OnError?.Invoke(ex);
}
}
}
return(response);
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
var valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
if (valueResult == null)
{
return(null);
}
var value = valueResult.ConvertTo(typeof(string)) as string;
if (string.IsNullOrEmpty(value))
{
return(null);
}
var controller = (ContextController)controllerContext.Controller;
try
{
return(TimeSpanHelper.ParseHtml(value));
}
catch (Exception)
{
controller.ModelState.AddModelError(bindingContext.ModelName, "Неверный формат");
controller.ModelState.SetModelValue(bindingContext.ModelName, valueResult);
return(null);
}
}
public ActionResult Edit(UnitTestEditModel model)
{
model.UnitTest = GetUnitTestById(model.Id);
if (!ModelState.IsValid)
{
View(model);
}
var updateData = new UpdateUnitTestRequestData()
{
NoSignalColor = model.NoSignalColor.GetSelectedOne(),
ActualTime = TimeSpanHelper.GetSeconds(model.ActualTime),
DisplayName = model.DisplayName,
ComponentId = model.ComponentId,
PeriodSeconds = model.PeriodSeconds,
UnitTestId = model.Id,
SystemName = model.UnitTest.SystemName
};
var dispatcher = GetDispatcherClient();
var response = dispatcher.UpdateUnitTest(CurrentUser.AccountId, updateData);
if (response.Success)
{
return(RedirectToAction("ResultDetails", new { id = model.Id }));
}
SetCommonError(response.ErrorMessage);
return(View(model));
}
public static TResult WithRetry <TResult>([NotNull] Func <TResult> func, int retries = 1, int milliSecondTimeBetweenExecutions = 0, CancellationToken token = default(CancellationToken))
{
if (retries < 1)
{
throw new ArgumentOutOfRangeException(nameof(retries));
}
int remaining = retries + 1;
TResult result = default(TResult);
while (!token.IsCancellationRequested)
{
try
{
result = func();
}
catch
{
remaining--;
if (remaining == 0)
{
throw;
}
if (milliSecondTimeBetweenExecutions > 0)
{
TimeSpanHelper.WasteTime(milliSecondTimeBetweenExecutions, token);
}
}
}
return(result);
}
public IMetricTypeCacheReadObject CreateMetricType(Guid accountId, CreateMetricTypeRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (string.IsNullOrWhiteSpace(data.SystemName))
{
throw new UserFriendlyException("Не укзан SystemName");
}
if (string.IsNullOrWhiteSpace(data.DisplayName))
{
data.DisplayName = data.SystemName;
}
var metricTypeId = AllCaches.MetricTypes.CreateMetricType(accountId, data.SystemName);
var cache = new AccountCache(accountId);
using (var metricType = cache.MetricTypes.Write(metricTypeId))
{
metricType.DisplayName = data.DisplayName;
metricType.ConditionRed = data.AlarmCondition;
metricType.ConditionYellow = data.WarningCondition;
metricType.ConditionGreen = data.SuccessCondition;
metricType.ElseColor = data.ElseColor;
metricType.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs);
metricType.NoSignalColor = data.NoSignalColor;
metricType.BeginSave();
metricType.WaitSaveChanges();
return(metricType);
}
}
public ActionResult Edit(Guid?id, Guid?componentId, Guid?metricTypeId)
{
var model = new EditModel()
{
ComponentId = componentId,
MetricTypeId = metricTypeId
};
if (id.HasValue)
{
var metric = GetMetricById(id.Value);
if (metric != null)
{
model.Metric = metric;
model.MetricType = metric.MetricType;
model.Id = metric.Id;
model.ComponentId = metric.ComponentId;
model.MetricTypeId = metric.MetricTypeId;
model.ConditionRed = metric.ConditionAlarm;
model.ConditionYellow = metric.ConditionWarning;
model.ConditionGreen = metric.ConditionSuccess;
model.ElseColor = ColorStatusSelectorValue.FromColor(metric.ConditionElseColor);
model.ActualTime = TimeSpanHelper.FromSeconds(metric.ActualTimeSecs);
}
}
return(View(model));
}
public static UnitTestCacheWriteObject Create(UnitTest unitTest, Guid accountId)
{
if (unitTest == null)
{
return(null);
}
return(new UnitTestCacheWriteObject()
{
Id = unitTest.Id,
AccountId = accountId,
ErrorColor = unitTest.ErrorColor,
Enable = unitTest.Enable,
DisableComment = unitTest.DisableComment,
DisableToDate = unitTest.DisableToDate,
DisplayName = unitTest.DisplayName,
CreateDate = unitTest.CreateDate,
ComponentId = unitTest.ComponentId,
IsDeleted = unitTest.IsDeleted,
NextDate = unitTest.NextExecutionDate,
ParentEnable = unitTest.ParentEnable,
PeriodSeconds = unitTest.PeriodSeconds,
SimpleMode = unitTest.SimpleMode,
StatusDataId = unitTest.StatusDataId,
SystemName = unitTest.SystemName,
TypeId = unitTest.TypeId,
NoSignalColor = unitTest.NoSignalColor,
ActualTime = TimeSpanHelper.FromSeconds(unitTest.ActualTimeSecs),
LastExecutionDate = unitTest.LastExecutionDate
});
}
protected override void UpdateBatchObject(AccountDbContext accountDbContext, UnitTestCacheWriteObject unitTest, bool useCheck)
{
if (unitTest.Response.LastSavedData == null)
{
throw new Exception("unitTest.Response.LastSavedData == null");
}
var dbEntity = unitTest.Response.LastSavedData.CreateEf();
accountDbContext.UnitTests.Attach(dbEntity);
dbEntity.IsDeleted = unitTest.IsDeleted;
dbEntity.ComponentId = unitTest.ComponentId;
dbEntity.CreateDate = unitTest.CreateDate;
dbEntity.DisplayName = unitTest.DisplayName;
dbEntity.Enable = unitTest.Enable;
dbEntity.DisableComment = unitTest.DisableComment;
dbEntity.DisableToDate = unitTest.DisableToDate;
dbEntity.ErrorColor = unitTest.ErrorColor;
dbEntity.IsDeleted = unitTest.IsDeleted;
dbEntity.NextExecutionDate = unitTest.NextDate;
dbEntity.ParentEnable = unitTest.ParentEnable;
dbEntity.PeriodSeconds = unitTest.PeriodSeconds;
dbEntity.SimpleMode = unitTest.SimpleMode;
dbEntity.StatusDataId = unitTest.StatusDataId;
dbEntity.SystemName = unitTest.SystemName;
dbEntity.NoSignalColor = unitTest.NoSignalColor;
dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(unitTest.ActualTime);
dbEntity.LastExecutionDate = unitTest.LastExecutionDate;
}
public static bool Die(this Thread thisValue)
{
if (!IsAwaitable(thisValue))
{
return(true);
}
if (IsWaiting(thisValue))
{
TimeSpanHelper.WasteTime(TimeSpanHelper.HALF);
}
if (IsStopped(thisValue))
{
return(true);
}
if (IsSuspended(thisValue))
{
Awake(thisValue);
}
try
{
thisValue.Abort();
SpinWait.SpinUntil(() => !thisValue.IsAlive);
return(true);
}
catch (ThreadAbortException)
{
return(true);
}
catch
{
return(false);
}
}
protected override void UpdateBatchObject(AccountDbContext accountDbContext, MetricTypeCacheWriteObject metricType, bool useCheck)
{
var oldMetricType = metricType.Response.LastSavedData;
if (oldMetricType == null)
{
throw new Exception("oldMetricType == null");
}
var dbEntity = oldMetricType.CreateEf();
accountDbContext.MetricTypes.Attach(dbEntity);
dbEntity.CreateDate = metricType.CreateDate;
dbEntity.IsDeleted = metricType.IsDeleted;
dbEntity.CreateDate = metricType.CreateDate;
dbEntity.SystemName = metricType.SystemName;
dbEntity.DisplayName = metricType.DisplayName;
dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(metricType.ActualTime);
dbEntity.NoSignalColor = metricType.NoSignalColor;
dbEntity.ConditionAlarm = metricType.ConditionRed;
dbEntity.ConditionWarning = metricType.ConditionYellow;
dbEntity.ConditionSuccess = metricType.ConditionGreen;
dbEntity.ConditionElseColor = metricType.ElseColor;
}
public async Task IncrementalAsyncWithoutResultTest()
{
const int RetryCount = 5;
TimeSpan retryInterval = TimeSpan.FromSeconds(1);
TimeSpan incremental = TimeSpan.FromSeconds(1);
Counter <InvalidOperationException> counter = new(RetryCount);
int retryFuncCount = 0;
int retryHandlerCount = 0;
await Retry.IncrementalAsync(
async() =>
{
retryFuncCount++;
counter.Increase();
await Task.Yield();
},
RetryCount,
exception => exception is InvalidOperationException,
(sender, e) =>
{
Assert.IsInstanceOfType(e.LastException, typeof(InvalidOperationException));
Assert.AreEqual(retryInterval + TimeSpan.FromTicks(incremental.Ticks *retryHandlerCount), e.Delay);
Assert.AreEqual(counter.Time.Count, e.CurrentRetryCount);
retryHandlerCount++;
},
retryInterval,
incremental,
false);
Assert.AreEqual(RetryCount, retryFuncCount);
Assert.AreEqual(RetryCount - 1, retryHandlerCount);
Assert.AreEqual(RetryCount, counter.Time.Count);
TimeSpan[] intervals = counter.Time.Take(counter.Time.Count - 1).Zip(counter.Time.Skip(1), (a, b) => b - a).ToArray();
Assert.AreEqual(RetryCount - 1, intervals.Length);
intervals.ForEach((interval, index) => Assert.IsTrue(TimeSpanHelper.AlmostEquals(interval.Ticks, retryInterval.Ticks + incremental.Ticks * index)));
}
public static bool Die(this Process thisValue, int delay = 0)
{
if (!IsAwaitable(thisValue))
{
return(true);
}
if (delay > 0)
{
TimeSpanHelper.WasteTime(delay);
if (!IsAwaitable(thisValue))
{
return(true);
}
}
try
{
if (!KillChildren(thisValue))
{
return(false);
}
if (!IsAwaitable(thisValue))
{
return(true);
}
thisValue.Kill();
return(true);
}
catch
{
return(false);
}
}
protected override void OnContentChanged()
{
base.OnContentChanged();
SuppressEvents = true;
try {
if (Content == null)
{
timeLimitTextBox.Text = TimeSpanHelper.FormatNatural(TimeSpan.FromSeconds(60));
snapshotsTextBox.Text = String.Empty;
storeAlgorithmInEachSnapshotCheckBox.Checked = false;
algorithmViewHost.Content = null;
snapshotsView.Content = null;
runsView.Content = null;
}
else
{
timeLimitTextBox.Text = TimeSpanHelper.FormatNatural(Content.MaximumExecutionTime);
snapshotsTextBox.Text = String.Join(" ; ", Content.SnapshotTimes.Select(x => TimeSpanHelper.FormatNatural(x, true)));
storeAlgorithmInEachSnapshotCheckBox.Checked = Content.StoreAlgorithmInEachSnapshot;
algorithmViewHost.Content = Content.Algorithm;
snapshotsView.Content = Content.Snapshots;
runsView.Content = Content.Runs;
}
} finally { SuppressEvents = false; }
}
public Metric CreateEf()
{
return(new Metric()
{
Id = Id,
Enable = Enable,
DisableComment = DisableComment,
DisableToDate = DisableToDate,
IsDeleted = IsDeleted,
ParentEnable = ParentEnable,
CreateDate = CreateDate,
Value = Value,
BeginDate = BeginDate,
ComponentId = ComponentId,
ActualDate = ActualDate,
MetricTypeId = MetricTypeId,
StatusDataId = StatusDataId,
NoSignalColor = NoSignalColor,
ConditionAlarm = ConditionRed,
ConditionWarning = ConditionYellow,
ConditionSuccess = ConditionGreen,
ConditionElseColor = ElseColor,
ActualTimeSecs = TimeSpanHelper.GetSeconds(ActualTime)
});
}
/// <summary>
/// Редактирует подписку
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Edit(Guid id)
{
var subscriptionRepository = CurrentAccountDbContext.GetSubscriptionRepository();
var subscription = subscriptionRepository.GetById(id);
var model = new SubscriptionEditModel()
{
ModalMode = Request.IsAjaxRequest(),
ReturnUrl = Url.Action("Index", new { userId = subscription.UserId }),
Id = subscription.Id,
Object = subscription.Object,
NotifyBetterStatus = subscription.NotifyBetterStatus,
UserId = subscription.UserId,
ComponentTypeId = subscription.ComponentTypeId,
ComponentId = subscription.ComponentId,
Channel = subscription.Channel,
CanShowChannel = false,
CanShowComponentType = false,
CanShowComponent = false,
IsEnabled = subscription.IsEnabled,
Color = ColorStatusSelectorValue.FromEventImportance(subscription.Importance),
MinimumDuration = TimeSpanHelper.FromSeconds(subscription.DurationMinimumInSeconds),
ResendTime = TimeSpanHelper.FromSeconds(subscription.ResendTimeInSeconds)
};
return(View(model));
}
public static MetricCacheWriteObject Create(Metric metric, Guid accountId)
{
if (metric == null)
{
return(null);
}
var cache = new MetricCacheWriteObject()
{
Id = metric.Id,
Enable = metric.Enable,
DisableToDate = metric.DisableToDate,
DisableComment = metric.DisableComment,
StatusDataId = metric.StatusDataId,
Value = metric.Value,
ParentEnable = metric.ParentEnable,
ComponentId = metric.ComponentId,
AccountId = accountId,
BeginDate = metric.BeginDate,
ActualDate = metric.ActualDate,
IsDeleted = metric.IsDeleted,
CreateDate = metric.CreateDate,
MetricTypeId = metric.MetricTypeId,
ActualTime = TimeSpanHelper.FromSeconds(metric.ActualTimeSecs),
ConditionRed = metric.ConditionAlarm,
ConditionYellow = metric.ConditionWarning,
ConditionGreen = metric.ConditionSuccess,
ElseColor = metric.ConditionElseColor,
NoSignalColor = metric.NoSignalColor
};
return(cache);
}
public ActionResult Edit(UnitTestTypeEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var repository = CurrentAccountDbContext.GetUnitTestTypeRepository();
var unitTestType = repository.GetById(model.Id);
CheckEditingPermissions(unitTestType);
var client = GetDispatcherClient();
var response = client.UpdateUnitTestType(CurrentUser.AccountId, new UpdateUnitTestTypeRequestData()
{
UnitTestTypeId = unitTestType.Id,
DisplayName = model.DisplayName,
SystemName = model.SystemName,
ActualTimeSecs = TimeSpanHelper.GetSeconds(model.ActualTime),
NoSignalColor = model.NoSignalColor.GetSelectedOne()
});
response.Check();
return(RedirectToAction("Show", new { id = model.Id }));
}
public IMetricCacheReadObject CreateMetric(Guid accountId, CreateMetricRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
var meticType = GetOrCreateType(accountId, data.MetricName);
var metricId = CreateMetric(accountId, data.ComponentId, meticType.Id);
var cache = new AccountCache(accountId);
using (var metric = cache.Metrics.Write(metricId))
{
metric.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs);
metric.NoSignalColor = data.NoSignalColor;
metric.ConditionRed = data.AlarmCondition;
metric.ConditionYellow = data.WarningCondition;
metric.ConditionGreen = data.SuccessCondition;
metric.ElseColor = data.ElseColor;
metric.BeginSave();
}
var metrikRead = cache.Metrics.Read(metricId);
metrikRead.WaitSaveChanges();
return(metrikRead);
}
private void textBox_Validating(object sender, CancelEventArgs e)
{
var textBox = (TextBox)sender;
TimeSpan value;
errorProvider.SetError(textBox, String.Empty);
if (!TimeSpanHelper.TryGetFromNaturalFormat(textBox.Text, out value))
{
errorProvider.SetError(textBox, "Please enter a valid timespan.");
e.Cancel = true;
return;
}
if (textBox == minimumTextBox)
{
Minimum = value;
}
else if (textBox == maximumTextBox)
{
Maximum = value;
}
else if (textBox == stepSizeTextBox)
{
Step = value;
}
okButton.Enabled = IsValid();
}
protected override void UpdateBatchObject(AccountDbContext accountDbContext, MetricCacheWriteObject metric, bool useCheck)
{
var oldMetric = metric.Response.LastSavedData;
if (oldMetric == null)
{
throw new Exception("oldMetric == null");
}
var dbEntity = oldMetric.CreateEf();
accountDbContext.Metrics.Attach(dbEntity);
dbEntity.ActualDate = metric.ActualDate;
dbEntity.BeginDate = metric.BeginDate;
dbEntity.ComponentId = metric.ComponentId;
dbEntity.CreateDate = metric.CreateDate;
dbEntity.Enable = metric.Enable;
dbEntity.DisableComment = metric.DisableComment;
dbEntity.DisableToDate = metric.DisableToDate;
dbEntity.IsDeleted = metric.IsDeleted;
dbEntity.MetricTypeId = metric.MetricTypeId;
dbEntity.ParentEnable = metric.ParentEnable;
dbEntity.StatusDataId = metric.StatusDataId;
dbEntity.Value = metric.Value;
dbEntity.ConditionAlarm = metric.ConditionRed;
dbEntity.ConditionWarning = metric.ConditionYellow;
dbEntity.ConditionSuccess = metric.ConditionGreen;
dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(metric.ActualTime);
dbEntity.NoSignalColor = metric.NoSignalColor;
dbEntity.ConditionElseColor = metric.ElseColor;
}
