Class: FilteredParameter

Inherits:
Object
  • Object
show all
Defined in:
app/models/filtered_parameter.rb

Constant Summary

TRUE_PARAMETER_VALUES = 
[true, 1, '1', 't', 'T', 'true', 'TRUE', 'yes','YES'].to_set
FALSE_PARAMETER_VALUES = 
[false, 0, '0', 'f', 'F', 'false', 'FALSE','no','NO'].to_set
ALLOWED_GDATA_ALT_TYPES =

per gdata specification

['atom','rss','json','json-in-script','atom-in-script','rss-in-script']
ALLOWED_CONTENT_TYPES =

content types

['articles','faqs','news']
RECOGNIZED_PARAMETERS =

recognized names and types

{}

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (FilteredParameter) initialize(name, providedvalue, providedoptions = {})

A new instance of FilteredParameter



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'app/models/filtered_parameter.rb', line 88

def initialize(name, providedvalue, providedoptions = {})
  @options = providedoptions.dup
  @name = name
  @providedvalue = providedvalue
  @required = @options.delete(:required) || false  # TODO: handle required situation? or caller handles?
  @datatype = @options.delete(:datatype)
  @default = @options.delete(:default)
  
  # datatype handling
  if(@datatype.nil? or @datatype == :auto)
    if(RECOGNIZED_PARAMETERS[name].blank?)
      @datatype = nil
    else
      if(RECOGNIZED_PARAMETERS[name].is_a?(Symbol))
        @datatype = RECOGNIZED_PARAMETERS[name]
      elsif(RECOGNIZED_PARAMETERS[name].is_a?(Hash))
        @datatype = RECOGNIZED_PARAMETERS[name][:datatype]
        if(@default.nil? and !(RECOGNIZED_PARAMETERS[name][:default].nil?))
          @default = RECOGNIZED_PARAMETERS[name][:default]
        else
          @default = @default
        end
      else
        @datatype = nil
      end
    end      
  end
end

Instance Attribute Details

- (Object) datatype (readonly)

end: TODO: review



86
87
88
 
# File 'app/models/filtered_parameter.rb', line 86

def datatype
  @datatype
end

- (Object) default (readonly)

end: TODO: review



86
87
88
 
# File 'app/models/filtered_parameter.rb', line 86

def default
  @default
end

- (Object) name (readonly)

end: TODO: review



86
87
88
 
# File 'app/models/filtered_parameter.rb', line 86

def name
  @name
end

- (Object) options (readonly)

end: TODO: review



86
87
88
 
# File 'app/models/filtered_parameter.rb', line 86

def options
  @options
end

- (Object) providedvalue (readonly)

end: TODO: review



86
87
88
 
# File 'app/models/filtered_parameter.rb', line 86

def providedvalue
  @providedvalue
end

- (Object) required (readonly)

end: TODO: review



86
87
88
 
# File 'app/models/filtered_parameter.rb', line 86

def required
  @required
end

Class Method Details

+ (Object) value_to_boolean(value)

convert something to a boolean



298
299
300
301
302
303
304
 
# File 'app/models/filtered_parameter.rb', line 298

def value_to_boolean(value)
  if value.is_a?(String) && value.blank?
    nil
  else
    TRUE_PARAMETER_VALUES.include?(value)
  end
end

Instance Method Details

- (Object) filter_content_types(value) 



256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'app/models/filtered_parameter.rb', line 256

def filter_content_types(value)
   returnarray = []
   if(value.blank?)
      return nil
   else
      list = value.split(Regexp.new(/\s*,\s*/)).collect{|item| item.strip}
      list.each do |content_type|
         if(ALLOWED_CONTENT_TYPES.include?(content_type))
            returnarray << content_type
         end
      end
      if returnarray.blank?
         return nil
      end
   end
   return returnarray.compact.uniq
end

- (Object) filter_order(value) 



212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'app/models/filtered_parameter.rb', line 212

def filter_order(value)
  defaultcolumns = @options[:defaultcolumns] || nil
  defaultdirection = @options[:defaultdirection] || 'ASC'
  (returncolumns,tmpdirection) = value.split(' ')
  
  if(returncolumns.blank?)
    if(defaultcolumns.nil?) 
      return nil
    else
      returncolumns = defaultcolumns
    end
  end
  
  if(tmpdirection.blank?)
    if(defaultdirection.nil?)
      return nil
    else
      tmpdirection = defaultdirection
    end
  end
  
  # sanitycheck direction
  if(['d','descending','desc'].include?(tmpdirection.downcase))
    returndirection = 'DESC'
  else
    returndirection = defaultdirection
  end
  
  return "#{returncolumns} #{returndirection}"
end

- (Object) filter_tqx(value) 



243
244
245
246
247
248
249
250
251
252
253
254
 
# File 'app/models/filtered_parameter.rb', line 243

def filter_tqx(value)
  if(value.nil?)
    return {}
  else
    returnhash = {}
    value.split(';').each do |keyval|
      key,value = keyval.split(':')
      returnhash[:key] = value
    end
    return returnhash
  end
end

- (Object) filtered

Casts value (which is a String coming from the parameters) to an appropriate instance.



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'app/models/filtered_parameter.rb', line 123

def filtered
  value = self.unfiltered
  return nil if value.nil?
  case datatype
  when :method
    if(self.class.method_defined?("filter_#{name}"))
      self.send("filter_#{name}",value)
    else
      nil # TODO: raise error?
    end
  when :string      
    value
  when :integer     
    value.to_i rescue value ? 1 : 0
  when :float       
    value.to_f
  when :datetime
    begin    
      Time.zone.parse(value) 
    rescue 
      nil # TODO: raise invalid error
    end 
  when :date
    if(value.is_a?(Date))
      return value
    else
      begin        
        Time.zone.parse(value).to_date 
      rescue 
        nil # TODO: raise invalid error
      end
    end
  when :boolean     
    self.class.value_to_boolean(value)
  when :serialized
    begin  
      YAML::load(Base64.decode64(value))
    rescue 
      nil # TODO: raise invalid error
    end
  when :community   
    Community.find_by_id_or_name_or_shortname(value)
  when :location    
    Location.find_by_id(value)
  when :county      
    County.find_by_id(value)
  when :position    
    Position.find_by_id(value)
  when :user        
    User.find_by_email_or_extensionid_or_id(value)
  when :account        
    Account.find_by_email_or_extensionid_or_id(value,false)
  when :category    
    Category.find_by_name_or_id(value)
  when :activity_application 
    ActivityApplication.find_by_id_or_shortname(value)
  when :activity
    if(activitycodes = Activity.activity_to_codes(value))
      return value
    else
      return nil # TODO: raise invalid error
    end
  when :activitygroup
    if(activitytypes = Activity.activitygroup_to_types(value))
      return value
    else
      return nil # TODO: raise invalid error
    end
  when :gdata_alt
    if(ALLOWED_GDATA_ALT_TYPES.include?(value))
      return value
    else
      return nil # TODO: raise invalid error
    end
  when :apikey
    ApiKey.find_by_keyvalue(value)
  when :taglist
     return Tag.castlist_to_array(value.gsub('|',','),true,false)
  when :content_tag
     return Tag.content_tags.find_by_name(value.downcase.gsub('_',' '))
  else
    nil # TODO: raise invalid datatype error
  end
end

- (Boolean) number?

Returns:

  • (Boolean) 


208
209
210
 
# File 'app/models/filtered_parameter.rb', line 208

def number?
  datatype == :integer || datatype == :float 
end

- (Object) taglist_operator

if datatype is a taglist return whether it included a | anywhere which we'll treat as “or” otherwise, treat it as an and?



279
280
281
282
283
284
285
286
287
288
289
 
# File 'app/models/filtered_parameter.rb', line 279

def taglist_operator
   if(@datatype == :taglist)
      if(self.unfiltered.include?('|'))
         return 'or'
      else
         return 'and'
      end
   else
      return nil
   end
end

- (Object) unfiltered 



117
118
119
120
 
# File 'app/models/filtered_parameter.rb', line 117

def unfiltered 
  return nil if(providedvalue.nil? and default.nil?)
  (providedvalue.nil? ? default : providedvalue)
end