public async Task <BaseResponseModel> Drop(int id)
{
BaseResponseModel response = new BaseResponseModel();
ProjectMetric projectMetric = await Load(id, response);
if (projectMetric != null)
{
foreach (var item in projectMetric.ProjectMetricSnapshot)
{
Database.ProjectMetricColumnValue.RemoveRange(item.ProjectMetricColumnValue);
}
Database.ProjectMetricLog.RemoveRange(projectMetric.ProjectMetricLog);
Database.ProjectMetricSnapshot.RemoveRange(projectMetric.ProjectMetricSnapshot);
Database.ProjectMetric.Remove(projectMetric);
await Database.SaveChangesAsync();
response.Message = "Project metric was successfully deleted!";
}
return(response);
}
public void WhenCreatingProjectMetricThenEnumeratesPassedNamespaceMetrics()
{
var mockNamespaces = new Mock <IEnumerable <INamespaceMetric> >();
mockNamespaces.Setup(x => x.GetEnumerator()).Returns(Enumerable.Empty <INamespaceMetric>().GetEnumerator());
var metric = new ProjectMetric("name", mockNamespaces.Object, Enumerable.Empty <string>(), 0);
mockNamespaces.Verify(x => x.GetEnumerator(), Times.AtLeastOnce);
}
public ProjectMetricModel ConvertToModel(ProjectMetric dbModel)
{
return(new ProjectMetricModel
{
Id = dbModel.Id,
CreateDate = dbModel.CreateDate,
DataUrl = dbModel.DataUrl,
MetricId = dbModel.MetricId,
ProjectId = dbModel.ProjectId,
Warning = dbModel.Warning,
MinimalWarningValue = dbModel.MinimalWarningValue,
LastUpdateDate = dbModel.LastUpdateDate,
DataUsername = dbModel.DataUsername
});
}
public async Task <BaseResponseModelGetAll <ProjectMetricLogModel> > GetProjectMetricLogs(int id)
{
var response = new BaseResponseModelGetAll <ProjectMetricLogModel>()
{
Values = new List <ProjectMetricLogModel>()
};
ProjectMetric projectMetric = await Load(id, response);
if (projectMetric != null)
{
response.Values = GetLogs(projectMetric.ProjectMetricLog);
}
return(response);
}
public async Task <BaseResponseModelGet <ProjectMetricModel> > Get(int id, bool lazy)
{
var response = new BaseResponseModelGet <ProjectMetricModel>();
ProjectMetric projectMetric = await Load(id, response);
if (projectMetric != null)
{
response.Value = ConvertToModel(projectMetric);
if (!lazy)
{
response.Value.Snapshots = GetSnapshots(projectMetric.ProjectMetricSnapshot);
}
}
return(response);
}
public async Task <ProjectMetric> Load(int id, BaseResponseModel response, bool tracking = true, bool lazy = true)
{
ProjectMetric projectMetric = await Database.ProjectMetric.FirstOrDefaultAsyncSpecial(a => a.Id == id, tracking, pm => pm.Metric);
if (projectMetric == null)
{
response.Success = false;
response.Message = "Unknown project metric!";
}
else
{
if (!projectMetric.Metric.Public && projectMetric.Metric.CompanyId != CurrentUser.CompanyId)
{
projectMetric = null;
response.Success = false;
response.Message = "You don't have access to this project metric!";
}
}
return(projectMetric);
}
public async Task <BaseResponseModelPost> Create(ProjectMetricModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
if (await CheckMetric(request, response) && await CheckProject(request.ProjectId, response) && TestURL(request.DataUrl, response))
{
ProjectMetric projectMetric = new ProjectMetric
{
MetricId = request.MetricId,
ProjectId = request.ProjectId,
CreateDate = DateTime.Now,
LastUpdateDate = DateTime.Now,
DataUrl = request.DataUrl,
DataUsername = request.DataUsername,
DataPassword = PasswordHelper.Base64Encode(request.DataPassword),
Warning = request.Warning,
MinimalWarningValue = request.Warning ? request.MinimalWarningValue ?? 0 : default(decimal?)
};
await Database.ProjectMetric.AddAsync(projectMetric);
await Database.SaveChangesAsync();
response.Id = projectMetric.Id;
response.Message = "Project metric was successfully created!";
}
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public async Task <BaseResponseModel> Edit(ProjectMetricModel request)
{
BaseResponseModel response = new BaseResponseModel();
if (request.Validate())
{
if (await CheckMetric(request, response) && await CheckProject(request.ProjectId, response) && TestURL(request.DataUrl, response))
{
ProjectMetric projectMetric = await Load(request.Id, response);
if (projectMetric != null)
{
projectMetric.DataUrl = request.DataUrl;
projectMetric.DataUsername = request.DataUsername;
projectMetric.Warning = request.Warning;
projectMetric.MinimalWarningValue = request.Warning ? request.MinimalWarningValue ?? 0 : default(decimal?);
if (!string.IsNullOrEmpty(request.DataPassword))
{
projectMetric.DataPassword = PasswordHelper.Base64Encode(request.DataPassword);
}
await Database.SaveChangesAsync();
response.Message = "Project metric was successfully edited!";
}
}
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
/// <summary>
/// vytvori snapshot dane projektove metriky
/// </summary>
/// <param name="projectMetric">projektova metrika</param>
/// <returns></returns>
public async Task CreateSnapshot(ProjectMetric projectMetric)
{
_suffix = 0;
string xml = await GetDataFromJazzReportingService(projectMetric.DataUrl, projectMetric.DataUsername, PasswordHelper.Base64Decode(projectMetric.DataPassword));
if (!string.IsNullOrEmpty(xml))
{
_document = new XmlDocument();
_document.LoadXml(xml);
XmlNode schemaLocationAttribute = _document.DocumentElement.SelectSingleNode("//@*[local-name()='schemaLocation']"); //je nutne nacist schema, jinak nejde vybirat prvky pomoci xpath
if (schemaLocationAttribute != null)
{
_namespaces = new XmlNamespaceManager(_document.NameTable);
_namespaces.AddNamespace("ns", schemaLocationAttribute.Value.Split(null)[0]);
List <string> names = new List <string>(); //vyber nazvu skupin pozadavku
do
{
if (names.Count > 0)
{
_suffix++; //prochazi se po indexech vyse
names.Clear();
}
foreach (XmlNode name in _document.SelectNodes($"/ns:results/ns:result/ns:NAME{Suffix}[text()]", _namespaces))
{
names.Add(name.InnerText);
}
} while (names.Any(n => n.Length > 4)); //dokud nejsou jen ctyrmistne (HWRS atd.)
XmlNodeList results = null;
if (names.Distinct().Count() == 1) //jen jedna skupina
{
results = _document.SelectNodes("/ns:results/ns:result", _namespaces);
}
else //vice skupin, nacte se tedy jen ta jedna specifikovana
{
results = _document.SelectNodes($"/ns:results/ns:result[ns:NAME{Suffix}='{projectMetric.Metric.RequirementGroup}']", _namespaces);
}
if (results.Count > 0)
{
if (projectMetric.Metric.MetricType.NumberMetric)
{
ParseXmlForNumberMetric(projectMetric, results);
}
else if (projectMetric.Metric.MetricType.CoverageMetric)
{
ParseXmlForCoverageMetric(projectMetric, results);
}
else
{
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Metric #{projectMetric.MetricId} has unknown metric type {projectMetric.Metric.MetricType.Name}!"));
}
projectMetric.LastUpdateDate = DateTime.Now;
}
else
{
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Project metric #{projectMetric.Id} data XML does not have proper format (results(1) > result(1..X))!"));
}
}
else
{
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Project metric #{projectMetric.Id} data XML does not have proper format (XML schmema or namespace is missing)!"));
}
}
else
{
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Project metric #{projectMetric.Id} data XML is empty, propably bad URL."));
}
}
/// <summary>
/// zpracuje XML pro number metriku
/// </summary>
/// <param name="projectMetric">projektova metrida</param>
/// <param name="results">nactene elementy z XML</param>
private void ParseXmlForNumberMetric(ProjectMetric projectMetric, XmlNodeList results)
{
ProjectMetricSnapshot snapshot = new ProjectMetricSnapshot
{
InsertionDate = DateTime.Now,
ProjectMetric = projectMetric,
ProjectMetricColumnValue = new List <ProjectMetricColumnValue>()
};
if (results.Count == 1) //je jen jeden sloupec -> to znamena, ze v nem suma a neni treba nic pocitat
{
if (projectMetric.Metric.MetricColumn.Count > 1)
{
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Metric #{projectMetric.MetricId} has {projectMetric.Metric.MetricColumn.Count} columns, but in data XML was only one column!"));
}
MetricColumn column = projectMetric.Metric.MetricColumn.First();
ProjectMetricColumnValue columnValue = new ProjectMetricColumnValue
{
Value = 0,
MetricColumnId = column.Id,
ProjectMetricSnapshot = snapshot
};
XmlNode value = SelectSingleNodeSpecial(results[0], column.NumberFieldName) ?? SelectSingleNodeSpecial(results[0], FIELD_ID) ?? SelectSingleNodeSpecial(results[0], column.FieldName);
if (ParseNodeValue(value, out int numberValue))
{
columnValue.Value = numberValue;
}
else
{
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Column #{column.Id} of metric #{column.MetricId}, does not have proper tag with numeric value in data XML!"));
}
snapshot.ProjectMetricColumnValue.Add(columnValue);
}
else //vice sloupcu
{
foreach (var column in projectMetric.Metric.MetricColumn)
{
ProjectMetricColumnValue columnValue = new ProjectMetricColumnValue
{
Value = 0,
MetricColumnId = column.Id,
ProjectMetricSnapshot = snapshot
};
string[] values = column.Value.Split(';').Select(v => v.Trim().ToLower()).ToArray();
foreach (XmlNode result in results) //hledam hodnoty a jejich pocty, pripadne jen pricitam
{
XmlNode name = SelectSingleNodeSpecial(result, column.FieldName) ?? SelectSingleNodeSpecial(result, FIELD_VALUE);
if (name != null && (values.Contains(name.InnerText.ToLower()) || (values[0] == ANY_VALUE && name.InnerText != string.Empty)))
{
XmlNode value = SelectSingleNodeSpecial(result, column.NumberFieldName) ?? SelectSingleNodeSpecial(result, FIELD_COUNT);
if (ParseNodeValue(value, out int numberValue))
{
columnValue.Value += numberValue;
}
else
{
columnValue.Value++;
}
}
}
snapshot.ProjectMetricColumnValue.Add(columnValue);
}
}
projectMetric.ProjectMetricSnapshot.Add(snapshot);
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Snapshot of project metric #{projectMetric.Id} was successfully created!", false));
}
/// <summary>
/// zpracuje XML pro coverage metriku
/// </summary>
/// <param name="projectMetric">projektova metrida</param>
/// <param name="results">nactene elementy z XML</param>
private void ParseXmlForCoverageMetric(ProjectMetric projectMetric, XmlNodeList results)
{
ProjectMetricSnapshot snapshot = new ProjectMetricSnapshot
{
InsertionDate = DateTime.Now,
ProjectMetric = projectMetric,
ProjectMetricColumnValue = new List <ProjectMetricColumnValue>()
};
//nekde se totiz opakuji pozadavky, pokud maji treba vice testu (napr M78), mne staci jen vedet, ze aspon jeden ma
//takze nadbytecne nevyberu, jinak totiz zkresluje vysledek metriky
if (results.Item(0).SelectSingleNode($"//ns:{FIELD_ID}", _namespaces) != null)
{
//vybiram podle referenceID, ktere ma kazdy pozadavek jedinecne
results = _document.SelectNodes($"/ns:results/ns:result[ns:NAME{Suffix}='{projectMetric.Metric.RequirementGroup}' and ns:{FIELD_ID}[not=(.=../following-sibling::ns:result/ns:{FIELD_ID})]]", _namespaces);
}
foreach (var column in projectMetric.Metric.MetricColumn)
{
ProjectMetricColumnValue columnValue = new ProjectMetricColumnValue
{
Value = 0,
MetricColumnId = column.Id,
ProjectMetricSnapshot = snapshot
};
int count = 0, accepted = 0;
if (results.Count > 1 && results.Item(0).SelectSingleNode($"//ns:{FIELD_COUNT}", _namespaces) == null) //pokud se nenachazi node se sumou prvku
{
if (column.DivisorValue != ALL_VALUES && !string.IsNullOrEmpty(column.DivisorFieldName)) //mam specifikovane jen nektere pro delitele
{
count = _document.SelectNodes($"/ns:results/ns:result[ns:{column.DivisorFieldName}='{column.DivisorValue}']", _namespaces).Count;
}
else //vsechny nody pro delitele
{
count = results.Count;
}
}
else //existuje node s poctem prvku, tak musim secist jednotlive hodnoty
{
XmlNodeList groupResults = results;
if (column.DivisorValue != ALL_VALUES && !string.IsNullOrEmpty(column.DivisorFieldName))
{
groupResults = _document.SelectNodes($"/ns:results/ns:result[ns:{column.DivisorFieldName}='{column.DivisorValue}']", _namespaces); //mam specifikovane jen nektere pro delitele
}
foreach (XmlNode result in groupResults) //scitam pocty
{
XmlNode value = SelectSingleNodeSpecial(result, FIELD_COUNT);
if (ParseNodeValue(value, out int numberValue))
{
count += numberValue;
}
else //pro pripad, ze tam neni cislo
{
count++;
}
}
}
if (results.Item(0).SelectSingleNode("//ns:REFERENCE_ID1", _namespaces) != null && results.Item(0).SelectSingleNode("//ns:NAME2", _namespaces) != null)
{ //metriky, kde jen hledam, zda maji vyplneny nektery pozadovany atribut
foreach (XmlNode result in results)
{
XmlNode reference = SelectSingleNodeSpecial(result, column.FieldName) ?? SelectSingleNodeSpecial(result, "REFERENCE_ID1")
?? SelectSingleNodeSpecial(result, "NAME2") ?? SelectSingleNodeSpecial(result, "NAME3");
if (reference != null && !string.IsNullOrEmpty(reference.InnerText))
{
accepted++;
}
}
}
else if (results.Item(0).SelectSingleNode($"//ns:{column.FieldName}", _namespaces) != null || results.Item(0).SelectSingleNode($"//ns:{FIELD_VALUE}", _namespaces) != null) //M03, M06, M60
{ //metriky, kde hledam, jestli ma vyplnenou danou hodnotu
string[] values = column.Value.Split(';').Select(v => v.Trim().ToLower()).ToArray();
foreach (XmlNode result in results)
{
XmlNode name = SelectSingleNodeSpecial(result, column.FieldName) ?? SelectSingleNodeSpecial(result, FIELD_VALUE);
if (name != null && (values.Contains(name.InnerText.ToLower()) || values[0] == ANY_VALUE))
{
XmlNode value = SelectSingleNodeSpecial(result, FIELD_COUNT);
if (ParseNodeValue(value, out int numberValue)) //znovu, pokud je suma, pricitam sumu, jinak jen jeden
{
accepted += numberValue;
}
else
{
accepted++;
}
}
}
}
else
{
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Metric #{projectMetric.MetricId} coverage column '{column.Value}' is unknown type!"));
}
columnValue.Value = (accepted / (decimal)count) * 100; //v %
snapshot.ProjectMetricColumnValue.Add(columnValue);
}
projectMetric.ProjectMetricSnapshot.Add(snapshot);
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Snapshot of project metric #{projectMetric.Id} was successfully created!", false));
}
public async Task <BaseResponseModel> CreateSnapshot(int id, int projectMetricId, ProjectMetric projectMetric = null)
{
BaseResponseModel response = new BaseResponseModel {
Message = "Creating of a snapshot ended successfully. For more detailed result check project metric log."
};
try
{
projectMetric = projectMetric ?? await _projectMetricService.Load(projectMetricId, response);
if (projectMetric != null)
{
await _jazzService.CreateSnapshot(projectMetric);
await Database.SaveChangesAsync();
}
}
catch (Exception e)
{
response.Success = false;
response.Message = "Creating of a snapshot was not successfull! Please try again later.";
await _helperService.SaveErrorToDB(new AppErrorModel(e, message : "task - all projects", module : "ProjectService", function : "CreateSnapshots"));
projectMetric.ProjectMetricLog.Add(new ProjectMetricLog($"Within processing of snapshot for project metric #{projectMetric.Id} occured and error!"));
}
return(response);
}
