1830 lines
52 KiB
C#
1830 lines
52 KiB
C#
// INSTRUCTIONS FOR GENERATING
|
|
// ===========================
|
|
// library api with all response_groups
|
|
// https://app.quicktype.io/
|
|
// left pane:
|
|
// name=LibraryApiV10
|
|
// paste in full output of library api with all response_groups
|
|
// right pane:
|
|
// namespace: DTOs
|
|
// array
|
|
// complete
|
|
// make all properties optional. this adds unneeded stuff (see next step) but also needed stuff
|
|
// remove all instances of ", NullValueHandling = NullValueHandling.Ignore"
|
|
// PurchaseDate is not optional. remove "?" from type
|
|
// Status is not optional. remove "?" from type
|
|
// RuntimeLengthMin type: int?
|
|
// add comments to class
|
|
// Audible API. GET /1.0/library , GET /1.0/library/{asin}
|
|
// rename Author class to Person
|
|
|
|
// <auto-generated />
|
|
//
|
|
// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
|
|
//
|
|
// using DTOs;
|
|
//
|
|
// var libraryApiV10 = LibraryApiV10.FromJson(jsonString);
|
|
|
|
namespace DTOs
|
|
{
|
|
using System;
|
|
using System.Globalization;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Converters;
|
|
|
|
/// <summary>
|
|
/// Audible API. GET /1.0/library , GET /1.0/library/{asin}
|
|
/// </summary>
|
|
public partial class LibraryApiV10
|
|
{
|
|
[JsonProperty("items")]
|
|
public Item[] Items { get; set; }
|
|
|
|
[JsonProperty("response_groups")]
|
|
public string[] ResponseGroups { get; set; }
|
|
}
|
|
|
|
public partial class Item
|
|
{
|
|
[JsonProperty("asin")]
|
|
public string Asin { get; set; }
|
|
|
|
[JsonProperty("audible_editors_summary")]
|
|
public string AudibleEditorsSummary { get; set; }
|
|
|
|
[JsonProperty("authors")]
|
|
public Person[] Authors { get; set; }
|
|
|
|
[JsonProperty("availability")]
|
|
public object Availability { get; set; }
|
|
|
|
[JsonProperty("available_codecs")]
|
|
public AvailableCodec[] AvailableCodecs { get; set; }
|
|
|
|
[JsonProperty("badge_types")]
|
|
public object BadgeTypes { get; set; }
|
|
|
|
[JsonProperty("buying_options")]
|
|
public object BuyingOptions { get; set; }
|
|
|
|
[JsonProperty("category_ladders")]
|
|
public CategoryLadder[] CategoryLadders { get; set; }
|
|
|
|
[JsonProperty("claim_code_url")]
|
|
public object ClaimCodeUrl { get; set; }
|
|
|
|
[JsonProperty("content_delivery_type")]
|
|
public ContentDeliveryType? ContentDeliveryType { get; set; }
|
|
|
|
[JsonProperty("content_level")]
|
|
public object ContentLevel { get; set; }
|
|
|
|
[JsonProperty("content_rating")]
|
|
public ContentRating ContentRating { get; set; }
|
|
|
|
[JsonProperty("content_type")]
|
|
public ContentType? ContentType { get; set; }
|
|
|
|
[JsonProperty("copyright")]
|
|
public object Copyright { get; set; }
|
|
|
|
[JsonProperty("credits_required")]
|
|
public object CreditsRequired { get; set; }
|
|
|
|
[JsonProperty("customer_reviews")]
|
|
public Review[] CustomerReviews { get; set; }
|
|
|
|
[JsonProperty("date_first_available")]
|
|
public object DateFirstAvailable { get; set; }
|
|
|
|
[JsonProperty("distribution_rights_region")]
|
|
public object DistributionRightsRegion { get; set; }
|
|
|
|
[JsonProperty("editorial_reviews")]
|
|
public string[] EditorialReviews { get; set; }
|
|
|
|
[JsonProperty("extended_product_description")]
|
|
public object ExtendedProductDescription { get; set; }
|
|
|
|
[JsonProperty("format_type")]
|
|
public FormatType? FormatType { get; set; }
|
|
|
|
[JsonProperty("generic_keyword")]
|
|
public object GenericKeyword { get; set; }
|
|
|
|
[JsonProperty("has_children")]
|
|
public bool? HasChildren { get; set; }
|
|
|
|
[JsonProperty("image_url")]
|
|
public object ImageUrl { get; set; }
|
|
|
|
[JsonProperty("invites_remaining")]
|
|
public object InvitesRemaining { get; set; }
|
|
|
|
[JsonProperty("is_adult_product")]
|
|
public bool? IsAdultProduct { get; set; }
|
|
|
|
[JsonProperty("is_buyable")]
|
|
public object IsBuyable { get; set; }
|
|
|
|
[JsonProperty("is_downloaded")]
|
|
public bool? IsDownloaded { get; set; }
|
|
|
|
[JsonProperty("is_finished")]
|
|
public object IsFinished { get; set; }
|
|
|
|
[JsonProperty("is_in_wishlist")]
|
|
public object IsInWishlist { get; set; }
|
|
|
|
[JsonProperty("is_listenable")]
|
|
public bool? IsListenable { get; set; }
|
|
|
|
[JsonProperty("is_preorderable")]
|
|
public object IsPreorderable { get; set; }
|
|
|
|
[JsonProperty("is_returnable")]
|
|
public bool? IsReturnable { get; set; }
|
|
|
|
[JsonProperty("is_searchable")]
|
|
public object IsSearchable { get; set; }
|
|
|
|
[JsonProperty("is_ws4v_companion_asin_owned")]
|
|
public object IsWs4VCompanionAsinOwned { get; set; }
|
|
|
|
[JsonProperty("is_ws4v_enabled")]
|
|
public object IsWs4VEnabled { get; set; }
|
|
|
|
[JsonProperty("isbn")]
|
|
public object Isbn { get; set; }
|
|
|
|
[JsonProperty("issue_date")]
|
|
public DateTimeOffset? IssueDate { get; set; }
|
|
|
|
[JsonProperty("language")]
|
|
public Language? Language { get; set; }
|
|
|
|
[JsonProperty("member_giving_status")]
|
|
public object MemberGivingStatus { get; set; }
|
|
|
|
[JsonProperty("merchandising_description")]
|
|
public object MerchandisingDescription { get; set; }
|
|
|
|
[JsonProperty("merchandising_summary")]
|
|
public string MerchandisingSummary { get; set; }
|
|
|
|
[JsonProperty("narration_accent")]
|
|
public object NarrationAccent { get; set; }
|
|
|
|
[JsonProperty("narrators")]
|
|
public Person[] Narrators { get; set; }
|
|
|
|
[JsonProperty("order_id")]
|
|
public object OrderId { get; set; }
|
|
|
|
[JsonProperty("order_item_id")]
|
|
public object OrderItemId { get; set; }
|
|
|
|
[JsonProperty("origin_asin")]
|
|
public string OriginAsin { get; set; }
|
|
|
|
[JsonProperty("origin_id")]
|
|
public string OriginId { get; set; }
|
|
|
|
[JsonProperty("origin_marketplace")]
|
|
public OriginMarketplace? OriginMarketplace { get; set; }
|
|
|
|
[JsonProperty("origin_type")]
|
|
public OriginType? OriginType { get; set; }
|
|
|
|
[JsonProperty("part_number")]
|
|
public object PartNumber { get; set; }
|
|
|
|
[JsonProperty("pdf_link")]
|
|
public Uri PdfLink { get; set; }
|
|
|
|
[JsonProperty("pdf_url")]
|
|
public Uri PdfUrl { get; set; }
|
|
|
|
[JsonProperty("percent_complete")]
|
|
public double? PercentComplete { get; set; }
|
|
|
|
[JsonProperty("periodical_info")]
|
|
public object PeriodicalInfo { get; set; }
|
|
|
|
[JsonProperty("plans")]
|
|
public Plan[] Plans { get; set; }
|
|
|
|
[JsonProperty("platinum_keywords")]
|
|
public object PlatinumKeywords { get; set; }
|
|
|
|
[JsonProperty("price")]
|
|
public Price Price { get; set; }
|
|
|
|
[JsonProperty("product_images")]
|
|
public ProductImages ProductImages { get; set; }
|
|
|
|
[JsonProperty("product_page_url")]
|
|
public object ProductPageUrl { get; set; }
|
|
|
|
[JsonProperty("product_site_launch_date")]
|
|
public object ProductSiteLaunchDate { get; set; }
|
|
|
|
[JsonProperty("provided_review")]
|
|
public Review ProvidedReview { get; set; }
|
|
|
|
[JsonProperty("publication_name")]
|
|
public string PublicationName { get; set; }
|
|
|
|
[JsonProperty("publisher_name")]
|
|
public string PublisherName { get; set; }
|
|
|
|
[JsonProperty("publisher_summary")]
|
|
public string PublisherSummary { get; set; }
|
|
|
|
[JsonProperty("purchase_date")]
|
|
public DateTimeOffset PurchaseDate { get; set; }
|
|
|
|
[JsonProperty("rating")]
|
|
public Rating Rating { get; set; }
|
|
|
|
[JsonProperty("read_along_support")]
|
|
public object ReadAlongSupport { get; set; }
|
|
|
|
[JsonProperty("relationships")]
|
|
public Relationship[] Relationships { get; set; }
|
|
|
|
[JsonProperty("release_date")]
|
|
public DateTimeOffset? ReleaseDate { get; set; }
|
|
|
|
[JsonProperty("runtime_length_min")]
|
|
public int? RuntimeLengthMin { get; set; }
|
|
|
|
[JsonProperty("sample_url")]
|
|
public Uri SampleUrl { get; set; }
|
|
|
|
[JsonProperty("series")]
|
|
public Series[] Series { get; set; }
|
|
|
|
[JsonProperty("sku")]
|
|
public string Sku { get; set; }
|
|
|
|
[JsonProperty("sku_lite")]
|
|
public string SkuLite { get; set; }
|
|
|
|
[JsonProperty("status")]
|
|
public Status Status { get; set; }
|
|
|
|
[JsonProperty("subscription_asins")]
|
|
public object SubscriptionAsins { get; set; }
|
|
|
|
[JsonProperty("subtitle")]
|
|
public string Subtitle { get; set; }
|
|
|
|
[JsonProperty("thesaurus_subject_keywords")]
|
|
public string[] ThesaurusSubjectKeywords { get; set; }
|
|
|
|
[JsonProperty("title")]
|
|
public string Title { get; set; }
|
|
|
|
[JsonProperty("ws4v_companion_asin")]
|
|
public object Ws4VCompanionAsin { get; set; }
|
|
}
|
|
|
|
public partial class Person
|
|
{
|
|
[JsonProperty("asin")]
|
|
public string Asin { get; set; }
|
|
|
|
[JsonProperty("name")]
|
|
public string Name { get; set; }
|
|
}
|
|
|
|
public partial class AvailableCodec
|
|
{
|
|
[JsonProperty("enhanced_codec")]
|
|
public EnhancedCodec? EnhancedCodec { get; set; }
|
|
|
|
[JsonProperty("format")]
|
|
public AvailableCodecFormat? Format { get; set; }
|
|
|
|
[JsonProperty("is_kindle_enhanced")]
|
|
public bool? IsKindleEnhanced { get; set; }
|
|
|
|
[JsonProperty("name")]
|
|
public Name? Name { get; set; }
|
|
}
|
|
|
|
public partial class CategoryLadder
|
|
{
|
|
[JsonProperty("date_product_available_in_category")]
|
|
public object DateProductAvailableInCategory { get; set; }
|
|
|
|
[JsonProperty("ladder")]
|
|
public Ladder[] Ladder { get; set; }
|
|
|
|
[JsonProperty("root")]
|
|
public Root? Root { get; set; }
|
|
}
|
|
|
|
public partial class Ladder
|
|
{
|
|
[JsonProperty("category_presentation")]
|
|
public object CategoryPresentation { get; set; }
|
|
|
|
[JsonProperty("children")]
|
|
public object Children { get; set; }
|
|
|
|
[JsonProperty("default_offline_storage_days_count")]
|
|
public object DefaultOfflineStorageDaysCount { get; set; }
|
|
|
|
[JsonProperty("default_offline_storage_item_count")]
|
|
public object DefaultOfflineStorageItemCount { get; set; }
|
|
|
|
[JsonProperty("description")]
|
|
public object Description { get; set; }
|
|
|
|
[JsonProperty("header")]
|
|
public object Header { get; set; }
|
|
|
|
[JsonProperty("id")]
|
|
public string Id { get; set; }
|
|
|
|
[JsonProperty("images")]
|
|
public object Images { get; set; }
|
|
|
|
[JsonProperty("initial_download_days_count")]
|
|
public object InitialDownloadDaysCount { get; set; }
|
|
|
|
[JsonProperty("initial_download_item_count")]
|
|
public object InitialDownloadItemCount { get; set; }
|
|
|
|
[JsonProperty("is_new")]
|
|
public object IsNew { get; set; }
|
|
|
|
[JsonProperty("localized_name")]
|
|
public object LocalizedName { get; set; }
|
|
|
|
[JsonProperty("name")]
|
|
public string Name { get; set; }
|
|
|
|
[JsonProperty("products")]
|
|
public object Products { get; set; }
|
|
|
|
[JsonProperty("promote_upsell")]
|
|
public object PromoteUpsell { get; set; }
|
|
|
|
[JsonProperty("suppress_download_option")]
|
|
public object SuppressDownloadOption { get; set; }
|
|
|
|
[JsonProperty("suppress_release_date")]
|
|
public object SuppressReleaseDate { get; set; }
|
|
}
|
|
|
|
public partial class ContentRating
|
|
{
|
|
[JsonProperty("steaminess")]
|
|
[JsonConverter(typeof(ParseStringConverter))]
|
|
public long? Steaminess { get; set; }
|
|
}
|
|
|
|
public partial class Review
|
|
{
|
|
[JsonProperty("asin")]
|
|
public string Asin { get; set; }
|
|
|
|
[JsonProperty("author_id")]
|
|
public string AuthorId { get; set; }
|
|
|
|
[JsonProperty("author_name")]
|
|
public string AuthorName { get; set; }
|
|
|
|
[JsonProperty("body")]
|
|
public string Body { get; set; }
|
|
|
|
[JsonProperty("customer_vote")]
|
|
public object CustomerVote { get; set; }
|
|
|
|
[JsonProperty("format")]
|
|
public CustomerReviewFormat? Format { get; set; }
|
|
|
|
[JsonProperty("guided_responses")]
|
|
public GuidedResponse[] GuidedResponses { get; set; }
|
|
|
|
[JsonProperty("id")]
|
|
public string Id { get; set; }
|
|
|
|
[JsonProperty("location")]
|
|
public string Location { get; set; }
|
|
|
|
[JsonProperty("ratings")]
|
|
public Ratings Ratings { get; set; }
|
|
|
|
[JsonProperty("review_content_scores")]
|
|
public ReviewContentScores ReviewContentScores { get; set; }
|
|
|
|
[JsonProperty("submission_date")]
|
|
public DateTimeOffset? SubmissionDate { get; set; }
|
|
|
|
[JsonProperty("title")]
|
|
public string Title { get; set; }
|
|
}
|
|
|
|
public partial class GuidedResponse
|
|
{
|
|
[JsonProperty("answer")]
|
|
public string Answer { get; set; }
|
|
|
|
[JsonProperty("id")]
|
|
[JsonConverter(typeof(ParseStringConverter))]
|
|
public long? Id { get; set; }
|
|
|
|
[JsonProperty("question")]
|
|
public string Question { get; set; }
|
|
|
|
[JsonProperty("question_type")]
|
|
public QuestionType? QuestionType { get; set; }
|
|
}
|
|
|
|
public partial class Ratings
|
|
{
|
|
[JsonProperty("overall_rating")]
|
|
public long? OverallRating { get; set; }
|
|
|
|
[JsonProperty("performance_rating")]
|
|
public long? PerformanceRating { get; set; }
|
|
|
|
[JsonProperty("story_rating")]
|
|
public long? StoryRating { get; set; }
|
|
}
|
|
|
|
public partial class ReviewContentScores
|
|
{
|
|
[JsonProperty("content_quality")]
|
|
public long? ContentQuality { get; set; }
|
|
|
|
[JsonProperty("num_helpful_votes")]
|
|
public long? NumHelpfulVotes { get; set; }
|
|
|
|
[JsonProperty("num_unhelpful_votes")]
|
|
public long? NumUnhelpfulVotes { get; set; }
|
|
}
|
|
|
|
public partial class Plan
|
|
{
|
|
[JsonProperty("detail_plan_names")]
|
|
public object DetailPlanNames { get; set; }
|
|
|
|
[JsonProperty("end_date")]
|
|
public DateTimeOffset? EndDate { get; set; }
|
|
|
|
[JsonProperty("plan_name")]
|
|
public PlanName? PlanName { get; set; }
|
|
|
|
[JsonProperty("start_date")]
|
|
public DateTimeOffset? StartDate { get; set; }
|
|
}
|
|
|
|
public partial class Price
|
|
{
|
|
[JsonProperty("credit_price")]
|
|
public long? CreditPrice { get; set; }
|
|
|
|
[JsonProperty("is_buy_for_free_eligible")]
|
|
public object IsBuyForFreeEligible { get; set; }
|
|
|
|
[JsonProperty("is_credit_price_eligible")]
|
|
public object IsCreditPriceEligible { get; set; }
|
|
|
|
[JsonProperty("is_free_eligible")]
|
|
public object IsFreeEligible { get; set; }
|
|
|
|
[JsonProperty("is_ws4v_upsell_eligible")]
|
|
public object IsWs4VUpsellEligible { get; set; }
|
|
|
|
[JsonProperty("list_price")]
|
|
public ListPriceClass ListPrice { get; set; }
|
|
|
|
[JsonProperty("lowest_price")]
|
|
public ListPriceClass LowestPrice { get; set; }
|
|
|
|
[JsonProperty("ws4v_upsell_price")]
|
|
public ListPriceClass Ws4VUpsellPrice { get; set; }
|
|
}
|
|
|
|
public partial class ListPriceClass
|
|
{
|
|
[JsonProperty("base")]
|
|
public double? Base { get; set; }
|
|
|
|
[JsonProperty("currency_code")]
|
|
public CurrencyCode? CurrencyCode { get; set; }
|
|
|
|
[JsonProperty("merchant_id")]
|
|
public MerchantId? MerchantId { get; set; }
|
|
|
|
[JsonProperty("type")]
|
|
public TypeEnum? Type { get; set; }
|
|
}
|
|
|
|
public partial class ProductImages
|
|
{
|
|
[JsonProperty("500")]
|
|
public Uri The500 { get; set; }
|
|
}
|
|
|
|
public partial class Rating
|
|
{
|
|
[JsonProperty("num_reviews")]
|
|
public long? NumReviews { get; set; }
|
|
|
|
[JsonProperty("overall_distribution")]
|
|
public Distribution OverallDistribution { get; set; }
|
|
|
|
[JsonProperty("performance_distribution")]
|
|
public Distribution PerformanceDistribution { get; set; }
|
|
|
|
[JsonProperty("story_distribution")]
|
|
public Distribution StoryDistribution { get; set; }
|
|
}
|
|
|
|
public partial class Distribution
|
|
{
|
|
[JsonProperty("average_rating")]
|
|
public double? AverageRating { get; set; }
|
|
|
|
[JsonProperty("display_average_rating")]
|
|
public string DisplayAverageRating { get; set; }
|
|
|
|
[JsonProperty("display_stars")]
|
|
public double? DisplayStars { get; set; }
|
|
|
|
[JsonProperty("num_five_star_ratings")]
|
|
public long? NumFiveStarRatings { get; set; }
|
|
|
|
[JsonProperty("num_four_star_ratings")]
|
|
public long? NumFourStarRatings { get; set; }
|
|
|
|
[JsonProperty("num_one_star_ratings")]
|
|
public long? NumOneStarRatings { get; set; }
|
|
|
|
[JsonProperty("num_ratings")]
|
|
public long? NumRatings { get; set; }
|
|
|
|
[JsonProperty("num_three_star_ratings")]
|
|
public long? NumThreeStarRatings { get; set; }
|
|
|
|
[JsonProperty("num_two_star_ratings")]
|
|
public long? NumTwoStarRatings { get; set; }
|
|
}
|
|
|
|
public partial class Relationship
|
|
{
|
|
[JsonProperty("asin")]
|
|
public string Asin { get; set; }
|
|
|
|
[JsonProperty("relationship_to_product")]
|
|
public RelationshipToProduct? RelationshipToProduct { get; set; }
|
|
|
|
[JsonProperty("relationship_type")]
|
|
public RelationshipType? RelationshipType { get; set; }
|
|
|
|
[JsonProperty("sequence")]
|
|
public string Sequence { get; set; }
|
|
|
|
[JsonProperty("sku")]
|
|
public string Sku { get; set; }
|
|
|
|
[JsonProperty("sku_lite")]
|
|
public string SkuLite { get; set; }
|
|
|
|
[JsonProperty("sort")]
|
|
[JsonConverter(typeof(ParseStringConverter))]
|
|
public long? Sort { get; set; }
|
|
}
|
|
|
|
public partial class Series
|
|
{
|
|
[JsonProperty("asin")]
|
|
public string Asin { get; set; }
|
|
|
|
[JsonProperty("sequence")]
|
|
public string Sequence { get; set; }
|
|
|
|
[JsonProperty("title")]
|
|
public string Title { get; set; }
|
|
|
|
[JsonProperty("url")]
|
|
public string Url { get; set; }
|
|
}
|
|
|
|
public enum EnhancedCodec { Aax, Format4, Lc128_44100_Stereo, Lc32_22050_Stereo, Lc64_22050_Stereo, Lc64_44100_Stereo, Mp42232, Mp42264, Mp444128, Mp44464, Piff2232, Piff2264, Piff44128, Piff4464 };
|
|
|
|
public enum AvailableCodecFormat { Enhanced, Format4 };
|
|
|
|
public enum Name { Aax, Aax22_32, Aax22_64, Aax44_128, Aax44_64, Format4, Mp422_32, Mp422_64, Mp444_128, Mp444_64, Piff22_32, Piff22_64, Piff44_128, Piff44_64 };
|
|
|
|
public enum Root { EditorsPicks, ExploreBy, Genres, InstitutionsHpMarketing, RodizioBuckets, RodizioGenres, ShortsPrime };
|
|
|
|
public enum ContentDeliveryType { MultiPartBook, Periodical, SinglePartBook };
|
|
|
|
public enum ContentType { Episode, Lecture, Meditation, Misc, Performance, Product, RadioTvProgram, Show, Speech };
|
|
|
|
public enum CustomerReviewFormat { Freeform, Guided };
|
|
|
|
public enum QuestionType { Genre, Misc, Overall, Performance, Story };
|
|
|
|
public enum FormatType { Abridged, OriginalRecording, Unabridged };
|
|
|
|
public enum Language { English };
|
|
|
|
public enum OriginMarketplace { Af2M0Kc94Rcea };
|
|
|
|
public enum OriginType { AudibleChannels, AudibleComplimentaryOriginal, Purchase };
|
|
|
|
public enum PlanName { AyceRomance, ComplimentaryOriginalMemberBenefit, Radio, Rodizio, SpecialBenefit };
|
|
|
|
public enum CurrencyCode { Usd };
|
|
|
|
public enum MerchantId { A2Zo8Jx97D5Mn9 };
|
|
|
|
public enum TypeEnum { List, Member, Sale, Ws4VUpsell };
|
|
|
|
public enum RelationshipToProduct { Child, Parent };
|
|
|
|
public enum RelationshipType { Component, Episode, MerchantTitleAuthority, Season, Series };
|
|
|
|
public enum Status { Active };
|
|
|
|
public enum ThesaurusSubjectKeyword { AdventurersExplorers, AlternateHistory, Comedians, Contemporary, Dramatizations, EasternReligions, LaConfidential, LiteratureAndFiction, Medicine, Spirituality, StandupComedy, Storytelling, SwordSorcery, Workouts };
|
|
|
|
public partial class LibraryApiV10
|
|
{
|
|
public static LibraryApiV10 FromJson(string json) => JsonConvert.DeserializeObject<LibraryApiV10>(json, DTOs.Converter.Settings);
|
|
}
|
|
|
|
public static class Serialize
|
|
{
|
|
public static string ToJson(this LibraryApiV10 self) => JsonConvert.SerializeObject(self, DTOs.Converter.Settings);
|
|
}
|
|
|
|
internal static class Converter
|
|
{
|
|
public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
|
|
{
|
|
MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
|
|
DateParseHandling = DateParseHandling.None,
|
|
Converters =
|
|
{
|
|
EnhancedCodecConverter.Singleton,
|
|
AvailableCodecFormatConverter.Singleton,
|
|
NameConverter.Singleton,
|
|
RootConverter.Singleton,
|
|
ContentDeliveryTypeConverter.Singleton,
|
|
ContentTypeConverter.Singleton,
|
|
CustomerReviewFormatConverter.Singleton,
|
|
QuestionTypeConverter.Singleton,
|
|
FormatTypeConverter.Singleton,
|
|
LanguageConverter.Singleton,
|
|
OriginMarketplaceConverter.Singleton,
|
|
OriginTypeConverter.Singleton,
|
|
PlanNameConverter.Singleton,
|
|
CurrencyCodeConverter.Singleton,
|
|
MerchantIdConverter.Singleton,
|
|
TypeEnumConverter.Singleton,
|
|
RelationshipToProductConverter.Singleton,
|
|
RelationshipTypeConverter.Singleton,
|
|
StatusConverter.Singleton,
|
|
ThesaurusSubjectKeywordConverter.Singleton,
|
|
new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
|
|
},
|
|
};
|
|
}
|
|
|
|
internal class EnhancedCodecConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(EnhancedCodec) || t == typeof(EnhancedCodec?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "LC_128_44100_stereo":
|
|
return EnhancedCodec.Lc128_44100_Stereo;
|
|
case "LC_32_22050_stereo":
|
|
return EnhancedCodec.Lc32_22050_Stereo;
|
|
case "LC_64_22050_stereo":
|
|
return EnhancedCodec.Lc64_22050_Stereo;
|
|
case "LC_64_44100_stereo":
|
|
return EnhancedCodec.Lc64_44100_Stereo;
|
|
case "aax":
|
|
return EnhancedCodec.Aax;
|
|
case "format4":
|
|
return EnhancedCodec.Format4;
|
|
case "mp42232":
|
|
return EnhancedCodec.Mp42232;
|
|
case "mp42264":
|
|
return EnhancedCodec.Mp42264;
|
|
case "mp444128":
|
|
return EnhancedCodec.Mp444128;
|
|
case "mp44464":
|
|
return EnhancedCodec.Mp44464;
|
|
case "piff2232":
|
|
return EnhancedCodec.Piff2232;
|
|
case "piff2264":
|
|
return EnhancedCodec.Piff2264;
|
|
case "piff44128":
|
|
return EnhancedCodec.Piff44128;
|
|
case "piff4464":
|
|
return EnhancedCodec.Piff4464;
|
|
}
|
|
throw new Exception("Cannot unmarshal type EnhancedCodec");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (EnhancedCodec)untypedValue;
|
|
switch (value)
|
|
{
|
|
case EnhancedCodec.Lc128_44100_Stereo:
|
|
serializer.Serialize(writer, "LC_128_44100_stereo");
|
|
return;
|
|
case EnhancedCodec.Lc32_22050_Stereo:
|
|
serializer.Serialize(writer, "LC_32_22050_stereo");
|
|
return;
|
|
case EnhancedCodec.Lc64_22050_Stereo:
|
|
serializer.Serialize(writer, "LC_64_22050_stereo");
|
|
return;
|
|
case EnhancedCodec.Lc64_44100_Stereo:
|
|
serializer.Serialize(writer, "LC_64_44100_stereo");
|
|
return;
|
|
case EnhancedCodec.Aax:
|
|
serializer.Serialize(writer, "aax");
|
|
return;
|
|
case EnhancedCodec.Format4:
|
|
serializer.Serialize(writer, "format4");
|
|
return;
|
|
case EnhancedCodec.Mp42232:
|
|
serializer.Serialize(writer, "mp42232");
|
|
return;
|
|
case EnhancedCodec.Mp42264:
|
|
serializer.Serialize(writer, "mp42264");
|
|
return;
|
|
case EnhancedCodec.Mp444128:
|
|
serializer.Serialize(writer, "mp444128");
|
|
return;
|
|
case EnhancedCodec.Mp44464:
|
|
serializer.Serialize(writer, "mp44464");
|
|
return;
|
|
case EnhancedCodec.Piff2232:
|
|
serializer.Serialize(writer, "piff2232");
|
|
return;
|
|
case EnhancedCodec.Piff2264:
|
|
serializer.Serialize(writer, "piff2264");
|
|
return;
|
|
case EnhancedCodec.Piff44128:
|
|
serializer.Serialize(writer, "piff44128");
|
|
return;
|
|
case EnhancedCodec.Piff4464:
|
|
serializer.Serialize(writer, "piff4464");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type EnhancedCodec");
|
|
}
|
|
|
|
public static readonly EnhancedCodecConverter Singleton = new EnhancedCodecConverter();
|
|
}
|
|
|
|
internal class AvailableCodecFormatConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(AvailableCodecFormat) || t == typeof(AvailableCodecFormat?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "Enhanced":
|
|
return AvailableCodecFormat.Enhanced;
|
|
case "Format4":
|
|
return AvailableCodecFormat.Format4;
|
|
}
|
|
throw new Exception("Cannot unmarshal type AvailableCodecFormat");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (AvailableCodecFormat)untypedValue;
|
|
switch (value)
|
|
{
|
|
case AvailableCodecFormat.Enhanced:
|
|
serializer.Serialize(writer, "Enhanced");
|
|
return;
|
|
case AvailableCodecFormat.Format4:
|
|
serializer.Serialize(writer, "Format4");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type AvailableCodecFormat");
|
|
}
|
|
|
|
public static readonly AvailableCodecFormatConverter Singleton = new AvailableCodecFormatConverter();
|
|
}
|
|
|
|
internal class NameConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(Name) || t == typeof(Name?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "aax":
|
|
return Name.Aax;
|
|
case "aax_22_32":
|
|
return Name.Aax22_32;
|
|
case "aax_22_64":
|
|
return Name.Aax22_64;
|
|
case "aax_44_128":
|
|
return Name.Aax44_128;
|
|
case "aax_44_64":
|
|
return Name.Aax44_64;
|
|
case "format4":
|
|
return Name.Format4;
|
|
case "mp4_22_32":
|
|
return Name.Mp422_32;
|
|
case "mp4_22_64":
|
|
return Name.Mp422_64;
|
|
case "mp4_44_128":
|
|
return Name.Mp444_128;
|
|
case "mp4_44_64":
|
|
return Name.Mp444_64;
|
|
case "piff_22_32":
|
|
return Name.Piff22_32;
|
|
case "piff_22_64":
|
|
return Name.Piff22_64;
|
|
case "piff_44_128":
|
|
return Name.Piff44_128;
|
|
case "piff_44_64":
|
|
return Name.Piff44_64;
|
|
}
|
|
throw new Exception("Cannot unmarshal type Name");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (Name)untypedValue;
|
|
switch (value)
|
|
{
|
|
case Name.Aax:
|
|
serializer.Serialize(writer, "aax");
|
|
return;
|
|
case Name.Aax22_32:
|
|
serializer.Serialize(writer, "aax_22_32");
|
|
return;
|
|
case Name.Aax22_64:
|
|
serializer.Serialize(writer, "aax_22_64");
|
|
return;
|
|
case Name.Aax44_128:
|
|
serializer.Serialize(writer, "aax_44_128");
|
|
return;
|
|
case Name.Aax44_64:
|
|
serializer.Serialize(writer, "aax_44_64");
|
|
return;
|
|
case Name.Format4:
|
|
serializer.Serialize(writer, "format4");
|
|
return;
|
|
case Name.Mp422_32:
|
|
serializer.Serialize(writer, "mp4_22_32");
|
|
return;
|
|
case Name.Mp422_64:
|
|
serializer.Serialize(writer, "mp4_22_64");
|
|
return;
|
|
case Name.Mp444_128:
|
|
serializer.Serialize(writer, "mp4_44_128");
|
|
return;
|
|
case Name.Mp444_64:
|
|
serializer.Serialize(writer, "mp4_44_64");
|
|
return;
|
|
case Name.Piff22_32:
|
|
serializer.Serialize(writer, "piff_22_32");
|
|
return;
|
|
case Name.Piff22_64:
|
|
serializer.Serialize(writer, "piff_22_64");
|
|
return;
|
|
case Name.Piff44_128:
|
|
serializer.Serialize(writer, "piff_44_128");
|
|
return;
|
|
case Name.Piff44_64:
|
|
serializer.Serialize(writer, "piff_44_64");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type Name");
|
|
}
|
|
|
|
public static readonly NameConverter Singleton = new NameConverter();
|
|
}
|
|
|
|
internal class RootConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(Root) || t == typeof(Root?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "EditorsPicks":
|
|
return Root.EditorsPicks;
|
|
case "ExploreBy":
|
|
return Root.ExploreBy;
|
|
case "Genres":
|
|
return Root.Genres;
|
|
case "InstitutionsHpMarketing":
|
|
return Root.InstitutionsHpMarketing;
|
|
case "RodizioBuckets":
|
|
return Root.RodizioBuckets;
|
|
case "RodizioGenres":
|
|
return Root.RodizioGenres;
|
|
case "ShortsPrime":
|
|
return Root.ShortsPrime;
|
|
}
|
|
throw new Exception("Cannot unmarshal type Root");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (Root)untypedValue;
|
|
switch (value)
|
|
{
|
|
case Root.EditorsPicks:
|
|
serializer.Serialize(writer, "EditorsPicks");
|
|
return;
|
|
case Root.ExploreBy:
|
|
serializer.Serialize(writer, "ExploreBy");
|
|
return;
|
|
case Root.Genres:
|
|
serializer.Serialize(writer, "Genres");
|
|
return;
|
|
case Root.InstitutionsHpMarketing:
|
|
serializer.Serialize(writer, "InstitutionsHpMarketing");
|
|
return;
|
|
case Root.RodizioBuckets:
|
|
serializer.Serialize(writer, "RodizioBuckets");
|
|
return;
|
|
case Root.RodizioGenres:
|
|
serializer.Serialize(writer, "RodizioGenres");
|
|
return;
|
|
case Root.ShortsPrime:
|
|
serializer.Serialize(writer, "ShortsPrime");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type Root");
|
|
}
|
|
|
|
public static readonly RootConverter Singleton = new RootConverter();
|
|
}
|
|
|
|
internal class ContentDeliveryTypeConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(ContentDeliveryType) || t == typeof(ContentDeliveryType?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "MultiPartBook":
|
|
return ContentDeliveryType.MultiPartBook;
|
|
case "Periodical":
|
|
return ContentDeliveryType.Periodical;
|
|
case "SinglePartBook":
|
|
return ContentDeliveryType.SinglePartBook;
|
|
}
|
|
throw new Exception("Cannot unmarshal type ContentDeliveryType");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (ContentDeliveryType)untypedValue;
|
|
switch (value)
|
|
{
|
|
case ContentDeliveryType.MultiPartBook:
|
|
serializer.Serialize(writer, "MultiPartBook");
|
|
return;
|
|
case ContentDeliveryType.Periodical:
|
|
serializer.Serialize(writer, "Periodical");
|
|
return;
|
|
case ContentDeliveryType.SinglePartBook:
|
|
serializer.Serialize(writer, "SinglePartBook");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type ContentDeliveryType");
|
|
}
|
|
|
|
public static readonly ContentDeliveryTypeConverter Singleton = new ContentDeliveryTypeConverter();
|
|
}
|
|
|
|
internal class ParseStringConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(long) || t == typeof(long?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
long l;
|
|
if (Int64.TryParse(value, out l))
|
|
{
|
|
return l;
|
|
}
|
|
throw new Exception("Cannot unmarshal type long");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (long)untypedValue;
|
|
serializer.Serialize(writer, value.ToString());
|
|
return;
|
|
}
|
|
|
|
public static readonly ParseStringConverter Singleton = new ParseStringConverter();
|
|
}
|
|
|
|
internal class ContentTypeConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(ContentType) || t == typeof(ContentType?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "Episode":
|
|
return ContentType.Episode;
|
|
case "Lecture":
|
|
return ContentType.Lecture;
|
|
case "Meditation":
|
|
return ContentType.Meditation;
|
|
case "Misc":
|
|
return ContentType.Misc;
|
|
case "Performance":
|
|
return ContentType.Performance;
|
|
case "Product":
|
|
return ContentType.Product;
|
|
case "Radio/TV Program":
|
|
return ContentType.RadioTvProgram;
|
|
case "Show":
|
|
return ContentType.Show;
|
|
case "Speech":
|
|
return ContentType.Speech;
|
|
}
|
|
throw new Exception("Cannot unmarshal type ContentType");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (ContentType)untypedValue;
|
|
switch (value)
|
|
{
|
|
case ContentType.Episode:
|
|
serializer.Serialize(writer, "Episode");
|
|
return;
|
|
case ContentType.Lecture:
|
|
serializer.Serialize(writer, "Lecture");
|
|
return;
|
|
case ContentType.Meditation:
|
|
serializer.Serialize(writer, "Meditation");
|
|
return;
|
|
case ContentType.Misc:
|
|
serializer.Serialize(writer, "Misc");
|
|
return;
|
|
case ContentType.Performance:
|
|
serializer.Serialize(writer, "Performance");
|
|
return;
|
|
case ContentType.Product:
|
|
serializer.Serialize(writer, "Product");
|
|
return;
|
|
case ContentType.RadioTvProgram:
|
|
serializer.Serialize(writer, "Radio/TV Program");
|
|
return;
|
|
case ContentType.Show:
|
|
serializer.Serialize(writer, "Show");
|
|
return;
|
|
case ContentType.Speech:
|
|
serializer.Serialize(writer, "Speech");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type ContentType");
|
|
}
|
|
|
|
public static readonly ContentTypeConverter Singleton = new ContentTypeConverter();
|
|
}
|
|
|
|
internal class CustomerReviewFormatConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(CustomerReviewFormat) || t == typeof(CustomerReviewFormat?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "Freeform":
|
|
return CustomerReviewFormat.Freeform;
|
|
case "Guided":
|
|
return CustomerReviewFormat.Guided;
|
|
}
|
|
throw new Exception("Cannot unmarshal type CustomerReviewFormat");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (CustomerReviewFormat)untypedValue;
|
|
switch (value)
|
|
{
|
|
case CustomerReviewFormat.Freeform:
|
|
serializer.Serialize(writer, "Freeform");
|
|
return;
|
|
case CustomerReviewFormat.Guided:
|
|
serializer.Serialize(writer, "Guided");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type CustomerReviewFormat");
|
|
}
|
|
|
|
public static readonly CustomerReviewFormatConverter Singleton = new CustomerReviewFormatConverter();
|
|
}
|
|
|
|
internal class QuestionTypeConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(QuestionType) || t == typeof(QuestionType?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "Genre":
|
|
return QuestionType.Genre;
|
|
case "Misc":
|
|
return QuestionType.Misc;
|
|
case "Overall":
|
|
return QuestionType.Overall;
|
|
case "Performance":
|
|
return QuestionType.Performance;
|
|
case "Story":
|
|
return QuestionType.Story;
|
|
}
|
|
throw new Exception("Cannot unmarshal type QuestionType");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (QuestionType)untypedValue;
|
|
switch (value)
|
|
{
|
|
case QuestionType.Genre:
|
|
serializer.Serialize(writer, "Genre");
|
|
return;
|
|
case QuestionType.Misc:
|
|
serializer.Serialize(writer, "Misc");
|
|
return;
|
|
case QuestionType.Overall:
|
|
serializer.Serialize(writer, "Overall");
|
|
return;
|
|
case QuestionType.Performance:
|
|
serializer.Serialize(writer, "Performance");
|
|
return;
|
|
case QuestionType.Story:
|
|
serializer.Serialize(writer, "Story");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type QuestionType");
|
|
}
|
|
|
|
public static readonly QuestionTypeConverter Singleton = new QuestionTypeConverter();
|
|
}
|
|
|
|
internal class FormatTypeConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(FormatType) || t == typeof(FormatType?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "abridged":
|
|
return FormatType.Abridged;
|
|
case "original_recording":
|
|
return FormatType.OriginalRecording;
|
|
case "unabridged":
|
|
return FormatType.Unabridged;
|
|
}
|
|
throw new Exception("Cannot unmarshal type FormatType");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (FormatType)untypedValue;
|
|
switch (value)
|
|
{
|
|
case FormatType.Abridged:
|
|
serializer.Serialize(writer, "abridged");
|
|
return;
|
|
case FormatType.OriginalRecording:
|
|
serializer.Serialize(writer, "original_recording");
|
|
return;
|
|
case FormatType.Unabridged:
|
|
serializer.Serialize(writer, "unabridged");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type FormatType");
|
|
}
|
|
|
|
public static readonly FormatTypeConverter Singleton = new FormatTypeConverter();
|
|
}
|
|
|
|
internal class LanguageConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(Language) || t == typeof(Language?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
if (value == "english")
|
|
{
|
|
return Language.English;
|
|
}
|
|
throw new Exception("Cannot unmarshal type Language");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (Language)untypedValue;
|
|
if (value == Language.English)
|
|
{
|
|
serializer.Serialize(writer, "english");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type Language");
|
|
}
|
|
|
|
public static readonly LanguageConverter Singleton = new LanguageConverter();
|
|
}
|
|
|
|
internal class OriginMarketplaceConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(OriginMarketplace) || t == typeof(OriginMarketplace?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
if (value == "AF2M0KC94RCEA")
|
|
{
|
|
return OriginMarketplace.Af2M0Kc94Rcea;
|
|
}
|
|
throw new Exception("Cannot unmarshal type OriginMarketplace");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (OriginMarketplace)untypedValue;
|
|
if (value == OriginMarketplace.Af2M0Kc94Rcea)
|
|
{
|
|
serializer.Serialize(writer, "AF2M0KC94RCEA");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type OriginMarketplace");
|
|
}
|
|
|
|
public static readonly OriginMarketplaceConverter Singleton = new OriginMarketplaceConverter();
|
|
}
|
|
|
|
internal class OriginTypeConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(OriginType) || t == typeof(OriginType?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "AudibleChannels":
|
|
return OriginType.AudibleChannels;
|
|
case "AudibleComplimentaryOriginal":
|
|
return OriginType.AudibleComplimentaryOriginal;
|
|
case "Purchase":
|
|
return OriginType.Purchase;
|
|
}
|
|
throw new Exception("Cannot unmarshal type OriginType");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (OriginType)untypedValue;
|
|
switch (value)
|
|
{
|
|
case OriginType.AudibleChannels:
|
|
serializer.Serialize(writer, "AudibleChannels");
|
|
return;
|
|
case OriginType.AudibleComplimentaryOriginal:
|
|
serializer.Serialize(writer, "AudibleComplimentaryOriginal");
|
|
return;
|
|
case OriginType.Purchase:
|
|
serializer.Serialize(writer, "Purchase");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type OriginType");
|
|
}
|
|
|
|
public static readonly OriginTypeConverter Singleton = new OriginTypeConverter();
|
|
}
|
|
|
|
internal class PlanNameConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(PlanName) || t == typeof(PlanName?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "AyceRomance":
|
|
return PlanName.AyceRomance;
|
|
case "ComplimentaryOriginalMemberBenefit":
|
|
return PlanName.ComplimentaryOriginalMemberBenefit;
|
|
case "Radio":
|
|
return PlanName.Radio;
|
|
case "Rodizio":
|
|
return PlanName.Rodizio;
|
|
case "SpecialBenefit":
|
|
return PlanName.SpecialBenefit;
|
|
}
|
|
throw new Exception("Cannot unmarshal type PlanName");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (PlanName)untypedValue;
|
|
switch (value)
|
|
{
|
|
case PlanName.AyceRomance:
|
|
serializer.Serialize(writer, "AyceRomance");
|
|
return;
|
|
case PlanName.ComplimentaryOriginalMemberBenefit:
|
|
serializer.Serialize(writer, "ComplimentaryOriginalMemberBenefit");
|
|
return;
|
|
case PlanName.Radio:
|
|
serializer.Serialize(writer, "Radio");
|
|
return;
|
|
case PlanName.Rodizio:
|
|
serializer.Serialize(writer, "Rodizio");
|
|
return;
|
|
case PlanName.SpecialBenefit:
|
|
serializer.Serialize(writer, "SpecialBenefit");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type PlanName");
|
|
}
|
|
|
|
public static readonly PlanNameConverter Singleton = new PlanNameConverter();
|
|
}
|
|
|
|
internal class CurrencyCodeConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(CurrencyCode) || t == typeof(CurrencyCode?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
if (value == "USD")
|
|
{
|
|
return CurrencyCode.Usd;
|
|
}
|
|
throw new Exception("Cannot unmarshal type CurrencyCode");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (CurrencyCode)untypedValue;
|
|
if (value == CurrencyCode.Usd)
|
|
{
|
|
serializer.Serialize(writer, "USD");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type CurrencyCode");
|
|
}
|
|
|
|
public static readonly CurrencyCodeConverter Singleton = new CurrencyCodeConverter();
|
|
}
|
|
|
|
internal class MerchantIdConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(MerchantId) || t == typeof(MerchantId?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
if (value == "A2ZO8JX97D5MN9")
|
|
{
|
|
return MerchantId.A2Zo8Jx97D5Mn9;
|
|
}
|
|
throw new Exception("Cannot unmarshal type MerchantId");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (MerchantId)untypedValue;
|
|
if (value == MerchantId.A2Zo8Jx97D5Mn9)
|
|
{
|
|
serializer.Serialize(writer, "A2ZO8JX97D5MN9");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type MerchantId");
|
|
}
|
|
|
|
public static readonly MerchantIdConverter Singleton = new MerchantIdConverter();
|
|
}
|
|
|
|
internal class TypeEnumConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(TypeEnum) || t == typeof(TypeEnum?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "list":
|
|
return TypeEnum.List;
|
|
case "member":
|
|
return TypeEnum.Member;
|
|
case "sale":
|
|
return TypeEnum.Sale;
|
|
case "ws4v_upsell":
|
|
return TypeEnum.Ws4VUpsell;
|
|
}
|
|
throw new Exception("Cannot unmarshal type TypeEnum");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (TypeEnum)untypedValue;
|
|
switch (value)
|
|
{
|
|
case TypeEnum.List:
|
|
serializer.Serialize(writer, "list");
|
|
return;
|
|
case TypeEnum.Member:
|
|
serializer.Serialize(writer, "member");
|
|
return;
|
|
case TypeEnum.Sale:
|
|
serializer.Serialize(writer, "sale");
|
|
return;
|
|
case TypeEnum.Ws4VUpsell:
|
|
serializer.Serialize(writer, "ws4v_upsell");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type TypeEnum");
|
|
}
|
|
|
|
public static readonly TypeEnumConverter Singleton = new TypeEnumConverter();
|
|
}
|
|
|
|
internal class RelationshipToProductConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(RelationshipToProduct) || t == typeof(RelationshipToProduct?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "child":
|
|
return RelationshipToProduct.Child;
|
|
case "parent":
|
|
return RelationshipToProduct.Parent;
|
|
}
|
|
throw new Exception("Cannot unmarshal type RelationshipToProduct");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (RelationshipToProduct)untypedValue;
|
|
switch (value)
|
|
{
|
|
case RelationshipToProduct.Child:
|
|
serializer.Serialize(writer, "child");
|
|
return;
|
|
case RelationshipToProduct.Parent:
|
|
serializer.Serialize(writer, "parent");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type RelationshipToProduct");
|
|
}
|
|
|
|
public static readonly RelationshipToProductConverter Singleton = new RelationshipToProductConverter();
|
|
}
|
|
|
|
internal class RelationshipTypeConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(RelationshipType) || t == typeof(RelationshipType?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "component":
|
|
return RelationshipType.Component;
|
|
case "episode":
|
|
return RelationshipType.Episode;
|
|
case "merchant_title_authority":
|
|
return RelationshipType.MerchantTitleAuthority;
|
|
case "season":
|
|
return RelationshipType.Season;
|
|
case "series":
|
|
return RelationshipType.Series;
|
|
}
|
|
throw new Exception("Cannot unmarshal type RelationshipType");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (RelationshipType)untypedValue;
|
|
switch (value)
|
|
{
|
|
case RelationshipType.Component:
|
|
serializer.Serialize(writer, "component");
|
|
return;
|
|
case RelationshipType.Episode:
|
|
serializer.Serialize(writer, "episode");
|
|
return;
|
|
case RelationshipType.MerchantTitleAuthority:
|
|
serializer.Serialize(writer, "merchant_title_authority");
|
|
return;
|
|
case RelationshipType.Season:
|
|
serializer.Serialize(writer, "season");
|
|
return;
|
|
case RelationshipType.Series:
|
|
serializer.Serialize(writer, "series");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type RelationshipType");
|
|
}
|
|
|
|
public static readonly RelationshipTypeConverter Singleton = new RelationshipTypeConverter();
|
|
}
|
|
|
|
internal class StatusConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(Status);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
if (value == "Active")
|
|
{
|
|
return Status.Active;
|
|
}
|
|
throw new Exception("Cannot unmarshal type Status");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (Status)untypedValue;
|
|
if (value == Status.Active)
|
|
{
|
|
serializer.Serialize(writer, "Active");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type Status");
|
|
}
|
|
|
|
public static readonly StatusConverter Singleton = new StatusConverter();
|
|
}
|
|
|
|
internal class ThesaurusSubjectKeywordConverter : JsonConverter
|
|
{
|
|
public override bool CanConvert(Type t) => t == typeof(ThesaurusSubjectKeyword) || t == typeof(ThesaurusSubjectKeyword?);
|
|
|
|
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
|
|
{
|
|
if (reader.TokenType == JsonToken.Null) return null;
|
|
var value = serializer.Deserialize<string>(reader);
|
|
switch (value)
|
|
{
|
|
case "adventurers_&_explorers":
|
|
return ThesaurusSubjectKeyword.AdventurersExplorers;
|
|
case "alternate_history":
|
|
return ThesaurusSubjectKeyword.AlternateHistory;
|
|
case "comedians":
|
|
return ThesaurusSubjectKeyword.Comedians;
|
|
case "contemporary":
|
|
return ThesaurusSubjectKeyword.Contemporary;
|
|
case "dramatizations":
|
|
return ThesaurusSubjectKeyword.Dramatizations;
|
|
case "eastern_religions":
|
|
return ThesaurusSubjectKeyword.EasternReligions;
|
|
case "la_confidential":
|
|
return ThesaurusSubjectKeyword.LaConfidential;
|
|
case "literature-and-fiction":
|
|
return ThesaurusSubjectKeyword.LiteratureAndFiction;
|
|
case "medicine":
|
|
return ThesaurusSubjectKeyword.Medicine;
|
|
case "spirituality":
|
|
return ThesaurusSubjectKeyword.Spirituality;
|
|
case "standup_comedy":
|
|
return ThesaurusSubjectKeyword.StandupComedy;
|
|
case "storytelling":
|
|
return ThesaurusSubjectKeyword.Storytelling;
|
|
case "sword_&_sorcery":
|
|
return ThesaurusSubjectKeyword.SwordSorcery;
|
|
case "workouts":
|
|
return ThesaurusSubjectKeyword.Workouts;
|
|
}
|
|
throw new Exception("Cannot unmarshal type ThesaurusSubjectKeyword");
|
|
}
|
|
|
|
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
|
|
{
|
|
if (untypedValue == null)
|
|
{
|
|
serializer.Serialize(writer, null);
|
|
return;
|
|
}
|
|
var value = (ThesaurusSubjectKeyword)untypedValue;
|
|
switch (value)
|
|
{
|
|
case ThesaurusSubjectKeyword.AdventurersExplorers:
|
|
serializer.Serialize(writer, "adventurers_&_explorers");
|
|
return;
|
|
case ThesaurusSubjectKeyword.AlternateHistory:
|
|
serializer.Serialize(writer, "alternate_history");
|
|
return;
|
|
case ThesaurusSubjectKeyword.Comedians:
|
|
serializer.Serialize(writer, "comedians");
|
|
return;
|
|
case ThesaurusSubjectKeyword.Contemporary:
|
|
serializer.Serialize(writer, "contemporary");
|
|
return;
|
|
case ThesaurusSubjectKeyword.Dramatizations:
|
|
serializer.Serialize(writer, "dramatizations");
|
|
return;
|
|
case ThesaurusSubjectKeyword.EasternReligions:
|
|
serializer.Serialize(writer, "eastern_religions");
|
|
return;
|
|
case ThesaurusSubjectKeyword.LaConfidential:
|
|
serializer.Serialize(writer, "la_confidential");
|
|
return;
|
|
case ThesaurusSubjectKeyword.LiteratureAndFiction:
|
|
serializer.Serialize(writer, "literature-and-fiction");
|
|
return;
|
|
case ThesaurusSubjectKeyword.Medicine:
|
|
serializer.Serialize(writer, "medicine");
|
|
return;
|
|
case ThesaurusSubjectKeyword.Spirituality:
|
|
serializer.Serialize(writer, "spirituality");
|
|
return;
|
|
case ThesaurusSubjectKeyword.StandupComedy:
|
|
serializer.Serialize(writer, "standup_comedy");
|
|
return;
|
|
case ThesaurusSubjectKeyword.Storytelling:
|
|
serializer.Serialize(writer, "storytelling");
|
|
return;
|
|
case ThesaurusSubjectKeyword.SwordSorcery:
|
|
serializer.Serialize(writer, "sword_&_sorcery");
|
|
return;
|
|
case ThesaurusSubjectKeyword.Workouts:
|
|
serializer.Serialize(writer, "workouts");
|
|
return;
|
|
}
|
|
throw new Exception("Cannot marshal type ThesaurusSubjectKeyword");
|
|
}
|
|
|
|
public static readonly ThesaurusSubjectKeywordConverter Singleton = new ThesaurusSubjectKeywordConverter();
|
|
}
|
|
}
|