419 lines
18 KiB
C#
419 lines
18 KiB
C#
namespace Xylem.Common.Service.MeterProcessState.Controllers
|
|
{
|
|
using global::Common.Logic.Extensions.SQL;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Configuration;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Web.Http;
|
|
|
|
using Xylem.Common.Logic.ProductionOrderCore.TestResults;
|
|
using Xylem.Common.Logic.ServiceCore;
|
|
|
|
[RoutePrefix("api/TestBench")]
|
|
public class TestBenchController : ApiController
|
|
{
|
|
public static class GlobalConfig
|
|
{
|
|
public static Lazy<String> connectionString = new Lazy<String>(() => ConfigurationManager.ConnectionStrings["default"].ConnectionString);
|
|
}
|
|
|
|
public static readonly Lazy<String> ConnectionString = new Lazy<String>(() => ConfigurationManager.ConnectionStrings["default"].ConnectionString);
|
|
|
|
/// <summary>
|
|
/// SetMeterLogPathInfo
|
|
/// </summary>
|
|
/// <param name="SerialNumber">PcbID from Meter</param>
|
|
/// <param name="TestRunId"> </param>
|
|
/// <param name="CalibrationRunId"> </param>
|
|
/// <param name="BasePath"> </param>
|
|
/// <param name="MainLogName"> </param>
|
|
/// <param name="LEDName"> </param>
|
|
/// <returns></returns>
|
|
[Route("SetMeterLogPathInfo"), HttpGet]
|
|
public IHttpActionResult SetMeterLogPathInfo(Int32 SerialNumber, Int32? TestRunId = null, Int32? CalibrationRunId = null, String BasePath = "", String MainLogName = "", String LEDName = "")
|
|
{
|
|
var rowsAffected = SQLConnection
|
|
.CreateSQLConnection(ConnectionString.Value)
|
|
.CreateCommand($@"
|
|
INSERT
|
|
INTO [CordonelLogFiles]
|
|
( [SerialNumber]
|
|
, [TestRunId]
|
|
, [CalibrationRunId]
|
|
, [BasePath]
|
|
, [MainLog]
|
|
, [LED])
|
|
VALUES (@{nameof(SerialNumber)}
|
|
, @{nameof(TestRunId)}
|
|
, @{nameof(CalibrationRunId)}
|
|
, @{nameof(BasePath)}
|
|
, @{nameof(MainLogName)}
|
|
, @{nameof(LEDName)})")
|
|
.SetParameter(nameof(SerialNumber), SerialNumber)
|
|
.SetParameter(nameof(TestRunId), TestRunId)
|
|
.SetParameter(nameof(CalibrationRunId), CalibrationRunId)
|
|
.SetParameter(nameof(BasePath), BasePath)
|
|
.SetParameter(nameof(MainLogName), MainLogName)
|
|
.SetParameter(nameof(LEDName), LEDName)
|
|
.ExecuteNonQuery();
|
|
|
|
if (rowsAffected == 1)
|
|
{
|
|
return this.Ok();
|
|
}
|
|
|
|
return this.BadRequest("Invalid data.");
|
|
}
|
|
|
|
[Route("SetCalibrationValues"), HttpPost]
|
|
public IHttpActionResult SetCalibrationValues([FromBody] JustageResults val)
|
|
{
|
|
var rowsAffected = SQLConnection
|
|
.CreateSQLConnection(ConnectionString.Value)
|
|
.CreateCommand($@"
|
|
|
|
INSERT INTO[dbo].[Cordonel_Q3Calibration]
|
|
([PcbId]
|
|
,[P1Offset]
|
|
,[P1Cal]
|
|
,[P2Offset]
|
|
,[P2Cal]
|
|
,[P3Offset]
|
|
,[P3Cal]
|
|
,[Date])
|
|
VALUES (@{nameof(JustageResults.pcbId)}
|
|
, @{nameof(JustageResults.p1Target)}
|
|
, @{nameof(JustageResults.p1Value)}
|
|
, @{nameof(JustageResults.p2Target)}
|
|
, @{nameof(JustageResults.p2Value)}
|
|
, @{nameof(JustageResults.p3Target)}
|
|
, @{nameof(JustageResults.p3Value)}
|
|
, @{nameof(JustageResults.dt)})")
|
|
.SetParameter(nameof(JustageResults.pcbId), int.Parse(val.pcbId))
|
|
.SetParameter(nameof(JustageResults.p1Target), val.p1Target)
|
|
.SetParameter(nameof(JustageResults.p1Value), ((Int32)val.p1Value))
|
|
.SetParameter(nameof(JustageResults.p2Target), val.p2Target)
|
|
.SetParameter(nameof(JustageResults.p2Value), ((Int32)val.p2Value))
|
|
.SetParameter(nameof(JustageResults.p3Target), val.p3Target)
|
|
.SetParameter(nameof(JustageResults.p3Value), ((Int32)val.p3Value))
|
|
.SetParameter(nameof(JustageResults.dt), val.dt)
|
|
.ExecuteNonQuery();
|
|
|
|
if (rowsAffected == 1)
|
|
{
|
|
return this.Ok();
|
|
}
|
|
|
|
return this.BadRequest("Invalid data.");
|
|
}
|
|
/// <summary>
|
|
/// Get SerialNumber from PcbID
|
|
/// </summary>
|
|
/// <param name="PcbID">PcbID from Meter</param>
|
|
/// <returns></returns>
|
|
[Route("GetMeterInfoForTestBench"), HttpGet]
|
|
public IHttpActionResult GetMeterInfoForTestBench(String PcbID)
|
|
{
|
|
var results = SQLConnection
|
|
.CreateSQLConnection(ConnectionString.Value)
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[MapPcbIdToSerialNumber_SerialNumber] AS [SerialNr]
|
|
, [MapOrder].[CordonelAssignedPicking_FertigungsAuftragsNr] AS [FertigungsNr]
|
|
, [Meter].[Adresse] AS [RadioAddress]
|
|
, [KundeneigeneSerienNr] AS [CustomerSerialNr]
|
|
, (SELECT TOP 1 [ID]
|
|
FROM [CordonelMeterCalibrationResults]
|
|
WHERE [PcbId] = @{nameof(PcbID)}
|
|
ORDER BY [Date] DESC) AS [CalibrationRunID]
|
|
, (SELECT TOP 1 [StatusFertigung]
|
|
FROM [AuftragPositionSerienNr]
|
|
WHERE [SerienNr] = [MapPcbIdToSerialNumber_SerialNumber]
|
|
ORDER BY [AnlageDatum] DESC) AS [LastProcessState]
|
|
, [Nennweite] AS [Dn]
|
|
, (SELECT TOP 1 [Dn_InternalId]
|
|
FROM [CordonelMeterSizes]
|
|
WHERE [Dn_VakoID] = SUBSTRING([Identnr].[VakoCode], 4, 2)) AS [NewNennweiteID]
|
|
, [lut].[FileCrc] AS [LutCrc]
|
|
, fw.Version as FWVersion
|
|
FROM [Cordonel_AssignedPicking] AS [MapOrder]
|
|
LEFT OUTER JOIN [MapPcbIdToSerialNumber] AS [map]
|
|
ON [MapOrder].[CordonelAssignedPicking_PcbId] = [map].[MapPcbIdToSerialNumber_PcbId]
|
|
AND [map].[MapPcbIdToSerialNumber_Deleted] = 0
|
|
LEFT OUTER JOIN [AuftragPositionSerienNr] AS [mapSrn]
|
|
ON [map].[MapPcbIdToSerialNumber_SerialNumber] = [mapSrn].[SerienNr]
|
|
AND [mapSrn].[Pruefgangnr] = 0
|
|
LEFT OUTER JOIN [AuftragPosition_gesamt] AS [auftraginfo]
|
|
ON [auftraginfo].[AuftragNr] = [mapSrn].[AuftragNr]
|
|
AND [auftraginfo].[PositionNr] = [mapSrn].[PositionNr]
|
|
LEFT OUTER JOIN [Genesis_Meter] AS [Meter]
|
|
ON [Meter].[Seriennummer] = [map].[MapPcbIdToSerialNumber_SerialNumber]
|
|
LEFT OUTER JOIN [Identnr]
|
|
ON [auftraginfo].[Identnr] = [Identnr].[IdentNr]
|
|
LEFT OUTER JOIN [Cordonel_Lut] AS [lut]
|
|
ON [lut].[MeterSize] = (SELECT TOP 1 [Dn_InternalId]
|
|
FROM [CordonelMeterSizes]
|
|
WHERE [Dn_VakoID] = SUBSTRING([Identnr].[VakoCode], 4, 2))
|
|
AND [lut].[CurrentVersionForProd] = 1
|
|
left outer join Cordonel_CurrentFw AS fw
|
|
ON [fw].Metersize = (SELECT TOP 1 [Dn_InternalId]
|
|
FROM [CordonelMeterSizes]
|
|
WHERE [Dn_VakoID] = SUBSTRING([Identnr].[VakoCode], 4, 2))
|
|
AND [fw].CurrentForProd = 1
|
|
|
|
WHERE [MapOrder].[CordonelAssignedPicking_IsDeleted] = 0
|
|
AND [MapOrder].[CordonelAssignedPicking_PcbId] = @{nameof(PcbID)} ")
|
|
.SetParameter(nameof(PcbID), PcbID)
|
|
.ExecuteReader(x => new string[]
|
|
{
|
|
$"{x.GetValue<Int32>(0)}", // SerialNr,
|
|
$"{x.GetValue<Int32>(1)}", // FertigungsNr,
|
|
$"{x.GetValue<Int64>(2)}", // RadioAddress,
|
|
$"{x.GetValue<String>(3)}", // CustomerSerialNr,
|
|
$"{x.GetValue<Int32?>(4)}", // CalibrationRunID,
|
|
$"{x.GetValue<Byte>(5)}", // LastProcessState,
|
|
$"{x.GetValue<Int32>(6)}", // Dn,
|
|
$"{x.GetValue<Int32>(7)}", // NewNennweiteID,
|
|
$"{x.GetValue<Int32?>(8)}", // LutCrc
|
|
$"{x.GetValue<Int32?>(9)}", // Fwversion
|
|
});
|
|
|
|
if (results.Count() == 1)
|
|
{
|
|
return this.Ok(results.FirstOrDefault());
|
|
}
|
|
|
|
return this.Content(HttpStatusCode.BadRequest, new string[] { string.Empty, string.Empty, string.Empty });
|
|
}
|
|
|
|
[HttpGet]
|
|
[Route("GetOffsetCalibration/{pcbId}")]
|
|
public IHttpActionResult GetOffsetCalibration(int pcbId)
|
|
{
|
|
var offset = SQLConnection
|
|
.CreateSQLConnection(ConnectionString.Value)
|
|
.CreateCommand($@"
|
|
SELECT [PcbId]
|
|
, [TestRunNr]
|
|
, [Offset]
|
|
FROM [Cordonel_Calibrations]
|
|
WHERE [PcbId] = @{nameof(pcbId)}")
|
|
.SetParameter(nameof(pcbId), pcbId)
|
|
.FirstOrDefault(x => new CordonelCalibration
|
|
{
|
|
PcbId = x.GetValue<Int32>(0),
|
|
TestRunNr = x.GetValue<Int32>(1),
|
|
Offset = x.GetValue<Double>(2)
|
|
});
|
|
|
|
return this.Ok();
|
|
}
|
|
|
|
[HttpPost]
|
|
public IHttpActionResult AddOffsetCalibration([FromBody] CordonelCalibration model)
|
|
{
|
|
var rowsAffected = SQLConnection
|
|
.CreateSQLConnection(ConnectionString.Value)
|
|
.CreateCommand($@"
|
|
INSERT
|
|
INTO [Cordonel_Calibrations]
|
|
( [PcbId]
|
|
, [TestRunNr]
|
|
, [Offset])
|
|
VALUES (@{nameof(CordonelCalibration.PcbId)}
|
|
, @{nameof(CordonelCalibration.TestRunNr)}
|
|
, @{nameof(CordonelCalibration.Offset)})")
|
|
.SetParameter(nameof(CordonelCalibration.PcbId), model.PcbId)
|
|
.SetParameter(nameof(CordonelCalibration.TestRunNr), model.TestRunNr)
|
|
.SetParameter(nameof(CordonelCalibration.Offset), model.Offset)
|
|
.ExecuteNonQuery();
|
|
|
|
if (rowsAffected == 1)
|
|
{
|
|
return this.Ok();
|
|
}
|
|
|
|
return this.BadRequest("Invalid data.");
|
|
}
|
|
|
|
[HttpPost]
|
|
public IHttpActionResult SetOffsetCalibration([FromBody] CordonelCalibration model)
|
|
{
|
|
var rowsAffected = SQLConnection
|
|
.CreateSQLConnection(ConnectionString.Value)
|
|
.CreateCommand($@"
|
|
UPDATE [Cordonel_Calibrations]
|
|
SET [TestRunNr] = @{nameof(CordonelCalibration.TestRunNr)}
|
|
, [Offset] = @{nameof(CordonelCalibration.Offset)}
|
|
WHERE [PcbId] = @{nameof(CordonelCalibration.PcbId)}")
|
|
.SetParameter(nameof(CordonelCalibration.TestRunNr), model.TestRunNr)
|
|
.SetParameter(nameof(CordonelCalibration.Offset), model.Offset)
|
|
.SetParameter(nameof(CordonelCalibration.PcbId), model.PcbId)
|
|
.ExecuteNonQuery();
|
|
|
|
if (rowsAffected == 1)
|
|
{
|
|
return this.Ok();
|
|
}
|
|
|
|
return this.BadRequest("Invalid data.");
|
|
}
|
|
|
|
|
|
|
|
[Route("GetTestResults"), HttpGet]
|
|
public IHttpActionResult GetTestResults(int SerialNr, int TestRunNr)
|
|
{
|
|
using (var dataacces = new SqlDataAccess(GlobalConfig.connectionString.Value))
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.AppendLine($@"
|
|
Select
|
|
p.PruefgangNr,
|
|
p.PruefstationNr,
|
|
p.Datum,
|
|
p.Typ ,
|
|
p.Nennweite ,
|
|
p.Nenntemperatur ,
|
|
p.Lufttemperatur ,
|
|
p.LuftDruck,
|
|
p.RelativeFeuchte,
|
|
p.Vorlauftemperatur,
|
|
p.Anzahl, ");
|
|
|
|
|
|
|
|
for (int i = 1; i < 10; i++)
|
|
{
|
|
sb.AppendLine($"p.PP{i}_Zeit,");
|
|
|
|
sb.AppendLine($"p.PP{i}_Soll , ");
|
|
sb.AppendLine($"p.PP{i}_Ist , ");
|
|
sb.AppendLine($"p.PP{i}_RefZSerienNr , ");
|
|
sb.AppendLine($"p.PP{i}_RefFehl , ");
|
|
sb.AppendLine($"p.PP{i}_Ist_V , ");
|
|
sb.AppendLine($"p.PP{i}_Waage , ");
|
|
sb.AppendLine($"p.PP{i}_Info , ");
|
|
|
|
|
|
sb.AppendLine($"f.PP{i}_Fehler as PP{i}DisplayError,");
|
|
|
|
|
|
|
|
sb.AppendLine($"f1.PP{i}_Fehler as PP{i}Chnl_1_Error,");
|
|
sb.AppendLine($"f1.PP{i}_TimeS as PP{i}Chnl_1_TimeS,");
|
|
sb.AppendLine($"f1.PP{i}_VolumeQm as PP{i}Chnl_1_VolumeQm, ");
|
|
|
|
|
|
|
|
sb.AppendLine($"f2.PP{i}_Fehler as PP{i}Chnl_2_Error,");
|
|
sb.AppendLine($"f2.PP{i}_TimeS as PP{i}Chnl_2_TimeS,");
|
|
sb.AppendLine($"f2.PP{i}_VolumeQm as PP{i}Chnl_2_VolumeQm, ");
|
|
|
|
|
|
sb.AppendLine($"f3.PP{i}_Fehler as PP{i}Chnl_3_Error,");
|
|
sb.AppendLine($"f3.PP{i}_TimeS as PP{i}Chnl_3_TimeS,");
|
|
sb.AppendLine($"f3.PP{i}_VolumeQm as PP{i}Chnl_3_VolumeQm, ");
|
|
}
|
|
|
|
sb.AppendLine($@"
|
|
p.Bemerkung
|
|
from Pruefgang p
|
|
inner
|
|
join Prueffehler f on f.PruefgangNr = p.PruefgangNr and f.SerienNr = {SerialNr}
|
|
inner join PrueffehlerGenesisPfade f1 on f1.PruefgangNr = p.PruefgangNr and f1.SerienNr = {SerialNr} and f1.Pfad = 1
|
|
inner join PrueffehlerGenesisPfade f2 on f2.PruefgangNr = p.PruefgangNr and f2.SerienNr = {SerialNr} and f2.Pfad = 2
|
|
inner join PrueffehlerGenesisPfade f3 on f3.PruefgangNr = p.PruefgangNr and f3.SerienNr = {SerialNr} and f3.Pfad = 3
|
|
where p.PruefgangNr = {TestRunNr}");
|
|
|
|
var dt = dataacces.ExecuteQuery(sb.ToString());
|
|
|
|
|
|
if (dt.Rows.Count != 1)
|
|
{
|
|
return this.Content(HttpStatusCode.BadRequest, new string[] { });
|
|
}
|
|
var tr = new TestResults();
|
|
tr.Serialnr = SerialNr;
|
|
tr.TestRunNr = TestRunNr;
|
|
|
|
|
|
//Convert.ToInt32(
|
|
var dr = dt.Rows[0];
|
|
tr.TestBenchNr = Convert.ToInt32(dr["PruefstationNr"]);
|
|
tr.Date = Convert.ToDateTime(dr["Datum"]);
|
|
tr.MeterType = dt.Rows[0]["Typ"].ToString();
|
|
tr.MeterSize = Convert.ToInt32(dr["Nennweite"]);
|
|
tr.AirTempC = Convert.ToDouble(dr["Lufttemperatur"]);
|
|
tr.AirPressure = Convert.ToDouble(dr["LuftDruck"]);
|
|
tr.AirHumanity = Convert.ToDouble(dr["RelativeFeuchte"]);
|
|
tr.WaterTempC = Convert.ToDouble(dr["Vorlauftemperatur"]);
|
|
tr.TotalMeters = Convert.ToInt32(dr["Anzahl"]);
|
|
tr.Remark = dr["Bemerkung"].ToString();
|
|
|
|
tr.Details = new List<TestPointDetail>();
|
|
tr.TestPointsChannels = new List<ChnlTestPoint>();
|
|
tr.TestPointsMain = new List<TestPoint>();
|
|
for (int i = 1; i < 10; i++)
|
|
{
|
|
try
|
|
{
|
|
var d = new TestPointDetail();
|
|
|
|
if (dr[$"PP{i}_Soll"] is DBNull)
|
|
{
|
|
continue;
|
|
}
|
|
d.TimeS = Convert.ToDouble(dr[$"PP{i}_Zeit"]);
|
|
d.FlowTargetQmh = Convert.ToDouble(dr[$"PP{i}_Soll"]);
|
|
d.FlowrateQmh = Convert.ToDouble(dr[$"PP{i}_Ist"]);
|
|
d.VolumeQm = Convert.ToDouble(dr[$"PP{i}_Ist_V"]);
|
|
d.Info = dr[$"PP{i}_Info"].ToString();
|
|
d.Scale = Convert.ToBoolean(dr[$"PP{i}_Waage"]);
|
|
|
|
tr.Details.Add(d);
|
|
var m = new TestPoint();
|
|
m.TestPointNr = i;
|
|
|
|
m.Error = Convert.ToDouble(dr[$"PP{i}DisplayError"]);
|
|
tr.TestPointsMain.Add(m);
|
|
|
|
for (int z = 1; z < 3; z++)
|
|
{
|
|
var c = new ChnlTestPoint();
|
|
c.TestPointNr = i;
|
|
c.ChanlNr = z;
|
|
c.Error = Convert.ToDouble(dr[$"PP{i}Chnl_{z}_Error"]);
|
|
c.TimeS = Convert.ToDouble(dr[$"PP{i}Chnl_{z}_TimeS"]);
|
|
c.VolumenQm = Convert.ToDouble(dr[$"PP{i}Chnl_{z}_VolumeQm"]);
|
|
tr.TestPointsChannels.Add(c);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return this.Content(HttpStatusCode.OK, tr);
|
|
}
|
|
}
|
|
|
|
public class CordonelCalibration
|
|
{
|
|
public int PcbId { get; set; }
|
|
|
|
public int TestRunNr { get; set; }
|
|
|
|
public double Offset { get; set; }
|
|
}
|
|
}
|
|
}
|