Example #1
0
        public static RunVideos Parse(SpeedrunComClient client, dynamic videosElement)
        {
            if (videosElement == null)
                return null;

            var videos = new RunVideos();

            videos.Text = videosElement.text as string;

            videos.Links = client.ParseCollection(videosElement.links, new Func<dynamic, Uri>(parseVideoLink));

            return videos;
        }
Example #2
0
        public static RunVideos Parse(SpeedrunComClient client, dynamic videosElement)
        {
            if (videosElement == null)
            {
                return(null);
            }

            var videos = new RunVideos();

            videos.Text = videosElement.text as string;

            videos.Links = client.ParseCollection(videosElement.links, new Func <dynamic, Uri>(parseVideoLink));

            return(videos);
        }
Example #3
0
        public static RunVideos Parse(SpeedrunComClient client, dynamic videosElement)
        {
            if (videosElement == null)
            {
                return(null);
            }

            IDictionary <string, dynamic> properties = videosElement as IDictionary <string, dynamic>;

            RunVideos videos = new RunVideos();

            if (properties.ContainsKey("text"))
            {
                videos.Text = properties["text"];
            }

            if (properties.ContainsKey("links"))
            {
                videos.Links = client.ParseCollection(properties["links"], new Func <dynamic, Uri>(parseVideoLink));
            }


            return(videos);
        }
        internal static void Parse(Run run, SpeedrunComClient client, dynamic runElement)
        {
            //Parse Attributes
            IDictionary <string, dynamic> properties = runElement as IDictionary <string, dynamic>;

            run.ID      = properties["id"] as string;
            run.WebLink = new Uri(properties["weblink"] as string);
            run.Videos  = RunVideos.Parse(client, properties["videos"]) as RunVideos;
            run.Comment = properties["comment"] as string;
            run.Status  = RunStatus.Parse(client, properties["status"]) as RunStatus;

            Func <dynamic, Player> parsePlayer = x => Player.Parse(client, x) as Player;

            if (properties["players"] is IEnumerable <dynamic> )
            {
                run.Players = client.ParseCollection(properties["players"], parsePlayer);
            }
            else if (properties["players"] is System.Collections.ArrayList && properties["players"].Count == 0)
            {
                run.Players = new List <Player>().AsReadOnly();
            }
            else
            {
                run.Players = client.ParseCollection(properties["players"].data, parsePlayer);
            }

            if (properties.ContainsKey("date"))
            {
                if (properties["date"] != null)
                {
                    run.Date = DateTime.ParseExact(properties["date"].ToString(), "yyyy-MM-dd", CultureInfo.InvariantCulture);
                }
            }

            if (properties.ContainsKey("submitted"))
            {
                if (runElement.submitted != null)
                {
                    run.DateSubmitted = (DateTime)runElement.submitted;
                }
            }

            run.Times  = RunTimes.Parse(client, properties["times"]);
            run.System = RunSystem.Parse(client, properties["system"]);

            var splits = properties["splits"];

            if (splits != null)
            {
                run.SplitsUri = new Uri(splits.uri as string);
            }

            if (properties.ContainsKey("values"))
            {
                var valueProperties = properties["values"] as IDictionary <string, dynamic>;

                run.VariableValues = valueProperties.Select(x => VariableValue.ParseValueDescriptor(client, x) as VariableValue).ToList().AsReadOnly();
            }
            else
            {
                run.VariableValues = new List <VariableValue>().AsReadOnly();
            }

            //Parse Links

            if (properties["game"] is string)
            {
                run.GameID = properties["game"] as string;
                run.game   = new Lazy <Game>(() => client.Games.GetGame(run.GameID));
            }
            else
            {
                var game = Game.Parse(client, properties["game"]["data"]) as Game;
                run.game   = new Lazy <Game>(() => game);
                run.GameID = game.ID;
            }

            if (properties["category"] == null)
            {
                run.category = new Lazy <Category>(() => null);
            }
            else if (properties["category"] is string)
            {
                run.CategoryID = properties["category"] as string;
                run.category   = new Lazy <Category>(() => client.Categories.GetCategory(run.CategoryID));
            }
            else
            {
                var category = Category.Parse(client, properties["category"].data) as Category;
                run.category = new Lazy <Category>(() => category);

                if (category != null)
                {
                    run.CategoryID = category.ID;
                }
            }

            if (properties["level"] == null)
            {
                run.level = new Lazy <Level>(() => null);
            }
            else if (properties["level"] is string)
            {
                run.LevelID = properties["level"] as string;
                run.level   = new Lazy <Level>(() => client.Levels.GetLevel(run.LevelID));
            }
            else
            {
                if (properties["level"].data as string != null)
                {
                    Level level = Level.Parse(client, properties["level"].data);

                    run.level = new Lazy <Level>(() => level);

                    if (level != null)
                    {
                        run.LevelID = level.ID;
                    }
                }
                else
                {
                    run.level = new Lazy <Level>(() => null);
                }
            }

            if (properties.ContainsKey("platform"))
            {
                Platform platform = Platform.Parse(client, properties["platform"].data);

                run.System.platform = new Lazy <Platform>(() => platform);
            }

            if (properties.ContainsKey("region"))
            {
                Region region = Region.Parse(client, properties["region"].data);

                run.System.region = new Lazy <Region>(() => region);
            }

            if (!string.IsNullOrEmpty(run.Status.ExaminerUserID))
            {
                run.examiner = new Lazy <User>(() => client.Users.GetUser(run.Status.ExaminerUserID));
            }
            else
            {
                run.examiner = new Lazy <User>(() => null);
            }
        }
Example #5
0
        internal static void Parse(Run run, SpeedrunComClient client, dynamic runElement)
        {
            //Parse Attributes

            run.ID      = runElement.id as string;
            run.WebLink = new Uri(runElement.weblink as string);
            run.Videos  = RunVideos.Parse(client, runElement.videos) as RunVideos;
            run.Comment = runElement.comment as string;
            run.Status  = RunStatus.Parse(client, runElement.status) as RunStatus;

            Func <dynamic, Player> parsePlayer = x => Player.Parse(client, x) as Player;

            if (runElement.players is IEnumerable <dynamic> )
            {
                run.Players = client.ParseCollection(runElement.players, parsePlayer);
            }
            else if (runElement.players is System.Collections.ArrayList && runElement.players.Count == 0)
            {
                run.Players = new List <Player>().AsReadOnly();
            }
            else
            {
                run.Players = client.ParseCollection(runElement.players.data, parsePlayer);
            }

            var runDate = runElement.date;

            if (!string.IsNullOrEmpty(runDate))
            {
                run.Date = DateTime.Parse(runDate, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
            }

            var dateSubmitted = runElement.submitted;

            if (!string.IsNullOrEmpty(dateSubmitted))
            {
                run.DateSubmitted = DateTime.Parse(dateSubmitted, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
            }

            run.Times  = RunTimes.Parse(client, runElement.times) as RunTimes;
            run.System = RunSystem.Parse(client, runElement.system) as RunSystem;

            var splits = runElement.splits;

            if (splits != null)
            {
                run.SplitsUri = new Uri(splits.uri as string);
            }

            if (runElement.values is DynamicJsonObject)
            {
                var valueProperties = runElement.values.Properties as IDictionary <string, dynamic>;
                run.VariableValues = valueProperties.Select(x => VariableValue.ParseValueDescriptor(client, x) as VariableValue).ToList().AsReadOnly();
            }
            else
            {
                run.VariableValues = new List <VariableValue>().AsReadOnly();
            }

            //Parse Links

            var properties = runElement.Properties as IDictionary <string, dynamic>;

            if (properties["game"] is string)
            {
                run.GameID = runElement.game as string;
                run.game   = new Lazy <Game>(() => client.Games.GetGame(run.GameID));
            }
            else
            {
                var game = Game.Parse(client, properties["game"].data) as Game;
                run.game   = new Lazy <Game>(() => game);
                run.GameID = game.ID;
            }

            if (properties["category"] == null)
            {
                run.category = new Lazy <Category>(() => null);
            }
            else if (properties["category"] is string)
            {
                run.CategoryID = runElement.category as string;
                run.category   = new Lazy <Category>(() => client.Categories.GetCategory(run.CategoryID));
            }
            else
            {
                var category = Category.Parse(client, properties["category"].data) as Category;
                run.category = new Lazy <Category>(() => category);
                if (category != null)
                {
                    run.CategoryID = category.ID;
                }
            }

            if (properties["level"] == null)
            {
                run.level = new Lazy <Level>(() => null);
            }
            else if (properties["level"] is string)
            {
                run.LevelID = runElement.level as string;
                run.level   = new Lazy <Level>(() => client.Levels.GetLevel(run.LevelID));
            }
            else
            {
                var level = Level.Parse(client, properties["level"].data) as Level;
                run.level = new Lazy <Level>(() => level);
                if (level != null)
                {
                    run.LevelID = level.ID;
                }
            }

            if (properties.ContainsKey("platform"))
            {
                var platform = Platform.Parse(client, properties["platform"].data) as Platform;
                run.System.platform = new Lazy <Platform>(() => platform);
            }

            if (properties.ContainsKey("region"))
            {
                var region = Region.Parse(client, properties["region"].data) as Region;
                run.System.region = new Lazy <Region>(() => region);
            }

            if (!string.IsNullOrEmpty(run.Status.ExaminerUserID))
            {
                run.examiner = new Lazy <User>(() => client.Users.GetUser(run.Status.ExaminerUserID));
            }
            else
            {
                run.examiner = new Lazy <User>(() => null);
            }
        }