drg_cms 0.6.1.5 → 0.6.1.11

data/app/assets/stylesheets/drg_cms_application.css

@@ -9,6 +9,6 @@
  * compiled file, but it's generally better to create a new file per style scope.
  *
  *= require drg_cms/drg_cms
- *= require font-awesome
+ *= require drg_material_icons
 
 */

data/app/assets/stylesheets/drg_cms_cms.css

@@ -14,9 +14,6 @@
  *= require drg_cms/jstree
 
  *= require jquery-ui/all
- 
- *= require font-awesome
+ *= require drg_material_icons
 */
 
-/* Required for link buttons to look alike */
-.dc-link a, .dc-link-submit input {font-weight: 600; }   

data/app/controllers/cmsedit_controller.rb

@@ -99,7 +99,7 @@ end
 ########################################################################
 # Filter action. 
 ########################################################################
-def filter
+def _filter
   index
 end
 
@@ -128,12 +128,10 @@ end
 # Login can be called directly with url http://site.com/cmsedit/login
 ########################################################################
 def login
-  if    params[:id] == 'test' then set_test_site
-  elsif params[:ok]           then render action: 'login', layout: 'cms' 
-  else
-    session[:edit_mode] = 0
-    render action: 'login', layout: 'cms'
-  end
+  return set_test_site if params[:id] == 'test'
+
+  session[:edit_mode] = 0 if !params[:ok]
+  render action: 'login', layout: 'cms'
 end
 
 ########################################################################
@@ -198,7 +196,7 @@ def new
   end
   # new_record callback. Set default values for new record
   if (m = callback_method('new_record') ) then call_callback_method(m)  end
-  @parms['action'] = 'create'
+  @form_params['action'] = 'create'
 end
 
 ########################################################################
@@ -259,12 +257,9 @@ def duplicate_document(source)
 end
 
 ########################################################################
-# Create (or duplicate) action. Action is also used for turning filter on.
+# Create (or duplicate) action.
 ########################################################################
 def create
-  # abusing create for turning filter on
-  return index if params[:filter].to_s == 'on'
-
   # not authorized
   unless dc_user_can(DcPermission::CAN_CREATE)
     flash[:error] = t('drgcms.not_authorized')
@@ -284,8 +279,8 @@ def create
       flash[:info] = t('drgcms.doc_saved')
       params[:return_to] = 'index' if params[:commit] == t('drgcms.save&back') # save & back
       return process_return_to(params[:return_to]) if params[:return_to]
-      
-      @parms['id'] = @record.id # must be set, for proper update link
+
+      @form_params['id'] = @record.id # must be set, for proper update link
       params[:id]  = @record.id # must be set, for find_record
       edit
     else # error
@@ -314,7 +309,7 @@ def edit
     # don't do anything if return is false
     return index if ret.class == FalseClass
   end
-  @parms['action'] = 'update'
+  @form_params['action'] = 'update'
   render action: :edit
 end
 
@@ -336,7 +331,7 @@ def update
 
     if save_data
       params[:return_to] = 'index' if params[:commit] == t('drgcms.save&back') # save & back
-      @parms['action'] = 'update'
+      @form_params['action'] = 'update'
       # Process return_to
       return process_return_to(params[:return_to]) if params[:return_to]
     else
@@ -427,7 +422,7 @@ def destroy
 
   end
 
-  @parms['action'] = 'update'
+  @form_params['action'] = 'update'
   render action: :edit
 end
 
@@ -439,7 +434,7 @@ def run
   control_name, method_name = params[:control].split('.')
   if method_name.nil?
     method_name  = control_name
-    control_name = params[:table]   
+    control_name = CmsHelper.table_param(params)
   end
   # extend with control methods
   extend_with_control_module(control_name)
@@ -476,7 +471,7 @@ def can_process_run
     response = send(:dc_can_process)
     return response unless response.class == Array
   else
-    response = [DcPermission::CAN_VIEW, params[:table] || 'dc_memory']
+    response = [DcPermission::CAN_VIEW, CmsHelper.table_param(params) || 'dc_memory']
   end
   dc_user_can *response
 end
@@ -501,108 +496,6 @@ def user_has_permission?(permission, collection_name)
   true
 end
 
-########################################################################
-# Merges two forms when current form extends other form. Subroutine of read_drg_form.
-# With a little help of https://www.ruby-forum.com/topic/142809 
-########################################################################
-def forms_merge(hash1, hash2)
-  target = hash1.dup
-  hash2.keys.each do |key|
-    if hash2[key].is_a? Hash and hash1[key].is_a? Hash
-      target[key] = forms_merge(hash1[key], hash2[key])
-      next
-    end
-    target[key] = hash2[key] == '/' ? nil :  hash2[key]
-  end
-  # delete keys with nil value
-  target.delete_if { |k, v| v.nil? }
-end
-
-########################################################################
-# Extends DRGCMS form file. Extended file is processed first and then merged
-# with code in this form file. Form can extend only single form file.
-# 
-# [Parameters:]
-# [extend_option] : Value of @form['extend'] option
-########################################################################
-def extend_drg_form(extend_option)
-  form_file_name = dc_find_form_file(extend_option) 
-  @form_js << read_js_drg_form(form_file_name)
-  form  = YAML.load_file( form_file_name )
-  @form = forms_merge(form, @form)
-  # If combined form contains tabs and fields options, merge fields into tabs
-  if @form['form']['tabs'] && @form['form']['fields']
-    @form['form']['tabs']['fields'] = @form['form']['fields']
-    @form['form']['fields'] = nil
-  end
-end
-
-########################################################################
-# Include code from another DRGCMS form file. Included code is merged
-# with current form file code. Form can include more than one other DRGCMS forms.
-# 
-# [Parameters:]
-# [include_option] : Value of @form['include'] option
-########################################################################
-def include_drg_form(include_option)
-  includes = include_option.class == Array ? include_option : include_option.split(/\,|\;/)
-  includes.each do |include_file|
-    form_file_name = dc_find_form_file(include_file)    
-    @form_js << read_js_drg_form(form_file_name)
-    form  = YAML.load_file(form_file_name)    
-    @form = forms_merge(@form, form)
-  end
-end
-
-########################################################################
-# Will read data from form_file_name.js if exists.
-# 
-# [Parameters:]
-# [form_file_name] : Physical form filename
-########################################################################
-def read_js_drg_form(form_file_name)
-  js_form_file_name = form_file_name.sub('.yml','.js')
-  File.read(js_form_file_name) rescue ''
-end
-
-########################################################################
-# Read DRG form into @form object. Subroutine of check_authorization.
-########################################################################
-def read_drg_form
-  table_name = decamelize_type(params[:table].strip)
-  @tables = table_name.split(';').inject([]) { |r,v| r << [(v.classify.constantize rescue nil), v] }
-
-  # split ids passed when embedded document
-  ids = params[:ids].to_s.strip.downcase
-  @ids = ids.split(';').inject([]) { |r,v| r << v }
-
-  # form_name defaults to last table specified
-  form_name = params[:form_name] || @tables.last[1]
-  @form_js = ''
-
-  # dynamically generated form
-  @form = if params[:form_name] == 'method'
-            dc_eval_class_method(params[:form_method], params)
-          else
-            form_file_name = dc_find_form_file(form_name)
-            @form_js = read_js_drg_form(form_file_name)
-            YAML.load_file(form_file_name)
-          end
-
-  # form includes or extends another form file
-  include_drg_form(@form['include']) if @form['include']
-  extend_drg_form(@form['extend'])   if @form['extend']
-  @form['script'] = (@form['script'].blank? ? @form_js : @form['script'] + @form_js)
-  # add readonly key to form if readonly parameter is passed in url
-  @form['readonly'] = 1 if params['readonly'] #and %w(1 yes true).include?(params['readonly'].to_s.downcase.strip)
-
-  # !!!!!! Always use strings for key names since @parms['table'] != @parms[:table]
-  @parms = { 'table' => table_name, 'ids' => params[:ids], 'form_name' => form_name,
-             'return_to' => params['return_to'], 'edit_only' => params['edit_only'],
-             'readonly' => params['readonly'] 
-           }
-end
-
 ############################################################################
 # Load module if available. Try not to mask errors in control module
 ############################################################################
@@ -621,7 +514,7 @@ end
 ############################################################################
 def extend_with_control_module(control_name = @form['controls'] || @form['control'])
   # May include embedded forms so ; => _
-  control_name ||= params[:table].gsub(';','_')
+  control_name ||= CmsHelper.table_param(params).gsub(';','_')
   control_name += '_control' unless control_name.match(/control$|report$/i)
   # p '************',  control_name
   controls = load_controls_module(control_name)
@@ -642,9 +535,10 @@ end
 # load DRG form.
 ############################################################################
 def check_authorization
-  params[:table] ||= params[:form_name]
+  params[:table] ||= params[:t] || CmsHelper.form_param(params)
   # Only show menu
   return login if params[:id].in?(%w(login logout test))
+
   table = params[:table].to_s.strip.downcase
   set_default_guest_user_role if session[:user_roles].nil?
   # request shouldn't pass
@@ -652,8 +546,7 @@ def check_authorization
      (table.size < 3 or !dc_user_can(DcPermission::CAN_VIEW))
     return render(action: 'error', locals: { error: t('drgcms.not_authorized')} )
   end
-  read_drg_form
-  return render( plain: t('drgcms.form_error') ) if @form.nil?
+  dc_form_read
 
   # Permissions can be also defined on form
   #TODO So far only can_view is used. Think about if using other permissions has sense
@@ -702,6 +595,7 @@ def update_standards(record = @record)
     # and will be directly visible only to admins
     record.dc_site_id = dc_get_site.id if record.respond_to?('dc_site_id') && record.dc_site_id.nil?
   end
+  record.send(:set_history, self) if record.respond_to?(:set_history)
 end
 
 ########################################################################
@@ -743,7 +637,7 @@ def callback_method(key) #:nodoc:
   callback = case
     when params['data'] && params['data'][data_key] then params['data'][data_key]
     # dc_ + key method is present then call it automatically
-    when @form['form'][key] then @form['form'][key]
+    when @form.dig('form', key) then @form['form'][key]
     when respond_to?('dc_' + key) then 'dc_' + key
     when params[data_key] then params[data_key]
     else nil
@@ -783,9 +677,10 @@ end
 def process_return_to(return_to)
   script = case
     when return_to == 'index' then return index
+    when return_to.match(/eval=/i) then return_to.sub('eval=', '')
     when return_to.match(/parent\.reload/i) then 'parent.location.href=parent.location.href;'
     when return_to.match(/reload/i) then 'location.href=location.href;'
-    when return_to.match(/close/i) then 'window.close();'
+    when return_to.match(/window.close/i) then 'window.close();'
     when return_to.match(/none/i) then return
     else "location.href='#{return_to}'"
   end
@@ -829,6 +724,7 @@ def save_data
     value = DrgcmsFormFields.const_get(v['type'].camelize).get_data(params, v['name'])
     @record.send("#{v['name']}=", value)
   end
+
   # before_save callback
   if (m = callback_method('before_save') )
     ret = call_callback_method(m)
@@ -870,23 +766,12 @@ end
 ########################################################################
 # Will check and set sorting options for current result set. Subroutine of index method.
 ########################################################################
-def check_sort_options() #:nodoc:
+def check_sort_options #:nodoc:
   table_name = @tables.first[1]
-  old_sort = session[table_name][:sort].to_s
-  sort, direction = old_sort.split(' ')
+  return if session[table_name][:sort].nil? || @records.class != Mongoid::Criteria
 
-  if params['sort']
-    # reverse sort if same selected
-    if params['sort'] == sort
-      direction = (direction == '1') ? '-1' : '1'
-    end
-    direction ||= '1'
-    sort = params[:sort]
-    session[table_name][:sort] = "#{params['sort']} #{direction}"
-    session[table_name][:page] = 1
-  end
-  @records.sort( sort => direction.to_i ) if session[table_name][:sort] && @records.class == Mongoid::Criteria
-  params['sort'] = nil # otherwise there is problem with other links
+  sort, direction = session[table_name][:sort].split(' ')
+  @records = @records.order_by( sort => direction.to_i )
 end
 
 ########################################################################
@@ -912,82 +797,20 @@ def user_sort_options(model) #:nodoc:
   { field.to_sym => direction.to_i }
 end
 
-########################################################################
-# Will set session[table_name][:filter] and save last filter settings to session.
-# subroutine of check_filter_options.
-########################################################################
-def set_session_filter(table_name)
-  # models that can not be filtered (for now)
-  return if %w(dc_temp dc_memory).include?(params[:table])
-  # clear filter 
-  if params[:filter] == 'off' 
-    session[table_name][:filter] = nil
-    return
-  end
-  # field_name should exist on set filter condition
-  return if params[:filter_oper] && params[:filter_field].blank?
-
-  filter_value = if params[:filter_value].nil?
-    #NIL indicates that no filtering is needed
-    '#NIL'
-  else     
-    if params[:filter_value].class == String and params[:filter_value][0] == '@'
-      # Internal value. Remove leading @ and evaluate expression
-      expression = DcInternals.get(params[:filter_value])
-      eval(expression) rescue nil
-    else
-      # No filter when empty
-      params[:filter_value] == '' ? '#NIL' : params[:filter_value] 
-    end
-  end
-  # if filter field parameter is omitted then just set filter value
-  session[table_name][:filter] =
-  if params[:filter_field].nil?
-    saved = YAML.load(session[table_name][:filter])
-    saved['value'] = filter_value
-    saved.to_yaml
-  else 
-    # as field defined. Split name and alternative input field
-    field = if params[:filter_field].match(' as ')
-      params[:filter_input] = params[:filter_field].split(' as ').last.strip
-      params[:filter_field].split(' as ').first.strip
-    else
-      params[:filter_field]
-    end
-
-    {'field'     => field, 
-     'operation' => params[:filter_oper], 
-     'value'     => filter_value,
-     'input'     => params[:filter_input],
-     'table'     => table_name }.to_yaml
-  end
-  # must be. Otherwise kaminari includes parames on paging links
-  params[:filter]        = nil
-  params[:filter_id]     = nil
-  params[:filter_oper]   = nil
-  params[:filter_input]  = nil
-  params[:filter_field]  = nil
-end
-
 ########################################################################
 # Will check and set current filter options for result set. Subroutine of index method.
 ########################################################################
-def check_filter_options() #:nodoc:
-  table_name = @tables.first[1]
-  model      = @tables.first[0]
+def check_filter_options #:nodoc:
+  table_name = CmsHelper.table_param(params).strip.split(';').first.underscore
+  model      = table_name.classify.constantize
   session[table_name] ||= {}
   # page is set
   session[table_name][:page] = params[:page] if params[:page]
-  # new filter is applied
-  if params[:filter]
-    set_session_filter(table_name)
-    session[table_name][:page] = 1
-  end
   # if data model has field dc_site_id ensure that only documents which belong to the site are selected.
   site_id = dc_get_site._id if dc_get_site
 
   # don't filter site if no dc_site_id field or user is ADMIN
-  site_id = nil if !model.method_defined?('dc_site_id') or dc_user_can(DcPermission::CAN_ADMIN)
+  site_id = nil if !model.method_defined?('dc_site_id') || dc_user_can(DcPermission::CAN_ADMIN)
   site_id = nil if session[table_name][:filter].to_s.match('dc_site_id')
 
   if @records = DcFilter.get_filter(session[table_name][:filter])
@@ -997,7 +820,7 @@ def check_filter_options() #:nodoc:
   end
   process_select_and_deny_fields
   # pagination if required
-  per_page = (@form['result_set']['per_page'] || 30).to_i
+  per_page = (@form['result_set']['per_page'] || 25).to_i
   @records = @records.page(session[table_name][:page]).per(per_page) if per_page > 0
 end
 
@@ -1033,7 +856,7 @@ def process_collections #:nodoc
       process_select_and_deny_fields           
       # pagination but only if not already set
       unless (@form['table'] == 'dc_memory' || @records.options[:limit])
-        per_page = (@form['result_set']['per_page'] || 30).to_i
+        per_page = (@form['result_set']['per_page'] || 25).to_i
         @records = @records.page(params[:page]).per(per_page) if per_page > 0
       end
     elsif form_filter != 'dc_filter'
@@ -1077,5 +900,4 @@ def process_in_memory #:nodoc
   false
 end
 
-
 end

data/app/controllers/dc_application_controller.rb

@@ -114,27 +114,6 @@ def set_page_title
   dc_add_meta_tag(:name, 'description', @page.meta_description)
 end
 
-########################################################################
-# Searches forms path for file_name and returns full file name or nil if not found.
-# 
-# @param [String] Form file name. File name can be passed as gem_name.filename. This can
-# be useful when you are extending form but want to retain same name as original form
-# For example. You are extending dc_user form from drg_cms gem and want to
-# retain same dc_user name. This can be done by setting drg_cms.dc_user as extend option.
-# 
-# @return [String] Form file name including path or nil if not found.
-########################################################################
-def dc_find_form_file(form_file)
-  form_path = nil
-  form_path, form_file = form_file.split(/\.|\//) if form_file.match(/\.|\//)
-
-  DrgCms.paths(:forms).reverse.each do |path|
-    f = "#{path}/#{form_file}.yml"
-    return f if File.exist?(f) && (form_path.nil? || path.to_s.match(/\/#{form_path}(-|\/)/i))
-  end
-  raise "Exception: Form file '#{form_file}' not found!"
-end
-
 #######################################################################
 # Will render public/404.html file with some debug code includded.
 # 
@@ -257,7 +236,7 @@ def dc_set_options(parameters)
   return if parameters.to_s.size < 3
   # parameters are set as YAML. This should be default in future.
   parms = YAML.load(parameters) rescue {}
-  @options.merge!(parms)
+  @options = @options.deep_merge(parms)
 end
 
 ##########################################################################
@@ -833,4 +812,101 @@ def redis
   Rails.cache.redis
 end
 
+########################################################################
+# Extends DRGCMS form file. Extended file is processed first and then merged
+# with code in this form file. Form can extend only single form file.
+#
+# [Parameters:]
+# [extend_option] : Value of @form['extend'] option
+########################################################################
+def dc_form_extend(extend_option)
+  form_file_name = CmsHelper.form_file_find(extend_option)
+  @form_js << read_js_drg_form(form_file_name)
+  form  = YAML.load_file( form_file_name )
+  @form = CmsHelper.forms_merge(form, @form)
+  # If combined form contains tabs and fields options, merge fields into tabs
+  if @form['form']['tabs'] && @form['form']['fields']
+    @form['form']['tabs']['fields'] = @form['form']['fields']
+    @form['form']['fields'] = nil
+  end
+end
+
+########################################################################
+# Include code from another DRGCMS form file. Included code is merged
+# with current form file code. Form can include more than one other DRGCMS forms.
+#
+# [Parameters:]
+# [include_option] : Value of @form['include'] option
+########################################################################
+def dc_form_include(include_option)
+  includes = include_option.class == Array ? include_option : include_option.split(/\,|\;/)
+  includes.each do |include_file|
+    form_file_name = CmsHelper.form_file_find(include_file)
+    @form_js << read_js_drg_form(form_file_name)
+    form  = YAML.load_file(form_file_name)
+    @form = CmsHelper.forms_merge(@form, form)
+  end
+end
+
+########################################################################
+# Will read data from form_file_name.js if exists.
+#
+# [Parameters:]
+# [form_file_name] : Physical form filename
+########################################################################
+def read_js_drg_form(form_file_name)
+  js_form_file_name = form_file_name.sub('.yml','.js')
+  File.read(js_form_file_name) rescue ''
+end
+
+########################################################################
+# Read DRG form into @form object. Subroutine of check_authorization.
+########################################################################
+def dc_form_read
+  params[:table] ||= params[:t] || CmsHelper.form_param(params)
+  table_name = decamelize_type(CmsHelper.table_param(params).strip)
+  @tables = table_name.split(';').inject([]) { |r, v| r << [(v.classify.constantize rescue nil), v] }
+
+  # split ids passed when embedded document
+  ids = params[:ids].to_s.strip.downcase
+  @ids = ids.split(';').inject([]) { |r,v| r << v }
+
+  # form_name defaults to last table specified
+  form_name = CmsHelper.form_param(params) || @tables.last[1]
+  @form_js = ''
+
+  # dynamically generated form
+  @form = if CmsHelper.form_param(params) == 'method'
+            dc_eval_class_method(params[:form_method], params)
+          else
+            form_file_name = CmsHelper.form_file_find(form_name)
+            @form_js = read_js_drg_form(form_file_name)
+            YAML.load_file(form_file_name)
+          end
+
+  # form includes or extends another form file
+  dc_form_include(@form['include']) if @form['include']
+  dc_form_extend(@form['extend'])   if @form['extend']
+  @form['script'] = (@form['script'].blank? ? @form_js : @form['script'] + @form_js)
+  # add readonly key to form if readonly parameter is passed in url
+  @form['readonly'] = 1 if params['readonly'] #and %w(1 yes true).include?(params['readonly'].to_s.downcase.strip)
+
+  # !!!!!! Always use strings for key names since @form_params['table'] != @form_params[:table]
+  @form_params = { 'table' => table_name, 'ids' => params[:ids], 'form_name' => form_name,
+                   'return_to' => params['return_to'], 'edit_only' => params['edit_only'],
+                   'readonly' => params['readonly'], 'window_close' => params['window_close']}
+end
+
+########################################################################
+# Will search for help file and return it's full path name if found.
+########################################################################
+def self.find_help_file(help_file_name)
+  file_name = nil
+  DrgCms.paths(:forms).reverse.each do |path|
+    f = "#{path}/help/#{help_file_name}.#{I18n.locale}"
+    file_name = f and break if File.exist?(f)
+  end
+  file_name
+end
+
 end

data/app/controllers/dc_common_controller.rb

@@ -217,8 +217,9 @@ def copy_clipboard
     format.json { dc_render_ajax(operation: 'window', url: request.url ) }
     
     format.html do
-      doc = dc_find_document(params[:table], params[:id], params[:ids])
-      text = "<br><br>[#{params[:table]},#{params[:id]},#{params[:ids]}]<br>"
+      table = CmsHelper.table_param(params)
+      doc   = dc_find_document(table, params[:id], params[:ids])
+      text  = "<br><br>[#{table},#{params[:id]},#{params[:ids]}]<br>"
       render plain: text + doc.as_document.to_json
     end
   end  
@@ -266,8 +267,8 @@ end
 # document.
 ########################################################################
 def add_json_ld_schema
-  edited_document = DcJsonLd.find_document_by_ids(params[:table], params[:ids])
-  yaml = YAML.load_file( dc_find_form_file('json_ld_schema') )
+  edited_document = DcJsonLd.find_document_by_ids(CmsHelper.table_param(params), params[:ids])
+  yaml = YAML.load_file( CmsHelper.form_file_find('json_ld_schema') )
   schema_data = yaml[params[:schema]]
   # Existing document
   if edited_document.dc_json_lds.find_by(type: "@#{params[:schema]}")
@@ -282,12 +283,10 @@ end
 # Will provide help data
 ########################################################################
 def help
-  form_name = params[:form_name] || params[:table]
-  @form = form_name ? YAML.load_file(dc_find_form_file(form_name)) : {}
-  return render json: {} if @form.nil?
-
-  help_file_name = @form['help'] || @form['extend'] || params[:form_name] || params[:table]
-  help_file_name = find_help_file(help_file_name)
+  dc_form_read
+  form_name = CmsHelper.form_param(params) || CmsHelper.table_param(params)
+  help_file_name = @form['help'] || @form['extend'] || form_name
+  help_file_name = DcApplicationController.find_help_file(help_file_name)
   @help = YAML.load_file(help_file_name) if help_file_name
   # no auto generated help on index action
   return render json: {} if params[:type] == 'index' && @help.nil?
@@ -297,18 +296,6 @@ end
 
 protected
 
-########################################################################
-# Will search for help file and return it's path if found
-########################################################################
-def find_help_file(help_file_name)
-  file_name = nil
-  DrgCms.paths(:forms).reverse.each do |path|
-    f = "#{path}/help/#{help_file_name}.#{I18n.locale}"
-    file_name = f and break if File.exist?(f)
-  end
-  file_name
-end
-
 ########################################################################
 # Subroutine of add_json_ld_schema for adding one element
 ########################################################################