1155 lines
81 KiB
C#
1155 lines
81 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 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)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
for (int i = 0; i < formResponse.formDatasets.Length; i++)
|
|
{
|
|
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];
|
|
|
|
if (fds.startPeriodSpecified)
|
|
Trace.WriteLine(fds.startPeriod);
|
|
Trace.WriteLine(string.Format("Dataset {0}", i));
|
|
foreach (WebReference.FormData formData in fds.formData)
|
|
{
|
|
string[] nElems = formData.name.Split('.');
|
|
if (nElems.Length != 2)
|
|
{
|
|
_log.WarnFormat("Field name {0} has wrong format!", formData.name);
|
|
continue;
|
|
}
|
|
|
|
// create dictionaries on demand
|
|
if (!groupedVals.ContainsKey(nElems[0]))
|
|
groupedVals[nElems[0]] = new Dictionary<string, string>();
|
|
if (!groupedRowVals.ContainsKey(nElems[0]))
|
|
groupedRowVals[nElems[0]] = new Dictionary<int, Dictionary<string, string>>();
|
|
if (!groupedRowVals[nElems[0]].ContainsKey(formData.rowNo))
|
|
groupedRowVals[nElems[0]][formData.rowNo] = new Dictionary<string, string>();
|
|
|
|
if (formData.rowNoSpecified == false)
|
|
{
|
|
// "normale" Felder werden pro Nachrichtentyp in einem Dict abgespeichert
|
|
|
|
groupedVals[nElems[0]][nElems[1]] = 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[nElems[0]][formData.rowNo][nElems[1]] = 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 messageType in groupedVals.Keys)
|
|
{
|
|
Dictionary<string, string> vDict = groupedVals[messageType];
|
|
Dictionary<int, Dictionary<string, string>> nDict = groupedRowVals[messageType];
|
|
|
|
DatabaseEntity derivedMessage = null;
|
|
saveMessages.Clear();
|
|
|
|
Message theMessage = null;
|
|
if (!messages.ContainsKey(messageType.ToUpper()))
|
|
{
|
|
theMessage = new Message();
|
|
if (messageType.Equals("HAZ")) continue; // HE spezial, sollte HAZA o. HAZD sein
|
|
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
|
|
}
|
|
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.InfoFormat("found message type {0}", messageType);
|
|
theMessage = messages[messageType.ToUpper()];
|
|
}
|
|
|
|
switch (messageType)
|
|
{
|
|
#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 = DateTime.Parse(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 = DateTime.Parse(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 = DateTime.Parse(vDict["ETAToNextPort"]);
|
|
if (vDict.ContainsKey("ETDFromLastPort")) noa_nod.ETDFromLastPort = DateTime.Parse(vDict["ETDFromLastPort"]);
|
|
if (vDict.ContainsKey("ETAToPortOfCall")) noa_nod.ETAToPortOfCall = DateTime.Parse(vDict["ETAToPortOfCall"]);
|
|
if (vDict.ContainsKey("ETDFromPortOfCall")) noa_nod.ETDFromPortOfCall = DateTime.Parse(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 = DateTime.Parse(vDict["ETAToKielCanal"]);
|
|
if (vDict.ContainsKey("ETDFromKielCanal")) noa_nod.ETDFromKielCanal = DateTime.Parse(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];
|
|
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 = (float)Double.Parse(vDict["LengthOverall_MTR"]);
|
|
if (vDict.ContainsKey("Beam_MTR")) stat.Beam_MTR = (float)Double.Parse(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"];
|
|
}
|
|
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 = DateTime.Parse(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 = DateTime.Parse(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 = DateTime.Parse(vDict["InfectedAreaDate"]);
|
|
|
|
// sublisten
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
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 = DateTime.Parse(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 (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 = DateTime.Parse(ppDict["PortOfItineraryETA"]);
|
|
|
|
saveMessages.Add(poi);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading BPOL fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region BKRA
|
|
case "BKRA":
|
|
{
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> bDict = nDict[key];
|
|
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 = (float)Double.Parse(bDict["BunkerFuelQuantity_TNE"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading BKRA fields: {0}", ex.Message);
|
|
}
|
|
saveMessages.Add(bkra);
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region SERV
|
|
case "SERV":
|
|
{
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
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);
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region CREW
|
|
case "CREW":
|
|
{
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
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 = DateTime.Parse(pDict["CrewMemberDateOfBirth"]);
|
|
if (pDict.ContainsKey("CrewMemberGender")) crew.CrewMemberGender = (byte)Enum.Parse(typeof(Enums.PassengerGender), pDict["CrewMemberGender"], true);
|
|
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);
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region BKRD
|
|
case "BKRD":
|
|
{
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> bDict = nDict[key];
|
|
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 = (float)Double.Parse(bDict["BunkerFuelQuantity_TNE"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading BKRD fields: {0}", ex.Message);
|
|
}
|
|
|
|
saveMessages.Add(bkrd);
|
|
}
|
|
}
|
|
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 (vDict.ContainsKey("ConstructionCharacteristicsOfShip")) info.ConstructionCharacteristicsOfShip = vDict["ConstructionCharacteristicsOfShip"];
|
|
if (vDict.ContainsKey("FumigatedBulkCargo")) info.FumigatedBulkCargo = (byte)Enum.Parse(typeof(Enums.FumigatedBulkCargo), vDict["FumigatedBulkCargo"]);
|
|
}
|
|
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");
|
|
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 = (float)Double.Parse(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 = DateTime.Parse(vDict["DateOfLastExpandedInspection"], DateTimeFormatInfo.InvariantInfo);
|
|
if (vDict.ContainsKey("PlannedPeriodOfStay_HUR")) pre72h.PlannedPeriodOfStay_HUR = (float)Double.Parse(vDict["PlannedPeriodOfStay_HUR"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading PRE72H fields: {0}", ex.Message);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region LADG
|
|
case "LADG":
|
|
{
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> lDict = nDict[key];
|
|
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 = (float)Double.Parse(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);
|
|
}
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region PAS
|
|
case "PAS":
|
|
{
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> pDict = nDict[key];
|
|
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 = DateTime.Parse(pDict["PassengerDateOfBirth"]);
|
|
if (pDict.ContainsKey("PassengerGender")) pas.PassengerGender = (byte)Enum.Parse(typeof(Enums.PassengerGender), pDict["PassengerGender"], true);
|
|
if (pDict.ContainsKey("PassengerNationalityCode")) pas.PassengerNationality = pDict["PassengerNationalityCode"];
|
|
if (pDict.ContainsKey("PassengerIdentityDocumentType")) pas.PassengerIdentityDocumentType = (byte)Enum.Parse(typeof(Enums.PassengerIdentityDocumentType), pDict["PassengerIdentityDocumentType"]);
|
|
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);
|
|
}
|
|
}
|
|
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 = DateTime.Parse(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)
|
|
{
|
|
waste = new Waste();
|
|
waste.Identifier = key.ToString();
|
|
waste.WAS = was;
|
|
was.Waste.Add(waste);
|
|
}
|
|
|
|
if(wDict.ContainsKey("WasteAmountGeneratedTillNextPort_MTQ")) waste.WasteAmountGeneratedTillNextPort_MTQ = (float) Double.Parse(wDict["WasteAmountGeneratedTillNextPort_MTQ"]);
|
|
if(wDict.ContainsKey("WasteAmountRetained_MTQ")) waste.WasteAmountRetained_MTQ = (float) Double.Parse(wDict["WasteAmountRetained_MTQ"]);
|
|
if(wDict.ContainsKey("WasteCapacity_MTQ")) waste.WasteCapacity_MTQ = (float) Double.Parse(wDict["WasteCapacity_MTQ"]);
|
|
if(wDict.ContainsKey("WasteDisposalAmount_MTQ")) waste.WasteDisposalAmount_MTQ = (float) Double.Parse(wDict["WasteDisposalAmount_MTQ"]);
|
|
if(wDict.ContainsKey("WasteDescription")) waste.WasteDescription = wDict["WasteDescription"];
|
|
if(wDict.ContainsKey("WasteType")) waste.WasteType = Enums.ParseWasteType(wDict["WasteType"]);
|
|
if(wDict.ContainsKey("WasteDisposalPort")) waste.WasteDisposalPort = wDict["WasteDisposalPort"];
|
|
|
|
saveMessages.Add(waste);
|
|
}
|
|
|
|
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"]);
|
|
if (vDict.ContainsKey("ISSCIssuerType")) sec.ISSCIssuerType = (byte)Enum.Parse(typeof(Enums.ISSCIssuerType), vDict["ISSCIssuerType"]);
|
|
if (vDict.ContainsKey("ISSCIssuerName")) sec.ISSCIssuerName = vDict["ISSCIssuerName"];
|
|
if (vDict.ContainsKey("ISSCDateOfExpiration")) sec.ISSCDateOfExpiration = DateTime.Parse(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("PortFacilityOfArrival")) sec.PortFacilityOfArrival = vDict["PortFacilityOfArrival"];
|
|
if (vDict.ContainsKey("GeneralDescriptionOfCargo")) sec.GeneralDescriptionOfCargo = (byte)Enum.Parse(typeof(Enums.GeneralDescriptionOfCargo), vDict["GeneralDescriptionOfCargo"]);
|
|
|
|
// process sublists
|
|
|
|
foreach (int key in nDict.Keys)
|
|
{
|
|
Dictionary<string, string> sDict = nDict[key];
|
|
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"))
|
|
{
|
|
poc.PortFacilityPortLoCode = sDict["PortFacilityPortCountryCode"] + sDict["PortFacilityPortLoCode"];
|
|
changedPfC = true;
|
|
}
|
|
if (sDict.ContainsKey("PortFacilityDateOfArrival")) { poc.PortFacilityDateOfArrival = DateTime.Parse(sDict["PortFacilityDateOfArrival"]); changedPfC = true; }
|
|
if (sDict.ContainsKey("PortFacilityDateOfDeparture")) { poc.PortFacilityDateOfDeparture = DateTime.Parse(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 (sDict.ContainsKey("ShipToShipActivityLocationName")) { sts.ShipToShipActivityLocationName = sDict["ShipToShipActivityLocationName"]; changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivityLocationLoCode") && sDict.ContainsKey("ShipToShipActivityCountryCode"))
|
|
{
|
|
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 = DateTime.Parse(sDict["ShipToShipActivityDateFrom"]); changedStS = true; }
|
|
if (sDict.ContainsKey("ShipToShipActivityDateTo")) { sts.ShipToShipActivityDateTo = DateTime.Parse(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 = DateTime.Parse(vDict["ETAPortOfCall"]);
|
|
if (vDict.ContainsKey("ETAKielCanal")) aMessageCore.ETAKielCanal = DateTime.Parse(vDict["ETAKielCanal"]);
|
|
}
|
|
break;
|
|
#endregion
|
|
|
|
#region Transit
|
|
case "Transit":
|
|
{
|
|
theMessage.MessageNotificationClass = Message.NotificationClass.TRANSIT;
|
|
if (vDict.ContainsKey("ETAKielCanal")) aMessageCore.ETAKielCanal = DateTime.Parse(vDict["ETAKielCanal"]);
|
|
}
|
|
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 = (float)Double.Parse(pDict["TowageOnArrivalBeam_MTR"]);
|
|
if (pDict.ContainsKey("TowageOnArrivalDraught_DMT")) towa.TowageOnArrivalDraught_DMT = (float)Double.Parse(pDict["TowageOnArrivalDraught_DMT"]);
|
|
if (pDict.ContainsKey("TowageOnArrivalLengthOverall_MTR")) towa.TowageOnArrivalLengthOverall_MTR = (float)Double.Parse(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 = (float)Double.Parse(pDict["TowageOnDepartureBeam_MTR"]);
|
|
if (pDict.ContainsKey("TowageOnDepartureDraught_DMT")) towd.TowageOnDepartureDraught_DMT = (float)Double.Parse(pDict["TowageOnDepartureDraught_DMT"]);
|
|
if (pDict.ContainsKey("TowageOnDepartureLengthOverall_MTR")) towd.TowageOnDepartureLengthOverall_MTR = (float)Double.Parse(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 = (float)Double.Parse(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 = (float)Double.Parse(vDict["DraughtUponDeparture_DMT"]);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.ErrorFormat("Error reading TIEFD 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)
|
|
)
|
|
{
|
|
DBManager.Instance.Save(theMessage);
|
|
if (derivedMessage != null)
|
|
DBManager.Instance.Save(derivedMessage);
|
|
foreach (DatabaseEntity saveEntity in saveMessages)
|
|
DBManager.Instance.Save(saveEntity);
|
|
}
|
|
}
|
|
|
|
DBManager.Instance.Save(aMessageCore); // warum?
|
|
}
|
|
}
|
|
|
|
/// <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.InfoFormat("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;
|
|
}
|
|
}
|
|
}
|