ezframe 0.0.4 → 0.4.0

data/lib/ezframe/column_type.rb

@@ -9,8 +9,6 @@ module Ezframe
       return nil unless key
       upper = Object.const_get("Ezframe")
       key_camel = "#{key}_type".to_camel
-      # puts "get_class: #{key_camel}"
-      # puts "const_get: #{upper.const_get(key_camel).inspect}"
       if upper.const_defined?(key_camel)
         return upper.const_get(key_camel)
       end
@@ -26,17 +24,22 @@ module Ezframe
 
     def initialize(attr = nil)
       @attribute = attr || {}
+      @value = @attribute[:default]
     end
 
     def key
-      @attribute[:key]
+      @attribute[:key].to_sym
     end
 
-    def label
-      return nil if @attribute[:hidden]
+    def label(opts = {})
+      return nil if @attribute[:hidden] && !opts[:force]
       @attribute[:label]
     end
 
+    def type
+      @attribute[:type]
+    end
+
     def value(_situation = nil)
       @value
     end
@@ -57,21 +60,23 @@ module Ezframe
       nil
     end
 
-    def form_html(opts = {})
-      form_h = form(opts)
-      return nil unless form_h
-      return Html.convert(form_h)
-    end
-
     def view(opts = {})
       return nil if no_view?
-      @value
+      if @attribute[:view_format]
+        return use_view_format(@attribute[:view_format], @value)
+      else
+        @value
+      end
     end
 
-    def validate
-      if !@value || @value.empty?
-        if @attribute[:must]
-          @error = "必須項目です。"
+    def normalize(val)
+      return val
+    end
+
+    def validate(val)
+      if !val || val.to_s.empty?
+        if @attribute[:required] == "true"
+          @error = "required"
           return @error
         end
       end  
@@ -83,120 +88,271 @@ module Ezframe
     end
 
     def no_view?
-      return (@attribute[:hidden] && !@attribute[:force])
+      return (@attribute[:hidden] || @attribute[:no_view]) && !@attribute[:force]
+    end
+
+    # 複数のinputを持っているか？
+    def multi_inputs?
+      nil
+    end
+
+    # フォーマットに従って表示する
+    def use_view_format(format_a, val)
+      return nil unless val
+      if format_a.is_a?(String)
+        return format_a % val
+      else
+        fmt_a = format_a.clone
+        pattern = fmt_a.shift
+        value_a = fmt_a.map {|key| val.send(key) }
+        return pattern % value_a
+      end
+    end
+
+    def make_error_box(name)
+      Ht.div(id: "error-box-#{name}", class: %w[error-box hide], child: "")
     end
   end
 
   class TextType < TypeBase
-    def normalize
-      return unless @value
-      @value = @value.to_s
-      @value.gsub!(/　/, " ")
-      @value.gsub!(/\s+/, " ")
-      @value.strip!
+    def normalize(val)
+      return nil unless val
+      val = val.dup.to_s
+      val.gsub!(/　/, " ")
+      # val.gsub!(/\s+/, " ")
+      val.strip!
+      return val
     end
 
-    def value=(v)
-      super(v)
-      normalize
+    def value=(val)
+      @value = normalize(val)
     end
 
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
-      h = { tag: "input", type: "text", name: @attribute[:key], key: @attribute[:key], label: @attribute[:label], value: @value || "" }
-      h[:size] = @attribute[:size] if @attribute[:size]
-      h
+      key = self.key
+      key ="#{key}#{opts[:key_suffix]}" if opts[:key_suffix]
+      h = Ht.input(type: "text", name: key, label: @attribute[:label], value: @value || "")
+      h[:class] = @attribute[:class] if @attribute[:class]
+      h[:after]  = make_error_box(key)
+      return h
     end
 
     def db_type
-      "text"
+      return "text"
+    end
+  end
+
+  class TextareaType < TextType
+    def value=(val)
+      @value = normalize(val)
+      @value = val
+    end
+
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      val = @value
+      key = self.key
+      key ="#{key}#{opts[:key_suffix]}" if opts[:key_suffix]
+      h = Ht.textarea(name: key, label: @attribute[:label], child: val)
+      h[:class] = @attribute[:class] if @attribute[:class]
+      h[:after] = make_error_box(key)
+      return h
     end
   end
 
   class IntType < TextType
     def view(opts = {})
       return nil if no_view? && !opts[:force]
-      return Util.add_comma(@value.to_i)
+      return nil unless @value
+      return nil if @attribute[:no_view_if_zero] && @value.to_i == 0
+      if @attribute[:view_format]
+        return use_view_format(@attribute[:view_format], @value)
+      else
+        if @attribute[:add_comma]
+          return @value.to_i.add_comma
+        else
+          return @value.to_s
+        end
+      end
+    end
+
+    def normalize(val)
+      if val.is_a?(String)
+        val = val.tr("０-９", "0-9").strip
+      end
+      return val
     end
 
     def value=(v)
+      if v.nil?
+        default = @attribute[:default]
+        if default
+          @value = default
+        else
+          @value = nil
+        end
+        return
+      end
+
       if v.nil?
         @value = nil
         return
       end
-      if v.is_a?(String)
-        v = v.tr("０-９", "0-9").strip
+      unless v.is_a?(Integer)  || v.is_a?(String)
+        EzLog.debug("value must integer or string: key=#{self.key}, #{v}: class=#{v.class}")
+        return
       end
+      v = normalize(v)
       @value = v.to_i
     end
 
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
-      { tag: "input", type: "number", key: @attribute[:key], label: @attribute[:label], value: @value || "" }
+      key = self.key
+      key ="#{key}#{opts[:key_suffix]}" if opts[:key_suffix]
+      h = Ht.input(type: "number", name: key, label: @attribute[:label], value: @value || "")
+      h[:class] = @attribute[:class] if @attribute[:class]
+      h[:after] = make_error_box(key)
+      return h
     end
 
-    def db_type
-      "int"
+    def validate(val)
+      return nil if !val || val.to_s.strip.empty?
+      unless /^\d+$/ =~ val.to_s
+        return :invalid_value
+      end
+      return nil
     end
 
-
+    def db_type
+      return "int"
+    end
   end
 
   class ForeignType < IntType
+    attr_accessor :db_data 
+
+    def target_table
+      table = @attribute[:table]
+      return table if table
+      return self.key
+    end
+
     def view(opts = {})
       return nil if no_view? && !opts[:force]
-      dataset = @parent.db.dataset[self.type.inner]
-      data = dataset.get(id: @value)
-      return data[@attribute[:view]]
+      colkey = @attribute[:view_column]
+      if @value && colkey
+        data_h = DB::Cache[target_table.to_sym]
+        data = data_h[@value.to_i]
+        return nil unless data
+        return data[colkey.to_sym]
+      end
+      return nil
     end
 
-    def form
-      return nil
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      view_key = @attribute[:menu_column] || @attribute[:view_column]
+      data_h = DB::Cache[target_table.to_sym]
+      menu_a = data_h.map do |id, data|
+        [ data[:id], data[view_key&.to_sym] ]
+      end
+      key = self.key
+      key ="#{key}#{opts[:key_suffix]}" if opts[:key_suffix]
+      return Ht.select(name: key, class: %w[browser-default], item: menu_a, value: @value, after: make_error_box(key))
     end
-  end
 
-  class IdType < IntType
-    def label
-      return nil if no_view?
-      return "ID"
+    def db_type
+      return "int"
+    end
+
+    def set_db_data
+      @db_data = {}
+      if @value
+        @db_data = DB::Cache[target_table.to_sym][@value]
+      end
     end
+  end
 
+  class IdType < IntType
     def form(opts = {})
       return nil
     end
   end
 
   class PasswordType < TextType
+    def initialize(attr = nil)
+      super(attr)
+      @attribute[:no_view] = true
+    end
+
+    def encrypt_value(val)
+      crypt = BCrypt::Password.create(val)
+      return crypt.to_s
+    end
+
+    def value_equal?(value_from_db, new_value)
+      crypt = BCrypt::Password.new(value_from_db)
+      return crypt == new_value
+    end
+
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
-      return { tag: "input", type: "password", label: @attribute[:label], value: @value || "" }
+      key = self.key
+      key ="#{key}#{opts[:key_suffix]}" if opts[:key_suffix]
+      h = Ht.input(type: "password", name: key, label: @attribute[:label], value: "")
+      h[:class] = @attribute[:class] if @attribute[:class]
+      h[:after] = make_error_box(key)
+      return  h
     end
 
     def db_value
-      return value
+      crypt = BCrypt::Password.create(@value)
+      return crypt.to_s
     end
   end
 
   class SelectType < TypeBase
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
-      # puts "selectType: #{@attribute[:items].inspect}"
-      return { tag: "select", key: @attribute[:key], label: @attribute[:label], items: @attribute[:items], value: @value }
+      @items ||= @attribute[:item]
+      h = Ht.select(class: %w[browser-default], name: self.key, label: @attribute[:label], item: @items, value: @value)
+      h[:class] = @attribute[:class] if @attribute[:class]
+      h[:after] = make_error_box(self.key)
+      return h
     end
 
     def db_type
       return "text"
     end
+
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
+      item = @attribute[:item]
+      # EzLog.debug("select.view: @value=#{@value}, #{@value.class}, item=#{item}, result=#{item[@value]}")
+      return nil unless @value
+      return item[@value.to_s.to_sym]
+    end
+
+    def validate(val)
+      return nil
+    end
   end
 
   class CheckboxType < TypeBase
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
-      return { tag: "checkbox", key: @attribute[:key], name: @attribute[:key], value: parent[:id].value, label: @attribute[:label] }
+      key = self.key
+      key ="#{key}#{opts[:key_suffix]}" if opts[:key_suffix]
+      h = Ht.checkbox(name: key, value: parent[:id].value, label: @attribute[:label])
+      h[:class] = @attribute[:class] if @attribute[:class]
+      h[:after] = make_error_box(key)
+      return h
     end
 
     def db_type
-      return "int"
+      return "text"
     end
   end
 
@@ -204,20 +360,23 @@ module Ezframe
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
       h = super
+      return nil unless h
       if h
-        #        h[:type] = 'date'
+        # h[:type] = 'date'
         h[:type] = "text"
-        h[:class] = "datepicker"
-        h[:value] = value || ""
+        h[:value] = @value || ""
+        h[:class] = [ "datepicker" ]
+        h[:class].push(@attribute[:class]) if @attribute[:class]
       end
       return h
     end
 
     def db_type
-      "date"
+      return "date"
     end
 
     def value
+      return nil if @value.nil? || (@value.is_a?(String) && @value.strip.empty?)
       if @value.is_a?(Date) || @value.is_a?(Time)
         return "%d-%02d-%02d" % [@value.year, @value.mon, @value.mday]
       end
@@ -226,7 +385,12 @@ module Ezframe
 
     def value=(v)
       if v.nil?
-        @value = nil
+        default = @attribute[:default]
+        if default
+          @value = default
+        else
+          @value = nil
+        end
         return
       end
       if v.is_a?(String)
@@ -235,21 +399,24 @@ module Ezframe
           return
         end
         y, m, d = v.split(/[\-\/]/)
-        # puts "date=#{v.inspect}"
         @value = Date.new(y.to_i, m.to_i, d.to_i)
         return
       end
       if v.is_a?(Date) || v.is_a?(Time)
         @value = v
       else
-        mylog "[WARN] illegal value for date type: #{v.inspect}"
+        EzLog.info "[WARN] illegal value for date type: #{v.inspect}"
       end
     end
 
     def view(opts = {})
       return nil if no_view? && !opts[:force]
       if @value.is_a?(Time) || @value.is_a?(Date)
-        return "#{@value.year}/#{@value.mon}/#{@value.mday}"
+        if @attribute[:view_format]
+          return use_view_format(@attribute[:view_format], @value)
+        else
+          return "%d-%02d-%02d" % [@value.year, @value.mon, @value.mday]
+        end
       else
         return @value
       end
@@ -257,31 +424,164 @@ module Ezframe
   end
 
   class TimeType < TextType
+    def db_value
+      return nil if @value.nil? || @value.strip.empty?
+      return @value
+    end
   end
 
-  class DatetimeType < DateType
+  class DatetimeType < TextType
+    def initialize(attr = nil)
+      super(attr)
+      # @attribute[:class] = "datettimepicker"  # for jquery datetimepicker
+      @attribute[:class] = "datetpicker"  
+    end
+
+    def value=(v)
+      if v.nil?
+        default = @attribute[:default]
+        if default
+          @value = default
+        else
+          @value = nil
+        end
+        return
+      end
+      if v.is_a?(String)
+        if v.strip.empty?
+          @value = nil
+          return
+        end
+        begin
+          @value = DateTime.parse(v)
+        rescue => e
+          EzLog.warn("date format error: #{self.key}=#{v}:#{e}")
+          @value = nil
+        end
+        return
+      end
+      if v.is_a?(Date) || v.is_a?(Time) || v.is_a?(DateTime)
+        @value = v
+      else
+        EzLog.info "[WARN] illegal value for date type: #{v.inspect}"
+      end
+    end
+
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
+      if @value.is_a?(Time) || @value.is_a?(Date)
+        if @attribute[:view_format]
+          return use_view_format(@attribute[:view_format], @value)
+        else
+          return "%d/%02d/%02d %02d:%02d:%02d"%[@value.year, @value.mon, @value.mday, @value.hour, @value.min, @value.sec]
+        end
+      else
+        return @value
+      end
+    end
+
+    def form(opts = {})
+      # EzLog.debug("DatetimeType: key=#{self.key}, opts=#{opts}")
+      return nil if no_edit? && !opts[:force]
+      h = super
+      return nil unless h
+      if h
+        h[:type] = "text"
+        h[:value] = @value || ""
+        h[:class] = [ "datepicker" ]
+        h[:class].push(@attribute[:class]) if @attribute[:class]
+      end
+      return h
+    end
+
     def db_type
       "timestamp"
     end
+
+    def value
+      return nil if @value.nil? || (@value.is_a?(String) && @value.strip.empty?)
+      return @value if @value.is_a?(Date) || @value.is_a?(Time)
+      return DateTime.parse(@value) if @value.is_a?(String)
+    end
   end
 
-  class BirthdayType < DateType
+  class BirthdayType < TextType
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
-      prefix = @attribute[:key]
       now = Time.now
       year_list = []
       110.times do |y|
         year = now.year - y - 10
-        year_list.push [year, "#{year}年 (#{Japanese.convert_wareki(year)})"]
+        year_list.push [year, "#{year}(#{Japanese.convert_wareki(year)})"]
       end
-      mon_list = (1..12).map { |m| [m, "#{m}月"] }
+      year_list.unshift([ 0, "(年)" ])
+
+      key = self.key
+      key ="#{key}#{opts[:key_suffix]}" if opts[:key_suffix]
+
+      year, mon, mday = parse_date(@value)
+      mon_list = (1..12).map { |m| [m, "#{m}"] }
       mon_list.unshift([0, "(月)"])
-      mday_list = (1..31).map { |d| [d, "#{d}日"] }
+      mday_list = (1..31).map { |d| [d, "#{d}"] }
       mday_list.unshift([0, "(日)"])
-      return [Ht.select(name: "#{prefix}_year", items: year_list),
-              Ht.select(name: "#{prefix}_mon", items: mon_list),
-              Ht.select(name: "#{prefix}_mday", items: mday_list)]
+      ezvalid = "target_key=#{key}:with=#multi-#{key}"
+      return  Ht.div(id: "multi-#{key}",
+        child: [ Ht.div([Ht.select(name: "#{key}_year", class: %w[browser-default multi_input], item: year_list, value: year, ezvalid: ezvalid),
+              Ht.small("年")]),
+              Ht.select(name: "#{key}_mon", class: %w[browser-default multi_input], item: mon_list, value: mon, ezvalid: ezvalid),
+              Ht.small("月"),
+              Ht.select(name: "#{key}_mday", class: %w[browser-default multi_input], item: mday_list, value: mday, ezvalid: ezvalid),
+              Ht.small("日"), 
+              make_error_box(key)])
+    end
+
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
+      return nil unless @value
+      year, mon, mday = parse_date(@value)
+      year_s = if year.to_i == 0 then "?" else "%d" % [year]; end
+      mon_s = if mon.to_i == 0 then "?" else "%2d" % [mon]; end
+      mday_s = if mday.to_i == 0 then "?" else "%2d" % [mday]; end
+      return "#{year_s}<small>年</small>#{mon_s}<small>月</small>#{mday_s}<small>日</small>"
+    end
+
+    def parse_date(date)
+      if date && date =~ /(\d+)\-(\d+)\-(\d+)/
+        return [ $1.to_i,$2.to_i,$3.to_i ]
+      end
+      return nil
+    end
+
+    def multi_inputs?
+      true
+    end
+
+    def form_to_value(form, target_key: nil)
+      key = target_key || self.key
+      y, m, d = form["#{key}_year".to_sym], form["#{key}_mon".to_sym], form["#{key}_mday".to_sym]
+      return "%d-%02d-%02d"%[y.to_i, m.to_i, d.to_i]
+    end
+
+    def validate(val)
+      return validate_date(val)
+    end
+
+    # 日付の検証
+    def validate_date(val)
+      if val.is_a?(String)
+        y,m,d = val.split("-")
+        if y.to_i == 0 || m.to_i == 0 || d.to_i == 0
+          return nil
+        end
+        tm = Time.mktime(y.to_i, m.to_i, d.to_i)
+      elsif val.is_a?(Time)
+        tm = val
+      end
+      if tm.mday != d.to_i
+        @error = :invalid_value
+        return @error
+      end
+      return nil
     end
   end
 
@@ -289,63 +589,103 @@ module Ezframe
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
       h = super
-      h[:type] = "email" if h
+      return nil unless h
+      h[:type] = "email"
+      h[:class] = @attribute[:class] if @attribute[:class]
       return h
     end
 
-    def normalize
-      return unless @value
-      @value = NKF.nkf('-w -Z4', @value)
+    def normalize(val)
+      return nil unless val
+      return NKF.nkf('-w -Z4', val)
     end
 
-    def validate
-      super
+    def validate(val)
+      super(val)
       return @error if @error
-      if email_format?
-        @error = "形式が正しくありません"
+      return nil if !val || val.strip.empty?
+      unless email_format?(val)
+        @error = :invalid_value
         return @error
       end
       return nil
     end
 
-    def email_format?
-      return nil unless @value
-      return @value =~ /^[a-zA-Z0-9.!\#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
+    def email_format?(val)
+      return val.to_s =~ /^[a-zA-Z0-9.!\#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
     end
   end
 
   class TelType < TextType
-    def validate
-      super
+    def normalize(val)
+      return nil unless val
+      val = super(val)
+      val = val.tr("０-９", "0-9")
+      # val = val.gsub(/\D+/, "")
+      return val
+    end
+
+    def validate(val)
+      super(val)
       return @error if @error
-      unless /^0\d{9,10}$/ =~ @value
-        @error = "形式が正しくありません"
+      return nil if !val || val.strip.empty?
+      unless /^0\d{9,10}$/ =~ val.to_s
+        @error = :invalid_value
         return @error
       end
+      return nil
     end
   end
 
+  class UrlType < TextType
+  end
+
   class JpnameType < TextType
   end
 
-  class JpnameKanaType < TextType
-    def normalize
-      return unless @value
-      super
-      @value.tr!("ァ-ン", "ぁ-ん")
+  class KatakanaType < TextType
+    def normalize(val)
+      val = super(val)
+      return val.tr("ァ-ン", "ぁ-ん")
     end
 
-    def validation
-      unless /^[ぁ-ん ]+$/ =~ @value
-        "ひらがなのみで入力してください。"
+    def validate(val)
+      super(val)
+      return @error if @error
+      return nil if !val || val.strip.empty?
+      unless /^[ぁ-ん ]+$/ =~ val.to_s
+        @error = :hiragana_only
+        return @error
+      end
+      return nil
+    end
+  end
+
+  class KatakanaType < TextType
+    def normalize(val)
+      return nil unless val
+      val = super(val)
+      return val.tr("ぁ-ん", "ァ-ン")
+    end
+
+    def validate(val)
+      super(val)
+      return @error if @error
+      return nil if !val || val.strip.empty?
+      unless /^[ァ-ン ]+$/ =~ val
+        @error = :katakana_only
+        return @error
       end
+      return nil
     end
   end
 
   class PrefectureType < SelectType
-    def initialize(attr)
+    attr_accessor :pref_h
+
+    def initialize(attr = nil)
       super(attr)
-      @pref_a = %w[選択してください 北海道 青森県 岩手県 宮城県 秋田県 山形県 福島県
+      @pref_a = %w[() 北海道 青森県 岩手県 宮城県 秋田県 山形県 福島県
                    茨城県 栃木県 群馬県 埼玉県 千葉県 東京都 神奈川県
                    新潟県 富山県 石川県 福井県 山梨県 長野県 岐阜県 静岡県 愛知県
                    三重県 滋賀県 京都府 大阪府 兵庫県 奈良県 和歌山県
@@ -359,11 +699,13 @@ module Ezframe
     def form(opts = {})
       return nil if no_edit? && !opts[:force]
       h = super
-      h[:items] = @pref_h
+      return nil unless h
+      h[:item] = @pref_h
       return h
     end
 
-    def view
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
       return @pref_h[@value.to_i]
     end
   end
@@ -376,8 +718,23 @@ module Ezframe
       return @value.to_s.gsub(/(\d{3})(\d{4})/) { "#{$1}-#{$2}" }
     end
 
-    def db_type
-      return "text"
+    def normalize(val)
+      val = super(val)
+      return nil if !val || val.strip.empty?
+      val = val.tr("０-９", "0-9")
+      return val
+    end
+
+    def validate(val)
+      super(val)
+      return @error if @error
+      return nil if !val || val.to_s.strip.empty?
+
+      unless /^\d{7}$/ =~ val.to_s
+        @error = :invalid_value
+        return @error
+      end
+      return nil
     end
   end
 end