public static async Task ClassInitializeAsync(TestContext context)
{
MeasurementType t1 = new MeasurementType
{
MeasurementTypeId = 1,
Name = "MyMeasurementType1"
};
MeasurementType t2 = new MeasurementType
{
MeasurementTypeId = 2,
Name = "MyMeasurementType2"
};
MeasurementType t3 = new MeasurementType
{
MeasurementTypeId = 3,
Name = "MyMeasurementType3"
};
measurementTypes.Add(t1);
measurementTypes.Add(t2);
measurementTypes.Add(t3);
foreach (MeasurementType t in measurementTypes)
{
await measurementTypeDao.InsertAsync(t);
}
}
public async override Task TestFindByIdAsync()
{
MeasurementType t = measurementTypes[0];
MeasurementType s = await measurementTypeDao.FindByIdAsync(t.MeasurementTypeId);
Assert.AreEqual(t, s);
}
public void TestMethodValues()
{
Measurement actutalMeasurement, expectedMeasurement;
DateTime timeOfSample = DateTime.Parse("2017-01-03T10:04:45");
Double valueOfSample = 35.79;
MeasurementType typeOfSample = MeasurementType.TEMP;
// Sets values.
actutalMeasurement = new Measurement()
{
MeasurementTime = new Instant()
{
Time = timeOfSample
},
MeasurementValue = valueOfSample,
Type = typeOfSample
};
expectedMeasurement = new Measurement()
{
MeasurementTime = new Instant()
{
Time = timeOfSample
},
MeasurementValue = valueOfSample,
Type = typeOfSample
};
// Checks if values are same.
Assert.AreEqual(expectedMeasurement.MeasurementTime.Time, actutalMeasurement.MeasurementTime.Time);
Assert.AreEqual(expectedMeasurement.MeasurementValue, actutalMeasurement.MeasurementValue);
Assert.AreEqual(expectedMeasurement.Type, actutalMeasurement.Type);
}
public void TestMethodToString()
{
Measurement actutalMeasurement, expectedMeasurement;
DateTime timeOfSample = DateTime.Parse("2017-01-03T10:04:45");
Double valueOfSample = 35.79;
MeasurementType typeOfSample = MeasurementType.TEMP;
// Sets values.
actutalMeasurement = new Measurement()
{
MeasurementTime = new Instant()
{
Time = timeOfSample
},
MeasurementValue = valueOfSample,
Type = typeOfSample
};
expectedMeasurement = new Measurement()
{
MeasurementTime = new Instant()
{
Time = timeOfSample
},
MeasurementValue = valueOfSample,
Type = typeOfSample
};
// Checks ToString() method returns same string.
Assert.AreEqual(expectedMeasurement.ToString(), actutalMeasurement.ToString());
}
public async Task<bool> UpdateAsync(MeasurementType measurementType)
{
return await this.template.ExecuteAsync(
@"update measurementType set name = @name where measurementTypeId = @measurementTypeId",
new Parameter("@measurementTypeId", measurementType.MeasurementTypeId),
new Parameter("@name", measurementType.Name)) == 1;
}
public async Task <bool> DeleteMeasurementTypeAsync(MeasurementType measurementType)
{
return(await _template.ExecuteAsync(
"delete from measurement_type where id = @id",
new[] { new QueryParameter("@id", measurementType.Id) }
) == 1);
}
public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
View view = inflater.Inflate(Resource.Layout.ListMeasurements, container, false);
measurementRecyclerView = view.FindViewById <RecyclerView>(Resource.Id.recyclerViewMeasurements);
measurementRecyclerView.SetLayoutManager(new LinearLayoutManager(this.Activity));
measurementRecyclerView.HasFixedSize = true;
//measurement type spinner
spinner = view.FindViewById <Spinner>(Resource.Id.measurementsListSpinner);
spinner.ItemSelected += new EventHandler <AdapterView.ItemSelectedEventArgs>(spinner_ItemSelected);
var adapter = ArrayAdapter.CreateFromResource(this.Activity, Resource.Array.measurements_array, Android.Resource.Layout.SimpleSpinnerItem);
adapter.SetDropDownViewResource(Android.Resource.Layout.SimpleSpinnerDropDownItem);
spinner.Adapter = adapter;
selected = spinner.SelectedItemPosition;
measurementType = (MeasurementType)selected;
loadData(measurementType);
var fabAdd = view.FindViewById <FloatingActionButton>(Resource.Id.fab_add);
fabAdd.Click += (s, e) =>
{
var trans = FragmentManager.BeginTransaction();
Bundle bundle = new Bundle();
bundle.PutInt("type", selected);
addMeasurementFragment.Arguments = bundle;
trans.Replace(Resource.Id.fragmentContainer, addMeasurementFragment);
//trans.AddToBackStack(null);
trans.Commit();
};
return(view);
}
public async Task<bool> InsertAsync(MeasurementType measurementType)
{
return await this.template.ExecuteAsync(
@"insert into measurementType (measurementTypeId, name) VALUES (@measurementTypeId, @name)",
new Parameter("@measurementTypeId", measurementType.MeasurementTypeId),
new Parameter("@name", measurementType.Name)) == 1;
}
public DataTable PrepareDataContainer(int electrodes, MeasurementType type)
{
if (this.dataGridView1.DataSource != null)
{
this.dataGridView1.DataSource = null;
}
this.data = new DataTable();
for (int i = 0; i < electrodes; i++)
{
this.data.Columns.Add((i + 1).ToString(), typeof(Complex));
}
object[] r = new object[electrodes];
for (int i = 0; i < electrodes; i++)
{
r[i] = Complex.Zero;
}
for (int i = 0; i < electrodes; i++)
{
this.data.Rows.Add(r);
}
this.MeasurementType = type;
this.dataGridView1.DataSource = this.data;
this.dataGridView1.Columns[0].Visible = false;
this.data.RowChanged += Data_RowChanged;
this.RecalculateColors();
return(this.data);
}
public short this[MeasurementType mt]
{
get
{
int index = _List.IndexOfKey((int)mt);
return(index >= 0 ? (short)_List.GetByIndex(index) : NoValue);
}
set
{
int index = _List.IndexOfKey((int)mt);
if (value == NoValue)
{
if (index >= 0)
{
_List.RemoveAt(index);
}
}
else
{
if (index >= 0)
{
_List.SetByIndex(index, value);
}
else
{
_List.Add((int)mt, value);
}
}
}
}
public void Units(MeasurementType type, Type unitType)
{
using TestForm tf = new TestForm();
var util = MeasurementTools.Instance.GetUtility(type);
var control = tf.AddControl <MeasurementControl.MeasurementControl>(13, 13, 300, 28);
if (control.MeasurementType != type)
{
control.MeasurementType = type;
}
control.Unit.Should().BeOfType(unitType);
if (control.MeasurementType == MeasurementType.BallisticCoefficient)
{
control.Value.Should().BeOfType(typeof(BallisticCoefficient));
}
else
{
control.Value.Should().BeOfType(typeof(Measurement <>).MakeGenericType(new Type[] { unitType }));
}
var unitPart = control.ComboBox("UnitPart");
unitPart.Should()
.HaveItemsCount(util.Units.Count)
.And
.HaveItemsCount(Enum.GetValues(unitType).Length);
foreach (MeasurementUtility.Unit unit in util.Units)
{
unitPart.Should().HaveItemMatching <MeasurementUtility.Unit>(u => u.Equals(unit));
}
}
public static MeasurementType GetMeasurementType(int measurementId)
{
MeasurementType result = new MeasurementType();
switch (measurementId)
{
case (int)MeasurementType.Gram:
result = MeasurementType.Gram;
break;
case (int)MeasurementType.Dekagram:
result = MeasurementType.Dekagram;
break;
case (int)MeasurementType.Hectogram:
result = MeasurementType.Hectogram;
break;
case (int)MeasurementType.Kilogram:
result = MeasurementType.Kilogram;
break;
case (int)MeasurementType.Ton:
result = MeasurementType.Ton;
break;
default:
break;
}
return(result);
}
public static void Main(string[] args)
{
notificationList = Notification.GetNotifications();
InitNotificationSendDateDictionary();
while (true)
{
foreach (Notification notification in notificationList)
{
double currentValue = Measurement.GetCurrentValue(MeasurementType.GetMeasurementTypes()
.Find(x => x.name == notification.measurement_type).id, notification.tunnel.id);
DateTime currentDateTime = DateTime.Now;
if (notification.condition == "<")
{
if (currentValue < notification.value)
{
if ((currentDateTime - notificationSendDate[notification.id]).TotalMinutes > notification.repeat_after)
{
string messageText = $"W tunelu {notification.tunnel.name} wartość" +
$" {notification.measurement_type} " +
$"nie może byc mniejsze od {notification.value} a jest równe = {currentValue}";
try {
new MailSending(notification.receivers).SendMessage(messageText);
} catch (Exception e) {
Console.WriteLine(e);
}
notificationSendDate[notification.id] = currentDateTime;
}
}
}
else if (notification.condition == ">")
{
if (currentValue > notification.value)
{
if ((currentDateTime - notificationSendDate[notification.id]).TotalMinutes > notification.repeat_after)
{
string messageText = $"W tunelu {notification.tunnel.name} wartość" +
$" {notification.measurement_type} " +
$"nie może byc większe od {notification.value} a jest równe = {currentValue}";
try {
new MailSending(notification.receivers).SendMessage(messageText);
} catch (Exception e) {
Console.WriteLine(e);
}
notificationSendDate[notification.id] = currentDateTime;
}
}
}
}
Thread.Sleep(30000);
}
}
/// <summary>
/// Begins the measurement using the specified measuremet annotation.
/// </summary>
/// <param name="type">The measurement annotation type.</param>
private void BeginMeasurement(MeasurementType type)
{
ImageMeasureTool tool = (ImageMeasureTool)VisualTool;
switch (type)
{
case MeasurementType.Line:
tool.BeginLineMeasurement();
break;
case MeasurementType.Lines:
tool.BeginLinesMeasurement();
break;
case MeasurementType.Ellipse:
tool.BeginEllipseMeasurement();
break;
case MeasurementType.Angle:
tool.BeginAngleMeasurement();
break;
default:
throw new NotImplementedException();
}
}
public async Task <List <WsreComponentTab> > GetComponentTabData(int wsreId, MeasurementType uom)
{
var w = await _context.WSRE.FindAsync(wsreId);
if (w == null)
{
return(null);
}
return(w.ComponentRecords.Select(c => new WsreComponentTab()
{
Id = c.Id,
Brand = c.Component.Make == null ? "Unknown" : c.Component.Make.makedesc,
Cmu = c.Cmu,
Comment = c.Comment,
Component = c.Component.LU_COMPART.LU_COMPART_TYPE.comparttype + " - " + c.Component.LU_COMPART.compartid,
Measurement = uom == MeasurementType.Milimeter ? c.Measurement : c.Measurement.MilimeterToInch(),
Photos = c.Photos.Where(p => p.Deleted == false).Select(p => new WsreComponentPhoto()
{
Id = p.Id,
ImageData = Convert.ToBase64String(p.Data),
Title = p.Title
}).ToList(),
Recommendations = c.Recommendations.Select(r => r.Recommendation.Description).ToList(),
RemainingLife = c.RemainingLife,
WornPercentage = c.WornPercentage
}).ToList());
}
protected override void Initialize(IServiceProvider provider)
{
if (ParentWorkflow.Parameters.ContainsKey("TimeMeasurement"))
{
_timeMeasurement = FromTimeParameter(ParentWorkflow.Parameters["TimeMeasurement"]);
}
else
{
_timeMeasurement = TimeMeasurement.Relative; //Assume relative.
}
if (ParentWorkflow.Parameters.ContainsKey("MeasurementType"))
{
_measurementType = FromMeasurementParameter(ParentWorkflow.Parameters["MeasurementType"]);
}
else
{
_measurementType = MeasurementType.Relative; //Assume relative.
}
if (ParentWorkflow.Parameters.ContainsKey("AlertType"))
{
if (ParentWorkflow.Parameters["AlertType"].ToString().ToLower() == "period")
{
_alertType = AlertType.Period;
}
else
{
_alertType = AlertType.Daily;
}
}
else
{
_alertType = AlertType.Daily; //Assume daily.
}
}
public MeasurementTimeByType Calculate(MeasurementType type, ReleaseWindow releaseWindow, IEnumerable<Metric> metrics)
{
if (releaseWindow == null)
throw new ArgumentNullException("releaseWindow");
switch (type)
{
case MeasurementType.OverallTime:
return CalculateOverallTime(releaseWindow);
case MeasurementType.DownTime:
return CalculateTimeBetweenMetrics(releaseWindow, metrics, type, MetricType.SiteDown, MetricType.SiteUp);
case MeasurementType.DeployTime:
return CalculateTimeBetweenMetrics(releaseWindow, metrics, type, MetricType.StartDeploy, MetricType.FinishDeploy);
case MeasurementType.PreDownTime:
return CalculatePreDownTime(releaseWindow, metrics);
case MeasurementType.PostDownTime:
return CalculatePostDownTime(releaseWindow, metrics);
case MeasurementType.RunTime:
return CalculateTimeBetweenMetrics(releaseWindow, metrics, type, MetricType.StartRun, MetricType.FinishRun);
default: return null;
}
}
/**
* Get measurement corresponding to the input DateTime and MeasurementType.
* If no key/value pair exists for this DateTime, return null.
*/
public GrowthMeasurement GetMeasurementForDateAndType(DateTime date, MeasurementType measurementType)
{
// TODO: [Stefan 09/25/2017] Make measurement retrieval convert values to given units.
// Check if measurement exists for date/type and update value of "measurement".
/*
* Boolean measurement_exists_for_date = measurementTypeMap[measurementType].TryGetValue(date, out GrowthMeasurement measurement);
* if (measurement_exists_for_date)
* {
* return measurement;
* }
* else
* {
* return null;
* }
*/
switch (measurementType)
{
case MeasurementType.HEIGHT:
heightData.TryGetValue(date, out HeightMeasurement heightMeasurement);
return(heightMeasurement);
case MeasurementType.WEIGHT:
weightData.TryGetValue(date, out WeightMeasurement weightMeasurement);
return(weightMeasurement);
case MeasurementType.HEAD_CIRCUMFERENCE:
headCircumferenceData.TryGetValue(date, out HeadCircumferenceMeasurement headCircumferenceMeasurement);
return(headCircumferenceMeasurement);
}
return(null);
}
void ChangeAlgorithm(int ID)
{
switch (ID)
{
case 0:
nowAlogrithm = AlgorithmPattern.CrossSpectrum;
nowMeasurementType = MeasurementType.Standard;
break;
case 1:
nowAlogrithm = AlgorithmPattern.instantaneous;
nowMeasurementType = MeasurementType.Transient;
break;
case 2:
nowAlogrithm = AlgorithmPattern.STFT;
nowMeasurementType = MeasurementType.Transient;
break;
case 3:
nowAlogrithm = AlgorithmPattern.AmbisonicsT;
nowMeasurementType = MeasurementType.Transient;
break;
case 4:
nowAlogrithm = AlgorithmPattern.AmbisonicsTF;
nowMeasurementType = MeasurementType.Transient;
break;
}
UpdateSTFTParam();
}
public async Task Update()
{
IMeasurementTypeDao measurementTypeDao = new AdoMeasurementTypeDao(DefaultConnectionFactory.FromConfiguration(configName));
MeasurementType measurementType = await measurementTypeDao.FindByIdAsync(1);
string originalName = measurementType.Name;
measurementType.Name = "New name";
bool update1 = await measurementTypeDao.UpdateMeasurementTypeAsync(measurementType);
Assert.IsTrue(update1);
measurementType = await measurementTypeDao.FindByIdAsync(1);
Assert.AreEqual(measurementType.Name, "New name");
measurementType.Name = originalName;
bool update2 = await measurementTypeDao.UpdateMeasurementTypeAsync(measurementType);
Assert.IsTrue(update2);
measurementType = await measurementTypeDao.FindByIdAsync(1);
Assert.AreEqual(measurementType.Name, originalName);
}
/**
* Retrieve sorted list of data corresponding to a given measurementType.
* Return null if no data.
* TODO: [Stefan 10/03/2017] Return measurements converted to proper units.
*/
public List <GrowthMeasurement> GetSortedMeasurementList(MeasurementType measurementType)
{
//Dictionary<DateTime, GrowthMeasurement> measurementDictionary = measurementTypeMap[measurementType];
List <GrowthMeasurement> measurements = new List <GrowthMeasurement>();
switch (measurementType)
{
case MeasurementType.HEIGHT:
measurements.AddRange(heightData?.Values);
break;
case MeasurementType.WEIGHT:
measurements.AddRange(weightData?.Values);
break;
case MeasurementType.HEAD_CIRCUMFERENCE:
measurements.AddRange(headCircumferenceData?.Values);
break;
}
if (EMPTY == measurements.Count)
{
return(null);
}
if (measurements.Count > 1)
{
measurements.Sort((x, y) => x.DateRecorded.CompareTo(y.DateRecorded));
}
return(measurements);
}
public void MeasurementUtil_Types(MeasurementType type, Type unit, Type value)
{
var util = MeasurementTools.Instance.GetUtility(type);
util.MeasurementUnit.Should().Be(unit);
util.MeasurementType.Should().Be(value);
}
public double Measure(MeasurementType measurementType)
{
double measurement = double.NaN;
Adapter.ViSessionStatusCheck(IviDCPwrInterop.Measure(Adapter.Session, ChannelName, DCPwrMeasurementType.getC_Value(measurementType), ref measurement));
return(measurement);
}
public Mapping(string propertyName, MeasurementType measurementType, Func <double, double> convertFunction)
{
PropertyName = propertyName;
MeasurementType = measurementType;
convertFunction ??= d => d;
ConvertFunction = convertFunction;
}
public static String MeasurementTypeAsString(MeasurementType measurementType, Language language)
{
if (language == null || language == Language.ENGLISH)
{
switch (measurementType)
{
case MeasurementType.HEIGHT:
return(HEIGHT_STRING_ENG);
case MeasurementType.WEIGHT:
return(WEIGHT_STRING_ENG);
case MeasurementType.HEAD_CIRCUMFERENCE:
return(HEAD_CIRCUMFERENCE_STRING_ENG);
default:
return("");
}
}
// Spanish language settings.
switch (measurementType)
{
case MeasurementType.HEIGHT:
return(HEIGHT_STRING_SPANISH);
case MeasurementType.WEIGHT:
return(WEIGHT_STRING_SPANISH);
case MeasurementType.HEAD_CIRCUMFERENCE:
return(HEAD_CIRCUMFERENCE_STRING_SPANISH);
default:
return("");
}
}
public ActionResult DeleteConfirmed(int id)
{
MeasurementType measurementType = _measurementTypeService.GetById(id);
_measurementTypeService.Delete(measurementType);
return(RedirectToAction("Index"));
}
public static Dictionary<string, string> CreateGetMeasureHttpContent(string deviceId, Scale scale, MeasurementType[] measurementTypes, string moduleId = null, bool onlyLastMeasurement = false, DateTime? begin = null, DateTime? end = null, bool optimize = true, int limit = 1024, bool realtime = false)
{
var content = new Dictionary<string, string>
{
{"device_id", deviceId },
{"scale", scale.GetScaleName()},
{"type", measurementTypes.ToMeasurementTypesString() },
{"optimize", optimize.ToString() },
};
if (!string.IsNullOrEmpty(moduleId))
content.Add("module_id", moduleId);
if (onlyLastMeasurement)
{
content.Add("date_end", "last");
}
else
{
if (begin.HasValue)
content.Add("date_begin", begin.Value.ToUtcTimestamp().ToString());
if (end.HasValue)
content.Add("date_end", end.Value.ToUtcTimestamp().ToString());
}
if (limit != 1024)
content.Add("limit", limit > 1024 || limit < 1 ? "1024" : limit.ToString());
if (realtime)
content.Add("realtime", "true");
return content;
}
private void btnSendParametersToRLC_Click(object sender, EventArgs e)
{
MeasurementType mt = MeasurementType.Unknown;
if (this.rbParallelCapacitance.Checked)
{
mt = MeasurementType.Capacitance_Parallel;
}
if (this.rbSerialCapacitance.Checked)
{
mt = MeasurementType.Capacitance_Serial;
}
if (this.rbImpedance.Checked)
{
mt = MeasurementType.Resistance_Reactance;
}
int freq = (int)this.edtMeasurementFrequency.Value;
double voltage = (double)this.edtVoltage.Value;
double delay = (double)this.edtTriggerDelay.Value;
int average = (int)this.edtAverage.Value;
Debug.Assert(mt != MeasurementType.Unknown);
try
{
Program.a.SendConfiguration(mt, freq, voltage, delay, 0, average);
MessageBox.Show("Konfiguracja wysłana do mostka.\nTryb pomiarowy=" + mt.ToString(), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show("Wyjątek podczas komunikacji z mostkiem:\n" + ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
Program.a.SafeDisconnect();
}
}
public async Task <IActionResult> Edit(int id, [Bind("MeasurementTypeId,Type")] MeasurementType measurementType)
{
if (id != measurementType.MeasurementTypeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(measurementType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MeasurementTypeExists(measurementType.MeasurementTypeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(measurementType));
}
private void PrintMeasurements(MeasurementType measurementType, IEnumerable <Measurement> sampledMeasurements)
{
Print($"Measurement Type: {measurementType.GetDescription()}");
foreach (var measurement in sampledMeasurements)
{
Print($"\t{measurement}");
}
}
public static Attribute[] GetAttributes(this MeasurementType measType)
{
var fi = measType.GetType().GetField(measType.ToString());
Attribute[] attributes = (Attribute[])fi.GetCustomAttributes(typeof(Attribute), false);
return(attributes);
}
public static decimal ConvertFrom(this decimal reading, MeasurementType from)
{
if (from == MeasurementType.Milimeter)
{
return(reading * (decimal)(0.0393701));
}
return(reading * (decimal)25.4);
}
public void CreateMeasurementData(bool optimized, MeasurementType[] measurementTypes)
{
Measurements = new List<Measurement>();
if (optimized)
{
var array = Data as JArray;
if (array == null)
throw new Exception("Unexpected JSON format");
foreach (var a in array)
{
var begintime = (long)JsonConvert.DeserializeObject(a["beg_time"].ToString(), typeof(long));
long stepTime = 0;
if (a["step_time"] != null) //contains does somehow not seem to work here
{
stepTime = (long)JsonConvert.DeserializeObject(a["step_time"].ToString(), typeof(long));
}
var valueSteps = a["value"] as JArray;
for (var i = 0; i < valueSteps.Count; i++)
{
var valueArray = (double?[])JsonConvert.DeserializeObject(valueSteps[i].ToString(), typeof(double?[]));
var measurementValues = new List<MeasurementValue>();
for (var j = 0; j < measurementTypes.Count(); j++)
{
var value = new MeasurementValue {Type = measurementTypes[j], Value = valueArray[j]};
measurementValues.Add(value);
}
var measurement = new Measurement(begintime + (stepTime * i), measurementValues);
Measurements.Add(measurement);
}
}
}
else
{
var dict = (Dictionary<long, double?[]>)JsonConvert.DeserializeObject(Data.ToString(), typeof(Dictionary<long, double?[]>));
foreach (var entry in dict)
{
var measurementValues = new List<MeasurementValue>();
for (var j = 0; j < measurementTypes.Count(); j++)
{
var value = new MeasurementValue { Type = measurementTypes[j], Value = entry.Value[j] };
measurementValues.Add(value);
}
var measurement = new Measurement(entry.Key, measurementValues);
Measurements.Add(measurement);
}
}
}
void AddMeasureType(string name, string id)
{
MeasurementType mt = new MeasurementType();
mt.ID = id;
mt.Name = name;
mt.Category = "LMI";
mt.Unit = "people";
mt.Frequency = "monthly";
mt.RelatedEntityTypeId = reid;
m.Add(name, mt);
}
public static extern IntPtr imaqMeasureParticles(IntPtr image, MeasureParticlesCalibrationMode calibrationMode, ref MeasurementType measurements, int numMeasurements);
public static extern int imaqMeasureParticle(IntPtr image, int particleNumber, int calibrated, MeasurementType measurement, ref double value);
public Measurement(MeasurementType type, string value)
{
Type = type;
Value = value;
}
public MeasurementObject(MeasurementType type, string name, double value)
{
this.Type = type;
this.Name = name;
this.Value = value;
}
private static MeasurementTimeByType CalculateTimeBetweenMetrics(ReleaseWindow releaseWindow, IEnumerable<Metric> metrics,
MeasurementType measurementType, MetricType startMetricType, MetricType finishMetricType)
{
var metricDict = GetMetricTimes(new[] { startMetricType, finishMetricType }, metrics);
if (metricDict == null)
{
Log.WarnFormat("Some metrics are absent. ReleaseId={0}, Metrics={1}", releaseWindow.ExternalId, new[] { startMetricType, finishMetricType }.FormatElements());
return null;
}
var startMetricTime = metricDict[startMetricType];
var finishMetricTime = metricDict[finishMetricType];
if (finishMetricTime < startMetricTime)
throw new ArgumentException(string.Format("{1} time less then {0} time", startMetricType, finishMetricType));
return new MeasurementTimeByType
{
Type = measurementType,
Value = ConvertToMinutes(
finishMetricTime.Subtract(startMetricTime).TotalMinutes
)
};
}
