class AutoForme::Models::Sequel

  1. lib/autoforme/models/sequel.rb
Superclass: Model

Sequel specific model class for AutoForme

Constants

S = ::Sequel  

Short reference to top level Sequel module, for easily calling methods

SUPPORTED_ASSOCIATION_TYPES = [:many_to_one, :one_to_one, :one_to_many, :many_to_many]  

What association types to recognize. Other association types are ignored.

Attributes

params_name [R]

The namespace for form parameter names for this model, needs to match the ones automatically used by Forme.

Public Class methods

new (*)

Make sure the forme plugin is loaded into the model.

[show source]
   # File lib/autoforme/models/sequel.rb
18 def initialize(*)
19   super
20   model.plugin :forme
21   @params_name = model.new.forme_namespace
22 end

Public Instance methods

all_rows_for (type, request)

Retrieve all matching rows for this model.

[show source]
    # File lib/autoforme/models/sequel.rb
128 def all_rows_for(type, request)
129   all_dataset_for(type, request).all
130 end
apply_associated_eager (type, request, ds)

On the browse/search results pages, in addition to eager loading based on the current model's eager loading config, also eager load based on the associated models config.

[show source]
    # File lib/autoforme/models/sequel.rb
203 def apply_associated_eager(type, request, ds)
204   columns_for(type, request).each do |col|
205     if association?(col)
206       if model = associated_model_class(col)
207         eager = model.eager_for(:association, request) || model.eager_graph_for(:association, request)
208         ds = ds.eager(col=>eager)
209       else
210         ds = ds.eager(col)
211       end
212     end
213   end
214   ds
215 end
apply_dataset_options (type, request, ds)

Apply the model's filter, eager, and order to the given dataset

[show source]
    # File lib/autoforme/models/sequel.rb
231 def apply_dataset_options(type, request, ds)
232   ds = apply_filter(type, request, ds)
233   if order = order_for(type, request)
234     ds = ds.order(*order)
235   end
236   if eager = eager_for(type, request)
237     ds = ds.eager(eager)
238   end
239   if eager_graph = eager_graph_for(type, request)
240     ds = ds.eager_graph(eager_graph)
241   end
242   ds
243 end
apply_filter (type, request, ds)

Apply the model's filter to the given dataset

[show source]
    # File lib/autoforme/models/sequel.rb
223 def apply_filter(type, request, ds)
224   if filter = filter_for
225     ds = filter.call(ds, type, request)
226   end
227   ds
228 end
associated_class (assoc)

The associated class for the given association

[show source]
   # File lib/autoforme/models/sequel.rb
70 def associated_class(assoc)
71   model.association_reflection(assoc).associated_class
72 end
associated_mtm_objects (request, assoc, obj)

The currently associated many to many objects for the association

[show source]
    # File lib/autoforme/models/sequel.rb
305 def associated_mtm_objects(request, assoc, obj)
306   ds = obj.send("#{assoc}_dataset")
307   if assoc_class = associated_model_class(assoc)
308     ds = assoc_class.apply_dataset_options(:association, request, ds)
309   end
310   ds
311 end
associated_new_column_values (obj, assoc)

An array of pairs mapping foreign keys in associated class to primary key value of current object

[show source]
   # File lib/autoforme/models/sequel.rb
96 def associated_new_column_values(obj, assoc)
97   ref = model.association_reflection(assoc)
98   ref[:keys].zip(ref[:primary_keys].map{|k| obj.send(k)})
99 end
association? (column)

Whether the column represents an association.

[show source]
   # File lib/autoforme/models/sequel.rb
60 def association?(column)
61   case column
62   when String
63     model.associations.map(&:to_s).include?(column)
64   else
65     model.association_reflection(column)
66   end
67 end
association_autocomplete? (assoc, request)

Whether to autocomplete for the given association.

[show source]
    # File lib/autoforme/models/sequel.rb
246 def association_autocomplete?(assoc, request)
247   (c = associated_model_class(assoc)) && c.autocomplete_options_for(:association, request)
248 end
association_key (assoc)

The foreign key column for the given many to one association.

[show source]
   # File lib/autoforme/models/sequel.rb
90 def association_key(assoc)
91   model.association_reflection(assoc)[:key]
92 end
association_names (types=SUPPORTED_ASSOCIATION_TYPES)

Array of association name strings for given association types

[show source]
    # File lib/autoforme/models/sequel.rb
107 def association_names(types=SUPPORTED_ASSOCIATION_TYPES)
108   model.all_association_reflections.select{|r| types.include?(r[:type])}.map{|r| r[:name]}.sort_by(&:to_s)
109 end
association_type (assoc)

A short type for the association, either :one for a singular association, :new for an association where you can create new objects, or :edit for association where you can add/remove members from the association.

[show source]
   # File lib/autoforme/models/sequel.rb
78 def association_type(assoc)
79   case model.association_reflection(assoc)[:type]
80   when :many_to_one, :one_to_one
81     :one
82   when :one_to_many
83     :new
84   when :many_to_many
85     :edit
86   end
87 end
autocomplete (opts={})

Return array of autocompletion strings for the request. Options:

:type

Action type symbol

:request

AutoForme::Request instance

:association

Association symbol

:query

Query string submitted by the user

:exclude

Primary key value of current model, excluding already associated values (used when editing many to many associations)

[show source]
    # File lib/autoforme/models/sequel.rb
257 def autocomplete(opts={})
258   type, request, assoc, query, exclude = opts.values_at(:type, :request, :association, :query, :exclude)
259   if assoc
260     if exclude && association_type(assoc) == :edit
261       ref = model.association_reflection(assoc)
262       block = lambda do |ds|
263         ds.exclude(S.qualify(ref.associated_class.table_name, ref.right_primary_key)=>model.db.from(ref[:join_table]).where(ref[:left_key]=>exclude).select(ref[:right_key]))
264       end
265     end
266     return associated_model_class(assoc).autocomplete(opts.merge(:type=>:association, :association=>nil), &block)
267   end
268   opts = autocomplete_options_for(type, request)
269   callback_opts = {:type=>type, :request=>request, :query=>query}
270   ds = all_dataset_for(type, request)
271   ds = opts[:callback].call(ds, callback_opts) if opts[:callback]
272   display = opts[:display] || S.qualify(model.table_name, :name)
273   display = display.call(callback_opts) if display.respond_to?(:call)
274   limit = opts[:limit] || 10
275   limit = limit.call(callback_opts) if limit.respond_to?(:call)
276   opts[:filter] ||= lambda{|ds1, _| ds1.where(S.ilike(display, "%#{ds.escape_like(query)}%"))}
277   ds = opts[:filter].call(ds, callback_opts)
278   ds = ds.select(S.join([S.qualify(model.table_name, model.primary_key), display], ' - ').as(:v)).
279     limit(limit)
280   ds = yield ds if block_given?
281   ds.map(:v)
282 end
base_class ()

The base class for the underlying model, ::Sequel::Model.

[show source]
   # File lib/autoforme/models/sequel.rb
25 def base_class
26   S::Model
27 end
browse (type, request, opts={})

Return array of matching objects for the current page.

[show source]
    # File lib/autoforme/models/sequel.rb
181 def browse(type, request, opts={})
182   paginate(type, request, apply_associated_eager(:browse, request, all_dataset_for(type, request)), opts)
183 end
column_type (column)

The schema type for the column

[show source]
    # File lib/autoforme/models/sequel.rb
218 def column_type(column)
219   (sch = model.db_schema[column]) && sch[:type]
220 end
default_columns ()

Return the default columns for this model

[show source]
    # File lib/autoforme/models/sequel.rb
133 def default_columns
134   columns = model.columns - Array(model.primary_key)
135   model.all_association_reflections.each do |reflection|
136     next unless reflection[:type] == :many_to_one
137     if i = columns.index(reflection[:key])
138       columns[i] = reflection[:name]
139     end
140   end
141   columns.sort_by(&:to_s)
142 end
form_param_name (assoc)

The name of the form param for the given association.

[show source]
   # File lib/autoforme/models/sequel.rb
30 def form_param_name(assoc)
31   "#{params_name}[#{association_key(assoc)}]"
32 end
mtm_association_names ()

Array of many to many association name strings.

[show source]
    # File lib/autoforme/models/sequel.rb
102 def mtm_association_names
103   association_names([:many_to_many])
104 end
mtm_update (request, assoc, obj, add, remove)

Update the many to many association. add and remove should be arrays of primary key values of associated objects to add to the association.

[show source]
    # File lib/autoforme/models/sequel.rb
286 def mtm_update(request, assoc, obj, add, remove)
287   ref = model.association_reflection(assoc)
288   assoc_class = associated_model_class(assoc)
289   ret = nil
290   model.db.transaction do
291     [[add, ref.add_method], [remove, ref.remove_method]].each do |ids, meth|
292       if ids
293         ids.each do |id|
294           next if id.to_s.empty?
295           ret = assoc_class ? assoc_class.with_pk(:association, request, id) : obj.send(:_apply_association_options, ref, ref.associated_class.dataset.clone).with_pk!(id)
296           obj.send(meth, ret)
297         end
298       end
299     end
300   end
301   ret
302 end
paginate (type, request, ds, opts={})

Do very simple pagination, by selecting one more object than necessary, and noting if there is a next page by seeing if more objects are returned than the limit.

[show source]
    # File lib/autoforme/models/sequel.rb
187 def paginate(type, request, ds, opts={})
188   return ds.all if opts[:all_results]
189   limit = limit_for(type, request)
190   %r{\/(\d+)\z} =~ request.env['PATH_INFO']
191   offset = (($1||1).to_i - 1) * limit
192   objs = ds.limit(limit+1, (offset if offset > 0)).all
193   next_page = false
194   if objs.length > limit
195     next_page = true
196     objs.pop
197   end
198   [next_page, objs]
199 end
primary_key_value (obj)

The primary key value for the given object.

[show source]
    # File lib/autoforme/models/sequel.rb
118 def primary_key_value(obj)
119   obj.pk
120 end
save (obj)

Save the object, returning the object if successful, or nil if not.

[show source]
    # File lib/autoforme/models/sequel.rb
112 def save(obj)
113   obj.raise_on_save_failure = false
114   obj.save
115 end
search_results (type, request, opts={})

Returning array of matching objects for the current search page using the given parameters.

[show source]
    # File lib/autoforme/models/sequel.rb
157 def search_results(type, request, opts={})
158   params = request.params
159   ds = apply_associated_eager(:search, request, all_dataset_for(type, request))
160   columns_for(:search_form, request).each do |c|
161     if (v = params[c.to_s]) && !v.empty?
162       if association?(c)
163         ref = model.association_reflection(c)
164         ads = ref.associated_dataset
165         if model_class = associated_model_class(c)
166           ads = model_class.apply_filter(:association, request, ads)
167         end
168         primary_key = S.qualify(ref.associated_class.table_name, ref.primary_key)
169         ds = ds.where(S.qualify(model.table_name, ref[:key])=>ads.where(primary_key=>v).select(primary_key))
170       elsif column_type(c) == :string
171         ds = ds.where(S.ilike(S.qualify(model.table_name, c), "%#{ds.escape_like(v.to_s)}%"))
172       else
173         ds = ds.where(S.qualify(model.table_name, c)=>model.db.typecast_value(column_type(c), v))
174       end
175     end
176   end
177   paginate(type, request, ds, opts)
178 end
session_value (column)

Add a filter restricting access to only rows where the column name matching the session value. Also add a before_create hook that sets the column value to the session value.

[show source]
    # File lib/autoforme/models/sequel.rb
147 def session_value(column)
148   filter do |ds, type, req|
149     ds.where(S.qualify(model.table_name, column)=>req.session[column])
150   end
151   before_create do |obj, req|
152     obj.send("#{column}=", req.session[column])
153   end
154 end
set_fields (obj, type, request, params)

Set the fields for the given action type to the object based on the request params.

[show source]
   # File lib/autoforme/models/sequel.rb
35 def set_fields(obj, type, request, params)
36   columns_for(type, request).each do |col|
37     column = col
38 
39     if association?(col)
40       ref = model.association_reflection(col)
41       ds = ref.associated_dataset
42       if model_class = associated_model_class(col)
43         ds = model_class.apply_filter(:association, request, ds)
44       end
45 
46       v = params[ref[:key].to_s]
47       v = nil if v.to_s.strip == ''
48       if v
49         v = ds.first!(S.qualify(ds.model.table_name, ref.primary_key)=>v)
50       end
51     else
52       v = params[col.to_s]
53     end
54 
55     obj.send("#{column}=", v)
56   end
57 end
unassociated_mtm_objects (request, assoc, obj)

All objects in the associated table that are not currently associated to the given object.

[show source]
    # File lib/autoforme/models/sequel.rb
314 def unassociated_mtm_objects(request, assoc, obj)
315   ref = model.association_reflection(assoc)
316   assoc_class = associated_model_class(assoc)
317   lambda do |ds|
318     subquery = model.db.from(ref[:join_table]).
319       select(ref.qualified_right_key).
320       where(ref.qualified_left_key=>obj.pk)
321     ds = ds.exclude(S.qualify(ref.associated_class.table_name, ref.associated_class.primary_key)=>subquery)
322     ds = assoc_class.apply_dataset_options(:association, request, ds) if assoc_class
323     ds
324   end
325 end
with_pk (type, request, pk)

Retrieve underlying model instance with matching primary key

[show source]
    # File lib/autoforme/models/sequel.rb
123 def with_pk(type, request, pk)
124   dataset_for(type, request).with_pk!(pk)
125 end