Class: Bulk::Resource

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

Direct Known Subclasses

ApplicationResource

Constant Summary collapse

@@resources = 
[]

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(controller, options = {}) ⇒ Resource

Returns a new instance of Resource.



102
103
104
105
106
107
108
 
# File 'lib/bulk/resource.rb', line 102

def initialize(controller, options = {})
  @controller = controller
  @resource_name = options[:resource_name].to_s if options[:resource_name]

  # try to get klass to raise error early if something is not ok
  klass unless options[:abstract]
end

Class Attribute Details

.abstract ⇒ Object (readonly) Also known as: abstract?

Returns the value of attribute abstract.



14
15
16
 
# File 'lib/bulk/resource.rb', line 14

def abstract
  @abstract
end

.application_resource_class ⇒ Object 



32
33
34
35
 
# File 'lib/bulk/resource.rb', line 32

def application_resource_class
  @application_resource_class ||= "ApplicationResource"
  @application_resource_class.is_a?(Class) ? @application_resource_class : Object.const_get(@application_resource_class.to_sym)
end

Instance Attribute Details

#controller ⇒ Object (readonly)

Returns the value of attribute controller.



7
8
9
 
# File 'lib/bulk/resource.rb', line 7

def controller
  @controller
end

Class Method Details

.abstract! ⇒ Object 



51
52
53
54
 
# File 'lib/bulk/resource.rb', line 51

def abstract!
  @abstract = true
  @@resources = []
end

.inherited(base) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/bulk/resource.rb', line 37

def inherited(base)
  if base.name == application_resource_class.to_s
    base.abstract!
  elsif base.name =~ /(.*)Resource$/
    base.resource_name($1.underscore.pluralize)
  end
end

.resource_class(klass = nil) ⇒ Object 



17
18
19
20
 
# File 'lib/bulk/resource.rb', line 17

def resource_class(klass = nil)
  @resource_class = klass if klass
  @resource_class
end

.resource_name(name = nil) ⇒ Object 



22
23
24
25
 
# File 'lib/bulk/resource.rb', line 22

def resource_name(name = nil)
  @resource_name = name if name
  @resource_name
end

.resources(*resources) ⇒ Object 



27
28
29
30
 
# File 'lib/bulk/resource.rb', line 27

def resources(*resources)
  @@resources = resources unless resources.blank?
  @@resources
end

Instance Method Details

#as_json(hash) ⇒ Object 



187
188
189
 
# File 'lib/bulk/resource.rb', line 187

def as_json(hash)
  hash
end

#as_json_options(klass) ⇒ Object 



183
184
185
 
# File 'lib/bulk/resource.rb', line 183

def as_json_options(klass)
  {}
end

#create(hashes) ⇒ Object 



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/bulk/resource.rb', line 128

def create(hashes)
  collection = Collection.new
  ids = hashes.map { |r| r[:_local_id] }
  with_records_auth :create, collection, ids do
    hashes.each do |attrs|
      local_id = attrs.delete(:_local_id)
      record = klass.new(filter_params(attrs))
      record[:_local_id] = local_id
      yield record if block_given?
      with_record_auth :create, collection, local_id, record do
        record.save
        set_with_validity_check(collection, local_id, record)
      end
    end
  end
  collection
end

#delete(ids) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/bulk/resource.rb', line 164

def delete(ids)
  collection = Collection.new
  with_records_auth :delete, collection, ids do
    ids.each do |id|
      record = klass.where(:id => id).first
      yield record if block_given?
      with_record_auth :delete, collection, record.id, record do
        record.destroy
        set_with_validity_check(collection, record.id, record)
      end
    end
  end
  collection
end

#get(ids = 'all') ⇒ Object 



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/bulk/resource.rb', line 110

def get(ids = 'all')
  ids = ids.to_s == 'all' ? nil : ids
  collection = Collection.new
  with_records_auth :get, collection, ids do
    records = if block_given?
      yield ids
    else
      ids ? klass.where(:id => ids) : klass.all
    end
    records.each do |r|
      with_record_auth :get, collection, r.id, r do
        collection.set(r.id, r)
      end
    end
  end
  collection
end

#resource_name ⇒ Object 



179
180
181
 
# File 'lib/bulk/resource.rb', line 179

def resource_name
  @resource_name || self.class.resource_name
end

#update(hashes) ⇒ Object 



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/bulk/resource.rb', line 146

def update(hashes)
  collection = Collection.new
  ids = hashes.map { |r| r[:id] }
  with_records_auth :update, collection, ids do
    hashes.each do |attrs|
      attrs.delete(:_local_id)
      record = klass.where(:id => attrs[:id]).first
      record.attributes = filter_params(attrs)
      yield record if block_given?
      with_record_auth :update, collection, record.id, record do
        record.save
        set_with_validity_check(collection, record.id, record)
      end
    end
  end
  collection
end