lux-fw 0.2.3 → 0.5.32

data/{lib/lux → plugins}/api/lib/model_api.rb

@@ -1,5 +1,41 @@
-class ModelApi < ApplicationApi
+class Sequel::Model
+  module InstanceMethods
+    def same_as_last_field_value data
+      data = data.join('-') if data.is_array?
+      data = '' if data.is_hash?
+      data
+    end
+
+    def same_as_last?
+      @last = self.class.xorder('id desc').first
+      return unless @last
+
+      return if respond_to?(:name) && name != @last[:name]
+
+      new_o = self.to_h
+      new_o.delete :created_at
+      new_o.delete :updated_at
+      new_o.delete :id
 
+      old_o = new_o.keys.inject({}) do |t, key|
+        t[key] = @last.send(key)
+
+        new_o[key] = same_as_last_field_value new_o[key]
+        t[key]     = same_as_last_field_value t[key]
+
+        t
+      end
+
+      if new_o.to_s.length == old_o.to_s.length
+        raise "#{self.class} is the copy of the last one created."
+      end
+    end
+  end
+end
+
+###
+
+class ModelApi < ApplicationApi
   class << self
     def toggle_ids name
       self.class_eval %[
@@ -12,7 +48,7 @@ class ModelApi < ApplicationApi
   end
 
   # toggles value in postgre array field
-  def toggle!(object, field, value)
+  def toggle! object, field, value
     object[field] ||= []
 
     if object[field].include?(value)
@@ -43,15 +79,13 @@ class ModelApi < ApplicationApi
   def create
     @object = @class_name.constantize.new
 
-    @last = @class_name.constantize.my.last rescue @class_name.constantize.last
-    if @last && @last[:name].present? && @last[:name] == @params[:name]
-      error "#{@class_name} is same as last one created."
-    end
-
-    for k,v in @params
+    for k, v in @params
+      v = nil if v.blank?
       @object.send("#{k}=", v) if @object.respond_to?(k.to_sym)
     end
 
+    @object.same_as_last? rescue error($!.message)
+
     can? :create, @object
     @object.save if @object.valid?
     return if report_errros_if_any @object
@@ -71,7 +105,9 @@ class ModelApi < ApplicationApi
     error "Object not found" unless @object
 
     for k,v in @params
-      @object.send("#{k}=", v) if @object.respond_to?(k.to_sym)
+      m = "#{k}=".to_sym
+      v = nil if v.blank?
+      @object.send(m, v) if @object.respond_to?(m)
     end
 
     can? :update, @object
@@ -135,13 +171,13 @@ class ModelApi < ApplicationApi
       desc = v.join(', ')
 
       response.error k, desc
-      response.error desc
     end
 
     error
   end
 
-  def can? action, object
+  def can? action, object=nil
+    object ||= @object
     object.can?(action) do |err|
       msg  = 'No %s permission for %s' % [action.to_s.sub('?',''), Lux.current.var.user ? Lux.current.var.user.email : :guests]
       msg += ' on %s' % object.class.name if object
@@ -151,7 +187,10 @@ class ModelApi < ApplicationApi
 
   def add_response_object_path
     begin
-      response.meta :path, @object.path if @object.respond_to?(:path)
+      if @object.respond_to?(:path)
+        response.meta :path, @object.path
+        response.meta :string_id, @object.id.string_id
+      end
     rescue
       nil
     end

data/{lib/lux → plugins}/api/lib/response.rb

@@ -11,7 +11,7 @@ class Lux::Api::Response
   attr_accessor :message
 
   def initialize
-    @meta = {}
+    @meta = {}.h_wia
   end
 
   def status num=nil
@@ -25,15 +25,20 @@ class Lux::Api::Response
   end
 
   def error key, data=nil
-    if data
-      @error_hash ||= {}
-      @error_hash[key.to_s] = data
-      data
-    else
-      @errors ||= []
-      @errors.push key unless @errors.include?(key)
-      key
+    unless data
+      data = key
+      key  = :base
     end
+
+    key = key.to_s
+
+    @errors ||= {}
+    @errors[key] ||= []
+    @errors[key].push data unless @errors[key].include?(data)
+  end
+
+  def errors?
+    !!@errors
   end
 
   def message what
@@ -44,22 +49,26 @@ class Lux::Api::Response
     @meta['location'] = url
   end
 
-  def errors?
-    (@error_hash || @errors) ? true : false
+  def event name, opts={}
+    @meta['event'] ||= []
+    @meta['event'].push([name, opts])
   end
 
   def render
     output = {}
 
-    if errors?
+    if @errors
       status 400
 
-      output[:error] ||= {}
-      output[:error][:messages] = @errors if @errors
-      output[:error][:hash] = @error_hash if @error_hash
-    end
+      errors = @errors.inject({}) { |t, (k, v)| t[k] = v.join(', '); t }
+      base   = errors.values.uniq
 
-    Lux.current.response.status status
+      errors.delete('base')
+
+      output[:error]          ||= {}
+      output[:error][:messages] = base
+      output[:error][:hash]     = errors if errors.keys.first
+    end
 
     output[:data]    = @data    if @data.present?
     output[:meta]    = @meta    if @meta.present?
@@ -68,4 +77,9 @@ class Lux::Api::Response
     output
   end
   alias :to_hash :render
+
+  def write
+    Lux.current.response.status status
+    Lux.current.response.body render
+  end
 end

data/{bin/cli/am → plugins/db/auto_migrate/auto_migrate.rb}

@@ -1,27 +1,10 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'dotenv'
-
-Dotenv.load
-Bundler.require(:default)
-
-# load app config
-require './config/db'
-
-# Sequel extension and plugin test
-DB.run %[DROP TABLE IF EXISTS lux_tests;]
-DB.run %[CREATE TABLE lux_tests (int_array integer[] default '{}', text_array text[] default '{}');]
-class LuxTest < Sequel::Model; end;
-LuxTest.new.save
-die('"DB.extension :pg_array" not loaded') unless LuxTest.first.int_array.class == Sequel::Postgres::PGArray
-DB.run %[DROP TABLE IF EXISTS lux_tests;]
+# https://github.com/jeremyevans/sequel/blob/master/doc/schema_modification.rdoc
 
 class AutoMigrate
   attr_accessor :fields
 
   class << self
-    def table table_name
+    def table table_name, opts={}
       die "Table [#{table_name}] not in plural -> expected [#{table_name.to_s.pluralize}]" unless table_name.to_s.pluralize == table_name.to_s
 
       die 'Table name "%s" is not permited' % table_name if [:categories].include?(table_name)
@@ -34,7 +17,7 @@ class AutoMigrate
         end
       end
 
-      t = new table_name
+      t = new table_name, opts
       yield t
       t.fix_fields
       t.update
@@ -57,20 +40,19 @@ class AutoMigrate
         raise $!
       end
     end
+
   end
 
   ###
 
-  def initialize table_name
+  def initialize table_name, opts={}
+    @fields     = {}
+    @opts       = opts
     @table_name = table_name
-    @fields = {}
 
     klass = @table_name.to_s.classify
 
-    if Object.const_defined?(klass)
-      puts 'Table name "%s" is not allowed - class "%s" is allready defined'.red % [table_name, klass]
-      exit
-    end
+    Object.send(:remove_const, klass) if Object.const_defined?(klass)
 
     eval %[class ::%s < Sequel::Model; end;] % klass
     @object = klass.constantize.new
@@ -119,11 +101,13 @@ class AutoMigrate
     puts "Table #{@table_name.to_s.yellow}, #{@fields.keys.length} fields"
 
     # remove extra fields
-    for field in (@object.columns - @fields.keys - [:id])
-      print "Remove colum #{@table_name}.#{field} (y/N): ".light_blue
-      if STDIN.gets.chomp.downcase.index('y')
-        DB.drop_column @table_name, field
-        puts " drop_column #{field}".green
+    if @opts[:drop].class != FalseClass
+      for field in (@object.columns - @fields.keys - [:id])
+        print "Remove colum #{@table_name}.#{field} (y/N): ".light_blue
+        if STDIN.gets.chomp.downcase.index('y')
+          DB.drop_column @table_name, field
+          puts " drop_column #{field}".green
+        end
       end
     end
 
@@ -261,9 +245,9 @@ class AutoMigrate
     name = args[0]
     opts = args[1] || {}
 
-    if [:string, :integer, :text, :boolean, :datetime, :date, :jsonb].index(type)
+    if [:string, :integer, :text, :boolean, :datetime, :date, :jsonb, :geography].index(type)
       @fields[name.to_sym] = [type, opts]
-    elsif [:decimal].index(type)
+    elsif type == :decimal
       opts[:precision] ||= 8
       opts[:scale] ||= 2
       @fields[name.to_sym] = [:decimal, opts]
@@ -274,6 +258,7 @@ class AutoMigrate
       @fields[:updated_at] = [:datetime, opts]
       @fields[:updated_by] = [:integer, opts]
     elsif type == :polymorphic
+      name ||= :model
       @fields["#{name}_id".to_sym]   = [:integer, opts.merge(index: true) ]
       @fields["#{name}_type".to_sym] = [:string, opts.merge(limit: 100, index: "#{name}_id")]
     else
@@ -281,5 +266,3 @@ class AutoMigrate
     end
   end
 end
-
-require './config/schema.rb'

data/plugins/db/helpers/array_search.rb

@@ -0,0 +1,27 @@
+Sequel::Model.dataset_module do
+  # only postgree
+  # Bucket.can.all_tags -> can_tags mora biti zadnji
+  def all_tags field=:tags, *args
+    sqlq = sql.split(' FROM ')[1]
+    sqlq = "select lower(unnest(#{field})) as tag FROM " + sqlq
+    sqlq = "select tag as name, count(tag) as cnt from (#{sqlq}) as tags group by tag order by cnt desc"
+    DB.fetch(sqlq).map(&:h).or([])
+  end
+
+  # were users.id in (select unnest(user_ids) from doors)
+  # def where_unnested klass
+  #   target_table = klass.to_s.tableize
+  #   where("#{table_name}.id in (select unnest(#{table_name.singularize}_ids) from #{target_table})")
+  # end
+  # assumes field name is tags
+  def where_any data, field
+    return self unless data.present?
+
+    if data.is_a?(Array)
+      xwhere data.map { |v| "#{v}=any(#{field})" }.join(' or ')
+    else
+      xwhere('?=any(%s)' % field, data)
+    end
+  end
+end
+

data/plugins/db/helpers/before_save_filters.rb

@@ -0,0 +1,32 @@
+module Sequel::Plugins::LuxBeforeSave
+  module InstanceMethods
+    def before_save
+      # timestamps
+      self[:created_at] = Time.now.utc if !self[:id] && respond_to?(:created_at)
+      self[:updated_at] ||= Time.now.utc if respond_to?(:updated_at)
+
+      # return error if user needed and not defined
+      if !User.current && (respond_to?(:created_by) || respond_to?(:updated_by))
+        errors.add(:base, 'You have to be registered to save data')
+        return
+      end
+
+      # add timestamps
+      self[:created_by]   = User.current.id if respond_to?(:created_by) && !id
+      self[:updated_by] ||= User.current.id if respond_to?(:updated_by)
+
+      # delete cache key if defined
+      Lux.cache.delete(cache_key)
+
+      super
+    end
+
+    def before_destroy
+      Lux.cache.delete(cache_key)
+
+      super
+    end
+  end
+end
+
+Sequel::Model.plugin :lux_before_save

data/plugins/db/helpers/composite_primary_keys.rb

@@ -0,0 +1,36 @@
+# define composite key and check before save
+# class OrgUser < ApplicationModel
+#   primary_keys :org_id, :user_id
+# end
+
+module Sequel::Plugins::PrimaryKeys
+  module ClassMethods
+    def primary_keys(*args)
+      unless args[0]
+        return respond_to?(:_primary_keys) ? _primary_keys : [:id]
+      end
+
+      define_singleton_method(:_primary_keys) { args }
+    end
+  end
+
+  module InstanceMethods
+    def before_save
+      klass = self.class
+
+      if klass.respond_to?(:_primary_keys)
+        check = klass._primary_keys.inject(klass.dataset) do |record, field|
+          record = record.where(field =>send(field))
+        end
+
+        check = check.xwhere('id<>?', id) if self[:id]
+
+        raise StandardError, 'Record allredy exists (primary_keys check)' if check.first
+      end
+
+      super
+    end
+  end
+end
+
+Sequel::Model.plugin :primary_keys

data/plugins/db/helpers/core.rb

@@ -0,0 +1,94 @@
+# http://ricostacruz.com/cheatsheets/sequel.html
+# http://sequel.jeremyevans.net/rdoc/files/doc/model_plugins_rdoc.html
+
+class Sequel::Model
+  module ClassMethods
+    def find_by what
+      where(what).first
+    end
+
+    # active record like define scope
+    # http://sequel.jeremyevans.net/rdoc/classes/Sequel/Model/ClassMethods.html
+    def scope name, body=nil, &block
+      block ||= body
+      dataset_module{define_method(name, &block)}
+    end
+
+    # instance scope, same as scope but runs on instance
+    # iscope(:notes)   { Note.where(created_by:id) }
+    def iscope name, body=nil, &block
+      block ||= body
+      define_method(name, &block)
+    end
+
+    def first_or_new filter
+      where(filter).first || new(filter)
+    end
+
+    def first_or_create filter
+      where(filter).first || create(filter)
+    end
+  end
+
+  module InstanceMethods
+    def cache_key
+      "#{self.class}/#{id}"
+    end
+
+    def attributes
+      ret = {}
+      for el in columns
+        ret[el.to_s] = send(el.to_s) rescue '-'
+      end
+      ret
+    end
+
+    def touch
+      self[:updated_at] = Time.now.utc
+      save columns: [:updated_at]
+    end
+
+    def to_h
+      ret = {}
+      for el in self.keys
+        ret[el] = send el
+      end
+      ret
+    end
+
+    def creator
+      self[:created_by] ? User.find(self[:created_by]) : nil
+    end
+
+    def parent_model
+      model_type.constantize.find(model_id)
+    end
+
+    # has?(:name, "Name is not defined") -> errors.add("Name is not defined")
+    # has?(:name) -> false
+    def has?(*args)
+      if args[1] && args[1].kind_of?(String)
+        unless self[args[0]].present?
+          errors.add(args[0], args[1])
+          return false
+        end
+        return true
+      end
+      args.each { |el| return false unless self[el].present? }
+      true
+    end
+
+    def unique?(field)
+      select(field).xwhere('id<>?', id).count == 0
+    end
+
+    def save!
+      save
+    end
+  end
+
+  module DatasetMethods
+  end
+end
+
+

data/plugins/db/helpers/dataset_methods.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+Sequel::Model.dataset_module do
+  def random
+    order(Sequel.lit('random()'))
+  end
+
+  def xselect text
+    select Sequel.lit text
+  end
+
+  def xorder text
+    order Sequel.lit text
+  end
+
+  def xfrom text
+    from Sequel.lit text
+  end
+
+  def xwhere hash_or_string, *args
+    return where(Sequel.lit("coalesce(%s,'')!=''" % hash_or_string)) if hash_or_string.is_a?(Symbol)
+    return where(Sequel.lit(hash_or_string, *args))                  if hash_or_string.is_a?(String)
+
+    # check if we do where in a array
+    if hash_or_string.class == Hash
+      key = hash_or_string.keys.first
+
+      if model.db_schema[key][:db_type].include?('[]')
+        value = hash_or_string.values.first
+
+        if value.is_a?(Array)
+          # { skills: ['ruby', 'perl'] }, 'or'
+          # { skills: ['ruby', 'perl'] }, 'and'
+          join_type = args.first or die('Define join type for xwhere array search ("or" or "and")')
+
+          data = value.map do |v|
+            val =
+            if v.is_a?(Integer)
+              v
+            else
+              v = v.gsub(/['"]/,'')
+              v = "'%s'" % v
+            end
+
+            "%s=any(#{key})" % v
+          end
+            .join(' %s ' % join_type)
+
+          return where(Sequel.lit(data))
+        else
+          # skills: 'ruby'
+          return where(Sequel.lit("?=any(#{key})", value))
+        end
+      end
+    end
+
+    q = hash_or_string.select{ |k,v| v.present? && v != 0 }
+    q.keys.blank? ? self : where(q)
+  end
+
+  def xlike search, *args
+    unless search.blank?
+      search = search.gsub(/'/,"''").downcase
+      where_str = []
+
+      for str in search.split(/\s+/).select(&:present?)
+        and_str = []
+        str = "%#{str}%"
+
+        for el in args
+          if model.db_schema[el][:db_type] == 'jsonb'
+            like_sql = "CAST(#{el} -> '#{Locale.current}' as text) ilike '#{str}'"
+            if Locale::DEFAULT != Locale.current
+              and_str << "(#{like_sql}) or (CAST(#{el} -> '#{Locale::DEFAULT}' as text) ilike '#{str}')"
+            else
+              and_str << like_sql
+            end
+          else
+            and_str << "#{el}::text ilike '#{str}'"
+          end
+        end
+
+        where_str.push '('+and_str.join(' or ')+')'
+      end
+
+      return where(Sequel.lit(where_str.join(' and ')))
+    end
+    self
+  end
+
+  def last_updated
+    field = model.db_schema[:updated_at] ? :updated_at : :id
+    order(Sequel.desc(field)).first
+  end
+
+  def for obj
+    # column_names
+    field_name = "#{obj.class.name.underscore}_id".to_sym
+    n1         = model.to_s.underscore
+    n2         = obj.class.to_s.underscore
+
+    cname = n1[0] < n2[0] ? n1+'_'+n2.pluralize : n2+'_'+n1.pluralize
+
+    if (cname.classify.constantize rescue false)
+      where Sequel.lit 'id in (select %s_id from %s where %s_id=%i)' % [n1, cname, n2, obj.id]
+    elsif model.db_schema["#{n2}_ids".to_sym]
+      return where Sequel.lit '%i=any(%s_ids)' % [obj.id, n2]
+    elsif model.db_schema[field_name]
+      return where Sequel.lit '%s=%i' % [field_name, obj.id]
+    elsif model.db_schema[:model_type]
+      return where(:model_type=>obj.class.to_s, :model_id=>obj.id)
+    elsif obj.class.to_s == 'User'
+      if obj.respond_to?(field_name)
+        return where Sequel.lit '%s=?' % [field_name, obj.id]
+      end
+      return where Sequel.lit 'created_by=%i' % obj.id
+    else
+      r "Unknown link for #{obj.class} (probably missing db field)"
+    end
+  end
+
+  def desc
+    reverse :id
+  end
+
+  def asc
+    order :id
+  end
+
+  def pluck field
+    select_map field
+  end
+
+  def ids
+    select(:id).map(&:id)
+  end
+end
+

data/plugins/db/helpers/enums_plugin.rb

@@ -0,0 +1,52 @@
+class Sequel::Model
+  module ClassMethods
+    # enums name: :steps, method: :step, field: :step_sid, default: 'o' do |list|
+    #   list['o'] = 'Open'
+    #   list['w'] = { name: 'Waiting', desc: '...' }.h
+    # end
+    # enums :steps
+    #   list['o'] = 'Otvoreno'
+    #   list['w'] = { name: 'Waiting', desc: '...' }.h
+    # end
+    # enums :steps, values: { 'o'=>'Open', 'w'=>'Waiting' }
+    # enums :kinds, ['string', 'boolean', 'textarea']
+    def enums name, opts={}, &block
+      if opts.class == Array
+        opts = {
+          values: opts,
+          field: false
+        }
+      end
+
+      opts[:default] ||= opts.first if opts[:values].class == Array
+
+      values = opts[:values] || {}.tap { |_| block.call(_) }
+      values = values.inject({}) { |h, (k,v)| h[k.to_s] = v; h }
+
+      opts[:method]  ||= name.to_s.singularize
+      opts[:default]   = values.keys.first unless opts.key?(:default)
+      opts[:default]   = opts[:default].to_s
+
+      unless opts[:field].class == FalseClass
+        unless opts[:field]
+          opts[:field] = opts[:method] + '_id'
+          opts[:field] = opts[:method] + '_sid' unless db_schema[opts[:field].to_sym]
+        end
+
+        raise NameError.new('Field %s not found for enums %s' % [opts[:field], name]) unless db_schema[opts[:field].to_sym]
+
+        define_method(opts[:method]) do
+          value = send(opts[:field]).or opts[:default]
+          return unless value.present?
+          values[value.to_s] || raise('Key "%s" not found' % value)
+        end
+      end
+
+      # this is class method that will list all options
+      define_singleton_method(name) do |id=nil|
+        id ? values[id] : values
+      end
+    end
+  end
+end
+