X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=lib%2Fpeta%2Fitem.rb;h=e33702a16bb828d4dcc629153906183633a88114;hb=f522407ab18ef79c237ed4dfe2f3bbb590d1b42e;hp=25acd422969e9b30c7bba14dc5b989ef7a3b4d0c;hpb=c75552d8db3397821ffc4913bc9e465f6141b5c5;p=pettanr%2Fpettanr.git

diff --git a/lib/peta/item.rb b/lib/peta/item.rb
index 25acd422..e33702a1 100644
--- a/lib/peta/item.rb
+++ b/lib/peta/item.rb
@@ -1,24 +1,79 @@
 module Peta
   class Item < ActiveRecord::Base
     self.abstract_class = true
+    attr :boosters
+    
+    # Dynamic ClassMethods
+    
+    def self._dev?
+      Rails.env == "development"
+    end
+    
+    def self._skip_load?
+      if self._dev?
+        return true unless self.my_manifest
+        return true unless Manifest.manifest.items
+        return true unless Manifest.manifest.models
+      end
+      false
+    end
+    
+    def self.load_manifest
+      return nil if self._skip_load?
+      vc = self.my_manifest.valid_encode_columns
+      define_singleton_method("valid_encode_columns") do 
+        vc
+      end
+      cm = self.my_manifest.child_models
+      define_singleton_method("child_models") do
+        cm
+      end
+      cen = self.my_manifest.child_element_names
+      define_singleton_method("child_element_names") do
+        cen
+      end
+      # Instance Methods
+    end
+    
     # ClassMethods
     # class_name
-    # table_name
     
     before_validation :valid_encode
     
+    def self.my_peta
+      return nil unless Manifest.manifest.items
+      Manifest.manifest.items[self.item_name]
+    end
+    
+    def self.my_controller
+      return nil unless Manifest.manifest.controllers
+      Manifest.manifest.controllers[self.table_name]
+    end
+    
+    def self.my_manifest
+      return nil unless Manifest.manifest.models
+      Manifest.manifest.models[self.item_name]
+    end
+    
     def self.singular
       self.to_s
     end
     
     def self.plural
-      self.singular.pluralize
+      table_name = Manifest.manifest.pluralize self.item_name
+      table_name.camelize
     end
     
     def self.item_name
       self.singular.underscore
     end
     
+    # self.model_name
+    # => "PanelPicture"
+    
+    # self.table_name
+    # => "panel_picture"
+    
     def self.item?
       true
     end
@@ -27,24 +82,40 @@ module Peta
       false
     end
     
-    def self.path_name with_engine = false
-      self.plural.underscore
+    def self.element?
+      false
     end
     
-    def self.valid_encode_columns
-      []
+    def self.root?
+      false
     end
     
-    def self.visible_count_options
+    def self.parent_model
       nil
     end
     
-    def self.list_where
-      ''
+    def self.path_name with_engine = false
+      self.table_name
+    end
+    
+    def self.pickup_item_name
+      self.item_name
+    end
+    
+    def self.pickup_column_name
+      'id'
+    end
+    
+    def self.find_boost_name column_name
+      self.my_peta.find_boost_name column_name
     end
     
-    def self.list_order
-      ''
+    def self.extend_column? column_name
+      self.my_peta.extend_column? column_name
+    end
+    
+    def self.index_list_where list
+      nil
     end
     
     def self.list_opt
@@ -55,11 +126,12 @@ module Peta
       {}
     end
     
-    def self.show item_id, operators
+    def self.show item_id, operators = nil
       opt = {}
       opt.merge!(self.show_opt)
-      item = self.find(item_id, opt)
-      raise ActiveRecord::Forbidden unless item.visible?(operators)
+      item = self.find(item_id)
+      item.boosts 'read'
+      raise ActiveRecord::Forbidden if operators and item.visible?(operators) == false
       item
     end
     
@@ -71,15 +143,28 @@ module Peta
       {}
     end
     
-    def self.visible_count
-      self.count self.visible_count_options
+    def self.fold_extend_settings attr
+      self.my_peta.boost.each do |name, manifest|
+        my_settings = attr[manifest.settings_column_name]
+        if my_settings.is_a?(Hash)
+          attr[manifest.settings_column_name] = my_settings.to_json
+        end
+      end
     end
     
-    def self.visible_count_options
-      []
+    #InstanceMethods
+    
+    def my_manifest
+      self.class.my_manifest
     end
     
-    #InstanceMethods
+    def singular
+      self.class.singular
+    end
+    
+    def plural
+      self.class.plural
+    end
     
     def item_name
       self.class.item_name
@@ -93,32 +178,70 @@ module Peta
       self.class.table_name
     end
     
-    def extend_column
-      nil
+    def path_name with_engine = false
+      self.class.path_name(with_engine)
     end
     
-    def extend_item_name
-      self.extend_column ? self.attributes[self.extend_column] : self.item_name
+    def pickup_item_name
+      self.class.pickup_item_name
+    end
+    
+    def pickup_column_name
+      self.class.pickup_column_name
+    end
+    
+    def pickup_id
+      self.attributes[self.pickup_column_name]
+    end
+    
+    def form_template with_engine = false
+      self.path_name(with_engine) + '/form'
     end
     
     def form_name
-      self.extend_item_name
+      self.extend_column ? self.attributes[self.extend_column] : self.item_name
     end
     
     def valid_encode
       self.class.valid_encode_columns.each do |a|
         next if attributes[a] == nil
-        raise Pettanr::BadRequest unless attributes[a].valid_encoding?
+        raise Pettanr::BadRequest unless self.attributes[a].valid_encoding?
       end
     end
     
+    def boosts level
+      self.class.my_peta.boost.each do |boost_name, boost_manifest|
+        next if level == 'read' and boost_manifest.level == 'post'
+        self.boost boost_manifest
+      end
+    end
+    
+    def boost boost_manifest
+      @boosters ||= {}
+      @boosters[boost_manifest.name] ||= Locmare::Booster.new(boost_manifest, self)
+    end
+    
+    def boosters
+      @boosters ||= {}
+    end
+    
+    def extend_column? column_name
+      self.class.extend_column? column_name
+    end
+    
     def supply_default
+      self.boosters.each do |boost_name, booster|
+        booster.supply_default
+      end
     end
     
     def overwrite 
+      self.boosters.each do |boost_name, booster|
+        booster.overwrite
+      end
     end
     
-    def visible? operators
+    def user_visible? operators
       if Manifest.manifest.magic_numbers['run_mode'] == 0
         return false unless operators.guest?
       else
@@ -127,69 +250,151 @@ module Peta
       true
     end
     
-    def dom_id_item 
-      self.new_record? ? '0' : self.id.to_s
+    def visible? operators
+      return false unless self.user_visible? operators
+      true
     end
     
-    def tag_item_id c = nil
-      self.item_name + self.item_id + c.to_s
+    def permit_params params, default_permit_attributes = []
+      attrs = self.class.permit_attributes(default_permit_attributes)
+      params.require(self.item_name.to_sym).permit(attrs)
     end
     
-    def dom_id_item_field field_name
-      self.tag_item_id + field_name.to_s
+    def self.permit_attributes default_permit_attributes = []
+      attrs = self.my_manifest.attributes.keys
+      attrs.concat(default_permit_attributes)
+      attrs
     end
     
-    def path_name with_engine = false
-      self.class.path_name(with_engine)
+    def editize?
+      self.respond_to? :editor
     end
     
-    def form_template with_engine = false
-      self.path_name(with_engine) + '/form'
+    def dom_id
+      self.id.to_s
     end
     
-    def tag_item_attributes column = nil, opt = {}
-      {
-        :id => self.field_tag_id(column), :panel_id => self.tag_panel_id, 
-        :element_id => self.tag_element_id, :element_type => self.tag_element_type
-      }.merge(opt)
+    def dom_pool_type
+      self.new_record? ? 'stored' : 'new'
     end
     
-      def tag_new_index
+    def merge_dom_item_id attr, name = nil
+      if self.editize?
+        attr.merge({'id' => self.dom_item_id(name)})
+      else
+        attr
       end
-      
-    def field_tag_attributes column, no_attr, opt = {}
-      self.tag_attributes(column).merge(
-        {:column => column, :new_index => self.tag_new_index, :no_attr => no_attr}
-      ).merge(opt)
     end
     
-    #render element by body
-    def any_tag_attributes name = nil, opt = {}
-      r = self.tag_attributes(name)
-      r.merge!(
-        {:new_index => self.tag_new_index}
-      ) if self.new_index
-      r.merge(opt)
-    end
-    
-    def select_tag_attributes(selected, column, no_attr)
-      [
-        :last, :first, 
-        {:html => {:selected => selected}}, 
-        self.field_tag_attributes(column, no_attr)
-      ]
+    def tag_attributes name = nil, opt = {}
+      r = {
+        'data-pool_type' => self.dom_pool_type, 'data-id' => self.dom_id, 
+        'data-item_name' => self.item_name
+      }
+      r = self.merge_dom_item_id r, name
+      r.merge!(opt)
+      r
     end
     
     def tag_attr column = nil, opt = {}
       self.tag_attributes(column, opt).to_attr
     end
     
-    def field_tag_attr column, no_attr, opt = {}
-      self.field_tag_attributes(column, no_attr, opt).to_attr
+    def field_tag_attributes column_name, opt = {}
+      self.tag_attributes(column_name, opt).merge(
+        {'data-column_name' => column_name}
+      )
+    end
+    
+    def post_attribute_key
+      self.dom_id
+    end
+    
+    ##################################################################
+    # importer
+    ##################################################################
+    
+    def self.each_import data
+      data.each do |n, d|
+        yield n, d
+      end
+    end
+    
+    def self.import_system_picture attr
+      d = attr["text"]
+      return false if d.blank?
+      imager = PettanImager.load(Base64.decode64(d.to_s))
+      return false unless imager
+      sp = SystemPicture.store(imager)
+      return false unless sp
+      sp.id
+    end
+    
+    def self.replace_system_picture attr
+      attr.each do |name, value|
+        if value.is_a? Hash
+          r = if name.to_s =~ /_id$/
+            self.import_system_picture value
+          else
+            self.replace_system_picture value
+          end
+          return false unless r
+          attr[name] = r
+        end
+      end
+    end
+    
+    def self.modify_object(name, attr, key = 'name')
+      c = 'find_by_' + key.to_s
+      r = self.__send__ c, name
+      if r
+        r.attributes = attr
+      else
+        r = self.new attr
+        r[key] = name
+      end
+      r
+    end
+    
+    def self.import_list(attrs, &blk)
+      res = []
+      self.transaction do
+        attrs.each do |name, item|
+          m = blk.call(name, item)
+          res.push(m) unless m.valid?
+        end
+        raise ActiveRecord::Rollback unless res.empty?
+      end
+      res
+    end
+    
+    def self.import_text(text, &blk)
+      attrs = JSON.parse(text)
+      self.import_list attrs, &blk
+    end
+    
+    def self.import_file(filename, &blk)
+      text = File.open(filename, 'r').read
+      self.import_text text, &blk
     end
     
-    def any_tag_attr name = nil, opt = {}
-      self.any_tag_attributes(name, opt).to_attr
+    def self.import_url(url, &blk)
+      text = open(url).read
+      self.import_text text, &blk
+    end
+    
+    def self.import_urls(urls, &blk)
+      r = {}
+      urls.each do |url|
+        h = {}
+        begin
+          h[:validations] = self.import_url(url, &blk)
+        rescue
+          h[:exception] = {:location => $@, :message => $!}
+        end
+        r[url] = h
+      end
+      r
     end
     
   end