Class: TmdbApiClient::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/tmdb_ryanstep.rb

Instance Method Summary collapse

Constructor Details

#initialize(api_key:, base_url: nil, environment: TmdbApiClient::Environment::PRODUCTION, max_retries: nil, timeout_in_seconds: nil) ⇒ TmdbApiClient::Client

Parameters:

  • base_url (String) (defaults to: nil)
  • environment (TmdbApiClient::Environment) (defaults to: TmdbApiClient::Environment::PRODUCTION)
  • max_retries (Long) (defaults to: nil) —

    The number of times to retry a failed request, defaults to 2.

  • timeout_in_seconds (Long) (defaults to: nil)
  • api_key (String) 


43
44
45
46
47
48
49
50
51
52
 
# File 'lib/tmdb_ryanstep.rb', line 43

def initialize(api_key:, base_url: nil, environment: TmdbApiClient::Environment::PRODUCTION, max_retries: nil,
               timeout_in_seconds: nil)
  @request_client = TmdbApiClient::RequestClient.new(
    base_url: base_url,
    environment: environment,
    max_retries: max_retries,
    timeout_in_seconds: timeout_in_seconds,
    api_key: api_key
  )
end

Instance Method Details

#account_favorite_movies(account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil) ⇒ TmdbApiClient::AccountFavoriteMoviesResponse

Get a users list of favourite movies.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

Returns:



482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
 
# File 'lib/tmdb_ryanstep.rb', line 482

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language,
      "sort_by": sort_by
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/movie/favorites"
  end
  TmdbApiClient::AccountFavoriteMoviesResponse.from_json(json_object: response.body)
end

#account_favorite_tv(account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil) ⇒ TmdbApiClient::AccountFavoriteTvResponse

Get a users list of favourite TV shows.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

Returns:



520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
 
# File 'lib/tmdb_ryanstep.rb', line 520

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language,
      "sort_by": sort_by
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/tv/favorites"
  end
  TmdbApiClient::AccountFavoriteTvResponse.from_json(json_object: response.body)
end

#account_lists(account_object_id:, page: nil, request_options: nil) ⇒ TmdbApiClient::AccountListsResponse

Get the custom lists that a user has created.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

Returns:



449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
 
# File 'lib/tmdb_ryanstep.rb', line 449

def (account_object_id:, page: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = { **(request_options&.additional_query_parameters || {}), "page": page }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/lists"
  end
  TmdbApiClient::AccountListsResponse.from_json(json_object: response.body)
end

#account_movie_recommendations(account_object_id:, page: nil, language: nil, request_options: nil) ⇒ TmdbApiClient::AccountMovieRecommendationsResponse

Get a users list of recommended movies.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

  • account_object_id (String)
  • page (Integer) (defaults to: nil)
  • language (String) (defaults to: nil)
  • request_options (TmdbApiClient::RequestOptions) (defaults to: nil)

Returns:



593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
 
# File 'lib/tmdb_ryanstep.rb', line 593

def (account_object_id:, page: nil, language: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/movie/recommendations"
  end
  TmdbApiClient::AccountMovieRecommendationsResponse.from_json(json_object: response.body)
end

#account_movie_watchlist(account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil) ⇒ TmdbApiClient::AccountMovieWatchlistResponse

Get a users movie watchlist.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

Returns:



630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
 
# File 'lib/tmdb_ryanstep.rb', line 630

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language,
      "sort_by": sort_by
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/movie/watchlist"
  end
  TmdbApiClient::AccountMovieWatchlistResponse.from_json(json_object: response.body)
end

#account_rated_movies(account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil) ⇒ TmdbApiClient::AccountRatedMoviesResponse

Get a users rated movies.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

Returns:



706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
 
# File 'lib/tmdb_ryanstep.rb', line 706

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language,
      "sort_by": sort_by
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/movie/rated"
  end
  TmdbApiClient::AccountRatedMoviesResponse.from_json(json_object: response.body)
end

#account_rated_tv(account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil) ⇒ TmdbApiClient::AccountRatedTvResponse

Get a users rated TV shows.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

Returns:



744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
 
# File 'lib/tmdb_ryanstep.rb', line 744

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language,
      "sort_by": sort_by
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/tv/rated"
  end
  TmdbApiClient::AccountRatedTvResponse.from_json(json_object: response.body)
end

#account_tv_recommendations(account_object_id:, page: nil, language: nil, request_options: nil) ⇒ TmdbApiClient::AccountTvRecommendationsResponse

Get a users list of recommended TV shows.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

  • account_object_id (String)
  • page (Integer) (defaults to: nil)
  • language (String) (defaults to: nil)
  • request_options (TmdbApiClient::RequestOptions) (defaults to: nil)

Returns:



557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
 
# File 'lib/tmdb_ryanstep.rb', line 557

def (account_object_id:, page: nil, language: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/tv/recommendations"
  end
  TmdbApiClient::AccountTvRecommendationsResponse.from_json(json_object: response.body)
end

#account_tv_watchlist(account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil) ⇒ TmdbApiClient::AccountTvWatchlistResponse

Get a users TV watchlist.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.(account_object_id: "account_object_id")

Parameters:

Returns:



668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
 
# File 'lib/tmdb_ryanstep.rb', line 668

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "page": page,
      "language": language,
      "sort_by": sort_by
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/account/#{}/tv/watchlist"
  end
  TmdbApiClient::AccountTvWatchlistResponse.from_json(json_object: response.body)
end

#auth_create_access_token(raw_body:, request_options: nil) ⇒ TmdbApiClient::AuthCreateAccessTokenResponse

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.auth_create_access_token(raw_body: "RAW_BODY")

Parameters:

Returns:



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/tmdb_ryanstep.rb', line 94

def auth_create_access_token(raw_body:, request_options: nil)
  response = @request_client.conn.post do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/auth/access_token"
  end
  TmdbApiClient::AuthCreateAccessTokenResponse.from_json(json_object: response.body)
end

#auth_create_request_token(raw_body:, request_options: nil) ⇒ TmdbApiClient::AuthCreateRequestTokenResponse

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.auth_create_request_token(raw_body: "RAW_BODY")

Parameters:

Returns:



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/tmdb_ryanstep.rb', line 65

def auth_create_request_token(raw_body:, request_options: nil)
  response = @request_client.conn.post do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/auth/request_token"
  end
  TmdbApiClient::AuthCreateRequestTokenResponse.from_json(json_object: response.body)
end

#auth_logout(raw_body:, request_options: nil) ⇒ TmdbApiClient::AuthLogoutResponse

Log out of a session.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.auth_logout(raw_body: "RAW_BODY")

Parameters:

Returns:



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/tmdb_ryanstep.rb', line 124

def auth_logout(raw_body:, request_options: nil)
  response = @request_client.conn.delete do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/auth/access_token"
  end
  TmdbApiClient::AuthLogoutResponse.from_json(json_object: response.body)
end

#getting_started(request_options: nil) ⇒ Void

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.getting_started

Parameters:

Returns:

  • (Void) 


777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
 
# File 'lib/tmdb_ryanstep.rb', line 777

def getting_started(request_options: nil)
  @request_client.conn.post do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/"
  end
end

#list_add_items(list_id:, raw_body:, request_options: nil) ⇒ TmdbApiClient::ListAddItemsResponse

Add items to a list.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_add_items(list_id: 1, raw_body: "RAW_BODY")

Parameters:

Returns:



316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/tmdb_ryanstep.rb', line 316

def list_add_items(list_id:, raw_body:, request_options: nil)
  response = @request_client.conn.post do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list/#{list_id}/items"
  end
  TmdbApiClient::ListAddItemsResponse.from_json(json_object: response.body)
end

#list_clear(list_id:, request_options: nil) ⇒ TmdbApiClient::ListClearResponse

Clear all of the items on a list.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_clear(list_id: 1)

Parameters:

Returns:



251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/tmdb_ryanstep.rb', line 251

def list_clear(list_id:, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list/#{list_id}/clear"
  end
  TmdbApiClient::ListClearResponse.from_json(json_object: response.body)
end

#list_create(raw_body:, request_options: nil) ⇒ TmdbApiClient::ListCreateResponse

Create a new list.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_create(raw_body: "RAW_BODY")

Parameters:

Returns:



221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/tmdb_ryanstep.rb', line 221

def list_create(raw_body:, request_options: nil)
  response = @request_client.conn.post do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list"
  end
  TmdbApiClient::ListCreateResponse.from_json(json_object: response.body)
end

#list_delete(list_id:, request_options: nil) ⇒ TmdbApiClient::ListDeleteResponse

Delete a list.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_delete(list_id: 1)

Parameters:

Returns:



283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
 
# File 'lib/tmdb_ryanstep.rb', line 283

def list_delete(list_id:, request_options: nil)
  response = @request_client.conn.delete do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/#{list_id}"
  end
  TmdbApiClient::ListDeleteResponse.from_json(json_object: response.body)
end

#list_details(list_id:, language: nil, page: nil, request_options: nil) ⇒ TmdbApiClient::ListDetailsResponse

Retrieve a list by id.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_details(list_id: 1)

Parameters:

  • list_id (Integer)
  • language (String) (defaults to: nil)
  • page (Integer) (defaults to: nil)
  • request_options (TmdbApiClient::RequestOptions) (defaults to: nil)

Returns:



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/tmdb_ryanstep.rb', line 156

def list_details(list_id:, language: nil, page: nil, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "language": language,
      "page": page
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list/#{list_id}"
  end
  TmdbApiClient::ListDetailsResponse.from_json(json_object: response.body)
end

#list_item_status(list_id:, media_id:, media_type:, request_options: nil) ⇒ TmdbApiClient::ListItemStatusResponse

Check if an item is on a list.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_item_status(
  list_id: 1,
  media_id: 1,
  media_type: EMPTY
)

Parameters:

Returns:



414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
 
# File 'lib/tmdb_ryanstep.rb', line 414

def list_item_status(list_id:, media_id:, media_type:, request_options: nil)
  response = @request_client.conn.get do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    req.params = {
      **(request_options&.additional_query_parameters || {}),
      "media_id": media_id,
      "media_type": media_type
    }.compact
    unless request_options.nil? || request_options&.additional_body_parameters.nil?
      req.body = { **(request_options&.additional_body_parameters || {}) }.compact
    end
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list/#{list_id}/item_status"
  end
  TmdbApiClient::ListItemStatusResponse.from_json(json_object: response.body)
end

#list_remove_items(list_id:, raw_body:, request_options: nil) ⇒ TmdbApiClient::ListRemoveItemsResponse

Remove items from a list

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_remove_items(list_id: 1, raw_body: "RAW_BODY")

Parameters:

Returns:



378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
 
# File 'lib/tmdb_ryanstep.rb', line 378

def list_remove_items(list_id:, raw_body:, request_options: nil)
  response = @request_client.conn.delete do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list/#{list_id}/items"
  end
  TmdbApiClient::ListRemoveItemsResponse.from_json(json_object: response.body)
end

#list_update(list_id:, raw_body:, request_options: nil) ⇒ TmdbApiClient::ListUpdateResponse

Update the details of a list.

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_update(list_id: 1, raw_body: "RAW_BODY")

Parameters:

Returns:



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/tmdb_ryanstep.rb', line 191

def list_update(list_id:, raw_body:, request_options: nil)
  response = @request_client.conn.put do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list/#{list_id}"
  end
  TmdbApiClient::ListUpdateResponse.from_json(json_object: response.body)
end

#list_update_items(list_id:, raw_body:, request_options: nil) ⇒ TmdbApiClient::ListUpdateItemsResponse

Update an individual item on a list

Examples:

api = TmdbApiClient::Client.new(
  base_url: "https://api.example.com",
  environment: TmdbApiClient::Environment::PRODUCTION,
  api_key: "YOUR_API_KEY"
)
api.list_update_items(list_id: "list_id", raw_body: "RAW_BODY")

Parameters:

Returns:



347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
 
# File 'lib/tmdb_ryanstep.rb', line 347

def list_update_items(list_id:, raw_body:, request_options: nil)
  response = @request_client.conn.put do |req|
    req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
    req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
    req.headers = {
  **(req.headers || {}),
  **@request_client.get_headers,
  **(request_options&.additional_headers || {})
    }.compact
    unless request_options.nil? || request_options&.additional_query_parameters.nil?
      req.params = { **(request_options&.additional_query_parameters || {}) }.compact
    end
    req.body = { **(request_options&.additional_body_parameters || {}), RAW_BODY: raw_body }.compact
    req.url "#{@request_client.get_url(request_options: request_options)}/4/list/#{list_id}/items"
  end
  TmdbApiClient::ListUpdateItemsResponse.from_json(json_object: response.body)
end