394 lines
16 KiB
C#
394 lines
16 KiB
C#
using Azure.Core;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using SystemX.Core.DB;
|
|
using SystemX.Core.Services;
|
|
using Web.Tra.Model;
|
|
using WebClient.Library.Config;
|
|
|
|
namespace Web.Tra.Services
|
|
{
|
|
public class CPXV2LogService
|
|
{
|
|
private readonly IServiceScopeFactory _scopeFactory;
|
|
private readonly ConfigService<WebClientConfig>? _configService;
|
|
|
|
public CPXV2LogService(IServiceProvider serviceProvider, IServiceScopeFactory scopeFactory, ConfigService<WebClientConfig> configService)
|
|
{
|
|
_scopeFactory = scopeFactory;
|
|
_configService = configService;
|
|
}
|
|
|
|
//Get Overview
|
|
public async Task<List<SearchData>> GetSearchDataOverview(RequestSearch request)
|
|
{
|
|
List<SearchData> searchData = new List<SearchData>();
|
|
|
|
int startYear = request.SearchStart.Year;
|
|
int endYear = request.SearchEnd.Year;
|
|
|
|
//search log
|
|
List<HIST_LogSummary> SearchLogList = new List<HIST_LogSummary>();
|
|
for (int i = startYear; i <= endYear; i++)
|
|
{
|
|
using (var scope = _scopeFactory.CreateScope())
|
|
{
|
|
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
|
|
using (var context = GetDBContext<CPXV2Log>(provider, i))
|
|
{
|
|
if (context is not null)
|
|
{
|
|
SearchLogList.AddRange(await context.HIST_LogSummaries.Where(x => request.SearchStart <= DateOnly.FromDateTime(x.TestDT) && DateOnly.FromDateTime(x.TestDT) <= request.SearchEnd).ToListAsync());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//search testlist
|
|
using (var scope = _scopeFactory.CreateScope())
|
|
{
|
|
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
|
|
using (var context = GetDBContext<CPXV2>(provider, 1))
|
|
{
|
|
if (context is not null)
|
|
{
|
|
var varProdVariant = context.PROD_Variants.ToList();
|
|
var varProudGroup = context.PROD_Groups.ToList();
|
|
var TesetInfoList = varProdVariant.Select(x => new TestInfo
|
|
{
|
|
PROD_Variant = x,
|
|
PROD_Group = varProudGroup.Find(y => y.No == x.GroupNo)
|
|
}).ToList();
|
|
|
|
var search = SearchLogList.Select(x => new SearchData
|
|
{
|
|
Summary = x,
|
|
TestInfo = TesetInfoList.Find(y => y.PROD_Variant.No == x.TestListVariantNo)
|
|
});
|
|
|
|
var ListSearchData = search
|
|
// .Where(x => x.Summary.TestListVariantNo > 0)
|
|
.OrderBy(x => x.Summary.TestDT).ToList();
|
|
|
|
searchData.AddRange(ListSearchData);
|
|
}
|
|
}
|
|
}
|
|
|
|
return searchData;
|
|
}
|
|
|
|
public async Task<List<Overview>> GetOverviews(List<SearchData> request)
|
|
{
|
|
var group = request
|
|
.GroupBy(x => (x.Summary.HostID, x.Summary.Section))
|
|
.Select(x => x.ToOverview())
|
|
.OrderBy(x => (x.Host, x.Section));
|
|
|
|
await Task.CompletedTask;
|
|
return group.ToList();
|
|
}
|
|
|
|
public async Task<List<Overview>> GetOverviewMerged(List<SearchData> request)
|
|
{
|
|
var group = request.OrderByDescending(x=>x.Summary.TestDT)
|
|
.GroupBy(x =>
|
|
(
|
|
DateOnly.FromDateTime(x.Summary.TestDT.Date),
|
|
x.Summary.TestType,
|
|
x.Summary.ProdNo_C,
|
|
x.Summary.Testcode,
|
|
x.Summary.TestListFileNo,
|
|
x.Summary.TestListVariantNo,
|
|
x.Summary.ProdNo_P,
|
|
x.Summary.ProdCode,
|
|
x.Summary.Version,
|
|
x.Summary.StepVersion
|
|
))
|
|
.Select(x => x.ToOverviewMerged())
|
|
.OrderByDescending(x=>x.TestDate)
|
|
.DistinctBy(x => (x.TestType, x.ProductNo, x.TestCode))
|
|
.OrderBy(x => (x.ProductNo, x.ParentNo, x.TestCode));
|
|
|
|
await Task.CompletedTask;
|
|
return group.ToList();
|
|
}
|
|
|
|
public async Task<List<Overview>> GetDetailOverview(List<SearchData> request, IDataModel row)
|
|
{
|
|
var selectRow = row as Overview;
|
|
List<Overview> detailOverview = new List<Overview>();
|
|
|
|
if (selectRow is not null)
|
|
{
|
|
detailOverview = request
|
|
.Where(x => x.Summary.HostID == selectRow.Host &&
|
|
x.Summary.Section == selectRow.Section &&
|
|
x.Summary.Testcode == selectRow.TestCode
|
|
)
|
|
.OrderByDescending(x => x.Summary.TestDT.Date)
|
|
.GroupBy(x => (
|
|
DateOnly.FromDateTime(x.Summary.TestDT.Date),
|
|
x.Summary.TestListCntID,
|
|
x.Summary.StepVersion
|
|
))
|
|
.Select(x => x.ToOverview())
|
|
.OrderBy(x => x.TestDate)
|
|
.ToList();
|
|
}
|
|
|
|
await Task.CompletedTask;
|
|
return detailOverview;
|
|
}
|
|
|
|
public async Task<List<Overview>> GetDetailOverviewMerged(List<SearchData> request, IDataModel row)
|
|
{
|
|
var selectRow = row as Overview;
|
|
List<Overview> detailOverview = new List<Overview>();
|
|
|
|
if (selectRow is not null)
|
|
{
|
|
detailOverview = request
|
|
.Where(x => x.Summary.Testcode == selectRow.TestCode &&
|
|
x.Summary.ProdNo_C == selectRow.ProductNo &&
|
|
x.Summary.ProdNo_P == selectRow.ParentNo)
|
|
.GroupBy(x => (
|
|
DateOnly.FromDateTime(x.Summary.TestDT.Date),
|
|
x.Summary.StepVersion
|
|
))
|
|
.Select(x => x.ToOverviewMerged())
|
|
.OrderBy(x => x.TestDate)
|
|
.ToList();
|
|
}
|
|
|
|
await Task.CompletedTask;
|
|
return detailOverview;
|
|
}
|
|
|
|
public async Task<List<TestHistory>> GetTestHistory(List<SearchData> request, IDataModel row)
|
|
{
|
|
var selectRow = row as Overview;
|
|
List<TestHistory> testHistory = new List<TestHistory>();
|
|
|
|
if (selectRow is not null)
|
|
{
|
|
testHistory = request
|
|
.Where(x => x.Summary.TestDT.Date == selectRow.TestDate.Value.Date &&
|
|
x.Summary.HostID == selectRow.Host &&
|
|
x.Summary.Section == selectRow.Section &&
|
|
x.Summary.ProdNo_C == selectRow.ProductNo &&
|
|
x.Summary.ProdNo_P == selectRow.ParentNo &&
|
|
x.Summary.TestListCntID == selectRow.TestListCntID)
|
|
.Select(x => x.ToTestHistory())
|
|
.OrderBy(x => x.No)
|
|
.ToList();
|
|
}
|
|
|
|
await Task.CompletedTask;
|
|
return testHistory;
|
|
}
|
|
|
|
public async Task<List<TestHistory>> GetTestHistoryMerged(List<SearchData> request, IDataModel row)
|
|
{
|
|
var selectRow = row as Overview;
|
|
List<TestHistory> testHistory = new List<TestHistory>();
|
|
|
|
if(selectRow is not null)
|
|
{
|
|
testHistory = request
|
|
.Where(x => x.Summary.TestDT.Date == selectRow.TestDate.Value.Date &&
|
|
x.Summary.Testcode == selectRow.TestCode &&
|
|
x.Summary.ProdNo_C == selectRow.ProductNo &&
|
|
x.Summary.ProdNo_P == selectRow.ParentNo &&
|
|
x.Summary.StepVersion == selectRow.StepVersion)
|
|
.Select(x => x.ToTestHistory())
|
|
.OrderBy(x => (x.TestListReqID, x.No))
|
|
.ToList();
|
|
}
|
|
|
|
await Task.CompletedTask;
|
|
return testHistory.ToList();
|
|
}
|
|
|
|
public async Task<TestList> GetTestList(string productNo, string testCode, int stepVersion)
|
|
{
|
|
TestList testList = new TestList();
|
|
|
|
if (TryParseTestCode(testCode, out var outTestCode) == true)
|
|
{
|
|
//cpxv2
|
|
using (var scope = _scopeFactory.CreateScope())
|
|
{
|
|
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
|
|
using (var context = GetDBContext<CPXV2>(provider, 1))
|
|
{
|
|
if (context is not null)
|
|
{
|
|
var prodRelease = context.PROD_Releases.Where(x => x.ProdNo_C == productNo && x.TestCodeNo == outTestCode)?.FirstOrDefault();
|
|
if(prodRelease is not null)
|
|
{
|
|
var prodVariant = context.PROD_Variants.Where(x => x.No == prodRelease.VariantNo)?.FirstOrDefault();
|
|
var prodGroup = context.PROD_Groups.Where(x => x.No == prodVariant.GroupNo)?.FirstOrDefault();
|
|
var statTestCode = context.STAT_TestCodes.Where(x => x.No == prodRelease.TestCodeNo)?.FirstOrDefault();
|
|
var storTestListFile = context.STOR_TestListFiles.Where(x => x.No == prodVariant.TestListFileNo)?.FirstOrDefault();
|
|
var maxStepVersion = context.HIST_TestListFileLatestStepVersions.Where(x => x.TestListFileNo == prodVariant.TestListFileNo)?.FirstOrDefault();
|
|
|
|
//max version보다 크면 max로
|
|
if (stepVersion > maxStepVersion.LatestStepVersion)
|
|
{
|
|
stepVersion = maxStepVersion.LatestStepVersion;
|
|
}
|
|
else if (stepVersion < 0)
|
|
{
|
|
stepVersion = 0;
|
|
}
|
|
|
|
var findTestList = context.VRFY_TestListFileReleases
|
|
.Where(x => x.TestListFileNo == prodVariant.TestListFileNo && x.StepVersion <= stepVersion)
|
|
.OrderBy(x => x.StepID)
|
|
.ThenByDescending(x => x.StepVersion)
|
|
.AsEnumerable()
|
|
.DistinctBy(x => x.StepID)
|
|
.ToList();
|
|
|
|
testList.ProdRelease = prodRelease;
|
|
testList.ProdVariant = prodVariant;
|
|
testList.ProdGroup = prodGroup;
|
|
testList.StatTestCode = statTestCode;
|
|
testList.StorTestListFile = storTestListFile;
|
|
testList.TestListFile = findTestList;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return testList;
|
|
}
|
|
|
|
public async Task<TestResult> GetTestResult(IDataModel row, int stepVersion)
|
|
{
|
|
TestResult result = new TestResult();
|
|
|
|
var selectRow = row as TestHistory;
|
|
if(selectRow is not null)
|
|
{
|
|
TestList testList = new TestList();
|
|
|
|
//if (TryParseTestCode(selectRow.TestCode, out var testCode) == true)
|
|
{
|
|
//testlist info
|
|
var testListInfo = await GetTestList(selectRow.ProductNo, selectRow.TestCode, stepVersion);
|
|
|
|
//log
|
|
if(testListInfo?.TestListFile is not null)
|
|
{
|
|
if (Int32.TryParse(selectRow.TestDateTime?.Year.ToString(), out var year) == true)
|
|
{
|
|
using (var scope = _scopeFactory.CreateScope())
|
|
{
|
|
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
|
|
using (var context = GetDBContext<CPXV2Log>(provider, year))
|
|
{
|
|
if (context is not null)
|
|
{
|
|
var testResult = context.HIST_TestResults.Where(x => x.No == selectRow.No)?.First();
|
|
result = testResult.ToTestResult(testListInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
await Task.CompletedTask;
|
|
return result;
|
|
}
|
|
|
|
public async Task<TestSummary> GetTestSummary(List<TestHistory> histories, int stepVersion)
|
|
{
|
|
TestSummary result = new TestSummary();
|
|
|
|
if (histories?.Count() > 0)
|
|
{
|
|
List<TestResult> getTestResults = new List<TestResult>();
|
|
|
|
//test result parse
|
|
foreach (var hist in histories)
|
|
{
|
|
getTestResults.Add(await GetTestResult(hist, stepVersion));
|
|
}
|
|
|
|
result = getTestResults.ToTestSummary();
|
|
|
|
}
|
|
|
|
await Task.CompletedTask;
|
|
return result;
|
|
}
|
|
|
|
public async Task<TestTrend> GetTestTrend(List<TestHistory> histories, int stepVersion, int stepId)
|
|
{
|
|
TestTrend result = new TestTrend();
|
|
|
|
if (histories?.Count() > 0)
|
|
{
|
|
List<TestResult> getTestResults = new List<TestResult>();
|
|
|
|
//test result parse
|
|
foreach (var hist in histories)
|
|
{
|
|
getTestResults.Add(await GetTestResult(hist, stepVersion));
|
|
}
|
|
|
|
result = histories.ToTestTrend(getTestResults, getTestResults.ToTestSummary(), stepId);
|
|
}
|
|
|
|
await Task.CompletedTask;
|
|
return result;
|
|
}
|
|
|
|
public bool TryParseTestCode(string testCode, out int outValue)
|
|
{
|
|
bool result = false;
|
|
outValue = -1;
|
|
|
|
//search testlist
|
|
using (var scope = _scopeFactory.CreateScope())
|
|
{
|
|
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
|
|
using (var context = GetDBContext<CPXV2>(provider, 1))
|
|
{
|
|
if (context is not null)
|
|
{
|
|
var selectTestCode = context.STAT_TestCodes.Where(x => x.TestCode == testCode)?.FirstOrDefault();
|
|
if(selectTestCode is not null)
|
|
{
|
|
outValue = selectTestCode.No;
|
|
result = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//Get DBContext
|
|
private T? GetDBContext<T>(DbContextProvider provider, int dbID) where T : DbContext
|
|
{
|
|
var contextName = typeof(T).Name;
|
|
|
|
if(provider.DBDictionary.TryGetValue(dbID, out var findDB) == true)
|
|
{
|
|
return provider?.GetDBContext<T>(findDB.DBID);
|
|
}
|
|
|
|
LogXnet.WriteLine($"GetDBContext Error DBID:{dbID}", LogXLabel.Error);
|
|
return null;
|
|
}
|
|
}
|
|
}
|