1663 lines
122 KiB
C#
1663 lines
122 KiB
C#
//
|
|
// Class: Util
|
|
// Current CLR: 4.0.30319.34209
|
|
// System: Microsoft Visual Studio 10.0
|
|
// Author: dani
|
|
// Created: 4/13/2015 10:42:13 PM
|
|
//
|
|
// Copyright (c) 2015 Informatikbüro Daniel Schick. All rights reserved.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Text.RegularExpressions;
|
|
using log4net;
|
|
|
|
using bsmd.database;
|
|
|
|
namespace bsmd.herberg.FormService
|
|
{
|
|
public static class Util
|
|
{
|
|
private static ILog _log = LogManager.GetLogger(typeof(Util));
|
|
|
|
internal static void UpdateFormCore(MessageCore aMessageCore, WebReference.GetFormDataResponseData formResponse)
|
|
{
|
|
RuleEngine ruleEngine = new RuleEngine(); // das brauchen wir noch weiter unten..
|
|
ReportingParty bsmdParty = null;
|
|
Dictionary<Guid, ReportingParty> repDict = DBManager.Instance.GetReportingPartyDict();
|
|
foreach (Guid key in repDict.Keys)
|
|
{
|
|
if (repDict[key].Name.Equals("BSMD"))
|
|
{
|
|
bsmdParty = repDict[key];
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool isDeparture = false;
|
|
|
|
//for (int i = 0; i < formResponse.formDatasets.Length; i++)
|
|
if(formResponse.formDatasets.Length > 0) // wir verarbeiten nur das "neueste" form dataset
|
|
{
|
|
|
|
int i = formResponse.formDatasets.Length - 1;
|
|
|
|
// nur zum debuggen
|
|
for (int n = 0; n < formResponse.formDatasets[i].formData.Length; n++)
|
|
{
|
|
if (formResponse.formDatasets[i].formData[n].name.Contains("Transmission"))
|
|
{
|
|
_log.Info("foundit");
|
|
}
|
|
}
|
|
|
|
// Daten werden nur aktualisiert, wenn die form ein anderes (=neueres) Rev. Date hat
|
|
if (aMessageCore.HerbergRevDate.HasValue && (formResponse.formDatasets[i].revisionDate == aMessageCore.HerbergRevDate.Value))
|
|
return;
|
|
|
|
if (aMessageCore.ReportStatus != MessageCore.ReportStatusEnum.COMPLETE)
|
|
aMessageCore.ReportStatus = MessageCore.ReportStatusEnum.HE_REVISION;
|
|
|
|
aMessageCore.HerbergRevDate = formResponse.formDatasets[i].revisionDate;
|
|
|
|
Dictionary<string, Dictionary<string, string>> groupedVals = new Dictionary<string, Dictionary<string, string>>();
|
|
Dictionary<string, Dictionary<int, Dictionary<string, string>>> groupedRowVals = new Dictionary<string, Dictionary<int, Dictionary<string, string>>>();
|
|
|
|
WebReference.FormDataset fds = formResponse.formDatasets[i];
|
|
_log.InfoFormat("proc. dataset with Rev.Date:{0}", fds.revisionDate);
|
|
|
|
foreach (WebReference.FormData formData in fds.formData)
|
|
{
|
|
string[] nElems = formData.name.Split('.');
|
|
string keyString = null;
|
|
string valString = null;
|
|
|
|
if (nElems.Length == 1)
|
|
{
|
|
switch (nElems[0])
|
|
{
|
|
case "REGISTRATION_TYPE":
|
|
_log.InfoFormat("REGISTRATION_TYPE: {0}", formData.value);
|
|
break;
|
|
case "REPORT_TYPE":
|
|
|
|
if ((aMessageCore.HerbergReportType != formData.value) &&
|
|
(aMessageCore.ReportStatus != MessageCore.ReportStatusEnum.COMPLETE))
|
|
aMessageCore.ReportStatus = MessageCore.ReportStatusEnum.HE_REPORTTYPE; // neuer Report-Type!
|
|
|
|
aMessageCore.HerbergReportType = formData.value;
|
|
if (aMessageCore.HerbergReportType.Equals("Pre-Departure Notification Update") ||
|
|
aMessageCore.HerbergReportType.Equals("Departure Notification Update"))
|
|
isDeparture = true;
|
|
|
|
aMessageCore.Incoming = !isDeparture;
|
|
|
|
break;
|
|
case "EmailContactReportingVessel":
|
|
aMessageCore.HerbergEmailContactReportingVessel = formData.value;
|
|
break;
|
|
case "Email24HrsContact":
|
|
aMessageCore.HerbergEmail24HrsContact = formData.value;
|
|
break;
|
|
default:
|
|
_log.WarnFormat("unhandled single parameter {0}", nElems[0]);
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
else if (nElems.Length == 2)
|
|
{
|
|
keyString = nElems[0];
|
|
valString = nElems[1];
|
|
}
|
|
else if (nElems.Length == 3)
|
|
{
|
|
// haza sublists
|
|
keyString = string.Format("{0}.{1}", nElems[0], nElems[1]);
|
|
valString = nElems[2];
|
|
}
|
|
else
|
|
{
|
|
_log.WarnFormat("Field name {0} has wrong format!", formData.name);
|
|
continue;
|
|
}
|
|
|
|
// create dictionaries on demand
|
|
if (!groupedVals.ContainsKey(keyString))
|
|
groupedVals[keyString] = new Dictionary<string, string>();
|
|
if (!groupedRowVals.ContainsKey(keyString))
|
|
groupedRowVals[keyString] = new Dictionary<int, Dictionary<string, string>>();
|
|
if (!groupedRowVals[keyString].ContainsKey(formData.rowNo))
|
|
groupedRowVals[keyString][formData.rowNo] = new Dictionary<string, string>();
|
|
|
|
if (formData.rowNoSpecified == false)
|
|
{
|
|
// "normale" Felder werden pro Nachrichtentyp in einem Dict abgespeichert
|
|
|
|
groupedVals[keyString][valString] = formData.value;
|
|
}
|
|
else
|
|
{
|
|
// "1:n" Felder (mit Zeilennummer) werden in einem Dict<Dict .. abgespeichert. Erster
|
|
// Schlüssel ist die Row-Id, damit Datensätze aus derselben Zeile zusammenfinden
|
|
|
|
groupedRowVals[keyString][formData.rowNo][valString] = formData.value;
|
|
}
|
|
}
|
|
|
|
// jetzt können wir die Felder nach Nachrichtentyp abarbeiten
|
|
Dictionary<string, Message> messages = Util.PrepareMessageDict(aMessageCore);
|
|
|
|
List<DatabaseEntity> saveMessages = new List<DatabaseEntity>(); // 1:n messages
|
|
|
|
foreach (string groupMessageType in groupedVals.Keys)
|
|
{
|
|
string messageType = groupMessageType;
|
|
|
|
Dictionary<string, string> vDict = groupedVals[groupMessageType];
|
|
Dictionary<int, Dictionary<string, string>> nDict = groupedRowVals[groupMessageType];
|
|
|
|
DatabaseEntity derivedMessage = null;
|
|
saveMessages.Clear();
|
|
|
|
if (messageType.Equals("HAZ"))
|
|
messageType = isDeparture ? "HAZD" : "HAZA";
|
|
|
|
Message theMessage = null;
|
|
if (!messages.ContainsKey(messageType.ToUpper()))
|
|
{
|
|
theMessage = new Message();
|
|
if (messageType.Equals("Agency"))
|
|
{
|
|
if (aMessageCore.Customer == null) aMessageCore.Customer = new Customer();
|
|
|
|
if (vDict.ContainsKey("Name")) aMessageCore.Customer.Name = vDict["Name"];
|
|
if (vDict.ContainsKey("Phone")) aMessageCore.Customer.Phone = vDict["Phone"];
|
|
if (vDict.ContainsKey("Email")) aMessageCore.Customer.Email = vDict["Email"];
|
|
if (vDict.ContainsKey("ContactFirstName")) aMessageCore.Customer.ContactFirstName = vDict["ContactFirstName"];
|
|
if (vDict.ContainsKey("ContactLastName")) aMessageCore.Customer.ContactLastName = vDict["ContactLastName"];
|
|
|
|
continue; // das Zeug verhält sich wie eine Not. Class
|
|
}
|
|
|
|
if (messageType.Contains(".")) // eine subliste
|
|
continue;
|
|
|
|
theMessage.MessageNotificationClass = (Message.NotificationClass)Enum.Parse(typeof(Message.NotificationClass), messageType, true);
|
|
|
|
theMessage.MessageCoreId = aMessageCore.Id;
|
|
theMessage.MessageCore = aMessageCore;
|
|
if (bsmdParty != null)
|
|
theMessage.ReportingParty = bsmdParty;
|
|
}
|
|
else
|
|
{
|
|
_log.DebugFormat("found message type {0}", messageType);
|
|
theMessage = messages[messageType.ToUpper()];
|
|
}
|
|
|
|
switch (groupMessageType)
|
|
{
|
|
#region ATA
|
|
case "ATA":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
ATA newATA = new ATA();
|
|
newATA.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.ATA;
|
|
theMessage.Elements.Add(newATA);
|
|
}
|
|
ATA ata = theMessage.Elements[0] as ATA;
|
|
derivedMessage = ata;
|
|
if (ata != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("ATAPortOfCall")) ata.ATAPortOfCall = Extensions.TryParseDateTime(vDict["ATAPortOfCall"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading ATA fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region ATD
|
|
case "ATD":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
ATD newATD = new ATD();
|
|
newATD.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.ATD;
|
|
theMessage.Elements.Add(newATD);
|
|
}
|
|
ATD atd = theMessage.Elements[0] as ATD;
|
|
derivedMessage = atd;
|
|
if (atd != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("ATDPortOfCall")) atd.ATDPortOfCall = Extensions.TryParseDateTime(vDict["ATDPortOfCall"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading ATD fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region NAME
|
|
case "NAME":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
NAME newName = new NAME();
|
|
newName.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.NAME;
|
|
theMessage.Elements.Add(newName);
|
|
}
|
|
NAME name = theMessage.Elements[0] as NAME;
|
|
derivedMessage = name;
|
|
if (name != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("NameOfMaster")) name.NameOfMaster = vDict["NameOfMaster"];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading NAME fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region NOA_NOD
|
|
case "NOA_NOD":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
NOA_NOD newNOA_NOD = new NOA_NOD();
|
|
newNOA_NOD.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.NOA_NOD;
|
|
theMessage.Elements.Add(newNOA_NOD);
|
|
}
|
|
NOA_NOD noa_nod = theMessage.Elements[0] as NOA_NOD;
|
|
derivedMessage = noa_nod;
|
|
if (noa_nod != null)
|
|
{
|
|
try
|
|
{
|
|
// if (vDict.ContainsKey("CallPurposeCode")) noa_nod.CallPurposeCode = Int32.Parse(vDict["CallPurposeCode"]);
|
|
if (vDict.ContainsKey("ETAToNextPort")) noa_nod.ETAToNextPort = Extensions.TryParseDateTime(vDict["ETAToNextPort"]);
|
|
if (vDict.ContainsKey("ETDFromLastPort")) noa_nod.ETDFromLastPort = Extensions.TryParseDateTime(vDict["ETDFromLastPort"]);
|
|
if (vDict.ContainsKey("ETAToPortOfCall")) noa_nod.ETAToPortOfCall = Extensions.TryParseDateTime(vDict["ETAToPortOfCall"]);
|
|
if (vDict.ContainsKey("ETDFromPortOfCall")) noa_nod.ETDFromPortOfCall = Extensions.TryParseDateTime(vDict["ETDFromPortOfCall"]);
|
|
// if (vDict.ContainsKey("CallPurposeDescription")) noa_nod.CallPurposeDescription = vDict["CallPurposeDescription"];
|
|
// if(vDict.ContainsKey("CountryOfNextPort")) noa_nod. nicht relevant
|
|
if (vDict.ContainsKey("ETAToKielCanal")) noa_nod.ETAToKielCanal = Extensions.TryParseDateTime(vDict["ETAToKielCanal"]);
|
|
if (vDict.ContainsKey("ETDFromKielCanal")) noa_nod.ETDFromKielCanal = Extensions.TryParseDateTime(vDict["ETDFromKielCanal"]);
|
|
if (vDict.ContainsKey("CountryCodeOfLastPort") && vDict.ContainsKey("LastPortCode"))
|
|
noa_nod.LastPort = vDict["CountryCodeOfLastPort"] + vDict["LastPortCode"];
|
|
if (vDict.ContainsKey("CountryCodeOfNextPort") && vDict.ContainsKey("NextPortCode"))
|
|
noa_nod.NextPort = vDict["CountryCodeOfNextPort"] + vDict["NextPortCode"];
|
|
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> subvDict = nDict[key];
|
|
if (subvDict.Count > 0)
|
|
{
|
|
CallPurpose cp = noa_nod.GetSublistElementWithIdentifier(key.ToString()) as CallPurpose;
|
|
if (cp == null)
|
|
{
|
|
cp = new CallPurpose();
|
|
cp.Identifier = key.ToString();
|
|
cp.NOA_NOD = noa_nod;
|
|
noa_nod.CallPurposes.Add(cp);
|
|
}
|
|
|
|
if (subvDict.ContainsKey("CallPurposeCode")) cp.CallPurposeCode = Int32.Parse(subvDict["CallPurposeCode"]);
|
|
if (subvDict.ContainsKey("CallPurposeDescription")) cp.CallPurposeDescription = subvDict["CallPurposeDescription"];
|
|
|
|
saveMessages.Add(cp);
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading NOA_NOD fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region STAT
|
|
case "STAT":
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
STAT newStat = new STAT();
|
|
newStat.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.STAT;
|
|
theMessage.Elements.Add(newStat);
|
|
}
|
|
STAT stat = theMessage.Elements[0] as STAT;
|
|
derivedMessage = stat;
|
|
if (stat != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("ShipName")) stat.ShipName = vDict["ShipName"];
|
|
if (vDict.ContainsKey("CallSign")) stat.CallSign = vDict["CallSign"];
|
|
if (vDict.ContainsKey("MMSINumber")) stat.MMSINumber = vDict["MMSINumber"];
|
|
if (vDict.ContainsKey("Flag")) stat.Flag = vDict["Flag"];
|
|
if (vDict.ContainsKey("ShipType")) stat.ShipType = vDict["ShipType"];
|
|
if (vDict.ContainsKey("LengthOverall_MTR")) stat.LengthOverall_MTR = Extensions.TryParseDouble(vDict["LengthOverall_MTR"]);
|
|
if (vDict.ContainsKey("Beam_MTR")) stat.Beam_MTR = Extensions.TryParseDouble(vDict["Beam_MTR"]);
|
|
if (vDict.ContainsKey("GrossTonnage")) stat.GrossTonnage = Int32.Parse(vDict["GrossTonnage"]);
|
|
// if (vDict.ContainsKey("PortNameOfRegistry")) stat.PortOfRegistry = vDict["PortNameOfRegistry"]; // existiert nicht
|
|
if (vDict.ContainsKey("InmarsatCallNumber")) stat.InmarsatCallNumber = vDict["InmarsatCallNumber"];
|
|
// if(vDict.ContainsKey("CountryOfRegistry")) stat.r // existiert nicht in spec
|
|
if (vDict.ContainsKey("PortCodeOfRegistry") && vDict.ContainsKey("CountryCodeOfRegistry"))
|
|
stat.PortOfRegistry = vDict["CountryCodeOfRegistry"] + vDict["PortCodeOfRegistry"];
|
|
if (vDict.ContainsKey("ShipTypeCode")) stat.ShipType = vDict["ShipTypeCode"];
|
|
if (vDict.ContainsKey("ISMCompanyName")) stat.ISMCompanyName = vDict["ISMCompanyName"];
|
|
if (vDict.ContainsKey("ISMCompanyId")) stat.ISMCompanyId = vDict["ISMCompanyId"];
|
|
if (vDict.ContainsKey("ISMCompanyStreetAndNumber")) stat.ISMCompanyStreetAndNumber = vDict["ISMCompanyStreetAndNumber"];
|
|
if (vDict.ContainsKey("ISMCompanyPostalCode")) stat.ISMCompanyPostalCode = vDict["ISMCompanyPostalCode"];
|
|
if (vDict.ContainsKey("ISMCompanyCity")) stat.ISMCompanyCity = vDict["ISMCompanyCity"];
|
|
if (vDict.ContainsKey("ISMCompanyCountry")) stat.ISMCompanyCountry = vDict["ISMCompanyCountry"];
|
|
if (stat.Flag.IsNullOrEmpty() && vDict.ContainsKey("CountryCodeOfRegistry"))
|
|
stat.Flag = vDict["CountryCodeOfRegistry"];
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading STAT fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region MDH
|
|
case "MDH":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
MDH newMDH = new MDH();
|
|
newMDH.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.MDH;
|
|
theMessage.Elements.Add(newMDH);
|
|
}
|
|
MDH mdh = theMessage.Elements[0] as MDH;
|
|
derivedMessage = mdh;
|
|
if (mdh != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("Simplification")) mdh.MDHSimplification = vDict["Simplification"].Equals("Y");
|
|
if (vDict.ContainsKey("PortOfCallWhereCompleteMDHNotified")) mdh.PortOfCallWhereCompleteMDHNotified = vDict["PortOfCallWhereCompleteMDHNotified"];
|
|
if (vDict.ContainsKey("NonAccidentialDeathsDuringVoyage")) mdh.NonAccidentalDeathsDuringVoyage = vDict["NonAccidentialDeathsDuringVoyage"].Equals("Y");
|
|
if (vDict.ContainsKey("NonAccidentialDeathsDuringVoyageCount")) mdh.NonAccidentalDeathsDuringVoyageCount = Int32.Parse(vDict["NonAccidentialDeathsDuringVoyageCount"]);
|
|
if (vDict.ContainsKey("SuspisionInfectiousNature")) mdh.SuspisionInfectiousNature = vDict["SuspisionInfectiousNature"].Equals("Y");
|
|
if (vDict.ContainsKey("NumberOfIllPersonsHigherThanExpected")) mdh.NumberOfIllPersonsHigherThanExpected = vDict["NumberOfIllPersonsHigherThanExpected"].Equals("Y");
|
|
if (vDict.ContainsKey("NumberOfIllPersons")) mdh.NumberOfIllPersons = Int32.Parse(vDict["NumberOfIllPersons"]);
|
|
if (vDict.ContainsKey("SickPersonsOnBoard")) mdh.SickPersonsOnBoard = vDict["SickPersonsOnBoard"].Equals("Y");
|
|
if (vDict.ContainsKey("MedicalConsulted")) mdh.MedicalConsulted = vDict["MedicalConsulted"].Equals("Y");
|
|
if (vDict.ContainsKey("AwareOfConditionsForFurtherInfections")) mdh.AwareOfFurtherInfections = vDict["AwareOfConditionsForFurtherInfections"].Equals("Y");
|
|
if (vDict.ContainsKey("SanitaryMeasuresApplied")) mdh.SanitaryMeasuresApplied = vDict["SanitaryMeasuresApplied"].Equals("Y");
|
|
if (vDict.ContainsKey("SanitaryMeasuresType")) mdh.SanitaryMeasuresType = vDict["SanitaryMeasuresType"];
|
|
if (vDict.ContainsKey("SanitaryMeasuresLocation")) mdh.SanitaryMeasuresLocation = vDict["SanitaryMeasuresLocation"];
|
|
if (vDict.ContainsKey("SanitaryMeasuresDate")) mdh.SanitaryMeasuresDate = Extensions.TryParseDateTime(vDict["SanitaryMeasuresDate"]);
|
|
if (vDict.ContainsKey("StowawaysDetected")) mdh.StowawaysDetected = vDict["StowawaysDetected"].Equals("Y");
|
|
if (vDict.ContainsKey("StowawaysJoiningLocation")) mdh.StowawaysJoiningLocation = vDict["StowawaysJoiningLocation"];
|
|
if (vDict.ContainsKey("SickAnimalOrPetOnBoard")) mdh.SickAnimalOrPetOnBoard = vDict["SickAnimalOrPetOnBoard"].Equals("Y");
|
|
if (vDict.ContainsKey("ValidSanitaryControlExemptionOrCertificateOnBoard")) mdh.ValidSanitaryControlExemptionOrCertificateOnBoard = vDict["ValidSanitaryControlExemptionOrCertificateOnBoard"].Equals("Y");
|
|
if (vDict.ContainsKey("SanitaryControlCertPlaceOfIssue")) mdh.PlaceOfIssue = vDict["SanitaryControlCertPlaceOfIssue"];
|
|
if (vDict.ContainsKey("SanitaryControlCertDateOfIssue")) mdh.DateOfIssue = Extensions.TryParseDateTime(vDict["SanitaryControlCertDateOfIssue"]);
|
|
if (vDict.ContainsKey("SanitaryControlReinspectionRequired")) mdh.SanitaryControlReinspectionRequired = vDict["SanitaryControlReinspectionRequired"].Equals("Y");
|
|
if (vDict.ContainsKey("InfectedAreaVisited")) mdh.InfectedAreaVisited = vDict["InfectedAreaVisited"].Equals("Y");
|
|
if (vDict.ContainsKey("InfectedAreaPort")) mdh.InfectedAreaPort = vDict["InfectedAreaPort"];
|
|
if (vDict.ContainsKey("InfectedAreaDate")) mdh.InfectedAreaDate = Extensions.TryParseDateTime(vDict["InfectedAreaDate"]);
|
|
|
|
// sublisten
|
|
if (!mdh.MDHSimplification ?? true)
|
|
{
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
if (pDict.Count > 0)
|
|
{
|
|
PortOfCallLast30Days poc30 = mdh.GetSublistElementWithIdentifier(key.ToString()) as PortOfCallLast30Days;
|
|
if (poc30 == null)
|
|
{
|
|
poc30 = new PortOfCallLast30Days();
|
|
poc30.Identifier = key.ToString();
|
|
mdh.PortOfCallLast30Days.Add(poc30);
|
|
poc30.MDH = mdh;
|
|
}
|
|
|
|
if (pDict.ContainsKey("PortOfCallLast30DaysDateOfDeparture")) poc30.PortOfCallLast30DaysDateOfDeparture = Extensions.TryParseDateTime(pDict["PortOfCallLast30DaysDateOfDeparture"]);
|
|
if (pDict.ContainsKey("PortOfCallLast30DaysCrewMembersJoined")) poc30.PortOfCallLast30DaysCrewMembersJoined = pDict["PortOfCallLast30DaysCrewMembersJoined"].Equals("Y");
|
|
if (pDict.ContainsKey("PortOfCallLast30DaysPortCode") && pDict.ContainsKey("PortOfCallLast30DaysCountryCode"))
|
|
poc30.PortOfCallLast30DaysLocode = pDict["PortOfCallLast30DaysCountryCode"] + pDict["PortOfCallLast30DaysPortCode"];
|
|
|
|
|
|
|
|
saveMessages.Add(poc30);
|
|
|
|
// lookup / crew members (Identifier hier der Name! (vereinfachung, ich habe keine rowid))
|
|
if (pDict.ContainsKey("PortOfCallLast30DaysCrewMemberNamesJoined"))
|
|
{
|
|
string[] names = pDict["PortOfCallLast30DaysCrewMemberNamesJoined"].Split(',');
|
|
for (int k = 0; k < names.Length; k++)
|
|
{
|
|
string crewname = names[k].Trim();
|
|
PortOfCallLast30DaysCrewJoinedShip poc30Crew = poc30.GetSublistElementWithIdentifier(crewname) as PortOfCallLast30DaysCrewJoinedShip;
|
|
if (poc30Crew == null)
|
|
{
|
|
poc30Crew = new PortOfCallLast30DaysCrewJoinedShip();
|
|
poc30Crew.Identifier = crewname;
|
|
poc30Crew.PortOfCallLast30Days = poc30;
|
|
poc30Crew.PortOfCallLast30DaysCrewJoinedShipName = crewname;
|
|
poc30.CrewJoinedShip.Add(poc30Crew);
|
|
saveMessages.Add(poc30Crew);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading MDH fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region POBA
|
|
case "POBA":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
POBA newPOBA = new POBA();
|
|
newPOBA.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.POBA;
|
|
theMessage.Elements.Add(newPOBA);
|
|
}
|
|
POBA poba = theMessage.Elements[0] as POBA;
|
|
derivedMessage = poba;
|
|
if (poba != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("TotalPersonsOnBoardUponArrival")) poba.TotalPersonsOnBoardUponArrival = Int32.Parse(vDict["TotalPersonsOnBoardUponArrival"]);
|
|
if (vDict.ContainsKey("TotalCrewMembersOnBoardUponArrival")) poba.TotalCrewMembersOnBoardUponArrival = Int32.Parse(vDict["TotalCrewMembersOnBoardUponArrival"]);
|
|
if (vDict.ContainsKey("TotalPassengersOnBoardUponArrival")) poba.TotalPassengersOnBoardUponArrival = Int32.Parse(vDict["TotalPassengersOnBoardUponArrival"]);
|
|
if (vDict.ContainsKey("TotalStowawaysOnBoardUponArrival")) poba.TotalStowawaysOnBoardUponArrival = Int32.Parse(vDict["TotalStowawaysOnBoardUponArrival"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading POBA fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region POBD
|
|
case "POBD":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
POBD newPOBD = new POBD();
|
|
newPOBD.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.POBD;
|
|
theMessage.Elements.Add(newPOBD);
|
|
}
|
|
POBD pobd = theMessage.Elements[0] as POBD;
|
|
derivedMessage = pobd;
|
|
if (pobd != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("TotalPersonsOnBoardUponDeparture")) pobd.TotalPersonsOnBoardUponDeparture = Int32.Parse(vDict["TotalPersonsOnBoardUponDeparture"]);
|
|
if (vDict.ContainsKey("TotalCrewMembersOnBoardUponDeparture")) pobd.TotalCrewMembersOnBoardUponDeparture = Int32.Parse(vDict["TotalCrewMembersOnBoardUponDeparture"]);
|
|
if (vDict.ContainsKey("TotalPassengersOnBoardUponDeparture")) pobd.TotalPassengersOnBoardUponDeparture = Int32.Parse(vDict["TotalPassengersOnBoardUponDeparture"]);
|
|
if (vDict.ContainsKey("TotalStowawaysOnBoardUponDeparture")) pobd.TotalStowawaysOnBoardUponDeparture = Int32.Parse(vDict["TotalStowawaysOnBoardUponDeparture"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading POBA fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region BPOL
|
|
case "BPOL":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
BPOL newBPOL = new BPOL();
|
|
newBPOL.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.BPOL;
|
|
theMessage.Elements.Add(newBPOL);
|
|
}
|
|
BPOL bpol = theMessage.Elements[0] as BPOL;
|
|
derivedMessage = bpol;
|
|
if (bpol != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("StowawayOnBoard")) bpol.StowawaysOnBoard = vDict["StowawayOnBoard"].Equals("Y");
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
PortOfItinerary poi = bpol.GetSublistElementWithIdentifier(key.ToString()) as PortOfItinerary;
|
|
Dictionary<string, string> ppDict = nDict[key];
|
|
if (ppDict.Count > 0)
|
|
{
|
|
if (poi == null)
|
|
{
|
|
poi = new PortOfItinerary();
|
|
poi.Identifier = key.ToString();
|
|
poi.BPOL = bpol;
|
|
bpol.PortOfItineraries.Add(poi);
|
|
}
|
|
|
|
if (ppDict.ContainsKey("PortOfItineraryName")) poi.PortOfItineraryName = ppDict["PortOfItineraryName"];
|
|
if (ppDict.ContainsKey("PortOfItineraryETA")) poi.PortOfItineraryETA = Extensions.TryParseDateTime(ppDict["PortOfItineraryETA"]);
|
|
|
|
saveMessages.Add(poi);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading BPOL fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region BKRA
|
|
case "BKRA":
|
|
{
|
|
Dictionary<string, string> keysInMessage = new Dictionary<string, string>();
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> bDict = nDict[key];
|
|
keysInMessage.Add(key.ToString(), key.ToString());
|
|
BRKA bkra = theMessage.GetSublistElementWithIdentifier(key.ToString()) as BRKA;
|
|
if (bkra == null)
|
|
{
|
|
bkra = new BRKA();
|
|
bkra.MessageHeader = theMessage;
|
|
bkra.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.BKRA;
|
|
theMessage.Elements.Add(bkra);
|
|
}
|
|
|
|
try
|
|
{
|
|
if (bDict.ContainsKey("BunkerFuelType")) bkra.BunkerFuelType = bDict["BunkerFuelType"];
|
|
if (bDict.ContainsKey("BunkerFuelQuantity_TNE")) bkra.BunkerFuelQuantity_TNE = Extensions.TryParseDouble(bDict["BunkerFuelQuantity_TNE"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading BKRA fields: {0}", ex.Message);
|
|
}
|
|
saveMessages.Add(bkra);
|
|
}
|
|
|
|
// check for missing messages (passenger deleted in EU-NOAD)
|
|
foreach (BRKA bkra in theMessage.Elements)
|
|
{
|
|
if (!keysInMessage.ContainsKey(bkra.Identifier))
|
|
{
|
|
_log.InfoFormat("BRKA {0}, Ident {1} not found in EU-NOAD message, removing!",
|
|
bkra.BunkerFuelType ?? "", bkra.Identifier);
|
|
DBManager.Instance.Delete(bkra);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region SERV
|
|
case "SERV":
|
|
{
|
|
Dictionary<string, string> keysInMessage = new Dictionary<string, string>();
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
keysInMessage.Add(key.ToString(), key.ToString());
|
|
SERV serv = theMessage.GetSublistElementWithIdentifier(key.ToString()) as SERV;
|
|
if (serv == null)
|
|
{
|
|
serv = new SERV();
|
|
serv.MessageHeader = theMessage;
|
|
serv.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.SERV;
|
|
theMessage.Elements.Add(serv);
|
|
}
|
|
try
|
|
{
|
|
if (pDict.ContainsKey("ServiceName")) serv.ServiceName = pDict["ServiceName"];
|
|
if (pDict.ContainsKey("ServiceBenificiary")) serv.ServiceBeneficiary = pDict["ServiceBenificiary"];
|
|
if (pDict.ContainsKey("ServiceInvoiceRecipient")) serv.ServiceInvoiceRecipient = pDict["ServiceInvoiceRecipient"];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading SERV fields: {0}", ex.Message);
|
|
}
|
|
|
|
saveMessages.Add(serv);
|
|
}
|
|
// check for missing messages (passenger deleted in EU-NOAD)
|
|
foreach (SERV serv in theMessage.Elements)
|
|
{
|
|
if (!keysInMessage.ContainsKey(serv.Identifier))
|
|
{
|
|
_log.InfoFormat("SERV {0}, Ident {1} not found in EU-NOAD message, removing!",
|
|
serv.ServiceName ?? "", serv.Identifier);
|
|
DBManager.Instance.Delete(serv);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region CREW
|
|
case "CREW":
|
|
{
|
|
Dictionary<string, string> keysInMessage = new Dictionary<string, string>();
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
keysInMessage.Add(key.ToString(), key.ToString());
|
|
CREW crew = theMessage.GetSublistElementWithIdentifier(key.ToString()) as CREW;
|
|
if (crew == null)
|
|
{
|
|
crew = new CREW();
|
|
crew.MessageHeader = theMessage;
|
|
crew.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.CREW;
|
|
theMessage.Elements.Add(crew);
|
|
}
|
|
try
|
|
{
|
|
if (pDict.ContainsKey("CrewMemberLastName")) crew.CrewMemberLastName = pDict["CrewMemberLastName"];
|
|
if (pDict.ContainsKey("CrewMemberFirstName")) crew.CrewMemberFirstName = pDict["CrewMemberFirstName"];
|
|
if (pDict.ContainsKey("CrewMemberPlaceOfBirth")) crew.CrewMemberPlaceOfBirth = pDict["CrewMemberPlaceOfBirth"];
|
|
if (pDict.ContainsKey("CrewMemberDateOfBirth")) crew.CrewMemberDateOfBirth = Extensions.TryParseDateTime(pDict["CrewMemberDateOfBirth"]);
|
|
if (pDict.ContainsKey("CrewMemberGender")) crew.CrewMemberGender = Enums.ParseGender(pDict["CrewMemberGender"]);
|
|
if (pDict.ContainsKey("CrewMemberNationalityCode")) crew.CrewMemberNationality = pDict["CrewMemberNationalityCode"];
|
|
if (pDict.ContainsKey("CrewMemberIdentityDocumentType")) crew.CrewMemberIdentityDocumentType = (byte)Enum.Parse(typeof(Enums.PassengerIdentityDocumentType), pDict["CrewMemberIdentityDocumentType"], true);
|
|
if (pDict.ContainsKey("CrewMemberIdentityDocumentId")) crew.CrewMemberIdentityDocumentId = pDict["CrewMemberIdentityDocumentId"];
|
|
if (pDict.ContainsKey("CrewMemberVisaNumber")) crew.CrewMemberVisaNumber = pDict["CrewMemberVisaNumber"];
|
|
if (pDict.ContainsKey("CrewMemberDuty")) crew.CrewMemberDuty = pDict["CrewMemberDuty"];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading CREW fields: {0}", ex.Message);
|
|
}
|
|
saveMessages.Add(crew);
|
|
}
|
|
// check for missing messages (crew deleted in EU-NOAD)
|
|
foreach (CREW crew in theMessage.Elements)
|
|
{
|
|
if (!keysInMessage.ContainsKey(crew.Identifier))
|
|
{
|
|
_log.InfoFormat("CREW {0} {1}, Ident {2} not found in EU-NOAD message, removing!",
|
|
crew.CrewMemberLastName ?? "", crew.CrewMemberFirstName ?? "", crew.Identifier);
|
|
DBManager.Instance.Delete(crew);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region BKRD
|
|
case "BKRD":
|
|
{
|
|
Dictionary<string, string> keysInMessage = new Dictionary<string, string>();
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> bDict = nDict[key];
|
|
keysInMessage.Add(key.ToString(), key.ToString());
|
|
BRKD bkrd = theMessage.GetSublistElementWithIdentifier(key.ToString()) as BRKD;
|
|
if (bkrd == null)
|
|
{
|
|
bkrd = new BRKD();
|
|
bkrd.MessageHeader = theMessage;
|
|
bkrd.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.BKRD;
|
|
theMessage.Elements.Add(bkrd);
|
|
}
|
|
|
|
try
|
|
{
|
|
if (bDict.ContainsKey("BunkerFuelType")) bkrd.BunkerFuelType = bDict["BunkerFuelType"];
|
|
if (bDict.ContainsKey("BunkerFuelQuantity_TNE")) bkrd.BunkerFuelQuantity_TNE = Extensions.TryParseDouble(bDict["BunkerFuelQuantity_TNE"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading BKRD fields: {0}", ex.Message);
|
|
}
|
|
|
|
saveMessages.Add(bkrd);
|
|
}
|
|
|
|
// check for missing messages (passenger deleted in EU-NOAD)
|
|
foreach (BRKD brkd in theMessage.Elements)
|
|
{
|
|
if (!keysInMessage.ContainsKey(brkd.Identifier))
|
|
{
|
|
_log.InfoFormat("BRKD {0}, Ident {1} not found in EU-NOAD message, removing!",
|
|
brkd.BunkerFuelType ?? "", brkd.Identifier);
|
|
DBManager.Instance.Delete(brkd);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region INFO
|
|
case "INFO":
|
|
{
|
|
if(theMessage.Elements.Count == 0)
|
|
{
|
|
INFO newInfo = new INFO();
|
|
newInfo.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.INFO;
|
|
theMessage.Elements.Add(newInfo);
|
|
}
|
|
INFO info = theMessage.Elements[0] as INFO;
|
|
derivedMessage = info;
|
|
if (info != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("ShippingArea")) info.ShippingArea = (byte) Enum.Parse(typeof(Enums.ShippingArea), vDict["ShippingArea"]);
|
|
if (vDict.ContainsKey("RequestedPositionInPortOfCall")) info.RequestedPositionInPortOfCall = vDict["RequestedPositionInPortOfCall"];
|
|
if (vDict.ContainsKey("SpecialRequirementsOfShipAtBerth")) info.SpecialRequirementsOfShipAtBerth = vDict["SpecialRequirementsOfShipAtBerth"];
|
|
if (info.SpecialRequirementsOfShipAtBerth.IsNullOrEmpty())
|
|
info.SpecialRequirementsOfShipAtBerth = aMessageCore.Customer.Name;
|
|
else
|
|
{
|
|
if((aMessageCore.Customer != null) && (aMessageCore.Customer.Name != null))
|
|
info.SpecialRequirementsOfShipAtBerth = string.Format("{0} - Agent: {1}", info.SpecialRequirementsOfShipAtBerth, aMessageCore.Customer.Name);
|
|
}
|
|
if (vDict.ContainsKey("ConstructionCharacteristicsOfShip")) info.ConstructionCharacteristicsOfShip = vDict["ConstructionCharacteristicsOfShip"];
|
|
if (vDict.ContainsKey("FumigatedBulkCargo") && !vDict["FumigatedBulkCargo"].IsNullOrEmpty())
|
|
info.FumigatedBulkCargo = (byte)Enum.Parse(typeof(Enums.FumigatedBulkCargo), vDict["FumigatedBulkCargo"]);
|
|
else
|
|
info.FumigatedBulkCargo = (byte) Enums.FumigatedBulkCargo.N;
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading INFO fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region PRE72H
|
|
case "PRE72H":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
PRE72H newp = new PRE72H();
|
|
newp.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.PRE72H;
|
|
theMessage.Elements.Add(newp);
|
|
}
|
|
PRE72H pre72h = theMessage.Elements[0] as PRE72H;
|
|
derivedMessage = pre72h;
|
|
if (pre72h != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("Tanker")) pre72h.Tanker = vDict["Tanker"].Equals("Y");
|
|
else pre72h.Tanker = false; // 18.10.15, vorläufig als default
|
|
if (vDict.ContainsKey("TankerHullConfiguration")) pre72h.TankerHullConfiguration = (byte)Enum.Parse(typeof(Enums.TankerHullConfiguration), vDict["TankerHullConfiguration"]);
|
|
if (vDict.ContainsKey("ConditionCargoBallastTanks")) pre72h.ConditionCargoBallastTanks = (byte)Enum.Parse(typeof(Enums.ConditionCargoBallastTanks), vDict["ConditionCargoBallastTanks"]);
|
|
if (vDict.ContainsKey("NatureOfCargo")) pre72h.NatureOfCargo = vDict["NatureOfCargo"];
|
|
if (vDict.ContainsKey("VolumeOfCargo_TNE")) pre72h.VolumeOfCargo = Extensions.TryParseDouble(vDict["VolumeOfCargo_TNE"]);
|
|
if (vDict.ContainsKey("PlannedOperations")) pre72h.PlannedOperations = vDict["PlannedOperations"];
|
|
if (vDict.ContainsKey("PlannedWorks")) pre72h.PlannedWorks = vDict["PlannedWorks"];
|
|
if (vDict.ContainsKey("DateOfLastExpandedInspection")) pre72h.DateOfLastExpandedInspection = Extensions.TryParseDateTime(vDict["DateOfLastExpandedInspection"]);
|
|
if (vDict.ContainsKey("PlannedPeriodOfStay_HUR")) pre72h.PlannedPeriodOfStay_HUR = Extensions.TryParseDouble(vDict["PlannedPeriodOfStay_HUR"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading PRE72H fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region LADG
|
|
case "LADG":
|
|
{
|
|
Dictionary<string, string> keysInMessage = new Dictionary<string, string>();
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> lDict = nDict[key];
|
|
keysInMessage.Add(key.ToString(), key.ToString());
|
|
LADG ladg = theMessage.GetSublistElementWithIdentifier(key.ToString()) as LADG;
|
|
if (ladg == null)
|
|
{
|
|
ladg = new LADG();
|
|
ladg.MessageHeader = theMessage;
|
|
ladg.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.LADG;
|
|
theMessage.Elements.Add(ladg);
|
|
}
|
|
if (lDict.ContainsKey("CargoGrossQuantity_TNE")) ladg.CargoGrossQuantity_TNE = Extensions.TryParseDouble(lDict["CargoGrossQuantity_TNE"]);
|
|
if (lDict.ContainsKey("CargoNumberOfItems")) ladg.CargoNumberOfItems = Int32.Parse(lDict["CargoNumberOfItems"]);
|
|
if (lDict.ContainsKey("CargoCodeNST")) ladg.CargoCodeNST = lDict["CargoCodeNST"];
|
|
if (lDict.ContainsKey("CargoHandlingType")) ladg.CargoHandlingType = (byte) Enum.Parse(typeof(Enums.CargoHandlingType), lDict["CargoHandlingType"]);
|
|
|
|
saveMessages.Add(ladg);
|
|
}
|
|
|
|
// check for missing messages (passenger deleted in EU-NOAD)
|
|
foreach (LADG ladg in theMessage.Elements)
|
|
{
|
|
if (!keysInMessage.ContainsKey(ladg.Identifier))
|
|
{
|
|
_log.InfoFormat("LADG {0}, Ident {1} not found in EU-NOAD message, removing!",
|
|
ladg.CargoCodeNST ?? "", ladg.Identifier);
|
|
DBManager.Instance.Delete(ladg);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region PAS
|
|
case "PAS":
|
|
{
|
|
Dictionary<string, string> keysInMessage = new Dictionary<string, string>();
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
keysInMessage.Add(key.ToString(), key.ToString());
|
|
PAS pas = theMessage.GetSublistElementWithIdentifier(key.ToString()) as PAS;
|
|
if (pas == null)
|
|
{
|
|
pas = new PAS();
|
|
pas.MessageHeader = theMessage;
|
|
pas.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.PAS;
|
|
theMessage.Elements.Add(pas);
|
|
}
|
|
try
|
|
{
|
|
if (pDict.ContainsKey("PassengerLastName")) pas.PassengerLastName = pDict["PassengerLastName"];
|
|
if (pDict.ContainsKey("PassengerFirstName")) pas.PassengerFirstName = pDict["PassengerFirstName"];
|
|
if (pDict.ContainsKey("PassengerPlaceOfBirth")) pas.PassengerPlaceOfBirth = pDict["PassengerPlaceOfBirth"];
|
|
if (pDict.ContainsKey("PassengerDateOfBirth")) pas.PassengerDateOfBirth = Extensions.TryParseDateTime(pDict["PassengerDateOfBirth"]);
|
|
if (pDict.ContainsKey("PassengerGender")) pas.PassengerGender = Enums.ParseGender(pDict["PassengerGender"]);
|
|
if (pDict.ContainsKey("PassengerNationalityCode")) pas.PassengerNationality = pDict["PassengerNationalityCode"];
|
|
if (pDict.ContainsKey("PassengerIdentityDocumentType")) pas.PassengerIdentityDocumentType = (byte)Enum.Parse(typeof(Enums.PassengerIdentityDocumentType), pDict["PassengerIdentityDocumentType"], true);
|
|
if (pDict.ContainsKey("PassengerIdentityDocumentId")) pas.PassengerIdentityDocumentId = pDict["PassengerIdentityDocumentId"];
|
|
if (pDict.ContainsKey("PassengerVisaNumber")) pas.PassengerVisaNumber = pDict["PassengerVisaNumber"];
|
|
if (pDict.ContainsKey("PassengerPortCodeOfEmbarkation") && pDict.ContainsKey("PassengerCountryCodeOfEmbarkation"))
|
|
pas.PassengerPortOfEmbarkation = pDict["PassengerCountryCodeOfEmbarkation"] + pDict["PassengerPortCodeOfEmbarkation"];
|
|
if (pDict.ContainsKey("PassengerPortCodeOfDisembarkation") && pDict.ContainsKey("PassengerCountryCodeOfDisembarkation"))
|
|
pas.PassengerPortOfDisembarkation = pDict["PassengerCountryCodeOfEmbarkation"] + pDict["PassengerPortCodeOfDisembarkation"];
|
|
if (pDict.ContainsKey("PassengerInTransit")) pas.PassengerInTransit = pDict["PassengerInTransit"].Equals("Y");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading PAS fields: {0}", ex.Message);
|
|
}
|
|
|
|
saveMessages.Add(pas);
|
|
}
|
|
// check for missing messages (passenger deleted in EU-NOAD)
|
|
foreach (PAS pas in theMessage.Elements)
|
|
{
|
|
if (!keysInMessage.ContainsKey(pas.Identifier))
|
|
{
|
|
_log.InfoFormat("PAS {0} {1}, Ident {2} not found in EU-NOAD message, removing!",
|
|
pas.PassengerLastName ?? "", pas.PassengerFirstName ?? "", pas.Identifier);
|
|
DBManager.Instance.Delete(pas);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region WAS
|
|
case "WAS":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
WAS newWAS = new WAS();
|
|
newWAS.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.WAS;
|
|
theMessage.Elements.Add(newWAS);
|
|
}
|
|
WAS was = theMessage.Elements[0] as WAS;
|
|
derivedMessage = was;
|
|
if (was != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("WasteDisposalValidExemption")) was.WasteDisposalValidExemption = vDict["WasteDisposalValidExemption"].Equals("Y");
|
|
if (vDict.ContainsKey("LastWasteDisposalDate")) was.LastWasteDisposalDate = Extensions.TryParseDateTime(vDict["LastWasteDisposalDate"]);
|
|
|
|
if (vDict.ContainsKey("LastWasteDisposalPortCode") && vDict.ContainsKey("LastWasteDisposalCountryCode"))
|
|
was.LastWasteDisposalPort = vDict["LastWasteDisposalCountryCode"] + vDict["LastWasteDisposalPortCode"];
|
|
if (vDict.ContainsKey("WasteDisposalDelivery")) was.WasteDisposalDelivery = (byte) Enum.Parse(typeof(Enums.WasteDisposalDelivery), vDict["WasteDisposalDelivery"], true);
|
|
if (vDict.ContainsKey("ConfirmationOfCorrectness")) was.ConfirmationOfCorrectness = vDict["ConfirmationOfCorrectness"].Equals("Y");
|
|
|
|
// parse given waste
|
|
foreach(int key in nDict.Keys) {
|
|
Dictionary<string, string> wDict = nDict[key];
|
|
Waste waste = was.GetSublistElementWithIdentifier(key.ToString()) as Waste;
|
|
if (waste == null)
|
|
{
|
|
foreach (Waste existingWaste in was.Waste)
|
|
{
|
|
if ((existingWaste.WasteType ?? 0) == (Enums.ParseWasteType(wDict["WasteType"]) ?? 0))
|
|
{
|
|
waste = existingWaste;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (waste == null)
|
|
{
|
|
waste = new Waste();
|
|
waste.Identifier = key.ToString();
|
|
waste.WAS = was;
|
|
was.Waste.Add(waste);
|
|
}
|
|
|
|
if (wDict.ContainsKey("WasteAmountGeneratedTillNextPort_MTQ")) waste.WasteAmountGeneratedTillNextPort_MTQ = Extensions.TryParseDouble(wDict["WasteAmountGeneratedTillNextPort_MTQ"]);
|
|
if (wDict.ContainsKey("WasteAmountRetained_MTQ")) waste.WasteAmountRetained_MTQ = Extensions.TryParseDouble(wDict["WasteAmountRetained_MTQ"]);
|
|
if (wDict.ContainsKey("WasteCapacity_MTQ")) waste.WasteCapacity_MTQ = Extensions.TryParseDouble(wDict["WasteCapacity_MTQ"]);
|
|
if (wDict.ContainsKey("WasteDisposalAmount_MTQ")) waste.WasteDisposalAmount_MTQ = Extensions.TryParseDouble(wDict["WasteDisposalAmount_MTQ"]);
|
|
if (wDict.ContainsKey("WasteDescription")) waste.WasteDescription = wDict["WasteDescription"];
|
|
if (wDict.ContainsKey("WasteType")) waste.WasteType = Enums.ParseWasteType(wDict["WasteType"]);
|
|
if (wDict.ContainsKey("WasteDisposalCountryCode") && wDict.ContainsKey("WasteDisposalPortCode"))
|
|
waste.WasteDisposalPort = wDict["WasteDisposalCountryCode"] + wDict["WasteDisposalPortCode"];
|
|
|
|
// Wenn das Feld leer ist mit "-" entwerten
|
|
if (((waste.WasteType ?? 0) == 3) && waste.WasteDescription.IsNullOrEmpty())
|
|
waste.WasteDescription = "-";
|
|
if (((waste.WasteType ?? 0) == 8) && waste.WasteDescription.IsNullOrEmpty())
|
|
waste.WasteDescription = "-";
|
|
if (((waste.WasteType ?? 0) == 9) && waste.WasteDescription.IsNullOrEmpty())
|
|
waste.WasteDescription = "-";
|
|
|
|
saveMessages.Add(waste);
|
|
}
|
|
|
|
// fehlende Waste Meldungen als "leer" hinzufügen, der Identifier muss dann zur Kennzeichnung leer sein
|
|
// falls später vom Schiff als Update korrigierte Werte kommen.
|
|
saveMessages.AddRange(was.AddRemainingWasteTypes());
|
|
|
|
if (vDict.ContainsKey("WasteDisposalServiceProviderName"))
|
|
{
|
|
WasteDisposalServiceProvider wdsp = null;
|
|
if (was.WasteDisposalServiceProvider.Count == 0)
|
|
{
|
|
wdsp = new WasteDisposalServiceProvider();
|
|
wdsp.WAS = was;
|
|
was.WasteDisposalServiceProvider.Add(wdsp);
|
|
}
|
|
else
|
|
{
|
|
wdsp = was.WasteDisposalServiceProvider[0];
|
|
}
|
|
wdsp.WasteDisposalServiceProviderName = vDict["WasteDisposalServiceProviderName"];
|
|
saveMessages.Add(wdsp);
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading WAS fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region SEC
|
|
case "SEC":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
SEC newSEC = new SEC();
|
|
newSEC.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.SEC;
|
|
theMessage.Elements.Add(newSEC);
|
|
}
|
|
SEC sec = theMessage.Elements[0] as SEC;
|
|
derivedMessage = sec;
|
|
if (sec != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("Simplification")) sec.SECSimplification = vDict["Simplification"].Equals("Y");
|
|
if (vDict.ContainsKey("PortOfCallWhereCompleteSECNotified")) sec.PortOfCallWhereCompleteSECNotified = vDict["PortOfCallWhereCompleteSECNotified"];
|
|
if (vDict.ContainsKey("CSOLastName")) sec.CSOLastName = vDict["CSOLastName"];
|
|
if (vDict.ContainsKey("CSOFirstName")) sec.CSOFirstName = vDict["CSOFirstName"];
|
|
if (vDict.ContainsKey("CSOPhone")) sec.CSOPhone = vDict["CSOPhone"];
|
|
if (vDict.ContainsKey("CSOFax")) sec.CSOFax = vDict["CSOFax"];
|
|
if (vDict.ContainsKey("CSOEMail")) sec.CSOEMail = vDict["CSOEMail"];
|
|
if (vDict.ContainsKey("ValidISSCOnBoard")) sec.ValidISSCOnBoard = vDict["ValidISSCOnBoard"].Equals("Y");
|
|
if (vDict.ContainsKey("ReasonsForNoValidISSC")) sec.ReasonsForNoValidISSC = vDict["ReasonsForNoValidISSC"];
|
|
if (vDict.ContainsKey("ISSCType")) sec.ISSCType = (byte)Enum.Parse(typeof(Enums.ISSCType), vDict["ISSCType"], true);
|
|
if (vDict.ContainsKey("ISSCIssuerType")) sec.ISSCIssuerType = (byte)Enum.Parse(typeof(Enums.ISSCIssuerType), vDict["ISSCIssuerType"], true);
|
|
if (vDict.ContainsKey("ISSCIssuerName")) sec.ISSCIssuerName = vDict["ISSCIssuerName"];
|
|
if (vDict.ContainsKey("ISSCDateOfExpiration")) sec.ISSCDateOfExpiration = Extensions.TryParseDateTime(vDict["ISSCDateOfExpiration"]);
|
|
if (vDict.ContainsKey("ApprovedSecurityPlanOnBoard")) sec.ApprovedSecurityPlanOnBoard = vDict["ApprovedSecurityPlanOnBoard"].Equals("Y");
|
|
if (vDict.ContainsKey("CurrentShipSecurityLevel")) sec.CurrentShipSecurityLevel = Byte.Parse(vDict["CurrentShipSecurityLevel"]);
|
|
if (vDict.ContainsKey("CurrentShipSecurityLevel ")) sec.CurrentShipSecurityLevel = Byte.Parse(vDict["CurrentShipSecurityLevel "]);
|
|
if (vDict.ContainsKey("PortFacilityOfArrival")) sec.PortFacilityOfArrival = vDict["PortFacilityOfArrival"];
|
|
if (vDict.ContainsKey("GeneralDescriptionOfCargo")) sec.GeneralDescriptionOfCargo = (byte)Enum.Parse(typeof(Enums.GeneralDescriptionOfCargo), vDict["GeneralDescriptionOfCargo"], true);
|
|
|
|
// process sublists
|
|
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> sDict = nDict[key];
|
|
if (sDict.Count > 0)
|
|
{
|
|
bool changedPfC = false;
|
|
bool changedStS = false;
|
|
|
|
ShipToShipActivitiesDuringLastTenPortFacilitiesCalled sts = sec.GetShipToShipWithIdentifier(key.ToString());
|
|
if (sts == null)
|
|
{
|
|
sts = new ShipToShipActivitiesDuringLastTenPortFacilitiesCalled();
|
|
sts.SEC = sec;
|
|
sts.Identifier = key.ToString();
|
|
sec.ShipToShipActivitiesDuringLastTenPortFacilitiesCalled.Add(sts);
|
|
}
|
|
|
|
LastTenPortFacilitiesCalled poc = sec.GetPortFacilityWithIdentifier(key.ToString());
|
|
if (poc == null)
|
|
{
|
|
poc = new LastTenPortFacilitiesCalled();
|
|
poc.SEC = sec;
|
|
poc.Identifier = key.ToString();
|
|
sec.LastTenPortFacilitesCalled.Add(poc);
|
|
}
|
|
|
|
if (sDict.ContainsKey("PortFacilityPortName")) { poc.PortFacilityPortName = sDict["PortFacilityPortName"]; changedPfC = true; }
|
|
if (sDict.ContainsKey("PortFacilityPortCountry")) { poc.PortFacilityPortCountry = sDict["PortFacilityPortCountry"]; changedPfC = true; }
|
|
if (sDict.ContainsKey("PortFacilityPortLoCode") && sDict.ContainsKey("PortFacilityPortCountryCode") && (sDict["PortFacilityPortLoCode"].Length < 4))
|
|
{
|
|
poc.PortFacilityPortLoCode = sDict["PortFacilityPortCountryCode"] + sDict["PortFacilityPortLoCode"];
|
|
changedPfC = true;
|
|
}
|
|
if (sDict.ContainsKey("PortFacilityDateOfArrival")) { poc.PortFacilityDateOfArrival = Extensions.TryParseDateTime(sDict["PortFacilityDateOfArrival"]); changedPfC = true; }
|
|
if (sDict.ContainsKey("PortFacilityDateOfDeparture")) { poc.PortFacilityDateOfDeparture = Extensions.TryParseDateTime(sDict["PortFacilityDateOfDeparture"]); changedPfC = true; }
|
|
if (sDict.ContainsKey("PortFacilityShipSecurityLevel")) { poc.PortFacilityShipSecurityLevel = Byte.Parse(sDict["PortFacilityShipSecurityLevel"]); changedPfC = true; }
|
|
if (sDict.ContainsKey("PortFacilitySecurityMattersToReport")) { poc.PortFacilitySecurityMattersToReport = sDict["PortFacilitySecurityMattersToReport"]; changedPfC = true; }
|
|
if (sDict.ContainsKey("PortFacilityGISISCode"))
|
|
{
|
|
poc.PortFacilityGISISCode = sDict["PortFacilityGISISCode"]; changedPfC = true;
|
|
if (poc.PortFacilityGISISCode.Length > 4)
|
|
poc.PortFacilityGISISCode = poc.PortFacilityGISISCode.Substring(0, 4);
|
|
}
|
|
|
|
// sanitize GISIS code
|
|
if (poc.PortFacilityGISISCode.IsNullOrEmpty())
|
|
{
|
|
poc.PortFacilityGISISCode = "0000";
|
|
}
|
|
else {
|
|
Regex rgx = new Regex("[0-9]{4}");
|
|
if (!rgx.IsMatch(poc.PortFacilityGISISCode))
|
|
{
|
|
_log.WarnFormat("PortFacilityGISISCode invalid: {0}, replacing with 0000", poc.PortFacilityGISISCode);
|
|
poc.PortFacilityGISISCode = "0000";
|
|
}
|
|
}
|
|
|
|
if (sDict.ContainsKey("ShipToShipActivityLocationName")) { sts.ShipToShipActivityLocationName = sDict["ShipToShipActivityLocationName"]; changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivityLocationLoCode") && sDict.ContainsKey("ShipToShipActivityCountryCode") && (sDict["ShipToShipActivityLocationLoCode"].Length < 4))
|
|
{
|
|
sts.ShipToShipActivityLocationLoCode = sDict["ShipToShipActivityCountryCode"] + sDict["ShipToShipActivityLocationLoCode"];
|
|
changedStS = true;
|
|
}
|
|
if (sDict.ContainsKey("ShipToShipActivityLocationCoordinatesLatitude")) { sts.ShipToShipActivityLocationCoordinatesLatitude = Int32.Parse(sDict["ShipToShipActivityLocationCoordinatesLatitude"]); changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivityLocationCoordinatesLongitude")) { sts.ShipToShipActivityLocationCoordinatesLongitude = Int32.Parse(sDict["ShipToShipActivityLocationCoordinatesLongitude"]); changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivityDateFrom")) { sts.ShipToShipActivityDateFrom = Extensions.TryParseDateTime(sDict["ShipToShipActivityDateFrom"]); changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivityDateTo")) { sts.ShipToShipActivityDateTo = Extensions.TryParseDateTime(sDict["ShipToShipActivityDateTo"]); changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivityType")) { sts.ShipToShipActivityType = sDict["ShipToShipActivityType"]; changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivitySecurityMattersToReport")) { sts.ShipToShipActivitySecurityMattersToReport = sDict["ShipToShipActivitySecurityMattersToReport"]; changedStS = true; }
|
|
|
|
if (changedPfC) saveMessages.Add(poc);
|
|
if (changedStS) saveMessages.Add(sts);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading SEC fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region Visit
|
|
case "Visit":
|
|
{
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.VISIT;
|
|
if (vDict.ContainsKey("PortNameOfCall")) aMessageCore.Portname = vDict["PortNameOfCall"];
|
|
if (vDict.ContainsKey("PortOfCall")) aMessageCore.PoC = "DE" + vDict["PortOfCall"];
|
|
// if (vDict.ContainsKey("TransitKielCanal")) aMessageCore.IsTransit = vDict["TransitKielCanal"].Equals("Y");
|
|
if (vDict.ContainsKey("ETAPortOfCall")) aMessageCore.ETA = Extensions.TryParseDateTime(vDict["ETAPortOfCall"]);
|
|
if (vDict.ContainsKey("ETAKielCanal")) aMessageCore.ETAKielCanal = Extensions.TryParseDateTime(vDict["ETAKielCanal"]);
|
|
aMessageCore.IsTransit = false;
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region Transit
|
|
case "Transit":
|
|
{
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.TRANSIT;
|
|
if (vDict.ContainsKey("ETAKielCanal")) aMessageCore.ETAKielCanal = Extensions.TryParseDateTime(vDict["ETAKielCanal"]);
|
|
aMessageCore.IsTransit = true;
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region TOWA
|
|
case "TOWA":
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
TOWA towa = theMessage.GetSublistElementWithIdentifier(key.ToString()) as TOWA;
|
|
if (towa == null)
|
|
{
|
|
towa = new TOWA();
|
|
towa.MessageHeader = theMessage;
|
|
towa.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.TOWA;
|
|
theMessage.Elements.Add(towa);
|
|
}
|
|
try
|
|
{
|
|
if (pDict.ContainsKey("TowageOnArrivalBeam_MTR")) towa.TowageOnArrivalBeam_MTR = Extensions.TryParseDouble(pDict["TowageOnArrivalBeam_MTR"]);
|
|
if (pDict.ContainsKey("TowageOnArrivalDraught_DMT")) towa.TowageOnArrivalDraught_DMT = Extensions.TryParseDouble(pDict["TowageOnArrivalDraught_DMT"]);
|
|
if (pDict.ContainsKey("TowageOnArrivalLengthOverall_MTR")) towa.TowageOnArrivalLengthOverall_MTR = Extensions.TryParseDouble(pDict["TowageOnArrivalLengthOverall_MTR"]);
|
|
if (pDict.ContainsKey("TowageOnArrivalGrossTonnage")) towa.TowageOnArrivalGrossTonnage = Int32.Parse(pDict["TowageOnArrivalGrossTonnage"]);
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorCountry")) towa.TowageOnArrivalOperatorCountry = pDict["TowageOnArrivalOperatorCountry"];
|
|
if (pDict.ContainsKey("TowageOnArrivalPurposeOfCall")) towa.TowageOnArrivalPurposeOfCall = pDict["TowageOnArrivalPurposeOfCall"];
|
|
if (pDict.ContainsKey("TowageOnArrivalName")) towa.TowageOnArrivalName = pDict["TowageOnArrivalName"];
|
|
if (pDict.ContainsKey("TowageOnArrivalFlag")) towa.TowageOnArrivalFlag = pDict["TowageOnArrivalFlag"];
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorCompanyName")) towa.TowageOnArrivalOperatorCompanyName = pDict["TowageOnArrivalOperatorCompanyName"];
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorStreetAndNumber")) towa.TowageOnArrivalOperatorStreetNameAndNumber = pDict["TowageOnArrivalOperatorStreetAndNumber"];
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorPostalCode")) towa.TowageOnArrivalOperatorPostalCode = pDict["TowageOnArrivalOperatorPostalCode"];
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorCity")) towa.TowageOnArrivalOperatorCity = pDict["TowageOnArrivalOperatorCity"];
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorPhone")) towa.TowageOnArrivalOperatorPhone = pDict["TowageOnArrivalOperatorPhone"];
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorFax")) towa.TowageOnArrivalOperatorFax = pDict["TowageOnArrivalOperatorFax"];
|
|
if (pDict.ContainsKey("TowageOnArrivalOperatorEmail")) towa.TowageOnArrivalOperatorEmail = pDict["TowageOnArrivalOperatorEmail"];
|
|
if (pDict.ContainsKey("TowageOnArrivalRemarks")) towa.TowageOnArrivalRemarks = pDict["TowageOnArrivalRemarks"];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading TOWA fields: {0}", ex.Message);
|
|
}
|
|
saveMessages.Add(towa);
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region TOWD
|
|
case "TOWD":
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
TOWD towd = theMessage.GetSublistElementWithIdentifier(key.ToString()) as TOWD;
|
|
if (towd == null)
|
|
{
|
|
towd = new TOWD();
|
|
towd.MessageHeader = theMessage;
|
|
towd.Identifier = key.ToString();
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.TOWD;
|
|
theMessage.Elements.Add(towd);
|
|
}
|
|
try
|
|
{
|
|
if (pDict.ContainsKey("TowageOnDepartureBeam_MTR")) towd.TowageOnDepartureBeam_MTR = Extensions.TryParseDouble(pDict["TowageOnDepartureBeam_MTR"]);
|
|
if (pDict.ContainsKey("TowageOnDepartureDraught_DMT")) towd.TowageOnDepartureDraught_DMT = Extensions.TryParseDouble(pDict["TowageOnDepartureDraught_DMT"]);
|
|
if (pDict.ContainsKey("TowageOnDepartureLengthOverall_MTR")) towd.TowageOnDepartureLengthOverall_MTR = Extensions.TryParseDouble(pDict["TowageOnDepartureLengthOverall_MTR"]);
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorCountry")) towd.TowageOnDepartureOperatorCountry = pDict["TowageOnDepartureOperatorCountry"];
|
|
if (pDict.ContainsKey("TowageOnDepartureName")) towd.TowageOnDepartureName = pDict["TowageOnDepartureName"];
|
|
if (pDict.ContainsKey("TowageOnDepartureFlag")) towd.TowageOnDepartureFlag = pDict["TowageOnDepartureFlag"];
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorCompanyName")) towd.TowageOnDepartureOperatorCompanyName = pDict["TowageOnDepartureOperatorCompanyName"];
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorStreetAndNumber")) towd.TowageOnDepartureOperatorStreetNameAndNumber = pDict["TowageOnDepartureOperatorStreetAndNumber"];
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorPostalCode")) towd.TowageOnDepartureOperatorPostalCode = pDict["TowageOnDepartureOperatorPostalCode"];
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorCity")) towd.TowageOnDepartureOperatorCity = pDict["TowageOnDepartureOperatorCity"];
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorPhone")) towd.TowageOnDepartureOperatorPhone = pDict["TowageOnDepartureOperatorPhone"];
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorFax")) towd.TowageOnDepartureOperatorFax = pDict["TowageOnDepartureOperatorFax"];
|
|
if (pDict.ContainsKey("TowageOnDepartureOperatorEmail")) towd.TowageOnDepartureOperatorEmail = pDict["TowageOnDepartureOperatorEmail"];
|
|
if (pDict.ContainsKey("TowageOnDepartureRemarks")) towd.TowageOnDepartureRemarks = pDict["TowageOnDepartureRemarks"];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading TOWA fields: {0}", ex.Message);
|
|
}
|
|
saveMessages.Add(towd);
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region TIEFA
|
|
case "TIEFA":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
TIEFA newTIEFA = new TIEFA();
|
|
newTIEFA.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.TIEFA;
|
|
theMessage.Elements.Add(newTIEFA);
|
|
}
|
|
TIEFA tiefa = theMessage.Elements[0] as TIEFA;
|
|
derivedMessage = tiefa;
|
|
if (tiefa != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("DraughtUponArrival_DMT")) tiefa.DraughtUponArrival_DMT = Extensions.TryParseDouble(vDict["DraughtUponArrival_DMT"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading TIEFA fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#endregion
|
|
|
|
#region TIEFD
|
|
case "TIEFD":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
TIEFD newTIEFD = new TIEFD();
|
|
newTIEFD.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.TIEFD;
|
|
theMessage.Elements.Add(newTIEFD);
|
|
}
|
|
TIEFD tiefd = theMessage.Elements[0] as TIEFD;
|
|
derivedMessage = tiefd;
|
|
if (tiefd != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("DraughtUponDeparture_DMT")) tiefd.DraughtUponDeparture_DMT = Extensions.TryParseDouble(vDict["DraughtUponDeparture_DMT"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading TIEFD fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#endregion
|
|
|
|
#region HAZ
|
|
case "HAZ":
|
|
{
|
|
if (theMessage.Elements.Count == 0)
|
|
{
|
|
HAZ newHaz = new HAZ();
|
|
newHaz.MessageHeader = theMessage;
|
|
theMessage.MessageNotificationClass = isDeparture ? Message.NotificationClass.HAZD : Message.NotificationClass.HAZA;
|
|
theMessage.Elements.Add(newHaz);
|
|
}
|
|
HAZ haz = theMessage.Elements[0] as HAZ;
|
|
derivedMessage = haz;
|
|
if (haz != null)
|
|
{
|
|
try
|
|
{
|
|
if (vDict.ContainsKey("NoDPGOnBoard")) haz.NoDPGOnBoardOnArrival = vDict["NoDPGOnBoard"].Equals("Y");
|
|
if (vDict.ContainsKey("DPGManifestOnBoard")) haz.DPGManifestOnBoardOnArrival = vDict["DPGManifestOnBoard"].Equals("Y");
|
|
if (vDict.ContainsKey("INFShipClass")) haz.INFShipClass = (byte)Enum.Parse(typeof(Enums.INFShipClass), vDict["INFShipClass"], true);
|
|
if (vDict.ContainsKey("DPGClassificationIMDG")) haz.DPGClassificationIMDG = vDict["DPGClassificationIMDG"].Equals("1");
|
|
if (vDict.ContainsKey("DPGClassificationIGC")) haz.DPGClassificationIMDG = vDict["DPGClassificationIGC"].Equals("1");
|
|
if (vDict.ContainsKey("DPGClassificationIBC")) haz.DPGClassificationIMDG = vDict["DPGClassificationIBC"].Equals("1");
|
|
if (vDict.ContainsKey("DPGClassificationIMSBC")) haz.DPGClassificationIMDG = vDict["DPGClassificationIMSBC"].Equals("1");
|
|
if (vDict.ContainsKey("DPGClassificationMARPOL_ANNEX_I")) haz.DPGClassificationIMDG = vDict["DPGClassificationMARPOL_ANNEX_I"].Equals("1");
|
|
if (vDict.ContainsKey("TransmissionType"))
|
|
{
|
|
_log.DebugFormat("TransmissionType: {0}", vDict["TransmissionType"]);
|
|
}
|
|
|
|
Dictionary<int, Dictionary<string, string>> subDict = null;
|
|
if (groupedRowVals.ContainsKey("HAZ.IMDG"))
|
|
{
|
|
subDict = groupedRowVals["HAZ.IMDG"];
|
|
foreach (int key in subDict.Keys)
|
|
{
|
|
Dictionary<string, string> aDict = subDict[key];
|
|
if (aDict.Count > 0)
|
|
{
|
|
IMDGPosition imdgPosition = haz.GetIMDGPositionWithIdentifier(key.ToString());
|
|
if (imdgPosition == null)
|
|
{
|
|
imdgPosition = new IMDGPosition();
|
|
imdgPosition.Identifier = key.ToString();
|
|
haz.IMDGPositions.Add(imdgPosition);
|
|
imdgPosition.HAZ = haz;
|
|
}
|
|
|
|
saveMessages.Add(imdgPosition);
|
|
|
|
if (aDict.ContainsKey("UNNumber")) imdgPosition.UNNumber = aDict["UNNumber"];
|
|
if (aDict.ContainsKey("PackingGroup")) imdgPosition.PackingGroup = (byte)Enum.Parse(typeof(Enums.PackingGroup), aDict["PackingGroup"], true);
|
|
if (aDict.ContainsKey("ProperShippingName")) imdgPosition.ProperShippingName = aDict["ProperShippingName"];
|
|
if (aDict.ContainsKey("IMOClass")) imdgPosition.IMOClass = aDict["IMOClass"];
|
|
if (aDict.ContainsKey("CompatibilityGroup")) imdgPosition.CompatibilityGroup = aDict["CompatibilityGroup"];
|
|
if (aDict.ContainsKey("TechnicalName")) imdgPosition.TechnicalName = aDict["TechnicalName"];
|
|
if (aDict.ContainsKey("NetExplosiveMass_KGM")) imdgPosition.NetExplosiveMass_KGM = Extensions.TryParseDouble(aDict["NetExplosiveMass_KGM"]);
|
|
if (aDict.ContainsKey("Flashpoint_CEL")) imdgPosition.Flashpoint_CEL = aDict["Flashpoint_CEL"];
|
|
if (aDict.ContainsKey("Class7NuclideName")) imdgPosition.Class7NuclideName = aDict["Class7NuclideName"];
|
|
if (aDict.ContainsKey("Class7MaxActivity_BQL")) imdgPosition.Class7MaxActivity_BQL = Extensions.TryParseDouble(aDict["Class7MaxActivity_BQL"]);
|
|
if (aDict.ContainsKey("Class7Category")) imdgPosition.Class7Category = Int32.Parse(aDict["Class7Category"], NumberFormatInfo.InvariantInfo);
|
|
if (aDict.ContainsKey("Class7TransportIndex")) imdgPosition.Class7TransportIndex = Extensions.TryParseDouble(aDict["Class7TransportIndex"]);
|
|
if (aDict.ContainsKey("Class7CSI")) imdgPosition.Class7CSI = Int32.Parse(aDict["Class7CSI"]);
|
|
if (aDict.ContainsKey("ControlTemperature_CEL")) imdgPosition.ControlTemperature_CEL = Extensions.TryParseDouble(aDict["ControlTemperature_CEL"]);
|
|
if (aDict.ContainsKey("EmergencyTemperature_CEL")) imdgPosition.EmergencyTemperature_CEL = Extensions.TryParseDouble(aDict["EmergencyTemperature_CEL"]);
|
|
if (aDict.ContainsKey("SubsidiaryRisk"))
|
|
{
|
|
if (imdgPosition.SubsidiaryRiskList.Count == 0)
|
|
{
|
|
SubsidiaryRisks newSRisk = new SubsidiaryRisks();
|
|
newSRisk.IMDGPosition = imdgPosition;
|
|
imdgPosition.SubsidiaryRiskList.Add(newSRisk);
|
|
}
|
|
SubsidiaryRisks sRisks = imdgPosition.SubsidiaryRiskList[0];
|
|
sRisks.SubsidiaryRisk = aDict["SubsidiaryRisk"];
|
|
saveMessages.Add(sRisks);
|
|
}
|
|
if (aDict.ContainsKey("MarinePollutant")) imdgPosition.MarinePollutant = aDict["MarinePollutant"].Equals("Y");
|
|
if (aDict.ContainsKey("NumberOfPackages")) imdgPosition.NumberOfPackages = Int32.Parse(aDict["NumberOfPackages"]);
|
|
if (aDict.ContainsKey("PackageType")) imdgPosition.PackageType = aDict["PackageType"];
|
|
if (aDict.ContainsKey("LimitedQuantities")) imdgPosition.LimitedQuantities = aDict["LimitedQuantities"].Equals("Y");
|
|
if (aDict.ContainsKey("ExceptedQuantities")) imdgPosition.ExceptedQuantities = aDict["ExceptedQuantities"].Equals("Y");
|
|
if (aDict.ContainsKey("NetQuantity_KGM")) imdgPosition.NetQuantity_KGM = Extensions.TryParseDouble(aDict["NetQuantity_KGM"]);
|
|
if (aDict.ContainsKey("GrossQuantity_KGM")) imdgPosition.GrossQuantity_KGM = Extensions.TryParseDouble(aDict["GrossQuantity_KGM"]);
|
|
if (aDict.ContainsKey("Volume_MTQ")) imdgPosition.Volume_MTQ = Extensions.TryParseDouble(aDict["Volume_MTQ"]);
|
|
if (aDict.ContainsKey("GeneralCargoIBC")) imdgPosition.GeneralCargoIBC = aDict["GeneralCargoIBC"].Equals("Y");
|
|
if (aDict.ContainsKey("ContainerNumber")) imdgPosition.ContainerNumber = aDict["ContainerNumber"];
|
|
if (aDict.ContainsKey("VehicleLicenseNumber")) imdgPosition.VehicleLicenseNumber = aDict["VehicleLicenseNumber"];
|
|
if (aDict.ContainsKey("StowagePosition")) imdgPosition.StowagePosition = aDict["StowagePosition"];
|
|
if (aDict.ContainsKey("PortCodeOfLoading") && aDict.ContainsKey("CountryCodeOfLoading"))
|
|
imdgPosition.PortOfLoading = aDict["CountryCodeOfLoading"] + aDict["PortCodeOfLoading"];
|
|
if (aDict.ContainsKey("PortCodeOfDischarge") && aDict.ContainsKey("CountryCodeOfDischarge"))
|
|
imdgPosition.PortOfDischarge = aDict["CountryCodeOfDischarge"] + aDict["PortCodeOfDischarge"];
|
|
if (aDict.ContainsKey("Remarks")) imdgPosition.Remarks = aDict["Remarks"];
|
|
if (aDict.ContainsKey("Identifier"))
|
|
{
|
|
_log.InfoFormat("Igoring IMDGPosition identifer {0}, using row number {1} instead",
|
|
aDict["Identifier"], key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (groupedRowVals.ContainsKey("HAZ.IBC"))
|
|
{
|
|
subDict = groupedRowVals["HAZ.IBC"];
|
|
foreach (int key in subDict.Keys)
|
|
{
|
|
Dictionary<string, string> aDict = subDict[key];
|
|
if (aDict.Count > 0)
|
|
{
|
|
IBCPosition ibcPosition = haz.GetIBCPositionWithIdentifier(key.ToString());
|
|
if (ibcPosition == null)
|
|
{
|
|
ibcPosition = new IBCPosition();
|
|
ibcPosition.Identifier = key.ToString();
|
|
haz.IBCPositions.Add(ibcPosition);
|
|
ibcPosition.HAZ = haz;
|
|
}
|
|
|
|
if (aDict.ContainsKey("ProductName")) ibcPosition.ProductName = aDict["ProductName"];
|
|
if (aDict.ContainsKey("PollutionCategory")) ibcPosition.PollutionCategory = (byte)Enum.Parse(typeof(Enums.PollutionCategory), aDict["PollutionCategory"], true);
|
|
if (aDict.ContainsKey("Hazards")) ibcPosition.Hazards = Enums.ParseHazardType(aDict["Hazards"]);
|
|
if (aDict.ContainsKey("FlashpointInformation")) ibcPosition.FlashpointInformation = Enums.ParseFlashpointInformation(aDict["FlashpointInformation"]);
|
|
if (aDict.ContainsKey("Quantity_KGM")) ibcPosition.Quantity_KGM = Extensions.TryParseDouble(aDict["Quantity_KGM"]);
|
|
if (aDict.ContainsKey("StowagePosition")) ibcPosition.StowagePosition = aDict["StowagePosition"];
|
|
if (aDict.ContainsKey("PortCodeOfLoading") && aDict.ContainsKey("CountryCodeOfLoading"))
|
|
ibcPosition.PortOfLoading = aDict["CountryCodeOfLoading"] + aDict["PortCodeOfLoading"];
|
|
if (aDict.ContainsKey("PortCodeOfDischarge") && aDict.ContainsKey("CountryCodeOfDischarge"))
|
|
ibcPosition.PortOfDischarge = aDict["CountryCodeOfDischarge"] + aDict["PortCodeOfDischarge"];
|
|
if (aDict.ContainsKey("Remarks")) ibcPosition.Remarks = aDict["Remarks"];
|
|
if (aDict.ContainsKey("Identifier"))
|
|
{
|
|
_log.InfoFormat("Igoring IMDGPosition identifer {0}, using row number {1} instead",
|
|
aDict["Identifier"], key);
|
|
}
|
|
|
|
saveMessages.Add(ibcPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (groupedRowVals.ContainsKey("HAZ.IGC"))
|
|
{
|
|
subDict = groupedRowVals["HAZ.IGC"];
|
|
foreach (int key in subDict.Keys)
|
|
{
|
|
Dictionary<string, string> aDict = subDict[key];
|
|
if (aDict.Count > 0)
|
|
{
|
|
IGCPosition igcPosition = haz.GetIGCPositionWithIdentifier(key.ToString());
|
|
if (igcPosition == null)
|
|
{
|
|
igcPosition = new IGCPosition();
|
|
igcPosition.Identifier = key.ToString();
|
|
haz.IGCPositions.Add(igcPosition);
|
|
igcPosition.HAZ = haz;
|
|
}
|
|
|
|
if (aDict.ContainsKey("UNNumber")) igcPosition.UNNumber = aDict["UNNumber"];
|
|
if (aDict.ContainsKey("IMOClass")) igcPosition.IMOClass = aDict["IMOClass"];
|
|
if (aDict.ContainsKey("ProductName")) igcPosition.ProductName = aDict["ProductName"];
|
|
if (aDict.ContainsKey("Quantity_KGM")) igcPosition.Quantity_KGM = Extensions.TryParseDouble(aDict["Quantity_KGM"]);
|
|
if (aDict.ContainsKey("StowagePosition")) igcPosition.StowagePosition = aDict["StowagePosition"];
|
|
if (aDict.ContainsKey("PortCodeOfLoading") && aDict.ContainsKey("CountryCodeOfLoading"))
|
|
igcPosition.PortOfLoading = aDict["CountryCodeOfLoading"] + aDict["PortCodeOfLoading"];
|
|
if (aDict.ContainsKey("PortCodeOfDischarge") && aDict.ContainsKey("CountryCodeOfDischarge"))
|
|
igcPosition.PortOfDischarge = aDict["CountryCodeOfDischarge"] + aDict["PortCodeOfDischarge"];
|
|
if (aDict.ContainsKey("Remarks")) igcPosition.Remarks = aDict["Remarks"];
|
|
if (aDict.ContainsKey("Identifier"))
|
|
{
|
|
_log.InfoFormat("Igoring IMDGPosition identifer {0}, using row number {1} instead",
|
|
aDict["Identifier"], key);
|
|
}
|
|
|
|
saveMessages.Add(igcPosition);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if (groupedRowVals.ContainsKey("HAZ.IMSBC"))
|
|
{
|
|
subDict = groupedRowVals["HAZ.IMSBC"];
|
|
foreach (int key in subDict.Keys)
|
|
{
|
|
Dictionary<string, string> aDict = subDict[key];
|
|
if (aDict.Count > 0)
|
|
{
|
|
IMSBCPosition imsbcPosition = haz.GetIMSBCPositionWithIdentifier(key.ToString());
|
|
if (imsbcPosition == null)
|
|
{
|
|
imsbcPosition = new IMSBCPosition();
|
|
imsbcPosition.Identifier = key.ToString();
|
|
imsbcPosition.HAZ = haz;
|
|
haz.IMSBCPositions.Add(imsbcPosition);
|
|
}
|
|
|
|
if (aDict.ContainsKey("BulkCargoShippingName")) imsbcPosition.BulkCargoShippingName = aDict["BulkCargoShippingName"];
|
|
if (aDict.ContainsKey("MHB")) imsbcPosition.MHB = aDict["MHB"].Equals("Y");
|
|
if (aDict.ContainsKey("UNNumber")) imsbcPosition.UNNumber = aDict["UNNumber"];
|
|
if (aDict.ContainsKey("IMOClass")) imsbcPosition.IMOClass = aDict["IMOClass"];
|
|
if (aDict.ContainsKey("Quantity_KGM")) imsbcPosition.Quantity_KGM = Extensions.TryParseDouble(aDict["Quantity_KGM"]);
|
|
if (aDict.ContainsKey("StowagePosition")) imsbcPosition.StowagePosition = aDict["StowagePosition"];
|
|
if (aDict.ContainsKey("PortCodeOfLoading") && aDict.ContainsKey("CountryCodeOfLoading"))
|
|
imsbcPosition.PortOfLoading = aDict["CountryCodeOfLoading"] + aDict["PortCodeOfLoading"];
|
|
if (aDict.ContainsKey("PortCodeOfDischarge") && aDict.ContainsKey("CountryCodeOfDischarge"))
|
|
imsbcPosition.PortOfDischarge = aDict["CountryCodeOfDischarge"] + aDict["PortCodeOfDischarge"];
|
|
if (aDict.ContainsKey("Remarks")) imsbcPosition.Remarks = aDict["Remarks"];
|
|
if (aDict.ContainsKey("Identifier"))
|
|
{
|
|
_log.InfoFormat("Igoring IMDGPosition identifer {0}, using row number {1} instead",
|
|
aDict["Identifier"], key);
|
|
}
|
|
|
|
saveMessages.Add(imsbcPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (groupedRowVals.ContainsKey("HAZ.MARPOLAnnexI"))
|
|
{
|
|
subDict = groupedRowVals["HAZ.MARPOLAnnexI"];
|
|
foreach (int key in subDict.Keys)
|
|
{
|
|
Dictionary<string, string> aDict = subDict[key];
|
|
if (aDict.Count > 0)
|
|
{
|
|
MARPOL_Annex_I_Position marpolPosition = haz.GetMARPOLPositionWithIdentifier(key.ToString());
|
|
if (marpolPosition == null)
|
|
{
|
|
marpolPosition = new MARPOL_Annex_I_Position();
|
|
marpolPosition.Identifier = key.ToString();
|
|
marpolPosition.HAZ = haz;
|
|
haz.MARPOLPositions.Add(marpolPosition);
|
|
}
|
|
|
|
if (aDict.ContainsKey("Name")) marpolPosition.Name = aDict["Name"];
|
|
if (aDict.ContainsKey("FlashpointInformation")) marpolPosition.FlashpointInformation = Enums.ParseFlashpointInformation(aDict["FlashpointInformation"]);
|
|
if (aDict.ContainsKey("Flashpoint_CEL")) marpolPosition.Flashpoint_CEL = aDict["Flashpoint_CEL"];
|
|
if (aDict.ContainsKey("Quantity_KGM")) marpolPosition.Quantity_KGM = Extensions.TryParseDouble(aDict["Quantity_KGM"]);
|
|
if (aDict.ContainsKey("StowagePosition")) marpolPosition.StowagePosition = aDict["StowagePosition"];
|
|
if (aDict.ContainsKey("PortCodeOfLoading") && aDict.ContainsKey("CountryCodeOfLoading"))
|
|
marpolPosition.PortOfLoading = aDict["CountryCodeOfLoading"] + aDict["PortCodeOfLoading"];
|
|
if (aDict.ContainsKey("PortCodeOfDischarge") && aDict.ContainsKey("CountryCodeOfDischarge"))
|
|
marpolPosition.PortOfDischarge = aDict["CountryCodeOfDischarge"] + aDict["PortCodeOfDischarge"];
|
|
if (aDict.ContainsKey("Remarks")) marpolPosition.Remarks = aDict["Remarks"];
|
|
if (aDict.ContainsKey("Identifier"))
|
|
{
|
|
_log.InfoFormat("Igoring IMDGPosition identifer {0}, using row number {1} instead",
|
|
aDict["Identifier"], key);
|
|
}
|
|
|
|
saveMessages.Add(marpolPosition);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading HAZ fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
}
|
|
|
|
// Die Logik dient dazu, dass bei "leeren" Nachrichten (also z.B. MDH ohne MDH Infos) nicht nur der
|
|
// Header gespeichert wird und danach in der Luft hängt
|
|
if ((theMessage.MessageNotificationClass == Message.NotificationClass.VISIT) ||
|
|
(theMessage.MessageNotificationClass == Message.NotificationClass.TRANSIT) ||
|
|
(derivedMessage != null) ||
|
|
(saveMessages.Count > 0)
|
|
)
|
|
{
|
|
// clear validation info for this message
|
|
if (!theMessage.IsNew)
|
|
{
|
|
DBManager.Instance.DeleteMessageErrors(theMessage);
|
|
DBManager.Instance.DeleteMessageViolations(theMessage);
|
|
}
|
|
|
|
DBManager.Instance.Save(theMessage);
|
|
theMessage.MessageCore = aMessageCore;
|
|
// now let's validate the message
|
|
ruleEngine.Validate(theMessage);
|
|
|
|
if (derivedMessage != null)
|
|
DBManager.Instance.Save(derivedMessage);
|
|
foreach (DatabaseEntity saveEntity in saveMessages)
|
|
DBManager.Instance.Save(saveEntity);
|
|
}
|
|
}
|
|
|
|
DBManager.Instance.Save(aMessageCore);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aufbereitung eines Dictionaries: Nachrichtentyp (aus Feld-Präfixen) zu eigentlichen Nachrichten
|
|
/// </summary>
|
|
private static Dictionary<string, Message> PrepareMessageDict(MessageCore aMessageCore)
|
|
{
|
|
List<Message> messages = DBManager.Instance.GetMessagesForCore(aMessageCore);
|
|
Dictionary<string, Message> result = new Dictionary<string, Message>();
|
|
_log.DebugFormat("Core has {0} messages", messages.Count);
|
|
foreach (Message message in messages)
|
|
{
|
|
if (!result.ContainsKey(message.MessageNotificationClass.ToString()))
|
|
{
|
|
result.Add(message.MessageNotificationClass.ToString(), message);
|
|
}
|
|
else
|
|
{
|
|
// es gibt schon einen Nachricht mit diesem Typ.
|
|
// Das kann nur der Fall sein wenn es schon eine Cancel/Reset Nachricht gegeben hat. In diesem Fall wird eine
|
|
// Nachricht überschrieben, wenn beide Flags nicht gesetzt sind
|
|
if (!message.Reset && !message.Cancel)
|
|
{
|
|
result[message.MessageNotificationClass.ToString()] = message;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|