Class: TmdbApiClient::AsyncClient

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::AsyncClient

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) 


804
805
806
807
808
809
810
811
812
813
 
# File 'lib/tmdb_ryanstep.rb', line 804

def initialize(api_key:, base_url: nil, environment: TmdbApiClient::Environment::PRODUCTION, max_retries: nil,
               timeout_in_seconds: nil)
  @async_request_client = TmdbApiClient::AsyncRequestClient.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:



1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
 
# File 'lib/tmdb_ryanstep.rb', line 1243

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
 
# File 'lib/tmdb_ryanstep.rb', line 1281

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
 
# File 'lib/tmdb_ryanstep.rb', line 1210

def (account_object_id:, page: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
 
# File 'lib/tmdb_ryanstep.rb', line 1354

def (account_object_id:, page: nil, language: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
 
# File 'lib/tmdb_ryanstep.rb', line 1391

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
 
# File 'lib/tmdb_ryanstep.rb', line 1467

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
 
# File 'lib/tmdb_ryanstep.rb', line 1505

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
 
# File 'lib/tmdb_ryanstep.rb', line 1318

def (account_object_id:, page: nil, language: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
 
# File 'lib/tmdb_ryanstep.rb', line 1429

def (account_object_id:, page: nil, language: nil, sort_by: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/account/#{account_object_id}/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:



855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
 
# File 'lib/tmdb_ryanstep.rb', line 855

def auth_create_access_token(raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
 
# File 'lib/tmdb_ryanstep.rb', line 826

def auth_create_request_token(raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
 
# File 'lib/tmdb_ryanstep.rb', line 885

def auth_logout(raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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) 


1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
 
# File 'lib/tmdb_ryanstep.rb', line 1538

def getting_started(request_options: nil)
  @async_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 || {}),
  **@async_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 "#{@async_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:



1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
 
# File 'lib/tmdb_ryanstep.rb', line 1077

def list_add_items(list_id:, raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
 
# File 'lib/tmdb_ryanstep.rb', line 1012

def list_clear(list_id:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
 
# File 'lib/tmdb_ryanstep.rb', line 982

def list_create(raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
 
# File 'lib/tmdb_ryanstep.rb', line 1044

def list_delete(list_id:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
 
# File 'lib/tmdb_ryanstep.rb', line 917

def list_details(list_id:, language: nil, page: nil, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
 
# File 'lib/tmdb_ryanstep.rb', line 1175

def list_item_status(list_id:, media_id:, media_type:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
 
# File 'lib/tmdb_ryanstep.rb', line 1139

def list_remove_items(list_id:, raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
 
# File 'lib/tmdb_ryanstep.rb', line 952

def list_update(list_id:, raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_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:



1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
 
# File 'lib/tmdb_ryanstep.rb', line 1108

def list_update_items(list_id:, raw_body:, request_options: nil)
  response = @async_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 || {}),
  **@async_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 "#{@async_request_client.get_url(request_options: request_options)}/4/list/#{list_id}/items"
  end
  TmdbApiClient::ListUpdateItemsResponse.from_json(json_object: response.body)
end