Пример #1
0
        /// <summary>
        /// Read data from file
        /// </summary>
        /// <param name="addBlankLineInEmptyTable"></param>
        /// <returns></returns>
        internal Data_Schema.DepartureWebDataTable DepartureReadHistoryFromFile(bool addBlankLineInEmptyTable)
        {
            string fileName = Utils.CreatePhysicalFileName(Constants.FileName.DepartureShow);

            Data_Schema.DepartureWebDataTable history = Utils.DataTableReadFromFile(fileName, new Data_Schema.DepartureWebDataTable()) as Data_Schema.DepartureWebDataTable;
            if ((history == null) && addBlankLineInEmptyTable)
            {
                history = new Data_Schema.DepartureWebDataTable();
                history.AddDepartureWebRow(0L, DateTime.MaxValue, "", "", "", "", "", "", "", "", "", "", 0L, 0, "", "", "", "", "", DateTime.MaxValue);
            }
            return(history);
        }
Пример #2
0
        public Data_Schema.DepartureWebDataTable GetAllDeparture()
        {
            string   fileName        = Utils.CreatePhysicalFileName(Constants.FileName.DepartureActualTimeStamp);
            DateTime latestTimestamp = Utils.TimeStampRead(fileName);

            if (latestTimestamp.AddSeconds(_refreshTime) > DateTime.Now)
            {
                Data_Schema.DepartureWebDataTable dataFromCache = DepartureReadHistoryFromFile(false);
                if (dataFromCache != null)
                {
                    return(dataFromCache);
                }
            }
            string dataXMLFromWeb = ReadSourceData(false);

            if (!string.IsNullOrWhiteSpace(dataXMLFromWeb))
            {
                return(DepartureAppendHistoryToActualReadData(ConvertToDeparture(dataXMLFromWeb)));
            }
            return(new Data_Schema.DepartureWebDataTable());
        }
Пример #3
0
 /// <summary>
 /// Fill historical data
 /// </summary>
 /// <param name="actualDataReadFromService"></param>
 /// <returns></returns>
 internal Data_Schema.DepartureWebDataTable DepartureAppendHistoryToActualReadData(Data_Schema.DepartureWebDataTable actualDataReadFromService)
 {
     Data_Schema.DepartureWebDataTable departureHistoryDataFromFile;
     lock (departureLock)
     {
         departureHistoryDataFromFile = DepartureReadHistoryFromFile(false);
         if (departureHistoryDataFromFile == null)
         {
             departureHistoryDataFromFile = new Data_Schema.DepartureWebDataTable();
         }
         DateTime    minimalDateForRemember = DateTime.Now.AddHours(-_history);
         List <long> ListOfFlightID         = actualDataReadFromService.AsEnumerable().Select(Selrow => Selrow.Field <long>("FLIGHTID")).ToList();
         if (ListOfFlightID == null)
         {
             ListOfFlightID = new List <long>();
         }
         Data_Schema.DepartureWebRow rowForShowOnWeb;
         for (int i = departureHistoryDataFromFile.Rows.Count; i > 0; i--)
         {
             rowForShowOnWeb = departureHistoryDataFromFile.Rows[i - 1] as Data_Schema.DepartureWebRow;
             if (rowForShowOnWeb != null)
             {
                 if (ListOfFlightID.Contains(rowForShowOnWeb.FLIGHTID))
                 {
                     departureHistoryDataFromFile.Rows.RemoveAt(i - 1);
                 }
                 else if (rowForShowOnWeb.TIME_LT < minimalDateForRemember)
                 {
                     departureHistoryDataFromFile.Rows.RemoveAt(i - 1);
                 }
             }
         }
         foreach (Data_Schema.DepartureWebRow rowActualReadFromService in actualDataReadFromService.Rows)
         {
             rowForShowOnWeb          = departureHistoryDataFromFile.NewDepartureWebRow();
             rowForShowOnWeb.FLIGHTID = rowActualReadFromService.FLIGHTID;
             rowForShowOnWeb.TIME_LT  = rowActualReadFromService.TIME_LT;
             rowForShowOnWeb.ICAO_AIR = rowActualReadFromService.ICAO_AIR;
             rowForShowOnWeb.IATAICAO = rowActualReadFromService.IATAICAO;
             rowForShowOnWeb.FLGTNUM  = rowActualReadFromService.FLGTNUM;
             rowForShowOnWeb.S1       = rowActualReadFromService.S1;
             rowForShowOnWeb.S1CIT    = rowActualReadFromService.S1CIT;
             rowForShowOnWeb.PARID    = rowActualReadFromService.PARID;
             if (!rowActualReadFromService.IsAIRCRFTNull())
             {
                 rowForShowOnWeb.AIRCRFT = rowActualReadFromService.AIRCRFT;
             }
             if (!rowActualReadFromService.IsHALNull())
             {
                 rowForShowOnWeb.HAL = rowActualReadFromService.HAL;
             }
             if (!rowActualReadFromService.IsHDGNull())
             {
                 rowForShowOnWeb.HDG = rowActualReadFromService.HDG;
             }
             if (!rowActualReadFromService.IsORDERNull())
             {
                 rowForShowOnWeb.ORDER = rowActualReadFromService.ORDER;
             }
             if (!rowActualReadFromService.IsREMARKNull())
             {
                 rowForShowOnWeb.REMARK = rowActualReadFromService.REMARK;
             }
             if (!rowActualReadFromService.IsS2CITNull())
             {
                 rowForShowOnWeb.S2CIT = rowActualReadFromService.S2CIT;
             }
             if (!rowActualReadFromService.IsS2Null())
             {
                 rowForShowOnWeb.S2 = rowActualReadFromService.S2;
             }
             if (!rowActualReadFromService.IsATD_LTNull())
             {
                 rowForShowOnWeb.ATD_LT = rowActualReadFromService.ATD_LT;
             }
             if (!rowActualReadFromService.IsGATE1Null())
             {
                 rowForShowOnWeb.GATE1 = rowActualReadFromService.GATE1;
             }
             if (!rowActualReadFromService.IsGATE2Null())
             {
                 rowForShowOnWeb.GATE2 = rowActualReadFromService.GATE2;
             }
             if (!rowActualReadFromService.IsCHIN_FNull())
             {
                 rowForShowOnWeb.CHIN_F = rowActualReadFromService.CHIN_F;
             }
             if (!rowActualReadFromService.IsCHIN_LNull())
             {
                 rowForShowOnWeb.CHIN_L = rowActualReadFromService.CHIN_L;
             }
             departureHistoryDataFromFile.AddDepartureWebRow(rowForShowOnWeb);
         }
         string fileName = Utils.CreatePhysicalFileName(Constants.FileName.DepartureShow);
         Utils.DataTableWriteToFile(fileName, departureHistoryDataFromFile);
     }
     return(departureHistoryDataFromFile);
 }
Пример #4
0
        public Data_Schema.DepartureShowDataTable DepartureData()
        {
            Data_Schema.DepartureShowDataTable    tableToShow         = new Data_Schema.DepartureShowDataTable();
            Dictionary <long, ShareCodeDeparture> shareCodeDictionary = new Dictionary <long, ShareCodeDeparture>();
            Hashtable ht = new Hashtable();

            Data_Schema.DepartureWebDataTable sourceTableFromWebAndCache = GetAllDeparture();
            if (sourceTableFromWebAndCache == null)
            {
                logger.Error(Constants.LoggerMessages.ProxyWebSourceError, Constants.CommonConst.TextDeparture);
                sourceTableFromWebAndCache = DepartureReadHistoryFromFile(true);
            }
            Data_Schema.DepartureShowRow rowShow;
            foreach (Data_Schema.DepartureWebRow rowSourceTableFromWebAndCache in sourceTableFromWebAndCache.Rows)
            {
                switch (rowSourceTableFromWebAndCache.ORDER)
                {
                case 1:
                    rowShow = tableToShow.NewDepartureShowRow();
                    if (shareCodeDictionary.ContainsKey(rowSourceTableFromWebAndCache.FLIGHTID))
                    {
                        shareCodeDictionary[rowSourceTableFromWebAndCache.FLIGHTID].MASTERROW = rowShow;
                    }
                    else
                    {
                        shareCodeDictionary.Add(rowSourceTableFromWebAndCache.FLIGHTID, new ShareCodeDeparture(rowShow));
                    }
                    tableToShow.AddDepartureShowRow(CopyLineDeparture(rowSourceTableFromWebAndCache, rowShow));
                    break;

                case 0:
                    tableToShow.AddDepartureShowRow(CopyLineDeparture(rowSourceTableFromWebAndCache, tableToShow.NewDepartureShowRow()));
                    break;

                case 2:
                    if (shareCodeDictionary.ContainsKey(rowSourceTableFromWebAndCache.PARID))
                    {
                        shareCodeDictionary[rowSourceTableFromWebAndCache.PARID].IATAICAO.Add(rowSourceTableFromWebAndCache.IATAICAO);
                        shareCodeDictionary[rowSourceTableFromWebAndCache.PARID].ICAO_AIR.Add(rowSourceTableFromWebAndCache.ICAO_AIR);
                        shareCodeDictionary[rowSourceTableFromWebAndCache.PARID].FLGTNUM.Add(rowSourceTableFromWebAndCache.FLGTNUM);
                    }
                    else
                    {
                        shareCodeDictionary.Add(rowSourceTableFromWebAndCache.PARID, new ShareCodeDeparture(rowSourceTableFromWebAndCache.IATAICAO, rowSourceTableFromWebAndCache.ICAO_AIR, rowSourceTableFromWebAndCache.FLGTNUM));
                    }

                    break;

                default:
                    logger.Warn(Constants.LoggerMessages.ProxyOrderBadValue, Constants.CommonConst.TextDeparture, rowSourceTableFromWebAndCache.PARID);
                    break;
                }
            }
            foreach (ShareCodeDeparture shareCode in shareCodeDictionary.Values)
            {
                if (shareCode.MASTERROW != null)
                {
                    shareCode.MASTERROW.FLGTSHARE = Utils.ConvertListToString(shareCode.FLGTNUM, Constants.CommonConst.SelectorNewLine);
                    shareCode.MASTERROW.ICAO_AIR  = Utils.ConvertListToStringICAO(shareCode.MASTERROW.IATAICAO, shareCode.MASTERROW.ICAO_AIR, shareCode.IATAICAO,
                                                                                  shareCode.ICAO_AIR, Constants.CommonConst.SelectorDash, Constants.CommonConst.SelectorNewLine);
                }
            }
            tableToShow.AddDepartureShowRow(-1, "", "", "", DateTime.Now, "", "", "", "", "", "", "", "", "", "", "", "", "");
            tableToShow.DefaultView.Sort             = "TIME_LT";
            tableToShow.DefaultView.ApplyDefaultSort = true;
            return(tableToShow);
        }
Пример #5
0
        /// <summary>
        /// Convert departure string to desired DataTable
        /// </summary>
        /// <param name="dataReadFromWebInXMLFormat">Incoming stream</param>
        /// <returns>DataTable or DataTable.Empty when no data to parse or error ocure</returns>
        internal Data_Schema.DepartureWebDataTable ConvertToDeparture(string dataReadFromWebInXMLFormat)
        {
            Data_Schema.DepartureWebDataTable tableConvertedFromXML = new Data_Schema.DepartureWebDataTable();
            Data_Schema.DepartureWebRow       rowCinvertedFromXML;
            XmlDocument xmlDocumentReadFromService = new XmlDocument();

            xmlDocumentReadFromService.LoadXml(dataReadFromWebInXMLFormat);
            XmlNode     xRoot = xmlDocumentReadFromService.DocumentElement;
            XmlNodeList xListContentFromSourceXML = xRoot.SelectNodes("/*/Content");
            string      actualDate = DateTime.Now.ToString("dd.MM.yyyy");

            foreach (XmlNode nodeInContentPartXML in xListContentFromSourceXML)
            {
                rowCinvertedFromXML = tableConvertedFromXML.NewDepartureWebRow();
                if (nodeInContentPartXML.SelectNodes("DATE_LT").Count > 0)
                {
                    actualDate = nodeInContentPartXML.SelectSingleNode("DATE_LT").InnerText;
                }
                foreach (XmlNode xOneRecordInContentPartXML in nodeInContentPartXML.ChildNodes)
                {
                    switch (xOneRecordInContentPartXML.Name.ToUpper())
                    {
                    case "FLIGHTID":
                        rowCinvertedFromXML.FLIGHTID = Utils.ConvertStringToLong(xOneRecordInContentPartXML.InnerText, 0L);
                        break;

                    case "TIME_LT":
                        rowCinvertedFromXML.TIME_LT = Utils.ConvertHHMM(xOneRecordInContentPartXML.InnerText, rowCinvertedFromXML.TIME_LT);
                        break;

                    case "DATE_LT":
                        rowCinvertedFromXML.TIME_LT = Utils.ConvertDDMMYYY(xOneRecordInContentPartXML.InnerText, rowCinvertedFromXML.TIME_LT);
                        break;

                    case "ICAO_AIR":
                        rowCinvertedFromXML.ICAO_AIR = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "IATAICAO":
                        rowCinvertedFromXML.IATAICAO = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "FLGTNUM":
                        rowCinvertedFromXML.FLGTNUM = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "ORDER":
                        rowCinvertedFromXML.ORDER = Utils.ConvertStringToInt(xOneRecordInContentPartXML.InnerText, 0);
                        break;

                    case "S1":
                        rowCinvertedFromXML.S1 = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "S1CIT":
                        rowCinvertedFromXML.S1CIT = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "S2":
                        rowCinvertedFromXML.S2 = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "S2CIT":
                        rowCinvertedFromXML.S2CIT = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "HAL":
                        rowCinvertedFromXML.HAL = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "CHIN_F":
                        rowCinvertedFromXML.CHIN_F = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "CHIN_L":
                        rowCinvertedFromXML.CHIN_L = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "REMARK":
                        rowCinvertedFromXML.REMARK = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "GATE1":
                        rowCinvertedFromXML.GATE1 = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "GATE2":
                        rowCinvertedFromXML.GATE2 = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "HDG":
                        rowCinvertedFromXML.HDG = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "AIRCRFT":
                        rowCinvertedFromXML.AIRCRFT = xOneRecordInContentPartXML.InnerText;
                        break;

                    case "ATD_LT":
                        rowCinvertedFromXML.ATD_LT = Utils.ConvertHHMM(xOneRecordInContentPartXML.InnerText, DateTime.Now);
                        rowCinvertedFromXML.ATD_LT = Utils.ConvertDDMMYYY(actualDate, rowCinvertedFromXML.ATD_LT);
                        break;

                    case "PARID":
                        rowCinvertedFromXML.PARID = Utils.ConvertStringToLong(xOneRecordInContentPartXML.InnerText, 0L);
                        break;

                    default:
                        logger.Warn(Constants.LoggerMessages.ProxyXmlNodeName, xOneRecordInContentPartXML.Name, xOneRecordInContentPartXML.InnerText);
                        break;
                    }
                }

                tableConvertedFromXML.AddDepartureWebRow(rowCinvertedFromXML);
            }

            return(tableConvertedFromXML);
        }