651 lines
33 KiB
C#
651 lines
33 KiB
C#
namespace LaaProductionWeb.Services
|
|
{
|
|
using LaaProductionWeb.Data.Interfaces;
|
|
using LaaProductionWeb.Services.Interfaces;
|
|
using LaaProductionWeb.Services.Models;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
public class ShipmentsService : IShipmentsService
|
|
{
|
|
private readonly ISqlClient sqlClient;
|
|
|
|
public ShipmentsService(ISqlClient sqlClient)
|
|
=> this.sqlClient = sqlClient;
|
|
|
|
public OrderScanModel DeletePalletEntry(int id)
|
|
=> this.sqlClient
|
|
.CreateCommand($@"
|
|
DELETE
|
|
FROM [PalettenScan]
|
|
OUTPUT [deleted].[AuftragNr]
|
|
, [deleted].[PositionNr]
|
|
, [deleted].[PalettenNr]
|
|
WHERE [ID] = @{nameof(id)}")
|
|
.AddParameter(nameof(id), id)
|
|
.FirstOrDefault(x => new OrderScanModel
|
|
{
|
|
OrderNr = x.GetInt(),
|
|
PositionNr = x.GetInt(),
|
|
PalletNr = x.GetSmallint()
|
|
});
|
|
|
|
public byte[] LoadBatchBuffer(OrderScanModel model)
|
|
{
|
|
var palletLoad = this.sqlClient.ExecuteReader(
|
|
query: $@"
|
|
SELECT [PalettenNr]
|
|
, [SerienNr]
|
|
FROM [PalettenScan]
|
|
WHERE [AuftragNr] = @{nameof(model.OrderNr)}
|
|
AND [PositionNr] = @{nameof(model.PositionNr)}
|
|
AND [PalettenNr] = @{nameof(model.PalletNr)}
|
|
ORDER BY [SerienNr]",
|
|
parameters: parameters => parameters
|
|
.Add(nameof(model.OrderNr), model.OrderNr)
|
|
.Add(nameof(model.PositionNr), model.PositionNr)
|
|
.Add(nameof(model.PalletNr), model.PalletNr),
|
|
reader: reader => string.Join(",", new string[]
|
|
{
|
|
reader.GetString(0),
|
|
reader.GetString(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.sqlClient
|
|
.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.GetDate(),
|
|
OrderNr = x.GetInt(),
|
|
PosNr = x.GetSmallint(),
|
|
SerialNr = x.GetInt(),
|
|
CustomSerial = x.GetString(),
|
|
Term = x.GetString(),
|
|
Type = x.GetString()
|
|
});
|
|
|
|
private bool PalletNrExists(int orderNo, int? palletNo)
|
|
{
|
|
var countPalletsByNo = this.sqlClient
|
|
.CreateCommand($@"
|
|
SELECT ISNULL(COUNT(1), 0) AS [Found]
|
|
FROM [PalettenScan] AS [PS]
|
|
WHERE [PS].[AuftragNr] = @{nameof(orderNo)}
|
|
AND [PS].[PalettenNr] = @{nameof(palletNo)}")
|
|
.AddParameter(nameof(orderNo), orderNo)
|
|
.AddParameter(nameof(palletNo), palletNo)
|
|
.FirstOrDefault(x => x.GetInt());
|
|
|
|
return countPalletsByNo > 0;
|
|
}
|
|
|
|
private IEnumerable<PalletPosition> LoadLastPalletPositions(int orderNo)
|
|
=> this.sqlClient
|
|
.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")
|
|
.AddParameter(nameof(orderNo), orderNo)
|
|
.ExecuteReader(x => new PalletPosition
|
|
{
|
|
PositionNr = x.GetSmallint(),
|
|
Description = string
|
|
.Join(" ", new[] { x.GetString(), x.GetString(), x.GetString() }
|
|
.Where(s => !string.IsNullOrWhiteSpace(s))),
|
|
ItemsCount = x.GetInt(),
|
|
TotalItemsCount = x.GetInt(),
|
|
Items = this.LoadPalletItems(x.GetInt(), x.GetSmallint(), x.GetSmallint())
|
|
});
|
|
|
|
private IEnumerable<PalletPosition> LoadPalletPositions(int orderNo, int? palletNo)
|
|
=> this.sqlClient
|
|
.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)}")
|
|
.AddParameter(nameof(orderNo), orderNo)
|
|
.AddParameter(nameof(palletNo), palletNo)
|
|
.ExecuteReader(x => new PalletPosition
|
|
{
|
|
PositionNr = x.GetSmallint(),
|
|
Description = string
|
|
.Join(" ", new[] { x.GetString(), x.GetString(), x.GetString() }
|
|
.Where(s => !string.IsNullOrWhiteSpace(s))),
|
|
ItemsCount = x.GetInt(),
|
|
TotalItemsCount = x.GetInt(),
|
|
Items = this.LoadPalletItems(x.GetInt(), x.GetSmallint(), x.GetSmallint())
|
|
});
|
|
|
|
private bool SamePallet(int orderNo, int? positionNo, int? palletNo)
|
|
{
|
|
var countPalletsByNo = this.sqlClient
|
|
.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)}")
|
|
.AddParameter(nameof(orderNo), orderNo)
|
|
.AddParameter(nameof(positionNo), positionNo)
|
|
.AddParameter(nameof(palletNo), palletNo)
|
|
.FirstOrDefault(x => x.GetInt());
|
|
|
|
return countPalletsByNo > 0;
|
|
}
|
|
|
|
private IEnumerable<PalletPosition> LoadLastPalletPosition(int orderNo, int? positionNo)
|
|
=> this.sqlClient
|
|
.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)})")
|
|
.AddParameter(nameof(orderNo), orderNo)
|
|
.AddParameter(nameof(positionNo), positionNo)
|
|
.ExecuteReader(x => new PalletPosition
|
|
{
|
|
PositionNr = x.GetSmallint(),
|
|
Description = string
|
|
.Join(" ", new[] { x.GetString(), x.GetString(), x.GetString() }
|
|
.Where(s => !string.IsNullOrWhiteSpace(s))),
|
|
ItemsCount = x.GetInt(),
|
|
TotalItemsCount = x.GetInt(),
|
|
Items = this.LoadPalletItems(x.GetInt(), x.GetSmallint(), x.GetSmallint())
|
|
});
|
|
|
|
private IEnumerable<PalletPosition> LoadPalletPosition(int orderNo, int? positionNo, int? palletNo)
|
|
=> this.sqlClient
|
|
.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)}")
|
|
.AddParameter(nameof(orderNo), orderNo)
|
|
.AddParameter(nameof(positionNo), positionNo)
|
|
.AddParameter(nameof(palletNo), palletNo)
|
|
.ExecuteReader(x => new PalletPosition
|
|
{
|
|
PositionNr = x.GetSmallint(),
|
|
Description = string
|
|
.Join(" ", new[] { x.GetString(), x.GetString(), x.GetString() }
|
|
.Where(s => !string.IsNullOrWhiteSpace(s))),
|
|
ItemsCount = x.GetInt(),
|
|
TotalItemsCount = x.GetInt(),
|
|
Items = this.LoadPalletItems(x.GetInt(), x.GetSmallint(), x.GetSmallint())
|
|
});
|
|
|
|
private IEnumerable<SerialNr> LoadPalletItems(int orderNo, int posNo, int palletNr)
|
|
=> this.sqlClient
|
|
.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]")
|
|
.AddParameter(nameof(orderNo), orderNo)
|
|
.AddParameter(nameof(posNo), posNo)
|
|
.AddParameter(nameof(palletNr), palletNr)
|
|
.ExecuteReader(x => new SerialNr
|
|
{
|
|
Id = x.GetInt(),
|
|
PositionNr = x.GetSmallint(),
|
|
Serial = x.GetInt(),
|
|
CustomerSerial = x.GetString(),
|
|
IsScanned = x.GetBool(),
|
|
PalletNr = palletNr
|
|
});
|
|
|
|
private PalletsBatchModel LoadBatchModel(int orderNo, int? posNo, int? palletNo)
|
|
{
|
|
var batchModel = this.sqlClient.FirstOrDefault(
|
|
query: $@"
|
|
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",
|
|
parameters: parameters => parameters
|
|
.Add(nameof(orderNo), orderNo)
|
|
.Add(nameof(posNo), posNo),
|
|
reader: reader => new PalletsBatchModel
|
|
{
|
|
OrderNr = reader.GetValue<int>(),
|
|
ProductionOrderNr = reader.GetValue<int>(),
|
|
Customer = reader.GetString(),
|
|
AdditionalText = reader.GetString()
|
|
});
|
|
|
|
return batchModel ?? new PalletsBatchModel();
|
|
}
|
|
|
|
public OrderScanModel LoadPallets(OrderScanModel model)
|
|
{
|
|
if (model != null && model.OrderNr != null && model.OrderNr > 0)
|
|
{
|
|
var pallets = this.sqlClient.ExecuteReader(
|
|
query: $@" 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]",
|
|
parameters: parameters => parameters
|
|
.Add(nameof(model.OrderNr), model.OrderNr)
|
|
.Add(nameof(model.PositionNr), model.PositionNr),
|
|
reader: reader => new KeyValuePair<int, bool>(
|
|
key: (int)reader.GetValue<short>(),
|
|
value: reader.GetValue<bool>()));
|
|
|
|
model.UpdatePallets(pallets);
|
|
|
|
model.Positions = this.sqlClient.ExecuteReader(
|
|
query: $@"SELECT DISTINCT [x].[PositionNr]
|
|
FROM [AlleAuftragPositionen] AS [x]
|
|
WHERE [x].[AuftragNr] = @{nameof(model.OrderNr)}
|
|
ORDER BY [x].[PositionNr]",
|
|
parameters: parameters => parameters.Add(nameof(model.OrderNr), model.OrderNr),
|
|
reader: reader => (int)reader.GetValue<short>());
|
|
}
|
|
|
|
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(int? orderNr, int? positionNr, string serialNr)
|
|
=> this.sqlClient.FirstOrDefault(
|
|
query: $@"
|
|
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])), ' ', '')) + '%'",
|
|
parameters: parameters => parameters
|
|
.Add(nameof(orderNr), orderNr)
|
|
.Add(nameof(positionNr), positionNr)
|
|
.Add(nameof(serialNr), serialNr),
|
|
reader: reader => new OrderIdentity
|
|
{
|
|
OrderNr = orderNr ?? -1,
|
|
PositionNr = reader.GetValue<short>(0),
|
|
SerialNr = reader.GetValue<int>(1),
|
|
CustomerSerialNr = reader.GetValue<string>(2),
|
|
});
|
|
|
|
private OrderIdentity UpdateOrderIdentifiersGenesisMetterRadioAddresses(string address)
|
|
=> this.sqlClient
|
|
.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")
|
|
.AddParameter(nameof(address), address)
|
|
.FirstOrDefault(x => new OrderIdentity
|
|
{
|
|
OrderNr = x.GetInt(),
|
|
PositionNr = x.GetSmallint(),
|
|
SerialNr = x.GetInt(),
|
|
CustomerSerialNr = x.GetString(),
|
|
});
|
|
|
|
private OrderIdentity UpdateOrderIdentifiersERegisterRadioAddresses(string address)
|
|
=> this.sqlClient
|
|
.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")
|
|
.AddParameter(nameof(address), address)
|
|
.FirstOrDefault(x => new OrderIdentity
|
|
{
|
|
OrderNr = x.GetInt(),
|
|
PositionNr = x.GetSmallint(),
|
|
SerialNr = x.GetInt(),
|
|
CustomerSerialNr = x.GetString(),
|
|
});
|
|
|
|
private int InsertPalletEntry(OrderScanModel model)
|
|
=> this.sqlClient.ExecuteNonQuery($@"
|
|
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())",
|
|
parameters => parameters
|
|
.Add(nameof(model.PalletNr), model.PalletNr)
|
|
.Add(nameof(model.OrderNr), model.OrderNr)
|
|
.Add(nameof(model.PositionNr), model.PositionNr)
|
|
.Add(nameof(model.SerialNr), model.SerialNr)
|
|
.Add(nameof(model.Host), model.Host)
|
|
.Add(nameof(model.Place), model.Place));
|
|
|
|
private bool PalletsEntryExists(int? orderNr, int? positionNr, string serialNr)
|
|
=> this.sqlClient.FirstOrDefault($@"
|
|
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)}",
|
|
parameters => parameters
|
|
.Add(nameof(orderNr), orderNr)
|
|
.Add(nameof(positionNr), positionNr)
|
|
.Add(nameof(serialNr), serialNr),
|
|
reader => reader.GetValue<bool>());
|
|
}
|
|
} |