Merge branch 'master' into 3634-tab-state
[arvados.git] / apps / workbench / app / models / arvados_base.rb
1 class ArvadosBase < ActiveRecord::Base
2   self.abstract_class = true
3   attr_accessor :attribute_sortkey
4   attr_accessor :create_params
5
6   def self.arvados_api_client
7     ArvadosApiClient.new_or_current
8   end
9
10   def arvados_api_client
11     ArvadosApiClient.new_or_current
12   end
13
14   def self.uuid_infix_object_kind
15     @@uuid_infix_object_kind ||=
16       begin
17         infix_kind = {}
18         arvados_api_client.discovery[:schemas].each do |name, schema|
19           if schema[:uuidPrefix]
20             infix_kind[schema[:uuidPrefix]] =
21               'arvados#' + name.to_s.camelcase(:lower)
22           end
23         end
24
25         # Recognize obsolete types.
26         infix_kind.
27           merge('mxsvm' => 'arvados#pipelineTemplate', # Pipeline
28                 'uo14g' => 'arvados#pipelineInstance', # PipelineInvocation
29                 'ldvyl' => 'arvados#group') # Project
30       end
31   end
32
33   def initialize raw_params={}, create_params={}
34     super self.class.permit_attribute_params(raw_params)
35     @create_params = create_params
36     @attribute_sortkey ||= {
37       'id' => nil,
38       'name' => '000',
39       'owner_uuid' => '002',
40       'event_type' => '100',
41       'link_class' => '100',
42       'group_class' => '100',
43       'tail_uuid' => '101',
44       'head_uuid' => '102',
45       'object_uuid' => '102',
46       'summary' => '104',
47       'description' => '104',
48       'properties' => '150',
49       'info' => '150',
50       'created_at' => '200',
51       'modified_at' => '201',
52       'modified_by_user_uuid' => '202',
53       'modified_by_client_uuid' => '203',
54       'uuid' => '999',
55     }
56   end
57
58   def self.columns
59     return @columns if @columns.andand.any?
60     @columns = []
61     @attribute_info ||= {}
62     schema = arvados_api_client.discovery[:schemas][self.to_s.to_sym]
63     return @columns if schema.nil?
64     schema[:properties].each do |k, coldef|
65       case k
66       when :etag, :kind
67         attr_reader k
68       else
69         if coldef[:type] == coldef[:type].downcase
70           # boolean, integer, etc.
71           @columns << column(k, coldef[:type].to_sym)
72         else
73           # Hash, Array
74           @columns << column(k, :text)
75           serialize k, coldef[:type].constantize
76         end
77         @attribute_info[k] = coldef
78       end
79     end
80     @columns
81   end
82
83   def self.column(name, sql_type = nil, default = nil, null = true)
84     ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
85   end
86
87   def self.attribute_info
88     self.columns
89     @attribute_info
90   end
91
92   def self.find(uuid, opts={})
93     if uuid.class != String or uuid.length < 27 then
94       raise 'argument to find() must be a uuid string. Acceptable formats: warehouse locator or string with format xxxxx-xxxxx-xxxxxxxxxxxxxxx'
95     end
96
97     if self == ArvadosBase
98       # Determine type from uuid and defer to the appropriate subclass.
99       return resource_class_for_uuid(uuid).find(uuid, opts)
100     end
101
102     # Only do one lookup on the API side per {class, uuid, workbench
103     # request} unless {cache: false} is given via opts.
104     cache_key = "request_#{Thread.current.object_id}_#{self.to_s}_#{uuid}"
105     if opts[:cache] == false
106       Rails.cache.write cache_key, arvados_api_client.api(self, '/' + uuid)
107     end
108     hash = Rails.cache.fetch cache_key do
109       arvados_api_client.api(self, '/' + uuid)
110     end
111     new.private_reload(hash)
112   end
113
114   def self.find?(*args)
115     find(*args) rescue nil
116   end
117
118   def self.order(*args)
119     ArvadosResourceList.new(self).order(*args)
120   end
121
122   def self.filter(*args)
123     ArvadosResourceList.new(self).filter(*args)
124   end
125
126   def self.where(*args)
127     ArvadosResourceList.new(self).where(*args)
128   end
129
130   def self.limit(*args)
131     ArvadosResourceList.new(self).limit(*args)
132   end
133
134   def self.select(*args)
135     ArvadosResourceList.new(self).select(*args)
136   end
137
138   def self.eager(*args)
139     ArvadosResourceList.new(self).eager(*args)
140   end
141
142   def self.all(*args)
143     ArvadosResourceList.new(self).all(*args)
144   end
145
146   def self.permit_attribute_params raw_params
147     # strong_parameters does not provide security in Workbench: anyone
148     # who can get this far can just as well do a call directly to our
149     # database (Arvados) with the same credentials we use.
150     #
151     # The following permit! is necessary even with
152     # "ActionController::Parameters.permit_all_parameters = true",
153     # because permit_all does not permit nested attributes.
154     ActionController::Parameters.new(raw_params).permit!
155   end
156
157   def self.create raw_params={}, create_params={}
158     x = super(permit_attribute_params(raw_params))
159     x.create_params = create_params
160     x
161   end
162
163   def update_attributes raw_params={}
164     super(self.class.permit_attribute_params(raw_params))
165   end
166
167   def save
168     obdata = {}
169     self.class.columns.each do |col|
170       unless self.send(col.name.to_sym).nil? and !self.changed.include?(col.name)
171           obdata[col.name.to_sym] = self.send(col.name.to_sym)
172       end
173     end
174     obdata.delete :id
175     postdata = { self.class.to_s.underscore => obdata }
176     if etag
177       postdata['_method'] = 'PUT'
178       obdata.delete :uuid
179       resp = arvados_api_client.api(self.class, '/' + uuid, postdata)
180     else
181       postdata.merge!(@create_params) if @create_params
182       resp = arvados_api_client.api(self.class, '', postdata)
183     end
184     return false if !resp[:etag] || !resp[:uuid]
185
186     # set read-only non-database attributes
187     @etag = resp[:etag]
188     @kind = resp[:kind]
189
190     # attributes can be modified during "save" -- we should update our copies
191     resp.keys.each do |attr|
192       if self.respond_to? "#{attr}=".to_sym
193         self.send(attr.to_s + '=', resp[attr.to_sym])
194       end
195     end
196
197     @new_record = false
198
199     self
200   end
201
202   def save!
203     self.save or raise Exception.new("Save failed")
204   end
205
206   def destroy
207     if etag || uuid
208       postdata = { '_method' => 'DELETE' }
209       resp = arvados_api_client.api(self.class, '/' + uuid, postdata)
210       resp[:etag] && resp[:uuid] && resp
211     else
212       true
213     end
214   end
215
216   def links(*args)
217     o = {}
218     o.merge!(args.pop) if args[-1].is_a? Hash
219     o[:link_class] ||= args.shift
220     o[:name] ||= args.shift
221     o[:tail_uuid] = self.uuid
222     if all_links
223       return all_links.select do |m|
224         ok = true
225         o.each do |k,v|
226           if !v.nil?
227             test_v = m.send(k)
228             if (v.respond_to?(:uuid) ? v.uuid : v.to_s) != (test_v.respond_to?(:uuid) ? test_v.uuid : test_v.to_s)
229               ok = false
230             end
231           end
232         end
233         ok
234       end
235     end
236     @links = arvados_api_client.api Link, '', { _method: 'GET', where: o, eager: true }
237     @links = arvados_api_client.unpack_api_response(@links)
238   end
239
240   def all_links
241     return @all_links if @all_links
242     res = arvados_api_client.api Link, '', {
243       _method: 'GET',
244       where: {
245         tail_kind: self.kind,
246         tail_uuid: self.uuid
247       },
248       eager: true
249     }
250     @all_links = arvados_api_client.unpack_api_response(res)
251   end
252
253   def reload
254     private_reload(self.uuid)
255   end
256
257   def private_reload(uuid_or_hash)
258     raise "No such object" if !uuid_or_hash
259     if uuid_or_hash.is_a? Hash
260       hash = uuid_or_hash
261     else
262       hash = arvados_api_client.api(self.class, '/' + uuid_or_hash)
263     end
264     hash.each do |k,v|
265       if self.respond_to?(k.to_s + '=')
266         self.send(k.to_s + '=', v)
267       else
268         # When ArvadosApiClient#schema starts telling us what to expect
269         # in API responses (not just the server side database
270         # columns), this sort of awfulness can be avoided:
271         self.instance_variable_set('@' + k.to_s, v)
272         if !self.respond_to? k
273           singleton = class << self; self end
274           singleton.send :define_method, k, lambda { instance_variable_get('@' + k.to_s) }
275         end
276       end
277     end
278     @all_links = nil
279     @new_record = false
280     self
281   end
282
283   def to_param
284     uuid
285   end
286
287   def initialize_copy orig
288     super
289     forget_uuid!
290   end
291
292   def attributes_for_display
293     self.attributes.reject { |k,v|
294       attribute_sortkey.has_key?(k) and !attribute_sortkey[k]
295     }.sort_by { |k,v|
296       attribute_sortkey[k] or k
297     }
298   end
299
300   def class_for_display
301     self.class.to_s.underscore.humanize
302   end
303
304   def self.class_for_display
305     self.to_s.underscore.humanize
306   end
307
308   # Array of strings that are names of attributes that should be rendered as textile.
309   def textile_attributes
310     []
311   end
312
313   def self.creatable?
314     current_user
315   end
316
317   def self.goes_in_projects?
318     false
319   end
320
321   # can this class of object be copied into a project?
322   # override to false on indivudal model classes for which this should not be true
323   def self.copies_to_projects?
324     self.goes_in_projects?
325   end
326
327   def editable?
328     (current_user and current_user.is_active and
329      (current_user.is_admin or
330       current_user.uuid == self.owner_uuid or
331       new_record? or
332       (writable_by.include? current_user.uuid rescue false)))
333   end
334
335   def attribute_editable?(attr, ever=nil)
336     if %w(created_at modified_at modified_by_user_uuid modified_by_client_uuid updated_at).include? attr.to_s
337       false
338     elsif not (current_user.andand.is_active)
339       false
340     elsif attr == 'uuid'
341       current_user.is_admin
342     elsif ever
343       true
344     else
345       editable?
346     end
347   end
348
349   def self.resource_class_for_uuid(uuid, opts={})
350     if uuid.is_a? ArvadosBase
351       return uuid.class
352     end
353     unless uuid.is_a? String
354       return nil
355     end
356     if opts[:class].is_a? Class
357       return opts[:class]
358     end
359     if uuid.match /^[0-9a-f]{32}(\+[^,]+)*(,[0-9a-f]{32}(\+[^,]+)*)*$/
360       return Collection
361     end
362     resource_class = nil
363     uuid.match /^[0-9a-z]{5}-([0-9a-z]{5})-[0-9a-z]{15}$/ do |re|
364       resource_class ||= arvados_api_client.
365         kind_class(self.uuid_infix_object_kind[re[1]])
366     end
367     if opts[:referring_object] and
368         opts[:referring_attr] and
369         opts[:referring_attr].match /_uuid$/
370       resource_class ||= arvados_api_client.
371         kind_class(opts[:referring_object].
372                    attributes[opts[:referring_attr].
373                               sub(/_uuid$/, '_kind')])
374     end
375     resource_class
376   end
377
378   def resource_param_name
379     self.class.to_s.underscore
380   end
381
382   def friendly_link_name
383     (name if self.respond_to? :name) || default_name
384   end
385
386   def content_summary
387     self.class_for_display
388   end
389
390   def selection_label
391     friendly_link_name
392   end
393
394   def self.default_name
395     self.to_s.underscore.humanize
396   end
397
398   def controller
399     (self.class.to_s.pluralize + 'Controller').constantize
400   end
401
402   def controller_name
403     self.class.to_s.tableize
404   end
405
406   # Placeholder for name when name is missing or empty
407   def default_name
408     if self.respond_to? :name
409       "New #{class_for_display.downcase}"
410     else
411       uuid
412     end
413   end
414
415   def owner
416     ArvadosBase.find(owner_uuid) rescue nil
417   end
418
419   protected
420
421   def forget_uuid!
422     self.uuid = nil
423     @etag = nil
424     self
425   end
426
427   def self.current_user
428     Thread.current[:user] ||= User.current if Thread.current[:arvados_api_token]
429     Thread.current[:user]
430   end
431   def current_user
432     self.class.current_user
433   end
434 end