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