Class: ThreeScale::API::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/3scale/api/client.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(http_client) ⇒ Client 



8
9
10
 
# File 'lib/3scale/api/client.rb', line 8

def initialize(http_client)
  @http_client = http_client
end

Instance Attribute Details

#http_client ⇒ Object (readonly)

Returns the value of attribute http_client.



4
5
6
 
# File 'lib/3scale/api/client.rb', line 4

def http_client
  @http_client
end

Instance Method Details

#accept_application(account_id, application_id) ⇒ Hash

Returns application Application.



760
761
762
763
 
# File 'lib/3scale/api/client.rb', line 760

def accept_application(, application_id)
  response = http_client.put("/admin/api/accounts/#{account_id}/applications/#{application_id}/accept")
  extract(entity: 'application', from: response)
end

#activate_user(account_id, user_id) ⇒ Hash 



709
710
711
712
 
# File 'lib/3scale/api/client.rb', line 709

def activate_user(, user_id)
  response = http_client.put("/admin/api/accounts/#{account_id}/users/#{user_id}/activate")
  extract(entity: 'user', from: response)
end

#application_plan_as_default(service_id, application_plan_id) ⇒ Hash 



423
424
425
426
 
# File 'lib/3scale/api/client.rb', line 423

def application_plan_as_default(service_id, application_plan_id)
  response = http_client.put("/admin/api/services/#{service_id}/application_plans/#{application_plan_id}/default")
  extract(entity: 'application_plan', from: response)
end

#approve_account(account_id) ⇒ Hash 



717
718
719
720
 
# File 'lib/3scale/api/client.rb', line 717

def ()
  response = http_client.put("/admin/api/accounts/#{account_id}/approve")
  extract(entity: 'account', from: response)
end

#backend(id) ⇒ Hash 



854
855
856
857
 
# File 'lib/3scale/api/client.rb', line 854

def backend(id)
  response = http_client.get("/admin/api/backend_apis/#{id}")
  extract(entity: 'backend_api', from: response)
end

#backend_mapping_rule(backend_id, mapping_rule_id) ⇒ Hash 



993
994
995
996
 
# File 'lib/3scale/api/client.rb', line 993

def backend_mapping_rule(backend_id, mapping_rule_id)
  response = http_client.get("/admin/api/backend_apis/#{backend_id}/mapping_rules/#{mapping_rule_id}")
  extract(entity: 'mapping_rule', from: response)
end

#backend_method(backend_id, metric_id, method_id) ⇒ Hash 



946
947
948
949
 
# File 'lib/3scale/api/client.rb', line 946

def backend_method(backend_id, metric_id, method_id)
  response = http_client.get("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}/methods/#{method_id}")
  extract(entity: 'method', from: response)
end

#backend_metric(backend_id, metric_id) ⇒ Hash 



897
898
899
900
 
# File 'lib/3scale/api/client.rb', line 897

def backend_metric(backend_id, metric_id)
  response = http_client.get("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}")
  extract(entity: 'metric', from: response)
end

#backend_usage(product_id, id) ⇒ Hash 



1039
1040
1041
1042
 
# File 'lib/3scale/api/client.rb', line 1039

def backend_usage(product_id, id)
  response = http_client.get("/admin/api/services/#{product_id}/backend_usages/#{id}")
  extract(entity: 'backend_usage', from: response)
end

#create_activedocs(attributes) ⇒ Hash 



545
546
547
548
 
# File 'lib/3scale/api/client.rb', line 545

def create_activedocs(attributes)
  response = http_client.post('/admin/api/active_docs', body: attributes)
  extract(entity: 'api_doc', from: response)
end

#create_application(account_id, attributes = {}, plan_id:, **rest) ⇒ Hash

Returns an Application.

Options Hash (attributes):

  • :name (String) —

    Application Name

  • :description (String) —

    Application Description

  • :user_key (String) —

    Application User Key

  • :application_id (String) —

    Application App ID

  • :application_key (String) —

    Application App Key(s)



76
77
78
79
80
 
# File 'lib/3scale/api/client.rb', line 76

def create_application(, attributes = {}, plan_id:, **rest)
  body = { plan_id: plan_id }.merge(attributes).merge(rest)
  response = http_client.post("/admin/api/accounts/#{account_id}/applications", body: body)
  extract(entity: 'application', from: response)
end

#create_application_key(account_id, application_id, key) ⇒ Hash 



751
752
753
754
 
# File 'lib/3scale/api/client.rb', line 751

def create_application_key(, application_id, key)
  response = http_client.post("/admin/api/accounts/#{account_id}/applications/#{application_id}/keys", body: {key: key})
  extract(entity: 'application', from: response)
end

#create_application_plan(service_id, attributes) ⇒ Hash

Options Hash (attributes):

  • :name (String) —

    Application Plan Name



384
385
386
387
388
 
# File 'lib/3scale/api/client.rb', line 384

def create_application_plan(service_id, attributes)
  response = http_client.post("/admin/api/services/#{service_id}/application_plans",
                              body: { application_plan: attributes })
  extract(entity: 'application_plan', from: response)
end

#create_application_plan_feature(application_plan_id, id) ⇒ Hash 



619
620
621
622
623
 
# File 'lib/3scale/api/client.rb', line 619

def create_application_plan_feature(application_plan_id, id)
  response = http_client.post("/admin/api/application_plans/#{application_plan_id}/features",
                              body: { feature_id: id })
  extract(entity: 'feature', from: response)
end

#create_application_plan_limit(application_plan_id, metric_id, attributes) ⇒ Hash 



442
443
444
445
446
 
# File 'lib/3scale/api/client.rb', line 442

def create_application_plan_limit(application_plan_id, metric_id, attributes)
  response = http_client.post("/admin/api/application_plans/#{application_plan_id}/metrics/#{metric_id}/limits",
                              body: { usage_limit: attributes })
  extract(entity: 'limit', from: response)
end

#create_backend(attributes) ⇒ Hash 



839
840
841
842
 
# File 'lib/3scale/api/client.rb', line 839

def create_backend(attributes)
  response = http_client.post('/admin/api/backend_apis', body: attributes)
  extract(entity: 'backend_api', from: response)
end

#create_backend_mapping_rule(backend_id, attrs) ⇒ Hash 



975
976
977
978
979
 
# File 'lib/3scale/api/client.rb', line 975

def create_backend_mapping_rule(backend_id, attrs)
  response = http_client.post("/admin/api/backend_apis/#{backend_id}/mapping_rules",
                              body: attrs)
  extract(entity: 'mapping_rule', from: response)
end

#create_backend_method(backend_id, metric_id, attrs) ⇒ Hash 



926
927
928
929
930
 
# File 'lib/3scale/api/client.rb', line 926

def create_backend_method(backend_id, metric_id, attrs)
  response = http_client.post("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}/methods",
                              body: attrs)
  extract(entity: 'method', from: response)
end

#create_backend_metric(id, attrs) ⇒ Hash 



880
881
882
883
 
# File 'lib/3scale/api/client.rb', line 880

def create_backend_metric(id, attrs)
  response = http_client.post("/admin/api/backend_apis/#{id}/metrics", body: attrs)
  extract(entity: 'metric', from: response)
end

#create_backend_usage(product_id, attrs) ⇒ Hash 



1021
1022
1023
1024
1025
 
# File 'lib/3scale/api/client.rb', line 1021

def create_backend_usage(product_id, attrs)
  response = http_client.post("/admin/api/services/#{product_id}/backend_usages",
                              body: attrs)
  extract(entity: 'backend_usage', from: response)
end

#create_mapping_rule(service_id, attributes) ⇒ Array<Hash>

Options Hash (attributes):

  • :http_method (String) —

    HTTP Method

  • :pattern (String) —

    Pattern

  • :delta (Fixnum) —

    Increase the metric by delta.

  • :metric_id (Fixnum) —

    Metric ID



228
229
230
231
232
 
# File 'lib/3scale/api/client.rb', line 228

def create_mapping_rule(service_id, attributes)
  response = http_client.post("/admin/api/services/#{service_id}/proxy/mapping_rules",
                              body: { mapping_rule: attributes })
  extract(entity: 'mapping_rule', from: response)
end

#create_method(service_id, metric_id, attributes) ⇒ Hash

Options Hash (attributes):

  • :name (String) —

    Method Name



345
346
347
348
349
 
# File 'lib/3scale/api/client.rb', line 345

def create_method(service_id, metric_id, attributes)
  response = http_client.post("/admin/api/services/#{service_id}/metrics/#{metric_id}/methods",
                              body: { metric: attributes })
  extract(entity: 'method', from: response)
end

#create_metric(service_id, attributes) ⇒ Hash

Options Hash (attributes):

  • :name (String) —

    Metric Name



280
281
282
283
 
# File 'lib/3scale/api/client.rb', line 280

def create_metric(service_id, attributes)
  response = http_client.post("/admin/api/services/#{service_id}/metrics", body: { metric: attributes })
  extract(entity: 'metric', from: response)
end

#create_policy_registry(attributes) ⇒ Hash 



793
794
795
796
 
# File 'lib/3scale/api/client.rb', line 793

def create_policy_registry(attributes)
  response = http_client.post('/admin/api/registry/policies', body: attributes)
  extract(entity: 'policy', from: response)
end

#create_pricingrule(application_plan_id, metric_id, attributes) ⇒ Array<Hash> 



520
521
522
523
 
# File 'lib/3scale/api/client.rb', line 520

def create_pricingrule(application_plan_id, metric_id, attributes)
  response = http_client.post("/admin/api/application_plans/#{application_plan_id}/metrics/#{metric_id}/pricing_rules", body: attributes)
  extract(entity: 'pricing_rule', from: response)
end

#create_service(attributes) ⇒ Hash

Options Hash (attributes):

  • :name (String) —

    Service Name



131
132
133
134
 
# File 'lib/3scale/api/client.rb', line 131

def create_service(attributes)
  response = http_client.post('/admin/api/services', body: { service: attributes })
  extract(entity: 'service', from: response)
end

#create_service_feature(id, attributes) ⇒ Hash 



646
647
648
649
650
 
# File 'lib/3scale/api/client.rb', line 646

def create_service_feature(id, attributes)
  response = http_client.post("/admin/api/services/#{id}/features",
                              body: { feature: attributes })
  extract(entity: 'feature', from: response)
end

#create_user(account_id:, email:, username:, password:, **rest) ⇒ Hash 



699
700
701
702
703
 
# File 'lib/3scale/api/client.rb', line 699

def create_user(account_id:, email:, username:, password:, **rest)
  body = { email: email, username: username, password: password }.merge(rest)
  response = http_client.post("/admin/api/accounts/#{account_id}/users", body: body)
  extract(entity: 'user', from: response)
end

#customize_application_plan(account_id, application_id) ⇒ Hash

Returns a Plan.



96
97
98
99
 
# File 'lib/3scale/api/client.rb', line 96

def customize_application_plan(, application_id)
  response = http_client.put("/admin/api/accounts/#{account_id}/applications/#{application_id}/customize_plan")
  extract(entity: 'application_plan', from: response)
end

#delete_account(id) ⇒ Bool 



576
577
578
579
 
# File 'lib/3scale/api/client.rb', line 576

def (id)
  http_client.delete("/admin/api/accounts/#{id}")
  true
end

#delete_activedocs(id) ⇒ Hash 



561
562
563
564
 
# File 'lib/3scale/api/client.rb', line 561

def delete_activedocs(id)
  http_client.delete("/admin/api/active_docs/#{id}")
  true
end

#delete_application(account_id, id) ⇒ Bool 



585
586
587
588
 
# File 'lib/3scale/api/client.rb', line 585

def delete_application(, id)
  http_client.delete("/admin/api/accounts/#{account_id}/applications/#{id}")
  true
end

#delete_application_plan(service_id, application_plan_id) ⇒ Bool 



414
415
416
417
 
# File 'lib/3scale/api/client.rb', line 414

def delete_application_plan(service_id, application_plan_id)
  http_client.delete("/admin/api/services/#{service_id}/application_plans/#{application_plan_id}")
  true
end

#delete_application_plan_customization(account_id, application_id) ⇒ Hash

Returns a Plan.



105
106
107
108
 
# File 'lib/3scale/api/client.rb', line 105

def delete_application_plan_customization(, application_id)
  response = http_client.put("/admin/api/accounts/#{account_id}/applications/#{application_id}/decustomize_plan")
  extract(entity: 'application_plan', from: response)
end

#delete_application_plan_feature(application_plan_id, id) ⇒ Boolean 



629
630
631
632
 
# File 'lib/3scale/api/client.rb', line 629

def delete_application_plan_feature(application_plan_id, id)
  http_client.delete("/admin/api/application_plans/#{application_plan_id}/features/#{id}")
  true
end

#delete_application_plan_limit(application_plan_id, metric_id, limit_id) ⇒ Object 



463
464
465
466
 
# File 'lib/3scale/api/client.rb', line 463

def delete_application_plan_limit(application_plan_id, metric_id, limit_id)
  http_client.delete("/admin/api/application_plans/#{application_plan_id}/metrics/#{metric_id}/limits/#{limit_id}")
  true
end

#delete_application_plan_pricingrule(application_plan_id, metric_id, id) ⇒ Bool 



530
531
532
533
 
# File 'lib/3scale/api/client.rb', line 530

def delete_application_plan_pricingrule(application_plan_id, metric_id, id)
  http_client.delete("/admin/api/application_plans/#{application_plan_id}/metrics/#{metric_id}/pricing_rules/#{id}")
  true
end

#delete_backend(id) ⇒ Object 



846
847
848
849
 
# File 'lib/3scale/api/client.rb', line 846

def delete_backend(id)
  http_client.delete("/admin/api/backend_apis/#{id}")
  true
end

#delete_backend_mapping_rule(backend_id, mapping_rule_id) ⇒ Object 



984
985
986
987
 
# File 'lib/3scale/api/client.rb', line 984

def delete_backend_mapping_rule(backend_id, mapping_rule_id)
  http_client.delete("/admin/api/backend_apis/#{backend_id}/mapping_rules/#{mapping_rule_id}")
  true
end

#delete_backend_method(backend_id, metric_id, method_id) ⇒ Object 



936
937
938
939
 
# File 'lib/3scale/api/client.rb', line 936

def delete_backend_method(backend_id, metric_id, method_id)
  http_client.delete("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}/methods/#{method_id}")
  true
end

#delete_backend_metric(backend_id, metric_id) ⇒ Object 



888
889
890
891
 
# File 'lib/3scale/api/client.rb', line 888

def delete_backend_metric(backend_id, metric_id)
  http_client.delete("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}")
  true
end

#delete_backend_usage(product_id, id) ⇒ Object 



1030
1031
1032
1033
 
# File 'lib/3scale/api/client.rb', line 1030

def delete_backend_usage(product_id, id)
  http_client.delete("/admin/api/services/#{product_id}/backend_usages/#{id}")
  true
end

#delete_mapping_rule(service_id, id) ⇒ Array<Hash> 



238
239
240
241
 
# File 'lib/3scale/api/client.rb', line 238

def delete_mapping_rule(service_id, id)
  http_client.delete("/admin/api/services/#{service_id}/proxy/mapping_rules/#{id}")
  true
end

#delete_method(service_id, parent_id, id) ⇒ Bool 



356
357
358
359
 
# File 'lib/3scale/api/client.rb', line 356

def delete_method(service_id, parent_id, id)
  http_client.delete("/admin/api/services/#{service_id}/metrics/#{parent_id}/methods/#{id}")
  true
end

#delete_metric(service_id, metric_id) ⇒ Bool 



303
304
305
306
 
# File 'lib/3scale/api/client.rb', line 303

def delete_metric(service_id, metric_id)
  http_client.delete("/admin/api/services/#{service_id}/metrics/#{metric_id}")
  true
end

#delete_policy_registry(id) ⇒ Object 



817
818
819
820
 
# File 'lib/3scale/api/client.rb', line 817

def delete_policy_registry(id)
  http_client.delete("/admin/api/registry/policies/#{id}")
  true
end

#delete_service(id) ⇒ Object 



29
30
31
32
 
# File 'lib/3scale/api/client.rb', line 29

def delete_service(id)
  http_client.delete("/admin/api/services/#{id}")
  true
end

#delete_service_feature(service_id, id) ⇒ Boolean 



676
677
678
679
 
# File 'lib/3scale/api/client.rb', line 676

def delete_service_feature(service_id, id)
  http_client.delete("/admin/api/services/#{service_id}/features/#{id}")
  true
end

#find_account(criteria) ⇒ Hash 



471
472
473
474
 
# File 'lib/3scale/api/client.rb', line 471

def (criteria)
  response = http_client.get('/admin/api/accounts/find', params: criteria)
  extract(entity: 'account', from: response)
end

#find_application(id: nil, user_key: nil, application_id: nil, service_id: nil) ⇒ Hash 



56
57
58
59
60
61
62
63
64
65
 
# File 'lib/3scale/api/client.rb', line 56

def find_application(id: nil, user_key: nil, application_id: nil, service_id: nil)
  params = {
    application_id: id,
    user_key: user_key,
    app_id: application_id,
    service_id: service_id,
  }.compact
  response = http_client.get('/admin/api/applications/find', params: params)
  extract(entity: 'application', from: response)
end

#list_account_applications(account_id) ⇒ Array<Hash> 



725
726
727
728
 
# File 'lib/3scale/api/client.rb', line 725

def ()
  response = http_client.get("/admin/api/accounts/#{account_id}/applications")
  extract(collection: 'applications', entity: 'application', from: response)
end

#list_accounts ⇒ Array<Hash> 



568
569
570
571
 
# File 'lib/3scale/api/client.rb', line 568

def list_accounts
  response = http_client.get('/admin/api/accounts')
  extract(collection: 'accounts', entity: 'account', from: response)
end

#list_activedocs ⇒ Array<Hash> 



537
538
539
540
 
# File 'lib/3scale/api/client.rb', line 537

def list_activedocs
  response = http_client.get('/admin/api/active_docs')
  extract(collection: 'api_docs', entity: 'api_doc', from: response)
end

#list_application_keys(account_id, application_id) ⇒ Array<Hash> 



741
742
743
744
 
# File 'lib/3scale/api/client.rb', line 741

def list_application_keys(, application_id)
  response = http_client.get("/admin/api/accounts/#{account_id}/applications/#{application_id}/keys")
  extract(collection: 'keys', entity: 'key', from: response)
end

#list_application_plan_limits(application_plan_id) ⇒ Array<Hash> 



431
432
433
434
435
 
# File 'lib/3scale/api/client.rb', line 431

def list_application_plan_limits(application_plan_id)
  response = http_client.get("/admin/api/application_plans/#{application_plan_id}/limits")

  extract(collection: 'limits', entity: 'limit', from: response)
end

#list_application_plans ⇒ Array<Hash]

Returns Array<Hash].



732
733
734
735
 
# File 'lib/3scale/api/client.rb', line 732

def list_application_plans
  response = http_client.get("/admin/api/application_plans")
  extract(collection: 'plans', entity: 'application_plan', from: response)
end

#list_applications(service_id: nil, plan_id: nil) ⇒ Array<Hash> 



38
39
40
41
42
 
# File 'lib/3scale/api/client.rb', line 38

def list_applications(service_id: nil, plan_id: nil)
  params = { service_id: service_id, plan_id: plan_id }.compact
  response = http_client.get('/admin/api/applications', params: params)
  extract(collection: 'applications', entity: 'application', from: response)
end

#list_backend_mapping_rules(backend_id) ⇒ List 



966
967
968
969
 
# File 'lib/3scale/api/client.rb', line 966

def list_backend_mapping_rules(backend_id)
  response = http_client.get("/admin/api/backend_apis/#{backend_id}/mapping_rules")
  extract(collection: 'mapping_rules', entity: 'mapping_rule', from: response)
end

#list_backend_methods(backend_id, metric_id) ⇒ List 



916
917
918
919
 
# File 'lib/3scale/api/client.rb', line 916

def list_backend_methods(backend_id, metric_id)
  response = http_client.get("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}/methods")
  extract(collection: 'methods', entity: 'method', from: response)
end

#list_backend_metrics(id) ⇒ List 



871
872
873
874
 
# File 'lib/3scale/api/client.rb', line 871

def list_backend_metrics(id)
  response = http_client.get("/admin/api/backend_apis/#{id}/metrics")
  extract(collection: 'metrics', entity: 'metric', from: response)
end

#list_backend_usages(product_id) ⇒ List 



1012
1013
1014
1015
 
# File 'lib/3scale/api/client.rb', line 1012

def list_backend_usages(product_id)
  response = http_client.get("/admin/api/services/#{product_id}/backend_usages")
  extract(entity: 'backend_usage', from: response)
end

#list_backends ⇒ List 



831
832
833
834
 
# File 'lib/3scale/api/client.rb', line 831

def list_backends
  response = http_client.get('/admin/api/backend_apis')
  extract(collection: 'backend_apis', entity: 'backend_api', from: response)
end

#list_features_per_application_plan(application_plan_id) ⇒ Array<Hash> 



610
611
612
613
 
# File 'lib/3scale/api/client.rb', line 610

def list_features_per_application_plan(application_plan_id)
  response = http_client.get("/admin/api/application_plans/#{application_plan_id}/features")
  extract(collection: 'features', entity: 'feature', from: response)
end

#list_mapping_rules(service_id) ⇒ Array<Hash> 



206
207
208
209
 
# File 'lib/3scale/api/client.rb', line 206

def list_mapping_rules(service_id)
  response = http_client.get("/admin/api/services/#{service_id}/proxy/mapping_rules")
  extract(entity: 'mapping_rule', collection: 'mapping_rules', from: response)
end

#list_methods(service_id, metric_id) ⇒ Array<Hash> 



334
335
336
337
 
# File 'lib/3scale/api/client.rb', line 334

def list_methods(service_id, metric_id)
  response = http_client.get("/admin/api/services/#{service_id}/metrics/#{metric_id}/methods")
  extract(collection: 'methods', entity: 'method', from: response)
end

#list_metric_limits(application_plan_id, metric_id) ⇒ Hash 



365
366
367
368
 
# File 'lib/3scale/api/client.rb', line 365

def list_metric_limits(application_plan_id, metric_id)
  response = http_client.get("/admin/api/application_plans/#{application_plan_id}/metrics/#{metric_id}/limits")
  extract(collection: 'limits', entity: 'limit', from: response)
end

#list_metrics(service_id) ⇒ Array<Hash> 



270
271
272
273
 
# File 'lib/3scale/api/client.rb', line 270

def list_metrics(service_id)
  response = http_client.get("/admin/api/services/#{service_id}/metrics")
  extract(collection: 'metrics', entity: 'metric', from: response)
end

#list_policy_registry ⇒ Array<Hash> 



785
786
787
788
 
# File 'lib/3scale/api/client.rb', line 785

def list_policy_registry
  response = http_client.get('/admin/api/registry/policies')
  extract(collection: 'policies', entity: 'policy', from: response)
end

#list_pricingrules_per_application_plan(application_plan_id) ⇒ Array<Hash> 



512
513
514
515
 
# File 'lib/3scale/api/client.rb', line 512

def list_pricingrules_per_application_plan(application_plan_id)
  response = http_client.get("/admin/api/application_plans/#{application_plan_id}/pricing_rules")
  extract(collection: 'pricing_rules', entity: 'pricing_rule', from: response)
end

#list_pricingrules_per_metric(application_plan_id, metric_id) ⇒ Array<Hash> 



504
505
506
507
 
# File 'lib/3scale/api/client.rb', line 504

def list_pricingrules_per_metric(application_plan_id, metric_id)
  response = http_client.get("/admin/api/application_plans/#{application_plan_id}/metrics/#{metric_id}/pricing_rules")
  extract(collection: 'pricing_rules', entity: 'pricing_rule', from: response)
end

#list_service_application_plans(service_id) ⇒ Array<Hash> 



373
374
375
376
377
 
# File 'lib/3scale/api/client.rb', line 373

def list_service_application_plans(service_id)
  response = http_client.get("/admin/api/services/#{service_id}/application_plans")

  extract(collection: 'plans', entity: 'application_plan', from: response)
end

#list_service_features(id) ⇒ Array<Hash> 



637
638
639
640
 
# File 'lib/3scale/api/client.rb', line 637

def list_service_features(id)
  response = http_client.get("/admin/api/services/#{id}/features")
  extract(collection: 'features', entity: 'feature', from: response)
end

#list_services ⇒ Array<Hash> 



22
23
24
25
 
# File 'lib/3scale/api/client.rb', line 22

def list_services
  response = http_client.get('/admin/api/services')
  extract(collection: 'services', entity: 'service', from: response)
end

#list_users(account_id, state: nil, role: nil) ⇒ Array<Hash> 



686
687
688
689
690
 
# File 'lib/3scale/api/client.rb', line 686

def list_users(, state: nil, role: nil)
  params = { state: state, role: role }.reject { |_, value| value.nil? }
  response = http_client.get("/admin/api/accounts/#{account_id}/users", params: params)
  extract(collection: 'users', entity: 'user', from: response)
end

#promote_proxy_config(service_id, environment, version, to) ⇒ Hash 



188
189
190
191
192
 
# File 'lib/3scale/api/client.rb', line 188

def promote_proxy_config(service_id, environment, version, to)
  response = http_client.post("/admin/api/services/#{service_id}/proxy/configs/#{environment}/#{version}/promote",
                              body: { to: to })
  extract(entity: 'proxy_config', from: response)
end

#proxy_config_latest(service_id, environment = 'sandbox') ⇒ Hash 



167
168
169
170
 
# File 'lib/3scale/api/client.rb', line 167

def proxy_config_latest(service_id, environment = 'sandbox')
  response = http_client.get("/admin/api/services/#{service_id}/proxy/configs/#{environment}/latest")
  extract(entity: 'proxy_config', from: response)
end

#proxy_config_list(service_id, environment = 'sandbox') ⇒ Hash 



158
159
160
161
 
# File 'lib/3scale/api/client.rb', line 158

def proxy_config_list(service_id, environment = 'sandbox')
  response = http_client.get("/admin/api/services/#{service_id}/proxy/configs/#{environment}")
  extract(collection: 'proxy_configs', entity: 'proxy_config', from: response)
end

#resume_application(account_id, application_id) ⇒ Hash

Returns application Application.



778
779
780
781
 
# File 'lib/3scale/api/client.rb', line 778

def resume_application(, application_id)
  response = http_client.put("/admin/api/accounts/#{account_id}/applications/#{application_id}/resume")
  extract(entity: 'application', from: response)
end

#show_account(id) ⇒ Hash 



479
480
481
482
 
# File 'lib/3scale/api/client.rb', line 479

def (id)
  response = http_client.get("/admin/api/accounts/#{id}")
  extract(entity: 'account', from: response)
end

#show_application(id) ⇒ Hash 



47
48
49
 
# File 'lib/3scale/api/client.rb', line 47

def show_application(id)
  find_application(id: id)
end

#show_application_plan(service_id, id) ⇒ Hash 



394
395
396
397
 
# File 'lib/3scale/api/client.rb', line 394

def show_application_plan(service_id, id)
  response = http_client.get("/admin/api/services/#{service_id}/application_plans/#{id}")
  extract(entity: 'application_plan', from: response)
end

#show_mapping_rule(service_id, id) ⇒ Array<Hash> 



215
216
217
218
 
# File 'lib/3scale/api/client.rb', line 215

def show_mapping_rule(service_id, id)
  response = http_client.get("/admin/api/services/#{service_id}/proxy/mapping_rules/#{id}")
  extract(entity: 'mapping_rule', from: response)
end

#show_method(service_id, parent_id, id) ⇒ Hash 



313
314
315
316
 
# File 'lib/3scale/api/client.rb', line 313

def show_method(service_id, parent_id, id)
  response = http_client.get("/admin/api/services/#{service_id}/metrics/#{parent_id}/methods/#{id}")
  extract(entity: 'method', from: response)
end

#show_metric(service_id, id) ⇒ Hash 



262
263
264
265
 
# File 'lib/3scale/api/client.rb', line 262

def show_metric(service_id, id)
  response = http_client.get("/admin/api/services/#{service_id}/metrics/#{id}")
  extract(entity: 'metric', from: response)
end

#show_oidc(service_id) ⇒ Array<Hash> 



593
594
595
596
 
# File 'lib/3scale/api/client.rb', line 593

def show_oidc(service_id)
  response = http_client.get("/admin/api/services/#{service_id}/proxy/oidc_configuration")
  extract(entity: 'oidc_configuration', from: response)
end

#show_policies(id) ⇒ Array 



487
488
489
490
 
# File 'lib/3scale/api/client.rb', line 487

def show_policies(id)
  response = http_client.get("/admin/api/services/#{id}/proxy/policies")
  extract(entity: 'policies_config', from: response)
end

#show_policy_registry(id) ⇒ Hash 



801
802
803
804
 
# File 'lib/3scale/api/client.rb', line 801

def show_policy_registry(id)
  response = http_client.get("/admin/api/registry/policies/#{id}")
  extract(entity: 'policy', from: response)
end

#show_provider ⇒ Hash 



824
825
826
827
 
# File 'lib/3scale/api/client.rb', line 824

def show_provider
  response = http_client.get('/admin/api/provider')
  extract(entity: 'account', from: response)
end

#show_proxy(service_id) ⇒ Hash 



149
150
151
152
 
# File 'lib/3scale/api/client.rb', line 149

def show_proxy(service_id)
  response = http_client.get("/admin/api/services/#{service_id}/proxy")
  extract(entity: 'proxy', from: response)
end

#show_proxy_config(service_id, environment, version) ⇒ Hash 



177
178
179
180
 
# File 'lib/3scale/api/client.rb', line 177

def show_proxy_config(service_id, environment, version)
  response = http_client.get("/admin/api/services/#{service_id}/proxy/configs/#{environment}/#{version}")
  extract(entity: 'proxy_config', from: response)
end

#show_service(id) ⇒ Hash 



15
16
17
18
 
# File 'lib/3scale/api/client.rb', line 15

def show_service(id)
  response = http_client.get("/admin/api/services/#{id}")
  extract(entity: 'service', from: response)
end

#show_service_feature(service_id, id) ⇒ Hash 



656
657
658
659
 
# File 'lib/3scale/api/client.rb', line 656

def show_service_feature(service_id, id)
  response = http_client.get("/admin/api/services/#{service_id}/features/#{id}")
  extract(entity: 'feature', from: response)
end

#signup(attributes = {}, name:, username:, **rest) ⇒ Hash

Returns an Account.

Options Hash (attributes):

  • :email (String) —

    User Email

  • :password (String) —

    User Password

  • :account_plan_id (String) —

    Account Plan ID

  • :service_plan_id (String) —

    Service Plan ID

  • :application_plan_id (String) —

    Application Plan ID



120
121
122
123
124
125
 
# File 'lib/3scale/api/client.rb', line 120

def (attributes = {}, name:, username:, **rest)
  body = { org_name: name,
           username: username }.merge(attributes).merge(rest)
  response = http_client.post('/admin/api/signup', body: body)
  extract(entity: 'account', from: response)
end

#suspend_application(account_id, application_id) ⇒ Hash

Returns application Application.



769
770
771
772
 
# File 'lib/3scale/api/client.rb', line 769

def suspend_application(, application_id)
  response = http_client.put("/admin/api/accounts/#{account_id}/applications/#{application_id}/suspend")
  extract(entity: 'application', from: response)
end

#update_activedocs(id, attributes) ⇒ Hash 



554
555
556
557
 
# File 'lib/3scale/api/client.rb', line 554

def update_activedocs(id, attributes)
  response = http_client.put("/admin/api/active_docs/#{id}", body: attributes)
  extract(entity: 'api_doc', from: response)
end

#update_application(account_id, id, attrs) ⇒ Hash

Returns an Application.



87
88
89
90
 
# File 'lib/3scale/api/client.rb', line 87

def update_application(, id, attrs)
  response = http_client.put("/admin/api/accounts/#{account_id}/applications/#{id}", body: attrs)
  extract(entity: 'application', from: response)
end

#update_application_plan(service_id, id, attributes) ⇒ Hash 



404
405
406
407
408
 
# File 'lib/3scale/api/client.rb', line 404

def update_application_plan(service_id, id, attributes)
  response = http_client.patch("/admin/api/services/#{service_id}/application_plans/#{id}",
                               body: { application_plan: attributes })
  extract(entity: 'application_plan', from: response)
end

#update_application_plan_limit(application_plan_id, metric_id, limit_id, attributes) ⇒ Hash 



454
455
456
457
458
 
# File 'lib/3scale/api/client.rb', line 454

def update_application_plan_limit(application_plan_id, metric_id, limit_id, attributes)
  response = http_client.put("/admin/api/application_plans/#{application_plan_id}/metrics/#{metric_id}/limits/#{limit_id}",
                             body: { usage_limit: attributes })
  extract(entity: 'limit', from: response)
end

#update_backend(id, attributes) ⇒ Hash 



863
864
865
866
 
# File 'lib/3scale/api/client.rb', line 863

def update_backend(id, attributes)
  response = http_client.put("/admin/api/backend_apis/#{id}", body: attributes)
  extract(entity: 'backend_api', from: response)
end

#update_backend_mapping_rule(backend_id, mapping_rule_id, attributes) ⇒ Hash 



1003
1004
1005
1006
1007
 
# File 'lib/3scale/api/client.rb', line 1003

def update_backend_mapping_rule(backend_id, mapping_rule_id, attributes)
  response = http_client.put("/admin/api/backend_apis/#{backend_id}/mapping_rules/#{mapping_rule_id}",
                             body: attributes)
  extract(entity: 'mapping_rule', from: response)
end

#update_backend_method(backend_id, metric_id, method_id, attributes) ⇒ Hash 



957
958
959
960
961
 
# File 'lib/3scale/api/client.rb', line 957

def update_backend_method(backend_id, metric_id, method_id, attributes)
  response = http_client.put("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}/methods/#{method_id}",
                             body: attributes)
  extract(entity: 'method', from: response)
end

#update_backend_metric(backend_id, metric_id, attributes) ⇒ Hash 



907
908
909
910
 
# File 'lib/3scale/api/client.rb', line 907

def update_backend_metric(backend_id, metric_id, attributes)
  response = http_client.put("/admin/api/backend_apis/#{backend_id}/metrics/#{metric_id}", body: attributes)
  extract(entity: 'metric', from: response)
end

#update_backend_usage(product_id, id, attrs) ⇒ Hash 



1049
1050
1051
1052
1053
 
# File 'lib/3scale/api/client.rb', line 1049

def update_backend_usage(product_id, id, attrs)
  response = http_client.put("/admin/api/services/#{product_id}/backend_usages/#{id}",
                             body: attrs)
  extract(entity: 'backend_usage', from: response)
end

#update_mapping_rule(service_id, id, attributes) ⇒ Array<Hash>

Options Hash (attributes):

  • :http_method (String) —

    HTTP Method

  • :pattern (String) —

    Pattern

  • :delta (Fixnum) —

    Increase the metric by delta.

  • :metric_id (Fixnum) —

    Metric ID



252
253
254
255
256
 
# File 'lib/3scale/api/client.rb', line 252

def update_mapping_rule(service_id, id, attributes)
  response = http_client.patch("/admin/api/services/#{service_id}/mapping_rules/#{id}",
                               body: { mapping_rule: attributes })
  extract(entity: 'mapping_rule', from: response)
end

#update_method(service_id, parent_id, id, attributes) ⇒ Hash 



324
325
326
327
328
 
# File 'lib/3scale/api/client.rb', line 324

def update_method(service_id, parent_id, id, attributes)
  response = http_client.put("/admin/api/services/#{service_id}/metrics/#{parent_id}/methods/#{id}",
                             body: { metric: attributes })
  extract(entity: 'method', from: response)
end

#update_metric(service_id, metric_id, attributes) ⇒ Hash

Options Hash (attributes):

  • :friendly_name (String) —

    Metric Name

  • :unit (String) —

    Metric unit

  • :description (String) —

    Metric description



293
294
295
296
297
 
# File 'lib/3scale/api/client.rb', line 293

def update_metric(service_id, metric_id, attributes)
  response = http_client.put("/admin/api/services/#{service_id}/metrics/#{metric_id}",
                             body: { metric: attributes })
  extract(entity: 'metric', from: response)
end

#update_oidc(service_id, attributes) ⇒ Hash 



601
602
603
604
605
 
# File 'lib/3scale/api/client.rb', line 601

def update_oidc(service_id, attributes)
  response = http_client.patch("/admin/api/services/#{service_id}/proxy/oidc_configuration",
                               body: { oidc_configuration: attributes })
  extract(entity: 'oidc_configuration', from: response)
end

#update_policies(id, policies_config) ⇒ Array 



495
496
497
498
 
# File 'lib/3scale/api/client.rb', line 495

def update_policies(id, policies_config)
  response = http_client.put("/admin/api/services/#{id}/proxy/policies", body: policies_config)
  extract(entity: 'policies_config', from: response)
end

#update_policy_registry(id, attributes) ⇒ Hash 



810
811
812
813
 
# File 'lib/3scale/api/client.rb', line 810

def update_policy_registry(id, attributes)
  response = http_client.put("/admin/api/registry/policies/#{id}", body: attributes)
  extract(entity: 'policy', from: response)
end

#update_proxy(service_id, attributes) ⇒ Hash 



197
198
199
200
201
 
# File 'lib/3scale/api/client.rb', line 197

def update_proxy(service_id, attributes)
  response = http_client.patch("/admin/api/services/#{service_id}/proxy",
                               body: { proxy: attributes })
  extract(entity: 'proxy', from: response)
end

#update_service(service_id, attributes) ⇒ Hash

Options Hash (attributes):

  • :name (String) —

    Service Name



141
142
143
144
 
# File 'lib/3scale/api/client.rb', line 141

def update_service(service_id, attributes)
  response = http_client.put("/admin/api/services/#{service_id}", body: { service: attributes })
  extract(entity: 'service', from: response)
end

#update_service_feature(service_id, id, attributes) ⇒ Hash 



666
667
668
669
670
 
# File 'lib/3scale/api/client.rb', line 666

def update_service_feature(service_id, id, attributes)
  response = http_client.put("/admin/api/services/#{service_id}/features/#{id}",
                             body: { feature: attributes })
  extract(entity: 'feature', from: response)
end