250 lines
13 KiB
C#
250 lines
13 KiB
C#
namespace LaaProductionWeb.Services
|
|
{
|
|
using FluentSQLClient.Interfaces;
|
|
|
|
using LaaProductionWeb.Services.Interfaces;
|
|
using LaaProductionWeb.Services.Models;
|
|
using LaaProductionWeb.Services.Models.Reports;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
|
|
public class ProtocolService : IProtocolService
|
|
{
|
|
private readonly IFluentSQLConnection fluentSQL;
|
|
|
|
public ProtocolService(IFluentSQLConnection fluentSQL)
|
|
=> this.fluentSQL = fluentSQL;
|
|
|
|
public bool DeleteFile(int fileId)
|
|
=> this.fluentSQL
|
|
.CreateCommand($@"
|
|
DELETE FROM [File]
|
|
WHERE [FileId] = @{nameof(fileId)};
|
|
DELETE FROM [FilesOrders]
|
|
OUTPUT [Deleted].[FileId]
|
|
WHERE [FileId] = @{nameof(fileId)};")
|
|
.SetParameter(nameof(fileId), fileId)
|
|
.ExecuteScalar(x => x.GetInt()) > 0;
|
|
|
|
public string FileContent(int? fileId)
|
|
{
|
|
var fileContent = this.fluentSQL
|
|
.CreateCommand($@"
|
|
SELECT [dbo].[File].[FileContent]
|
|
FROM [dbo].[File]
|
|
WHERE [dbo].[File].[FileId] = @{nameof(fileId)}")
|
|
.SetParameter(nameof(fileId), fileId)
|
|
.FirstOrDefault(reader => reader.GetBytes())
|
|
?? Array.Empty<byte>();
|
|
|
|
return string.Format("data:application/pdf;base64,{0}", Convert.ToBase64String(fileContent));
|
|
}
|
|
|
|
public OrderClientModel FindOrder(int orderId)
|
|
{
|
|
var orderClientModel = this.fluentSQL
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[APG].[AuftragNr]
|
|
, [K].[KundenNr]
|
|
, [K].[Name]
|
|
, ISNULL((SELECT CAST([Positions].[PositionNr] AS VARCHAR) + ', '
|
|
FROM (SELECT DISTINCT TOP 1000 [PositionNr]
|
|
FROM [AuftragPositionSerienNr]
|
|
WHERE [AuftragNr] = [APG].[AuftragNr]
|
|
ORDER BY [PositionNr]) AS [Positions]
|
|
FOR XML PATH('')), '') AS [Positions]
|
|
FROM [AuftragPosition_Gesamt] AS [APG]
|
|
JOIN [Auftrag_Gesamt] AS [AG]
|
|
ON [AG].[AuftragNr] = [APG].[AuftragNr]
|
|
JOIN [IdentNr] AS [IN]
|
|
ON [IN].[IdentNr] = [APG].[Identnr]
|
|
AND [IN].[Typ] = 'GNS'
|
|
JOIN [Kunde] AS [K]
|
|
ON [K].[KundenNr] = [AG].[KundenNr]
|
|
WHERE [APG].[AuftragNr] = @{nameof(orderId)}")
|
|
.SetParameter(nameof(orderId), orderId)
|
|
.FirstOrDefault(reader => new OrderClientModel
|
|
{
|
|
OrderId = reader.GetInt(),
|
|
ClientId = reader.GetInt(),
|
|
ClientName = reader.GetString(),
|
|
Positions = reader.GetString().Trim().Trim(',')
|
|
});
|
|
|
|
if (orderClientModel != null && orderId > 0)
|
|
{
|
|
orderClientModel.FileId = this.fluentSQL
|
|
.CreateCommand($@"
|
|
SELECT [FileId]
|
|
FROM [FilesOrders]
|
|
WHERE [OrderId] = @{nameof(orderId)}
|
|
AND [Usage] = 'PROTOCOL'")
|
|
.SetParameter(nameof(orderId), orderId)
|
|
.FirstOrDefault(reader => reader.GetValue<int?>());
|
|
}
|
|
|
|
return orderClientModel ?? new OrderClientModel();
|
|
}
|
|
|
|
public IEnumerable<KeyValuePair<int, string>> FindOrdersById(int orderno)
|
|
=> this.fluentSQL
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[APG].[AuftragNr]
|
|
, [K].[Name]
|
|
FROM [AuftragPosition_Gesamt] AS [APG]
|
|
JOIN [Auftrag_Gesamt] AS [AG]
|
|
ON [AG].[AuftragNr] = [APG].[AuftragNr]
|
|
JOIN [IdentNr] AS [IN]
|
|
ON [IN].[IdentNr] = [APG].[Identnr]
|
|
AND [IN].[Typ] = 'GNS'
|
|
JOIN [Kunde] AS [K]
|
|
ON [K].[KundenNr] = [AG].[KundenNr]
|
|
WHERE [APG].[AuftragNr] LIKE @{nameof(orderno)}")
|
|
.SetParameter(nameof(orderno), $"%{orderno}%")
|
|
.ExecuteReader(reader => new KeyValuePair<int, string>(
|
|
key: reader.GetInt(),
|
|
value: reader.GetString()));
|
|
|
|
public IEnumerable<KeyValuePair<int, string>> FindOrdersByClient(string clientName)
|
|
=> this.fluentSQL
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[APG].[AuftragNr]
|
|
, [K].[Name]
|
|
FROM [AuftragPosition_Gesamt] AS [APG]
|
|
JOIN [Auftrag_Gesamt] AS [AG]
|
|
ON [AG].[AuftragNr] = [APG].[AuftragNr]
|
|
JOIN [IdentNr] AS [IN]
|
|
ON [IN].[IdentNr] = [APG].[Identnr]
|
|
AND [IN].[Typ] = 'GNS'
|
|
JOIN [Kunde] AS [K]
|
|
ON [K].[KundenNr] = [AG].[KundenNr]
|
|
WHERE [K].[Name] LIKE @{nameof(clientName)}")
|
|
.SetParameter(nameof(clientName), $"%{clientName}%")
|
|
.ExecuteReader(reader => new KeyValuePair<int, string>(
|
|
key: reader.GetInt(),
|
|
value: reader.GetString()));
|
|
|
|
public IEnumerable<TestStatus> LoadTestStatus(int orderId)
|
|
=> this.fluentSQL
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[APS].[PositionNr] AS [PosNr] -- 0
|
|
, ISNULL([APS].[KundeneigeneSerienNr], [APS].[SerienNr]) AS [SerialNr] -- 1
|
|
, [CPT].[CordonelPressureTest_Valid] AS [3TightnessTest] -- 2
|
|
, [DP].[Dicht] AS [4PressureAndTightness] -- 3
|
|
, MAX([APS].[StatusFertigung]) AS [5Metrologicaltesting] -- 4
|
|
, [CRRH].[Result] AS [6ConfigComparisonAndRadiotest] -- 5
|
|
FROM [AuftragPositionSerienNr] AS [APS]
|
|
LEFT JOIN [Genesis_Meter] AS [GM] ON [GM].[Seriennummer] = [APS].[SerienNr]
|
|
LEFT JOIN [MapPcbIdToSerialNumber] AS [PCB] ON [PCB].[MapPcbIdToSerialNumber_SerialNumber] = [GM].[Seriennummer]
|
|
LEFT JOIN [Cordonel_Radio_RSSI_History] AS [CRRH] ON [CRRH].[RadioAdress] = [GM].[Adresse] - 10000000000
|
|
AND [CRRH].[IsLast] = 1
|
|
AND [CRRH].[Result] = 1
|
|
LEFT JOIN [Druckpruefung] AS [DP] ON [DP].[FabNr] = [PCB].[MapPcbIdToSerialNumber_PcbId]
|
|
AND [DP].[Dicht] = 1
|
|
LEFT JOIN [Cordonel_PressureTest] AS [CPT] ON [CPT].[CordonelPressureTest_PcbId] = [PCB].[MapPcbIdToSerialNumber_PcbId]
|
|
AND [CPT].[CordonelPressureTest_Valid] = 1
|
|
WHERE [APS].[AuftragNr] = @{nameof(orderId)}
|
|
GROUP BY [APS].[PositionNr]
|
|
, [APS].[SerienNr]
|
|
, [APS].[KundeneigeneSerienNr]
|
|
, [CPT].[CordonelPressureTest_Valid]
|
|
, [DP].[Dicht]
|
|
, [CRRH].[Result]
|
|
ORDER BY [APS].[PositionNr]
|
|
, ISNULL([APS].[KundeneigeneSerienNr], [APS].[SerienNr])")
|
|
.SetParameter(nameof(orderId), orderId)
|
|
.ExecuteReader(reader => new TestStatus
|
|
{
|
|
PosNr = $"{reader.GetSmallint()}",
|
|
SerialNr = reader.GetString(),
|
|
HeliumTest = reader.GetValue<bool?>(),
|
|
PressureTest = reader.GetValue<bool?>(),
|
|
MetroTest = this.MetrologicalValue(reader.GetValue<byte?>()),
|
|
RadioTest = reader.GetValue<bool?>(),
|
|
});
|
|
|
|
public bool OrderCompleted(int orderId)
|
|
{
|
|
var sumResults = this.fluentSQL
|
|
.CreateCommand($@"
|
|
SELECT CAST(CASE WHEN ISNULL([CPT].[CordonelPressureTest_Valid], 1) = 1 THEN 0 ELSE 1 END AS INT)
|
|
+ CAST(CASE WHEN ISNULL([DP].[Dicht], 1) = 1 THEN 0 ELSE 1 END AS INT)
|
|
+ ISNULL(MAX([APS].[StatusFertigung]) - 30, 0)
|
|
+ CAST(CASE WHEN ISNULL([CRRH].[Result], 1) = 1 THEN 0 ELSE 1 END AS INT)
|
|
FROM [AuftragPositionSerienNr] AS [APS]
|
|
LEFT JOIN [Genesis_Meter] AS [GM] ON [GM].[Seriennummer] = [APS].[SerienNr]
|
|
LEFT JOIN [MapPcbIdToSerialNumber] AS [PCB] ON [PCB].[MapPcbIdToSerialNumber_SerialNumber] = [GM].[Seriennummer]
|
|
LEFT JOIN [Cordonel_Radio_RSSI_History] AS [CRRH] ON [CRRH].[RadioAdress] = [GM].[Adresse] - 10000000000
|
|
AND [CRRH].[IsLast] = 1
|
|
AND [CRRH].[Result] = 1
|
|
LEFT JOIN [Druckpruefung] AS [DP] ON [DP].[FabNr] = [PCB].[MapPcbIdToSerialNumber_PcbId]
|
|
AND [DP].[Dicht] = 1
|
|
LEFT JOIN [Cordonel_PressureTest] AS [CPT] ON [CPT].[CordonelPressureTest_PcbId] = [PCB].[MapPcbIdToSerialNumber_PcbId]
|
|
AND [CPT].[CordonelPressureTest_Valid] = 1
|
|
WHERE [APS].[AuftragNr] = @{nameof(orderId)}
|
|
GROUP BY [APS].[PositionNr]
|
|
, [APS].[SerienNr]
|
|
, [APS].[KundeneigeneSerienNr]
|
|
, [CPT].[CordonelPressureTest_Valid]
|
|
, [DP].[Dicht]
|
|
, [CRRH].[Result]")
|
|
.SetParameter(nameof(orderId), orderId)
|
|
.ExecuteReader(reader => reader.GetInt())
|
|
.Sum(x => x);
|
|
|
|
return sumResults == 0;
|
|
}
|
|
|
|
public int SaveFile(Stream fileStream, int clientId, int orderId)
|
|
{
|
|
var fileName = $"{clientId}_{orderId}.pdf";
|
|
var fileContent = this.GetBuffer(fileStream);
|
|
|
|
return this.fluentSQL
|
|
.CreateCommand($@"
|
|
INSERT INTO [dbo].[File] (
|
|
[FileName]
|
|
, [FileContent])
|
|
OUTPUT @{nameof(orderId)}, [Inserted].[FileId], 'PROTOCOL'
|
|
INTO [dbo].[FilesOrders]([OrderId], [FileId], [Usage])
|
|
OUTPUT [Inserted].[FileId]
|
|
VALUES (@{nameof(fileName)}
|
|
, @{nameof(fileContent)})")
|
|
.SetParameter(nameof(orderId), orderId)
|
|
.SetParameter(nameof(fileName), fileName)
|
|
.SetParameter(nameof(fileContent), fileContent)
|
|
.ExecuteScalar(x => x.GetInt());
|
|
}
|
|
|
|
private byte[] GetBuffer(Stream fileStream)
|
|
{
|
|
var fileContent = new byte[fileStream.Length];
|
|
|
|
using (var memoryStream = new MemoryStream())
|
|
{
|
|
fileStream.CopyTo(memoryStream);
|
|
|
|
fileContent = memoryStream.ToArray();
|
|
}
|
|
|
|
return fileContent;
|
|
}
|
|
|
|
private bool? MetrologicalValue(byte? value)
|
|
{
|
|
if (value is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return value == 30;
|
|
}
|
|
}
|
|
} |