626 lines
32 KiB
C#
626 lines
32 KiB
C#
namespace LaaProduction.Services
|
|
{
|
|
using LaaPackages.SqlClient;
|
|
using LaaProduction.Services.Interfaces;
|
|
using LaaProduction.Services.Models;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
public class ShipmentsService : IShipmentsService
|
|
{
|
|
private readonly SqlConnection sqlConnection;
|
|
|
|
public ShipmentsService(SqlConnection sqlConnection)
|
|
=> this.sqlConnection = sqlConnection;
|
|
|
|
public OrderScanModel DeletePalletEntry(Int32 id)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
DELETE
|
|
FROM [PalettenScan]
|
|
OUTPUT [deleted].[AuftragNr]
|
|
, [deleted].[PositionNr]
|
|
, [deleted].[PalettenNr]
|
|
WHERE [ID] = @{nameof(id)}")
|
|
.SetParameter(nameof(id), id)
|
|
.FirstOrDefault(x => new OrderScanModel
|
|
{
|
|
OrderNr = x.GetValue<Int32>(0),
|
|
PositionNr = x.GetValue<Int32>(1),
|
|
PalletNr = x.GetValue<Int16>(2)
|
|
});
|
|
|
|
public Byte[] LoadBatchBuffer(OrderScanModel model)
|
|
{
|
|
var palletLoad = this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT [PalettenNr]
|
|
, [SerienNr]
|
|
FROM [PalettenScan]
|
|
WHERE [AuftragNr] = @{nameof(model.OrderNr)}
|
|
AND [PositionNr] = @{nameof(model.PositionNr)}
|
|
AND [PalettenNr] = @{nameof(model.PalletNr)}
|
|
ORDER BY [SerienNr]")
|
|
.SetParameter(nameof(model.OrderNr), model.OrderNr)
|
|
.SetParameter(nameof(model.PositionNr), model.PositionNr)
|
|
.SetParameter(nameof(model.PalletNr), model.PalletNr)
|
|
.ExecuteReader(reader => String.Join(",", new String[]
|
|
{
|
|
reader.GetValue<String>(0),
|
|
reader.GetValue<String>(1),
|
|
}));
|
|
var csvContent = String.Join(Environment.NewLine, palletLoad);
|
|
|
|
return Encoding.UTF8.GetBytes($"Pallet Nr.,Serial Nr.{Environment.NewLine}{csvContent}");
|
|
}
|
|
|
|
public PalletsBatchModel LoadBatchModel(OrderScanModel model)
|
|
{
|
|
var batchModel = new PalletsBatchModel();
|
|
|
|
if (model != null && model.OrderNr != null)
|
|
{
|
|
var orderNo = model.OrderNr.Value;
|
|
var positionNo = model.PositionNr > 0 ? model.PositionNr : null;
|
|
var palletNo = model.PalletNr > 0 ? model.PalletNr : null;
|
|
|
|
batchModel = this.LoadBatchModel(orderNo, positionNo, palletNo);
|
|
|
|
if (positionNo is null)
|
|
{
|
|
if (this.PalletNrExists(orderNo, palletNo))
|
|
{
|
|
batchModel.Positions = this.LoadPalletPositions(orderNo, palletNo);
|
|
}
|
|
else
|
|
{
|
|
batchModel.Positions = this.LoadLastPalletPositions(orderNo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.SamePallet(orderNo, positionNo, palletNo))
|
|
{
|
|
batchModel.Positions = this.LoadPalletPosition(orderNo, positionNo, palletNo);
|
|
}
|
|
else
|
|
{
|
|
batchModel.Positions = this.LoadLastPalletPosition(orderNo, positionNo);
|
|
}
|
|
}
|
|
}
|
|
|
|
return batchModel;
|
|
}
|
|
|
|
public IEnumerable<MissingItem> MissingItems()
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
DECLARE @PalletOrders TABLE([OrderNo] INT NOT NULL)
|
|
INSERT INTO @PalletOrders([OrderNo])
|
|
SELECT DISTINCT [AuftragNr] FROM [PalettenScan]
|
|
|
|
SELECT [result].[Date]
|
|
, [result].[OrderNo]
|
|
, [result].[PosNo]
|
|
, [result].[SerialNo]
|
|
, [result].[CustomSerial]
|
|
, [result].[Bezeichnung]
|
|
, [result].[Type]
|
|
FROM (SELECT DISTINCT
|
|
CAST(MAX([x].[Date]) AS DATE) AS [Date]
|
|
, [x].[OrderNo]
|
|
, [x].[PosNo]
|
|
, [x].[SerialNo]
|
|
, [dbo].[NORMALIZE_SERIAL]([x].[CustomSerialNo]) AS [CustomSerial]
|
|
, ([inr].[Typ]
|
|
+ ' '
|
|
+ CASE WHEN [inr].[Typzusatz] IS NULL
|
|
THEN CAST([inr].[Nennweite] AS NVARCHAR(100))
|
|
ELSE [inr].[Typzusatz]
|
|
+ ' '
|
|
+ CAST([inr].[Nennweite] AS NVARCHAR(100))
|
|
END) AS [Type]
|
|
, [inr].[Bezeichnung]
|
|
FROM (SELECT CAST([aps].[AnlageDatum] AS DATE) AS [Date]
|
|
, [aps].[AuftragNr] AS [OrderNo]
|
|
, [aps].[PositionNr] AS [PosNo]
|
|
, [aps].[SerienNr] AS [SerialNo]
|
|
, ISNULL([aps].[KundeneigeneSerienNr], [aps].[SerienNr]) AS [CustomSerialNo]
|
|
FROM [AuftragPositionSerienNr] AS [aps]
|
|
JOIN @PalletOrders AS [po]
|
|
ON [po].[OrderNo] = [aps].[AuftragNr]
|
|
LEFT JOIN [PalettenScan] AS [ps]
|
|
ON [ps].[AuftragNr] = [aps].[AuftragNr]
|
|
AND [ps].[PositionNr] = [aps].[PositionNr]
|
|
AND [ps].[SerienNr] = [dbo].[NORMALIZE_SERIAL]([aps].[KundeneigeneSerienNr])
|
|
WHERE [ps].[SerienNr] IS NULL)
|
|
AS [x]
|
|
JOIN [AlleAuftragPositionen] AS [aap]
|
|
ON [aap].[AuftragNr] = [x].[OrderNo]
|
|
AND [aap].[PositionNr] = [x].[PosNo]
|
|
JOIN [Identnr] AS [inr]
|
|
ON [inr].[IdentNr] = [aap].[IdentNr]
|
|
GROUP BY [x].[OrderNo]
|
|
, [x].[PosNo]
|
|
, [x].[SerialNo]
|
|
, [x].[CustomSerialNo]
|
|
, [inr].[Typ]
|
|
, [inr].[Typzusatz]
|
|
, [inr].[Nennweite]
|
|
, [inr].[Bezeichnung])
|
|
AS [result]
|
|
ORDER BY [result].[OrderNo] DESC")
|
|
.ExecuteReader(x => new MissingItem
|
|
{
|
|
EntryDate = x.GetValue<DateTime>(0),
|
|
OrderNr = x.GetValue<Int32>(1),
|
|
PosNr = x.GetValue<Int16>(2),
|
|
SerialNr = x.GetValue<Int32>(3),
|
|
CustomSerial = x.GetValue<String>(4),
|
|
Term = x.GetValue<String>(5),
|
|
Type = x.GetValue<String>(6)
|
|
});
|
|
|
|
private Boolean PalletNrExists(Int32 orderNo, Int32? palletNo)
|
|
{
|
|
var countPalletsByNo = this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT ISNULL(COUNT(1), 0) AS [Found]
|
|
FROM [PalettenScan] AS [PS]
|
|
WHERE [PS].[AuftragNr] = @{nameof(orderNo)}
|
|
AND [PS].[PalettenNr] = @{nameof(palletNo)}")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.SetParameter(nameof(palletNo), palletNo)
|
|
.FirstOrDefault(x => x.GetValue<Int32>(0));
|
|
|
|
return countPalletsByNo > 0;
|
|
}
|
|
|
|
private IEnumerable<PalletPosition> LoadLastPalletPositions(Int32 orderNo)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
DECLARE @palettenNr INT;
|
|
|
|
SELECT @palettenNr = MAX([PalettenNr])
|
|
FROM [PalettenScan]
|
|
WHERE [AuftragNr] = @{nameof(orderNo)}
|
|
|
|
SELECT DISTINCT
|
|
[aap].[PositionNr] AS [Pos]
|
|
, [in].[Typ] AS [Typ]
|
|
, [in].[Typzusatz] AS [Typzusatz]
|
|
, [in].[Nennweite] AS [Nennweite]
|
|
, (SELECT COUNT(1)
|
|
FROM [PalettenScan] AS [x]
|
|
WHERE [x].[AuftragNr] = [ps].[AuftragNr]
|
|
AND [x].[PositionNr] = [ps].[PositionNr]
|
|
AND [x].[PalettenNr] = [ps].[PalettenNr])
|
|
, (SELECT TOP 1 [Menge]
|
|
FROM [AlleAuftragPositionen] AS [x]
|
|
WHERE [x].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [x].[PositionNr] = [aap].[PositionNr])
|
|
, [aap].[AuftragNr]
|
|
, [aap].[PositionNr]
|
|
, [ps].[PalettenNr]
|
|
FROM [Identnr] AS [in]
|
|
JOIN [AlleAuftragPositionen] AS [aap]
|
|
ON [aap].[IdentNr] = [in].[IdentNr]
|
|
LEFT JOIN [PalettenScan] AS [ps]
|
|
ON [ps].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [ps].[PositionNr] = [aap].[PositionNr]
|
|
WHERE [aap].[AuftragNr] = @{nameof(orderNo)}
|
|
AND [ps].[PalettenNr] = @palettenNr")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.ExecuteReader(this.LoadPalletPosition);
|
|
|
|
private IEnumerable<PalletPosition> LoadPalletPositions(Int32 orderNo, Int32? palletNo)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[aap].[PositionNr] AS [Pos]
|
|
, [in].[Typ] AS [Typ]
|
|
, [in].[Typzusatz] AS [Typzusatz]
|
|
, [in].[Nennweite] AS [Nennweite]
|
|
, (SELECT COUNT(1)
|
|
FROM [PalettenScan] AS [x]
|
|
WHERE [x].[AuftragNr] = [ps].[AuftragNr]
|
|
AND [x].[PositionNr] = [ps].[PositionNr]
|
|
AND [x].[PalettenNr] = [ps].[PalettenNr])
|
|
, (SELECT TOP 1 [Menge]
|
|
FROM [AlleAuftragPositionen] AS [x]
|
|
WHERE [x].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [x].[PositionNr] = [aap].[PositionNr])
|
|
, [aap].[AuftragNr]
|
|
, [aap].[PositionNr]
|
|
, [ps].[PalettenNr]
|
|
FROM [Identnr] AS [in]
|
|
JOIN [AlleAuftragPositionen] AS [aap]
|
|
ON [aap].[IdentNr] = [in].[IdentNr]
|
|
LEFT JOIN [PalettenScan] AS [ps]
|
|
ON [ps].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [ps].[PositionNr] = [aap].[PositionNr]
|
|
WHERE [aap].[AuftragNr] = @{nameof(orderNo)}
|
|
AND [ps].[PalettenNr] = @{nameof(palletNo)}")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.SetParameter(nameof(palletNo), palletNo)
|
|
.ExecuteReader(this.LoadPalletPosition);
|
|
|
|
private Boolean SamePallet(Int32 orderNo, Int32? positionNo, Int32? palletNo)
|
|
{
|
|
var countPalletsByNo = this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT ISNULL(COUNT(1), 0) AS [Found]
|
|
FROM [PalettenScan] AS [PS]
|
|
WHERE [PS].[AuftragNr] = @{nameof(orderNo)}
|
|
AND [PS].[PositionNr] = @{nameof(positionNo)}
|
|
AND [PS].[PalettenNr] = @{nameof(palletNo)}")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.SetParameter(nameof(positionNo), positionNo)
|
|
.SetParameter(nameof(palletNo), palletNo)
|
|
.FirstOrDefault(x => x.GetValue<Int32>(0));
|
|
|
|
return countPalletsByNo > 0;
|
|
}
|
|
|
|
private IEnumerable<PalletPosition> LoadLastPalletPosition(Int32 orderNo, Int32? positionNo)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
DECLARE @palettenNr INT;
|
|
|
|
SELECT @palettenNr = MAX([PalettenNr])
|
|
FROM [PalettenScan]
|
|
WHERE [AuftragNr] = @{nameof(orderNo)}
|
|
AND [PositionNr] = @{nameof(positionNo)}
|
|
|
|
SELECT DISTINCT
|
|
[aap].[PositionNr] AS [Pos]
|
|
, [in].[Typ] AS [Typ]
|
|
, [in].[Typzusatz] AS [Typzusatz]
|
|
, [in].[Nennweite] AS [Nennweite]
|
|
, (SELECT COUNT(1)
|
|
FROM [PalettenScan] AS [x]
|
|
WHERE [x].[AuftragNr] = [ps].[AuftragNr]
|
|
AND [x].[PositionNr] = [ps].[PositionNr]
|
|
AND [x].[PalettenNr] = [ps].[PalettenNr])
|
|
, (SELECT TOP 1 [Menge]
|
|
FROM [AlleAuftragPositionen] AS [x]
|
|
WHERE [x].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [x].[PositionNr] = [aap].[PositionNr])
|
|
, [aap].[AuftragNr]
|
|
, [aap].[PositionNr]
|
|
, [ps].[PalettenNr]
|
|
FROM [Identnr] AS [in]
|
|
JOIN [AlleAuftragPositionen] AS [aap]
|
|
ON [aap].[IdentNr] = [in].[IdentNr]
|
|
LEFT JOIN [PalettenScan] AS [ps]
|
|
ON [ps].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [ps].[PositionNr] = [aap].[PositionNr]
|
|
WHERE [aap].[AuftragNr] = @{nameof(orderNo)}
|
|
AND ([ps].[PalettenNr] = @palettenNr
|
|
OR [aap].[PositionNr] = @{nameof(positionNo)})")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.SetParameter(nameof(positionNo), positionNo)
|
|
.ExecuteReader(this.LoadPalletPosition);
|
|
|
|
private IEnumerable<PalletPosition> LoadPalletPosition(Int32 orderNo, Int32? positionNo, Int32? palletNo)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[aap].[PositionNr] AS [Pos]
|
|
, [in].[Typ] AS [Typ]
|
|
, [in].[Typzusatz] AS [Typzusatz]
|
|
, [in].[Nennweite] AS [Nennweite]
|
|
, (SELECT COUNT(1)
|
|
FROM [PalettenScan] AS [x]
|
|
WHERE [x].[AuftragNr] = [ps].[AuftragNr]
|
|
AND [x].[PositionNr] = [ps].[PositionNr]
|
|
AND [x].[PalettenNr] = [ps].[PalettenNr])
|
|
, (SELECT TOP 1 [Menge]
|
|
FROM [AlleAuftragPositionen] AS [x]
|
|
WHERE [x].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [x].[PositionNr] = [aap].[PositionNr])
|
|
, [aap].[AuftragNr]
|
|
, [aap].[PositionNr]
|
|
, [ps].[PalettenNr]
|
|
FROM [Identnr] AS [in]
|
|
JOIN [AlleAuftragPositionen] AS [aap]
|
|
ON [aap].[IdentNr] = [in].[IdentNr]
|
|
LEFT JOIN [PalettenScan] AS [ps]
|
|
ON [ps].[AuftragNr] = [aap].[AuftragNr]
|
|
AND [ps].[PositionNr] = [aap].[PositionNr]
|
|
WHERE [aap].[AuftragNr] = @{nameof(orderNo)}
|
|
AND [ps].[PositionNr] = @{nameof(positionNo)}
|
|
AND [ps].[PalettenNr] = @{nameof(palletNo)}")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.SetParameter(nameof(positionNo), positionNo)
|
|
.SetParameter(nameof(palletNo), palletNo)
|
|
.ExecuteReader(this.LoadPalletPosition);
|
|
|
|
private IEnumerable<SerialNr> LoadPalletItems(Int32 orderNo, Int32 posNo, Int32 palletNr)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT [x].[Id] AS [Id]
|
|
, [x].[PositionNr] AS [Pos]
|
|
, [x].[Serial] AS [Serial]
|
|
, [x].[CustomerSerial] AS [CustomerSerial]
|
|
, [x].[IsScanned] AS [IsScanned]
|
|
FROM (SELECT DISTINCT
|
|
[ps].[ID] AS [Id]
|
|
, [aps].[PositionNr] AS [PositionNr]
|
|
, [aps].[SerienNr] AS [Serial]
|
|
, ISNULL([dbo].[NORMALIZE_SERIAL]([aps].[KundeneigeneSerienNr]), [aps].[SerienNr]) AS [CustomerSerial]
|
|
, CAST(CASE WHEN [ps].[Datum] IS NOT NULL THEN 1 ELSE 0 END AS BIT) AS [IsScanned]
|
|
, [ps].[Datum] AS [DateAdded]
|
|
FROM [AuftragPositionSerienNr] AS [aps]
|
|
LEFT JOIN [PalettenScan] AS [ps]
|
|
ON [ps].[AuftragNr] = [aps].[AuftragNr]
|
|
AND [ps].[PositionNr] = [aps].[PositionNr]
|
|
AND [ps].[SerienNr] = [dbo].[NORMALIZE_SERIAL]([aps].[KundeneigeneSerienNr])
|
|
AND [ps].[PalettenNr] = @{nameof(palletNr)}
|
|
WHERE [aps].[AuftragNr] = @{nameof(orderNo)}
|
|
AND [aps].[PositionNr] = @{nameof(posNo)}
|
|
AND [dbo].[NORMALIZE_SERIAL]([aps].[KundeneigeneSerienNr])
|
|
NOT IN (SELECT [SerienNr]
|
|
FROM [PalettenScan]
|
|
WHERE [AuftragNr] = @{nameof(orderNo)}
|
|
AND [PositionNr] = @{nameof(posNo)}
|
|
AND [PalettenNr] != @{nameof(palletNr)}))
|
|
AS [x]
|
|
ORDER BY [x].[IsScanned] DESC
|
|
, [x].[CustomerSerial]")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.SetParameter(nameof(posNo), posNo)
|
|
.SetParameter(nameof(palletNr), palletNr)
|
|
.ExecuteReader(x => new SerialNr
|
|
{
|
|
Id = x.GetValue<Int32>(0),
|
|
PositionNr = x.GetValue<Int16>(1),
|
|
Serial = x.GetValue<Int32>(2),
|
|
CustomerSerial = x.GetValue<String>(3),
|
|
IsScanned = x.GetValue<Boolean>(4),
|
|
PalletNr = palletNr
|
|
});
|
|
|
|
private PalletsBatchModel LoadBatchModel(Int32 orderNo, Int32? posNo, Int32? palletNo)
|
|
{
|
|
var batchModel = this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT TOP 1
|
|
[AAP].[AuftragNr]
|
|
, [AAP].[FertigungsauftragNr]
|
|
, [Kunde].[Name]
|
|
, [AAP].[ZusatzText]
|
|
FROM [AlleAuftragPositionen] AS [AAP]
|
|
JOIN [Kunde] ON [Kunde].[KundenNr] = [AAP].[KundenNr]
|
|
WHERE [AAP].[AuftragNr] = @{nameof(orderNo)}
|
|
ORDER BY [AAP].[FertigungsauftragNr] DESC")
|
|
.SetParameter(nameof(orderNo), orderNo)
|
|
.SetParameter(nameof(posNo), posNo)
|
|
.FirstOrDefault(reader => new PalletsBatchModel
|
|
{
|
|
OrderNr = reader.GetValue<Int32>(0),
|
|
ProductionOrderNr = reader.GetValue<Int32>(1),
|
|
Customer = reader.GetValue<String>(2),
|
|
AdditionalText = reader.GetValue<String>(3)
|
|
});
|
|
|
|
return batchModel ?? new PalletsBatchModel();
|
|
}
|
|
|
|
public OrderScanModel LoadPallets(OrderScanModel model)
|
|
{
|
|
if (model != null && model.OrderNr != null && model.OrderNr > 0)
|
|
{
|
|
var pallets = this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT
|
|
[PSI].[PalettenNr]
|
|
, CAST(CASE WHEN [PSII].[ID] IS NULL
|
|
THEN 0
|
|
ELSE 1
|
|
END AS BIT)
|
|
FROM [PalettenScan] AS [PSI]
|
|
LEFT JOIN [PalettenScan] AS [PSII]
|
|
ON [PSII].[ID] = [PSI].[ID]
|
|
AND [PSII].[PositionNr] = @{nameof(model.PositionNr)}
|
|
WHERE [PSI].[AuftragNr] = @{nameof(model.OrderNr)}
|
|
ORDER BY [PSI].[PalettenNr]")
|
|
.SetParameter(nameof(model.OrderNr), model.OrderNr)
|
|
.SetParameter(nameof(model.PositionNr), model.PositionNr)
|
|
.ExecuteReader(reader => new KeyValuePair<Int32, Boolean>(
|
|
key: reader.GetValue<Int16>(0),
|
|
value: reader.GetValue<Boolean>(1)));
|
|
|
|
model.UpdatePallets(pallets);
|
|
|
|
model.Positions = this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT [x].[PositionNr]
|
|
FROM [AlleAuftragPositionen] AS [x]
|
|
WHERE [x].[AuftragNr] = @{nameof(model.OrderNr)}
|
|
ORDER BY [x].[PositionNr]")
|
|
.SetParameter(nameof(model.OrderNr), model.OrderNr)
|
|
.ExecuteReader(reader => (Int32)reader.GetValue<Int16>(0));
|
|
}
|
|
|
|
return model;
|
|
}
|
|
|
|
public Result UpdateBatchModel(OrderScanModel model)
|
|
{
|
|
if (!String.IsNullOrWhiteSpace(model.SerialNr))
|
|
{
|
|
var orderIdentity = this.UpdateOrderIdentifiers(model.OrderNr, model.PositionNr, model.SerialNr);
|
|
|
|
if (orderIdentity is null)
|
|
{
|
|
orderIdentity = this.UpdateOrderIdentifiersGenesisMetterRadioAddresses(model.SerialNr);
|
|
}
|
|
|
|
if (orderIdentity is null)
|
|
{
|
|
orderIdentity = this.UpdateOrderIdentifiersERegisterRadioAddresses(model.SerialNr);
|
|
}
|
|
|
|
if (orderIdentity is null || orderIdentity.OrderNr != model.OrderNr)
|
|
{
|
|
return $"Wasserzähler mit Serien-Nr: {model.SerialNr} ist nicht dem Auftrag/Position: {model.OrderNr}/{model.PositionNr} zugewiesen.";
|
|
}
|
|
|
|
model.SerialNr = orderIdentity.CustomerSerialNr;
|
|
model.PositionNr = orderIdentity.PositionNr;
|
|
|
|
if (this.PalletsEntryExists(model.OrderNr, model.PositionNr, model.SerialNr))
|
|
{
|
|
return $"Wasserzähler mit Serien-Nr: {model.SerialNr} wurde bereits hinzugefügt.";
|
|
}
|
|
|
|
var rowsAffected = this.InsertPalletEntry(model);
|
|
|
|
return rowsAffected == 1;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private OrderIdentity UpdateOrderIdentifiers(Int32? orderNr, Int32? positionNr, String serialNr)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT DISTINCT TOP 1
|
|
[APS].[PositionNr]
|
|
, [APS].[SerienNr]
|
|
, ISNULL(REPLACE(RTRIM(LTRIM([APS].[KundeneigeneSerienNr])), ' ', ''), [APS].[SerienNr])
|
|
FROM [AuftragPositionSerienNr] AS [APS]
|
|
WHERE [APS].[AuftragNr] = @{nameof(orderNr)}
|
|
AND ([APS].[PositionNr] = @{nameof(positionNr)} OR @{nameof(positionNr)} IS NULL)
|
|
AND @{nameof(serialNr)} LIKE '%' + (REPLACE(RTRIM(LTRIM([APS].[KundeneigeneSerienNr])), ' ', '')) + '%'")
|
|
.SetParameter(nameof(orderNr), orderNr)
|
|
.SetParameter(nameof(positionNr), positionNr)
|
|
.SetParameter(nameof(serialNr), serialNr)
|
|
.FirstOrDefault(reader => new OrderIdentity
|
|
{
|
|
OrderNr = orderNr ?? -1,
|
|
PositionNr = reader.GetValue<Int16>(0),
|
|
SerialNr = reader.GetValue<Int32>(1),
|
|
CustomerSerialNr = reader.GetValue<String>(2),
|
|
});
|
|
|
|
private OrderIdentity UpdateOrderIdentifiersGenesisMetterRadioAddresses(String address)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
DECLARE @serialNo NVARCHAR(50)
|
|
--------------------------------------------------------------------------
|
|
-- 1. FIND SERIAL-NO BY ADDRESS ------------------------------------------
|
|
--------------------------------------------------------------------------
|
|
SELECT TOP 1
|
|
@serialNo = [x].[Seriennummer]
|
|
FROM [Genesis_Meter] AS [x]
|
|
WHERE @{nameof(address)} LIKE '%' + CAST([x].[Adresse] AS NVARCHAR(50)) + '%'
|
|
ORDER BY [x].[Adresse] DESC
|
|
--------------------------------------------------------------------------
|
|
-- 2. FIND ORDER INFO ----------------------------------------------------
|
|
--------------------------------------------------------------------------
|
|
SELECT TOP 1
|
|
[APS].[AuftragNr] AS [AuftragNr]
|
|
, [APS].[PositionNr] AS [PositionNr]
|
|
, [APS].[SerienNr] AS [SerienNr]
|
|
, ISNULL(REPLACE(RTRIM(LTRIM([APS].[KundeneigeneSerienNr])), ' ', ''), [APS].[SerienNr]) AS [KundeneigeneSerienNr]
|
|
FROM [AuftragPositionSerienNr] AS [APS]
|
|
WHERE [APS].[SerienNr] = @serialNo")
|
|
.SetParameter(nameof(address), address)
|
|
.FirstOrDefault(x => new OrderIdentity
|
|
{
|
|
OrderNr = x.GetValue<Int32>(0),
|
|
PositionNr = x.GetValue<Int16>(1),
|
|
SerialNr = x.GetValue<Int32>(2),
|
|
CustomerSerialNr = x.GetValue<String>(3),
|
|
});
|
|
|
|
private OrderIdentity UpdateOrderIdentifiersERegisterRadioAddresses(String address)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
DECLARE @serialNo NVARCHAR(50)
|
|
--------------------------------------------------------------------------
|
|
-- 1. FIND SERIAL-NO BY ADDRESS ------------------------------------------
|
|
--------------------------------------------------------------------------
|
|
SELECT TOP 1
|
|
@serialNo = [x].[Seriennummer]
|
|
FROM [eRegister] AS [x]
|
|
WHERE @{nameof(address)} LIKE '%' + CAST([x].[Adresse] AS NVARCHAR(50)) + '%'
|
|
ORDER BY [x].[Adresse] DESC
|
|
--------------------------------------------------------------------------
|
|
-- 2. FIND ORDER INFO ----------------------------------------------------
|
|
--------------------------------------------------------------------------
|
|
SELECT TOP 1
|
|
[APS].[AuftragNr] AS [AuftragNr]
|
|
, [APS].[PositionNr] AS [PositionNr]
|
|
, [APS].[SerienNr] AS [SerienNr]
|
|
, ISNULL(REPLACE(RTRIM(LTRIM([APS].[KundeneigeneSerienNr])), ' ', ''), [APS].[SerienNr]) AS [KundeneigeneSerienNr]
|
|
FROM [AuftragPositionSerienNr] AS [APS]
|
|
WHERE [APS].[SerienNr] = @serialNo")
|
|
.SetParameter(nameof(address), address)
|
|
.FirstOrDefault(x => new OrderIdentity
|
|
{
|
|
OrderNr = x.GetValue<Int32>(0),
|
|
PositionNr = x.GetValue<Int16>(1),
|
|
SerialNr = x.GetValue<Int32>(2),
|
|
CustomerSerialNr = x.GetValue<String>(3),
|
|
});
|
|
|
|
private Int32 InsertPalletEntry(OrderScanModel model)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
INSERT
|
|
INTO [PalettenScan] (
|
|
[PalettenNr]
|
|
, [AuftragNr]
|
|
, [PositionNr]
|
|
, [SerienNr]
|
|
, [Host]
|
|
, [Platz]
|
|
, [Datum])
|
|
VALUES (@{nameof(model.PalletNr)}
|
|
, @{nameof(model.OrderNr)}
|
|
, @{nameof(model.PositionNr)}
|
|
, @{nameof(model.SerialNr)}
|
|
, @{nameof(model.Host)}
|
|
, @{nameof(model.Place)}
|
|
, GETDATE())")
|
|
.SetParameter(nameof(model.PalletNr), model.PalletNr)
|
|
.SetParameter(nameof(model.OrderNr), model.OrderNr)
|
|
.SetParameter(nameof(model.PositionNr), model.PositionNr)
|
|
.SetParameter(nameof(model.SerialNr), model.SerialNr)
|
|
.SetParameter(nameof(model.Host), model.Host)
|
|
.SetParameter(nameof(model.Place), model.Place)
|
|
.ExecuteNonQuery();
|
|
|
|
private Boolean PalletsEntryExists(Int32? orderNr, Int32? positionNr, String serialNr)
|
|
=> this.sqlConnection
|
|
.CreateCommand($@"
|
|
SELECT CAST(CASE WHEN [PalettenScan].[ID] IS NULL THEN 0 ELSE 1 END AS BIT)
|
|
FROM [PalettenScan]
|
|
WHERE [PalettenScan].[AuftragNr] = @{nameof(orderNr)}
|
|
AND [PalettenScan].[PositionNr] = @{nameof(positionNr)}
|
|
AND [PalettenScan].[SerienNr] = @{nameof(serialNr)}")
|
|
.SetParameter(nameof(orderNr), orderNr)
|
|
.SetParameter(nameof(positionNr), positionNr)
|
|
.SetParameter(nameof(serialNr), serialNr)
|
|
.FirstOrDefault(x => x.GetValue<Boolean>(0));
|
|
|
|
private PalletPosition LoadPalletPosition(SqlReader reader)
|
|
=> new PalletPosition
|
|
{
|
|
PositionNr = reader.GetValue<Int16>(0),
|
|
Description = String
|
|
.Join(" ", new[] { reader.GetValue<String>(1), reader.GetValue<String>(2), reader.GetValue<String>(3) }
|
|
.Where(s => !String.IsNullOrWhiteSpace(s))),
|
|
ItemsCount = reader.GetValue<Int32>(4),
|
|
TotalItemsCount = reader.GetValue<Int32>(5),
|
|
Items = this.LoadPalletItems(reader.GetValue<Int32>(6), reader.GetValue<Int16>(7), reader.GetValue<Int16>(8))
|
|
};
|
|
}
|
|
} |