drg_cms 0.6.1.4 → 0.6.1.9

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

@@ -41,9 +41,10 @@
 # its control's would be found in model_embedded_controls.rb. By convention module names
 # are declared in camel case, so our dc_page_controls.rb declares DrgcmsControls::DcPageControls module.
 # 
-# Controls (among other) may contain 6 fixed callback methods.
+# Controls (among other) may contain 7 callback methods.
 # These methods are:
 # * dc_new_record
+# * dc_dup_record
 # * dc_before_edit
 # * dc_before_save
 # * dc_after_save
@@ -67,7 +68,7 @@
 #      if dc_user_can(DcPermission::CAN_READ)
 #        dc_page.where(created_by: session[:user_id])
 #      else
-#        flash[:error] = 'You can not perform this operation!'
+#        flash[:error] = 'User can not perform this operation!'
 #        nil
 #      end
 #    end
@@ -76,7 +77,6 @@
 ########################################################################
 class CmseditController < DcApplicationController
 before_action :check_authorization, :except => [:login, :logout, :test, :run]
-before_action :dc_reload_patches if Rails.env.development?
 protect_from_forgery with: :null_session, only: Proc.new { |c| c.request.format.json? }
   
 layout 'cms'
@@ -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
 
 ########################################################################
@@ -234,6 +232,7 @@ end
 # duplicating document and is subroutine of create action.
 ########################################################################
 def duplicate_document(source)
+  params['dup_fields'] += ',' if params['dup_fields'] # for easier field matching
   dest = {}
   source.attribute_names.each do |attribute_name|
     next if attribute_name == '_id' # don't duplicate _id
@@ -258,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')
@@ -294,12 +290,11 @@ def create
     end
   else # duplicate record
     find_record
-    params['dup_fields'] += ',' if params['dup_fields'] # for easier field matching
     new_doc = duplicate_document(@record)
     create_new_empty_record(new_doc)
-    update_standards()
+    if (m = callback_method('dup_record')) then call_callback_method(m) end
+    update_standards
     @record.save!
-
     index
   end
 end
@@ -331,10 +326,8 @@ def update
     end
   end
 
-  if dc_user_can(DcPermission::CAN_EDIT_ALL) or
-    ( @record.respond_to?('created_by') and
-      @record.created_by == session[:user_id] and
-      dc_user_can(DcPermission::CAN_EDIT) )
+  if dc_user_can(DcPermission::CAN_EDIT_ALL) ||
+    (@record.respond_to?('created_by') && @record.created_by == session[:user_id] && dc_user_can(DcPermission::CAN_EDIT))
 
     if save_data
       params[:return_to] = 'index' if params[:commit] == t('drgcms.save&back') # save & back
@@ -441,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)
@@ -478,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
@@ -571,19 +564,19 @@ 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] }
+  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 = params[:form_name] || @tables.last[1]
+  form_name = CmsHelper.form_param(params) || @tables.last[1]
   @form_js = ''
 
   # dynamically generated form
-  @form = if params[:form_name] == 'method'
+  @form = if CmsHelper.form_param(params) == 'method'
             dc_eval_class_method(params[:form_method], params)
           else
             form_file_name = dc_find_form_file(form_name)
@@ -623,7 +616,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)
@@ -644,9 +637,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
@@ -688,7 +682,7 @@ def create_new_empty_record(initial_data = nil) #:nodoc:
     @record = @tables.first[0].new(initial_data)
   else
     rec = @tables.first[0].find(@ids.first)             # top most record
-    1.upto(@tables.size - 2) { |i| rec = rec.send(@tables[i][1].pluralize).find(@ids[i]) }  # find embedded childrens by ids
+    1.upto(@tables.size - 2) { |i| rec = rec.send(@tables[i][1].pluralize).find(@ids[i]) }  # find embedded children by ids
     @record = rec.send(@tables.last[1].pluralize).new(initial_data)   # new record
   end
 end
@@ -715,8 +709,9 @@ end
 ########################################################################
 def save_journal(operation, changes = {})
   if operation == :delete
-    @record.attributes.each {|k,v| changes[k] = v}
+    @record.attributes.each { |k, v| changes[k] = v }
   end
+  changes.except!('created_at', 'updated_at', 'created_by', 'updated_by')
 
   if (operation != :update) || changes.size > 0
     # determine site_id
@@ -740,7 +735,7 @@ end
 # Returns callback method name or nil if not defined.
 ########################################################################
 def callback_method(key) #:nodoc:
-  data_key = key.gsub('_','-') # convert _ to -
+  data_key = key.gsub('_', '-') # convert _ to -
   callback = case
     when params['data'] && params['data'][data_key] then params['data'][data_key]
     # dc_ + key method is present then call it automatically
@@ -784,9 +779,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
@@ -830,6 +826,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)
@@ -842,7 +839,7 @@ def save_data
   update_standards() if changes.size > 0  # update only if there has been some changes
   if (saved = @record.save)
     operation = @record.new_record? ? :new : :update
-    save_journal(operation, changes)
+    save_journal(operation, @record.previous_changes)
     # after_save callback
     if (m = callback_method('after_save') ) then call_callback_method(m) end
   end
@@ -871,23 +868,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
 
 ########################################################################
@@ -913,82 +899,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])
@@ -998,7 +922,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
 
@@ -1006,31 +930,35 @@ end
 # Process index action for normal collections.
 ########################################################################
 def process_collections #:nodoc
-# If result_set is not defined on form, then it will fail. :return_to should know where to go
+  # If result_set is not defined on form, then it will fail. :return_to should know where to go
   if @form['result_set'].nil?
-    process_return_to(params[:return_to] || 'reload') 
+    process_return_to(params[:return_to] || 'reload')
     return true
   end
-# for now enable only filtering of top level documents
+  # when result set is evaluated as Rails helper
+  @form['result_set']['type'] ||= 'default'
+  return unless @form['result_set']['type'] == 'default'
+
+  # for now enable only filtering of top level documents
   if @tables.size == 1 
     check_filter_options()
     check_sort_options()
   end  
-# result set is defined by filter method in control object
+  # result set is defined by filter method in control object
   form_filter = @form['result_set']['filter']
   if form_filter
     if respond_to?(form_filter)
       @records = send(form_filter)
-# something went wrong. flash[] should have explanation.
+      # something went wrong. flash[] should have explanation.
       if @records.class == FalseClass
         @records = []
         render(action: :index)
         return true
       end
       process_select_and_deny_fields           
-# pagination but only if not already set
-      unless (@form['table'] == 'dc_memory' or @records.options[:limit])
-        per_page = (@form['result_set']['per_page'] || 30).to_i
+      # pagination but only if not already set
+      unless (@form['table'] == 'dc_memory' || @records.options[:limit])
+        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'
@@ -1040,10 +968,10 @@ def process_collections #:nodoc
     if @tables.size > 1 
       rec = @tables.first[0].find(@ids.first)          # top most document.id
       1.upto(@tables.size - 2) { |i| rec = rec.send(@tables[i][1].pluralize).find(@ids[i]) }  # find embedded childrens by ids
-# TO DO. When field name is different then pluralized class name. Not working yet.
+      # TO DO. When field name is different then pluralized class name. Not working yet.
       embedded_field_name = @tables.last[0] ? @tables.last[1].pluralize : @tables.last[1]
       @records = rec.send(embedded_field_name)   # current embedded set
-# sort by order if order field is present in model
+      # sort by order if order field is present in model
       if @tables.last[1].classify.constantize.respond_to?(:order)
         @records = @records.order_by('order asc')
       end
@@ -1074,5 +1002,4 @@ def process_in_memory #:nodoc
   false
 end
 
-
 end

data/app/controllers/dc_application_controller.rb

@@ -28,7 +28,8 @@
 class DcApplicationController < ActionController::Base
 protect_from_forgery with: :null_session, only: Proc.new { |c| c.request.format.json? }
 before_action :dc_reload_patches if Rails.env.development?
-  
+before_action :dc_set_locale
+
 ########################################################################
 # Writes anything passed as parameter to logger file. 
 # Very useful for debuging strange errors.
@@ -256,7 +257,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
 
 ##########################################################################
@@ -578,6 +579,20 @@ def dc_reload_patches
   end
 end
 
+########################################################################
+# Will set new default locale for application
+#
+# @param [String] new_locale : New locale value. If omitted it will be provided from params[:locale].
+#  if new_locale value is 00, application's default_locale will be used.
+########################################################################
+def dc_set_locale(new_locale = nil)
+  new_locale ||= params[:locale]
+  if new_locale && new_locale != session[:locale]
+    session[:locale] = new_locale == '00' ? nil : new_locale.to_sym
+  end
+  I18n.locale = session[:locale] ? session[:locale] : I18n.default_locale
+end
+
 ############################################################################
 # Writes out deprication msg. It also adds site_name to message, so it is easier to
 # find where the message is comming from.

data/app/controllers/dc_common_controller.rb

@@ -49,7 +49,12 @@ def autocomplete
     name = params['search'].split('.').first
     params['table'] = name.underscore
   end
-  return render plain: t('drgcms.not_authorized') unless dc_user_can(DcPermission::CAN_VIEW)
+  if params['table'].match('_control')
+    # it must be at least logged on
+    return render json: { label: t('drgcms.not_authorized') } unless dc_user_can(DcPermission::CAN_VIEW, 'dc_memory')
+  else
+    return render json: { label: t('drgcms.not_authorized') } unless dc_user_can(DcPermission::CAN_VIEW)
+  end
 
   table = params['table'].classify.constantize
   input = params['input'].gsub(/\(|\)|\[|\]|\{|\|\.|\,}/, '')
@@ -69,7 +74,7 @@ def autocomplete
         end
       end
 
-  render plain: a.to_json
+  render json: a
 end
 
 ########################################################################
@@ -212,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  
@@ -261,7 +267,7 @@ end
 # document.
 ########################################################################
 def add_json_ld_schema
-  edited_document = DcJsonLd.find_document_by_ids(params[:table], params[:ids])
+  edited_document = DcJsonLd.find_document_by_ids(CmsHelper.table_param(params), params[:ids])
   yaml = YAML.load_file( dc_find_form_file('json_ld_schema') )
   schema_data = yaml[params[:schema]]
   # Existing document
@@ -277,11 +283,11 @@ end
 # Will provide help data
 ########################################################################
 def help
-  form_name = params[:form_name] || params[:table]
+  form_name = CmsHelper.form_param(params) || CmsHelper.table_param(params)
   @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 = @form['help'] || @form['extend'] || form_name
   help_file_name = find_help_file(help_file_name)
   @help = YAML.load_file(help_file_name) if help_file_name
   # no auto generated help on index action

data/app/controls/browse_models_control.rb

@@ -1,4 +1,3 @@
-#encoding: utf-8
 #--
 # Copyright (c) 2014+ Damjan Rems
 #
@@ -26,31 +25,19 @@
 # 
 ######################################################################
 module BrowseModelsControl
-include DcApplicationHelper
-
-#########################################################################
-# Determine model class from filename.
-#########################################################################
-def determine_model(path)
-  path =~ /(.*)\/(.*).rb/
-  begin
-    $2.camelize.constantize 
-    $2
-  rescue Exception # it happends
-    nil
-  end
-end
 
 #########################################################################
 # Return array of all models found in application.
 #########################################################################
-def all_collections()
+def all_collections
   collections = []
   DrgCms.paths(:forms).each do |path|
     models_dir = File.expand_path("../models", path)
-    Dir["#{models_dir}/*.rb"].each do |model_file| 
-      collection_name = determine_model(model_file)
-      collections << collection_name if collection_name
+    Dir["#{models_dir}/*.rb"].each do |model_file|
+      model_file =~ /(.*)\/(.*).rb/
+      # check if model exists
+      collection = $2.camelize.constantize.new rescue nil
+      collections << collection.class.to_s.underscore if collection&.respond_to?(:_id)
     end
   end
   collections.sort
@@ -59,10 +46,10 @@ end
 ######################################################################
 # List all collections
 ######################################################################
-def collections()
+def collections
   @records = []
   all_collections.each do |collection|
-    @records << {'id' =>  collection, 'description' => t("helpers.label.#{collection}.tabletitle") } 
+    @records << DcMemory.new({'id' =>  collection, 'description' => t("helpers.label.#{collection}.tabletitle") })
   end
   @records
 end
@@ -70,7 +57,7 @@ end
 ######################################################################
 # List field definition for single model
 ######################################################################
-def all_fields()
+def all_fields
   @records = []
   model = params[:id].classify.constantize
   document = model.new
@@ -80,12 +67,13 @@ def all_fields()
     description = I18n.t("helpers.label.#{params[:id]}.#{attribute_name}") if description.match('missing:')
     description = attribute_name if description.match('missing:')
 
-    @records << {'collection' =>  params[:id], 
+    @records << DcMemory.new({id: attribute_name,
+                 'collection' =>  params[:id],
                  'field' => attribute_name, 
                  'type' => options[:type],
                  'description' => description, 
                  '_default' => options[:default]
-                } 
+                })
   end
 # embedded documents
   document.embedded_relations.each do |a_embedded|
@@ -94,11 +82,12 @@ def all_fields()
     description = I18n.t("helpers.label.#{params[:id]}.#{embedded.key}") if description.match('missing:')
     description = embedded.key if description.match('missing:')
 
-    @records << {'collection' =>  params[:id], 
+    @records << DcMemory.new({ id: embedded.key,
+                 'collection' =>  params[:id],
                  'field' => embedded.key, 
                  'type' => 'Embedded:' + embedded.class_name,
                  'description' => description
-                }
+                })
   end
 
   @records