lib/peta/item.rb

   1 module Peta
   2   class Item < ActiveRecord::Base
   3     self.abstract_class = true
   4
   5     # Dynamic ClassMethods
   6
   7     def self._valid_encode_columns
   8       self.my_manifest.valid_encode_columns
   9     end
  10
  11     def self.load_manifest
  12       return nil unless self.my_manifest
  13       r = self._valid_encode_columns
  14       define_singleton_method("valid_encode_columns") do
  15         r
  16       end
  17     end
  18
  19     # ClassMethods
  20     # class_name
  21     # table_name
  22
  23     before_validation :valid_encode
  24
  25     def self.my_manifest
  26       Manifest.manifest.models[self.item_name]
  27     end
  28
  29     def self.singular
  30       self.to_s
  31     end
  32
  33     def self.plural
  34       self.singular.pluralize
  35     end
  36
  37     def self.item_name
  38       self.singular.underscore
  39     end
  40
  41     def self.item?
  42       true
  43     end
  44
  45     def self.content?
  46       false
  47     end
  48
  49     def self.path_name with_engine = false
  50       self.plural.underscore
  51     end
  52
  53     def self.visible_count_options
  54       nil
  55     end
  56
  57     def self.list_where
  58       ''
  59     end
  60
  61     def self.list_order
  62       ''
  63     end
  64
  65     def self.list_opt
  66       {}
  67     end
  68
  69     def self.list_json_opt
  70       {}
  71     end
  72
  73     def self.show item_id, operators
  74       opt = {}
  75       opt.merge!(self.show_opt)
  76       item = self.find(item_id, opt)
  77       raise ActiveRecord::Forbidden unless item.visible?(operators)
  78       item
  79     end
  80
  81     def self.show_opt
  82       {}
  83     end
  84
  85     def self.show_json_opt
  86       {}
  87     end
  88
  89     #InstanceMethods
  90
  91     def self.fold_extend_settings params
  92       speech_balloon_settings = params[:speech_balloon][:settings]
  93       if speech_balloon_settings.is_a?(Hash)
  94         params[:speech_balloon][:settings] = speech_balloon_settings.to_json
  95       end
  96       balloon_settings = params[:speech_balloon][:balloon_attributes][:settings]
  97       if balloon_settings.is_a?(Hash)
  98         params[:speech_balloon][:balloon_attributes][:settings] = balloon_settings.to_json
  99       end
 100       speech_settings = params[:speech_balloon][:speech_attributes][:settings]
 101       if speech_settings.is_a?(Hash)
 102         params[:speech_balloon][:speech_attributes][:settings] = speech_settings.to_json
 103       end
 104     end
 105
 106     def extend_engine_module
 107       self.extend self.speech_balloon_template.engine_speech_balloon_module
 108       self.elements.each do |element|
 109         element.extend_item
 110       end
 111     end
 112
 113     def item_name
 114       self.class.item_name
 115     end
 116
 117     def model_name
 118       self.item_name
 119     end
 120
 121     def table_name
 122       self.class.table_name
 123     end
 124
 125     def path_name with_engine = false
 126       self.class.path_name(with_engine)
 127     end
 128
 129     def form_template with_engine = false
 130       self.path_name(with_engine) + '/form'
 131     end
 132
 133     def extend_column
 134       nil
 135     end
 136
 137     def extend_item_name
 138       self.extend_column ? self.attributes[self.extend_column] : self.item_name
 139     end
 140
 141     def form_name
 142       self.extend_item_name
 143     end
 144
 145     def valid_encode
 146       self.class.valid_encode_columns.each do |a|
 147         next if attributes[a] == nil
 148         raise Pettanr::BadRequest unless attributes[a].valid_encoding?
 149       end
 150     end
 151
 152     def supply_default
 153     end
 154
 155     def overwrite
 156     end
 157
 158     def visible? operators
 159       if Manifest.manifest.magic_numbers['run_mode'] == 0
 160         return false unless operators.guest?
 161       else
 162         return false unless operators.resource_reader?
 163       end
 164       true
 165     end
 166
 167     def editor
 168       @editor
 169     end
 170
 171     def editor=(e)
 172       @editor = e
 173     end
 174
 175     def pool_id
 176       @pool_id || self.id
 177     end
 178
 179     def pool_id=(i)
 180       @pool_id = i
 181     end
 182
 183     def dom_id
 184       self.pool_id.to_s
 185     end
 186
 187     def dom_pool_type
 188       self.new_record? ? 'stored' : 'new'
 189     end
 190
 191     def dom_item_id name = nil
 192       r = [self.editor.eid, self.dom_pool_type, self.item_name, self.dom_id]
 193       r += name.to_s if column_name
 194       r.join '-'
 195     end
 196
 197     def tag_attributes name = nil, opt = {}
 198       r = {
 199         'data-pool_type' => self.dom_pool_type, 'data-id' => self.dom_id,
 200         'data-item_name' => self.item_name
 201       }
 202       r.merge!({'id' => self.dom_item_id(name)}) if self.editor
 203       r.merge!(opt)
 204       r
 205     end
 206
 207     def field_tag_attributes column_name, opt = {}
 208       self.tag_attributes(column_name, opt).merge(
 209         {'data-column_name' => column_name}
 210       )
 211     end
 212
 213   end
 214 end