Daniel Schick
6382b082ba
Die aktiven Zellen, d.h. die zu vergleichenden wurden nicht zuverlässig erkannt. Ich habe daher eine andere Funktion verwendet, die ich auf Stackoverflow gefunden habe. Ganz 100% sicher bin ich allerdings nicht, ob dieser Quatsch in jeder Situation zufriedenstellend funktioniert.
2446 lines
124 KiB
C#
2446 lines
124 KiB
C#
//
|
|
// Class: Util
|
|
// Current CLR: 4.0.30319.34209
|
|
// System: Microsoft Visual Studio 10.0
|
|
// Author: dani
|
|
// Created: 6/17/2015 7:12:38 AM
|
|
//
|
|
// Copyright (c) 2015 Informatikbüro Daniel Schick. All rights reserved.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using log4net;
|
|
using bsmd.database;
|
|
using ENI2.Locode;
|
|
|
|
namespace ENI2.Excel
|
|
{
|
|
public static class ExcelUtil
|
|
{
|
|
private static readonly ILog _log = LogManager.GetLogger(typeof(ExcelUtil));
|
|
|
|
#region Process Sheet (normal BSMD sheet import)
|
|
|
|
internal static bool ProcessSheet(ExcelReader reader, out string readMessage, MessageCore messageCore, List<Message.NotificationClass> notificationClasses)
|
|
{
|
|
bool result = true;
|
|
bool isOldVersion = false;
|
|
readMessage = "";
|
|
|
|
MessageCore aMessageCore = ExcelUtil.LookupCoreById(reader);
|
|
if((aMessageCore == null) || (aMessageCore.Id.Value != messageCore.Id.Value))
|
|
{
|
|
readMessage = "Id not matching in import sheet";
|
|
return false;
|
|
}
|
|
|
|
string imoeni = reader.ReadText("Visit.IMONumber")?.Trim();
|
|
|
|
if (!aMessageCore.IMO.IsNullOrEmpty() && !aMessageCore.IMO.Equals(imoeni))
|
|
{
|
|
readMessage = "IMO not matching in import sheet";
|
|
return false;
|
|
}
|
|
|
|
if (!aMessageCore.ENI.IsNullOrEmpty() && !aMessageCore.ENI.Equals(imoeni))
|
|
{
|
|
readMessage = "ENI not matching in import sheet";
|
|
return false;
|
|
}
|
|
|
|
// load messages if already present
|
|
List<Message> messages = DBManager.Instance.GetMessagesForCore(messageCore, DBManager.MessageLoad.ALL);
|
|
|
|
int? testCode = (int?)reader.ReadNumber("WAS.WasteCode_1");
|
|
if (testCode > 999) isOldVersion = true;
|
|
|
|
messages.Sort();
|
|
|
|
// parse selected classes
|
|
try
|
|
{
|
|
|
|
foreach (Message message in messages)
|
|
{
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.AGNT) && notificationClasses.Contains(Message.NotificationClass.AGNT))
|
|
{ if (ScanAGNT(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.ATA) && notificationClasses.Contains(Message.NotificationClass.ATA))
|
|
{ if (ScanATA(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.ATD) && notificationClasses.Contains(Message.NotificationClass.ATD))
|
|
{ if (ScanATD(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.BKRA) && notificationClasses.Contains(Message.NotificationClass.BKRA))
|
|
{ if (ScanBKRA(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.BKRD) && notificationClasses.Contains(Message.NotificationClass.BKRD))
|
|
{ if (ScanBKRD(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.BPOL) && notificationClasses.Contains(Message.NotificationClass.BPOL))
|
|
{ if (ScanBPOL(message, messages, messageCore, reader)) ExcelReader.SaveMessage(message); }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.CREW) && notificationClasses.Contains(Message.NotificationClass.CREW))
|
|
{ if (ScanCREW(message, reader, isOldVersion)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.CREWD) && notificationClasses.Contains(Message.NotificationClass.CREWD))
|
|
{ if (ScanCREWD(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.HAZA) && notificationClasses.Contains(Message.NotificationClass.HAZA))
|
|
{ if (ScanHAZA(message, reader, isOldVersion)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.HAZD) && notificationClasses.Contains(Message.NotificationClass.HAZD))
|
|
{ if (ScanHAZD(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.INFO) && notificationClasses.Contains(Message.NotificationClass.INFO))
|
|
{ if (ScanINFO(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.LADG) && notificationClasses.Contains(Message.NotificationClass.LADG))
|
|
{ if (ScanLADG(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.MDH) && notificationClasses.Contains(Message.NotificationClass.MDH))
|
|
{ if (ScanMDH(message, messages, messageCore, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.NAME) && notificationClasses.Contains(Message.NotificationClass.NAME))
|
|
{ if (ScanNAME(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.NOA_NOD) && notificationClasses.Contains(Message.NotificationClass.NOA_NOD))
|
|
{ if (ScanNOA_NOD(message, messageCore, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.PAS) && notificationClasses.Contains(Message.NotificationClass.PAS))
|
|
{ if (ScanPAS(message, reader, isOldVersion)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.PASD) && notificationClasses.Contains(Message.NotificationClass.PASD))
|
|
{ if (ScanPASD(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.POBA) && notificationClasses.Contains(Message.NotificationClass.POBA))
|
|
{ if (ScanPOBA(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.POBD) && notificationClasses.Contains(Message.NotificationClass.POBD))
|
|
{ if (ScanPOBD(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.PRE72H) && notificationClasses.Contains(Message.NotificationClass.PRE72H))
|
|
{ if (ScanPRE72H(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.SEC) && notificationClasses.Contains(Message.NotificationClass.SEC))
|
|
{ if (ScanSEC(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.SERV) && notificationClasses.Contains(Message.NotificationClass.SERV))
|
|
{ if (ScanSERV(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.STAT) && notificationClasses.Contains(Message.NotificationClass.STAT))
|
|
{ if (ScanSTAT(message, messageCore, messages, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.STO) && notificationClasses.Contains(Message.NotificationClass.STO))
|
|
{ if (ScanSTO(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.TIEFA) && notificationClasses.Contains(Message.NotificationClass.TIEFA))
|
|
{ if (ScanTIEFA(message, reader, isOldVersion)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.TIEFD) && notificationClasses.Contains(Message.NotificationClass.TIEFD))
|
|
{ if (ScanTIEFD(message, reader, isOldVersion)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.TOWA) && notificationClasses.Contains(Message.NotificationClass.TOWA))
|
|
{ if (ScanTOWA(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.TOWD) && notificationClasses.Contains(Message.NotificationClass.TOWD))
|
|
{ if (ScanTOWD(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
if ((message.MessageNotificationClass == Message.NotificationClass.WAS) && notificationClasses.Contains(Message.NotificationClass.WAS))
|
|
{ if (ScanWAS(message, reader, isOldVersion)) ExcelReader.SaveMessage(message); continue; }
|
|
if((message.MessageNotificationClass == Message.NotificationClass.WAS_RCPT) && notificationClasses.Contains(Message.NotificationClass.WAS_RCPT))
|
|
{ if (ScanWAS_RCPT(message, reader)) ExcelReader.SaveMessage(message); continue; }
|
|
|
|
}
|
|
|
|
DBManager.Instance.Save(messageCore); // muss das eigentlich sein?
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
readMessage = ex.Message;
|
|
result = false;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ATA
|
|
|
|
private static bool ScanATA(Message ataMessage, ExcelReader reader)
|
|
{
|
|
if (ataMessage.Elements.Count == 0)
|
|
{
|
|
ATA newATA = new ATA();
|
|
newATA.MessageHeader = ataMessage;
|
|
ataMessage.Elements.Add(newATA);
|
|
}
|
|
ATA ata = ataMessage.Elements[0] as ATA;
|
|
ExcelUtil.ScanMessage(ata, reader);
|
|
|
|
if(!ata.ATAPortOfCall.HasValue)
|
|
{
|
|
ata.ATAPortOfCall = reader.ReadDateTime("ATA.ATADatePortOfCall", "ATA.ATATimePortOfCall");
|
|
}
|
|
|
|
return !(!ata.ATAPortOfCall.HasValue && ataMessage.IsNew);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ATD
|
|
|
|
private static bool ScanATD(Message atdMessage, ExcelReader reader)
|
|
{
|
|
if (atdMessage.Elements.Count == 0)
|
|
{
|
|
ATD newATD = new ATD();
|
|
newATD.MessageHeader = atdMessage;
|
|
atdMessage.Elements.Add(newATD);
|
|
}
|
|
ATD atd = atdMessage.Elements[0] as ATD;
|
|
ExcelUtil.ScanMessage(atd, reader);
|
|
|
|
if (!atd.ATDPortOfCall.HasValue)
|
|
{
|
|
atd.ATDPortOfCall = reader.ReadDateTime("ATD.ATDDatePortOfCall", "ATD.ATDTimePortOfCall");
|
|
}
|
|
|
|
return !(!atd.ATDPortOfCall.HasValue && atdMessage.IsNew);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TIEFA
|
|
|
|
private static bool ScanTIEFA(Message tiefaMessage, ExcelReader reader, bool isOldVersion)
|
|
{
|
|
if (tiefaMessage.Elements.Count == 0)
|
|
{
|
|
TIEFA newTIEFA = new TIEFA();
|
|
newTIEFA.MessageHeader = tiefaMessage;
|
|
tiefaMessage.Elements.Add(newTIEFA);
|
|
}
|
|
TIEFA tiefa = tiefaMessage.Elements[0] as TIEFA;
|
|
ScanMessage(tiefa, reader);
|
|
if (!tiefa.DraughtUponArrival_DMT.HasValue && tiefaMessage.IsNew)
|
|
return false;
|
|
if (tiefa.DraughtUponArrival_DMT.HasValue && !isOldVersion)
|
|
tiefa.DraughtUponArrival_DMT = tiefa.DraughtUponArrival_DMT.Value * 10; // m to dm
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TIEFD
|
|
|
|
private static bool ScanTIEFD(Message tiefdMessage, ExcelReader reader, bool isOldVersion)
|
|
{
|
|
if(tiefdMessage.Elements.Count == 0)
|
|
{
|
|
TIEFD newTIEFD = new TIEFD();
|
|
newTIEFD.MessageHeader = tiefdMessage;
|
|
tiefdMessage.Elements.Add(newTIEFD);
|
|
}
|
|
TIEFD tiefd = tiefdMessage.Elements[0] as TIEFD;
|
|
ScanMessage(tiefd, reader);
|
|
if (!tiefd.DraughtUponDeparture_DMT.HasValue && tiefdMessage.IsNew)
|
|
return false;
|
|
if (tiefd.DraughtUponDeparture_DMT.HasValue && ! isOldVersion)
|
|
tiefd.DraughtUponDeparture_DMT = tiefd.DraughtUponDeparture_DMT.Value * 10; // m to dm
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region NAME
|
|
|
|
private static bool ScanNAME(Message nameMessage, ExcelReader reader)
|
|
{
|
|
if (nameMessage.Elements.Count == 0)
|
|
{
|
|
NAME newNAME = new NAME();
|
|
newNAME.MessageHeader = nameMessage;
|
|
nameMessage.Elements.Add(newNAME);
|
|
}
|
|
NAME name = nameMessage.Elements[0] as NAME;
|
|
ExcelUtil.ScanMessage(name, reader);
|
|
if (name.NameOfMaster.IsNullOrEmpty() && name.IsNew)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BPOL
|
|
|
|
private static bool ScanBPOL(Message bpolMessage, List<Message> messages, MessageCore messageCore, ExcelReader reader)
|
|
{
|
|
if (bpolMessage.Elements.Count == 0)
|
|
{
|
|
BPOL newBPOL = new BPOL();
|
|
newBPOL.MessageHeader = bpolMessage;
|
|
bpolMessage.Elements.Add(newBPOL);
|
|
}
|
|
|
|
BPOL bpol = bpolMessage.Elements[0] as BPOL;
|
|
ExcelUtil.ScanMessage(bpol, reader);
|
|
|
|
// 19.12.16: Einschleicher-Feld von Klasse POBA übernehmen (anderes ist nicht im Sheet!)
|
|
// (1.12.21: bezweifle ob das so wie gedacht funktioniert..)
|
|
Message pobaMessage = ExcelUtil.GetMessageWithType(messages, messageCore, Message.NotificationClass.POBA);
|
|
if (pobaMessage.Elements.Count > 0)
|
|
{
|
|
POBA poba = pobaMessage.Elements[0] as POBA;
|
|
bpol.StowawaysOnBoard = (poba.TotalStowawaysOnBoardUponArrival ?? 0) > 0;
|
|
}
|
|
|
|
bpol.DeleteElements();
|
|
|
|
// PortOfItinerary
|
|
for (int i = 1; i <= 10; i++)
|
|
{
|
|
string bpolName = string.Format("BPOL.PortOfItineraryName_{0}", i);
|
|
string bpolLocode = string.Format("BPOL.PortOfItineraryLoCode_{0}", i);
|
|
string bpolETADate = string.Format("BPOL.PortOfItineraryETADate_{0}", i);
|
|
string bpolETATime = string.Format("BPOL.PortOfItineraryETATime_{0}", i);
|
|
|
|
string bpolNameValue = reader.ReadText(bpolName)?.Trim();
|
|
string bpolLocodeValue = reader.ReadLoCode(bpolLocode);
|
|
|
|
if (!bpolNameValue.IsNullOrEmpty() || !bpolLocodeValue.IsNullOrEmpty())
|
|
{
|
|
if (!(bpol.GetSublistElementWithIdentifier(i.ToString()) is PortOfItinerary poi))
|
|
{
|
|
poi = new PortOfItinerary();
|
|
poi.BPOL = bpol;
|
|
poi.Identifier = i.ToString();
|
|
bpol.PortOfItineraries.Add(poi);
|
|
}
|
|
|
|
poi.PortOfItineraryName = bpolNameValue;
|
|
poi.PortOfItineraryLocode = bpolLocodeValue;
|
|
// falls nur Locode angegeben wurde, Portname aus Locode ermitteln
|
|
if(poi.PortOfItineraryName.IsNullOrEmpty() && !poi.PortOfItineraryLocode.IsNullOrEmpty() && (poi.PortOfItineraryLocode.Length == 5))
|
|
{
|
|
poi.PortOfItineraryName = LocodeDB.PortNameFromLocode(poi.PortOfItineraryLocode);
|
|
}
|
|
|
|
poi.PortOfItineraryETA = reader.ReadDateTime(bpolETADate, bpolETATime);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region POBA
|
|
|
|
private static bool ScanPOBA(Message pobaMessage, ExcelReader reader)
|
|
{
|
|
if(pobaMessage.Elements.Count == 0)
|
|
{
|
|
POBA newPoba = new POBA();
|
|
newPoba.MessageHeader = pobaMessage;
|
|
pobaMessage.Elements.Add(newPoba);
|
|
}
|
|
|
|
POBA poba = pobaMessage.Elements[0] as POBA;
|
|
ScanMessage(poba, reader);
|
|
if (((poba.TotalPersonsOnBoardUponArrival ?? 0) == 0) && poba.IsNew)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region POBD
|
|
|
|
private static bool ScanPOBD(Message pobdMessage, ExcelReader reader)
|
|
{
|
|
if(pobdMessage.Elements.Count == 0)
|
|
{
|
|
POBD newPobd = new POBD();
|
|
newPobd.MessageHeader = pobdMessage;
|
|
pobdMessage.Elements.Add(newPobd);
|
|
}
|
|
|
|
POBD pobd = pobdMessage.Elements[0] as POBD;
|
|
ScanMessage(pobd, reader);
|
|
if (((pobd.TotalPersonsOnBoardUponDeparture ?? 0) == 0) && pobd.IsNew)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region HAZA
|
|
|
|
private static bool ScanHAZA(Message hazaMessage, ExcelReader reader, bool isOldVersion)
|
|
{
|
|
|
|
if(hazaMessage.Elements.Count == 0)
|
|
{
|
|
HAZ newHaza = new HAZ();
|
|
newHaza.IsDeparture = false;
|
|
newHaza.MessageHeader = hazaMessage;
|
|
hazaMessage.Elements.Add(newHaza);
|
|
}
|
|
HAZ haza = hazaMessage.Elements[0] as HAZ;
|
|
|
|
haza.NoDPGOnBoardOnArrival = !reader.ReadBoolean("HAZA.DGOnBoard");
|
|
haza.DPGManifestOnBoardOnArrival = reader.ReadBoolean("HAZA.DPGManifestOnBoardOnArrival");
|
|
haza.DPGContactFamilyName = reader.ReadText("HAZA.DPGContactFamilyName");
|
|
haza.DPGContactPhone = reader.ReadText("HAZA.DPGContactPhone");
|
|
haza.MOUBaltic = reader.ReadBoolean("HAZA.MOUBaltic");
|
|
string shipClass = reader.ReadText("HAZA.INFShipClass");
|
|
if(!shipClass.IsNullOrEmpty())
|
|
{
|
|
if (shipClass.Contains('1')) haza.INFShipClass = 0;
|
|
if (shipClass.Contains('2')) haza.INFShipClass = 1;
|
|
if (shipClass.Contains('3')) haza.INFShipClass = 2;
|
|
}
|
|
|
|
#region IMDG
|
|
|
|
for (int i = 1; i <= 10; i++)
|
|
{
|
|
string imdg_unno = string.Format("HAZA.IMDG.UNNumber_{0}", i);
|
|
string imdg_properShippingName = string.Format("HAZA.IMDG.ProperShippingName_{0}", i);
|
|
string imdg_imoClass = string.Format("HAZA.IMDG.IMOClass_{0}", i);
|
|
string imdg_packingGroup = string.Format("HAZA.IMDG.PackingGroup_{0}", i);
|
|
string imdg_marinePollutant = string.Format("HAZA.IMDG.MarinePollutant_{0}", i);
|
|
string imdg_flashpoint = string.Format("HAZA.IMDG.Flashpoint_CEL_{0}", i);
|
|
string imdg_numberOfPackages = string.Format("HAZA.IMDG.NumberOfPackages_{0}", i);
|
|
string imdg_packageType = string.Format("HAZA.IMDG.PackageType_{0}", i);
|
|
string imdg_limitedQuantities = string.Format("HAZA.IMDG.LimitedQuantities_{0}", i);
|
|
string imdg_exceptedQuantities = string.Format("HAZA.IMDG.ExceptedQuantities_{0}", i);
|
|
string imdg_netQuantity = string.Format("HAZA.IMDG.NetQuantity_KGM_{0}", i);
|
|
string imdg_grossQuantity = string.Format("HAZA.IMDG.GrossQuantity_KGM_{0}", i);
|
|
string imdg_number = string.Format("HAZA.IMDG.Number_{0}", i);
|
|
string imdg_stowagePosition = string.Format("HAZA.IMDG.StowagePosition_{0}", i);
|
|
string imdg_portOfLoading = string.Format("HAZA.IMDG.PortOfLoading_{0}", i);
|
|
string imdg_portOfDischarge = string.Format("HAZA.IMDG.PortOfDischarge_{0}", i);
|
|
string imdg_containerNumber = string.Format("HAZA.IMDG.ContainerNumber_{0}", i);
|
|
string imdg_remarks = string.Format("HAZA.IMDG.Remarks_{0}", i);
|
|
|
|
string unNumber = reader.ReadText(imdg_unno);
|
|
if(unNumber.IsNullOrEmpty()) // if unnumber is not set ignore this row
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string posIdent = string.Format("IMDG-{0}", i);
|
|
IMDGPosition imdgPosition = haza.GetIMDGPositionWithIdentifier(posIdent);
|
|
if(imdgPosition == null)
|
|
{
|
|
imdgPosition = new IMDGPosition();
|
|
imdgPosition.HAZ = haza;
|
|
imdgPosition.Identifier = posIdent;
|
|
haza.IMDGPositions.Add(imdgPosition);
|
|
}
|
|
|
|
imdgPosition.UNNumber = unNumber;
|
|
imdgPosition.ProperShippingName = reader.ReadText(imdg_properShippingName);
|
|
imdgPosition.IMOClass = reader.ReadText(imdg_imoClass);
|
|
imdgPosition.PackingGroup = reader.ReadPackingGroup(imdg_packingGroup);
|
|
imdgPosition.MarinePollutant = reader.ReadBoolean(imdg_marinePollutant);
|
|
imdgPosition.Flashpoint_CEL = reader.ReadText(imdg_flashpoint);
|
|
imdgPosition.NumberOfPackages = (int?)reader.ReadNumber(imdg_numberOfPackages);
|
|
imdgPosition.PackageType = reader.ReadText(imdg_packageType);
|
|
imdgPosition.LimitedQuantities = reader.ReadBoolean(imdg_limitedQuantities);
|
|
imdgPosition.ExceptedQuantities = reader.ReadBoolean(imdg_exceptedQuantities);
|
|
imdgPosition.NetQuantity_KGM = reader.ReadNumber(imdg_netQuantity);
|
|
imdgPosition.GrossQuantity_KGM = reader.ReadNumber(imdg_grossQuantity);
|
|
imdgPosition.VehicleLicenseNumber = reader.ReadText(imdg_number);
|
|
imdgPosition.StowagePosition = reader.ReadText(imdg_stowagePosition);
|
|
imdgPosition.PortOfLoading = reader.ReadLoCode(imdg_portOfLoading);
|
|
imdgPosition.PortOfDischarge = reader.ReadLoCode(imdg_portOfDischarge);
|
|
imdgPosition.ContainerNumber = reader.ReadText(imdg_containerNumber);
|
|
imdgPosition.Remarks = reader.ReadText(imdg_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IBC
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string ibc_productName = string.Format("HAZA.IBC.ProductName_{0}", i);
|
|
string ibc_pollutionCategory = string.Format("HAZA.IBC.PollutionCategory_{0}", i);
|
|
string ibc_flash = string.Format("HAZA.IBC.Flashpoint_CEL_{0}", i);
|
|
if (isOldVersion)
|
|
ibc_flash = string.Format("HAZA.IBC.FlashpointInformation_{0}", i);
|
|
string ibc_quantity = string.Format("HAZA.IBC.Quantity_KGM_{0}", i);
|
|
string ibc_stowagePosition = string.Format("HAZA.IBC.StowagePosition_{0}", i);
|
|
string ibc_portOfLoading = string.Format("HAZA.IBC.PortOfLoading_{0}", i);
|
|
string ibc_portOfDischarge = string.Format("HAZA.IBC.PortOfDischarge_{0}", i);
|
|
string ibc_hazards = string.Format("HAZA.IBC.Hazards_{0}", i);
|
|
string ibc_specrefs = string.Format("HAZA.IBC.SpecRef15_19_{0}", i);
|
|
string ibc_remarks = string.Format("HAZA.IBC.Remarks_{0}", i);
|
|
|
|
string productName = reader.ReadText(ibc_productName);
|
|
if (productName.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("IBC-{0}", i);
|
|
IBCPosition ibcPosition = haza.GetIBCPositionWithIdentifier(posIdent);
|
|
if(ibcPosition == null)
|
|
{
|
|
ibcPosition = new IBCPosition();
|
|
ibcPosition.Identifier = posIdent;
|
|
ibcPosition.HAZ = haza;
|
|
haza.IBCPositions.Add(ibcPosition);
|
|
}
|
|
|
|
ibcPosition.ProductName = productName;
|
|
|
|
string pollutionCategory = reader.ReadText(ibc_pollutionCategory);
|
|
if(!pollutionCategory.IsNullOrEmpty())
|
|
{
|
|
if (pollutionCategory.Equals("X", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 0;
|
|
if (pollutionCategory.Equals("Y", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 1;
|
|
if (pollutionCategory.Equals("Z", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 2;
|
|
if (pollutionCategory.Equals("OS", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 3;
|
|
}
|
|
|
|
ibcPosition.Flashpoint_CEL = reader.ReadText(ibc_flash);
|
|
if (!ibcPosition.Flashpoint_CEL.IsNullOrEmpty())
|
|
{
|
|
if (ibcPosition.Flashpoint_CEL != "-")
|
|
{
|
|
if (double.TryParse(ibcPosition.Flashpoint_CEL, out double flashval))
|
|
{
|
|
if (flashval > 60) ibcPosition.FlashpointInformation = 1; // GT60CEL
|
|
else ibcPosition.FlashpointInformation = 2; // LE60CEL
|
|
}
|
|
}
|
|
}
|
|
|
|
ibcPosition.Quantity_KGM = (int ?) reader.ReadNumber(ibc_quantity);
|
|
ibcPosition.StowagePosition = reader.ReadText(ibc_stowagePosition);
|
|
ibcPosition.PortOfLoading = reader.ReadLoCode(ibc_portOfLoading);
|
|
ibcPosition.PortOfDischarge = reader.ReadLoCode(ibc_portOfDischarge);
|
|
ibcPosition.Hazards = reader.ReadHazards(ibc_hazards);
|
|
ibcPosition.SpecRef15_19 = reader.ReadBoolean(ibc_specrefs);
|
|
ibcPosition.Remarks = reader.ReadText(ibc_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IGC
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string igc_productName = string.Format("HAZA.IGC.ProductName_{0}", i);
|
|
string igc_quantity = string.Format("HAZA.IGC.Quantity_KGM_{0}", i);
|
|
string igc_stowagePosition = string.Format("HAZA.IGC.StowagePosition_{0}", i);
|
|
string igc_portOfLoading = string.Format("HAZA.IGC.PortOfLoading_{0}", i);
|
|
string igc_portOfDischarge = string.Format("HAZA.IGC.PortOfDischarge_{0}", i);
|
|
string igc_unnumber = string.Format("HAZA.IGC.UNNumber_{0}", i);
|
|
string igc_imoclass = string.Format("HAZA.IGC.IMOClass_{0}", i);
|
|
string igc_remarks = string.Format("HAZA.IGC.Remarks_{0}", i);
|
|
|
|
string productName = reader.ReadText(igc_productName);
|
|
if (productName.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("IGC-{0}", i);
|
|
IGCPosition igcPosition = haza.GetIGCPositionWithIdentifier(posIdent);
|
|
if(igcPosition == null)
|
|
{
|
|
igcPosition = new IGCPosition();
|
|
igcPosition.Identifier = posIdent;
|
|
igcPosition.HAZ = haza;
|
|
haza.IGCPositions.Add(igcPosition);
|
|
}
|
|
|
|
igcPosition.ProductName = productName;
|
|
igcPosition.Quantity_KGM = reader.ReadNumber(igc_quantity);
|
|
igcPosition.StowagePosition = reader.ReadText(igc_stowagePosition);
|
|
igcPosition.PortOfLoading = reader.ReadLoCode(igc_portOfLoading);
|
|
igcPosition.PortOfDischarge = reader.ReadLoCode(igc_portOfDischarge);
|
|
igcPosition.UNNumber = reader.ReadText(igc_unnumber);
|
|
igcPosition.IMOClass = reader.ReadText(igc_imoclass);
|
|
igcPosition.Remarks = reader.ReadText(igc_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IMSBC
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string imsbc_bcsn = string.Format("HAZA.IMSBC.BulkCargoShippingName_{0}", i);
|
|
string imsbc_mhb = string.Format("HAZA.IMSBC.MHB_{0}", i);
|
|
string imsbc_quantity = string.Format("HAZA.IMSBC.Quantity_KGM_{0}", i);
|
|
string imsbc_stowagePosition = string.Format("HAZA.IMSBC.StowagePosition_{0}", i);
|
|
string imsbc_portOfLoading = string.Format("HAZA.IMSBC.PortOfLoading_{0}", i);
|
|
string imsbc_portOfDischarge = string.Format("HAZA.IMSBC.PortOfDischarge_{0}", i);
|
|
string imsbc_hazardclass = string.Format("HAZA.IMSBC.IMOHazardClass_{0}", i);
|
|
string imsbc_unnumber = string.Format("HAZA.IMSBC.UNNumber_{0}", i);
|
|
string imsbc_imoclass = string.Format("HAZA.IMSBC.IMOClass_{0}", i);
|
|
string imsbc_remarks = string.Format("HAZA.IMSBC.Remarks_{0}", i);
|
|
|
|
string bcsn = reader.ReadText(imsbc_bcsn);
|
|
if (bcsn.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("IMSBC-{0}", i);
|
|
IMSBCPosition imsbcPosition = haza.GetIMSBCPositionWithIdentifier(posIdent);
|
|
if(imsbcPosition == null)
|
|
{
|
|
imsbcPosition = new IMSBCPosition();
|
|
imsbcPosition.Identifier = posIdent;
|
|
imsbcPosition.HAZ = haza;
|
|
haza.IMSBCPositions.Add(imsbcPosition);
|
|
}
|
|
|
|
imsbcPosition.BulkCargoShippingName = bcsn;
|
|
imsbcPosition.MHB = reader.ReadBoolean(imsbc_mhb);
|
|
imsbcPosition.Quantity_KGM = reader.ReadNumber(imsbc_quantity);
|
|
imsbcPosition.StowagePosition = reader.ReadText(imsbc_stowagePosition);
|
|
imsbcPosition.PortOfLoading = reader.ReadLoCode(imsbc_portOfLoading);
|
|
imsbcPosition.PortOfDischarge = reader.ReadLoCode(imsbc_portOfDischarge);
|
|
imsbcPosition.IMOHazardClass = reader.ReadHazardClass(imsbc_hazardclass);
|
|
imsbcPosition.UNNumber = reader.ReadText(imsbc_unnumber);
|
|
imsbcPosition.IMOClass = reader.ReadText(imsbc_imoclass);
|
|
imsbcPosition.Remarks = reader.ReadText(imsbc_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MARPOL
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string marpol_name = string.Format("HAZA.MARPOL.Name_{0}", i);
|
|
string marpol_flash = string.Format("HAZA.MARPOL.Flashpoint_CEL_{0}", i);
|
|
string marpol_quantity = string.Format("HAZA.MARPOL.Quantity_KGM_{0}", i);
|
|
string marpol_stowagePosition = string.Format("HAZA.MARPOL.StowagePosition_{0}", i);
|
|
string marpol_portOfLoading = string.Format("HAZA.MARPOL.PortOfLoading_{0}", i);
|
|
string marpol_portOfDischarge = string.Format("HAZA.MARPOL.PortOfDischarge_{0}", i);
|
|
string marpol_remarks = string.Format("HAZA.MARPOL.Remarks_{0}", i);
|
|
|
|
string name = reader.ReadText(marpol_name);
|
|
if (name.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("MARPOL-{0}", i);
|
|
MARPOL_Annex_I_Position marpolPosition = haza.GetMARPOLPositionWithIdentifier(posIdent);
|
|
if(marpolPosition == null)
|
|
{
|
|
marpolPosition = new MARPOL_Annex_I_Position();
|
|
marpolPosition.Identifier = posIdent;
|
|
marpolPosition.HAZ = haza;
|
|
haza.MARPOLPositions.Add(marpolPosition);
|
|
}
|
|
|
|
marpolPosition.Name = name;
|
|
marpolPosition.Flashpoint_CEL = reader.ReadText(marpol_flash);
|
|
|
|
// Früher bei NULL: NF // Ableitung Flashpoint-Info: Christin, 22.3.2017
|
|
// jetzt bei leerer Flashpoint_CEL: Flashpointinformation NULL: Basti, 13.7.2020
|
|
if (marpolPosition.Flashpoint_CEL.IsNullOrEmpty()) { marpolPosition.FlashpointInformation = null; }
|
|
else
|
|
{
|
|
if (double.TryParse(marpolPosition.Flashpoint_CEL, out double flashval))
|
|
{
|
|
if (flashval > 60) marpolPosition.FlashpointInformation = 1; // GT60CEL
|
|
else marpolPosition.FlashpointInformation = 2; // LE60CEL
|
|
}
|
|
}
|
|
|
|
marpolPosition.Quantity_KGM = reader.ReadNumber(marpol_quantity);
|
|
marpolPosition.StowagePosition = reader.ReadText(marpol_stowagePosition);
|
|
marpolPosition.PortOfLoading = reader.ReadLoCode(marpol_portOfLoading);
|
|
marpolPosition.PortOfDischarge = reader.ReadLoCode(marpol_portOfDischarge);
|
|
marpolPosition.Remarks = reader.ReadText(marpol_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
if(haza.HasPositions) // Christin 22.3.17: Felder bei Positionen immer fest ausfüllen
|
|
{
|
|
haza.NoDPGOnBoardOnArrival = false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region HAZD
|
|
|
|
private static bool ScanHAZD(Message hazdMessage, ExcelReader reader)
|
|
{
|
|
if (hazdMessage.Elements.Count == 0)
|
|
{
|
|
HAZ newHazd = new HAZ();
|
|
newHazd.IsDeparture = true;
|
|
newHazd.MessageHeader = hazdMessage;
|
|
hazdMessage.Elements.Add(newHazd);
|
|
}
|
|
HAZ hazd = hazdMessage.Elements[0] as HAZ;
|
|
|
|
hazd.NoDPGOnBoardOnArrival = !reader.ReadBoolean("HAZD.DGOnBoard");
|
|
hazd.DPGManifestOnBoardOnArrival = reader.ReadBoolean("HAZD.DPGManifestOnBoardOnDeparture");
|
|
hazd.DPGContactFamilyName = reader.ReadText("HAZD.DPGContactFamilyName");
|
|
hazd.DPGContactPhone = reader.ReadText("HAZD.DPGContactPhone");
|
|
hazd.MOUBaltic = reader.ReadBoolean("HAZD.MOUBaltic");
|
|
string shipClass = reader.ReadText("HAZD.INFShipClass");
|
|
if (!shipClass.IsNullOrEmpty())
|
|
{
|
|
if (shipClass.Contains('1')) hazd.INFShipClass = 0;
|
|
if (shipClass.Contains('2')) hazd.INFShipClass = 1;
|
|
if (shipClass.Contains('3')) hazd.INFShipClass = 2;
|
|
}
|
|
|
|
#region IMDG
|
|
|
|
for (int i = 1; i <= 10; i++)
|
|
{
|
|
string imdg_unno = string.Format("HAZD.IMDG.UNNumber_{0}", i);
|
|
string imdg_properShippingName = string.Format("HAZD.IMDG.ProperShippingName_{0}", i);
|
|
string imdg_imoClass = string.Format("HAZD.IMDG.IMOClass_{0}", i);
|
|
string imdg_packingGroup = string.Format("HAZD.IMDG.PackingGroup_{0}", i);
|
|
string imdg_marinePollutant = string.Format("HAZD.IMDG.MarinePollutant_{0}", i);
|
|
string imdg_flashpoint = string.Format("HAZD.IMDG.Flashpoint_CEL_{0}", i);
|
|
string imdg_numberOfPackages = string.Format("HAZD.IMDG.NumberOfPackages_{0}", i);
|
|
string imdg_packageType = string.Format("HAZD.IMDG.PackageType_{0}", i);
|
|
string imdg_limitedQuantities = string.Format("HAZD.IMDG.LimitedQuantities_{0}", i);
|
|
string imdg_exceptedQuantities = string.Format("HAZD.IMDG.ExceptedQuantities_{0}", i);
|
|
string imdg_netQuantity = string.Format("HAZD.IMDG.NetQuantity_KGM_{0}", i);
|
|
string imdg_grossQuantity = string.Format("HAZD.IMDG.GrossQuantity_KGM_{0}", i);
|
|
string imdg_number = string.Format("HAZD.IMDG.Number_{0}", i);
|
|
string imdg_stowagePosition = string.Format("HAZD.IMDG.StowagePosition_{0}", i);
|
|
string imdg_portOfLoading = string.Format("HAZD.IMDG.PortOfLoading_{0}", i);
|
|
string imdg_portOfDischarge = string.Format("HAZD.IMDG.PortOfDischarge_{0}", i);
|
|
string imdg_containerNumber = string.Format("HAZD.IMDG.ContainerNumber_{0}", i);
|
|
string imdg_remarks = string.Format("HAZD.IMDG.Remarks_{0}", i);
|
|
|
|
string unNumber = reader.ReadText(imdg_unno);
|
|
if (unNumber.IsNullOrEmpty()) continue; // if unnumber is not set ignore this row
|
|
|
|
string posIdent = string.Format("IMDG-{0}", i);
|
|
IMDGPosition imdgPosition = hazd.GetIMDGPositionWithIdentifier(posIdent);
|
|
if (imdgPosition == null)
|
|
{
|
|
imdgPosition = new IMDGPosition();
|
|
imdgPosition.HAZ = hazd;
|
|
imdgPosition.Identifier = posIdent;
|
|
hazd.IMDGPositions.Add(imdgPosition);
|
|
}
|
|
|
|
imdgPosition.UNNumber = unNumber;
|
|
imdgPosition.ProperShippingName = reader.ReadText(imdg_properShippingName);
|
|
imdgPosition.IMOClass = reader.ReadText(imdg_imoClass);
|
|
imdgPosition.PackingGroup = reader.ReadPackingGroup(imdg_packingGroup);
|
|
imdgPosition.MarinePollutant = reader.ReadBoolean(imdg_marinePollutant);
|
|
imdgPosition.Flashpoint_CEL = reader.ReadText(imdg_flashpoint);
|
|
imdgPosition.NumberOfPackages = (int?)reader.ReadNumber(imdg_numberOfPackages);
|
|
imdgPosition.PackageType = reader.ReadText(imdg_packageType);
|
|
imdgPosition.LimitedQuantities = reader.ReadBoolean(imdg_limitedQuantities);
|
|
imdgPosition.ExceptedQuantities = reader.ReadBoolean(imdg_exceptedQuantities);
|
|
imdgPosition.NetQuantity_KGM = reader.ReadNumber(imdg_netQuantity);
|
|
imdgPosition.GrossQuantity_KGM = reader.ReadNumber(imdg_grossQuantity);
|
|
imdgPosition.VehicleLicenseNumber = reader.ReadText(imdg_number);
|
|
imdgPosition.StowagePosition = reader.ReadText(imdg_stowagePosition);
|
|
imdgPosition.PortOfLoading = reader.ReadLoCode(imdg_portOfLoading);
|
|
imdgPosition.PortOfDischarge = reader.ReadLoCode(imdg_portOfDischarge);
|
|
imdgPosition.ContainerNumber = reader.ReadText(imdg_containerNumber);
|
|
imdgPosition.Remarks = reader.ReadText(imdg_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IBC
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string ibc_productName = string.Format("HAZD.IBC.ProductName_{0}", i);
|
|
string ibc_pollutionCategory = string.Format("HAZD.IBC.PollutionCategory_{0}", i);
|
|
string ibc_flash = string.Format("HAZD.IBC.Flashpoint_CEL_{0}", i);
|
|
string ibc_quantity = string.Format("HAZD.IBC.Quantity_KGM_{0}", i);
|
|
string ibc_stowagePosition = string.Format("HAZD.IBC.StowagePosition_{0}", i);
|
|
string ibc_portOfLoading = string.Format("HAZD.IBC.PortOfLoading_{0}", i);
|
|
string ibc_portOfDischarge = string.Format("HAZD.IBC.PortOfDischarge_{0}", i);
|
|
string ibc_hazards = string.Format("HAZD.IBC.Hazards_{0}", i);
|
|
string ibc_specref = string.Format("HAZD.IBC.SpecRef15_19_{0}", i);
|
|
string ibc_remarks = string.Format("HAZD.IBC.Remarks_{0}", i);
|
|
|
|
string productName = reader.ReadText(ibc_productName);
|
|
if (productName.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("IBC-{0}", i);
|
|
IBCPosition ibcPosition = hazd.GetIBCPositionWithIdentifier(posIdent);
|
|
if (ibcPosition == null)
|
|
{
|
|
ibcPosition = new IBCPosition();
|
|
ibcPosition.Identifier = posIdent;
|
|
ibcPosition.HAZ = hazd;
|
|
hazd.IBCPositions.Add(ibcPosition);
|
|
}
|
|
|
|
ibcPosition.ProductName = productName;
|
|
string pollutionCategory = reader.ReadText(ibc_pollutionCategory);
|
|
if (!pollutionCategory.IsNullOrEmpty())
|
|
{
|
|
if (pollutionCategory.Equals("X", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 0;
|
|
if (pollutionCategory.Equals("Y", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 1;
|
|
if (pollutionCategory.Equals("Z", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 2;
|
|
if (pollutionCategory.Equals("OS", StringComparison.OrdinalIgnoreCase)) ibcPosition.PollutionCategory = 3;
|
|
}
|
|
|
|
ibcPosition.Flashpoint_CEL = reader.ReadText(ibc_flash);
|
|
|
|
if (!ibcPosition.Flashpoint_CEL.IsNullOrEmpty())
|
|
{
|
|
if (ibcPosition.Flashpoint_CEL != "-")
|
|
{
|
|
if (double.TryParse(ibcPosition.Flashpoint_CEL, out double flashval))
|
|
{
|
|
if (flashval > 60) ibcPosition.FlashpointInformation = 1; // GT60CEL
|
|
else ibcPosition.FlashpointInformation = 2; // LE60CEL
|
|
}
|
|
}
|
|
}
|
|
|
|
ibcPosition.Quantity_KGM = (int?)reader.ReadNumber(ibc_quantity);
|
|
ibcPosition.StowagePosition = reader.ReadText(ibc_stowagePosition);
|
|
ibcPosition.PortOfLoading = reader.ReadLoCode(ibc_portOfLoading);
|
|
ibcPosition.PortOfDischarge = reader.ReadLoCode(ibc_portOfDischarge);
|
|
ibcPosition.Hazards = reader.ReadHazards(ibc_hazards);
|
|
ibcPosition.SpecRef15_19 = reader.ReadBoolean(ibc_specref);
|
|
ibcPosition.Remarks = reader.ReadText(ibc_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IGC
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string igc_productName = string.Format("HAZD.IGC.ProductName_{0}", i);
|
|
string igc_quantity = string.Format("HAZD.IGC.Quantity_KGM_{0}", i);
|
|
string igc_stowagePosition = string.Format("HAZD.IGC.StowagePosition_{0}", i);
|
|
string igc_portOfLoading = string.Format("HAZD.IGC.PortOfLoading_{0}", i);
|
|
string igc_portOfDischarge = string.Format("HAZD.IGC.PortOfDischarge_{0}", i);
|
|
string igc_unnumber = string.Format("HAZD.IGC.UNNumber_{0}", i);
|
|
string igc_imoclass = string.Format("HAZD.IGC.IMOClass_{0}", i);
|
|
string igc_remarks = string.Format("HAZD.IGC.Remarks_{0}", i);
|
|
|
|
string productName = reader.ReadText(igc_productName);
|
|
if (productName.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("IGC-{0}", i);
|
|
IGCPosition igcPosition = hazd.GetIGCPositionWithIdentifier(posIdent);
|
|
if (igcPosition == null)
|
|
{
|
|
igcPosition = new IGCPosition();
|
|
igcPosition.Identifier = posIdent;
|
|
igcPosition.HAZ = hazd;
|
|
hazd.IGCPositions.Add(igcPosition);
|
|
}
|
|
|
|
igcPosition.ProductName = productName;
|
|
igcPosition.Quantity_KGM = reader.ReadNumber(igc_quantity);
|
|
igcPosition.StowagePosition = reader.ReadText(igc_stowagePosition);
|
|
igcPosition.PortOfLoading = reader.ReadLoCode(igc_portOfLoading);
|
|
igcPosition.PortOfDischarge = reader.ReadLoCode(igc_portOfDischarge);
|
|
igcPosition.UNNumber = reader.ReadText(igc_unnumber);
|
|
igcPosition.IMOClass = reader.ReadText(igc_imoclass);
|
|
igcPosition.Remarks = reader.ReadText(igc_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IMSBC
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string imsbc_bcsn = string.Format("HAZD.IMSBC.BulkCargoShippingName_{0}", i);
|
|
string imsbc_mhb = string.Format("HAZD.IMSBC.MHB_{0}", i);
|
|
string imsbc_quantity = string.Format("HAZD.IMSBC.Quantity_KGM_{0}", i);
|
|
string imsbc_stowagePosition = string.Format("HAZD.IMSBC.StowagePosition_{0}", i);
|
|
string imsbc_portOfLoading = string.Format("HAZD.IMSBC.PortOfLoading_{0}", i);
|
|
string imsbc_portOfDischarge = string.Format("HAZD.IMSBC.PortOfDischarge_{0}", i);
|
|
string imsbc_hazardclass = string.Format("HAZD.IMSBC.IMOHazardClass_{0}", i);
|
|
string imsbc_unnumber = string.Format("HAZD.IMSBC.UNNumber_{0}", i);
|
|
string imsbc_imoclass = string.Format("HAZD.IMSBC.IMOClass_{0}", i);
|
|
string imsbc_remarks = string.Format("HAZD.IMSBC.Remarks_{0}", i);
|
|
|
|
string bcsn = reader.ReadText(imsbc_bcsn);
|
|
if (bcsn.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("IMSBC-{0}", i);
|
|
IMSBCPosition imsbcPosition = hazd.GetIMSBCPositionWithIdentifier(posIdent);
|
|
if (imsbcPosition == null)
|
|
{
|
|
imsbcPosition = new IMSBCPosition();
|
|
imsbcPosition.Identifier = posIdent;
|
|
imsbcPosition.HAZ = hazd;
|
|
hazd.IMSBCPositions.Add(imsbcPosition);
|
|
}
|
|
|
|
imsbcPosition.BulkCargoShippingName = bcsn;
|
|
imsbcPosition.MHB = reader.ReadBoolean(imsbc_mhb);
|
|
imsbcPosition.Quantity_KGM = reader.ReadNumber(imsbc_quantity);
|
|
imsbcPosition.StowagePosition = reader.ReadText(imsbc_stowagePosition);
|
|
imsbcPosition.PortOfLoading = reader.ReadLoCode(imsbc_portOfLoading);
|
|
imsbcPosition.PortOfDischarge = reader.ReadLoCode(imsbc_portOfDischarge);
|
|
imsbcPosition.IMOHazardClass = reader.ReadHazardClass(imsbc_hazardclass);
|
|
imsbcPosition.UNNumber = reader.ReadText(imsbc_unnumber);
|
|
imsbcPosition.IMOClass = reader.ReadText(imsbc_imoclass);
|
|
imsbcPosition.Remarks = reader.ReadText(imsbc_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MARPOL
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
string marpol_name = string.Format("HAZD.MARPOL.Name_{0}", i);
|
|
string marpol_flash = string.Format("HAZD.MARPOL.Flashpoint_CEL_{0}", i);
|
|
string marpol_quantity = string.Format("HAZD.MARPOL.Quantity_KGM_{0}", i);
|
|
string marpol_stowagePosition = string.Format("HAZD.MARPOL.StowagePosition_{0}", i);
|
|
string marpol_portOfLoading = string.Format("HAZD.MARPOL.PortOfLoading_{0}", i);
|
|
string marpol_portOfDischarge = string.Format("HAZD.MARPOL.PortOfDischarge_{0}", i);
|
|
string marpol_remarks = string.Format("HAZD.MARPOL.Remarks_{0}", i);
|
|
|
|
string name = reader.ReadText(marpol_name);
|
|
if (name.IsNullOrEmpty()) continue;
|
|
|
|
string posIdent = string.Format("MARPOL-{0}", i);
|
|
MARPOL_Annex_I_Position marpolPosition = hazd.GetMARPOLPositionWithIdentifier(posIdent);
|
|
if (marpolPosition == null)
|
|
{
|
|
marpolPosition = new MARPOL_Annex_I_Position();
|
|
marpolPosition.Identifier = posIdent;
|
|
marpolPosition.HAZ = hazd;
|
|
hazd.MARPOLPositions.Add(marpolPosition);
|
|
}
|
|
|
|
marpolPosition.Name = name;
|
|
marpolPosition.Flashpoint_CEL = reader.ReadText(marpol_flash);
|
|
if (marpolPosition.Flashpoint_CEL.IsNullOrEmpty()) {
|
|
marpolPosition.FlashpointInformation = 0;
|
|
} // NF // Ableitung Flashpoint-Info: Christin, 22.3.2017
|
|
else
|
|
{
|
|
if (double.TryParse(marpolPosition.Flashpoint_CEL, out double flashval))
|
|
{
|
|
if (flashval > 60) marpolPosition.FlashpointInformation = 1; // GT60CEL
|
|
else marpolPosition.FlashpointInformation = 2; // LE60CEL
|
|
}
|
|
}
|
|
|
|
marpolPosition.Quantity_KGM = reader.ReadNumber(marpol_quantity);
|
|
marpolPosition.StowagePosition = reader.ReadText(marpol_stowagePosition);
|
|
marpolPosition.PortOfLoading = reader.ReadLoCode(marpol_portOfLoading);
|
|
marpolPosition.PortOfDischarge = reader.ReadLoCode(marpol_portOfDischarge);
|
|
marpolPosition.Remarks = reader.ReadText(marpol_remarks);
|
|
}
|
|
|
|
#endregion
|
|
|
|
if (hazd.HasPositions) // Christin 22.3.17: Felder bei Positionen immer fest ausfüllen
|
|
{
|
|
hazd.NoDPGOnBoardOnArrival = false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region INFO
|
|
|
|
private static bool ScanINFO(Message infoMessage, ExcelReader reader)
|
|
{
|
|
if(infoMessage.Elements.Count == 0)
|
|
{
|
|
INFO newINFO = new INFO();
|
|
newINFO.MessageHeader = infoMessage;
|
|
infoMessage.Elements.Add(newINFO);
|
|
}
|
|
INFO info = infoMessage.Elements[0] as INFO;
|
|
ExcelUtil.ScanMessage(info, reader);
|
|
|
|
string portArea = reader.ReadText("INFO.PortArea")?.ToUpper();
|
|
if (!portArea.IsNullOrEmpty() && DBManager.Instance.GetPortAreaDict().ContainsKey(portArea))
|
|
info.PortArea = portArea;
|
|
else
|
|
info.PortArea = "";
|
|
|
|
info.ShippingArea = reader.ReadShippingArea("INFO.ShippingArea"); // enum read func
|
|
bool? fumigatedBulkCargo = reader.ReadBoolean("INFO.FumigatedBulkCargo");
|
|
info.FumigatedBulkCargo = (byte) ((fumigatedBulkCargo ?? false) ? 1 : 0);
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region STAT
|
|
|
|
private static bool ScanSTAT(Message statMessage, MessageCore messageCore, List<Message> messages, ExcelReader reader)
|
|
{
|
|
if(statMessage.Elements.Count == 0)
|
|
{
|
|
STAT newSTAT = new STAT();
|
|
newSTAT.MessageHeader = statMessage;
|
|
statMessage.Elements.Add(newSTAT);
|
|
}
|
|
STAT stat = statMessage.Elements[0] as STAT;
|
|
ScanMessage(stat, reader);
|
|
|
|
foreach(Message preMessage in messages)
|
|
{
|
|
if(preMessage.MessageNotificationClass == Message.NotificationClass.PRE72H)
|
|
{
|
|
if(preMessage.Elements.Count > 0)
|
|
{
|
|
PRE72H pre72h = preMessage.Elements[0] as PRE72H;
|
|
pre72h.Tanker = stat.IsTanker;
|
|
ExcelReader.SaveMessage(preMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!stat.Flag.IsNullOrEmpty()) stat.Flag = stat.Flag.ToUpper();
|
|
if (!stat.PortOfRegistry.IsNullOrEmpty()) stat.PortOfRegistry = stat.PortOfRegistry.ToUpper();
|
|
|
|
stat.MMSINumber = reader.ReadTextNoWhitespace("STAT.MMSINumber");
|
|
stat.CallSign = reader.ReadTextNoWhitespace("STAT.CallSign");
|
|
stat.ISMCompanyId = reader.ReadTextNoWhitespace("STAT.ISMCompanyId");
|
|
|
|
if (!stat.ISMCompanyId.IsNullOrEmpty())
|
|
{
|
|
// strip "ISM" at the beginning if it is there (27.12.21)
|
|
if (stat.ISMCompanyId.StartsWith("imo", StringComparison.OrdinalIgnoreCase))
|
|
stat.ISMCompanyId = stat.ISMCompanyId.Substring(3);
|
|
|
|
if(stat.ISMCompanyId.Length < 7) { // zero - fill
|
|
while (stat.ISMCompanyId.Length < 7)
|
|
stat.ISMCompanyId = "0" + stat.ISMCompanyId;
|
|
}
|
|
}
|
|
|
|
string transportMode = reader.ReadText("STAT.TransportMode");
|
|
if(transportMode != null)
|
|
{
|
|
if (transportMode.Contains("maritime", StringComparison.OrdinalIgnoreCase)) stat.TransportMode = "1";
|
|
if (transportMode.Equals("1")) stat.TransportMode = transportMode;
|
|
|
|
if (transportMode.Contains("inland", StringComparison.OrdinalIgnoreCase)) stat.TransportMode = "8";
|
|
if (transportMode.Equals("8")) stat.TransportMode = transportMode;
|
|
}
|
|
|
|
// Vessel Email as HerbergEmail sichern
|
|
messageCore.HerbergEmailContactReportingVessel = reader.ReadText("ShipMail");
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region NOA_NOD
|
|
|
|
private static bool ScanNOA_NOD(Message noa_nodMessage, MessageCore messageCore, ExcelReader reader)
|
|
{
|
|
if (noa_nodMessage.Elements.Count == 0)
|
|
{
|
|
NOA_NOD newNoa_nod = new NOA_NOD();
|
|
newNoa_nod.MessageHeader = noa_nodMessage;
|
|
noa_nodMessage.Elements.Add(newNoa_nod);
|
|
}
|
|
|
|
NOA_NOD noa_nod = noa_nodMessage.Elements[0] as NOA_NOD;
|
|
|
|
DateTime? eta = reader.ReadDateTime("NOA_NOD.ETADateToPortOfCall", "NOA_NOD.ETATimeToPortOfCall");
|
|
|
|
if (messageCore.IsTransit)
|
|
{
|
|
if (eta.HasValue)
|
|
noa_nod.ETAToKielCanal = eta;
|
|
}
|
|
else
|
|
{
|
|
if (eta.HasValue)
|
|
noa_nod.ETAToPortOfCall = eta;
|
|
|
|
for (int i = 1; i <= noa_nod.NumberOfExcelRows; i++)
|
|
{
|
|
string callPurposeDescriptionKey = string.Format("NOA_NOD.CallPuposeDescription_{0}", i);
|
|
string callPurposeCodeKey = string.Format("NOA_NOD.CallPurposeCode_{0}", i);
|
|
string callPurposeDescription = reader.ReadText(callPurposeDescriptionKey);
|
|
string callPurposeCode = reader.ReadText(callPurposeCodeKey);
|
|
|
|
if (!callPurposeCode.IsNullOrEmpty())
|
|
{
|
|
|
|
if (!(noa_nod.GetSublistElementWithIdentifier(i.ToString()) is CallPurpose callPurpose))
|
|
{
|
|
callPurpose = new CallPurpose();
|
|
callPurpose.NOA_NOD = noa_nod;
|
|
callPurpose.Identifier = i.ToString();
|
|
noa_nod.CallPurposes.Add(callPurpose);
|
|
}
|
|
callPurpose.CallPurposeCode = ((int?)reader.ReadNumber(callPurposeCodeKey)) ?? 0;
|
|
callPurpose.CallPurposeDescription = callPurposeDescription;
|
|
}
|
|
}
|
|
}
|
|
|
|
string lastPort = reader.ReadText("NOA_NOD.LastPort")?.Trim().ToUpper();
|
|
|
|
if (lastPort != null)
|
|
{
|
|
if (LocodeDB.PortNameFromLocode(lastPort) != null)
|
|
{
|
|
noa_nod.LastPort = lastPort;
|
|
}
|
|
else
|
|
{
|
|
List<string> lastPorts = LocodeDB.AllLocodesForCityName(lastPort);
|
|
if (lastPorts.Count == 1)
|
|
noa_nod.LastPort = lastPorts[0];
|
|
else
|
|
_log.WarnFormat("{0} results in {1} possible LOCODES", lastPort, lastPorts.Count);
|
|
}
|
|
}
|
|
|
|
string nextPort = reader.ReadText("NOA_NOD.NextPort")?.Trim().ToUpper();
|
|
if (!nextPort.IsNullOrEmpty() && (nextPort.Length > 5))
|
|
nextPort = nextPort.Substring(0, 5); //trunc
|
|
|
|
noa_nod.NextPort = nextPort;
|
|
|
|
if(messageCore.IsTransit)
|
|
{
|
|
noa_nod.ETDFromKielCanal = reader.ReadDateTime("NOA_NOD.ETDDateFromPortOfCall", "NOA_NOD.ETDTimeFromPortOfCall");
|
|
}
|
|
else
|
|
{
|
|
noa_nod.ETDFromPortOfCall = reader.ReadDateTime("NOA_NOD.ETDDateFromPortOfCall", "NOA_NOD.ETDTimeFromPortOfCall");
|
|
}
|
|
|
|
noa_nod.ETDFromLastPort = reader.ReadDateTime("NOA_NOD.ETDDateFromLastPort", "NOA_NOD.ETDTimeFromLastPort");
|
|
noa_nod.ETAToNextPort = reader.ReadDateTime("NOA_NOD.ETADateToNextPort", "NOA_NOD.ETATimeToNextPort");
|
|
// DK
|
|
noa_nod.IsAnchored = reader.ReadBoolean("NOA_NOD.IsAnchored");
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AGNT
|
|
|
|
private static bool ScanAGNT(Message agntMessage, ExcelReader reader)
|
|
{
|
|
if(agntMessage.Elements.Count == 0)
|
|
{
|
|
AGNT newAgnt = new AGNT();
|
|
newAgnt.MessageHeader = agntMessage;
|
|
agntMessage.Elements.Add(newAgnt);
|
|
}
|
|
AGNT agnt = agntMessage.Elements[0] as AGNT;
|
|
ExcelUtil.ScanMessage(agnt, reader);
|
|
|
|
if (agnt.AgentLastName.IsNullOrEmpty()) agnt.AgentLastName = "-";
|
|
|
|
// wird nicht mehr entfernt, egal welche Felder gelesen werden
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region WAS
|
|
|
|
private static bool ScanWAS(Message wasMessage, ExcelReader reader, bool isOldVersion)
|
|
{
|
|
if (wasMessage.Elements.Count == 0)
|
|
{
|
|
WAS newWAS = new WAS();
|
|
newWAS.MessageHeader = wasMessage;
|
|
wasMessage.Elements.Add(newWAS);
|
|
}
|
|
WAS was = wasMessage.Elements[0] as WAS;
|
|
was.DeleteElements();
|
|
|
|
ScanMessage(was, reader);
|
|
|
|
was.LastWasteDisposalPort = reader.ReadLoCode("WAS.LastWasteDisposalPort");
|
|
was.NextWasteDisposalPort = reader.ReadLoCode("WAS.NextWasteDisposalPort");
|
|
was.ConfirmationOfCorrectness = true; // wir haben immer Recht (NSW7.0)
|
|
was.ConfirmationOfSufficiency = true;
|
|
|
|
string wastedispServProvName = reader.ReadText("WAS.WasteDisposalServiceProviderName");
|
|
if (wastedispServProvName != null)
|
|
{
|
|
if (was.WasteDisposalServiceProvider.Count == 0)
|
|
{
|
|
WasteDisposalServiceProvider wdsp = new WasteDisposalServiceProvider();
|
|
wdsp.Identifier = "1";
|
|
wdsp.WAS = was;
|
|
was.WasteDisposalServiceProvider.Add(wdsp);
|
|
}
|
|
was.WasteDisposalServiceProvider[0].WasteDisposalServiceProviderName = wastedispServProvName;
|
|
}
|
|
|
|
// Waste 1 - 25
|
|
int maxWaste = isOldVersion ? 15 : was.NumberOfExcelRows;
|
|
for (int i = 1; i <= maxWaste; i++)
|
|
{
|
|
//string wastetype = string.Format("WAS.WasteType_{0}", i);
|
|
string wasteCode = string.Format("WAS.WasteCode_{0}", i);
|
|
string wasteDescription = string.Format("WAS.WasteDescription_{0}", i);
|
|
string wasteAmount = string.Format("WAS.WasteDisposalAmount_MTQ_{0}", i);
|
|
string wasteCapacity = string.Format("WAS.WasteCapacity_MTQ_{0}", i);
|
|
string wasteRetained = string.Format("WAS.WasteAmountRetained_MTQ_{0}", i);
|
|
string wastePort = string.Format("WAS.WasteDisposalPort_{0}", i);
|
|
string amountGen = string.Format("WAS.WasteAmountGeneratedTillNextPort_MTQ_{0}", i);
|
|
|
|
if (!(was.GetSublistElementWithIdentifier(i.ToString()) is Waste waste))
|
|
{
|
|
waste = new Waste();
|
|
waste.Identifier = i.ToString();
|
|
waste.WAS = was;
|
|
was.Waste.Add(waste);
|
|
}
|
|
|
|
waste.WasteType = (int?) reader.ReadNumber(wasteCode);
|
|
|
|
// Waste description Spezialfälle für DK
|
|
waste.WasteDescription = reader.ReadText(wasteDescription);
|
|
if (waste.WasteDescription.IsNullOrEmpty())
|
|
{
|
|
if ((reader.Mode == ExcelReader.CountryMode.DE) && waste.IsDashWasteCode)
|
|
{
|
|
waste.WasteDescription = "-";
|
|
}
|
|
else if (reader.Mode == ExcelReader.CountryMode.DK)
|
|
{
|
|
waste.WasteDescription = "-";
|
|
if (i == 6) waste.WasteDescription = "Domestic waste";
|
|
if (i == 9) waste.WasteDescription = "Operational waste";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (reader.Mode == ExcelReader.CountryMode.DK)
|
|
{
|
|
if (i == 6)
|
|
waste.WasteDescription = string.Format("Domestic waste - {0}", waste.WasteDescription);
|
|
if (i == 9)
|
|
waste.WasteDescription = string.Format("Operational waste - {0}", waste.WasteDescription);
|
|
}
|
|
}
|
|
|
|
// RM am 24.1.18, ich hoffe das stimmt so wie sie meint..
|
|
if((reader.Mode == ExcelReader.CountryMode.DK) && (i==9))
|
|
{
|
|
_log.DebugFormat("DK: Changing Waste code {0} to 2300 for line {1}", waste.WasteType, i);
|
|
waste.WasteType = 2300;
|
|
}
|
|
|
|
// falls ein altes Sheet eingelesen wird, diese Felder automatisch mappen
|
|
if (waste.WasteType == 1100) waste.WasteType = 102;
|
|
if (waste.WasteType == 1200) waste.WasteType = 101;
|
|
if (waste.WasteType == 1300) waste.WasteType = 999;
|
|
if (waste.WasteType == 2100) waste.WasteType = 502;
|
|
if (waste.WasteType == 2200) waste.WasteType = 501;
|
|
if (waste.WasteType == 2300) waste.WasteType = 503;
|
|
if (waste.WasteType == 2311) waste.WasteType = 504;
|
|
if (waste.WasteType == 2308) waste.WasteType = 505;
|
|
if (waste.WasteType == 2313) waste.WasteType = 506;
|
|
if (waste.WasteType == 2309) waste.WasteType = 507;
|
|
if (waste.WasteType == 3000) waste.WasteType = 401;
|
|
|
|
waste.WasteDisposalAmount_MTQ = reader.ReadNumberDefaultZero(wasteAmount);
|
|
waste.WasteCapacity_MTQ = reader.ReadNumberDefaultZero(wasteCapacity);
|
|
waste.WasteAmountRetained_MTQ = reader.ReadNumberDefaultZero(wasteRetained);
|
|
|
|
waste.WasteDisposalPort = reader.ReadLoCode(wastePort); // aka RemainingWasteDisposalPort
|
|
|
|
if (waste.WasteDisposalPort.IsNullOrEmpty())
|
|
{
|
|
waste.WasteDisposalPort = "ZZUKN";
|
|
}
|
|
|
|
waste.WasteAmountGeneratedTillNextPort_MTQ = reader.ReadNumberDefaultZero(amountGen);
|
|
|
|
if (!waste.WasteType.HasValue || (waste.WasteType > 999))
|
|
{
|
|
was.Waste.Remove(waste);
|
|
}
|
|
}
|
|
|
|
was.AddMissingWaste();
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#region WAS_RCPT
|
|
|
|
private static bool ScanWAS_RCPT(Message was_rcptMessage, ExcelReader reader)
|
|
{
|
|
was_rcptMessage.DeleteElements();
|
|
|
|
for (int i = 1; i <= was_rcptMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string wasrcpt_identNumber = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.IdentificationNumber", i);
|
|
string wasrcpt_portreceptFacilityName = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.PortReceptionFacilityName", i);
|
|
string wasrcpt_portreceptFacilityProviderName = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.PortReceptionFacilityProviderName", i);
|
|
string wasrcpt_treatmentFacility = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.TreatmentFacilityProviderName", i);
|
|
string wasrcpt_delFromDate = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.WasteDeliveryDateFromDate", i);
|
|
string wasrcpt_delFromTime = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.WasteDeliveryDateFromTime", i);
|
|
string wasrcpt_delToDate = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.WasteDeliveryDateToDate", i);
|
|
string wasrcpt_delToTime = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.WasteDeliveryDateToTime", i);
|
|
|
|
if (!(was_rcptMessage.GetSublistElementWithIdentifier(i.ToString()) is WAS_RCPT wasr))
|
|
{
|
|
wasr = new WAS_RCPT();
|
|
wasr.Identifier = i.ToString();
|
|
wasr.MessageHeader = was_rcptMessage;
|
|
was_rcptMessage.Elements.Add(wasr);
|
|
}
|
|
else
|
|
{
|
|
wasr.DeleteElements();
|
|
}
|
|
|
|
wasr.IdentificationNumber = reader.ReadText(wasrcpt_identNumber);
|
|
wasr.PortReceptionFacilityName = reader.ReadText(wasrcpt_portreceptFacilityName);
|
|
wasr.PortReceptionFacilityProviderName = reader.ReadText(wasrcpt_portreceptFacilityProviderName);
|
|
string treatmentFacility = reader.ReadText(wasrcpt_treatmentFacility);
|
|
if(!treatmentFacility.IsNullOrEmpty())
|
|
{
|
|
TreatmentFacilityProvider tfp = new TreatmentFacilityProvider();
|
|
tfp.WAS_RCPT = wasr;
|
|
tfp.Identifier = "1";
|
|
wasr.TreatmentFacilityProvider.Add(tfp);
|
|
tfp.TreatmentFacilityProviderName = treatmentFacility;
|
|
}
|
|
wasr.WasteDeliveryDateFrom = reader.ReadDateTime(wasrcpt_delFromDate, wasrcpt_delFromTime);
|
|
wasr.WasteDeliveryDateTo = reader.ReadDateTime(wasrcpt_delToDate, wasrcpt_delToTime);
|
|
|
|
// read waste deliveries
|
|
for (int j = 1; j <= wasr.NumberOfExcelRows; j++)
|
|
{
|
|
string wtype = string.Format("WAS_RCPT.WasteDeliveryReceipt.WasteCode_{0}", j);
|
|
string wDescr = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.WasteDescription_{1}", i, j);
|
|
string wAmount = string.Format("WAS_RCPT.WasteDeliveryReceipt_{0}.AmountWasteReceived_MTQ_{1}", i, j);
|
|
|
|
WasteReceived wr = new WasteReceived();
|
|
wr.WAS_RCPT = wasr;
|
|
wasr.WasteReceived.Add(wr);
|
|
wr.Identifier = j.ToString();
|
|
|
|
wr.WasteCode = reader.ReadText(wtype); // hier muss immer was stehen, ist ein festes Beschreibungsfeld
|
|
wr.WasteDescription = reader.ReadText(wDescr);
|
|
if(wr.WasteDescription.IsNullOrEmpty() && (wr.WasteCode != null))
|
|
{
|
|
if (wr.WasteCode.Equals("999") || wr.WasteCode.Equals("201") || wr.WasteCode.Equals("202") || wr.WasteCode.Equals("203") ||
|
|
wr.WasteCode.Equals("204") || wr.WasteCode.Equals("510") || wr.WasteCode.Equals("511"))
|
|
wr.WasteDescription = "-";
|
|
}
|
|
wr.AmountWasteReceived_MTQ = reader.ReadNumber(wAmount);
|
|
if (!wr.AmountWasteReceived_MTQ.HasValue) wr.AmountWasteReceived_MTQ = 0; // Default ist 0, nicht nix ;-)
|
|
}
|
|
|
|
// only add message when an identification number was given
|
|
if (wasr.IdentificationNumber.IsNullOrEmpty())
|
|
was_rcptMessage.Elements.Remove(wasr);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MDH
|
|
|
|
private static bool ScanMDH(Message mdhMessage, List<Message> messages, MessageCore messageCore, ExcelReader reader)
|
|
{
|
|
if(mdhMessage.Elements.Count == 0)
|
|
{
|
|
MDH newMDH = new MDH();
|
|
newMDH.MessageHeader = mdhMessage;
|
|
mdhMessage.Elements.Add(newMDH);
|
|
}
|
|
MDH mdh = mdhMessage.Elements[0] as MDH;
|
|
mdh.DeleteElements();
|
|
ExcelUtil.ScanMessage(mdh, reader);
|
|
|
|
// lt. Mail von Christin am 28.9.2016
|
|
mdh.MDHSimplification = false;
|
|
mdh.PortOfCallWhereCompleteMDHNotified = "";
|
|
|
|
|
|
string kuerzelErsteZelle = reader.ReadText("MDH.PortOfCallLast30DaysLocode_1");
|
|
|
|
try
|
|
{
|
|
|
|
#region PoC last 30 days
|
|
|
|
// lt. Mail von Christin am 11.10.2016
|
|
// "SEC" Mode, die Werte aus last10PortFacilitesCalled (SEC) werden übernommen
|
|
// das funktioniert, da SEC vor MDH gelesen wird
|
|
if (!kuerzelErsteZelle.IsNullOrEmpty() && kuerzelErsteZelle.Equals("sec", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
Message secMessage = ExcelUtil.GetMessageWithType(messages, messageCore, Message.NotificationClass.SEC);
|
|
if (secMessage.Elements.Count > 0)
|
|
{
|
|
SEC sec = secMessage.Elements[0] as SEC;
|
|
int i = 1;
|
|
foreach (LastTenPortFacilitiesCalled ltpfc in sec.LastTenPortFacilitesCalled)
|
|
{
|
|
if (!(mdh.GetSublistElementWithIdentifier((i + 1).ToString()) is PortOfCallLast30Days poc30d))
|
|
{
|
|
poc30d = new PortOfCallLast30Days();
|
|
poc30d.Identifier = (i + 1).ToString();
|
|
poc30d.MDH = mdh;
|
|
mdh.PortOfCallLast30Days.Add(poc30d);
|
|
}
|
|
|
|
poc30d.PortOfCallLast30DaysCrewMembersJoined = false;
|
|
poc30d.PortOfCallLast30DaysLocode = ltpfc.PortFacilityPortLoCode;
|
|
poc30d.PortOfCallLast30DaysDateOfDeparture = ltpfc.PortFacilityDateOfDeparture;
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
else // "normal mode", aus den Zellen lesen
|
|
{
|
|
|
|
// POC last 30 days
|
|
for (int i = 0; i < mdh.NumberOfExcelRows; i++)
|
|
{
|
|
string portName = string.Format("MDH.PortOfCallLast30DaysPort_{0}", i + 1);
|
|
string portCountry = string.Format("MDH.PortOfCallLast30DaysCountry_{0}", i + 1);
|
|
string locode = string.Format("MDH.PortOfCallLast30DaysLocode_{0}", i + 1);
|
|
string crewJoined = string.Format("MDH.PortOfCallLast30DaysCrewMembersJoined_{0}", i + 1);
|
|
string crewName = string.Format("MDH.PortOfCallLast30DaysCrewJoinedShipName_{0}", i + 1);
|
|
string depDate = string.Format("MDH.PortOfCallLast30DaysDateOfDeparture_{0}", i + 1);
|
|
|
|
if (!(mdh.GetSublistElementWithIdentifier((i + 1).ToString()) is PortOfCallLast30Days poc30d))
|
|
{
|
|
poc30d = new PortOfCallLast30Days();
|
|
poc30d.Identifier = (i + 1).ToString();
|
|
poc30d.MDH = mdh;
|
|
mdh.PortOfCallLast30Days.Add(poc30d);
|
|
}
|
|
|
|
string pName = reader.ReadText(portName);
|
|
string pCountry = reader.ReadText(portCountry);
|
|
|
|
poc30d.PortOfCallLast30DaysDateOfDeparture = reader.ReadDate(depDate);
|
|
poc30d.PortOfCallLast30DaysLocode = reader.ReadLoCode(locode);
|
|
|
|
// Verbesserungsvorschlag Jul/21: CrewMembersJoined Häkchen abhängig von den Namen in der Spalte
|
|
bool? PortOfCallLast30DaysCrewMembersJoinedFlag = reader.ReadBoolean(crewJoined);
|
|
|
|
string crewNameString = reader.ReadText(crewName);
|
|
poc30d.PortOfCallLast30DaysCrewMembersJoined = !crewNameString.IsNullOrEmpty();
|
|
|
|
if (poc30d.PortOfCallLast30DaysCrewMembersJoined ?? false)
|
|
{
|
|
// try different separators
|
|
string[] crew = crewNameString.Split(';');
|
|
if (crew.Length == 1)
|
|
crew = crewNameString.Split(',');
|
|
|
|
for (int j = 0; j < crew.Length; j++)
|
|
{
|
|
if (!(poc30d.GetSublistElementWithIdentifier((j + 1).ToString()) is PortOfCallLast30DaysCrewJoinedShip poc30dCrew))
|
|
{
|
|
poc30dCrew = new PortOfCallLast30DaysCrewJoinedShip();
|
|
poc30dCrew.Identifier = (j + 1).ToString();
|
|
poc30dCrew.PortOfCallLast30Days = poc30d;
|
|
poc30d.CrewJoinedShip.Add(poc30dCrew);
|
|
}
|
|
|
|
poc30dCrew.PortOfCallLast30DaysCrewJoinedShipName = crew[j];
|
|
}
|
|
}
|
|
|
|
// Leer/def. Zeilen entfernen
|
|
if (!poc30d.PortOfCallLast30DaysDateOfDeparture.HasValue && (poc30d.PortOfCallLast30DaysLocode == null))
|
|
mdh.PortOfCallLast30Days.Remove(poc30d);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SanitaryMeasures
|
|
|
|
if (mdh.SanitaryMeasuresApplied ?? false)
|
|
{
|
|
for (int i = 1; i <= 3; i++)
|
|
{
|
|
string smType = string.Format("MDH.SanitaryMeasuresType_{0}", i);
|
|
string smLocation = string.Format("MDH.SanitaryMeasuresLocation_{0}", i);
|
|
string smDate = string.Format("MDH.SanitaryMeasuresDate_{0}", i);
|
|
|
|
SanitaryMeasuresDetail smd = mdh.GetSanitaryMeasuresDetailWithIdentifier(i.ToString());
|
|
if(smd == null)
|
|
{
|
|
smd = new SanitaryMeasuresDetail();
|
|
smd.Identifier = i.ToString();
|
|
mdh.SanitaryMeasuresDetails.Add(smd);
|
|
smd.MDH = mdh;
|
|
}
|
|
|
|
smd.SanitaryMeasuresType = reader.ReadText(smType);
|
|
smd.SanitaryMeasuresLocation = reader.ReadText(smLocation);
|
|
smd.SanitaryMeasuresDate = reader.ReadDate(smDate);
|
|
// dont save completely empty structs
|
|
if (!smd.SanitaryMeasuresDate.HasValue && smd.SanitaryMeasuresLocation.IsNullOrEmpty() && smd.SanitaryMeasuresType.IsNullOrEmpty())
|
|
mdh.SanitaryMeasuresDetails.Remove(smd);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InfectedArea
|
|
|
|
if (mdh.InfectedAreaVisited ?? false)
|
|
{
|
|
for (int i = 1; i <= 3; i++)
|
|
{
|
|
string iaPort = string.Format("MDH.InfectedAreaPort_{0}", i);
|
|
string iaDate = string.Format("MDH.InfectedAreaDate_{0}", i);
|
|
InfectedArea ia = mdh.GetInfectedAreaWithIdentifier(i.ToString());
|
|
if (ia == null)
|
|
{
|
|
ia = new InfectedArea();
|
|
ia.Identifier = i.ToString();
|
|
mdh.InfectedAreas.Add(ia);
|
|
ia.MDH = mdh;
|
|
}
|
|
|
|
ia.InfectedAreaPort = reader.ReadText(iaPort);
|
|
ia.InfectedAreaDate = reader.ReadDate(iaDate);
|
|
// dont save completely empty structs
|
|
if (!ia.InfectedAreaDate.HasValue && ia.InfectedAreaPort.IsNullOrEmpty())
|
|
mdh.InfectedAreas.Remove(ia);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StowawaysJoiningLocation
|
|
|
|
if(mdh.StowawaysDetected ?? false)
|
|
{
|
|
for (int i = 1; i <= 3; i++)
|
|
{
|
|
string sjlLookup = string.Format("MDH.StowawaysJoiningLocation_{0}", i);
|
|
StowawaysJoiningLocation sjl = mdh.GetStowawaysJoiningLocationWithIdentifier(i.ToString());
|
|
if (sjl == null)
|
|
{
|
|
sjl = new StowawaysJoiningLocation();
|
|
sjl.Identifier = i.ToString();
|
|
sjl.MDH = mdh;
|
|
mdh.StowawaysJoiningLocations.Add(sjl);
|
|
}
|
|
|
|
sjl.StowawayJoiningLocation = reader.ReadText(sjlLookup);
|
|
if (sjl.StowawayJoiningLocation.IsNullOrEmpty())
|
|
{
|
|
mdh.StowawaysJoiningLocations.Remove(sjl);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
_log.ErrorFormat("Crash during reading of MDH message: {0}", ex);
|
|
return false;
|
|
}
|
|
|
|
// wird nicht wieder entfernt falls keine Daten vorliegen
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SEC
|
|
|
|
private static bool ScanSEC(Message secMessage, ExcelReader reader)
|
|
{
|
|
if (secMessage.Elements.Count == 0)
|
|
{
|
|
SEC newSEC = new SEC();
|
|
newSEC.MessageHeader = secMessage;
|
|
secMessage.Elements.Add(newSEC);
|
|
}
|
|
|
|
SEC sec = secMessage.Elements[0] as SEC;
|
|
ScanMessage(sec, reader);
|
|
|
|
reader.ReadBoolean("SEC.AreMatterToReport"); // das berücksichtigen wir derzeit nicht in der DB (implizit)
|
|
|
|
string isscType = reader.ReadText("SEC.ISSCType");
|
|
if(isscType != null)
|
|
{
|
|
if (isscType.Equals("full", StringComparison.OrdinalIgnoreCase) || isscType.Equals("1"))
|
|
sec.ISSCType = 0;
|
|
if (isscType.Equals("interim", StringComparison.OrdinalIgnoreCase) || isscType.Equals("2"))
|
|
sec.ISSCType = 1;
|
|
}
|
|
|
|
string shipsecLevel = reader.ReadText("SEC.CurrentShipSecurityLevel");
|
|
if (!shipsecLevel.IsNullOrEmpty())
|
|
{
|
|
if (shipsecLevel.Contains('1')) sec.CurrentShipSecurityLevel = 1;
|
|
if (shipsecLevel.Contains('2')) sec.CurrentShipSecurityLevel = 2;
|
|
if (shipsecLevel.Contains('3')) sec.CurrentShipSecurityLevel = 3;
|
|
}
|
|
|
|
string isscIssuerType = reader.ReadText("SEC.ISSCIssuerType");
|
|
if(isscIssuerType != null)
|
|
{
|
|
if (isscIssuerType.Equals("rso", StringComparison.OrdinalIgnoreCase) || isscIssuerType.Equals("2"))
|
|
sec.ISSCIssuerType = 1;
|
|
if (isscIssuerType.Contains("admin", StringComparison.OrdinalIgnoreCase) || isscIssuerType.Equals("1"))
|
|
sec.ISSCIssuerType = 0;
|
|
}
|
|
|
|
sec.GeneralDescriptionOfCargo = reader.ReadGeneralDescriptionOfCargo("SEC.GeneralDescriptionOfCargo");
|
|
|
|
bool? secKielArrival = reader.ReadBoolean("SEC.KielCanalPassagePlanned_Arrival");
|
|
bool? secKielDeparture = reader.ReadBoolean("SEC.KielCanalPassagePlanned_Departure");
|
|
|
|
// Leichter Umbau ("Verbesserung") der Logik Jul 21: Wenn ETA Werte drin stehen und das Flag nicht gesetzt ist
|
|
// wird es gesetzt sonst nicht gesetzt
|
|
sec.KielCanalPassagePlanned = (secKielArrival ?? false) || (secKielDeparture ?? false);
|
|
// if (sec.KielCanalPassagePlanned ?? false)
|
|
// {
|
|
sec.KielCanalPassagePlannedIncomming = reader.ReadDateTime("SEC.ETADateKielCanalPassagePlannedIncomming", "SEC.ETATimeKielCanalPassagePlannedIncomming");
|
|
sec.KielCanalPassagePlannedOutgoing = reader.ReadDateTime("SEC.ETADateKielCanalPassagePlannedOutgoing", "SEC.ETATimeKielCanalPassagePlannedOutgoing");
|
|
// }
|
|
|
|
if ((!sec.KielCanalPassagePlanned ?? false) && sec.KielCanalPassagePlannedIncomming.HasValue) sec.KielCanalPassagePlanned = true;
|
|
if ((!sec.KielCanalPassagePlanned ?? false) && sec.KielCanalPassagePlannedOutgoing.HasValue) sec.KielCanalPassagePlanned = true;
|
|
|
|
if (!sec.KielCanalPassagePlannedIncomming.HasValue && !sec.KielCanalPassagePlannedOutgoing.HasValue)
|
|
sec.KielCanalPassagePlanned = false;
|
|
|
|
// Last10PortFacilitesCalled
|
|
for (int i = 1; i <= 10; i++)
|
|
{
|
|
string portName = string.Format("SEC.PortFacilityPortName_{0}", i);
|
|
string portCountry = string.Format("SEC.PortFacilityPortCountry_{0}", i);
|
|
string portLocode = string.Format("SEC.PortFacilityPortLoCode_{0}", i);
|
|
string portDateOfArrival = string.Format("SEC.PortFacilityDateOfArrival_{0}", i);
|
|
string portDateOfDeparture = string.Format("SEC.PortFacilityDateOfDeparture_{0}", i);
|
|
string portShipSecLevel = string.Format("SEC.PortFacilityShipSecurityLevel_{0}", i);
|
|
string portGISISCode = string.Format("SEC.PortFacilityGISISCode_{0}", i);
|
|
string portSecMatters = string.Format("SEC.PortFacilitySecurityMattersToReport_{0}", i);
|
|
|
|
if (!(sec.GetPortFacilityWithIdentifier(i.ToString()) is LastTenPortFacilitiesCalled l10fc))
|
|
{
|
|
l10fc = new LastTenPortFacilitiesCalled();
|
|
l10fc.Identifier = i.ToString();
|
|
l10fc.SEC = sec;
|
|
sec.LastTenPortFacilitesCalled.Add(l10fc);
|
|
}
|
|
|
|
l10fc.PortFacilityPortName = reader.ReadText(portName);
|
|
l10fc.PortFacilityPortCountry = reader.ReadText(portCountry);
|
|
l10fc.PortFacilityPortLoCode = reader.ReadLoCode(portLocode);
|
|
l10fc.PortFacilityDateOfArrival = reader.ReadDate(portDateOfArrival);
|
|
l10fc.PortFacilityDateOfDeparture = reader.ReadDate(portDateOfDeparture);
|
|
|
|
string sLevel = reader.ReadText(portShipSecLevel);
|
|
if(!sLevel.IsNullOrEmpty())
|
|
{
|
|
if (sLevel.Contains('1')) l10fc.PortFacilityShipSecurityLevel = 1;
|
|
if (sLevel.Contains('2')) l10fc.PortFacilityShipSecurityLevel = 2;
|
|
if (sLevel.Contains('3')) l10fc.PortFacilityShipSecurityLevel = 3;
|
|
}
|
|
|
|
l10fc.PortFacilityGISISCode = reader.ReadTextNoWhitespace(portGISISCode);
|
|
|
|
if (l10fc.PortFacilityGISISCode.IsNullOrEmpty() || l10fc.PortFacilityGISISCode == "0")
|
|
l10fc.PortFacilityGISISCode = "0000";
|
|
if(l10fc.PortFacilityGISISCode?.Length < 4)
|
|
{
|
|
while (l10fc.PortFacilityGISISCode.Length < 4) l10fc.PortFacilityGISISCode = "0" + l10fc.PortFacilityGISISCode;
|
|
}
|
|
|
|
l10fc.PortFacilitySecurityMattersToReport = reader.ReadText(portSecMatters);
|
|
|
|
// keinen "leeren" Hafen anlegen, wenn der Eintrag leer war (trifft anscheinend bei Neubauten zu, siehe E-Mail Christin vom 20./22.6.17
|
|
if (l10fc.PortFacilityPortName.IsNullOrEmpty() && l10fc.PortFacilityPortLoCode.IsNullOrEmpty() && l10fc.PortFacilityPortCountry.IsNullOrEmpty())
|
|
sec.LastTenPortFacilitesCalled.Remove(l10fc);
|
|
|
|
}
|
|
|
|
// Ship2ShipActivities
|
|
for (int i = 1; i <= 10; i++)
|
|
{
|
|
string s2sName = string.Format("SEC.ShipToShipActivityLocationName_{0}", i);
|
|
string s2sLocode = string.Format("SEC.ShipToShipActivityLocationLoCode_{0}", i);
|
|
string s2sLatitude = string.Format("SEC.ShipToShipActivityLocationCoordinatesLatitude_{0}", i);
|
|
string s2sLongitude = string.Format("SEC.ShipToShipActivityLocationCoordinatesLongitude_{0}", i);
|
|
string s2sFromDate = string.Format("SEC.ShipToShipActivityDateFrom_{0}", i);
|
|
string s2sToDate = string.Format("SEC.ShipToShipActivityDateTo_{0}", i);
|
|
string s2sSec = string.Format("SEC.ShipToShipActivitySecurityMattersToReport_{0}", i);
|
|
string s2sActivityString = string.Format("SEC.ShipToShipActivityType_{0}", i);
|
|
|
|
|
|
if (!(sec.GetShipToShipWithIdentifier(i.ToString()) is ShipToShipActivitiesDuringLastTenPortFacilitiesCalled s2sActivity))
|
|
{
|
|
s2sActivity = new ShipToShipActivitiesDuringLastTenPortFacilitiesCalled();
|
|
s2sActivity.Identifier = i.ToString();
|
|
s2sActivity.SEC = sec;
|
|
sec.ShipToShipActivitiesDuringLastTenPortFacilitiesCalled.Add(s2sActivity);
|
|
}
|
|
|
|
s2sActivity.ShipToShipActivityLocationName = reader.ReadText(s2sName);
|
|
if (s2sActivity.ShipToShipActivityLocationName.IsNullOrEmpty())
|
|
{
|
|
sec.ShipToShipActivitiesDuringLastTenPortFacilitiesCalled.Remove(s2sActivity);
|
|
continue;
|
|
}
|
|
|
|
s2sActivity.ShipToShipActivityLocationLoCode = reader.ReadLoCode(s2sLocode);
|
|
s2sActivity.ShipToShipActivityLocationCoordinatesLatitude = (int?)reader.ReadNumber(s2sLatitude);
|
|
// keine "0" (d.h. fehlerhafte Koordinaten) ins ANSW übergeben falls im Sheet nichts ist aber der Reader das aus irgendeinem Grund liest
|
|
if (s2sActivity.ShipToShipActivityLocationCoordinatesLatitude == 0)
|
|
s2sActivity.ShipToShipActivityLocationCoordinatesLatitude = null;
|
|
s2sActivity.ShipToShipActivityLocationCoordinatesLongitude = (int?)reader.ReadNumber(s2sLongitude);
|
|
if (s2sActivity.ShipToShipActivityLocationCoordinatesLongitude == 0)
|
|
s2sActivity.ShipToShipActivityLocationCoordinatesLongitude = null;
|
|
s2sActivity.ShipToShipActivityDateFrom = reader.ReadDate(s2sFromDate);
|
|
s2sActivity.ShipToShipActivityDateTo = reader.ReadDate(s2sToDate);
|
|
s2sActivity.ShipToShipActivityTypeCode = (int?) reader.ReadNumber(s2sActivityString);
|
|
reader.ReadShip2ShipActivityType(s2sActivityString); // 24.8.21 nicht Code dem Klartext zuordnen, nur das Feld kolorieren
|
|
s2sActivity.ShipToShipActivitySecurityMattersToReport = reader.ReadText(s2sSec);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BKRA
|
|
|
|
private static bool ScanBKRA(Message bkraMessage,ExcelReader reader)
|
|
{
|
|
bkraMessage.DeleteElements();
|
|
for (int i = 1; i <= bkraMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string lnQuantity = string.Format("BKRA.BunkerFuelQuantity_TNE_{0}", i);
|
|
string lnType = string.Format("BKRA.BunkerFuelType_{0}", i);
|
|
|
|
if (!(bkraMessage.GetSublistElementWithIdentifier((i).ToString()) is BRKA bkra))
|
|
{
|
|
bkra = new BRKA();
|
|
bkra.Identifier = (i).ToString();
|
|
bkra.MessageHeader = bkraMessage;
|
|
bkraMessage.Elements.Add(bkra);
|
|
}
|
|
|
|
bkra.BunkerFuelQuantity_TNE = reader.ReadNumber(lnQuantity);
|
|
bkra.BunkerFuelType = reader.ReadText(lnType);
|
|
|
|
// dont save empty element
|
|
if (bkra.IsNew && !bkra.BunkerFuelQuantity_TNE.HasValue && bkra.BunkerFuelType.IsNullOrEmpty())
|
|
bkraMessage.Elements.Remove(bkra);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BKRD
|
|
|
|
private static bool ScanBKRD(Message bkrdMessage, ExcelReader reader)
|
|
{
|
|
bkrdMessage.DeleteElements();
|
|
for (int i = 1; i <= bkrdMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string lnQuantity = string.Format("BKRD.BunkerFuelQuantity_TNE_{0}", i);
|
|
string lnType = string.Format("BKRD.BunkerFuelType_{0}", i);
|
|
if (!(bkrdMessage.GetSublistElementWithIdentifier((i).ToString()) is BRKD bkrd))
|
|
{
|
|
bkrd = new BRKD();
|
|
bkrd.Identifier = (i).ToString();
|
|
bkrd.MessageHeader = bkrdMessage;
|
|
bkrdMessage.Elements.Add(bkrd);
|
|
}
|
|
|
|
bkrd.BunkerFuelQuantity_TNE = reader.ReadNumber(lnQuantity);
|
|
bkrd.BunkerFuelType = reader.ReadText(lnType);
|
|
|
|
// dont save empty element
|
|
if (bkrd.IsNew && !bkrd.BunkerFuelQuantity_TNE.HasValue && bkrd.BunkerFuelType.IsNullOrEmpty())
|
|
bkrdMessage.Elements.Remove(bkrd);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TOWA
|
|
|
|
private static bool ScanTOWA(Message towaMessage, ExcelReader reader)
|
|
{
|
|
// 24.4.21: TOWA beim Excel import
|
|
bool hasTOWAMarker = false;
|
|
for (int i = 1; i <= towaMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string tName = string.Format("TOWA.TowageOnArrivalName_{0}", i);
|
|
string towageName = reader.ReadText(tName);
|
|
if (!towageName.IsNullOrEmpty())
|
|
{
|
|
hasTOWAMarker = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasTOWAMarker) return false; // no TOWA info on sheet
|
|
|
|
towaMessage.DeleteElements();
|
|
for (int i = 1; i <= towaMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string tName = string.Format("TOWA.TowageOnArrivalName_{0}", i);
|
|
string tFlag = string.Format("TOWA.TowageOnArrivalFlag_{0}", i);
|
|
string tPoC = string.Format("TOWA.TowageOnArrivalPurposeOfCall_{0}", i);
|
|
string tDraft = string.Format("TOWA.TowageOnArrivalDraught_DMT_{0}", i);
|
|
string tGT = string.Format("TOWA.TowageOnArrivalGrossTonnage_{0}", i);
|
|
string tLen = string.Format("TOWA.TowageOnArrivalLengthOverall_MTR_{0}", i);
|
|
string tBeam = string.Format("TOWA.TowageOnArrivalBeam_MTR_{0}", i);
|
|
string tOp = string.Format("TOWA.TowageOnArrivalOperatorCompanyName_{0}", i);
|
|
|
|
string towageName = reader.ReadText(tName);
|
|
if (towageName.IsNullOrEmpty()) continue;
|
|
|
|
if (!(towaMessage.GetSublistElementWithIdentifier((i).ToString()) is TOWA towa))
|
|
{
|
|
towa = new TOWA();
|
|
towa.Identifier = (i).ToString();
|
|
towa.MessageHeader = towaMessage;
|
|
towaMessage.Elements.Add(towa);
|
|
}
|
|
|
|
towa.TowageOnArrivalName = towageName;
|
|
|
|
towa.TowageOnArrivalFlag = reader.ReadNationality(tFlag);
|
|
towa.TowageOnArrivalPurposeOfCall = reader.ReadText(tPoC);
|
|
towa.TowageOnArrivalDraught_DMT = reader.ReadNumber(tDraft);
|
|
if (towa.TowageOnArrivalDraught_DMT.HasValue)
|
|
towa.TowageOnArrivalDraught_DMT *= 10;
|
|
towa.TowageOnArrivalGrossTonnage = (int?) reader.ReadNumber(tGT);
|
|
towa.TowageOnArrivalLengthOverall_MTR = reader.ReadNumber(tLen);
|
|
towa.TowageOnArrivalBeam_MTR = reader.ReadNumber(tBeam);
|
|
towa.TowageOnArrivalOperatorCompanyName = reader.ReadText(tOp);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TOWD
|
|
|
|
private static bool ScanTOWD(Message towdMessage,ExcelReader reader)
|
|
{
|
|
|
|
// 24.4.21: TOWD beim Excel import
|
|
bool hasTOWDMarker = false;
|
|
for (int i = 1; i <= towdMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string tName = string.Format("TOWD.TowageOnDepartureName_{0}", i);
|
|
string towageName = reader.ReadText(tName);
|
|
if (!towageName.IsNullOrEmpty())
|
|
{
|
|
hasTOWDMarker = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasTOWDMarker) return false; // no TOWD info on sheet
|
|
|
|
towdMessage.DeleteElements();
|
|
|
|
for (int i = 1; i <= towdMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string tName = string.Format("TOWD.TowageOnDepartureName_{0}", i);
|
|
string tFlag = string.Format("TOWD.TowageOnDepartureFlag_{0}", i);
|
|
string tDraft = string.Format("TOWD.TowageOnDepartureDraught_DMT_{0}", i);
|
|
string tLen = string.Format("TOWD.TowageOnDepartureLengthOverall_MTR_{0}", i);
|
|
string tBeam = string.Format("TOWD.TowageOnDepartureBeam_MTR_{0}", i);
|
|
string tOp = string.Format("TOWD.TowageOnDepartureOperatorCompanyName_{0}", i);
|
|
string tPoc = string.Format("TOWD.TowageOnArrivalPurposeOfCall_{0}", i);
|
|
string tgt = string.Format("TOWD.TowageOnArrivalGrossTonnage_{0}", i);
|
|
|
|
string towageName = reader.ReadText(tName);
|
|
if (towageName.IsNullOrEmpty()) continue;
|
|
|
|
if (!(towdMessage.GetSublistElementWithIdentifier((i).ToString()) is TOWD towd))
|
|
{
|
|
towd = new TOWD();
|
|
towd.Identifier = (i).ToString();
|
|
towd.MessageHeader = towdMessage;
|
|
towdMessage.Elements.Add(towd);
|
|
}
|
|
|
|
towd.TowageOnDepartureName = towageName;
|
|
towd.TowageOnDepartureFlag = reader.ReadNationality(tFlag);
|
|
towd.TowageOnDepartureDraught_DMT = reader.ReadNumber(tDraft);
|
|
if (towd.TowageOnDepartureDraught_DMT.HasValue)
|
|
towd.TowageOnDepartureDraught_DMT *= 10;
|
|
towd.TowageOnDepartureLengthOverall_MTR = reader.ReadNumber(tLen);
|
|
towd.TowageOnDepartureBeam_MTR = reader.ReadNumber(tBeam);
|
|
towd.TowageOnDepartureOperatorCompanyName = reader.ReadText(tOp);
|
|
//towd.TowageOnD
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PRE72H
|
|
|
|
private static bool ScanPRE72H(Message pre72hMessage, ExcelReader reader)
|
|
{
|
|
if (pre72hMessage.Elements.Count == 0)
|
|
{
|
|
PRE72H newPRE72H = new PRE72H();
|
|
newPRE72H.MessageHeader = pre72hMessage;
|
|
pre72hMessage.Elements.Add(newPRE72H);
|
|
}
|
|
PRE72H pre72h = pre72hMessage.Elements[0] as PRE72H;
|
|
ScanMessage(pre72h, reader);
|
|
// diese Nachricht bleibt auch wenn sie leer ist
|
|
pre72h.ConditionCargoBallastTanks = reader.ReadConditionTanks("PRE72H.ConditionCargoBallastTanks");
|
|
pre72h.TankerHullConfiguration = reader.ReadHullConfiguration("PRE72H.TankerHullConfiguration");
|
|
pre72h.PlannedWorks = reader.ReadText("PRE72H.PlannedWorks");
|
|
if (pre72h.PlannedWorks.IsNullOrEmpty()) pre72h.PlannedWorks = "n";
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SERV
|
|
|
|
private static bool ScanSERV(Message servMessage, ExcelReader reader)
|
|
{
|
|
if(servMessage.Elements.Count == 0)
|
|
{
|
|
SERV newSERV = new SERV();
|
|
newSERV.MessageHeader = servMessage;
|
|
newSERV.Identifier = "1";
|
|
servMessage.Elements.Add(newSERV);
|
|
}
|
|
SERV serv = servMessage.Elements[0] as SERV;
|
|
ScanMessage(serv, reader);
|
|
if (serv.ServiceBeneficiary.IsNullOrEmpty() && serv.ServiceInvoiceRecipient.IsNullOrEmpty())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region STO
|
|
|
|
private static bool ScanSTO(Message stoMessage, ExcelReader reader)
|
|
{
|
|
stoMessage.DeleteElements();
|
|
|
|
for(int i=0;i<stoMessage.NumberOfExcelRows;i++) // 10
|
|
{
|
|
string stoName = string.Format("STO.Name_{0}", i + 1);
|
|
string stoQuantity = string.Format("STO.Quantity_{0}", i + 1);
|
|
string stoQuantityUnit = string.Format("STO.QuantityUnit_{0}", i + 1);
|
|
string stoLocationOnBoard = string.Format("STO.LocationOnBoard_{0}", i + 1);
|
|
string stoOfficialUse = string.Format("STO.OfficialUse_{0}", i + 1);
|
|
|
|
if (!(stoMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is STO sto))
|
|
{
|
|
sto = new STO();
|
|
sto.Identifier = (i + 1).ToString();
|
|
sto.MessageHeader = stoMessage;
|
|
stoMessage.Elements.Add(sto);
|
|
}
|
|
|
|
sto.Name = reader.ReadTextNoWhitespace(stoName);
|
|
sto.Quantity = (int?)reader.ReadNumber(stoQuantity);
|
|
sto.QuantityUnit = reader.ReadTextNoWhitespace(stoQuantityUnit);
|
|
sto.LocationOnBoard = reader.ReadTextNoWhitespace(stoLocationOnBoard);
|
|
sto.OfficialUse = reader.ReadTextNoWhitespace(stoOfficialUse);
|
|
|
|
// dont save empty element
|
|
if (sto.IsNew && sto.Name.IsNullOrEmpty())
|
|
stoMessage.Elements.Remove(sto);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region LADG
|
|
|
|
private static bool ScanLADG(Message ladgMessage, ExcelReader reader)
|
|
{
|
|
ladgMessage.DeleteElements();
|
|
|
|
for (int i = 0; i < ladgMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string lnCHT = string.Format("LADG.CargoHandlingType_{0}", i + 1);
|
|
string lnType = string.Format("LADG.CargoType_{0}", i + 1);
|
|
string lnCNOI = string.Format("LADG.CargoNumberOfItems_{0}", i + 1);
|
|
string lnCGQ = string.Format("LADG.CargoGrossQuantity_TNE_{0}", i + 1);
|
|
string lnLoad = string.Format("LADG.CargoPortOfLoading_{0}", i + 1);
|
|
string lnDis = string.Format("LADG.CargoPortOfDischarge_{0}", i + 1);
|
|
string lnLACode = string.Format("LADG.CargoLACode_{0}", i + 1);
|
|
string lnZusatz = string.Format("LADG.CargoTypeZusatz_{0}", i + 1);
|
|
|
|
if (!(ladgMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is LADG ladg))
|
|
{
|
|
ladg = new LADG();
|
|
ladg.Identifier = (i + 1).ToString();
|
|
ladg.MessageHeader = ladgMessage;
|
|
ladgMessage.Elements.Add(ladg);
|
|
}
|
|
|
|
ladg.CargoHandlingType = reader.ReadCargoHandlingType(lnCHT);
|
|
|
|
// Transit-Ladung für DE nicht übernehmen!
|
|
if ((reader.Mode == ExcelReader.CountryMode.DE) && ((ladg.CargoHandlingType ?? 0) == 2))
|
|
{
|
|
ladgMessage.Elements.Remove(ladg);
|
|
continue;
|
|
}
|
|
|
|
ladg.CargoCodeNST = reader.ReadText(lnType);
|
|
// Cargo Type Freitext in DK
|
|
|
|
if (reader.Mode == ExcelReader.CountryMode.DE)
|
|
{
|
|
if (ladg.CargoCodeNST?.Length == 1)
|
|
ladg.CargoCodeNST = "0" + ladg.CargoCodeNST;
|
|
|
|
if ((ladg.CargoCodeNST != null) && (ladg.CargoCodeNST.Length != 2))
|
|
{
|
|
ladg.CargoCodeNST = null; // stupid validation
|
|
}
|
|
else
|
|
{
|
|
if(Int32.TryParse(ladg.CargoCodeNST, out int ccnst))
|
|
{
|
|
if ((ccnst <= 0) && (ccnst > 20))
|
|
{
|
|
ladg.CargoCodeNST = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ladg.CargoCodeNST = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
ladg.CargoLACode = reader.ReadCargoLACode(lnLACode);
|
|
|
|
ladg.CargoCodeNST_3 = reader.ReadText(lnZusatz);
|
|
if (!ladg.CargoCodeNST_3.IsNullOrEmpty())
|
|
{
|
|
if (ladg.CargoCodeNST_3.Length > 8)
|
|
{
|
|
ladg.CargoCodeNST_3 = ladg.CargoCodeNST_3.Substring(0, 8);
|
|
}
|
|
}
|
|
|
|
ladg.CargoNumberOfItems = (int?) reader.ReadNumber(lnCNOI);
|
|
ladg.CargoGrossQuantity_TNE = reader.ReadNumber(lnCGQ);
|
|
ladg.PortOfLoading = reader.ReadLoCode(lnLoad);
|
|
ladg.PortOfDischarge = reader.ReadLoCode(lnDis);
|
|
|
|
// dont save empty element
|
|
if (ladg.IsNew && !ladg.CargoHandlingType.HasValue)
|
|
ladgMessage.Elements.Remove(ladg);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CREW
|
|
|
|
private static bool ScanCREW(Message crewMessage, ExcelReader reader, bool isOldVersion)
|
|
{
|
|
crewMessage.DeleteElements();
|
|
|
|
bool? notificationSchengen = reader.ReadBoolean("CREW.NotificationSchengen");
|
|
bool? notificationPax = reader.ReadBoolean("CREW.NotificationPAX");
|
|
|
|
for (int i = 0; i < crewMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string crewLastName = string.Format("CREW.CrewMemberLastName_{0}", i + 1);
|
|
string crewFirstName = string.Format("CREW.CrewMemberFirstName_{0}", i + 1);
|
|
string crewGender = string.Format("CREW.CrewMemberGender_{0}", i + 1);
|
|
string crewNationality = string.Format("CREW.CrewMemberNationality_{0}", i + 1);
|
|
string crewDuty = string.Format("CREW.CrewMemberDuty_{0}", i + 1);
|
|
string crewPlaceOfBirth = string.Format("CREW.CrewMemberPlaceOfBirth_{0}", i + 1);
|
|
string crewDateOfBirth = string.Format("CREW.CrewMemberDateOfBirth_{0}", i + 1);
|
|
string crewIdentDocType = string.Format("CREW.CrewMemberIdentityDocumentType_{0}", i + 1);
|
|
string crewIdentDocId = string.Format("CREW.CrewMemberIdentityDocumentId_{0}", i + 1);
|
|
string crewVisaNo = string.Format("CREW.CrewMemberVisaNumber_{0}", i + 1);
|
|
string crewIssuing = string.Format("CREW.CrewMemberIdentityDocumentIssuingState_{0}", i + 1);
|
|
string crewIdentDocExpiry = string.Format("CREW.CrewmemberIdentityDocumentExpiryDate_{0}", i + 1);
|
|
string crewCountryOfBirth = string.Format("CREW.CountryOfBirth_{0}", i + 1);
|
|
string crewEffects = string.Format("CREW.Effects_{0}", i + 1);
|
|
|
|
string lastName = reader.ReadText(crewLastName);
|
|
string firstName = reader.ReadText(crewFirstName);
|
|
|
|
if (!lastName.IsNullOrEmpty() || !firstName.IsNullOrEmpty())
|
|
{
|
|
if (!(crewMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is CREW crew))
|
|
{
|
|
crew = new CREW();
|
|
crew.Identifier = (i + 1).ToString();
|
|
crew.MessageHeader = crewMessage;
|
|
crewMessage.Elements.Add(crew);
|
|
}
|
|
|
|
crew.NotificationSchengen = notificationSchengen;
|
|
crew.NotificationPAX = notificationPax;
|
|
crew.CrewMemberLastName = lastName;
|
|
crew.CrewMemberFirstName = firstName;
|
|
crew.CrewMemberGender = reader.ReadGender(crewGender);
|
|
crew.CrewMemberDuty = reader.ReadText(crewDuty);
|
|
crew.CrewMemberNationality = reader.ReadNationality(crewNationality);
|
|
crew.CrewMemberPlaceOfBirth = reader.ReadText(crewPlaceOfBirth);
|
|
crew.CrewMemberDateOfBirth = reader.ReadBirthDate(crewDateOfBirth);
|
|
crew.CrewMemberIdentityDocumentType = reader.ReadIdentityDocumentType(crewIdentDocType);
|
|
crew.CrewMemberIdentityDocumentId = reader.ReadText(crewIdentDocId);
|
|
crew.CrewMemberVisaNumber = reader.ReadText(crewVisaNo);
|
|
crew.CrewMemberIdentityDocumentIssuingState = reader.ReadNationality(crewIssuing);
|
|
if (crew.CrewMemberIdentityDocumentIssuingState.IsNullOrEmpty() && isOldVersion)
|
|
crew.CrewMemberIdentityDocumentIssuingState = "XX";
|
|
crew.CrewMemberIdentityDocumentExpiryDate = reader.ReadDate(crewIdentDocExpiry);
|
|
if (!crew.CrewMemberIdentityDocumentExpiryDate.HasValue && isOldVersion)
|
|
crew.CrewMemberIdentityDocumentExpiryDate = new DateTime(2100, 12, 31);
|
|
crew.CrewMemberCountryOfBirth = reader.ReadNationality(crewCountryOfBirth);
|
|
crew.Effects = reader.ReadText(crewEffects);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static bool ScanCREWD(Message crewdMessage, ExcelReader reader)
|
|
{
|
|
crewdMessage.DeleteElements();
|
|
// CREW DEPARTURE
|
|
|
|
bool? notificationSchengen = reader.ReadBoolean("CREWD.NotificationSchengen");
|
|
bool? notificationPax = reader.ReadBoolean("CREWD.NotificationPAX");
|
|
|
|
for (int i = 0; i < crewdMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string crewLastName = string.Format("CREWD.CrewMemberLastName_{0}", i + 1);
|
|
string crewFirstName = string.Format("CREWD.CrewMemberFirstName_{0}", i + 1);
|
|
string crewGender = string.Format("CREWD.CrewMemberGender_{0}", i + 1);
|
|
string crewNationality = string.Format("CREWD.CrewMemberNationality_{0}", i + 1);
|
|
string crewDuty = string.Format("CREWD.CrewMemberDuty_{0}", i + 1);
|
|
string crewPlaceOfBirth = string.Format("CREWD.CrewMemberPlaceOfBirth_{0}", i + 1);
|
|
string crewDateOfBirth = string.Format("CREWD.CrewMemberDateOfBirth_{0}", i + 1);
|
|
string crewIdentDocType = string.Format("CREWD.CrewMemberIdentityDocumentType_{0}", i + 1);
|
|
string crewIdentDocId = string.Format("CREWD.CrewMemberIdentityDocumentId_{0}", i + 1);
|
|
string crewVisaNo = string.Format("CREWD.CrewMemberVisaNumber_{0}", i + 1);
|
|
string crewIssuing = string.Format("CREWD.CrewMemberIdentityDocumentIssuingState_{0}", i + 1);
|
|
string crewIdentDocExpiry = string.Format("CREWD.CrewmemberIdentityDocumentExpiryDate_{0}", i + 1);
|
|
string crewCountryOfBirth = string.Format("CREWD.CountryOfBirth_{0}", i + 1);
|
|
|
|
string lastName = reader.ReadText(crewLastName);
|
|
if (!lastName.IsNullOrEmpty())
|
|
{
|
|
if (!(crewdMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is CREWD crew))
|
|
{
|
|
crew = new CREWD();
|
|
crew.IsDeparture = true;
|
|
crew.Identifier = (i + 1).ToString();
|
|
crew.MessageHeader = crewdMessage;
|
|
crewdMessage.Elements.Add(crew);
|
|
}
|
|
|
|
crew.IsDeparture = true;
|
|
crew.NotificationSchengen = notificationSchengen;
|
|
crew.NotificationPAX = notificationPax;
|
|
crew.CrewMemberLastName = lastName;
|
|
crew.CrewMemberFirstName = reader.ReadText(crewFirstName);
|
|
crew.CrewMemberGender = reader.ReadGender(crewGender);
|
|
crew.CrewMemberDuty = reader.ReadText(crewDuty);
|
|
crew.CrewMemberNationality = reader.ReadNationality(crewNationality);
|
|
crew.CrewMemberPlaceOfBirth = reader.ReadText(crewPlaceOfBirth);
|
|
crew.CrewMemberDateOfBirth = reader.ReadBirthDate(crewDateOfBirth);
|
|
crew.CrewMemberIdentityDocumentType = reader.ReadIdentityDocumentType(crewIdentDocType);
|
|
crew.CrewMemberIdentityDocumentId = reader.ReadText(crewIdentDocId);
|
|
crew.CrewMemberVisaNumber = reader.ReadText(crewVisaNo);
|
|
crew.CrewMemberIdentityDocumentIssuingState = reader.ReadNationality(crewIssuing);
|
|
crew.CrewMemberIdentityDocumentExpiryDate = reader.ReadDate(crewIdentDocExpiry);
|
|
crew.CrewMemberCountryOfBirth = reader.ReadNationality(crewCountryOfBirth);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PAS
|
|
|
|
private static bool ScanPAS(Message pasMessage, ExcelReader reader, bool isOldVersion)
|
|
{
|
|
pasMessage.DeleteElements();
|
|
|
|
bool? notificationSchengen = reader.ReadBoolean("PAS.NotificationSchengen");
|
|
bool? notificationPax = reader.ReadBoolean("PAS.NotificationPAX");
|
|
|
|
for (int i = 0; i < pasMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string pasLastName = string.Format("PAS.PassengerLastName_{0}", i + 1);
|
|
string pasFirstName = string.Format("PAS.PassengerFirstName_{0}", i + 1);
|
|
string pasGender = string.Format("PAS.PassengerGender_{0}", i + 1);
|
|
string pasNationality = string.Format("PAS.PassengerNationality_{0}", i + 1);
|
|
string pasEmbarkation = string.Format("PAS.PassengerPortOfEmbarkation_{0}", i + 1);
|
|
string pasDebarkation = string.Format("PAS.PassengerPortOfDisembarkation_{0}", i + 1);
|
|
string pasTransit = string.Format("PAS.PassengerInTransit_{0}", i + 1);
|
|
string pasPlaceOfBirth = string.Format("PAS.PassengerPlaceOfBirth_{0}", i + 1);
|
|
string pasDateOfBirth = string.Format("PAS.PassengerDateOfBirth_{0}", i + 1);
|
|
string pasIdentDocType = string.Format("PAS.PassengerIdentityDocumentType_{0}", i + 1);
|
|
string pasIdentDocId = string.Format("PAS.PassengerIdentityDocumentId_{0}", i + 1);
|
|
string pasVisaNo = string.Format("PAS.PassengerVisaNumber_{0}", i + 1);
|
|
string pasIssuing = string.Format("PAS.PassengerIdentityDocumentIssuingState_{0}", i + 1);
|
|
string pasExpiryDate = string.Format("PAS.PassengerIdentityDocumentExpiryDate_{0}", i + 1);
|
|
string pasCountryOfBirth = string.Format("PAS.CountryOfBirth_{0}", i + 1);
|
|
string pasEmergencyCare = string.Format("PAS.EmergencyCare_{0}", i + 1);
|
|
string pasEmergencyContact = string.Format("PAS.EmergencyContactNumber_{0}", i + 1);
|
|
|
|
string lastName = reader.ReadText(pasLastName);
|
|
string firstName = reader.ReadText(pasFirstName);
|
|
|
|
if (!lastName.IsNullOrEmpty() || !firstName.IsNullOrEmpty())
|
|
{
|
|
if (!(pasMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is PAS pas))
|
|
{
|
|
pas = new PAS();
|
|
pas.Identifier = (i + 1).ToString();
|
|
pas.MessageHeader = pasMessage;
|
|
pasMessage.Elements.Add(pas);
|
|
}
|
|
|
|
pas.NotificationSchengen = notificationSchengen;
|
|
pas.NotificationPAX = notificationPax;
|
|
pas.PassengerLastName = lastName;
|
|
pas.PassengerFirstName = firstName;
|
|
pas.PassengerGender = reader.ReadGender(pasGender);
|
|
pas.PassengerNationality = reader.ReadNationality(pasNationality);
|
|
// TODO: Nicht klar ob hier LOCODEs kommen oder nicht
|
|
pas.PassengerPortOfEmbarkation = reader.ReadLoCode(pasEmbarkation);
|
|
pas.PassengerPortOfDisembarkation = reader.ReadLoCode(pasDebarkation);
|
|
pas.PassengerInTransit = reader.ReadBoolean(pasTransit);
|
|
pas.PassengerPlaceOfBirth = reader.ReadText(pasPlaceOfBirth);
|
|
pas.PassengerDateOfBirth = reader.ReadBirthDate(pasDateOfBirth);
|
|
pas.PassengerIdentityDocumentType = reader.ReadIdentityDocumentType(pasIdentDocType);
|
|
pas.PassengerIdentityDocumentId = reader.ReadText(pasIdentDocId);
|
|
pas.PassengerVisaNumber = reader.ReadText(pasVisaNo);
|
|
pas.PassengerIdentityDocumentIssuingState = reader.ReadNationality(pasIssuing);
|
|
if (pas.PassengerIdentityDocumentIssuingState.IsNullOrEmpty() && isOldVersion)
|
|
pas.PassengerIdentityDocumentIssuingState = "XX";
|
|
pas.PassengerIdentityDocumentExpiryDate = reader.ReadDate(pasExpiryDate);
|
|
if (!pas.PassengerIdentityDocumentExpiryDate.HasValue && isOldVersion)
|
|
pas.PassengerIdentityDocumentExpiryDate = new DateTime(2100, 12, 31);
|
|
pas.PassengerCountryOfBirth = reader.ReadNationality(pasCountryOfBirth);
|
|
pas.EmergencyCare = reader.ReadText(pasEmergencyCare);
|
|
pas.EmergencyContactNumber = reader.ReadText(pasEmergencyContact);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PASD
|
|
|
|
private static bool ScanPASD(Message pasMessage, ExcelReader reader)
|
|
{
|
|
pasMessage.DeleteElements();
|
|
|
|
bool? notificationSchengen = reader.ReadBoolean("PASD.NotificationSchengen");
|
|
bool? notificationPax = reader.ReadBoolean("PASD.NotificationPAX");
|
|
|
|
for (int i = 0; i < pasMessage.NumberOfExcelRows; i++)
|
|
{
|
|
string pasLastName = string.Format("PASD.PassengerLastName_{0}", i + 1);
|
|
string pasFirstName = string.Format("PASD.PassengerFirstName_{0}", i + 1);
|
|
string pasGender = string.Format("PASD.PassengerGender_{0}", i + 1);
|
|
string pasNationality = string.Format("PASD.PassengerNationality_{0}", i + 1);
|
|
string pasEmbarkation = string.Format("PASD.PassengerPortOfEmbarkation_{0}", i + 1);
|
|
string pasDebarkation = string.Format("PASD.PassengerPortOfDisembarkation_{0}", i + 1);
|
|
string pasTransit = string.Format("PASD.PassengerInTransit_{0}", i + 1);
|
|
string pasPlaceOfBirth = string.Format("PASD.PassengerPlaceOfBirth_{0}", i + 1);
|
|
string pasDateOfBirth = string.Format("PASD.PassengerDateOfBirth_{0}", i + 1);
|
|
string pasIdentDocType = string.Format("PASD.PassengerIdentityDocumentType_{0}", i + 1);
|
|
string pasIdentDocId = string.Format("PASD.PassengerIdentityDocumentId_{0}", i + 1);
|
|
string pasVisaNo = string.Format("PASD.PassengerVisaNumber_{0}", i + 1);
|
|
string pasIssuing = string.Format("PASD.PassengerIdentityDocumentIssuingState_{0}", i + 1);
|
|
string pasExpiryDate = string.Format("PASD.PassengerIdentityDocumentExpiryDate_{0}", i + 1);
|
|
string pasCountryOfBirth = string.Format("PASD.CountryOfBirth_{0}", i + 1);
|
|
string pasEmergencyCare = string.Format("PASD.EmergencyCare_{0}", i + 1);
|
|
string pasEmergencyContact = string.Format("PASD.EmergencyContactNumber_{0}", i + 1);
|
|
|
|
string lastName = reader.ReadText(pasLastName);
|
|
if (!lastName.IsNullOrEmpty())
|
|
{
|
|
if (!(pasMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is PASD pas))
|
|
{
|
|
pas = new PASD();
|
|
pas.IsDeparture = true;
|
|
pas.Identifier = (i + 1).ToString();
|
|
pas.MessageHeader = pasMessage;
|
|
pasMessage.Elements.Add(pas);
|
|
}
|
|
|
|
pas.IsDeparture = true;
|
|
pas.NotificationSchengen = notificationSchengen;
|
|
pas.NotificationPAX = notificationPax;
|
|
pas.PassengerLastName = lastName;
|
|
pas.PassengerFirstName = reader.ReadText(pasFirstName);
|
|
pas.PassengerGender = reader.ReadGender(pasGender);
|
|
pas.PassengerNationality = reader.ReadNationality(pasNationality);
|
|
// TODO: Nicht klar ob hier LOCODEs kommen oder nicht
|
|
pas.PassengerPortOfEmbarkation = reader.ReadTextNoWhitespace(pasEmbarkation);
|
|
pas.PassengerPortOfDisembarkation = reader.ReadTextNoWhitespace(pasDebarkation);
|
|
pas.PassengerInTransit = reader.ReadBoolean(pasTransit);
|
|
pas.PassengerPlaceOfBirth = reader.ReadText(pasPlaceOfBirth);
|
|
pas.PassengerDateOfBirth = reader.ReadBirthDate(pasDateOfBirth);
|
|
pas.PassengerIdentityDocumentType = reader.ReadIdentityDocumentType(pasIdentDocType);
|
|
pas.PassengerIdentityDocumentId = reader.ReadText(pasIdentDocId);
|
|
pas.PassengerVisaNumber = reader.ReadText(pasVisaNo);
|
|
pas.PassengerIdentityDocumentIssuingState = reader.ReadNationality(pasIssuing);
|
|
pas.PassengerIdentityDocumentExpiryDate = reader.ReadDate(pasExpiryDate);
|
|
pas.PassengerCountryOfBirth = reader.ReadNationality(pasCountryOfBirth);
|
|
pas.EmergencyCare = reader.ReadText(pasEmergencyCare);
|
|
pas.EmergencyContactNumber = reader.ReadText(pasEmergencyContact);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ScanMessage (generic)
|
|
|
|
private static void ScanMessage(DatabaseEntity dbEntity, ExcelReader reader)
|
|
{
|
|
Type objType = dbEntity.GetType();
|
|
List<PropertyInfo> props = new List<PropertyInfo>();
|
|
|
|
// add lookup properties to scan list
|
|
props.AddRange(objType.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(LookupNameAttribute))));
|
|
|
|
foreach (PropertyInfo property in props)
|
|
{
|
|
object propValue = property.GetValue(dbEntity, null);
|
|
string value = (propValue == null) ? string.Empty : propValue.ToString();
|
|
LookupNameAttribute lookupNameAttribute = Attribute.GetCustomAttribute(property, typeof(LookupNameAttribute)) as LookupNameAttribute;
|
|
|
|
if (property.PropertyType == typeof(DateTime?))
|
|
{
|
|
DateTime? sheetValue = reader.ReadDate(lookupNameAttribute.LookupName);
|
|
if (sheetValue != null)
|
|
{
|
|
property.SetValue(dbEntity, sheetValue);
|
|
}
|
|
}
|
|
else if (property.PropertyType == typeof(double?))
|
|
{
|
|
double? sheetValue = reader.ReadNumber(lookupNameAttribute.LookupName);
|
|
if (sheetValue != null)
|
|
{
|
|
property.SetValue(dbEntity, sheetValue);
|
|
}
|
|
}
|
|
else if (property.PropertyType == typeof(string))
|
|
{
|
|
string sheetValue = reader.ReadText(lookupNameAttribute.LookupName);
|
|
if (sheetValue != null)
|
|
{
|
|
property.SetValue(dbEntity, sheetValue);
|
|
}
|
|
}
|
|
else if (property.PropertyType == typeof(int?))
|
|
{
|
|
double? sheetValue = reader.ReadNumber(lookupNameAttribute.LookupName);
|
|
if (sheetValue.HasValue)
|
|
{
|
|
property.SetValue(dbEntity, (int)sheetValue.Value);
|
|
}
|
|
}
|
|
else if (property.PropertyType == typeof(byte?))
|
|
{
|
|
double? sheetValue = reader.ReadNumber(lookupNameAttribute.LookupName);
|
|
if (sheetValue.HasValue)
|
|
{
|
|
property.SetValue(dbEntity, (byte)sheetValue.Value);
|
|
}
|
|
}
|
|
else if (property.PropertyType == typeof(Boolean?))
|
|
{
|
|
bool? sheetValue = reader.ReadBoolean(lookupNameAttribute.LookupName);
|
|
string boolStringValue = reader.ReadText(lookupNameAttribute.LookupName);
|
|
if (sheetValue.HasValue) {
|
|
property.SetValue(dbEntity, sheetValue);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_log.DebugFormat("unhandled property type: {0}", property.PropertyType);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region LookupMessageCore
|
|
|
|
/// <summary>
|
|
/// try to get the MessageCore from the open sheet by id
|
|
/// </summary>
|
|
/// <param name="reader"></param>
|
|
/// <returns></returns>
|
|
private static MessageCore LookupCoreById(ExcelReader reader)
|
|
{
|
|
MessageCore result = null;
|
|
string visitTransitId = reader.ReadTextNoWhitespace("ID");
|
|
|
|
if (visitTransitId != null)
|
|
{
|
|
if (bsmd.database.Util.IsVisitId(visitTransitId))
|
|
{
|
|
result = DBManager.Instance.GetMessageCoreByVisitId(visitTransitId);
|
|
}
|
|
else if (bsmd.database.Util.IsTransitId(visitTransitId))
|
|
{
|
|
result = DBManager.Instance.GetMessageCoreByTransitId(visitTransitId);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetMessageWithType
|
|
|
|
private static Message GetMessageWithType(List<Message> messages, MessageCore core, Message.NotificationClass type)
|
|
{
|
|
foreach(Message message in messages)
|
|
if (message.MessageNotificationClass == type) return message;
|
|
|
|
Message newMessage = DBManager.Instance.GetMessage(core, type);
|
|
if (newMessage == null)
|
|
{
|
|
newMessage = new Message();
|
|
newMessage.MessageNotificationClass = type;
|
|
messages.Add(newMessage);
|
|
newMessage.MessageCore = core;
|
|
newMessage.MessageCoreId = core.Id;
|
|
}
|
|
return newMessage;
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|