public ITVTDatabase LoadXML(string filename, ITVTDatabase database, TVTDataRoot dataRoot)
        {
            var result = database;
            //int version = 0;
            //DatabaseVersion dbVersion = DatabaseVersion.V2;
            //TVTDataContent defaultType = TVTDataContent.FakeWithRefId;

            var doc = new XmlDocument();

            doc.Load(filename);

            var versionElement = doc.GetElementsByTagName("version");

            if (versionElement[0].HasAttribute("value"))
            {
                var version = versionElement[0].GetAttributeInteger("value");
                if (version != 2)
                {
                    throw new NotSupportedException("Only database version '2' is supported.");
                }
            }

            {
                var movies    = new List <MovieOldV2>();
                var allMovies = doc.GetElementsByTagName("allmovies");

                foreach (XmlNode xmlMovie in allMovies)
                {
                    foreach (XmlNode childNode in xmlMovie.ChildNodes)
                    {
                        switch (childNode.Name)
                        {
                        case "movie":
                            movies.AddRange(LoadMovie(childNode, true));
                            break;

                        default:
                            throw new NotSupportedException("Only 'movie'-tags are supported.");
                        }
                    }
                }
                OldV2Converter.Convert(movies, database, dataRoot);
            }

            {
                var series    = new List <MovieOldV2>();
                var allSeries = doc.GetElementsByTagName("allseries");

                foreach (XmlNode xmlSeries in allSeries)
                {
                    foreach (XmlNode childNode in xmlSeries.ChildNodes)
                    {
                        switch (childNode.Name)
                        {
                        case "serie":
                            series.AddRange(LoadMovie(childNode, true));
                            break;

                        default:
                            throw new NotSupportedException("Only 'serie'-tags are supported.");
                        }
                    }
                }
                OldV2Converter.Convert(series, database, dataRoot);
            }

            {
                var news    = new List <NewsOldV2>();
                var allNews = doc.GetElementsByTagName("allnews");

                foreach (XmlNode xmlNews in allNews)
                {
                    foreach (XmlNode childNode in xmlNews.ChildNodes)
                    {
                        switch (childNode.Name)
                        {
                        case "news":
                            news.AddRange(LoadNews(childNode, true));
                            break;

                        default:
                            throw new NotSupportedException("Only 'news'-tags are supported.");
                        }
                    }
                }
                OldV2Converter.Convert(news, database, dataRoot);
            }

            {
                var ads     = new List <AdvertisingOldV2>();
                var allNews = doc.GetElementsByTagName("allads");

                foreach (XmlNode xmlNews in allNews)
                {
                    foreach (XmlNode childNode in xmlNews.ChildNodes)
                    {
                        switch (childNode.Name)
                        {
                        case "ad":
                            ads.Add(LoadAd(childNode, true));
                            break;

                        default:
                            throw new NotSupportedException("Only 'news'-tags are supported.");
                        }
                    }
                }
                OldV2Converter.Convert(ads, database, dataRoot);
            }

            database.RefreshReferences();

            OldV2Converter.RefreshMovieDescriptions(database);

            return(result);
        }
        public static void Convert(List <AdvertisingOldV2> adsOldV2, ITVTDatabase database, TVTDataRoot dataRoot)
        {
            foreach (var adSrc in adsOldV2)
            {
                var ad = new TVTAdvertising();
                ad.DataRoot = dataRoot;

                ConvertCommonMinimal(adSrc, ad, database);
                ad.DescriptionDE = adSrc.description;
                ad.DescriptionEN = adSrc.descriptionEnglish;

                ad.CreatorId    = adSrc.creatorID;
                ad.EditorId     = adSrc.editorID;
                ad.LastModified = new DateTime(2004, 1, 1);

                ad.FixPrice    = (adSrc.fixedProfit > 0);
                ad.MinAudience = ConvertOldToNewValueFloat(adSrc.minAudience);
                ad.MinImage    = ConvertOldToNewValue(adSrc.minImage);
                ad.Repetitions = adSrc.repetitions;
                ad.Duration    = adSrc.duration;
                ad.Profit      = ConvertProfitPenalty(adSrc.profit, adSrc.fixedProfit > 0, adSrc.fixedProfit);
                ad.Penalty     = ConvertProfitPenalty(adSrc.penalty, adSrc.fixedPenalty > 0, adSrc.fixedPenalty);

                ad.TargetGroup = ConvertTargetGroup(adSrc.targetgroup);

                ad.Approved = adSrc.approved;

                database.AddAdvertising(ad);
            }
        }
        public static void Convert(List <NewsOldV2> newsOldV2, ITVTDatabase database, TVTDataRoot dataRoot)
        {
            foreach (var newsSrc in newsOldV2)
            {
                var news = new TVTNews();
                news.DataRoot = dataRoot;

                ConvertCommonMinimal(newsSrc, news, database);

                if (newsSrc.parentID == 0)
                {
                    news.NewsType     = TVTNewsType.InitialNews;
                    news.NewsThreadId = newsSrc.id.ToString();
                    news.Tag          = -1;
                }
                else
                {
                    news.NewsType     = TVTNewsType.FollowingNews;
                    news.NewsThreadId = newsSrc.parentID.ToString();
                    news.Tag          = newsSrc.episode;
                }

                //PossibleFollower - erst später ermitteln;
                news.Genre = (TVTNewsGenre)newsSrc.genre;

                news.AvailableAfterDays       = -1;
                news.YearRangeFrom            = -1;
                news.YearRangeTo              = -1;
                news.MinHoursAfterPredecessor = -1;
                news.TimeRangeFrom            = -1;
                news.TimeRangeTo              = -1;

                news.Price   = ConvertOldToNewValue(newsSrc.price);
                news.Quality = ConvertOldToNewValue(newsSrc.topicality);

                news.Resource1Type = null;
                news.Resource2Type = null;
                news.Resource3Type = null;
                news.Resource4Type = null;

                database.AddNews(news);
            }

            var allNews = database.GetAllNews();

            List <string> threadsDone = new List <string>();

            //Episoden-ID fixen
            foreach (var news in allNews)
            {
                if (!threadsDone.Contains(news.NewsThreadId))
                {
                    var newsThread = allNews.Where(x => x.NewsThreadId == news.NewsThreadId);

                    var start = newsThread.FirstOrDefault(x => (int)x.Tag == -1);
                    start.Tag = 0;

                    var rest = newsThread.ToList();
                    rest.Remove(start);

                    var episode = 1;
                    foreach (var restNews in rest.OrderBy(x => x.Tag).ToList())
                    {
                        restNews.Tag = episode;
                        episode++;
                    }

                    threadsDone.Add(news.NewsThreadId);
                }
            }

            foreach (var news in allNews)
            {
                var episode = (int)news.Tag;

                TVTNews follower = allNews.FirstOrDefault(x => x.NewsThreadId == news.NewsThreadId && (int)x.Tag == episode + 1);
                if (follower != null)
                {
                    follower.NewsType = TVTNewsType.FollowingNews;
                    news.Effects.Add(new TVTNewsEffect(TVTNewsEffectType.TriggerNews, follower.Id.ToString()));
                }
                else
                {
                    if (news.NewsThreadId == news.OldId)
                    {
                        news.NewsType = TVTNewsType.InitialNews;
                    }
                    else
                    {
                        news.NewsType = TVTNewsType.FollowingNews;
                    }
                }
            }

            foreach (var news in allNews)
            {
                //if ( news.NewsType == TVTNewsType.SingleNews )
                //    news.NewsThreadId = null;
                //else
                //{
                TVTNews thread_owner = allNews.FirstOrDefault(x => x.OldId == news.NewsThreadId);
                news.NewsThreadId = thread_owner.Id.ToString();
                //}
            }
        }
        public static void Convert(List <MovieOldV2> moviesOldV2, ITVTDatabase database, TVTDataRoot dataRoot)
        {
            foreach (var movSrc in moviesOldV2)
            {
                if (movSrc.parentID == 0)                   //Film
                {
                    var programme = new TVTProgramme();
                    programme.DataRoot      = dataRoot;
                    programme.ProductType   = TVTProductType.Programme;
                    programme.ProgrammeType = TVTProgrammeType.Movie;
                    programme.Approved      = movSrc.approved;

                    ConvertEpisode(movSrc, programme, database);

                    programme.CriticsRate = ConvertOldToNewValue(movSrc.critics);
                    programme.ViewersRate = ConvertOldToNewValue(movSrc.speed);
                    programme.PriceMod    = ((float)movSrc.price) / 150;
                    if (programme.PriceMod == 0.0)
                    {
                        programme.PriceMod = 1;
                    }
                    else if (programme.PriceMod > 10)
                    {
                        programme.PriceMod = 10;
                    }

                    programme.BoxOfficeRate = ConvertOldToNewValue(movSrc.outcome);

                    programme.Year    = movSrc.year;
                    programme.Country = movSrc.country;
                    programme.Blocks  = movSrc.blocks;

                    ConvertGenreAndFlags(programme, movSrc);

                    if (programme.Flags.Contains(TVTProgrammeFlag.Live) && movSrc.time > 0)
                    {
                        programme.LiveHour = movSrc.time;
                    }

                    if (movSrc.xrated)
                    {
                        programme.Flags.Add(TVTProgrammeFlag.XRated);
                    }

                    database.AddProgramme(programme);
                }
                else                 //Serien-Episode
                {
                    var episode = new TVTProgramme();
                    episode.DataRoot      = dataRoot;
                    episode.ProductType   = TVTProductType.Episode;
                    episode.ProgrammeType = TVTProgrammeType.Movie;
                    episode.Approved      = movSrc.approved;
                    ConvertEpisode(movSrc, episode, database);

                    episode.Tag = movSrc.parentID.ToString();

                    episode.CriticsRate = ConvertOldToNewValue(movSrc.critics);
                    if (episode.CriticsRate == 0)
                    {
                        episode.CriticsRate = -1;
                    }
                    episode.ViewersRate = ConvertOldToNewValue(movSrc.speed);
                    if (episode.ViewersRate == 0)
                    {
                        episode.ViewersRate = -1;
                    }
                    episode.EpisodeIndex = movSrc.episode;

                    episode.DistributionChannel = TVTDistributionChannel.Inherit;
                    episode.MainGenre           = TVTProgrammeGenre.Inherit;
                    episode.SubGenre            = TVTProgrammeGenre.Inherit;
                    episode.Flags.Add(TVTProgrammeFlag.Inhert);

                    episode.LiveHour = -1;

                    episode.TargetGroups.Add(TVTTargetGroup.Inhert);
                    episode.ProPressureGroups.Add(TVTPressureGroup.Inhert);
                    episode.ContraPressureGroups.Add(TVTPressureGroup.Inhert);

                    database.AddProgramme(episode);
                }
            }

            //Nachträglich die Parents auf IsSeries setzen
            var allMovies = database.GetAllProgrammes(true);

            foreach (var current in database.GetAllEpisodes())
            {
                var series = allMovies.FirstOrDefault(x => x.OldId.CompareTo(current.Tag) == 0);
                if (series != null)
                {
                    series.ProductType   = TVTProductType.Series;
                    current.SeriesMaster = new CodeKnight.Core.WeakReference <TVTProgramme>(series);
                }
                else
                {
                    current.DataStatus = TVTDataStatus.Incorrect;
                }
            }
        }