public void AddStatisticsValue(StatisticsType type, int value)
        {
            var aClass = new RouteAirlinerClass(
                AirlinerClass.ClassType.EconomyClass,
                RouteAirlinerClass.SeatingType.FreeSeating,
                0);

            AddStatisticsValue(aClass, type, value);
        }
        //returns the value for a statistics type for a route class
        public long GetStatisticsValue(RouteAirlinerClass aClass, StatisticsType type)
        {
            RouteStatisticsItem item =
                Stats.Find(i => i.Type.Shortname == type.Shortname && i.RouteClass.Type == aClass.Type);

            if (item == null)
            {
                return 0;
            }
            return item.Value;
        }
        public void AddStatisticsValue(RouteAirlinerClass aClass, StatisticsType type, int value)
        {
            RouteStatisticsItem item = Stats.Find(
                i => i.Type.Shortname == type.Shortname && i.RouteClass == aClass);

            if (item == null)
            {
                Stats.Add(new RouteStatisticsItem(aClass, type, value));
            }
            else
            {
                item.Value += value;
            }
        }
        public PassengerRoute(
            string id,
            Airport destination1,
            Airport destination2,
            DateTime startDate,
            double farePrice)
            : base(RouteType.Passenger, id, destination1, destination2, startDate)
        {
            Classes = new List<RouteAirlinerClass>();

            foreach (AirlinerClass.ClassType ctype in Enum.GetValues(typeof (AirlinerClass.ClassType)))
            {
                var cl = new RouteAirlinerClass(ctype, RouteAirlinerClass.SeatingType.ReservedSeating, farePrice);

                Classes.Add(cl);
            }
        }
        //loads a route
        private static Route LoadRoute(
            XmlElement routeNode,
            Airline airline,
            Route.RouteType routetype = Route.RouteType.Passenger)
        {
            string id = routeNode.Attributes["id"].Value;
            Airport dest1 = Airports.GetAirport(routeNode.Attributes["destination1"].Value);
            Airport dest2 = Airports.GetAirport(routeNode.Attributes["destination2"].Value);
            Boolean isBanned = Convert.ToBoolean(routeNode.Attributes["isbanned"].Value);

            if (routeNode.HasAttribute("type"))
            {
                routetype = (Route.RouteType) Enum.Parse(typeof (Route.RouteType), routeNode.Attributes["type"].Value);
            }

            Route route;

            if (routetype == Route.RouteType.Passenger || routetype == Route.RouteType.Mixed)
            {
                route = new PassengerRoute(id, dest1, dest2, DateTime.Now, 0);
            }
            else
            {
                route = new CargoRoute(id, dest1, dest2, DateTime.Now, 0);
            }

            route.Banned = isBanned;

            /* foreach (StopoverRoute stopover in route.Stopovers)
            {
                XmlElement routeStopoverNode = xmlDoc.CreateElement("stopover");
                routeStopoverNode.SetAttribute("airport", stopover.Stopover.Profile.ID);

                XmlElement stopoverLegsNode = xmlDoc.CreateElement("legs");
                foreach (Route leg in stopover.Legs)
                {
                    XmlElement stopoverLegNode = xmlDoc.CreateElement("leg");

                    stopoverLegNode.AppendChild(SaveRoute(xmlDoc, leg));

                    stopoverLegsNode.AppendChild(stopoverLegNode);
                }
                routeStopoverNode.AppendChild(stopoverLegsNode);
                routeStopoversNode.AppendChild(routeStopoverNode);*/

            XmlNodeList routeStopoverList = routeNode.SelectNodes("stopovers/stopover");

            if (routeStopoverList != null)
                foreach (XmlElement routeStopoverNode in routeStopoverList)
                {
                    Airport stopoverAirport = Airports.GetAirportFromID(routeStopoverNode.Attributes["airport"].Value);

                    var stopoverRoute = new StopoverRoute(stopoverAirport);

                    XmlNodeList legsList = routeStopoverNode.SelectNodes("legs/leg");

                    if (legsList != null)
                        foreach (XmlElement legNode in legsList)
                        {
                            stopoverRoute.AddLeg(LoadRoute((XmlElement) legNode.SelectSingleNode("route"), airline, routetype));
                        }

                    route.AddStopover(stopoverRoute);
                }

            if (routetype == Route.RouteType.Passenger || routetype == Route.RouteType.Mixed)
            {
                ((PassengerRoute) route).Classes.Clear();

                XmlNodeList routeClassList = routeNode.SelectNodes("routeclasses/routeclass");

                if (routeClassList != null)
                    foreach (XmlElement routeClassNode in routeClassList)
                    {
                        var airlinerClassType =
                            (AirlinerClass.ClassType)
                            Enum.Parse(typeof (AirlinerClass.ClassType), routeClassNode.Attributes["type"].Value);
                        double fareprice = Convert.ToDouble(
                            routeClassNode.Attributes["fareprice"].Value,
                            new CultureInfo("de-DE", false));
                        var seatingType =
                            (RouteAirlinerClass.SeatingType)
                            Enum.Parse(
                                typeof (RouteAirlinerClass.SeatingType),
                                routeClassNode.Attributes["seating"].Value);

                        var rClass = new RouteAirlinerClass(
                            airlinerClassType,
                            RouteAirlinerClass.SeatingType.ReservedSeating,
                            fareprice) {Seating = seatingType};

                        foreach (RouteFacility.FacilityType ftype in Enum.GetValues(typeof (RouteFacility.FacilityType)))
                        {
                            if (routeClassNode.HasAttribute(ftype.ToString()))
                            {
                                RouteFacility facility =
                                    RouteFacilities.GetFacility(routeClassNode.Attributes[ftype.ToString()].Value);
                                rClass.AddFacility(facility);
                            }
                        }

                        ((PassengerRoute) route).AddRouteAirlinerClass(rClass);
                    }
            }
            if (routetype == Route.RouteType.Mixed || routetype == Route.RouteType.Cargo)
            {
                var routeCargoNode = (XmlElement) routeNode.SelectSingleNode("cargo");
                if (routeCargoNode != null)
                {
                    double unitPrice = Convert.ToDouble(
                        routeCargoNode.Attributes["priceperunit"].Value,
                        new CultureInfo("de-DE", false));

                    ((CargoRoute) route).PricePerUnit = unitPrice;
                }
            }

            var timeTable = new RouteTimeTable(route);

            XmlNodeList timetableList = routeNode.SelectNodes("timetable/timetableentry");

            if (timetableList != null)
                foreach (XmlElement entryNode in timetableList)
                {
                    Airport entryDest = Airports.GetAirport(entryNode.Attributes["destination"].Value);
                    string flightCode = entryNode.Attributes["flightcode"].Value;
                    var day = (DayOfWeek) Enum.Parse(typeof (DayOfWeek), entryNode.Attributes["day"].Value);
                    TimeSpan time = TimeSpan.Parse(entryNode.Attributes["time"].Value);
                    FleetAirliner airliner = entryNode.Attributes["airliner"].Value == "-"
                                                 ? null
                                                 : airline.Fleet.Find(a => a.Airliner.ID == entryNode.Attributes["airliner"].Value);

                    var entry = new RouteTimeTableEntry(
                        timeTable,
                        day,
                        time,
                        new RouteEntryDestination(entryDest, flightCode, null),
                        null);

                    if (entryNode.HasAttribute("id"))
                    {
                        entry.ID = entryNode.Attributes["id"].Value;
                    }

                    if (entryNode.HasAttribute("mainentry"))
                    {
                        entry.MainEntry =
                            airline.Routes.SelectMany(r => r.TimeTable.Entries)
                                   .ToList()
                                   .Find(e => e.ID == entryNode.Attributes["mainentry"].Value);
                    }

                    entry.Airliner = airliner;

                    if (airliner != null && !airliner.Routes.Contains(route))
                    {
                        airliner.Routes.Add(route);
                    }

                    timeTable.AddEntry(entry);
                }
            route.TimeTable = timeTable;

            XmlNodeList routeInvoiceList = routeNode.SelectNodes("invoices/invoice");

            if (routeInvoiceList != null)
                foreach (XmlElement routeInvoiceNode in routeInvoiceList)
                {
                    var type =
                        (Invoice.InvoiceType)
                        Enum.Parse(typeof (Invoice.InvoiceType), routeInvoiceNode.Attributes["type"].Value);
                    int invoiceYear = Convert.ToInt16(routeInvoiceNode.Attributes["year"].Value);
                    int invoiceMonth = Convert.ToInt16(routeInvoiceNode.Attributes["month"].Value);
                    double invoiceAmount = Convert.ToDouble(
                        routeInvoiceNode.Attributes["amount"].Value,
                        new CultureInfo("de-DE", false));

                    route.SetRouteInvoice(type, invoiceYear, invoiceMonth, 1, invoiceAmount);
                }

            return route;
        }
 //adds a route airliner class to the route
 public void AddRouteAirlinerClass(RouteAirlinerClass aClass)
 {
     Classes.Add(aClass);
 }
        public long GetStatisticsValue(StatisticsType type)
        {
            var aClass = new RouteAirlinerClass(
                AirlinerClass.ClassType.EconomyClass,
                RouteAirlinerClass.SeatingType.FreeSeating,
                0);

            return GetStatisticsValue(aClass, type);
        }
 public RouteStatisticsItem(RouteAirlinerClass routeClass, StatisticsType type, int value)
 {
     RouteClass = routeClass;
     Type = type;
     Value = value;
 }
 public FlightAirlinerClass(RouteAirlinerClass aClass, int passengers)
 {
     AirlinerClass = aClass;
     Passengers = passengers;
 }
        public MVVMRouteClass(AirlinerClass.ClassType type, RouteAirlinerClass.SeatingType seating, double fareprice)
        {
            Type = type;
            Seating = seating;
            FarePrice = fareprice;

            Facilities = new ObservableCollection<MVVMRouteFacility>();

            foreach (RouteFacility.FacilityType facType in Enum.GetValues(typeof(RouteFacility.FacilityType)))
            {

                if (GameObject.GetInstance().GameTime.Year >= (int)facType)
                {
                    var facs = new List<RouteFacility>();
                    foreach (RouteFacility fac in RouteFacilities.GetFacilities(facType))
                    {
                        facs.Add(fac);
                    }

                    var facility = new MVVMRouteFacility(facType, facs);

                    Facilities.Add(facility);
                }
            }
        }