Esempio n. 1
0
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            var userDataUserId = _config.GetNfoConfiguration().UserId;

            switch (reader.Name)
            {
            // DateCreated
            case "dateadded":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime added;
                    if (DateTime.TryParseExact(val, BaseNfoSaver.DateAddedFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out added))
                    {
                        item.EndDate = added.ToUniversalTime();
                    }
                    else if (DateTime.TryParse(val, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.Warn("Invalid Added value found: " + val);
                    }
                }
                break;
            }

            case "originaltitle":
            {
                var val = reader.ReadElementContentAsString();

                var hasOriginalTitle = item as IHasOriginalTitle;
                if (hasOriginalTitle != null)
                {
                    if (!string.IsNullOrEmpty(hasOriginalTitle.OriginalTitle))
                    {
                        hasOriginalTitle.OriginalTitle = val;
                    }
                }
                break;
            }

            case "type":
                item.DisplayMediaType = reader.ReadElementContentAsString();
                break;

            case "title":
            case "localtitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "criticrating":
            {
                var text = reader.ReadElementContentAsString();

                var hasCriticRating = item as IHasCriticRating;

                if (hasCriticRating != null && !string.IsNullOrEmpty(text))
                {
                    float value;
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasCriticRating.CriticRating = value;
                    }
                }

                break;
            }

            case "budget":
            {
                var text      = reader.ReadElementContentAsString();
                var hasBudget = item as IHasBudget;
                if (hasBudget != null)
                {
                    double value;
                    if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasBudget.Budget = value;
                    }
                }

                break;
            }

            case "revenue":
            {
                var text      = reader.ReadElementContentAsString();
                var hasBudget = item as IHasBudget;
                if (hasBudget != null)
                {
                    double value;
                    if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasBudget.Revenue = value;
                    }
                }

                break;
            }

            case "metascore":
            {
                var text         = reader.ReadElementContentAsString();
                var hasMetascore = item as IHasMetascore;
                if (hasMetascore != null)
                {
                    float value;
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasMetascore.Metascore = value;
                    }
                }

                break;
            }

            case "awardsummary":
            {
                var text      = reader.ReadElementContentAsString();
                var hasAwards = item as IHasAwards;
                if (hasAwards != null)
                {
                    if (!string.IsNullOrWhiteSpace(text))
                    {
                        hasAwards.AwardSummary = text;
                    }
                }

                break;
            }

            case "sorttitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }
                break;
            }

            case "outline":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasShortOverview = item as IHasShortOverview;

                    if (hasShortOverview != null)
                    {
                        hasShortOverview.ShortOverview = val;
                    }
                }
                break;
            }

            case "biography":
            case "plot":
            case "review":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "criticratingsummary":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasCriticRating = item as IHasCriticRating;

                    if (hasCriticRating != null)
                    {
                        hasCriticRating.CriticRatingSummary = val;
                    }
                }

                break;
            }

            case "language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "countrycode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "website":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.HomePageUrl = val;
                }

                break;
            }

            case "lockedfields":
            {
                var fields = new List <MetadataFields>();

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var list = val.Split('|').Select(i =>
                        {
                            MetadataFields field;

                            if (Enum.TryParse <MetadataFields>(i, true, out field))
                            {
                                return((MetadataFields?)field);
                            }

                            return(null);
                        }).Where(i => i.HasValue).Select(i => i.Value);

                    fields.AddRange(list);
                }

                item.LockedFields = fields;

                break;
            }

            case "tagline":
            {
                var val = reader.ReadElementContentAsString();

                var hasTagline = item as IHasTaglines;
                if (hasTagline != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasTagline.AddTagline(val);
                    }
                }
                break;
            }

            case "country":
            {
                var val = reader.ReadElementContentAsString();

                var hasProductionLocations = item as IHasProductionLocations;
                if (hasProductionLocations != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        var parts = val.Split('/')
                                    .Select(i => i.Trim())
                                    .Where(i => !string.IsNullOrWhiteSpace(i));

                        foreach (var p in parts)
                        {
                            hasProductionLocations.AddProductionLocation(p);
                        }
                    }
                }
                break;
            }

            case "mpaa":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }
                break;
            }

            case "mpaadescription":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRatingDescription = rating;
                }
                break;
            }

            case "customrating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }
                break;
            }

            case "runtime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    int runtime;
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }
                break;
            }

            case "aspectratio":
            {
                var val = reader.ReadElementContentAsString();

                var hasAspectRatio = item as IHasAspectRatio;
                if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
                {
                    hasAspectRatio.AspectRatio = val;
                }
                break;
            }

            case "lockdata":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }
                break;
            }

            case "studio":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/')
                                .Select(i => i.Trim())
                                .Where(i => !string.IsNullOrWhiteSpace(i));

                    foreach (var p in parts)
                    {
                        item.AddStudio(p);
                    }
                }
                break;
            }

            case "director":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "credits":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/').Select(i => i.Trim())
                                .Where(i => !string.IsNullOrEmpty(i));

                    foreach (var p in parts.Select(v => new PersonInfo {
                            Name = v.Trim(), Type = PersonType.Writer
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }
                        itemResult.AddPerson(p);
                    }
                }
                break;
            }

            case "writer":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "actor":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    var person = GetPersonFromXmlNode(subtree);

                    if (!string.IsNullOrWhiteSpace(person.Name))
                    {
                        itemResult.AddPerson(person);
                    }
                }
                break;
            }

            case "trailer":
            {
                var val = reader.ReadElementContentAsString();

                var hasTrailer = item as IHasTrailers;
                if (hasTrailer != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        val = val.Replace("plugin://plugin.video.youtube/?action=play_video&videoid=", "http://www.youtube.com/watch?v=", StringComparison.OrdinalIgnoreCase);

                        hasTrailer.AddTrailerUrl(val, false);
                    }
                }
                break;
            }

            case "displayorder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }
                break;
            }

            case "year":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int productionYear;
                    if (int.TryParse(val, out productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "rating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    float val;
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out val))
                    {
                        item.CommunityRating = val;
                    }
                }
                break;
            }

            case "aired":
            case "formed":
            case "premiered":
            case "releasedate":
            {
                var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime date;

                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
                    {
                        item.PremiereDate   = date.ToUniversalTime();
                        item.ProductionYear = date.Year;
                    }
                }

                break;
            }

            case "enddate":
            {
                var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime date;

                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
                    {
                        item.EndDate = date.ToUniversalTime();
                    }
                }

                break;
            }

            case "tvdbid":
                var tvdbId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tvdbId))
                {
                    item.SetProviderId(MetadataProviders.Tvdb, tvdbId);
                }
                break;

            case "votes":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val))
                {
                    int num;

                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out num))
                    {
                        item.VoteCount = num;
                    }
                }
                break;
            }

            case "musicbrainzalbumid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzAlbum, mbz);
                }
                break;
            }

            case "musicbrainzalbumartistid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzAlbumArtist, mbz);
                }
                break;
            }

            case "musicbrainzartistid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzArtist, mbz);
                }
                break;
            }

            case "musicbrainzreleasegroupid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, mbz);
                }
                break;
            }

            case "tvrageid":
            {
                var id = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(id))
                {
                    item.SetProviderId(MetadataProviders.TvRage, id);
                }
                break;
            }

            case "audiodbartistid":
            {
                var id = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(id))
                {
                    item.SetProviderId(MetadataProviders.AudioDbArtist, id);
                }
                break;
            }

            case "audiodbalbumid":
            {
                var id = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(id))
                {
                    item.SetProviderId(MetadataProviders.AudioDbAlbum, id);
                }
                break;
            }

            case "rottentomatoesid":
                var rtId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(rtId))
                {
                    item.SetProviderId(MetadataProviders.RottenTomatoes, rtId);
                }
                break;

            case "tmdbid":
                var tmdb = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdb))
                {
                    item.SetProviderId(MetadataProviders.Tmdb, tmdb);
                }
                break;

            case "collectionnumber":
                var tmdbCollection = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdbCollection))
                {
                    item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
                }
                break;

            case "tvcomid":
                var TVcomId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(TVcomId))
                {
                    item.SetProviderId(MetadataProviders.Tvcom, TVcomId);
                }
                break;

            case "zap2itid":
                var zap2ItId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(zap2ItId))
                {
                    item.SetProviderId(MetadataProviders.Zap2It, zap2ItId);
                }
                break;

            case "imdb_id":
            case "imdbid":
                var imDbId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(imDbId))
                {
                    item.SetProviderId(MetadataProviders.Imdb, imDbId);
                }
                break;

            case "genre":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/')
                                .Select(i => i.Trim())
                                .Where(i => !string.IsNullOrWhiteSpace(i));

                    foreach (var p in parts)
                    {
                        item.AddGenre(p);
                    }
                }
                break;
            }

            case "style":
            case "tag":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasTags = item as IHasTags;
                    if (hasTags != null)
                    {
                        hasTags.AddTag(val);
                    }
                }
                break;
            }

            case "plotkeyword":
            {
                var val = reader.ReadElementContentAsString();

                var hasKeywords = item as IHasKeywords;
                if (hasKeywords != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasKeywords.AddKeyword(val);
                    }
                }
                break;
            }

            case "fileinfo":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromFileInfoNode(subtree, item);
                }
                break;
            }

            case "watched":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    bool parsedValue;
                    if (bool.TryParse(val, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.Played = parsedValue;
                    }
                }
                break;
            }

            case "playcount":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    int parsedValue;
                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.PlayCount = parsedValue;

                        if (parsedValue > 0)
                        {
                            userData.Played = true;
                        }
                    }
                }
                break;
            }

            case "lastplayed":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    DateTime parsedValue;
                    if (DateTime.TryParseExact(val, "yyyy-MM-dd HH:mm:ss", _usCulture, DateTimeStyles.AssumeLocal, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.LastPlayedDate = parsedValue.ToUniversalTime();
                    }
                }
                break;
            }

            case "resume":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    if (!string.IsNullOrWhiteSpace(userDataUserId))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        FetchFromResumeNode(subtree, item, userData);
                    }
                }
                break;
            }

            case "isuserfavorite":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    bool parsedValue;
                    if (bool.TryParse(val, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.IsFavorite = parsedValue;
                    }
                }
                break;
            }

            case "userrating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    double parsedValue;
                    if (double.TryParse(val, NumberStyles.Any, _usCulture, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.Rating = parsedValue;
                    }
                }
                break;
            }

            default:
                reader.Skip();
                break;
            }
        }
Esempio n. 2
0
        private void FetchAdditionalPartInfo(MetadataResult <Episode> result, XmlReader reader, CancellationToken cancellationToken)
        {
            var item = result.Item;

            // Use XmlReader for best performance
            using (reader)
            {
                reader.MoveToContent();

                // Loop through each element
                while (reader.Read())
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "EpisodeName":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Name))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Name += ", " + val;
                                }
                            }
                            break;
                        }

                        case "Overview":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Overview))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Overview += Environment.NewLine + Environment.NewLine + val;
                                }
                            }
                            break;
                        }

                        case "Director":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Director);
                                }
                            }

                            break;
                        }

                        case "GuestStars":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddGuestStars(result, val);
                                }
                            }

                            break;
                        }

                        case "Writer":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Writer);
                                }
                            }

                            break;
                        }

                        default:
                            reader.Skip();
                            break;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Gets the StockDetails.
        /// </summary>
        /// <param name="reader">The reader.</param>

        private StockDetails GetStockDetails(XmlReader reader)
        {
            if (reader == null)
            {
                throw new Exception("reader");
            }
            while (reader.NodeType != XmlNodeType.Element)
            {
                reader.Read();
            }
            if (reader.LocalName != "StockDetails")
            {
                throw new XmlException("Unexpected xml tag " + reader.LocalName);
            }
            reader.Read();
            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Read();
            }
            StockDetails stockDetails = new StockDetails();

            while (reader.LocalName != "StockDetails")
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.LocalName)
                    {
                    case "TradeNo":
                        stockDetails.TradeNo = reader.ReadElementContentAsString();
                        break;

                    case "CompanyName":
                        stockDetails.CompanyName = reader.ReadElementContentAsString();
                        break;

                    case "CostPrice":
                        stockDetails.CostPrice = reader.ReadElementContentAsString();
                        break;

                    case "SharesCount":
                        stockDetails.SharesCount = reader.ReadElementContentAsString();
                        break;

                    case "SalesPrice":
                        stockDetails.SalesPrice = reader.ReadElementContentAsString();
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    if ((reader.LocalName == "StockDetails") && reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }
                }
            }
            return(stockDetails);
        }
        private void AddImage(XmlReader reader, List <RemoteImageInfo> images)
        {
            reader.MoveToContent();

            string bannerType   = null;
            string url          = null;
            int?   bannerSeason = null;
            int?   width        = null;
            int?   height       = null;
            string language     = null;
            double?rating       = null;
            int?   voteCount    = null;
            string thumbnailUrl = null;

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "Rating":
                    {
                        var val = reader.ReadElementContentAsString() ?? string.Empty;

                        double rval;

                        if (double.TryParse(val, NumberStyles.Any, _usCulture, out rval))
                        {
                            rating = rval;
                        }

                        break;
                    }

                    case "RatingCount":
                    {
                        var val = reader.ReadElementContentAsString() ?? string.Empty;

                        int rval;

                        if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                        {
                            voteCount = rval;
                        }

                        break;
                    }

                    case "Language":
                    {
                        language = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "ThumbnailPath":
                    {
                        thumbnailUrl = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "BannerType":
                    {
                        bannerType = reader.ReadElementContentAsString() ?? string.Empty;

                        break;
                    }

                    case "BannerPath":
                    {
                        url = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "BannerType2":
                    {
                        var bannerType2 = reader.ReadElementContentAsString() ?? string.Empty;

                        // Sometimes the resolution is stuffed in here
                        var resolutionParts = bannerType2.Split('x');

                        if (resolutionParts.Length == 2)
                        {
                            int rval;

                            if (int.TryParse(resolutionParts[0], NumberStyles.Integer, _usCulture, out rval))
                            {
                                width = rval;
                            }

                            if (int.TryParse(resolutionParts[1], NumberStyles.Integer, _usCulture, out rval))
                            {
                                height = rval;
                            }
                        }

                        break;
                    }

                    case "Season":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            bannerSeason = int.Parse(val);
                        }
                        break;
                    }


                    default:
                        reader.Skip();
                        break;
                    }
                }
            }

            if (!string.IsNullOrEmpty(url) && !bannerSeason.HasValue)
            {
                var imageInfo = new RemoteImageInfo
                {
                    RatingType      = RatingType.Score,
                    CommunityRating = rating,
                    VoteCount       = voteCount,
                    Url             = TVUtils.BannerUrl + url,
                    ProviderName    = Name,
                    Language        = language,
                    Width           = width,
                    Height          = height
                };

                if (!string.IsNullOrEmpty(thumbnailUrl))
                {
                    imageInfo.ThumbnailUrl = TVUtils.BannerUrl + thumbnailUrl;
                }

                if (string.Equals(bannerType, "poster", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Primary;
                    images.Add(imageInfo);
                }
                else if (string.Equals(bannerType, "series", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Banner;
                    images.Add(imageInfo);
                }
                else if (string.Equals(bannerType, "fanart", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Backdrop;
                    images.Add(imageInfo);
                }
            }
        }
Esempio n. 5
0
            private static ReleaseResult ParseRelease(XmlReader reader, string releaseId)
            {
                var result = new ReleaseResult
                {
                    ReleaseId = releaseId
                };

                reader.MoveToContent();
                reader.Read();

                // http://stackoverflow.com/questions/2299632/why-does-xmlreader-skip-every-other-element-if-there-is-no-whitespace-separator

                // Loop through each element
                while (!reader.EOF && reader.ReadState == ReadState.Interactive)
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "title":
                        {
                            result.Title = reader.ReadElementContentAsString();
                            break;
                        }

                        case "date":
                        {
                            var      val = reader.ReadElementContentAsString();
                            DateTime date;
                            if (DateTime.TryParse(val, out date))
                            {
                                result.Year = date.Year;
                            }
                            break;
                        }

                        case "annotation":
                        {
                            result.Overview = reader.ReadElementContentAsString();
                            break;
                        }

                        case "release-group":
                        {
                            result.ReleaseGroupId = reader.GetAttribute("id");
                            reader.Skip();
                            break;
                        }

                        default:
                        {
                            reader.Skip();
                            break;
                        }
                        }
                    }
                    else
                    {
                        reader.Read();
                    }
                }

                return(result);
            }
        public SilverlightClientConfiguration Load(XmlReader reader)
        {
            var ret = new SilverlightClientConfiguration();

            ret.Bindings = new BindingsConfiguration();
            ret.Client   = new ClientConfiguration();

            reader.MoveToContent();
            if (reader.IsEmptyElement)
            {
                return(ret);
            }
            reader.ReadStartElement("configuration");

            for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
            {
                if (reader.NodeType != XmlNodeType.Element ||
                    reader.LocalName != "system.serviceModel" ||
                    reader.IsEmptyElement)
                {
                    reader.Skip();
                    continue;
                }
                // in <system.serviceModel>
                reader.ReadStartElement();
                for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                {
                    if (reader.NodeType != XmlNodeType.Element ||
                        reader.IsEmptyElement)
                    {
                        reader.Skip();
                        continue;
                    }
                    switch (reader.LocalName)
                    {
                    case "bindings":
                        reader.ReadStartElement();
                        for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                        {
                            if (reader.NodeType != XmlNodeType.Element ||
                                reader.IsEmptyElement)
                            {
                                reader.Skip();
                                continue;
                            }
                            switch (reader.LocalName)
                            {
                            case "customBinding":
                                reader.ReadStartElement();
                                for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                                {
                                    if (reader.NodeType != XmlNodeType.Element ||
                                        reader.LocalName != "binding")
                                    {
                                        reader.Skip();
                                        continue;
                                    }
                                    ret.Bindings.CustomBinding.Add(ReadCustomBinding(reader));
                                }
                                reader.ReadEndElement();
                                break;

                            case "basicHttpBinding":
                                reader.ReadStartElement();
                                for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                                {
                                    if (reader.NodeType != XmlNodeType.Element ||
                                        reader.LocalName != "binding")
                                    {
                                        reader.Skip();
                                        continue;
                                    }
                                    ret.Bindings.BasicHttpBinding.Add(ReadBasicHttpBinding(reader));
                                }
                                reader.ReadEndElement();
                                break;
                            }
                        }
                        reader.ReadEndElement();
                        break;

                    case "client":
                        reader.ReadStartElement();
                        for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                        {
                            if (reader.NodeType != XmlNodeType.Element ||
                                reader.LocalName != "endpoint")
                            {
                                reader.Skip();
                                continue;
                            }
                            ret.Client.Endpoints.Add(ReadEndpoint(reader));
                        }
                        reader.ReadEndElement();
                        break;
                    }
                }
                reader.ReadEndElement();
                // out <system.serviceModel>
            }
            reader.ReadEndElement();
            // out <configuration>

            return(ret);
        }
Esempio n. 7
0
        /// <summary>
        ///     Handles an element which describes how a value
        ///     should be read from the cache file.
        /// </summary>
        /// <param name="reader">The XmlReader that read the element.</param>
        /// <param name="elementName">The element's name.</param>
        /// <param name="visitor">The IPluginVisitor to call to.</param>
        private static void HandleValueElement(XmlReader reader, string elementName, IPluginVisitor visitor)
        {
            string name = "Unknown";
            uint offset = 0;
            var xmlLineInfo = reader as IXmlLineInfo;
            if (xmlLineInfo == null) return;
            var pluginLine = (uint) xmlLineInfo.LineNumber;
            bool visible = true;
            string tooltip = "";

            if (reader.MoveToAttribute("name"))
                name = reader.Value;
            if (reader.MoveToAttribute("offset"))
                offset = ParseUInt(reader.Value);
            if (reader.MoveToAttribute("visible"))
                visible = ParseBool(reader.Value);
            if (reader.MoveToAttribute("tooltip"))
                tooltip = reader.Value;

            reader.MoveToElement();
            switch (elementName.ToLower()) // FIXME: Using ToLower() here violates XML standards
            {
                case "uint8":
                    visitor.VisitUInt8(name, offset, visible, pluginLine, tooltip);
                    break;
                case "int8":
                    visitor.VisitInt8(name, offset, visible, pluginLine, tooltip);
                    break;
                case "uint16":
                    visitor.VisitUInt16(name, offset, visible, pluginLine, tooltip);
                    break;
                case "int16":
                    visitor.VisitInt16(name, offset, visible, pluginLine, tooltip);
                    break;
                case "uint32":
                    visitor.VisitUInt32(name, offset, visible, pluginLine, tooltip);
                    break;
                case "int32":
                    visitor.VisitInt32(name, offset, visible, pluginLine, tooltip);
                    break;
                case "uint64":
                    visitor.VisitUInt64(name, offset, visible, pluginLine, tooltip);
                    break;
                case "int64":
                    visitor.VisitInt64(name, offset, visible, pluginLine, tooltip);
                    break;
                case "float32":
                case "float":
                    visitor.VisitFloat32(name, offset, visible, pluginLine, tooltip);
                    break;
                case "undefined":
                    visitor.VisitUndefined(name, offset, visible, pluginLine, tooltip);
                    break;
                case "point2":
                    visitor.VisitPoint2(name, offset, visible, pluginLine, tooltip);
                    break;
                case "point3":
                    visitor.VisitPoint3(name, offset, visible, pluginLine, tooltip);
                    break;
                case "vector2":
                    visitor.VisitVector2(name, offset, visible, pluginLine, tooltip);
                    break;
                case "vector3":
                    visitor.VisitVector3(name, offset, visible, pluginLine, tooltip);
                    break;
                case "vector4":
                case "quaternion":
                    visitor.VisitVector4(name, offset, visible, pluginLine, tooltip);
                    break;
                case "degree":
                    visitor.VisitDegree(name, offset, visible, pluginLine, tooltip);
                    break;
                case "degree2":
                    visitor.VisitDegree2(name, offset, visible, pluginLine, tooltip);
                    break;
                case "degree3":
                    visitor.VisitDegree3(name, offset, visible, pluginLine, tooltip);
                    break;
                case "plane2":
                    visitor.VisitPlane2(name, offset, visible, pluginLine, tooltip);
                    break;
                case "plane3":
                    visitor.VisitPlane3(name, offset, visible, pluginLine, tooltip);
                    break;
                case "rect16":
                    visitor.VisitRect16(name, offset, visible, pluginLine, tooltip);
                    break;
                case "quat16":
                    visitor.VisitQuat16(name, offset, visible, pluginLine, tooltip);
                    break;
                case "point16":
                    visitor.VisitPoint16(name, offset, visible, pluginLine, tooltip);
                    break;
                case "stringid":
                    visitor.VisitStringID(name, offset, visible, pluginLine, tooltip);
                    break;
                case "tagref":
                    ReadTagRef(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "ascii":
                    ReadAscii(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "utf16":
                    ReadUtf16(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "flags8":
                case "bitfield8":
                    if (visitor.EnterFlags8(name, offset, visible, pluginLine, tooltip))
                        ReadBits(reader, visitor);
                    else
                        reader.Skip();
                    break;
                case "flags16":
                case "bitfield16":
                    if (visitor.EnterFlags16(name, offset, visible, pluginLine, tooltip))
                        ReadBits(reader, visitor);
                    else
                        reader.Skip();
                    break;
                case "flags32":
                case "bitfield32":
                    if (visitor.EnterFlags32(name, offset, visible, pluginLine, tooltip))
                        ReadBits(reader, visitor);
                    else
                        reader.Skip();
                    break;
                case "flags64":
                case "bitfield64":
                    if (visitor.EnterFlags64(name, offset, visible, pluginLine, tooltip))
                        ReadBits(reader, visitor);
                    else
                        reader.Skip();
                    break;

                case "enum8":
                    if (visitor.EnterEnum8(name, offset, visible, pluginLine, tooltip))
                        ReadOptions(reader, visitor);
                    else
                        reader.Skip();
                    break;
                case "enum16":
                    if (visitor.EnterEnum16(name, offset, visible, pluginLine, tooltip))
                        ReadOptions(reader, visitor);
                    else
                        reader.Skip();
                    break;
                case "enum32":
                    if (visitor.EnterEnum32(name, offset, visible, pluginLine, tooltip))
                        ReadOptions(reader, visitor);
                    else
                        reader.Skip();
                    break;

                case "color":
                case "color32":
                    visitor.VisitColorInt(name, offset, visible, ReadColorAlpha(reader), pluginLine, tooltip);
                    break;
                case "colorf":
                    ReadColorF(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "dataref":
                    ReadDataRef(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "reflexive":
                case "tagblock":
                    ReadTagBlock(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "raw":
                    ReadRaw(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "shader":
                    ReadShader(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "uniclist":
                    ReadUnicList(reader, name, offset, visible, visitor, pluginLine, tooltip);
                    break;

                case "range16":
                    visitor.VisitRangeInt16(name, offset, visible, pluginLine, tooltip);
                    break;
                case "rangef":
                    visitor.VisitRangeFloat32(name, offset, visible, pluginLine, tooltip);
                    break;
                case "ranged":
                    visitor.VisitRangeDegree(name, offset, visible, pluginLine, tooltip);
                    break;
                case "datum":
                    visitor.VisitDatum(name, offset, visible, pluginLine, tooltip);
                    break;

                default:
                    throw new ArgumentException("Unknown element \"" + elementName + "\"." + PositionInfo(reader));
            }
        }
Esempio n. 8
0
        /// <summary>
        /// Protected method that does the actual initialization of the Photo instance. Should be called by subclasses of the Photo class.
        /// </summary>
        /// <param name="reader">The reader containing the XML to be parsed.</param>
        /// <param name="allowExtraAtrributes">Wheither to allow unknown extra attributes. In debug builds will throw an exception if this parameter is false and an unknown attribute is found.</param>
        protected void Load(XmlReader reader, bool allowExtraAtrributes)
        {
            if (reader.LocalName != "photo")
            {
                Helper.CheckParsingException(reader);
            }

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                case "id":
                    PhotoId = reader.Value;
                    if (String.IsNullOrEmpty(reader.Value))
                    {
                        reader.Skip();
                        return;
                    }
                    break;

                case "owner":
                    UserId = reader.Value;
                    break;

                case "secret":
                    Secret = reader.Value;
                    break;

                case "server":
                    Server = reader.Value;
                    break;

                case "farm":
                    Farm = reader.Value;
                    break;

                case "title":
                    Title = reader.Value;
                    break;

                case "ispublic":
                    IsPublic = reader.Value == "1";
                    break;

                case "isfamily":
                    IsFamily = reader.Value == "1";
                    break;

                case "isfriend":
                    IsFriend = reader.Value == "1";
                    break;

                case "tags":
                    foreach (string tag in reader.Value.Split(' '))
                    {
                        Tags.Add(tag);
                    }
                    break;

                case "datetaken":
                    // For example : 2007-11-04 08:55:18
                    DateTaken = Helper.ParseDateWithGranularity(reader.Value);
                    break;

                case "datetakengranularity":
                    break;

                case "dateupload":
                    DateUploaded = Helper.UnixTimestampToDate(reader.Value);
                    break;

                case "license":
                    License = (LicenseType)int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "ownername":
                    OwnerName = reader.Value;
                    break;

                case "lastupdate":
                    LastUpdated = Helper.UnixTimestampToDate(reader.Value);
                    break;

                case "originalformat":
                    OriginalFormat = reader.Value;
                    break;

                case "originalsecret":
                    OriginalSecret = reader.Value;
                    break;

                case "place_id":
                    PlaceId = reader.Value;
                    break;

                case "woeid":
                    WoeId = reader.Value;
                    break;

                case "accuracy":
                    Accuracy = (GeoAccuracy)reader.ReadContentAsInt();
                    break;

                case "latitude":
                    Latitude = reader.ReadContentAsDouble();
                    break;

                case "longitude":
                    Longitude = reader.ReadContentAsDouble();
                    break;

                case "machine_tags":
                    MachineTags = reader.Value;
                    break;

                case "o_width":
                    OriginalWidth = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "o_height":
                    OriginalHeight = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "views":
                    Views = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "media":
                    Media = reader.Value;
                    break;

                case "media_status":
                    MediaStatus = reader.Value;
                    break;

                case "iconserver":
                    IconServer = reader.Value;
                    break;

                case "iconfarm":
                    IconFarm = reader.Value;
                    break;

                case "username":
                    OwnerName = reader.Value;
                    break;

                case "isprimary":
                case "is_primary":
                    break;

                case "pathalias":
                case "path_alias":
                    PathAlias = reader.Value;
                    break;

                case "url_sq":
                    urlSquare = reader.Value;
                    break;

                case "width_sq":
                    SquareThumbnailWidth = reader.ReadContentAsInt();
                    break;

                case "height_sq":
                    SquareThumbnailHeight = reader.ReadContentAsInt();
                    break;

                case "url_t":
                    urlThumbnail = reader.Value;
                    break;

                case "width_t":
                    ThumbnailWidth = reader.ReadContentAsInt();
                    break;

                case "height_t":
                    ThumbnailHeight = reader.ReadContentAsInt();
                    break;

                case "url_q":
                    urlLargeSquare = reader.Value;
                    break;

                case "width_q":
                    LargeSquareThumbnailWidth = reader.ReadContentAsInt();
                    break;

                case "height_q":
                    LargeSquareThumbnailHeight = reader.ReadContentAsInt();
                    break;

                case "url_n":
                    urlSmall320 = reader.Value;
                    break;

                case "width_n":
                    Small320Width = reader.ReadContentAsInt();
                    break;

                case "height_n":
                    Small320Height = reader.ReadContentAsInt();
                    break;

                case "url_s":
                    urlSmall = reader.Value;
                    break;

                case "width_s":
                    SmallWidth = reader.ReadContentAsInt();
                    break;

                case "height_s":
                    SmallHeight = reader.ReadContentAsInt();
                    break;

                case "url_m":
                    urlMedium = reader.Value;
                    break;

                case "width_m":
                    MediumWidth = reader.ReadContentAsInt();
                    break;

                case "height_m":
                    MediumHeight = reader.ReadContentAsInt();
                    break;

                case "url_c":
                    urlMedium800 = reader.Value;
                    break;

                case "width_c":
                    Medium800Width = reader.ReadContentAsInt();
                    break;

                case "height_c":
                    Medium800Height = reader.ReadContentAsInt();
                    break;

                case "url_l":
                    urlLarge = reader.Value;
                    break;

                case "width_l":
                    LargeWidth = reader.ReadContentAsInt();
                    break;

                case "height_l":
                    LargeHeight = reader.ReadContentAsInt();
                    break;

                case "url_z":
                    urlMedium640 = reader.Value;
                    break;

                case "width_z":
                    Medium640Width = reader.ReadContentAsInt();
                    break;

                case "height_z":
                    Medium640Height = reader.ReadContentAsInt();
                    break;

                case "url_o":
                    urlOriginal = reader.Value;
                    break;

                case "width_o":
                    OriginalWidth = reader.ReadContentAsInt();
                    break;

                case "height_o":
                    OriginalHeight = reader.ReadContentAsInt();
                    break;

                case "url_h":
                    Large1600Url = reader.Value;
                    break;

                case "width_h":
                    Large1600Width = reader.ReadContentAsInt();
                    break;

                case "height_h":
                    Large1600Height = reader.ReadContentAsInt();
                    break;

                case "url_k":
                    Large2048Url = reader.Value;
                    break;

                case "width_k":
                    Large2048Width = reader.ReadContentAsInt();
                    break;

                case "height_k":
                    Large2048Height = reader.ReadContentAsInt();
                    break;

                case "dateadded":
                    DateAddedToGroup = Helper.UnixTimestampToDate(reader.Value);
                    break;

                case "date_faved":
                    DateFavorited = Helper.UnixTimestampToDate(reader.Value);
                    break;

                case "has_comment":     // Gallery photos return this, but we ignore it and set GalleryPhoto.Comment instead.
                    break;

                case "can_comment":
                    CanComment = reader.Value == "1";
                    break;

                case "can_addmeta":
                    CanAddMeta = reader.Value == "1";
                    break;

                case "can_blog":
                    CanBlog = reader.Value == "1";
                    break;

                case "can_print":
                    CanPrint = reader.Value == "1";
                    break;

                case "can_download":
                    CanDownload = reader.Value == "1";
                    break;

                case "can_share":
                    CanShare = reader.Value == "1";
                    break;

                case "geo_is_family":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsFamily = reader.Value == "1";
                    break;

                case "geo_is_friend":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsFriend = reader.Value == "1";
                    break;

                case "geo_is_public":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsPublic = reader.Value == "1";
                    break;

                case "geo_is_contact":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsContact = reader.Value == "1";
                    break;

                case "context":
                    GeoContext = (GeoContext)reader.ReadContentAsInt();
                    break;

                case "rotation":
                    Rotation = reader.ReadContentAsInt();
                    break;

                default:
                    if (!allowExtraAtrributes)
                    {
                        Helper.CheckParsingException(reader);
                    }
                    break;
                }
            }

            reader.Read();

            if (reader.LocalName == "description")
            {
                Description = reader.ReadElementContentAsString();
            }
        }
        /// <summary>
        /// Populates the XML into a strong typed DOM tree.
        /// </summary>
        /// <param name="xmlReader">The XmlReader to read the XML content.</param>
        /// <param name="loadMode">Specifies a load mode that is either lazy or full.</param>
        private protected override void Populate(XmlReader xmlReader, OpenXmlLoadMode loadMode)
        {
            LoadAttributes(xmlReader);

            if (!xmlReader.IsEmptyElement)
            {
                xmlReader.Read(); // read this element

                while (!xmlReader.EOF)
                {
                    // O15:#3024890, OpenXmlCompositeElement ignores the Whitespace NodeType.
                    if (xmlReader.NodeType == XmlNodeType.Whitespace)
                    {
                        xmlReader.Skip();
                        continue;
                    }
                    else if (xmlReader.NodeType == XmlNodeType.EndElement)
                    {
                        Debug.Assert(string.Equals(xmlReader.LocalName, LocalName, StringComparison.Ordinal));
                        xmlReader.Skip(); // move to next node
                        break;
                    }

                    OpenXmlElement element = ElementFactory(xmlReader);

                    // set parent before Load( ) call. AlternateContentChoice need parent info on loading.
                    element.Parent = this;

                    bool isACB = element is AlternateContent;
                    if (isACB && element.OpenXmlElementContext is not null)
                    {
                        element.OpenXmlElementContext.ACBlockLevel++;
                    }

                    bool mcContextPushed = false;
                    if (!(element is OpenXmlMiscNode))
                    {
                        // push MC context based on the context of the child element to be loaded
                        mcContextPushed = PushMcContext(xmlReader);
                    }

                    //Process the element according to the MC behavior
                    var action = ElementAction.Normal;
                    if (OpenXmlElementContext is not null && OpenXmlElementContext.MCSettings.ProcessMode != DocumentFormat.OpenXml.Packaging.MarkupCompatibilityProcessMode.NoProcess)
                    {
                        action = OpenXmlElementContext.MCContext.GetElementAction(element, OpenXmlElementContext.MCSettings.TargetFileFormatVersions);
                    }

                    element.Load(xmlReader, loadMode);

                    if (mcContextPushed)
                    {
                        PopMcContext();
                    }

                    if (isACB && element.OpenXmlElementContext is not null)
                    {
                        element.OpenXmlElementContext.ACBlockLevel--;
                    }

                    switch (action)
                    {
                    case ElementAction.Normal:
                    {
                        AddANode(element);
                        break;
                    }

                    case ElementAction.Ignore:
                    {
                        element.Parent = null;
                        continue;
                    }

                    case ElementAction.ProcessContent:
                    {
                        element.Parent = null;
                        while (element.ChildElements.Count > 0)
                        {
                            if (element.FirstChild is not OpenXmlElement node)
                            {
                                break;
                            }

                            node.Remove();
                            var newnode = default(OpenXmlElement);

                            // If node is an UnknowElement, we should try to see whether the parent element can load the node as strong typed element
                            if (node is OpenXmlUnknownElement)
                            {
                                newnode = CreateElement(OpenXmlQualifiedName.Create(node.NamespaceUri, node.Prefix, node.LocalName));
                                if (!(newnode is OpenXmlUnknownElement))
                                {
                                    // The following method will load teh element in MCMode.Full
                                    // since the node is already MC-processed when loading as unknown type, full loading the outerXml is fine
                                    newnode.OuterXml = node.OuterXml;

                                    // unnecessary xmlns attribute will be added, remove it.
                                    RemoveUnnecessaryExtAttr(node, newnode);
                                }
                                else
                                {
                                    newnode = null;
                                }
                            }

                            if (newnode is not null)
                            {
                                AddANode(newnode);
                            }
                            else
                            {
                                //append the original node
                                AddANode(node);
                            }
                        }

                        break;
                    }

                    case ElementAction.ACBlock:
                    {
                        var effectiveNode = OpenXmlElementContext?.MCContext.GetContentFromACBlock(element as AlternateContent, OpenXmlElementContext.MCSettings.TargetFileFormatVersions);
                        if (effectiveNode is null)
                        {
                            break;
                        }

                        element.Parent       = null;
                        effectiveNode.Parent = null;
                        while (effectiveNode.FirstChild is not null)
                        {
                            var node = effectiveNode.FirstChild;
                            node.Remove();
                            AddANode(node);
                            node.CheckMustUnderstandAttr();
                        }

                        break;
                    }
                    }
                }
            }
            else
            {
                xmlReader.Skip();
            }

            // Set raw outer xml to empty to indicate that it passed
            RawOuterXml = string.Empty;
        }
Esempio n. 10
0
        static void AddXmlDocumentation(IXmlDocOutput output, XmlReader xml)
        {
            bool isNewLine = true;

            while (xml.Read())
            {
                if (xml.NodeType == XmlNodeType.Element)
                {
                    string elname = xml.Name.ToLowerInvariant();
                    switch (elname)
                    {
                    case "filterpriority":
                    case "remarks":
                        xml.Skip();
                        break;

                    case "example":
                        output.WriteNewLine();
                        output.Write("Example", BoxedTextColor.XmlDocToolTipHeader);
                        output.Write(":", BoxedTextColor.Text);
                        output.WriteNewLine();
                        isNewLine = true;
                        break;

                    case "exception":
                        output.WriteNewLine();
                        output.Write(GetCref(xml["cref"]), BoxedTextColor.XmlDocToolTipHeader);
                        output.Write(":", BoxedTextColor.Text);
                        output.WriteSpace();
                        isNewLine = false;
                        break;

                    case "returns":
                        output.WriteNewLine();
                        output.Write("Returns", BoxedTextColor.XmlDocToolTipHeader);
                        output.Write(":", BoxedTextColor.Text);
                        output.WriteSpace();
                        isNewLine = false;
                        break;

                    case "see":
                        output.Write(GetCref(xml["cref"]), BoxedTextColor.Text);
                        output.Write((xml["langword"] ?? string.Empty).Trim(), BoxedTextColor.Keyword);
                        isNewLine = false;
                        break;

                    case "seealso":
                        output.WriteNewLine();
                        output.Write("See also", BoxedTextColor.XmlDocToolTipHeader);
                        output.Write(":", BoxedTextColor.Text);
                        output.WriteSpace();
                        output.Write(GetCref(xml["cref"]), BoxedTextColor.Text);
                        isNewLine = false;
                        break;

                    case "paramref":
                        output.Write((xml["name"] ?? string.Empty).Trim(), BoxedTextColor.Parameter);
                        isNewLine = false;
                        break;

                    case "param":
                        output.WriteNewLine();
                        output.Write(whitespace.Replace((xml["name"] ?? string.Empty).Trim(), " "), BoxedTextColor.Parameter);
                        output.Write(":", BoxedTextColor.Text);
                        output.WriteSpace();
                        isNewLine = false;
                        break;

                    case "typeparam":
                        output.WriteNewLine();
                        output.Write(whitespace.Replace((xml["name"] ?? string.Empty).Trim(), " "), BoxedTextColor.TypeGenericParameter);
                        output.Write(":", BoxedTextColor.Text);
                        output.WriteSpace();
                        isNewLine = false;
                        break;

                    case "value":
                        output.WriteNewLine();
                        output.Write("Value", BoxedTextColor.Keyword);
                        output.Write(":", BoxedTextColor.Text);
                        output.WriteNewLine();
                        isNewLine = true;
                        break;

                    case "br":
                    case "para":
                        output.WriteNewLine();
                        isNewLine = true;
                        break;

                    default:
                        break;
                    }
                }
                else if (xml.NodeType == XmlNodeType.Text)
                {
                    var s = whitespace.Replace(xml.Value, " ");
                    if (isNewLine)
                    {
                        s = s.TrimStart();
                    }
                    output.Write(s, BoxedTextColor.Text);
                    isNewLine = false;
                }
            }
        }
Esempio n. 11
0
        private void ProcessCppCheckLog(XmlReader reader, IResultLogWriter output, OptionallyEmittedData dataToInsert)
        {
            reader.ReadStartElement(_strings.Results);

            if (!StringReference.AreEqual(reader.LocalName, _strings.CppCheck))
            {
                throw reader.CreateException(ConverterResources.CppCheckCppCheckElementMissing);
            }

            string version = reader.GetAttribute(_strings.Version);

            if (version != null && !version.IsSemanticVersioningCompatible())
            {
                // This logic only fixes up simple cases, such as being passed
                // 1.66, where Semantic Versioning 2.0 requires 1.66.0. Also
                // strips Revision member if passed a complete .NET version.
                Version dotNetVersion;
                if (Version.TryParse(version, out dotNetVersion))
                {
                    version =
                        Math.Max(0, dotNetVersion.Major) + "." +
                        Math.Max(0, dotNetVersion.Minor) + "." +
                        Math.Max(0, dotNetVersion.Build);
                }
            }

            if (String.IsNullOrWhiteSpace(version))
            {
                throw reader.CreateException(ConverterResources.CppCheckCppCheckElementMissing);
            }

            reader.Skip(); // <cppcheck />

            if (!StringReference.AreEqual(reader.LocalName, _strings.Errors))
            {
                throw reader.CreateException(ConverterResources.CppCheckErrorsElementMissing);
            }

            var results = new List <Result>();

            if (reader.IsEmptyElement)
            {
                reader.Skip(); // <errors />
            }
            else
            {
                int errorsDepth = reader.Depth;
                reader.Read(); // <errors>

                while (reader.Depth > errorsDepth)
                {
                    var parsedError = CppCheckError.Parse(reader, _strings);
                    results.Add(parsedError.ToSarifIssue());
                }

                reader.ReadEndElement(); // </errors>
            }

            reader.ReadEndElement(); // </results>

            var tool = new Tool
            {
                Name    = "CppCheck",
                Version = version,
            };

            var fileInfoFactory = new FileInfoFactory(uri => MimeType.Cpp, dataToInsert);
            Dictionary <string, FileData> fileDictionary = fileInfoFactory.Create(results);

            var run = new Run()
            {
                Tool = tool
            };

            output.Initialize(run);

            if (fileDictionary != null && fileDictionary.Count > 0)
            {
                output.WriteFiles(fileDictionary);
            }

            output.OpenResults();
            output.WriteResults(results);
            output.CloseResults();
        }
 public static void Load(this JavaGenericConstraint gc, XmlReader reader)
 {
     gc.Type = XmlUtil.GetRequiredAttribute(reader, "type");
     XmlUtil.CheckExtraneousAttributes("genericConstraint", reader, "type");
     reader.Skip();
 }
Esempio n. 13
0
        private void FetchFromVideoNode(XmlReader reader, T item)
        {
            reader.MoveToContent();
            reader.Read();

            // Loop through each element
            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "format3d":
                    {
                        var val = reader.ReadElementContentAsString();

                        var video = item as Video;

                        if (video != null)
                        {
                            if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
                            {
                                video.Video3DFormat = Video3DFormat.HalfSideBySide;
                            }
                            else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
                            {
                                video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
                            }
                            else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
                            {
                                video.Video3DFormat = Video3DFormat.FullTopAndBottom;
                            }
                            else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
                            {
                                video.Video3DFormat = Video3DFormat.FullSideBySide;
                            }
                            else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
                            {
                                video.Video3DFormat = Video3DFormat.MVC;
                            }
                        }

                        break;
                    }

                    case "aspect":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (item is Video video)
                        {
                            video.AspectRatio = val;
                        }

                        break;
                    }

                    case "width":
                    {
                        var val = reader.ReadElementContentAsInt();

                        if (item is Video video)
                        {
                            video.Width = val;
                        }

                        break;
                    }

                    case "height":
                    {
                        var val = reader.ReadElementContentAsInt();

                        if (item is Video video)
                        {
                            video.Height = val;
                        }

                        break;
                    }

                    case "durationinseconds":
                    {
                        var val = reader.ReadElementContentAsInt();

                        if (item is Video video)
                        {
                            video.RunTimeTicks = new TimeSpan(0, 0, val).Ticks;
                        }

                        break;
                    }

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                }
            }
        }
Esempio n. 14
0
        public static void ReadObjectProperties(XmlReader reader, object obj, PropertyConversionHandler handler = null)
        {
            // Build property lookup table
            PropertyInfo[] props = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
            Dictionary<string, PropertyInfo> propHash = new Dictionary<string, PropertyInfo>(props.Length);
            foreach (var pi in props)
                if (!Attribute.IsDefined(pi, typeof(XmlIgnoreAttribute), false))
                    propHash.Add(GetPropertyElementName(pi), pi);

            while (reader.MoveToContent() == System.Xml.XmlNodeType.Element)
            {
                PropertyInfo pi;
                if (propHash.TryGetValue(reader.LocalName, out pi))
                {
                    if (IsStandardType(pi.PropertyType))
                    {
                        object value = null;
                        if (pi.PropertyType.IsEnum)
                            value = Enum.Parse(pi.PropertyType, reader.ReadElementContentAsString());
                        else
                            value = reader.ReadElementContentAs(pi.PropertyType, null);

                        if (handler != null)
                            handler(pi, obj, ref value);

                        pi.SetValue(obj, value, null);
                    }
                    else
                    {
                        ReadObject(reader, pi.GetValue(obj, null));
                    }
                }
                else
                {
                    reader.Skip();
                    reader.MoveToContent();
                }
            }
        }
        protected internal virtual void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
        {
            Hashtable readProps = new Hashtable();

            reader.MoveToContent();
            elementPresent = true;

            while (reader.MoveToNextAttribute())
            {
                PropertyInformation prop = ElementInformation.Properties [reader.LocalName];
                if (prop == null || (serializeCollectionKey && !prop.IsKey))
                {
                    /* handle the built in ConfigurationElement attributes here */
                    if (reader.LocalName == "lockAllAttributesExcept")
                    {
                        LockAllAttributesExcept.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockAllElementsExcept")
                    {
                        LockAllElementsExcept.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockAttributes")
                    {
                        LockAttributes.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockElements")
                    {
                        LockElements.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockItem")
                    {
                        LockItem = (reader.Value.ToLowerInvariant() == "true");
                    }
                    else if (reader.LocalName == "xmlns")
                    {
                        /* ignore */
                    }
                    else if (this is ConfigurationSection && reader.LocalName == "configSource")
                    {
                        /* ignore */
                    }
                    else if (!OnDeserializeUnrecognizedAttribute(reader.LocalName, reader.Value))
                    {
                        throw new ConfigurationErrorsException("Unrecognized attribute '" + reader.LocalName + "'.", reader);
                    }

                    continue;
                }

                if (readProps.ContainsKey(prop))
                {
                    throw new ConfigurationErrorsException("The attribute '" + prop.Name + "' may only appear once in this element.", reader);
                }

                string value = null;
                try {
                    value = reader.Value;
                    ValidateValue(prop.Property, value);
                    prop.SetStringValue(value);
                } catch (ConfigurationErrorsException) {
                    throw;
                } catch (ConfigurationException) {
                    throw;
                } catch (Exception ex) {
                    string msg = String.Format("The value for the property '{0}' is not valid. The error is: {1}", prop.Name, ex.Message);
                    throw new ConfigurationErrorsException(msg, reader);
                }
                readProps [prop] = prop.Name;

                ConfigXmlTextReader _reader = reader as ConfigXmlTextReader;
                if (_reader != null)
                {
                    prop.Source     = _reader.Filename;
                    prop.LineNumber = _reader.LineNumber;
                }
            }

            reader.MoveToElement();
            if (reader.IsEmptyElement)
            {
                reader.Skip();
            }
            else
            {
                int depth = reader.Depth;

                reader.ReadStartElement();
                reader.MoveToContent();

                do
                {
                    if (reader.NodeType != XmlNodeType.Element)
                    {
                        reader.Skip();
                        continue;
                    }

                    PropertyInformation prop = ElementInformation.Properties [reader.LocalName];
                    if (prop == null || (serializeCollectionKey && !prop.IsKey))
                    {
                        if (!OnDeserializeUnrecognizedElement(reader.LocalName, reader))
                        {
                            if (prop == null)
                            {
                                ConfigurationElementCollection c = GetDefaultCollection();
                                if (c != null && c.OnDeserializeUnrecognizedElement(reader.LocalName, reader))
                                {
                                    continue;
                                }
                            }
                            throw new ConfigurationErrorsException("Unrecognized element '" + reader.LocalName + "'.", reader);
                        }
                        continue;
                    }

                    if (!prop.IsElement)
                    {
                        throw new ConfigurationErrorsException("Property '" + prop.Name + "' is not a ConfigurationElement.");
                    }

                    if (readProps.Contains(prop))
                    {
                        throw new ConfigurationErrorsException("The element <" + prop.Name + "> may only appear once in this section.", reader);
                    }

                    ConfigurationElement val = (ConfigurationElement)prop.Value;
                    val.DeserializeElement(reader, serializeCollectionKey);
                    readProps [prop] = prop.Name;

                    if (depth == reader.Depth)
                    {
                        reader.Read();
                    }
                } while (depth < reader.Depth);
            }

            modified = false;

            foreach (PropertyInformation prop in ElementInformation.Properties)
            {
                if (!String.IsNullOrEmpty(prop.Name) && prop.IsRequired && !readProps.ContainsKey(prop))
                {
                    PropertyInformation p = ElementInformation.Properties [prop.Name];
                    if (p == null)
                    {
                        object val = OnRequiredPropertyNotFound(prop.Name);
                        if (!object.Equals(val, prop.DefaultValue))
                        {
                            prop.Value      = val;
                            prop.IsModified = false;
                        }
                    }
                }
            }

            PostDeserialize();
        }
Esempio n. 16
0
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            var          nfoConfiguration = _config.GetNfoConfiguration();
            UserItemData?userData         = null;

            if (!string.IsNullOrWhiteSpace(nfoConfiguration.UserId))
            {
                var user = _userManager.GetUserById(Guid.Parse(nfoConfiguration.UserId));
                userData = _userDataManager.GetUserData(user, item);
            }

            switch (reader.Name)
            {
            // DateCreated
            case "dateadded":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (DateTime.TryParse(val, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.LogWarning("Invalid Added value found: {Value}", val);
                    }
                }

                break;
            }

            case "originaltitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(val))
                {
                    item.OriginalTitle = val;
                }

                break;
            }

            case "name":
            case "title":
            case "localtitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "sortname":
                item.SortName = reader.ReadElementContentAsString();
                break;

            case "criticrating":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(text))
                {
                    if (float.TryParse(text, NumberStyles.Any, UsCulture, out var value))
                    {
                        item.CriticRating = value;
                    }
                }

                break;
            }

            case "sorttitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }

                break;
            }

            case "biography":
            case "plot":
            case "review":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "watched":
            {
                var val = reader.ReadElementContentAsBoolean();

                if (userData != null)
                {
                    userData.Played = val;
                }

                break;
            }

            case "playcount":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val) && userData != null)
                {
                    if (int.TryParse(val, NumberStyles.Integer, UsCulture, out var count))
                    {
                        userData.PlayCount = count;
                    }
                }

                break;
            }

            case "lastplayed":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val) && userData != null)
                {
                    if (DateTime.TryParse(val, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var added))
                    {
                        userData.LastPlayedDate = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.LogWarning("Invalid lastplayed value found: {Value}", val);
                    }
                }

                break;
            }

            case "countrycode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "lockedfields":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.LockedFields = val.Split('|').Select(i =>
                        {
                            if (Enum.TryParse(i, true, out MetadataField field))
                            {
                                return((MetadataField?)field);
                            }

                            return(null);
                        }).OfType <MetadataField>().ToArray();
                }

                break;
            }

            case "tagline":
                item.Tagline = reader.ReadElementContentAsString();
                break;

            case "country":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ProductionLocations = val.Split('/')
                                               .Select(i => i.Trim())
                                               .Where(i => !string.IsNullOrWhiteSpace(i))
                                               .ToArray();
                }

                break;
            }

            case "mpaa":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }

                break;
            }

            case "customrating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }

                break;
            }

            case "runtime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, UsCulture, out var runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }

                break;
            }

            case "aspectratio":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) &&
                    item is IHasAspectRatio hasAspectRatio)
                {
                    hasAspectRatio.AspectRatio = val;
                }

                break;
            }

            case "lockdata":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }

                break;
            }

            case "studio":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.AddStudio(val);
                }

                break;
            }

            case "director":
            {
                var val = reader.ReadElementContentAsString();
                foreach (var p in SplitNames(val).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }

                    itemResult.AddPerson(p);
                }

                break;
            }

            case "credits":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/').Select(i => i.Trim())
                                .Where(i => !string.IsNullOrEmpty(i));

                    foreach (var p in parts.Select(v => new PersonInfo {
                            Name = v.Trim(), Type = PersonType.Writer
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }

                        itemResult.AddPerson(p);
                    }
                }

                break;
            }

            case "writer":
            {
                var val = reader.ReadElementContentAsString();
                foreach (var p in SplitNames(val).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }

                    itemResult.AddPerson(p);
                }

                break;
            }

            case "actor":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        var person = GetPersonFromXmlNode(subtree);

                        if (!string.IsNullOrWhiteSpace(person.Name))
                        {
                            itemResult.AddPerson(person);
                        }
                    }
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "trailer":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    val = val.Replace("plugin://plugin.video.youtube/?action=play_video&videoid=", BaseNfoSaver.YouTubeWatchUrl, StringComparison.OrdinalIgnoreCase);

                    item.AddTrailerUrl(val);
                }

                break;
            }

            case "displayorder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }

                break;
            }

            case "year":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (int.TryParse(val, out var productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "rating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
                    {
                        item.CommunityRating = val;
                    }
                }

                break;
            }

            case "ratings":
            {
                if (!reader.IsEmptyElement)
                {
                    using var subtree = reader.ReadSubtree();
                    FetchFromRatingsNode(subtree, item);
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "aired":
            case "formed":
            case "premiered":
            case "releasedate":
            {
                var formatString = nfoConfiguration.ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var date) && date.Year > 1850)
                    {
                        item.PremiereDate   = date.ToUniversalTime();
                        item.ProductionYear = date.Year;
                    }
                }

                break;
            }

            case "enddate":
            {
                var formatString = nfoConfiguration.ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var date) && date.Year > 1850)
                    {
                        item.EndDate = date.ToUniversalTime();
                    }
                }

                break;
            }

            case "genre":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/')
                                .Select(i => i.Trim())
                                .Where(i => !string.IsNullOrWhiteSpace(i));

                    foreach (var p in parts)
                    {
                        item.AddGenre(p);
                    }
                }

                break;
            }

            case "style":
            case "tag":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.AddTag(val);
                }

                break;
            }

            case "fileinfo":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromFileInfoNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "uniqueid":
            {
                if (reader.IsEmptyElement)
                {
                    reader.Read();
                    break;
                }

                var provider = reader.GetAttribute("type");
                var id       = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(provider) && !string.IsNullOrWhiteSpace(id))
                {
                    item.SetProviderId(provider, id);
                }

                break;
            }

            case "thumb":
            {
                var artType = reader.GetAttribute("aspect");
                var val     = reader.ReadElementContentAsString();

                // skip:
                // - empty aspect tag
                // - empty uri
                // - tag containing '.' because we can't set images for seasons, episodes or movie sets within series or movies
                if (string.IsNullOrEmpty(artType) || string.IsNullOrEmpty(val) || artType.Contains('.', StringComparison.Ordinal))
                {
                    break;
                }

                ImageType imageType = GetImageType(artType);

                if (!Uri.TryCreate(val, UriKind.Absolute, out var uri))
                {
                    Logger.LogError("Image location {Path} specified in nfo file for {ItemName} is not a valid URL or file path.", val, item.Name);
                    break;
                }

                if (uri.IsFile)
                {
                    // only allow one item of each type
                    if (itemResult.Images.Any(x => x.Type == imageType))
                    {
                        break;
                    }

                    var fileSystemMetadata = _directoryService.GetFile(val);
                    // non existing file returns null
                    if (fileSystemMetadata == null || !fileSystemMetadata.Exists)
                    {
                        Logger.LogWarning("Artwork file {Path} specified in nfo file for {ItemName} does not exist.", uri, item.Name);
                        break;
                    }

                    itemResult.Images.Add(new LocalImageInfo()
                        {
                            FileInfo = fileSystemMetadata,
                            Type     = imageType
                        });
                }
                else
                {
                    // only allow one item of each type
                    if (itemResult.RemoteImages.Any(x => x.type == imageType))
                    {
                        break;
                    }

                    itemResult.RemoteImages.Add((uri.ToString(), imageType));
                }

                break;
            }

            default:
                string readerName = reader.Name;
                if (_validProviderIds.TryGetValue(readerName, out string?providerIdValue))
                {
                    var id = reader.ReadElementContentAsString();
                    if (!string.IsNullOrWhiteSpace(providerIdValue) && !string.IsNullOrWhiteSpace(id))
                    {
                        item.SetProviderId(providerIdValue, id);
                    }
                }
                else
                {
                    reader.Skip();
                }

                break;
            }
        }
Esempio n. 17
0
        /// <summary>
        /// データをXML形式から読み込みます。
        /// </summary>
        /// <param title="reader"></param>
        public void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();
            if (reader.IsEmptyElement)
            {
                reader.Skip();
                return;
            }
            reader.ReadStartElement("MotionDataSet");
            int frameLength = 0;
            int count       = 0;

            for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None; reader.MoveToContent())
            {
                switch (reader.Name)
                {
                case "MotionDataHeader":
                    lock (this) {
                        Header = MotionDataHeader.Deserialize(reader);
                    }
                    break;

                case "EnumerateFrame()":
                    if (reader.IsEmptyElement)
                    {
                        reader.Skip();
                        continue;
                    }
                    string lengthStr;
                    if ((lengthStr = reader.GetAttribute("Length")) != null)
                    {
                        int length;
                        if (int.TryParse(lengthStr, out length))
                        {
                            frameLength = length;
                        }
                    }
                    reader.ReadStartElement("EnumerateFrame()");
                    while (reader.NodeType != XmlNodeType.None)
                    {
                        if (reader.NodeType == XmlNodeType.EndElement)
                        {
                            break;
                        }
                        string timeStr;
                        switch (reader.Name)
                        {
                        case "Frame":
                            if (reader.IsEmptyElement || (timeStr = reader.GetAttribute("Time")) == null)
                            {
                                reader.Skip();
                                continue;
                            }
                            reader.ReadStartElement("Frame");
                            decimal time;
                            if (decimal.TryParse(timeStr, out time) && reader.IsStartElement("MotionDataFrame"))
                            {
                                MotionDataFrame frame = MotionDataFrame.Deserialize(reader);
                                AddFrame(time, frame);
                                if (frameLength != 0)
                                {
                                    this.ReportProgress(100 * count / frameLength, string.Format("Load Data Set: {0} / {1}", count, frameLength));
                                }
                                else
                                {
                                    this.ReportProgress(100 - (10000 / (count + 100)), string.Format("Load Data Set: {0}", count));
                                }
                                count++;
                            }
                            while (reader.NodeType != XmlNodeType.None && reader.NodeType != XmlNodeType.EndElement)
                            {
                                reader.Skip();
                            }
                            reader.ReadEndElement();

                            break;

                        default:
                            reader.Skip();
                            break;
                        }
                    }
                    while (reader.NodeType != XmlNodeType.None && reader.NodeType != XmlNodeType.EndElement)
                    {
                        reader.Skip();
                    }
                    reader.ReadEndElement();

                    break;

                default:
                    reader.Skip();
                    break;
                }
            }
            reader.ReadEndElement();
        }
    void IXmlSerializable.ReadXml(XmlReader reader)
    {
        this.lobbyData.Clear();
        int    num       = 1;
        string attribute = reader.GetAttribute("Version");

        if (!string.IsNullOrEmpty(attribute))
        {
            int.TryParse(attribute, out num);
        }
        reader.ReadStartElement();
        string value = reader.ReadElementString("SessionMode");

        this.SessionMode = (SessionMode)((int)Enum.Parse(typeof(SessionMode), value));
        reader.ReadStartElement("LobbyData");
        while (reader.IsStartElement("LobbyData"))
        {
            string attribute2 = reader.GetAttribute("Key");
            reader.ReadStartElement("LobbyData");
            string value2 = reader.ReadString();
            this.lobbyData.Add(attribute2, value2);
            reader.ReadEndElement();
        }
        reader.ReadEndElement();
        if (num >= 2)
        {
            int    num2       = 0;
            string attribute3 = reader.GetAttribute("Count");
            int.TryParse(attribute3, out num2);
            this.presence = null;
            if (num2 > 0)
            {
                this.presence = new List <GameSaveSessionDescriptor.UserPresenceInfo> [num2];
                for (int i = 0; i < num2; i++)
                {
                    this.presence[i] = new List <GameSaveSessionDescriptor.UserPresenceInfo>();
                }
            }
            reader.ReadStartElement("UserPresence");
            for (int j = 0; j < this.presence.Length; j++)
            {
                attribute3 = reader.GetAttribute("Count");
                reader.ReadStartElement("UserPresenceInfo");
                int num3 = 0;
                int.TryParse(attribute3, out num3);
                for (int k = 0; k < num3; k++)
                {
                    string attribute4 = reader.GetAttribute("Turn");
                    string attribute5 = reader.GetAttribute("SteamUserID");
                    GameSaveSessionDescriptor.UserPresenceInfo userPresenceInfo  = default(GameSaveSessionDescriptor.UserPresenceInfo);
                    GameSaveSessionDescriptor.UserPresenceInfo userPresenceInfo2 = userPresenceInfo;
                    userPresenceInfo2.SteamUserID = attribute5;
                    userPresenceInfo = userPresenceInfo2;
                    int.TryParse(attribute4, out userPresenceInfo.Turn);
                    reader.ReadStartElement("Entry");
                    if (reader.NodeType == XmlNodeType.CDATA)
                    {
                        userPresenceInfo.UserName = reader.Value;
                        reader.Skip();
                    }
                    if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "Entry")
                    {
                        reader.ReadEndElement();
                    }
                    this.presence[j].Add(userPresenceInfo);
                }
                if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "UserPresenceInfo")
                {
                    reader.ReadEndElement();
                }
            }
            if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "UserPresence")
            {
                reader.ReadEndElement();
            }
        }
        reader.ReadEndElement();
        if (!this.lobbyData.ContainsKey("HeatWaveIntensity"))
        {
            this.lobbyData.Add("HeatWaveIntensity", "Moderate");
        }
        if (!this.lobbyData.ContainsKey("HeatWaveDuration"))
        {
            this.lobbyData.Add("HeatWaveDuration", "Moderate");
        }
        if (!this.lobbyData.ContainsKey("MadSeasonType"))
        {
            this.lobbyData.Add("MadSeasonType", "HighChanceShortDuration");
        }
        if (!this.lobbyData.ContainsKey("PlayWithMadSeason"))
        {
            this.lobbyData.Add("PlayWithMadSeason", "true");
        }
        if (!this.lobbyData.ContainsKey("PlayWithKaiju"))
        {
            this.lobbyData.Add("PlayWithKaiju", "true");
        }
    }
Esempio n. 19
0
        private void ReadTestCaseRuns(TestSuiteRun testSuiteRun, XmlReader xmlReader)
        {
            if (xmlReader.IsEmptyElement)
            {
                xmlReader.Skip();
                return;
            }

            xmlReader.Read();

            while (xmlReader.NodeType != XmlNodeType.EndElement)
            {
                switch (xmlReader.Name)
                {
                case "case":
                    string gallioStatus        = ReadAttribute(xmlReader, "status");
                    TestExecutionStatus status = TestExecutionStatus.NotImplemented;

                    switch (gallioStatus)
                    {
                    case "passed":
                        status = TestExecutionStatus.Successful;
                        break;

                    case "failed":
                        status = TestExecutionStatus.Failed;
                        break;

                    case "pending":
                    case "skipped":
                    case "inconclusive":
                        status = TestExecutionStatus.NotImplemented;
                        break;

                    default:
                        throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, "Gallio test status '{0}' not supported", gallioStatus));
                    }

                    TestCaseRun testCaseRun = new TestCaseRun(
                        ReadAttribute(xmlReader, "id"),
                        status);

                    ReadTestCaseRun(testCaseRun, xmlReader);

                    testSuiteRun.AddTestCaseRun(testCaseRun);

                    break;

                default:
                {
                    throw new NotSupportedException(
                              string.Format(
                                  CultureInfo.InvariantCulture,
                                  "Unsupported xml node '{0}'",
                                  xmlReader.Name));
                }
                }
            }

            xmlReader.Read();
        }
Esempio n. 20
0
        private void ProcessCppCheckLog(XmlReader reader, IResultLogWriter output, OptionallyEmittedData dataToInsert)
        {
            reader.ReadStartElement(_strings.Results);

            if (!StringReference.AreEqual(reader.LocalName, _strings.CppCheck))
            {
                throw reader.CreateException(ConverterResources.CppCheckCppCheckElementMissing);
            }

            string version = reader.GetAttribute(_strings.Version);

            if (version != null && !version.IsSemanticVersioningCompatible())
            {
                // This logic only fixes up simple cases, such as being passed
                // 1.66, where Semantic Versioning 2.0 requires 1.66.0. Also
                // strips Revision member if passed a complete .NET version.
                Version dotNetVersion;
                if (Version.TryParse(version, out dotNetVersion))
                {
                    version =
                        Math.Max(0, dotNetVersion.Major) + "." +
                        Math.Max(0, dotNetVersion.Minor) + "." +
                        Math.Max(0, dotNetVersion.Build);
                }
            }

            if (String.IsNullOrWhiteSpace(version))
            {
                throw reader.CreateException(ConverterResources.CppCheckCppCheckElementMissing);
            }

            reader.Skip(); // <cppcheck />

            if (!StringReference.AreEqual(reader.LocalName, _strings.Errors))
            {
                throw reader.CreateException(ConverterResources.CppCheckErrorsElementMissing);
            }

            var results = new List <Result>();

            if (reader.IsEmptyElement)
            {
                reader.Skip(); // <errors />
            }
            else
            {
                int errorsDepth = reader.Depth;
                reader.Read(); // <errors>

                while (reader.Depth > errorsDepth)
                {
                    var parsedError = CppCheckError.Parse(reader, _strings);
                    results.Add(parsedError.ToSarifIssue());
                }

                reader.ReadEndElement(); // </errors>
            }

            reader.ReadEndElement(); // </results>

            var run = new Run()
            {
                Tool = new Tool {
                    Driver = new ToolComponent {
                        Name = ToolName, Version = version
                    }
                },
            };

            PersistResults(output, results, run);
        }
        private TestOrder GetTestOrder(XmlReader reader)
        {
            if (reader == null)
            {
                throw new Exception("reader");
            }

            while (reader.NodeType != XmlNodeType.Element)
            {
                reader.Read();
            }

            if (reader.LocalName != "TestOrder")
            {
                throw new XmlException("Unexpected xml tag " + reader.LocalName);
            }

            reader.Read();

            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Read();
            }

            TestOrder testOrder = new TestOrder();

            while (reader.LocalName != "TestOrder")
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.LocalName)
                    {
                    case "ShipName":
                        testOrder.ShipName = reader.ReadElementContentAsString();
                        break;

                    case "ShipAddress":
                        testOrder.ShipAddress = reader.ReadElementContentAsString();
                        break;

                    case "ShipCity":
                        testOrder.ShipCity = reader.ReadElementContentAsString();
                        break;

                    case "ShipPostalCode":
                        testOrder.ShipPostalCode = reader.ReadElementContentAsString();
                        break;

                    case "ShipCountry":
                        testOrder.ShipCountry = reader.ReadElementContentAsString();
                        break;

                    case "PostalCode":
                        testOrder.PostalCode = reader.ReadElementContentAsString();
                        break;

                    case "CustomerID":
                        testOrder.CustomerID = reader.ReadElementContentAsString();
                        break;

                    case "Customers.CompanyName":
                        testOrder.Customers_CompanyName = reader.ReadElementContentAsString();
                        break;

                    case "HomePage":
                        testOrder.Salesperson = reader.ReadElementContentAsString();
                        break;

                    case "Address":
                        testOrder.Address = reader.ReadElementContentAsString();
                        break;

                    case "City":
                        testOrder.City = reader.ReadElementContentAsString();
                        break;

                    case "Country":
                        testOrder.Country = reader.ReadElementContentAsString();
                        break;

                    case "OrderID":
                        testOrder.OrderID = reader.ReadElementContentAsString();
                        break;

                    case "OrderDate":
                        testOrder.OrderDate = reader.ReadElementContentAsString();
                        break;

                    case "RequiredDate":
                        testOrder.RequiredDate = reader.ReadElementContentAsString();
                        break;

                    case "ShippedDate":
                        testOrder.ShippedDate = reader.ReadElementContentAsString();
                        break;

                    case "Shippers.CompanyName":
                        testOrder.Shippers_CompanyName = reader.ReadElementContentAsString();
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    if ((reader.LocalName == "TestOrders") && reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }
                }
            }
            return(testOrder);
        }
Esempio n. 22
0
        void IFlickrParsable.Load(XmlReader reader)
        {
            if (reader.LocalName != "method")
            {
                UtilityMethods.CheckParsingException(reader);
            }

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                case "name":
                    Name = reader.Value;
                    break;

                case "needslogin":
                    NeedsLogin = reader.Value == "1";
                    break;

                case "needssigning":
                    NeedsSigning = reader.Value == "1";
                    break;

                case "requiredperms":
                    RequiredPermissions = (MethodPermission)int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                    break;

                default:
                    UtilityMethods.CheckParsingException(reader);
                    break;
                }
            }

            reader.Read();

            while (reader.LocalName != "method")
            {
                switch (reader.LocalName)
                {
                case "description":
                    Description = reader.ReadElementContentAsString();
                    break;

                case "response":
                    Response = reader.ReadElementContentAsString();
                    break;

                case "explanation":
                    Explanation = reader.ReadElementContentAsString();
                    break;
                }
            }

            reader.ReadToFollowing("argument");

            while (reader.LocalName == "argument")
            {
                MethodArgument a = new MethodArgument();
                ((IFlickrParsable)a).Load(reader);
                Arguments.Add(a);
            }
            reader.ReadToFollowing("error");

            while (reader.LocalName == "error")
            {
                MethodError e = new MethodError();
                ((IFlickrParsable)e).Load(reader);
                Errors.Add(e);
            }
            reader.Read();

            reader.Skip();
        }
        private TestOrderDetail GetTestOrderDetail(XmlReader reader)
        {
            if (reader == null)
            {
                throw new Exception("reader");
            }

            while (reader.NodeType != XmlNodeType.Element)
            {
                reader.Read();
            }

            if (reader.LocalName != "TestOrderDetail")
            {
                throw new XmlException("Unexpected xml tag " + reader.LocalName);
            }

            reader.Read();

            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Read();
            }

            TestOrderDetail testOrderDetail = new TestOrderDetail();

            while (reader.LocalName != "TestOrderDetail")
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.LocalName)
                    {
                    case "OrderID":
                        testOrderDetail.OrderID = reader.ReadElementContentAsString();
                        break;

                    case "ProductID":
                        testOrderDetail.ProductID = reader.ReadElementContentAsString();
                        break;

                    case "ProductName":
                        testOrderDetail.ProductName = reader.ReadElementContentAsString();
                        break;

                    case "UnitPrice":
                        testOrderDetail.UnitPrice = reader.ReadElementContentAsString();
                        break;

                    case "Quantity":
                        testOrderDetail.Quantity = reader.ReadElementContentAsString();
                        break;

                    case "Discount":
                        testOrderDetail.Discount = reader.ReadElementContentAsString();
                        break;

                    case "ExtendedPrice":
                        testOrderDetail.ExtendedPrice = reader.ReadElementContentAsString();
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    if ((reader.LocalName == "TestOrderDetail") && reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }
                }
            }
            return(testOrderDetail);
        }
Esempio n. 24
0
        //=====================================================================

        /// <summary>
        /// This will parse the file content and extract the document type,
        /// unique ID, and revision number.
        /// </summary>
        /// <param name="reparse">If false and the file has already been
        /// parsed, the method just returns.  If true, the file is reparsed
        /// to refresh the information.</param>
        public void ParseContent(bool reparse)
        {
            XmlReaderSettings settings = new XmlReaderSettings();
            XmlReader         xr = null;
            string            attrValue, ext;
            int rev;

            if (!reparse && contentParsed)
            {
                return;
            }

            contentParsed = false;
            docType       = DocumentType.None;
            id            = errorMessage = null;
            revision      = 1;

            if (!File.Exists(fileItem.FullPath))
            {
                docType = DocumentType.NotFound;
                return;
            }

            // Don't bother parsing HTML files but support them for passing
            // through stuff like title pages which may not need to look like
            // the API topics.
            ext = Path.GetExtension(fileItem.FullPath).ToLowerInvariant();

            if (ext == ".htm" || ext == ".html" || ext == ".topic")
            {
                docType = DocumentType.Html;

                if (ext != ".topic")
                {
                    contentParsed = true;
                    this.ParseIdFromHtml();
                    return;
                }
            }

            try
            {
                settings.CloseInput     = true;
                settings.IgnoreComments = true;
                settings.IgnoreProcessingInstructions = true;
                settings.IgnoreWhitespace             = true;

                xr = XmlReader.Create(fileItem.FullPath, settings);
                xr.MoveToContent();

                while (!xr.EOF)
                {
                    if (xr.NodeType != XmlNodeType.Element)
                    {
                        xr.Read();
                    }
                    else
                    {
                        switch (xr.Name)
                        {
                        case "topic":
                            // If a <topic> element is found, parse the ID
                            // and revision number from it.
                            attrValue = xr.GetAttribute("id");

                            // The ID is required
                            if (attrValue != null && attrValue.Trim().Length != 0)
                            {
                                id = attrValue;
                            }
                            else
                            {
                                throw new XmlException("<topic> element " +
                                                       "is missing the 'id' attribute");
                            }

                            // This is optional
                            attrValue = xr.GetAttribute("revisionNumber");

                            if (attrValue != null && Int32.TryParse(attrValue, out rev))
                            {
                                revision = rev;
                            }

                            xr.Read();
                            break;

                        case "developerConceptualDocument":
                        case "developerErrorMessageDocument":
                        case "developerGlossaryDocument":
                        case "developerHowToDocument":
                        case "developerOrientationDocument":
                        case "codeEntityDocument":
                        case "developerReferenceWithSyntaxDocument":
                        case "developerReferenceWithoutSyntaxDocument":
                        case "developerSampleDocument":
                        case "developerSDKTechnologyOverviewArchitectureDocument":
                        case "developerSDKTechnologyOverviewCodeDirectoryDocument":
                        case "developerSDKTechnologyOverviewOrientationDocument":
                        case "developerSDKTechnologyOverviewScenariosDocument":
                        case "developerSDKTechnologyOverviewTechnologySummaryDocument":
                        case "developerTroubleshootingDocument":
                        case "developerUIReferenceDocument":
                        case "developerWalkthroughDocument":
                        case "developerWhitePaperDocument":
                        case "developerXmlReference":
                            docType = (DocumentType)Enum.Parse(typeof(DocumentType), xr.Name, true);
                            xr.Read();
                            break;

                        default:        // Ignore it
                            xr.Skip();
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                docType      = DocumentType.Invalid;
                errorMessage = ex.Message;
            }
            finally
            {
                if (xr != null)
                {
                    xr.Close();
                }

                contentParsed = true;
            }
        }
        private TestOrderTotal GetTestOrderTotal(XmlReader reader)
        {
            if (reader == null)
            {
                throw new Exception("reader");
            }

            while (reader.NodeType != XmlNodeType.Element)
            {
                reader.Read();
            }

            if (reader.LocalName != "TestOrderTotal")
            {
                throw new XmlException("Unexpected xml tag " + reader.LocalName);
            }

            reader.Read();

            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Read();
            }

            TestOrderTotal testOrderTotal = new TestOrderTotal();

            while (reader.LocalName != "TestOrderTotal")
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.LocalName)
                    {
                    case "OrderID":
                        testOrderTotal.OrderID = reader.ReadElementContentAsString();
                        break;

                    case "Subtotal":
                        testOrderTotal.Subtotal = reader.ReadElementContentAsString();
                        break;

                    case "Freight":
                        testOrderTotal.Freight = reader.ReadElementContentAsString();
                        break;

                    case "Total":
                        testOrderTotal.Total = reader.ReadElementContentAsString();
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    if ((reader.LocalName == "TestOrderTotal") && reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }
                }
            }
            return(testOrderTotal);
        }
Esempio n. 26
0
        /// <summary>
        /// Gets the persons from XML node.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <returns>IEnumerable{PersonInfo}.</returns>
        private PersonInfo GetPersonFromXmlNode(XmlReader reader)
        {
            var name      = string.Empty;
            var type      = PersonType.Actor; // If type is not specified assume actor
            var role      = string.Empty;
            int?sortOrder = null;

            reader.MoveToContent();

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "name":
                        name = reader.ReadElementContentAsString() ?? string.Empty;
                        break;

                    case "type":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            type = val;
                        }
                        break;
                    }

                    case "role":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            role = val;
                        }
                        break;
                    }

                    case "sortorder":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            int intVal;
                            if (int.TryParse(val, NumberStyles.Integer, _usCulture, out intVal))
                            {
                                sortOrder = intVal;
                            }
                        }
                        break;
                    }

                    default:
                        reader.Skip();
                        break;
                    }
                }
            }

            return(new PersonInfo
            {
                Name = name.Trim(),
                Role = role,
                Type = type,
                SortOrder = sortOrder
            });
        }
Esempio n. 27
0
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            switch (reader.Name)
            {
            // DateCreated
            case "dateadded":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime added;
                    if (DateTime.TryParseExact(val, BaseNfoSaver.DateAddedFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else if (DateTime.TryParse(val, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.LogWarning("Invalid Added value found: " + val);
                    }
                }
                break;
            }

            case "originaltitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(val))
                {
                    item.OriginalTitle = val;
                }
                break;
            }

            case "title":
            case "localtitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "criticrating":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(text))
                {
                    float value;
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        item.CriticRating = value;
                    }
                }

                break;
            }

            case "sorttitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }
                break;
            }

            case "biography":
            case "plot":
            case "review":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "countrycode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "lockedfields":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.LockedFields = val.Split('|').Select(i =>
                        {
                            MetadataFields field;

                            if (Enum.TryParse <MetadataFields>(i, true, out field))
                            {
                                return((MetadataFields?)field);
                            }

                            return(null);
                        }).Where(i => i.HasValue).Select(i => i.Value).ToArray();
                }

                break;
            }

            case "tagline":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Tagline = val;
                }
                break;
            }

            case "country":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ProductionLocations = val.Split('/')
                                               .Select(i => i.Trim())
                                               .Where(i => !string.IsNullOrWhiteSpace(i))
                                               .ToArray();
                }
                break;
            }

            case "mpaa":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }
                break;
            }

            case "customrating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }
                break;
            }

            case "runtime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    int runtime;
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }
                break;
            }

            case "aspectratio":
            {
                var val = reader.ReadElementContentAsString();

                var hasAspectRatio = item as IHasAspectRatio;
                if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
                {
                    hasAspectRatio.AspectRatio = val;
                }
                break;
            }

            case "lockdata":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }
                break;
            }

            case "studio":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    //var parts = val.Split('/')
                    //    .Select(i => i.Trim())
                    //    .Where(i => !string.IsNullOrWhiteSpace(i));

                    //foreach (var p in parts)
                    //{
                    //    item.AddStudio(p);
                    //}
                    item.AddStudio(val);
                }
                break;
            }

            case "director":
            {
                var val = reader.ReadElementContentAsString();
                foreach (var p in SplitNames(val).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "credits":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/').Select(i => i.Trim())
                                .Where(i => !string.IsNullOrEmpty(i));

                    foreach (var p in parts.Select(v => new PersonInfo {
                            Name = v.Trim(), Type = PersonType.Writer
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }
                        itemResult.AddPerson(p);
                    }
                }
                break;
            }

            case "writer":
            {
                var val = reader.ReadElementContentAsString();
                foreach (var p in SplitNames(val).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "actor":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        var person = GetPersonFromXmlNode(subtree);

                        if (!string.IsNullOrWhiteSpace(person.Name))
                        {
                            itemResult.AddPerson(person);
                        }
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "trailer":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    val = val.Replace("plugin://plugin.video.youtube/?action=play_video&videoid=", BaseNfoSaver.YouTubeWatchUrl, StringComparison.OrdinalIgnoreCase);

                    item.AddTrailerUrl(val);
                }
                break;
            }

            case "displayorder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }
                break;
            }

            case "year":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int productionYear;
                    if (int.TryParse(val, out productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "rating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    float val;
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out val))
                    {
                        item.CommunityRating = val;
                    }
                }
                break;
            }

            case "aired":
            case "formed":
            case "premiered":
            case "releasedate":
            {
                var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime date;

                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
                    {
                        item.PremiereDate   = date.ToUniversalTime();
                        item.ProductionYear = date.Year;
                    }
                }

                break;
            }

            case "enddate":
            {
                var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime date;

                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
                    {
                        item.EndDate = date.ToUniversalTime();
                    }
                }

                break;
            }

            case "genre":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/')
                                .Select(i => i.Trim())
                                .Where(i => !string.IsNullOrWhiteSpace(i));

                    foreach (var p in parts)
                    {
                        item.AddGenre(p);
                    }
                }
                break;
            }

            case "style":
            case "tag":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.AddTag(val);
                }
                break;
            }

            case "fileinfo":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromFileInfoNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            default:
                string readerName = reader.Name;
                string providerIdValue;
                if (_validProviderIds.TryGetValue(readerName, out providerIdValue))
                {
                    var id = reader.ReadElementContentAsString();
                    if (!string.IsNullOrWhiteSpace(id))
                    {
                        item.SetProviderId(providerIdValue, id);
                    }
                }
                else
                {
                    reader.Skip();
                }
                break;
            }
        }
Esempio n. 28
0
        private void FetchMainEpisodeInfo(MetadataResult <Episode> result, XmlReader reader, CancellationToken cancellationToken)
        {
            var item = result.Item;

            // Use XmlReader for best performance
            using (reader)
            {
                reader.MoveToContent();

                result.ResetPeople();

                // Loop through each element
                while (reader.Read())
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "id":
                        {
                            var val = reader.ReadElementContentAsString();
                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                item.SetProviderId(MetadataProviders.Tvdb, val);
                            }
                            break;
                        }

                        case "IMDB_ID":
                        {
                            var val = reader.ReadElementContentAsString();
                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                item.SetProviderId(MetadataProviders.Imdb, val);
                            }
                            break;
                        }

                        case "DVD_episodenumber":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                float num;

                                if (float.TryParse(val, NumberStyles.Any, _usCulture, out num))
                                {
                                    item.DvdEpisodeNumber = num;
                                }
                            }

                            break;
                        }

                        case "DVD_season":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                float num;

                                if (float.TryParse(val, NumberStyles.Any, _usCulture, out num))
                                {
                                    item.DvdSeasonNumber = Convert.ToInt32(num);
                                }
                            }

                            break;
                        }

                        case "EpisodeNumber":
                        {
                            if (!item.IndexNumber.HasValue)
                            {
                                var val = reader.ReadElementContentAsString();

                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    int rval;

                                    // int.TryParse is local aware, so it can be probamatic, force us culture
                                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                    {
                                        item.IndexNumber = rval;
                                    }
                                }
                            }

                            break;
                        }

                        case "SeasonNumber":
                        {
                            if (!item.ParentIndexNumber.HasValue)
                            {
                                var val = reader.ReadElementContentAsString();

                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    int rval;

                                    // int.TryParse is local aware, so it can be probamatic, force us culture
                                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                    {
                                        item.ParentIndexNumber = rval;
                                    }
                                }
                            }

                            break;
                        }

                        case "absolute_number":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AbsoluteEpisodeNumber = rval;
                                }
                            }

                            break;
                        }

                        case "airsbefore_episode":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AirsBeforeEpisodeNumber = rval;
                                }
                            }

                            break;
                        }

                        case "airsafter_season":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AirsAfterSeasonNumber = rval;
                                }
                            }

                            break;
                        }

                        case "airsbefore_season":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AirsBeforeSeasonNumber = rval;
                                }
                            }

                            break;
                        }

                        case "EpisodeName":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Name))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Name = val;
                                }
                            }
                            break;
                        }

                        case "Overview":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Overview))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Overview = val;
                                }
                            }
                            break;
                        }

                        case "Rating":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                float rval;

                                // float.TryParse is local aware, so it can be probamatic, force us culture
                                if (float.TryParse(val, NumberStyles.AllowDecimalPoint, _usCulture, out rval))
                                {
                                    item.CommunityRating = rval;
                                }
                            }
                            break;
                        }

                        case "RatingCount":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.VoteCount = rval;
                                }
                            }

                            break;
                        }

                        case "FirstAired":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                DateTime date;
                                if (DateTime.TryParse(val, out date))
                                {
                                    date = date.ToUniversalTime();

                                    item.PremiereDate   = date;
                                    item.ProductionYear = date.Year;
                                }
                            }

                            break;
                        }

                        case "Director":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Director);
                                }
                            }

                            break;
                        }

                        case "GuestStars":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddGuestStars(result, val);
                                }
                            }

                            break;
                        }

                        case "Writer":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Writer);
                                }
                            }

                            break;
                        }

                        default:
                            reader.Skip();
                            break;
                        }
                    }
                }
            }
        }
Esempio n. 29
0
        /// <summary>
        /// Gets the persons from XML node.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <returns>IEnumerable{PersonInfo}.</returns>
        private IEnumerable <PersonInfo> GetPersonsFromXmlNode(XmlReader reader)
        {
            var name      = string.Empty;
            var type      = PersonType.Actor; // If type is not specified assume actor
            var role      = string.Empty;
            int?sortOrder = null;

            reader.MoveToContent();
            reader.Read();

            // Loop through each element
            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "Name":
                        name = reader.ReadElementContentAsString() ?? string.Empty;
                        break;

                    case "Type":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            type = val;
                        }
                        break;
                    }

                    case "Role":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            role = val;
                        }
                        break;
                    }

                    case "SortOrder":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            if (int.TryParse(val, NumberStyles.Integer, _usCulture, out var intVal))
                            {
                                sortOrder = intVal;
                            }
                        }
                        break;
                    }

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                }
            }

            var personInfo = new PersonInfo
            {
                Name      = name.Trim(),
                Role      = role,
                Type      = type,
                SortOrder = sortOrder
            };

            return(new[] { personInfo });
        }
Esempio n. 30
0
        private protected override void Populate(XmlReader xmlReader, OpenXmlLoadMode loadMode)
        {
            LoadAttributes(xmlReader);

            if (!xmlReader.IsEmptyElement)
            {                     // only when element is not empty (not  <element />).
                xmlReader.Read(); // read this element

                RawInnerText = string.Empty;

                int         unwanted         = 0;
                int         textNodePosition = -1; // the position of the text in the ShadowElement's children when there are other unexpected node.
                XmlNodeType textNodeType     = XmlNodeType.Text;

                if (xmlReader.NodeType == XmlNodeType.EndElement)
                {
                    Debug.Assert(xmlReader.LocalName.Equals(LocalName));
                }
                else
                {
                    while (!xmlReader.EOF)
                    {
                        if (xmlReader.NodeType == XmlNodeType.EndElement)
                        {
                            Debug.Assert(xmlReader.LocalName.Equals(LocalName));
                            break;
                        }
                        else if (string.IsNullOrEmpty(RawInnerText) &&
                                 (xmlReader.NodeType == XmlNodeType.Text ||
                                  xmlReader.NodeType == XmlNodeType.CDATA ||
                                  xmlReader.NodeType == XmlNodeType.SignificantWhitespace ||
                                  xmlReader.NodeType == XmlNodeType.Whitespace /* O15:#3024890 */))
                        {
                            // text or CDATA
                            // scenario: normal text element <Application>Microsoft Office Word</Application>
                            // scenario: <w:t>This is <![CDATA[Xml Example <tag>text</tag>.]]> 1</w:t>

                            // only load text when no text is loaded,
                            // for case "<foo/>Text1<bar/>Text2", only load "Text1", very rare case
                            RawInnerText     = xmlReader.Value;
                            textNodePosition = unwanted;
                            textNodeType     = xmlReader.NodeType;

                            xmlReader.Read();
                        }
                        else
                        {
                            Debug.Assert(xmlReader.NodeType != XmlNodeType.EntityReference);

                            // Load unexpected children if there are any.
                            OpenXmlElement child = ElementFactory(xmlReader);
                            child.Load(xmlReader, OpenXmlLoadMode.Full);
                            unwanted++;

                            if (ShadowElement == null)
                            {
                                ShadowElement = new OpenXmlUnknownElement(Prefix, LocalName, NamespaceUri);
                            }

                            ShadowElement.AppendChild(child);
                        }
                    }
                }

                if (unwanted == 0)
                {
                    // only text node, no unwanted children
                    Debug.Assert(ShadowElement == null);
                }
                else if (textNodePosition > -1)
                {
                    // place an OpenXmlMiscNode for the loaded text in the ShadowElement so that we can write out correct content in serialization.
                    OpenXmlMiscNode textNode = null;
                    switch (textNodeType)
                    {
                    case XmlNodeType.Text:
                        textNode = OpenXmlMiscNode.CreateFromText(RawInnerText);
                        break;

                    case XmlNodeType.CDATA:
                        textNode = OpenXmlMiscNode.CreateFromCdata(RawInnerText);
                        break;

                    case XmlNodeType.SignificantWhitespace:
                    case XmlNodeType.Whitespace:     /* O15:#3024890 */
                        textNode = OpenXmlMiscNode.CreateFromSignificantWhitespace(RawInnerText);
                        break;
                    }

                    ShadowElement.InsertAt(textNode, textNodePosition);
                }
                else
                {
                    // textNodePosition == -1, no text loaded.
                }
            }

            xmlReader.Skip(); // skip the end tag

            // set raw outer xml to empty to indicate that it is passed
            RawOuterXml = string.Empty;
        }
Esempio n. 31
0
        /// <summary>
        /// Fetches metadata from one Xml Element
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="itemResult">The item result.</param>
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            switch (reader.Name)
            {
            // DateCreated
            case "Added":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (DateTime.TryParse(val, out var added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.LogWarning("Invalid Added value found: " + val);
                    }
                }
                break;
            }

            case "OriginalTitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(val))
                {
                    item.OriginalTitle = val;
                }
                break;
            }

            case "LocalTitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "CriticRating":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(text))
                {
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out var value))
                    {
                        item.CriticRating = value;
                    }
                }

                break;
            }

            case "SortTitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }
                break;
            }

            case "Overview":
            case "Description":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "Language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "CountryCode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "PlaceOfBirth":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var person = item as Person;
                    if (person != null)
                    {
                        person.ProductionLocations = new string[] { val };
                    }
                }

                break;
            }

            case "LockedFields":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.LockedFields = val.Split('|').Select(i =>
                        {
                            if (Enum.TryParse(i, true, out MetadataFields field))
                            {
                                return((MetadataFields?)field);
                            }

                            return(null);
                        }).Where(i => i.HasValue).Select(i => i.Value).ToArray();
                }

                break;
            }

            case "TagLines":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromTaglinesNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Countries":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromCountriesNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "ContentRating":
            case "MPAARating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }
                break;
            }

            case "CustomRating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }
                break;
            }

            case "RunningTime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out var runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }
                break;
            }

            case "AspectRatio":
            {
                var val = reader.ReadElementContentAsString();

                var hasAspectRatio = item as IHasAspectRatio;
                if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
                {
                    hasAspectRatio.AspectRatio = val;
                }
                break;
            }

            case "LockData":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }
                break;
            }

            case "Network":
            {
                foreach (var name in SplitNames(reader.ReadElementContentAsString()))
                {
                    if (string.IsNullOrWhiteSpace(name))
                    {
                        continue;
                    }
                    item.AddStudio(name);
                }
                break;
            }

            case "Director":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Writer":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Actors":
            {
                var actors = reader.ReadInnerXml();

                if (actors.Contains("<"))
                {
                    // This is one of the mis-named "Actors" full nodes created by MB2
                    // Create a reader and pass it to the persons node processor
                    FetchDataFromPersonsNode(XmlReader.Create(new StringReader("<Persons>" + actors + "</Persons>")), itemResult);
                }
                else
                {
                    // Old-style piped string
                    foreach (var p in SplitNames(actors).Select(v => new PersonInfo {
                            Name = v.Trim(), Type = PersonType.Actor
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }
                        itemResult.AddPerson(p);
                    }
                }
                break;
            }

            case "GuestStars":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.GuestStar
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Trailer":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.AddTrailerUrl(val);
                }
                break;
            }

            case "DisplayOrder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }
                break;
            }

            case "Trailers":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchDataFromTrailersNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "ProductionYear":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (int.TryParse(val, out var productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "Rating":
            case "IMDBrating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
                    {
                        item.CommunityRating = val;
                    }
                }
                break;
            }

            case "BirthDate":
            case "PremiereDate":
            case "FirstAired":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
                    {
                        item.PremiereDate   = airDate.ToUniversalTime();
                        item.ProductionYear = airDate.Year;
                    }
                }

                break;
            }

            case "DeathDate":
            case "EndDate":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
                    {
                        item.EndDate = airDate.ToUniversalTime();
                    }
                }

                break;
            }

            case "CollectionNumber":
                var tmdbCollection = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdbCollection))
                {
                    item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
                }
                break;

            case "Genres":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromGenresNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Tags":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromTagsNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Persons":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchDataFromPersonsNode(subtree, itemResult);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Studios":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromStudiosNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Shares":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        var hasShares = item as IHasShares;
                        if (hasShares != null)
                        {
                            FetchFromSharesNode(subtree, hasShares);
                        }
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Format3D":
            {
                var val = reader.ReadElementContentAsString();

                var video = item as Video;

                if (video != null)
                {
                    if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.HalfSideBySide;
                    }
                    else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
                    }
                    else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.FullTopAndBottom;
                    }
                    else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.FullSideBySide;
                    }
                    else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.MVC;
                    }
                }
                break;
            }

            default:
            {
                string readerName = reader.Name;
                if (_validProviderIds.TryGetValue(readerName, out string providerIdValue))
                {
                    var id = reader.ReadElementContentAsString();
                    if (!string.IsNullOrWhiteSpace(id))
                    {
                        item.SetProviderId(providerIdValue, id);
                    }
                }
                else
                {
                    reader.Skip();
                }

                break;
            }
            }
        }
Esempio n. 32
0
        public static void ReadObject(XmlReader reader, object obj, PropertyConversionHandler handler = null)
        {
            if (obj == null)
                throw new ArgumentNullException("obj");

            reader.MoveToContent();

            if (obj is IXmlSerializable)
            {
                ((IXmlSerializable)obj).ReadXml(reader);
            }
            else
            {
                object oVal = null;
                string oName = GetAttributeValue(obj.GetType(), typeof(XmlRootAttribute), "ElementName", true, ref oVal) ? oVal.ToString() : obj.GetType().Name;
                if (reader.LocalName != oName)
                    throw new XmlException("XML element name does not match object.");

                if (!reader.IsEmptyElement)
                {
                    reader.ReadStartElement();
                    reader.MoveToContent();
                    ReadObjectProperties(reader, obj, handler);
                    reader.ReadEndElement();
                }
                else
                    reader.Skip();
            }
        }
	// DEBUG INFORMATION

	// Method updates warning log and moves XML reader passed unknown elements
	void displayWarning(XmlReader myReader,string elementName,string parentTag)
	{
		// Set warning flag and add details to error log
		warning = true;
		myLog += "\nFound in Jellyfish '" + jellyfishName + "':" +
		"\nUnknown element found inside <"+parentTag+"> tag: <"+elementName+">\n";

		// Reader skips this unrecognised element (and all child elements of this tag)
		myReader.Skip();
	}