[pettanr/pettanr.git] / app / models / panel.rb

#コマ
class Panel < ActiveRecord::Base
  belongs_to :author
  has_many :scroll_panels
  has_many :sheet_panels
  has_many :panel_pictures, :dependent => :destroy
  has_many :speech_balloons, :dependent => :destroy
  has_many :ground_pictures, :dependent => :destroy
  has_many :ground_colors, :dependent => :destroy
  accepts_nested_attributes_for :panel_pictures, :allow_destroy => true
  accepts_nested_attributes_for :speech_balloons, :allow_destroy => true
  accepts_nested_attributes_for :ground_pictures, :allow_destroy => true
  accepts_nested_attributes_for :ground_colors, :allow_destroy => true

  validates :width, :presence => true, :numericality => true, :natural_number => true
  validates :height, :presence => true, :numericality => true, :natural_number => true
  validates :border, :presence => true, :numericality => {:greater_than_or_equal_to => 0}
  validates :author_id, :presence => true, :numericality => true, :existence => {:both => false}
  validates :publish, :presence => true, :numericality => true
  
  cattr_reader :singular, :plural
  @@singular = 'Panel'
  @@plural = 'Panels'
  def self.item_name
    self.singular.underscore
  end
  
  def item_name
    self.class.item_name
  end
  
  def self.path_name with_engine = false
    self.plural.underscore
  end
  
  def path_name 
    self.class.path_name
  end
  
  before_validation :valid_encode
  
  def valid_encode
    ['caption'].each do |a|
      next if attributes[a] == nil
      raise Pettanr::BadRequest unless attributes[a].valid_encoding?
    end
  end
  
  def self.each_element_class_names
    Pettanr::Application.manifest.system_resources.elements.each do |k, n|
      yield k
    end
  end
  
  def self.class_name_to_class k
    Object.const_get k
  end
  
  def self.each_element_classes
    self.each_element_class_names do |k|
      e = self.class_name_to_class k
      yield e
    end
  end
  
  def elements_by_class_name class_name
    self.__send__ class_name.tableize
  end
  
  def supply_default
    self.border = 2
    self.publish = 0
  end
  
  def overwrite au
    self.author_id = au.id
  end
  
  def own? roles
    roles = [roles] unless roles.respond_to?(:each)
    au = Panel.get_author_from_roles roles
    return false unless au
    self.author_id == au.id
  end
  
  def visible? roles
    if MagicNumber['run_mode'] == 0
      return false unless guest_role_check(roles)
    else
      return false unless reader_role_check(roles)
    end
    return true if self.own?(roles)
    return true if self.new_record?
    self.publish?
  end
  
  def usable? au
    visible? au
  end
  
  def publish?
    self.publish > 0
  end
  
  def tag_id c = nil
    'panel' + self.tag_panel_id + c.to_s
  end
  
  def tag_panel_id
    self.new_record? ? '0' : self.id.to_s
  end
  
  def field_tag_id f
    self.tag_id + f.to_s
  end
  
  def tag_attributes column = nil, opt = {}
    {
      :id => self.field_tag_id(column), :panel_id => self.tag_panel_id
    }.merge(opt)
  end
  
  def select_tag_attributes(selected, column, opt = {})
    [
      :last, :first, 
      {:html => {:selected => selected}}, 
      self.field_tag_attributes(column, opt)
    ]
  end
  
  def field_tag_attributes column, opt = {}
    self.tag_attributes(column).merge(
      {:column => column}
    ).merge(opt)
  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
  end
  
    def render_count
      @render_count ||= 1
    end
    
    def rendered
      @render_count = render_count + 1
    end
    
  def self.default_page_size
    25
  end
  
  def self.max_page_size
    100
  end
  
  def self.page prm = nil
    page = prm.to_i
    page = 1 if page < 1
    page
  end
  
  def self.page_size prm = self.default_page_size
    page_size = prm.to_i
    page_size = self.max_page_size if page_size > self.max_page_size
    page_size = self.default_page_size if page_size < 1
    page_size
  end
  
  def self.list_order
    'panels.updated_at desc'
  end
  
  def self.list_where
    'panels.publish > 0'
  end
  
  def self.mylist_where au
    ['panels.author_id = ?', au.id]
  end
  
  def self.himlist_where au
    ['panels.author_id = ? and panels.publish > 0', au.id]
  end
  
  def self.list page = 1, page_size = self.default_page_size
    Panel.where(self.list_where()).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
  end
  
  def self.mylist au, page = 1, page_size = Author.default_panel_page_size
    Panel.where(self.mylist_where(au)).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
  end
  
  def self.himlist au, page = 1, page_size = Author.default_panel_page_size
    Panel.where(self.himlist_where(au)).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
  end
  
  def self.list_paginate page = 1, page_size = self.default_page_size
    Kaminari.paginate_array(Array.new(Panel.where(self.list_where()).count, nil)).page(page).per(page_size)
  end
  
  def self.mylist_paginate au, page = 1, page_size = Author.default_panel_page_size
    Kaminari.paginate_array(Array.new(Panel.where(self.mylist_where(au)).count, nil)).page(page).per(page_size)
  end
  
  def self.himlist_paginate au, page = 1, page_size = Author.default_panel_page_size
    Kaminari.paginate_array(Array.new(Panel.where(self.himlist_where(au)).count, nil)).page(page).per(page_size)
  end
  
  def self.list_by_scroll scroll_id, roles, page = 1, page_size = self.default_page_size
    self.where(ScrollPanel.list_by_scroll_where(scroll_id)).includes(
      {:scroll_panels => {}}
    ).order('scroll_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
  end
  
  def self.list_by_sheet sheet_id, roles, page = 1, page_size = self.default_page_size
    self.where(SheetPanel.list_by_sheet_where(sheet_id)).includes(
      {:sheet_panels => {}}
    ).order('sheet_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
  end
  
  def self.list_by_speech_balloon_template speech_balloon_template_id, roles, page = 1, page_size = self.default_page_size
    self.where(SpeechBalloon.list_by_speech_balloon_template_where(speech_balloon_template_id)).includes(
      {:speech_balloons => {}}
    ).order('speech_balloons.updated_at desc').offset((page -1) * page_size).limit(page_size)
  end
  
  def self.list_by_author_where author_id
    ['panels.author_id = ?', author_id]
  end
  
  def self.list_by_author author_id, roles, page = 1, page_size = self.default_page_size
    self.where(self.list_by_author_where(author_id)).includes(self.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
  end
  
  def self.list_opt
    r = {
      :author => {}
    }
    self.each_element_classes do |e|
      r.merge!(e.list_opt_for_panel)
    end
    r
  end
  
  def self.show rid, roles
    opt = {}
    opt.merge!(Panel.show_opt)
    res = Panel.find(rid, opt)
    raise ActiveRecord::Forbidden unless res.visible?(roles)
    res
  end
  
  def self.edit rid, au
    opt = {}
    opt.merge!(Panel.show_opt)
    res = Panel.find(rid, opt)
    raise ActiveRecord::Forbidden unless res.own?(au)
    res
  end
  
  def self.show_opt
    r = {
      :author => {}
    }
    self.each_element_classes do |e|
      r.merge!(e.show_opt_for_panel)
    end
    {:include => r}
  end
  
  def parts_element
    r = []
    self.class.each_element_class_names do |k|
      r += (self.elements_by_class_name(k) || [])
    end
    r
  end
  
  def zorderd_elements
    res = []
    self.parts_element.each do |e|
      res[e.z-1] = e
    end
    res
  end
  
  def panel_elements
    res = []
    self.parts_element.each do |e|
      res[e.t] = e
    end
    res
  end
  
  def elements
    self.panel_elements.map {|e|
      #(-_-;)<... kore wa hidoi
      JSON.parse e.to_json({:include => e.class.json_opt_for_panel})
    }
  end
  
  def panel_elements_as_json
    self.to_json({:include => {:author => {}}, :methods => :elements})
  end
  
  def self.list_as_json_text ary
    '[' + ary.map {|i| i.panel_elements_as_json }.join(',') + ']'
  end
  
  def new_t
    self.panel_elements.size
  end
  
  def new_z
    self.panel_elements.size + 1
  end
  
  def scenario
    panel_elements.map { |e|
      e.scenario
    }.join
  end
  
  def plain_scenario
    panel_elements.map { |e|
      e.plain_scenario
    }.join
  end
  
  def licensed_pictures
    r = {}
    self.panel_elements.each do |elm|
      next unless elm.class.has_picture?
      r[elm.picture_id] = elm.picture unless r[elm.picture_id]
    end
    r
  end
  
  def self.visible_count
    Panel.count
  end
  
  def self.collect_element_value elements, name
    elements.map {|e|
      e.map {|o|
        if o['_destroy'] or o[:_destroy]
          nil
        else
          o[name]
        end
      }.compact
    }.flatten
  end
  
  def self.validate_serial ary, offset = 0
    i = offset
    ary.compact.sort.each do |n|
      break false unless n == i
      i += 1
    end
    ary.compact.size == i - offset
  end
  
  def self.validate_element_serial elements, name, offset = 0
    Panel.validate_serial(Panel.collect_element_value(elements, name), offset)
  end
  
  def self.validate_elements_serial c
    c.map {|conf|
      Panel.validate_element_serial(conf[:elements], conf[:name], conf[:offset]) ? nil : false
    }.compact.empty?
  end
  
  def validate_serial_list
    l = []
    self.class.each_element_class_names do |k|
      l << self.elements_by_class_name(k)
    end
    [
      {:elements => l, :name => :t, :offset => 0}, 
      {:elements => l, :name => :z, :offset => 1}
    ]
  end
  def validate_child
#    r1 = Panel.validate_elements_id validate_id_list
    Panel.validate_elements_serial validate_serial_list
  end
  
  def boost
    @new_element_index = 0
    self.panel_elements.each do |elm|
      if elm.new_record?
        elm.new_index = @new_element_index
        @new_element_index += 1
      end
    end
  end 
  
  def store attr, au
    if attr == false
      self.errors.add :base, I18n.t('errors.invalid_json')
      return false
    end
    self.attributes = attr
    self.overwrite au
    res = false
    Panel.transaction do
      self.panel_elements.each do |elm|
        elm.new_panel = self
        elm.boost
      end
#self.publish = nil
      res = self.save
      unless validate_child
        res = false
        self.errors.add :base, I18n.t('errors.invalid_t')
        raise ActiveRecord::Rollback
      end
    end
    res
  end
  
  def remove_element target, au
    ct = target.t
    cz = target.z
    panel_attributes = {}
    self.panel_elements.each do |elm|
      attr = elm.attributes
      if elm == target
        attr['_destroy'] = true
      end
      if elm.t > ct
        attr['t']  -= 1 
      end
      if elm.z > cz
        attr['z']  -= 1 
      end
      panel_attributes[elm.class.to_s.tableize + '_attributes'] ||= {}
      panel_attributes[elm.class.to_s.tableize + '_attributes'][elm.id] = attr
    end
    self.store(panel_attributes, au)
  end
  
  def destroy_with_elements
    res = false
    Panel.transaction do
      self.parts_element.each do |element|
        raise ActiveRecord::Rollback unless element.destroy
      end
      raise ActiveRecord::Rollback unless self.destroy
      res = true
    end
    res
  end
  
  def copy
    attr = self.copy_attributes
    Panel.each_element_class_names do |n|
      attr.merge! Panel.class_name_to_class(n).panelize(self.elements_by_class_name(n).map {|elm|  elm.copy_attributes})
    end
    attr
  end
  
  def copy_attributes
    r = self.attributes
    r.delete 'id'
    r.delete 'author_id'
    r.delete 'created_at'
    r.delete 'updated_at'
    r
  end
  
  def self.panelize panel
    attr = panel.attributes
    attr.delete 'id'
    attr
  end
  
  
=begin
  def self.validate_id ary, pid
    ary.map {|v|
      if pid
        (v == pid or v == nil) ? nil : false
      else
        v ? false : nil
      end
    }.compact.empty?
  end
  
  def self.validate_element_id elements, name, pid
    Panel.validate_id(Panel.collect_element_value(elements, name), pid)
  end
  
  def self.validate_elements_id c
    c.map {|conf|
      Panel.validate_element_id(conf[:elements], conf[:name], conf[:parent_id]) ? nil : false
    }.compact.empty?
  end
  
  def validate_id_list
    r = self.speech_balloons.map {|sb|
      {:elements => [sb.speeches, sb.balloons], :name => :speech_balloon_id, :parent_id => sb.id}
    }
    r.unshift({:elements => [self.panel_pictures, self.speech_balloons], :name => :panel_id, :parent_id => self.id})
    r
  end
=end
  
end