ezframe 0.0.4 → 0.4.0

data/lib/ezframe/config.rb

@@ -3,23 +3,40 @@ module Ezframe
     class << self
       attr_accessor :value_h
 
+      def init(dir = "./config")
+        load_files(dir)
+      end
+
       def load_files(dir)
         unless @value_h
-          Dir["#{dir}/*.yml"].each do |file|
-            load_one_file(file)
+          load_dir(dir)
+          rack_env = ENV['RACK_ENV']
+          env_dir = "#{dir}/#{rack_env}"
+          if rack_env && File.directory?(env_dir)
+            load_dir(env_dir)
           end
         end
       end
 
+      def load_dir(dir)
+        Dir["#{dir}/*.yml"].each do |file|
+          load_one_file(file)
+        end
+      end
+
       def load_one_file(filename)
+        instr = File.open(filename, &:read)
+        if instr.index("\#{")
+          instr = Template.fill_in_text(instr)
+        end
         begin
-          yaml = YAML.load_file(filename)
-        rescue
-          mylog("YAML load error: #{filename}")
+          yaml = YAML.load(instr, symbolize_names: true)
+        rescue => e
+          EzLog.info("YAML load error: #{filename}:#{e}")
           return 
         end
         @value_h ||={}
-        @value_h.update(yaml.recursively_symbolize_keys) if yaml.length>0
+        @value_h.update(yaml) if yaml.length>0 # .recursively_symbolize_keys
       end
 
       def [](k)
@@ -31,6 +48,10 @@ module Ezframe
         @value_h[k]=v
       end
 
+      def delete(k)
+        @value_h.delete(k) if @value_h[k]
+      end
+
       def inspect
         @value_h.inspect
       end

data/lib/ezframe/controller.rb

@@ -1,60 +1,63 @@
 # frozen_string_literal: true
-
 module Ezframe
-  class Boot
+  class Controller
     class << self
+      def init
+        Config.init
+        ColumnSets.init
+        DB.init
+        Message.init
+        Auth.init if Config[:auth]
+      end
+
       def exec(request, response)
         @request = request
-        Config.load_files("./config")
-        Model.init
-        model = Model.get_clone
-        Auth.init_warden if defined?(Warden)
-        @request.env["model"] = model
+        page_instance, method, url_params, class_opts = Route::choose(request)
 
-        mylog("exec: path=#{request.path_info} params=#{request.params}")
-        klass, method = PageBase::decide_route(request.path_info)
-        unless klass
-          response.status = 404
-          response['Content-Type'] = 'text/html; charset=utf-8'
-          response.body = [ Html.convert(Ht.p("file not found")) ]
+        EzLog.debug("Controller.exec: path=#{request.path_info}, params=#{request.params}, class=#{page_instance.class}, method=#{method}, url_params=#{url_params}, class_opts=#{class_opts}")
+        if !page_instance || page_instance == 404
+          file_not_found(response)
           return
         end
-        method = "default" if !method || method=="undefined"
-        page = klass.new(request, model)
-        if request.post?
-          method_full_name = "public_#{method}_post"
-        else
-          method_full_name = "public_#{method}_page"
-        end
-        if page.auth
+        @request.env["url_params"] = url_params
+        opt_auth = class_opts[:auth]
+        @session = @request.env['rack.session']
+        if !@session[:user] && Config[:auth] && (!opt_auth || opt_auth != "disable")
+          EzLog.debug("authenticate!")
           warden.authenticate! 
+          EzLog.info "Controller.exec: warden.options = #{@request.env['warden.options']}"
         end
-        # request.env["rack.session"]["kamatest"]="usable"
-        # mylog "method: #{klass}.#{method_full_name}"
-        #mylog "rack.session.id=#{request.env['rack.session'].id}"
-        mylog "rack.session.keys=#{request.env['rack.session'].keys}"
-        #mylog "warden=#{request.env['warden'].inspect}"
-        mylog "klass=#{klass}, method=#{method_full_name}"
-        body = if page.respond_to?(method_full_name)
-                    page.send(method_full_name)
-                  else
-                    mylog "no such method: #{method_full_name}"
-                    page.public_default_page
-                  end
+        # session["in_controller"] = "set in controller"
+        EzLog.debug "rack.session.keys=#{@session.keys}" if @session
+        page_instance.set_request(@request)
+        body = page_instance.send(method)
+
+        # 戻り値によるレスポンス生成
         if body.is_a?(Hash) || body.is_a?(Array)
-          response.body = [ JSON.generate(body) ]
+          # EzLog.debug("Controller: body = #{body}")
+          json = JSON.generate(body)
+          response.body = [ json ]
           response['Content-Type'] = 'application/json; charset=utf-8'
         else
           response.body = [ body ]
           response['Content-Type'] = 'text/html; charset=utf-8'
         end
         response.status = 200
+        # EzLog.debug("Controller.exec: response.body=#{response.body}")
       end
 
-#      def file_not_found(response)
-#        response.body = ['path not found']
-#        response.status = 404
-#      end
+      def file_not_found(response)
+        response.status = 404
+        response['Content-Type'] = 'text/html; charset=utf-8'
+        template_file = ("#{Config[:template_dir]}/404.html")
+        # puts template_file
+        if File.exist?(template_file) 
+          body = File.read(template_file)
+        else
+          body = Html.convert(Ht.p("file not found"))
+        end
+        response.body = [ body ]
+      end
 
       def warden
         @request.env["warden"]

data/lib/ezframe/database.rb

@@ -1,62 +1,181 @@
 # frozen_string_literal: true
-require "logger"
-
 module Ezframe
-  class Database
-    attr_accessor :sequel
-
-    def initialize(dbfile = nil)
-      @dbfile = dbfile
-      connect
-    end  
-
-    def connect
-      @dbfile ||= ENV["EZFRAME_DB"] || Config[:database] || "sqlite://db/devel.sqlite"
-      puts "Database.connect: dbfile=#{@dbfile}"
-      @sequel = Sequel.connect(@dbfile, loggers: [Logger.new($stdout)])
-    end  
-
-    def exec(sql)
-      @sequel.run(sql)  
-    end  
-
-    def dataset(table_name)
-      @sequel[table_name.to_sym]  
-    end
-  
-    def create_table(table_name, dbtype_h)
-      %w[id created_at updated_at].each do |key|
-        dbtype_h.delete(key.to_sym)
-      end
-      # puts "create_table: #{table_name}"
-      if @dbfile.index("postgres")
-        @sequel.create_table(table_name) do 
-          serial :id
-          dbtype_h.each do |key, dbtype|
-            column(key, dbtype)
+  class DB
+    class << self
+      attr_accessor :sequel, :pool
+
+      def init(dbfile = nil, opts = {})
+        @dbfile = dbfile || ENV["EZFRAME_DB"] || Config[:database]
+        unless @dbfile
+          raise "database settings error: dbfile=#{Config[:database]}"
+        end
+        #if Config[:use_connection_pool] || opts[:use_connection_pool]
+          #@pool = Sequel::ConnectionPool.new(max_connections: 10) do
+          #  Sequel.connect(@dbfile, loggers: [EzLog])
+          #end
+        #else
+        connect(@dbfile)
+        #end
+      end
+
+      def connect(dbfile = nil)
+        dbfile ||= @dbfile
+        @sequel = Sequel.connect(dbfile, EzLogs: [EzLog])
+        return @sequel
+      end
+
+      def disconnect
+        @sequel.disconnect
+      end
+
+      def get_conn
+        if @pool
+          @pool.hold {|conn| return conn }
+        else
+          @sequel
+        end
+      end
+
+      def exec(sql, first: nil)
+        conn = get_conn
+        if first
+          return conn[sql].first
+        else
+          return conn[sql].all
+        end
+      end
+
+      def run(sql)
+        conn = get_conn
+        conn.run(sql)
+      end
+
+      def dataset(table_name)
+        @sequel[table_name.to_sym]
+      end
+
+      class JointHash < Hash
+        def initialize(default_table, values = {})
+          @default_table = default_table
+          self.update(values)
+        end
+
+        def []=(key, value)
+          super(key.to_s, value)
+        end
+
+        def [](key)
+          key = key.to_s
+          return fetch(key) if has_key?(key)
+          alt_key = "#{@default_table}.#{key}"
+          return fetch(alt_key) if has_key?(alt_key)
+          return nil
+        end
+      end
+
+      # テーブルを連結して、全てのデータを返す。
+      def get_join_table(structure, opts = {})
+        col_h = {}
+        reverse_col_h = {}
+        query_a = []
+        table_a = []
+        prefix="_x_"
+        structure[:column_list].each_with_index do |k, i|
+          key = "#{prefix}#{i+1}"
+          col_h[k.to_sym] = key.to_sym
+          reverse_col_h[key.to_sym] = k
+          query_a.push "#{k} AS #{key}"
+        end
+        tables = structure[:tables].clone
+        join_cond = structure[:join_condition]
+        tb = tables.shift
+        table_part = [ tb ]
+        tables.each do |table|
+          cond = join_cond[table.to_sym]
+          if cond
+            table_part.push " LEFT JOIN #{table} ON #{cond}"
+          else
+            table_part.push " LEFT JOIN #{table} ON #{tb}.#{table} = #{table}.id"
           end
-          column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
-          column(:updated_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
-        end
-      else
-        @sequel.create_table(table_name) do 
-          primary_key :id, auto_increment: true
-          dbtype_h.each do |key, dbtype|
-            column(key, dbtype)
+        end
+        sql = "SELECT #{query_a.join(', ')} FROM #{table_part.join(' ')}"
+        sql += " WHERE #{opts[:where]}" if opts[:where]
+        sql += " ORDER BY #{opts[:order]}" if opts[:order]
+        sql += " LIMIT #{opts[:limit]}" if opts[:limit]
+        data_a = self.exec(sql)
+        res_a = []
+        data_a.each do |data|
+          new_data = JointHash.new(tb)
+          data.each do |k, v|
+            orig_key = reverse_col_h[k.to_sym]
+            next unless orig_key
+            new_data[orig_key] = v
           end
-          column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
-          column(:updated_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+          res_a.push(new_data)
         end
+        return res_a
+      end
+
+      # テーブル生成
+      def create_table(table_name, dbtype_h)
+        %w[id created_at updated_at deleted_at].each do |key|
+          dbtype_h.delete(key.to_sym)
+        end
+        # puts "create_table: #{table_name}"
+        if @dbfile.index("postgres")
+          @sequel.create_table(table_name) do
+            primary_key :id, identity: true
+            dbtype_h.each do |key, dbtype|
+              column(key, dbtype)
+            end
+            column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+            column(:updated_at, :timestamp)
+            column(:deleted_at, :timestamp)
+          end
+        else
+          @sequel.create_table(table_name) do
+            primary_key :id, auto_increment: true
+            dbtype_h.each do |key, dbtype|
+              column(key, dbtype)
+            end
+            column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+            column(:updated_at, :timestamp)
+            column(:deleted_at, :timestamp)
+          end
+        end
+      end
+
+      def insert(table_name, val_h)
+        dataset(table_name).insert(val_h)
+      end
+
+      def update(dataset, id, val_h)
+        val_h.update({ updated_at: Time.now })
+        dataset.where(id: id).update(val_h)
+      end
+
+      def delete(dataset, id)
+        dataset.where(id: id).update({ deleted_at: Time.now })
       end
-    end
-    
-    def insert(table_name, val_h)
-      dataset(table_name).insert(val_h)
     end
 
-    def update(dataset, val_h)
-      val_h.update({ updated_at: Time.now() })
-      dataset.update(val_h)
-    end  
+    class Cache
+      class << self
+
+        def [](table)
+          @store ||= {}
+          dataset = DB.dataset(table.to_sym)
+          # EzLog.debug("DB::Cache: #{table}")
+          unless @store[table.to_sym]
+            data_a = dataset.where(deleted_at: nil).all
+            h = {}
+            data_a.each {|data| h[data[:id]] = data }
+            @store[table.to_sym] = h
+          end
+          # EzLog.debug(@store[table.to_sym])
+          return @store[table.to_sym]
+        end
+      end
+    end
   end
 end

data/lib/ezframe/editor_common.rb

@@ -0,0 +1,74 @@
+module Ezframe
+  module EditorCommon
+    def get_id(class_name = nil)
+      class_name ||= @class_snake
+      params = @request.env['url_params']
+      return nil unless params
+      # EzLog.info "get_id: #{params.inspect}, #{class_name}"
+      return params[class_name.to_sym]
+    end
+
+    # 新規データの生成
+    def create_data(form)
+      @column_set.clear
+      @column_set[:id].value = id = @column_set.create(form)
+      return id
+    end
+
+    # データの更新
+    def update_data(id, form)
+      @column_set.update(id, form)
+    end
+
+    def make_form(url, child)
+      return Ht.form(ezload: "command=set_validation:validate_url=#{url}", child: child)
+    end
+
+    #  新規登録ボタンの生成
+    def make_create_button(event = nil)
+      event ||= "on=click:url=#{make_base_url(@id)}/create"
+      return Ht.button(id: "#{@class_snake}-create-button", class: %[btn], child: [Ht.icon("add"), Message[:create_button_label]], ezevent: event)
+    end
+
+    # 編集ボタンの生成
+    def make_edit_button(event = nil)
+      event ||= "on=click:url=#{make_base_url(@id)}/edit"
+      return Ht.button(class: %w[btn], ezevent: event, child: [ Ht.icon("edit"), Message[:edit_button_label]])    
+    end
+
+    # 削除ボタンの生成
+    def make_delete_button(event = nil)
+      event ||= "on=click:url=#{make_base_url(@id)}/delete"
+      return Ht.button(class: %w[btn right red], ezevent: event, child: [Ht.icon("delete"), Message[:delete_button_label]])
+    end
+
+    # キャンセルボタンの生成
+    def make_cancel_button(event = nil)
+      event ||= "on=click:url=#{make_base_url(@id)}/detail:cancel=true:with=form"
+      return Ht.button(class: %w[btn red], child: [Ht.icon("cancel"), Message[:cancel_button_label]], ezevent: event)
+    end
+
+    # 値の更新
+#    def update_value
+#      form = @event[:form]
+#      @column_set.update(get_id, form)
+#    end
+
+    # ラベル付きで1カラムのviewを表示
+    def show_label_view(key)
+      col = @column_set[key]
+      Ht.span([Ht.small(col.label), col.view(force: true)])
+    end
+
+    # ラベル付きで1カラムのformを表示
+    def show_label_edit(key)
+      col = @column_set[key]
+      Ht.span([Ht.small(col.label), col.form(force: true)])
+    end
+
+    # エラーメッセージだけを表示するページを生成
+    def show_message_page(title, body)
+      return show_base_template(title: title, body: Html.convert(body))
+    end
+  end
+end