Class: CardDB::Resources::Rulesets

Inherits:
Base
  • Object
show all
Defined in:
lib/carddb/resources/rulesets.rb

Overview

First-class rulesets resource for deck validation rules.

Instance Attribute Summary

Attributes inherited from Base

#client, #config, #connection

Instance Method Summary collapse

Methods inherited from Base

#initialize

Constructor Details

This class inherits a constructor from CardDB::Resources::Base

Instance Method Details

#activate_version(id:) ⇒ Object 



176
177
178
179
180
181
 
# File 'lib/carddb/resources/rulesets.rb', line 176

def activate_version(id:)
  config.require_secret_credential!('rulesets.activate_version')

  data = connection.execute(QueryBuilder.activate_ruleset_version, { id: id })
  RulesetVersion.new(data['rulesetVersionActivate'], client: client)
end

#create(input:) ⇒ Object 



130
131
132
133
134
135
 
# File 'lib/carddb/resources/rulesets.rb', line 130

def create(input:)
  config.require_secret_credential!('rulesets.create')

  data = connection.execute(QueryBuilder.create_ruleset, { input: input })
  Ruleset.new(data['rulesetCreate'], client: client)
end

#create_draft(ruleset_id:, input:) ⇒ Object 



144
145
146
147
148
149
 
# File 'lib/carddb/resources/rulesets.rb', line 144

def create_draft(ruleset_id:, input:)
  config.require_secret_credential!('rulesets.create_draft')

  data = connection.execute(QueryBuilder.create_ruleset_version_draft, { rulesetId: ruleset_id, input: input })
  RulesetVersion.new(data['rulesetVersionDraftCreate'], client: client)
end

#deck_validation_rules(game_id:, ruleset_key:, ruleset_version_id: nil, cache: nil) ⇒ Object 



97
98
99
100
101
102
103
104
105
 
# File 'lib/carddb/resources/rulesets.rb', line 97

def deck_validation_rules(game_id:, ruleset_key:, ruleset_version_id: nil, cache: nil)
  variables = build_variables(gameId: game_id, rulesetKey: ruleset_key, rulesetVersionId: ruleset_version_id)
  key = cache_key('rulesets', 'deck_validation_rules', **variables)

  with_cache(key, resource: :rulesets, cache: cache) do
    data = connection.execute(QueryBuilder.deck_validation_rules, variables)
    data['deckValidationRules'] ? DeckValidationRules.new(data['deckValidationRules'], client: client) : nil
  end
end

#get(id, cache: nil) ⇒ Object 



46
47
48
49
50
51
52
 
# File 'lib/carddb/resources/rulesets.rb', line 46

def get(id, cache: nil)
  key = cache_key('rulesets', 'get', id: id)
  with_cache(key, resource: :rulesets, cache: cache) do
    data = connection.execute(QueryBuilder.ruleset, { id: id })
    data['ruleset'] ? Ruleset.new(data['ruleset'], client: client) : nil
  end
end

#get_by_key(game_id:, key:, cache: nil) ⇒ Object 



54
55
56
57
58
59
60
 
# File 'lib/carddb/resources/rulesets.rb', line 54

def get_by_key(game_id:, key:, cache: nil)
  cache_key_value = cache_key('rulesets', 'get_by_key', game_id: game_id, key: key)
  with_cache(cache_key_value, resource: :rulesets, cache: cache) do
    data = connection.execute(QueryBuilder.ruleset, { gameId: game_id, key: key })
    data['ruleset'] ? Ruleset.new(data['ruleset'], client: client) : nil
  end
end

#get_version(id, cache: nil) ⇒ Object 



79
80
81
82
83
84
85
 
# File 'lib/carddb/resources/rulesets.rb', line 79

def get_version(id, cache: nil)
  key = cache_key('rulesets', 'get_version', id: id)
  with_cache(key, resource: :rulesets, cache: cache) do
    data = connection.execute(QueryBuilder.ruleset_version, { id: id })
    data['rulesetVersion'] ? RulesetVersion.new(data['rulesetVersion'], client: client) : nil
  end
end

#import_draft_from_dataset_record(ruleset_id:, input:) ⇒ Object 



151
152
153
154
155
156
157
158
159
 
# File 'lib/carddb/resources/rulesets.rb', line 151

def import_draft_from_dataset_record(ruleset_id:, input:)
  config.require_secret_credential!('rulesets.import_draft_from_dataset_record')

  data = connection.execute(
    QueryBuilder.import_ruleset_version_draft_from_dataset_record,
    { rulesetId: ruleset_id, input: input }
  )
  RulesetVersion.new(data['rulesetVersionDraftImportFromDatasetRecord'], client: client)
end

#list(game_id:, include_archived: nil, first: nil, after: nil, cache: nil) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/carddb/resources/rulesets.rb', line 7

def list(game_id:, include_archived: nil, first: nil, after: nil, cache: nil)
  query = QueryBuilder.rulesets(
    game_id: game_id,
    include_archived: include_archived,
    first: first,
    after: after
  )
  variables = build_variables(gameId: game_id, includeArchived: include_archived, first: first, after: after)
  key = cache_key('rulesets', 'list', **variables)

  data = with_cache(key, resource: :rulesets, cache: cache) do
    connection.execute(query, variables)
  end

  Collection.new(
    data['rulesets'],
    item_class: Ruleset,
    next_page_loader: ->(cursor) { list(game_id: game_id, include_archived: include_archived, first: first, after: cursor, cache: cache) },
    client: client
  )
end

#list_public(game_id:, first: nil, after: nil, cache: nil) ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/carddb/resources/rulesets.rb', line 29

def list_public(game_id:, first: nil, after: nil, cache: nil)
  query = QueryBuilder.public_rulesets(game_id: game_id, first: first, after: after)
  variables = build_variables(gameId: game_id, first: first, after: after)
  key = cache_key('rulesets', 'list_public', **variables)

  data = with_cache(key, resource: :rulesets, cache: cache) do
    connection.execute(query, variables)
  end

  Collection.new(
    data['publicRulesets'],
    item_class: Ruleset,
    next_page_loader: ->(cursor) { list_public(game_id: game_id, first: first, after: cursor, cache: cache) },
    client: client
  )
end

#preview_import(ruleset_id:, input:) ⇒ Object 



107
108
109
110
111
112
113
 
# File 'lib/carddb/resources/rulesets.rb', line 107

def preview_import(ruleset_id:, input:)
  data = connection.execute(
    QueryBuilder.ruleset_version_draft_import_preview,
    { rulesetId: ruleset_id, input: input }
  )
  RulesetVersionDraftImportPreview.new(data['rulesetVersionDraftImportPreview'], client: client)
end

#publish_version(id:, input: nil) ⇒ Object 



168
169
170
171
172
173
174
 
# File 'lib/carddb/resources/rulesets.rb', line 168

def publish_version(id:, input: nil)
  config.require_secret_credential!('rulesets.publish_version')

  variables = input.nil? ? { id: id } : { id: id, input: input }
  data = connection.execute(QueryBuilder.publish_ruleset_version, variables)
  RulesetVersion.new(data['rulesetVersionPublish'], client: client)
end

#update(id:, input:) ⇒ Object 



137
138
139
140
141
142
 
# File 'lib/carddb/resources/rulesets.rb', line 137

def update(id:, input:)
  config.require_secret_credential!('rulesets.update')

  data = connection.execute(QueryBuilder.update_ruleset, { id: id, input: input })
  Ruleset.new(data['rulesetUpdate'], client: client)
end

#update_draft(id:, input:) ⇒ Object 



161
162
163
164
165
166
 
# File 'lib/carddb/resources/rulesets.rb', line 161

def update_draft(id:, input:)
  config.require_secret_credential!('rulesets.update_draft')

  data = connection.execute(QueryBuilder.update_ruleset_version_draft, { id: id, input: input })
  RulesetVersion.new(data['rulesetVersionDraftUpdate'], client: client)
end

#validation_impact(ruleset_version_id:, first: nil, scope: nil, cache: nil) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/carddb/resources/rulesets.rb', line 115

def validation_impact(ruleset_version_id:, first: nil, scope: nil, cache: nil)
  query = QueryBuilder.ruleset_validation_impact(
    ruleset_version_id: ruleset_version_id,
    first: first,
    scope: scope
  )
  variables = build_variables(rulesetVersionId: ruleset_version_id, first: first, scope: scope)
  key = cache_key('rulesets', 'validation_impact', **variables)

  with_cache(key, resource: :rulesets, cache: cache) do
    data = connection.execute(query, variables)
    RulesetValidationImpact.new(data['rulesetValidationImpact'], client: client)
  end
end

#validation_rules(game_id:, ruleset_key:, ruleset_version_id: nil, cache: nil) ⇒ Object 



87
88
89
90
91
92
93
94
95
 
# File 'lib/carddb/resources/rulesets.rb', line 87

def validation_rules(game_id:, ruleset_key:, ruleset_version_id: nil, cache: nil)
  variables = build_variables(gameId: game_id, rulesetKey: ruleset_key, rulesetVersionId: ruleset_version_id)
  key = cache_key('rulesets', 'validation_rules', **variables)

  with_cache(key, resource: :rulesets, cache: cache) do
    data = connection.execute(QueryBuilder.ruleset_validation_rules, variables)
    data['rulesetValidationRules']
  end
end

#versions(ruleset_id:, status: nil, first: nil, after: nil, cache: nil) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/carddb/resources/rulesets.rb', line 62

def versions(ruleset_id:, status: nil, first: nil, after: nil, cache: nil)
  query = QueryBuilder.ruleset_versions(ruleset_id: ruleset_id, status: status, first: first, after: after)
  variables = build_variables(rulesetId: ruleset_id, status: status, first: first, after: after)
  key = cache_key('rulesets', 'versions', **variables)

  data = with_cache(key, resource: :rulesets, cache: cache) do
    connection.execute(query, variables)
  end

  Collection.new(
    data['rulesetVersions'],
    item_class: RulesetVersion,
    next_page_loader: ->(cursor) { versions(ruleset_id: ruleset_id, status: status, first: first, after: cursor, cache: cache) },
    client: client
  )
end