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._extend_column_name
  12       self.my_manifest.extend_column_name
  13     end
  14
  15     def self.load_manifest
  16       return nil unless self.my_manifest
  17       r = self._valid_encode_columns
  18       define_singleton_method("valid_encode_columns") do
  19         r
  20       end
  21       define_singleton_method("parent_model") do |tree_name|
  22         self.my_manifest.tree[tree_name].parent_model
  23       end
  24       define_singleton_method("child_models") do  |tree_name|
  25         self.my_manifest.child_models tree_name
  26       end
  27       define_singleton_method("child_element_names") do  |tree_name|
  28         self.my_manifest.child_element_names tree_name
  29       end
  30       # Instance Methods
  31       n = self._extend_column_name
  32       define_singleton_method("extend_column_name") do
  33         n
  34       end
  35     end
  36
  37     # ClassMethods
  38     # class_name
  39     # table_name
  40
  41     before_validation :valid_encode
  42
  43     def self.my_manifest
  44       Manifest.manifest.models[self.item_name]
  45     end
  46
  47     def self.singular
  48       self.to_s
  49     end
  50
  51     def self.plural
  52       self.singular.pluralize
  53     end
  54
  55     def self.item_name
  56       self.singular.underscore
  57     end
  58
  59     def self.item?
  60       true
  61     end
  62
  63     def self.content?
  64       false
  65     end
  66
  67     def self.path_name with_engine = false
  68       self.plural.underscore
  69     end
  70
  71     def self.visible_count_options
  72       nil
  73     end
  74
  75     def self.list_where
  76       ''
  77     end
  78
  79     def self.list_order
  80       ''
  81     end
  82
  83     def self.list_opt
  84       {}
  85     end
  86
  87     def self.list_json_opt
  88       {}
  89     end
  90
  91     def self.show item_id, operators
  92       opt = {}
  93       opt.merge!(self.show_opt)
  94       item = self.find(item_id, opt)
  95       raise ActiveRecord::Forbidden unless item.visible?(operators)
  96       item
  97     end
  98
  99     def self.show_opt
 100       {}
 101     end
 102
 103     def self.show_json_opt
 104       {}
 105     end
 106
 107     #InstanceMethods
 108
 109     def item_name
 110       self.class.item_name
 111     end
 112
 113     def model_name
 114       self.item_name
 115     end
 116
 117     def table_name
 118       self.class.table_name
 119     end
 120
 121     def extend_column_name
 122       self.class.extend_column_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 form_name
 134       self.extend_column ? self.attributes[self.extend_column] : self.item_name
 135     end
 136
 137     def valid_encode
 138       self.class.valid_encode_columns.each do |a|
 139         next if attributes[a] == nil
 140         raise Pettanr::BadRequest unless attributes[a].valid_encoding?
 141       end
 142     end
 143
 144     def self.fold_extend_settings params
 145       speech_balloon_settings = params[:speech_balloon][:settings]
 146       if speech_balloon_settings.is_a?(Hash)
 147         params[:speech_balloon][:settings] = speech_balloon_settings.to_json
 148       end
 149       balloon_settings = params[:speech_balloon][:balloon_attributes][:settings]
 150       if balloon_settings.is_a?(Hash)
 151         params[:speech_balloon][:balloon_attributes][:settings] = balloon_settings.to_json
 152       end
 153       speech_settings = params[:speech_balloon][:speech_attributes][:settings]
 154       if speech_settings.is_a?(Hash)
 155         params[:speech_balloon][:speech_attributes][:settings] = speech_settings.to_json
 156       end
 157     end
 158
 159     def engine
 160       Object.const_get self.attributes[self.extend_column_name]
 161     end
 162
 163     def my_engine_resource
 164       Manifest.manifest.system_resources.engine_resources[self.table_name]
 165     end
 166
 167     def engine?
 168       return false unless self.my_engine_resource
 169       self.my_engine_resource.resource_items.include? self.attributes[self.extend_column_name]
 170     end
 171
 172     def boost
 173       return false unless self.engine?
 174       self.engine.boost self
 175       true
 176     end
 177
 178     def supply_default
 179     end
 180
 181     def overwrite
 182     end
 183
 184     def visible? operators
 185       if Manifest.manifest.magic_numbers['run_mode'] == 0
 186         return false unless operators.guest?
 187       else
 188         return false unless operators.resource_reader?
 189       end
 190       true
 191     end
 192
 193     def editize?
 194       self.respond_to? :editor
 195     end
 196
 197     def dom_id
 198       self.id.to_s
 199     end
 200
 201     def dom_pool_type
 202       self.new_record? ? 'stored' : 'new'
 203     end
 204
 205     def merge_dom_item_id attr, name = nil
 206       if self.editize?
 207         attr.merge({'id' => self.dom_item_id(name)})
 208       else
 209         attr
 210       end
 211     end
 212
 213     def tag_attributes name = nil, opt = {}
 214       r = {
 215         'data-pool_type' => self.dom_pool_type, 'data-id' => self.dom_id,
 216         'data-item_name' => self.item_name
 217       }
 218       r = self.merge_dom_item_id r, name
 219       r.merge!(opt)
 220       r
 221     end
 222
 223     def field_tag_attributes column_name, opt = {}
 224       self.tag_attributes(column_name, opt).merge(
 225         {'data-column_name' => column_name}
 226       )
 227     end
 228
 229   end
 230 end