public static Task <Show> GetFullDetailsAsync(
            this SimplifiedShow show,
            HttpClient httpClient,
            IAccessTokenProvider accessTokenProvider,
            CancellationToken cancellationToken = default)
        {
            if (show is Show original)
            {
                return(Task.FromResult(original));
            }

            return(httpClient.GetAsync <Show>(show.Href, accessTokenProvider, cancellationToken));
        }
Пример #2
0
        public override Episode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            if (reader.TokenType is not JsonTokenType.StartObject)
            {
                throw new JsonException();
            }

            var externalUrlsConverter   = options.GetConverter <ExternalUrls>();
            var imageArrayConverter     = options.GetConverter <ImageArray>();
            var resumePointConverter    = options.GetConverter <ResumePoint>();
            var simplifiedShowConverter = options.GetConverter <SimplifiedShow>();
            var stringArrayConverter    = options.GetConverter <StringArray>();
            var uriConverter            = options.GetConverter <Uri>();

            string               id                   = string.Empty;
            Uri                  uri                  = null !;
            Uri                  href                 = null !;
            string               name                 = string.Empty;
            string               description          = string.Empty;
            ImageArray           images               = Array.Empty <Image>();
            SimplifiedShow       show                 = null !;
            int                  duration             = default;
            DateTime             releaseDate          = default;
            ReleaseDatePrecision releaseDatePrecision = default;
            bool                 isExplicit           = default;
            bool                 isPlayable           = default;
            bool                 isExternallyHosted   = default;
            StringArray          languages            = Array.Empty <string>();
            Uri?                 audioPreviewUrl      = null;
            ExternalUrls         externalUrls         = null !;
            ResumePoint?         resumePoint          = null;

            while (reader.Read())
            {
                if (reader.TokenType is JsonTokenType.EndObject)
                {
                    break;
                }

                if (reader.TokenType is not JsonTokenType.PropertyName)
                {
                    throw new JsonException();
                }

                var propertyName = reader.GetString();

                reader.Read(); // Skip to next token.

                switch (propertyName)
                {
                case "id":
                    id = reader.GetString() !;
                    break;

                case "uri":
                    uri = uriConverter.Read(ref reader, typeof(Uri), options) !;
                    break;

                case "href":
                    href = uriConverter.Read(ref reader, typeof(Uri), options) !;
                    break;

                case "name":
                    name = reader.GetString() !;
                    break;

                case "description":
                    description = reader.GetString() !;
                    break;

                case "images":
                    images = imageArrayConverter.Read(ref reader, typeof(ImageArray), options) !;
                    break;

                case "show":
                    show = simplifiedShowConverter.Read(ref reader, typeof(SimplifiedShow), options) !;
                    break;

                case "duration_ms":
                    duration = reader.GetInt32();
                    break;

                case "release_date":
                    releaseDate = reader.GetReleaseDate();
                    break;

                case "release_date_precision":
                    releaseDatePrecision = ReleaseDatePrecisionConverter.FromSpotifyString(reader.GetString() !);
                    break;

                case "explicit":
                    isExplicit = reader.GetBoolean();
                    break;

                case "is_playable":
                    isPlayable = reader.GetBoolean();
                    break;

                case "is_externally_hosted":
                    isExternallyHosted = reader.GetBoolean();
                    break;

                case "languages":
                    languages = stringArrayConverter.Read(ref reader, typeof(StringArray), options) !;
                    break;

                case "audio_preview_url":
                    audioPreviewUrl = (reader.TokenType is JsonTokenType.Null) ? null : uriConverter.Read(ref reader, typeof(Uri), options !);
                    break;

                case "external_urls":
                    externalUrls = externalUrlsConverter.Read(ref reader, typeof(ExternalUrls), options) !;
                    break;

                case "resume_point":
                    resumePoint = resumePointConverter.Read(ref reader, typeof(ResumePoint), options);
                    break;

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

            return(new(
                       id,
                       uri,
                       href,
                       name,
                       description,
                       images,
                       show,
                       duration,
                       releaseDate,
                       releaseDatePrecision,
                       isExplicit,
                       isPlayable,
                       isExternallyHosted,
                       languages,
                       audioPreviewUrl,
                       externalUrls,
                       resumePoint));
        }