290 lines
13 KiB
C#
290 lines
13 KiB
C#
using Newtonsoft.Json;
|
|
using SystemX.Core.DB;
|
|
using Web.Tra.Model;
|
|
using SystemX.Core.Utils;
|
|
using Microsoft.AspNetCore.Mvc.Infrastructure;
|
|
using Radzen.Blazor;
|
|
|
|
public static class ObjectExtend
|
|
{
|
|
public static Overview ToOverview(this IEnumerable<SearchData> data)
|
|
{
|
|
return new Overview
|
|
{
|
|
TestDate = data.Max(x => x.Summary.TestDT.Date),
|
|
StationName = data.Last().Summary.StationName,
|
|
Host = data.Last().Summary.HostID,
|
|
Section = data.Last().Summary.Section,
|
|
ModelName = data.Last().TestInfo?.PROD_Group?.ModelName,
|
|
TestType = data.Last().Summary.TestType,
|
|
ProductNo = data.Last().Summary.ProdNo_C,
|
|
TestCode = data.Last().Summary.Testcode,
|
|
ParentNo = data.GroupBy(x => x.Summary.TestListCntID).Last().Last().Summary.ProdNo_P,
|
|
TestListFileNo = data.GroupBy(x => x.Summary.TestListCntID).Last().Last().Summary.TestListFileNo,
|
|
TestListVariantNo = data.GroupBy(x => x.Summary.TestListCntID).Last().Last().Summary.TestListVariantNo,
|
|
FileCode = data.Last().Summary.ProdCode,
|
|
FileVersion = data.Last().Summary.Version,
|
|
StepVersion = data.Last().Summary.StepVersion,
|
|
FirstTestTime = data.GroupBy(x => x.Summary.TestListCntID).Last().Min(y => y.Summary.TestDT).ToString("HH:mm:ss"),
|
|
FinalTestTime = data.GroupBy(x => x.Summary.TestListCntID).Last().Max(y => y.Summary.TestDT).ToString("HH:mm:ss"),
|
|
Total = data.GroupBy(x => (x.Summary.TestListCntID, x.Summary.TestDT.Date)).Last().Count(),
|
|
OK = data.GroupBy(x => (x.Summary.TestListCntID, x.Summary.TestDT.Date)).Last().Count(y => y.Summary.Result.ToLower().Equals("ok")),
|
|
NG = data.GroupBy(x => (x.Summary.TestListCntID, x.Summary.TestDT.Date)).Last().Count(y => !y.Summary.Result.ToLower().Equals("ok")),
|
|
TestListCntID = data.Last().Summary.TestListCntID
|
|
};
|
|
}
|
|
|
|
public static Overview ToOverviewMerged(this IEnumerable<SearchData> data)
|
|
{
|
|
return new Overview
|
|
{
|
|
TestDate = data.Max(x => x.Summary.TestDT.Date),
|
|
ModelName = data.Last().TestInfo?.PROD_Group?.ModelName,
|
|
TestType = data.Last().Summary.TestType,
|
|
ProductNo = data.Last().Summary.ProdNo_C,
|
|
TestCode = data.Last().Summary.Testcode,
|
|
ParentNo = data.Last().Summary.ProdNo_P,
|
|
TestListFileNo = data.Last().Summary.TestListFileNo,
|
|
TestListVariantNo = data.Last().Summary.TestListVariantNo,
|
|
FileCode = data.Last().Summary.ProdCode,
|
|
FileVersion = data.Last().Summary.Version,
|
|
StepVersion = data.Last().Summary.StepVersion,
|
|
FirstTestTime = data.Min(y => y.Summary.TestDT).ToString("HH:mm:ss"),
|
|
FinalTestTime = data.Max(y => y.Summary.TestDT).ToString("HH:mm:ss"),
|
|
Total = data.Count(),
|
|
OK = data.Count(y => y.Summary.Result.ToLower().Equals("ok")),
|
|
NG = data.Count(y => !y.Summary.Result.ToLower().Equals("ok")),
|
|
};
|
|
}
|
|
|
|
public static Overview ToDetailOverview(this IEnumerable<SearchData> data)
|
|
{
|
|
return data.ToOverview();
|
|
}
|
|
|
|
public static TestHistory ToTestHistory(this SearchData data)
|
|
{
|
|
return new TestHistory
|
|
{
|
|
No = data.Summary.No,
|
|
TestDateTime = data.Summary.TestDT,
|
|
StationName = data.Summary.StationName,
|
|
Host = data.Summary.HostID,
|
|
Section = data.Summary.Section,
|
|
ProductID = data.Summary.ProductID,
|
|
TestType = data.Summary.TestType,
|
|
ProductNo = data.Summary.ProdNo_C,
|
|
TestCode = data.Summary.Testcode,
|
|
ParentNo = data.Summary.ProdNo_P,
|
|
FileCode = data.Summary.ProdCode,
|
|
FileVersion = data.Summary.Version,
|
|
StepVersion = Convert.ToInt32(data.Summary.StepVersion),
|
|
Duration = data.Summary.Duration,
|
|
TestResult = data.Summary.Result,
|
|
TestListReqID = data.Summary.TestListCntID,
|
|
|
|
TestListFileName = data.Summary.TestListFileName,
|
|
TestListFileNo = data.Summary.TestListFileNo.ToString(),
|
|
TestListVariantNo = data.Summary.TestListVariantNo.ToString()
|
|
};
|
|
}
|
|
|
|
public static TestResult ToTestResult(this HIST_TestResult histTestResult, TestList testList = null)
|
|
{
|
|
TestResult testResult = new TestResult();
|
|
testResult.TestList = testList;
|
|
|
|
//decompress
|
|
var decompStr = histTestResult?.LogData.GzipDecompress();
|
|
var logData = JsonConvert.DeserializeObject<List<DecompressTestResult>>(decompStr);
|
|
|
|
testResult.DecompressTestResult = logData;
|
|
|
|
//parse
|
|
var parse = logData.Select(x=>x.ParseTestResult(testList)).Where(x=> x is not null && string.IsNullOrEmpty(x.MeasuredValue) == false).ToList();
|
|
testResult.ParseTestResult = parse;
|
|
testResult.No = (long)histTestResult.No;
|
|
|
|
return testResult;
|
|
}
|
|
|
|
private static ParseTestResult ParseTestResult(this DecompressTestResult logData, TestList testList = null)
|
|
{
|
|
var selectData = testList.TestListFile.Where(x => x.StepID == logData.StepID)?.FirstOrDefault();
|
|
if (selectData is not null)
|
|
{
|
|
var parseTestResult = new ParseTestResult
|
|
{
|
|
StepNo = logData.StepID,
|
|
Position = (long)selectData?.Position,
|
|
Variant = selectData?.Variant,
|
|
Gate = selectData?.Gate,
|
|
MO = selectData?.StepDesc,
|
|
Function = selectData?.UseFunction,
|
|
Min = logData?.GlobalMin,
|
|
MeasuredValue = logData.MeasuredValue,
|
|
Max = logData.GlobalMax,
|
|
Dimension = selectData?.Dim,
|
|
Result = logData.Result,
|
|
Duration = logData.SpentTime
|
|
};
|
|
|
|
//min,max
|
|
if (selectData.IsGlobal == true)
|
|
{
|
|
parseTestResult.Min = logData.GlobalMin;
|
|
parseTestResult.Max = logData.GlobalMax;
|
|
}
|
|
else
|
|
{
|
|
parseTestResult.Min = selectData.SpecMin;
|
|
parseTestResult.Max = selectData.SpecMax;
|
|
}
|
|
|
|
//meas val
|
|
if (string.IsNullOrEmpty(logData.Message) == false)
|
|
{
|
|
parseTestResult.MeasuredValue = logData.Message;
|
|
}
|
|
else if (string.IsNullOrEmpty(logData.MeasValStr) == false)
|
|
{
|
|
parseTestResult.MeasuredValue = logData.MeasValStr;
|
|
}
|
|
else if (string.IsNullOrEmpty(parseTestResult.Min) == true &&
|
|
string.IsNullOrEmpty(parseTestResult.Max) == true &&
|
|
logData.MeasVal == 0)
|
|
{
|
|
parseTestResult.MeasuredValue = logData.MeasVal.ToString("F1");
|
|
}
|
|
else
|
|
{
|
|
parseTestResult.MeasuredValue = logData.MeasVal.ToString();
|
|
}
|
|
|
|
return parseTestResult;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static TestSummary ToTestSummary(this List<TestResult> testResults)
|
|
{
|
|
TestSummary testSummary = new TestSummary();
|
|
testSummary.ParseTestSummary = new List<ParseTestSummary>();
|
|
|
|
if(testResults?.Count > 0)
|
|
{
|
|
var parseTestResults = testResults.SelectMany(x => x.ParseTestResult??=new()).ToList();
|
|
var rowGroup = parseTestResults.GroupBy(x => x.StepNo).ToList().OrderBy(x => x.Key);
|
|
foreach(var rows in rowGroup)
|
|
{
|
|
var summary = new ParseTestSummary
|
|
{
|
|
StepNo = rows.First().StepNo,
|
|
Variant = rows.First().Variant,
|
|
Gate = rows.First().Gate,
|
|
MO = rows.First().MO,
|
|
Function = rows.First().Function,
|
|
Min = rows.First().Min,
|
|
Average = rows.First().MeasuredValue,
|
|
Max = rows.First().Max,
|
|
Dimension = rows.First().Dimension,
|
|
Total = rows.Count(),
|
|
OK = rows.Count(x => x.Result.ToLower().Equals("ok") || x.Result.ToLower().Equals("none")),
|
|
NG = rows.Count(x => !(x.Result.ToLower().Equals("ok") || x.Result.ToLower().Equals("none"))),
|
|
};
|
|
|
|
//calculate dim
|
|
if (rows.FirstOrDefault().Dimension.ToLower() == "dez" || rows.FirstOrDefault().Dimension.ToLower() == "v" ||
|
|
rows.FirstOrDefault().Dimension.ToLower() == "float" || rows.FirstOrDefault().Dimension.ToLower() == "int")
|
|
{
|
|
try
|
|
{
|
|
summary.Average = rows.Average(x => Convert.ToDouble(x.MeasuredValue)).ToString();
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
summary.Average = string.Empty;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (summary.Average == "0.0")
|
|
summary.Average = string.Empty;
|
|
}
|
|
|
|
testSummary.ParseTestSummary.Add(summary);
|
|
}
|
|
}
|
|
|
|
return testSummary;
|
|
}
|
|
|
|
public static TestSummaryInformation GetTestSummaryInformation(this List<TestHistory> testHistories)
|
|
{
|
|
return new TestSummaryInformation
|
|
{
|
|
StartTime = (DateTime)testHistories.Min(x => x.TestDateTime),
|
|
EndTime = (DateTime)testHistories.Max(x => x.TestDateTime),
|
|
StationName = testHistories.GroupBy(x=>x.StationName)?.Count() > 1 ? string.Empty : testHistories.FirstOrDefault().StationName,
|
|
HostID = testHistories.GroupBy(x => x.Host)?.Count() > 1 ? string.Empty : testHistories.FirstOrDefault().Host,
|
|
SectionID = testHistories.GroupBy(x => x.Section)?.Count() > 1 ? string.Empty : testHistories.FirstOrDefault().Section,
|
|
TestType = testHistories.FirstOrDefault().TestType,
|
|
ProductNo = testHistories.FirstOrDefault().ProductNo,
|
|
TestCode = testHistories.FirstOrDefault().TestCode,
|
|
ParentNo = testHistories.FirstOrDefault().ParentNo,
|
|
TestListFileNo = Convert.ToInt32(testHistories.FirstOrDefault().TestListFileNo),
|
|
TestListVariantNo = Convert.ToInt32(testHistories.FirstOrDefault().TestListVariantNo),
|
|
ProductionCode = testHistories.FirstOrDefault().FileCode,
|
|
FileVersion = testHistories.FirstOrDefault().FileVersion,
|
|
StepVersion = testHistories.FirstOrDefault().StepVersion,
|
|
TestRequestsID = testHistories.FirstOrDefault().TestListReqID,
|
|
};
|
|
}
|
|
|
|
public static TestTrend ToTestTrend(this List<TestHistory> histories, List<TestResult> testResult, TestSummary summary, int stepId)
|
|
{
|
|
TestTrend result = new TestTrend();
|
|
result.ParseTestTrend = new List<ParseTestTrend>();
|
|
result.TestStepInfo = summary.ParseTestSummary.Where(x=>x.StepNo == stepId)?.FirstOrDefault();
|
|
result.TestDataInfo = histories.GetTestSummaryInformation();
|
|
|
|
if (histories?.Count > 0)
|
|
{
|
|
int rowNo = 0;
|
|
foreach (var history in histories.OrderBy(x=>x.TestDateTime))
|
|
{
|
|
var r = testResult.Where(x => x.No == history.No)?.FirstOrDefault();
|
|
if (r is not null)
|
|
{
|
|
var step = r.ParseTestResult.Where(x => x.StepNo == stepId)?.FirstOrDefault();
|
|
if(step is not null)
|
|
{
|
|
result.ParseTestTrend.Add(new ParseTestTrend
|
|
{
|
|
RowNo = rowNo + 1,
|
|
TestTime = (DateTime)history.TestDateTime,
|
|
MO = step.MO,
|
|
ProductID = history.ProductID,
|
|
Min = step.Min,
|
|
Value = step.MeasuredValue,
|
|
Max = step.Max,
|
|
Result = step.Result,
|
|
Duration = step.Duration
|
|
});
|
|
}
|
|
}
|
|
rowNo += 1;
|
|
}
|
|
}
|
|
|
|
result.MesuredDataAnalysis = new MesuredDataAnalysis
|
|
{
|
|
Average = result.ParseTestTrend.Average(x => x.Value.GetType()== typeof(double) ? Convert.ToDouble(x.Value) : 0.0),
|
|
Min = result.ParseTestTrend.Min(x => x.Value.GetType() == typeof(double) ? Convert.ToDouble(x.Value) : 0.0),
|
|
Max = result.ParseTestTrend.Max(x => x.Value.GetType() == typeof(double) ? Convert.ToDouble(x.Value) : 0.0),
|
|
};
|
|
|
|
return result;
|
|
}
|
|
} |