public MetricModel TranslateToMetricModel()
{
MetricModel model = GetMetricModel();
if (NumberColumns.Count > 0)
{
model.Columns.AddRange(NumberColumns.Select(n =>
new MetricColumnModel
{
Id = n.Id,
Value = n.Value,
FieldName = n.FieldName,
NumberFieldName = n.NumberFieldName
}));
}
else
{
model.Columns.AddRange(CoverageColumns.Select(n =>
new MetricColumnModel
{
Id = n.Id,
Value = n.Value,
FieldName = n.FieldName,
DivisorValue = n.DivisorValue,
DivisorFieldName = n.DivisorFieldName,
CoverageName = n.CoverageName
}));
}
return(model);
}
public Metric(MetricModel model)
{
Id = model.Id;
Name = model.Name;
Displayed = model.Displayed;
ServiceId = model.ServiceId;
Entries = model.Entries?.Select(x => new MetricEntry(x));
}
protected MetricModel GetCurrentMetricModel()
{
MetricModel returnModel = new MetricModel();
returnModel.MetricName = metricName;
returnModel.MetricTitle = metricTitle;
return(returnModel);
}
public void Execute(MetricModel metric)
{
var metricToUpdate = _repo.Metric.FindByCondition(x => x.Id == metric.Id).FirstOrDefault();
metricToUpdate.MetricName = metric.MetricName;
_repo.Metric.Update(metricToUpdate);
_repo.Save();
}
public Metric CreateMetric(Metric metric)
{
using var ctx = CreateContext();
var model = new MetricModel(metric);
ctx.Metrics.Add(model);
ctx.SaveChanges();
return(new Metric(model));
}
public MetricModel HandleMetric(string text)
{
bool isHas = _firstTenHasDigit.StringHasDigit(text);
MetricModel returnModel = GetCurrentMetricModel();
returnModel.Value = isHas == true ? "Да" : "Нет";
return(returnModel);
}
public MetricModel HandleMetric(string text)
{
int capLettersCount = _comparer.CountCapitalLettersMatches(text);
MetricModel returnModel = GetCurrentMetricModel();
returnModel.Value = capLettersCount.ToString();
return(returnModel);
}
public async Task <BaseResponseModelPost> Create(MetricModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
if (await CheckAspiceProcess(request.AspiceProcessId, response))
{
if (await CheckMetricType(request.MetricTypeId, response))
{
if (await CheckAffectedField(request.AffectedFieldId, response))
{
if (await CheckMetricIdentificator(request.Identificator, response))
{
if (CheckMetricColumns(request.Columns, response))
{
Metric metric = new Metric
{
Name = request.Name,
Description = request.Description,
Identificator = request.Identificator,
RequirementGroup = request.RequirementGroup,
AspiceProcessId = request.AspiceProcessId,
AffectedFieldId = request.AffectedFieldId,
MetricTypeId = request.MetricTypeId,
Public = CurrentUser.CompanyId.HasValue ? request.Public : true,
CompanyId = CurrentUser.CompanyId
};
for (int i = 0; i < request.Columns.Count; i++)
{
await CreateMetricColumn(metric, request.Columns[i]);
}
await Database.Metric.AddAsync(metric);
await Database.SaveChangesAsync();
response.Id = metric.Id;
response.Message = "Metric was successfully created!";
}
}
}
}
}
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public int Execute(MetricModel metric)
{
var newMetric = new Entities.Models.Metric
{
MetricName = metric.MetricName
};
_repo.Metric.Create(newMetric);
_repo.Save();
return(newMetric.Id);
}
public MetricModel HandleMetric(string text)
{
int matchesCount = _comparer.CountExclamatorySentenceMatches(text);
MetricModel returnModel = GetCurrentMetricModel();
returnModel.Value = matchesCount.ToString();
return(returnModel);
}
public IList <MetricModel> GetMetricModels()
{
MetricModel m1 = new MetricModel {
Id = 0, Title = "Bounce Rate"
};
MetricModel m2 = new MetricModel {
Id = 1, Title = "Basket Adds"
};
return(new List <MetricModel> {
m1, m2
});
}
private IEnumerable <MetricModel> SetupFakeMetricsAggregator(MetricsResponse response)
{
var models = new List <MetricModel>();
foreach (var metric in response.Metrics)
{
var model = new MetricModel();
A.CallTo(() => this.fakeMetricsAggregator.Aggregate(metric))
.Returns(model);
models.Add(model);
}
return(models);
}
private void AssertEntityMatchesExpectedMetric(DynamicTableEntity entity, MetricModel metric)
{
Assert.NotNull(entity.PartitionKey);
Assert.NotNull(entity.RowKey);
var metricProperties = metric.GetType().GetProperties();
Assert.Equal(entity.Properties.Count, metricProperties.Length);
foreach (var property in metricProperties)
{
Assert.True(entity.Properties.ContainsKey(property.Name));
var metricValue = property.GetValue(metric);
Assert.Equal(metricValue, entity.Properties[property.Name].PropertyAsObject);
}
}
public async Task <MetricModel> UpdateOrAddMetricAsync(MetricModel model)
{
int metricToUpdateIndex = models.FindIndex((m) => m.MetricName == model.MetricName);
await Task.Run(() =>
{
if (metricToUpdateIndex == -1)
{
AddMetric(model);
}
else
{
UpdateMetric(metricToUpdateIndex, model);
}
});
return(model);
}
public static DynamicTableEntity ToEntity(this MetricModel metric, string sourceName, DateTimeOffset timeCaptured)
{
var minuteOffset = new DateTimeOffset(DateTime.Parse(timeCaptured.UtcDateTime.ToString("yyyy-MM-dd HH:mm:00")), TimeSpan.Zero);
var shardKey = (DateTimeOffset.MaxValue.Ticks - minuteOffset.Ticks).ToString("D19");
var entity = new DynamicTableEntity(shardKey,
string.Format("{0}_{1}", sourceName, metric.Name));
entity.Properties.Add("Name", EntityProperty.GeneratePropertyForString(metric.Name));
entity.Properties.Add("TimeStamp", EntityProperty.GeneratePropertyForDateTimeOffset(metric.TimeStamp));
entity.Properties.Add("Average", EntityProperty.GeneratePropertyForDouble(metric.Average));
entity.Properties.Add("Count", EntityProperty.GeneratePropertyForLong(metric.Count));
entity.Properties.Add("Maximum", EntityProperty.GeneratePropertyForDouble(metric.Maximum));
entity.Properties.Add("Minimum", EntityProperty.GeneratePropertyForDouble(metric.Minimum));
entity.Properties.Add("Total", EntityProperty.GeneratePropertyForDouble(metric.Total));
return(entity);
}
public virtual MetricModel Aggregate(Metric source)
{
if (!source.MetricValues.Any())
{
throw new ArgumentException("values cannot be empty", "values");
}
var metric = new MetricModel
{
Name = source.Name.Value,
TimeStamp = source.MetricValues.Max(v => v.TimeStamp),
Count = GetLongValueOrNull(source.MetricValues.Select(v => v.Count), source.IsCumulative ? Count_Max : Count_Sum),
Total = GetDoubleValueOrNull(source.MetricValues.Select(v => v.Total), source.IsCumulative ? Total_Max : Total_Sum),
Average = GetDoubleValueOrNull(source.MetricValues.Select(v => v.Average), Enumerable.Average),
Maximum = GetDoubleValueOrNull(source.MetricValues.Select(v => v.Maximum), Enumerable.Max),
Minimum = GetDoubleValueOrNull(source.MetricValues.Select(v => v.Minimum), Enumerable.Min),
};
return(metric);
}
public async Task AddMetric(MetricModel metric)
{
try
{
_logger.LogTrace("Saving the Job", metric);
Metric metricdto = _translator.Translate <Metric>(metric);
await _tsdbClient.AddMetricsAsync(metricdto);
MetricAddedIntegrationEvent test = new MetricAddedIntegrationEvent(
metric.Name, metric.Tags, metric.DataPoints, metric.Type);
_eventBus.Publish(test);
_logger.LogTrace("Item Saved & event publised. event:", test);
}
catch (Exception ex)
{
_logger.LogError("Unable to save the metric", ex);
}
await Task.CompletedTask;
}
public async Task <BaseResponseModelGetAll <MetricModel> > GetAll(bool lazy)
{
var response = new BaseResponseModelGetAll <MetricModel> {
Values = new List <MetricModel>()
};
foreach (var item in await GetAllMetrics(lazy))
{
MetricModel metric = ConvertToModel(item);
if (!lazy)
{
metric.MetricType = GetMetricType(item.MetricType);
metric.AspiceProcess = GetAspiceProcess(item.AspiceProcess);
metric.AffectedField = GetAffectedField(item.AffectedField);
metric.Columns = GetMetricColumns(item.MetricColumn);
}
response.Values.Add(metric);
}
return(response);
}
public async Task <IActionResult> Create(MetricModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(GetModelStateErrors(ModelState)));
}
var response = await _metricService.CreateMetric(model);
if (response.ResponseCode != ResponseCode.Ok)
{
return(Ok(WebApiResponses <MetricModel> .ErrorOccured(response.Message)));
}
return(Ok(WebApiResponses <MetricModel> .Successful(response.ResponseData)));
}
catch (Exception ex)
{
Log.Error(ex);
return(Ok(WebApiResponses <MetricModel> .ErrorOccured(ex.Message)));
}
}
public bool ReadFile(string filepath)
{
bool result = false;
try
{
FileInfo file = new FileInfo(filepath);
using (ExcelPackage package = new ExcelPackage(file))
{
ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
int rowCount = worksheet.Dimension.Rows;
int ColCount = worksheet.Dimension.Columns;
for (int row = 2; row <= rowCount; row++)
{
MetricModel metric = new MetricModel();
metric.Name = worksheet.Cells[row, 1].Value.ToString();
metric.Tags.Add("node", worksheet.Cells[row, 2].Value.ToString());
for (int col = 3; col <= ColCount; col++)
{
var timestamp = long.Parse(worksheet.Cells[1, col].Value.ToString());
var value = worksheet.Cells[row, col].Value;
metric.DataPoints.Add(new DataPoint(timestamp, value));
}
MetricAddIntegrationEvent addevent = new MetricAddIntegrationEvent(metric.Name, metric.Tags, metric.DataPoints, metric.Type);
_eventBus.Publish(addevent);
}
}
result = true;
}
catch (Exception ex)
{
result = false;
}
return(result);
}
private static void addMeasurement(ref ScenarioBenchmark scenario, string name, MetricModel metric, double value)
{
var iteration = new IterationModel
{
Iteration = new Dictionary <string, double>()
};
iteration.Iteration.Add(metric.Name, value);
var size = new ScenarioTestModel(name);
size.Performance.Metrics.Add(metric);
size.Performance.IterationModels.Add(iteration);
scenario.Tests.Add(size);
}
public IActionResult CreateMetric([FromBody] MetricModel metric)
{
var id = _service.CreateMetric(metric);
return(Ok(metric));
}
public IActionResult UpdateMetric([FromBody] MetricModel metric)
{
_service.UpdateMetric(metric);
return(Ok(metric));
}
MetricModel AddMetric(MetricModel model)
{
models.Add(model);
return(model);
}
MetricModel UpdateMetric(int index, MetricModel model)
{
models[index] = model;
return(model);
}
/// <summary>
/// Added By: Nirav Shah.
/// Action to show Improvement Tactics Detail.
/// </summary>
/// <param name="id">ImprovementTacticTypeId</param>
/// <returns>Return _InspectPopupImprovementTacticType PartialView</returns>
public PartialViewResult DetailImprovementTacticData(int id = 0)
{
BoostImprovementTacticModel bittobj = new BoostImprovementTacticModel();
PlanExchangeRate = Sessions.PlanExchangeRate;
string StageType_CR = Enums.StageType.CR.ToString();
string StageType_SV = Enums.StageType.SV.ToString();
string StageType_Size = Enums.MetricType.Size.ToString();
string StageTypeCW = Enums.Stage.CW.ToString();
double weight = 0;
/* check the mode if id has value 0 then its create mode other wise edit mode */
if (id != 0)
{
ImprovementTacticType ittobj = GetImprovementTacticTypeRecordbyId(id);
bittobj.Title = System.Web.HttpUtility.HtmlDecode(ittobj.Title); ////Modified by Mitesh Vaishnav on 07/07/2014 for PL ticket #584
bittobj.Description = System.Web.HttpUtility.HtmlDecode(ittobj.Description); ////Modified by Mitesh Vaishnav on 07/07/2014 for PL ticket #584
bittobj.Cost = objCurrency.GetValueByExchangeRate(ittobj.Cost, PlanExchangeRate); //Modified by Rahul Shah for PL #2501 to apply multi currency on boost screen
bittobj.IsDeployed = ittobj.IsDeployed;
bittobj.ImprovementTacticTypeId = id;
bittobj.ColorCode = ittobj.ColorCode;
bittobj.IsDeployedToIntegration = ittobj.IsDeployedToIntegration;
ViewBag.Title = "Tactic Detail";
ViewBag.CanDelete = true; //// Added by :- Sohel Pathan on 20/05/2014 for PL #457 to delete a boost tactic.
ViewBag.IsCreated = false; //// Added by :- Sohel Pathan on 20/05/2014 for PL #457 to delete a boost tactic.
}
else
{
bittobj.ImprovementTacticTypeId = 0;
bittobj.Cost = 0;
bittobj.IsDeployed = false;
bittobj.IsDeployedToIntegration = false;
ViewBag.Title = "New Tactic";
ViewBag.CanDelete = false; //// Added by :- Sohel Pathan on 20/05/2014 for PL #457 to delete a boost tactic.
ViewBag.IsCreated = true; //// Added by :- Sohel Pathan on 20/05/2014 for PL #457 to delete a boost tactic.
}
/*get the metrics related to improvement Tactic and display in view*/
List <MetricModel> listMetrics = new List <MetricModel>();
List <MetricModel> listMetricssize = new List <MetricModel>();
// Modified by Mitesh Vaishnav on 03/06/2014 for Customized Target stage - Boost Improvement Tactic
List <Stage> lstStages = GetStageListbyClientId(Sessions.User.CID);
var stageFilterCR = lstStages; //modified by Mitesh Vaishnav on 13/06/2014 to address #500 Customized Target stage - Boost Improvement Tactic
var stageFilterSV = lstStages; //modified by Mitesh Vaishnav on 13/06/2014 to address #500 Customized Target stage - Boost Improvement Tactic
//// Add MetricModel data to list except CW Stage Type data.
MetricModel Metricsobj = null;
foreach (var itemCR in stageFilterCR.Where(stage => stage.Level != null && stage.Code != StageTypeCW).OrderBy(stage => stage.Level).ToList())
{
foreach (var itemSV in stageFilterSV.Where(stage => stage.Level != null && stage.Code != StageTypeCW).OrderBy(stage => stage.Level).ToList())
{
if (itemCR.Level == itemSV.Level)
{
Metricsobj = new MetricModel();
Metricsobj.MetricType = StageType_CR;
Metricsobj.MetricName = Common.GetReplacedString(itemCR.ConversionTitle);
weight = db.ImprovementTacticType_Metric.Where(itm => itm.StageId == itemCR.StageId && itm.ImprovementTacticTypeId == id && itm.StageType == StageType_CR).Select(v => v.Weight).FirstOrDefault();
Metricsobj.ConversionValue = weight;
weight = db.ImprovementTacticType_Metric.Where(itm => itm.StageId == itemSV.StageId && itm.ImprovementTacticTypeId == id && itm.StageType == StageType_SV).Select(v => v.Weight).FirstOrDefault();
Metricsobj.VelocityValue = weight;
Metricsobj.MetricID_CR = itemCR.StageId;
Metricsobj.MetricID_SV = itemSV.StageId;
listMetrics.Add(Metricsobj);
}
}
}
//// Add null Stage Type MetricModel data to list.
foreach (var item in lstStages.Where(stage => stage.Level == null))
{
Metricsobj = new MetricModel();
Metricsobj.MetricID_Size = item.StageId;
//start: Modified by Mitesh Vaishnav on 21/07/2014 for functional review point 73
var stageTypeList = item.ImprovementTacticType_Metric.Where(ittm => ittm.StageId == item.StageId).FirstOrDefault();
if (stageTypeList != null)
{
Metricsobj.MetricType = stageTypeList.StageType;
}
else
{
Metricsobj.MetricType = Enums.MetricType.Size.ToString();
}
//End : Modified by Mitesh Vaishnav on 21/07/2014 for functional review point 73
Metricsobj.MetricName = item.Title;
weight = db.ImprovementTacticType_Metric.Where(itm => itm.StageId == item.StageId && itm.ImprovementTacticTypeId == id).Select(v => v.Weight).FirstOrDefault();
Metricsobj.ConversionValue = weight;
listMetricssize.Add(Metricsobj);
}
bittobj.listMetrics = listMetrics;
bittobj.listMetricssize = listMetricssize;
return(PartialView("_InspectPopupImprovementTacticType", bittobj));
}
public void UpdateMetric(MetricModel location)
{
new UpdateMetricOperation(_repository).Execute(location);
}
public int CreateMetric(MetricModel location)
{
return(new SaveMetricOperation(_repository).Execute(location));
}
public async Task <BaseResponseModel> Edit(MetricModel request)
{
BaseResponseModel response = new BaseResponseModel();
if (request.Validate())
{
if (await CheckAspiceProcess(request.AspiceProcessId, response))
{
if (await CheckMetricType(request.MetricTypeId, response))
{
if (await CheckAffectedField(request.AffectedFieldId, response))
{
Metric metric = await Load(request.Id, response);
if (metric != null && CheckMetricForCrud(metric, response))
{
if (await CheckMetricIdentificator(request.Identificator, response, metric.Id) && CheckMetricColumns(request.Columns, response))
{
metric.Identificator = request.Identificator;
metric.Name = request.Name;
metric.Description = request.Description;
metric.RequirementGroup = request.RequirementGroup;
metric.AspiceProcessId = request.AspiceProcessId;
metric.AffectedFieldId = request.AffectedFieldId;
//metric.MetricTypeId = request.MetricTypeId; --> nelze menit z duvodu, ze by potom nesedely hodnoty columns - musi se mazat columns
metric.Public = CurrentUser.CompanyId.HasValue ? request.Public : true;
//smazane
var deletedIds = metric.MetricColumn.Select(c => c.Id).Except(request.Columns.Select(c => c.Id));
Database.MetricColumn.RemoveRange(metric.MetricColumn.Where(c => deletedIds.Contains(c.Id)));
//nove a editovane
for (int i = 0; i < request.Columns.Count; i++)
{
if (request.Columns[i].Id == 0)
{
await CreateMetricColumn(metric, request.Columns[i]);
}
else
{
MetricColumn column = metric.MetricColumn.First(c => c.Id == request.Columns[i].Id);
column.Value = request.Columns[i].Value ?? string.Empty;
column.FieldName = request.Columns[i].FieldName;
column.NumberFieldName = request.Columns[i].NumberFieldName;
if (!string.IsNullOrEmpty(request.Columns[i].CoverageName))
{
column.DivisorValue = request.Columns[i].DivisorValue ?? JazzService.ALL_VALUES;
column.DivisorFieldName = request.Columns[i].DivisorFieldName ?? string.Empty;
column.CoverageName = request.Columns[i].CoverageName;
}
}
}
await Database.SaveChangesAsync();
response.Message = "Metric was successfully edited!";
}
}
}
}
}
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public IActionResult AddMetric(MetricModel metricModel)
{
return(Ok(_metricService.Add(metricModel)));
}
