drg_cms 0.6.1.1.1 → 0.6.1.4

data/app/controllers/dc_application_controller.rb

@@ -26,9 +26,8 @@
 # application controllers.
 ##########################################################################
 class DcApplicationController < ActionController::Base
-  protect_from_forgery
-  
-  before_action :dc_reload_patches if Rails.env.development?
+protect_from_forgery with: :null_session, only: Proc.new { |c| c.request.format.json? }
+before_action :dc_reload_patches if Rails.env.development?
   
 ########################################################################
 # Writes anything passed as parameter to logger file. 
@@ -54,9 +53,9 @@ end
 ####################################################################
 # Checks if user has required role.
 # 
-# @param [DcPolicyRole] role can be passed as DcPolicyRole object or 
-# @param [String] role as role name. If passed as name, dc_policy_roles is searched for appropriate role.
-# 
+# @param [DcPolicyRole or String] role can be passed as DcPolicyRole object or
+# as role name. If passed as name, dc_policy_roles is searched for appropriate role.
+#
 # @return [Boolean] True if user has required role added to his profile.
 # 
 # @example If user has required role
@@ -153,7 +152,7 @@ end
 # Will write document to dc_visits collection unless visit comes from robot. 
 # It also sets session[is_robot] variable to true if robot.
 ########################################################################
-def dc_log_visit()
+def dc_log_visit
   if request.env["HTTP_USER_AGENT"] and request.env["HTTP_USER_AGENT"].match(/\(.*https?:\/\/.*\)/)
     logger.info "ROBOT: #{Time.now.strftime('%Y.%m.%d %H:%M:%S')} id=#{@page.id} ip=#{request.remote_ip}."
     session[:is_robot] = true
@@ -173,8 +172,8 @@ protected
 # Checks if user can perform (read, create, edit, delete) document in specified
 # table (collection).
 # 
-# @param [Integer] Required permission level
-# @param [String] Collection (table) name for which permission is queried. Defaults to params[table].
+# @param [Integer] permission: Required permission level
+# @param [String] table: Collection (table) name for which permission is queried. Defaults to params[table].
 # 
 # @return [Boolean] true if user's role permits (is higher or equal then required) operation on a table (collection). 
 # 
@@ -182,19 +181,14 @@ protected
 #   if dc_user_can(DcPermission::CAN_VIEW, params[:table]) then ...
 ############################################################################
 def dc_user_can(permission, table = params[:table])
-  permissions = DcPermission.permissions_for_table(table)
-  session[:user_roles].each {|r| return true if permissions[r] && permissions[r] >= permission }
-  false
-end
-
-def dc_user_can(permission, table = params[:table])
+  table = table.underscore
   cache_key = ['dc_permission', table, session[:user_id], dc_get_site.id]
   permissions = dc_cache_read(cache_key)
   if permissions.nil?
     permissions = DcPermission.permissions_for_table(table)
     dc_cache_write(cache_key, permissions)
   end
-  session[:user_roles].each {|r| return true if permissions[r] && permissions[r] >= permission }
+  session[:user_roles].each { |r| return true if permissions[r] && permissions[r] >= permission }
   false
 end
 
@@ -216,33 +210,22 @@ def dc_cache_read(keys)
   end
 end
 
-def __dc_cache_read(keys)
-  p 'read', keys.join(''), Rails.cache.instance_variable_get(:@data).keys
-  pp Rails.cache.read(keys.join(''))
-end
-
 ####################################################################
 # Write data to cache
 #
-# @param [Array] Array of keys
-# @param [Object] Data written to cache
+# @param [Array] keys: Array of keys
+# @param [Object] data: Data written to cache
 #
 # @return [Object] data so dc_cache_write can be used as last statement in method.
 ####################################################################
-  def dc_cache_write(keys, data)
-    if redis_cache_store?
-      keys  = keys.dup
-      first = keys.shift
-      redis.hset(first, keys.join(''), Marshal.dump(data))
-    else
-      Rails.cache.write(keys.join(''), data)
-    end
-    data
+def dc_cache_write(keys, data)
+  if redis_cache_store?
+    keys  = keys.dup
+    first = keys.shift
+    redis.hset(first, keys.join(''), Marshal.dump(data))
+  else
+    Rails.cache.write(keys.join(''), data)
   end
-
-def __dc_cache_write(keys, data)
-  p 'write', keys.join('')
-  pp Rails.cache.write(keys.join(''), data)
   data
 end
 
@@ -256,8 +239,8 @@ def dc_set_is_mobile
   is_mobile = request.user_agent ? /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i.match(request.user_agent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.match(request.user_agent[0..3])
                                  : false
   session[:is_mobile] = is_mobile ? 1 : 0
-#
-  if request.env["HTTP_USER_AGENT "] and request.env["HTTP_USER_AGENT"].match(/\(.*https?:\/\/.*\)/)
+
+  if request.env["HTTP_USER_AGENT "] && request.env["HTTP_USER_AGENT"].match(/\(.*https?:\/\/.*\)/)
     logger.info "ROBOT: #{Time.now.strftime('%Y.%m.%d %H:%M:%S')} id=#{@page.id} ip=#{request.remote_ip}."
     session[:is_robot] = true
   end
@@ -266,23 +249,13 @@ end
 ##########################################################################
 # Merge values from parameters fields (from site, page ...) into internal @options hash.
 # 
-# @param [String] YAML string.
+# @param [String] parameters: passed as YAML string.
 ##########################################################################
 def dc_set_options(parameters)
   @options ||= {}
   return if parameters.to_s.size < 3
-# parameters are set az YAML. This should be default in future.
-  parms = YAML.load(parameters) rescue nil
-  if parms.nil? # error when loadnig yaml, try the old way parsing manually
-    parms = {}
-    parameters.split("\n").each do |line|
-      line.chomp.split(',').each do |parm|
-        key, value = parm.split(':')
-        value = value.to_s.strip.gsub(/\'|\"/,'')
-        parms[key.strip] = (value == '/' ? nil : value)
-      end
-    end
-  end
+  # parameters are set as YAML. This should be default in future.
+  parms = YAML.load(parameters) rescue {}
   @options.merge!(parms)
 end
 
@@ -296,7 +269,6 @@ end
 # @return [Boolean] true when none of documents is changed.
 ##########################################################################
 def dc_not_modified?(*documents)
-#  request.env.each {|k,v| p k,'*',v}
   return false unless request.env.include? 'HTTP_IF_MODIFIED_SINCE'
 
   since_date = Time.parse request.env['HTTP_IF_MODIFIED_SINCE']
@@ -305,7 +277,7 @@ def dc_not_modified?(*documents)
     next unless doc.respond_to?(:updated_at)
     last_modified = doc.updated_at if doc.updated_at > last_modified
   end
-#  p last_modified, since_date
+
   if last_modified >= since_date then
     render :nothing => true, :status => 304
     return true
@@ -324,13 +296,13 @@ def get_design_and_render(design_doc)
   layout      = @site.site_layout.blank? ? 'content' : @site.site_layout
   site_top    = '<%= dc_page_top %>'
   site_bottom = '<%= dc_page_bottom %>'
-# lets try the rails way
+  # lets try the rails way
  if @options[:control] && @options[:action]
     controller = "#{@options[:control]}_control".classify.constantize rescue nil
     extend controller if controller
     return send @options[:action] if respond_to?(@options[:action])
   end
-# design doc present 
+  # design doc present
   if design_doc
     # defined as rails view
     design = if design_doc.rails_view.blank? || design_doc.rails_view == 'site'
@@ -344,7 +316,7 @@ def get_design_and_render(design_doc)
     design = site_top + design + site_bottom
     return render(inline: design, layout: layout) unless design.blank?
   end
-# Design doc not defined
+  # Design doc not defined
   if @site.rails_view.blank?
     design = site_top + @site.design + site_bottom
     render(inline: design, layout: layout)
@@ -384,6 +356,7 @@ def dc_process_default_request
   params[:path]   = @options[:path].first if @options[:path].size > 1
   # some other process request. It should fail if not defined
   return send(@site.request_processor) unless @site.request_processor.blank?
+
   # Search for page
   pageclass = @site.page_klass
   if params[:id]
@@ -405,6 +378,7 @@ def dc_process_default_request
   end
   # if @page is not found render 404 error
   return dc_render_404('Page!') unless @page
+
   dc_set_is_mobile unless session[:is_mobile] # do it only once per session
   # find design if defined. Otherwise design MUST be declared in site
   if @page.dc_design_id
@@ -427,8 +401,7 @@ def dc_process_default_request
   get_design_and_render @design
 end
 
-######
-# ####################################################################
+###########################################################################
 # Single site document kind of request handler.
 # 
 # This request handler assumes that all data for the site is saved in the site document. 
@@ -444,18 +417,17 @@ def dc_single_sitedoc_request
   if @site.nil?
     session[:edit_mode] ||= 0
     @site = dc_get_site
-  # @site is not defined. render 404 error
+    # @site is not defined. render 404 error
     return dc_render_404('Site!') unless @site
+
     dc_set_options(@site.settings)
   end
-# HOMEPAGE. When no parameters is set
+  # HOMEPAGE. When no parameters is set
   params[:path] = @site.homepage_link if params[:path].nil?  
   @parts = @site.dc_parts
   @part  = @parts.find_by(link: params[:path])
   return dc_render_404('Part!') unless @part
-# Document was not modified since last visit  
-#  return if dc_not_modified?(@site, @part)
-#  
+
   @page_title = "#{@site.page_title} #{@part.name}"
   @js, @css = '', ''
   get_design_and_render nil
@@ -466,46 +438,36 @@ end
 # very good with non ascii chars. Since this method is used for converting from model
 # to collection names it is very unwise to use non ascii chars for table (collection) names.
 # 
-# @param [String] String to be converted 
-# 
+# @param [Object] model_string to be converted
+#
 # @example
 #   decamelize_type(ModelName) # 'ModelName' => 'model_name'
 ########################################################################
-def decamelize_type(string)
-  return nil unless string
-  r = ''
-  string.to_s.each_char do |c|
-    r << case 
-      when r.size == 0     then c.downcase
-      when c.downcase != c then '_' + c.downcase
-      else c      
-    end
-  end
-  r
+def decamelize_type(model_string)
+  model_string ? model_string.underscore : nil
 end
 
 ####################################################################
 # Return's error messages for the document formated for display on edit form.
 # 
-# @param [Document] Document object which will be examined for errors.
-# 
+# @param [Document] document object which will be examined for errors.
+#
 # @return [String] HTML code for displaying error on edit form.
 ####################################################################
 def dc_error_messages_for(document)
   return '' unless document.errors.any?
+
   msg = ''
-  document.errors.each do |attribute, errors_array|
-    label = t("helpers.label.#{decamelize_type(document.class)}.#{attribute}")
-    msg << "<li>#{label} : #{errors_array}</li>"
+  document.errors.each do |error|
+    label = t("helpers.label.#{decamelize_type(document.class)}.#{error.attribute}", error.attribute)
+    msg << "<li>#{label} : #{error.message}</li>"
   end
 
-html = <<eot
+  %(
 <div class="dc-form-error"> 
   <h2>#{t('drgcms.errors_no')} #{document.errors.size}</h2>  
   <ul>#{msg}</ul>  
-</div>
-eot
-  html.html_safe
+</div>).html_safe
 end
 
 ####################################################################
@@ -514,8 +476,8 @@ end
 # model errors or when saving to multiple collections and where each save must be 
 # checked if succesfull.
 # 
-# @param [Document] Document object which will be checked
-# @param [Boolean] If true method should end in runtime error. Default = false.
+# @param [Document] document: Document object to be checked
+# @param [Boolean] crash: If true method should end in runtime error. Default = false.
 # 
 # @return [String] Error messages or empty string if everything is OK.
 # 
@@ -527,16 +489,16 @@ end
 #   end
 #      
 ####################################################################
-def dc_check_model(document, crash=false)
+def dc_check_model(document, crash = false)
   DrgCms.model_check(document, crash)
 end
 
 ######################################################################
 # Call rake task from controller.
 # 
-# @param [String] Rake task name
-# @param [Hash] Options that will be send to task as environment variables
-# 
+# @param [String] task: Rake task name
+# @param [Hash] options: Options that will be send to task as environment variables
+#
 # @example Call rake task from application
 #   dc_call_rake('clear:all', some_parm: some_id)
 ######################################################################
@@ -551,7 +513,7 @@ end
 # made from DRG CMS form return may be quite complicated. All ajax return combinations 
 # can be found in drg_cms.js file. 
 # 
-# @param [Hash] Options
+# @param [Hash] opts: Options
 #
 # @return [JSON Response] Formatted to be used for ajax return.
 # 
@@ -643,51 +605,6 @@ def set_default_guest_user_role
   session[:user_roles] = [guest.id] if guest
 end
 
-####################################################################
-# Fills session with data related to successful login.
-#
-# @param [DcUser] user : User's document
-# @param [Boolean] remember_me : false by default
-####################################################################
-def fill_login_data(user, remember_me=false)
-  session[:user_id]    = user.id if user
-  session[:user_name]  = user.name if user
-  session[:edit_mode]  = 0
-  session[:user_roles] = []
-  # Every user has guest role
-  #  guest = DcPolicyRole.find_by(system_name: 'guest')
-  #  session[:user_roles] << guest.id if guest
-  set_default_guest_user_role
-  return unless user and user.active
-  # special for SUPERADMIN
-  sa = DcPolicyRole.find_by(system_name: 'superadmin')
-  if sa and (role = user.dc_user_roles.find_by(dc_policy_role_id: sa.id))
-    session[:user_roles] << role.dc_policy_role_id
-    session[:edit_mode]  = 2
-    return
-  end
-  # read default policy from site. Policy might be inherited
-  policy_site = dc_get_site()
-  policy_site = DcSite.find(policy_site.inherit_policy) if policy_site.inherit_policy
-  default_policy = policy_site.dc_policies.find_by(is_default: true)
-  # load user roles
-  user.dc_user_roles.each do |role|
-    next unless role.active
-    next if role.valid_from and role.valid_from > Time.now.end_of_day.to_date
-    next if role.valid_to   and role.valid_to < Time.now.to_date
-    # check if role is active in this site
-    policy_role = default_policy.dc_policy_rules.find_by(dc_policy_role_id: role.dc_policy_role_id)
-    next unless policy_role
-    # set edit_mode
-    session[:edit_mode] = 1 if policy_role.permission > 1
-    session[:user_roles] << role.dc_policy_role_id
-  end
-  # Save remember me cookie if not CMS user and remember me is selected
-  if session[:edit_mode] == 0 and remember_me
-    cookies.signed[:remember_me] = { :value => user.id, :expires => 180.days.from_now}
-  end
-end
-
 ####################################################################
 # Fills session with data related to successful login.
 # 
@@ -696,7 +613,7 @@ end
 ####################################################################
 def fill_login_data(user, remember_me = false)
   session[:user_id]   = user.id if user
-  session[:user_name] = user.name if user
+  session[:user_name] = user.name.squish if user
   session[:edit_mode] = 0
   set_default_guest_user_role
   return unless user&.active
@@ -771,7 +688,7 @@ end
 # Evaluates Class.method in more predictable context then just calling eval
 # 
 # @param [String] class_method defined as MyClass.method_name
-# @param [Object] optional parameters send to class_method
+# @param [Object] params: optional parameters send to class_method
 ##########################################################################
 def dc_eval_class_method(class_method, params = nil)
   klass, method = class_method.split('.')
@@ -823,28 +740,9 @@ def dc_add_meta_tag(type, name, content)
 end
 
 ########################################################################
-# Will prepare flash[:update] data, which will be used for updating fields
-# on forms parent form fields.
-# 
-# Parameters:
-# [field_name] String: Field name
-# [value] String: New value
-# [readonly] Boolean: Field is readonly
-# 
-########################################################################
-def dc_update_form_field(field_name, value, readonly=false)
-  dc_deprecate('dc_update_form_field will be deprecated. Use dc_update_form_element instead.')
-  key_name = (readonly ? 'td_' : '') + "record_#{field_name}"
-  flash[:update] ||= {}
-  flash[:update][key_name] = value
-end
-
-########################################################################
-# Will prepare flash[:update] data, which will be used for updating elements
+# Will prepare flash[:update] data, which is used for updating elements
 # on parent form.
 #
-# dc_update_form_field will be deprecated eventually.
-#
 # Parameters passed as hash:
 # [field] String: Field name
 # [head] String: Filed name in head of form
@@ -858,11 +756,10 @@ def dc_update_form_element(field: nil, head: nil, value:, readonly: true)
   elsif head
     "head-#{head}"
   end
+  return if key.nil?
 
-  if key
-    flash[:update] ||= {}
-    flash[:update][key] = value
-  end
+  flash[:update] ||= {}
+  flash[:update][key] = value
 end
 
 ####################################################################

data/app/controllers/dc_common_controller.rb

@@ -45,28 +45,29 @@ layout false
 ########################################################################
 def autocomplete
   # table parameter must be defined. If not, get it from search parameter
-  if params['table'].nil? and params['search'].match(/\./)
+  if params['table'].nil? && params['search'].match(/\./)
     name = params['search'].split('.').first
     params['table'] = name.underscore
   end
-  
   return render plain: t('drgcms.not_authorized') unless dc_user_can(DcPermission::CAN_VIEW)
-# TODO Double check if previous line works as it should.
+
   table = params['table'].classify.constantize
-  id = [params['id']] || '_id'
-# call method in class if search parameter has . This is for user defined searches
-# result must be returned as array of [id, search_field_value]
+  input = params['input'].gsub(/\(|\)|\[|\]|\{|\|\.|\,}/, '')
+  # call method in class if search parameter contains . This is for user defined searches
   a = if params['search'].match(/\./)
-    name, method = params['search'].split('.')
-    table.send(method, params['input']).inject([]) do |r,v|
-      r << { label: v[0], value: v[0], id: (v[1] || v[0]).to_s }
-    end
-# simply search which will search and return field_name defined in params['search']
-  else
-    table.where(params['search'] => /#{params['input']}/i).limit(20).inject([]) do |r,v|
-      r << { label: v[params['search']], value: v[params['search']], id: v.id.to_s }
-    end
-  end
+        #method, additional_params = params['search'].split('.')
+        #data = additional_params ? table.send(method, input, additional_params, self) : table.send(method, input)
+        name, method = params['search'].split('.')
+        data = table.send(method, input)
+        data.map do |v|
+          { label: v[0], value: v[0], id: (v[1] || v[0]).to_s }
+        end
+      # will search and return field_name defined in params['search']
+      else
+        table.where(params['search'] => /#{input}/i).limit(20).map do |v|
+          { label: v[params['search']], value: v[params['search']], id: v.id.to_s }
+        end
+      end
 
   render plain: a.to_json
 end
@@ -92,18 +93,19 @@ end
 ##########################################################################
 def toggle_edit_mode
   session[:edit_mode] ||= 0 
-# error when not logged in  
-  return dc_render_404 if session[:edit_mode] < 1 
-# if return_to_ypos parameter is present it will forward it and thus scroll to
-# aproximate position it was when toggle was clicked
+  # error when not logged in
+  return dc_render_404 if session[:edit_mode] < 1
+
+  # if return_to_ypos parameter is present it will forward it and thus scroll to
+  # aproximate position it was when toggle was clicked
   session[:edit_mode] = (session[:edit_mode] == 1) ? 2 : 1
   uri = Rack::Utils.parse_nested_query(request.url)
-# it parses only on & so first (return_to) parameter also contains url
+  # it parses only on & so first (return_to) parameter also contains url
   url = uri.first.last
   if (i = url.index('return_to_ypos')).to_i > 0
-    url = url[0,i-1]
+    url = url[0, i-1]
   end 
-# offset CMS menu
+  # offset CMS menu
   if (ypos = uri['return_to_ypos'].to_i) > 0
     ypos += session[:edit_mode] == 2 ? 250 : -250
   end
@@ -116,8 +118,8 @@ end
 # Default user login action.
 ####################################################################
 def process_login
-# Somebody is probably playing
-  return dc_render_404 unless ( params[:record] and params[:record][:username] and params[:record][:password] )
+  # Somebody is probably playing
+  return dc_render_404 unless ( params[:record] && params[:record][:username] && params[:record][:password] )
 
   unless params[:record][:password].blank? #password must not be empty
     user  = DcUser.find_by(username: params[:record][:username], active: true)
@@ -154,7 +156,7 @@ def login
       clear_login_data # on the safe side
     end
   end
-# Display login 
+  # Display login
   route = params[:route] || 'poll'
   redirect_to "/#{route}?poll_id=login&return_to=#{params[:return_to]}"
 end
@@ -163,23 +165,23 @@ end
 # Action for restoring document data from journal document.
 ####################################################################
 def restore_from_journal
-# Only administrators can perform this operation  
+  # Only administrators can perform this operation
   unless dc_user_has_role('admin')
     return render plain: { 'msg_info' => (t ('drgcms.not_authorized')) }.to_json
   end
-# selected fields to hash  
+  # selected fields to hash
   restore = {} 
-  params[:select].each {|key,value| restore[key] = value if value == '1' }
+  params[:select].each { |key,value| restore[key] = value if value == '1' }
   result = if restore.size == 0
     { 'msg_error' => (t ('drgcms.dc_journal.zero_selected')) }
   else
     journal_doc = DcJournal.find(params[:id])
-# update hash with data to be restored    
+    # update hash with data to be restored
     JSON.parse(journal_doc.diff).each {|k,v| restore[k] = v.first if restore[k] }
-# determine tables and document ids    
+    # determine tables and document ids
     tables = journal_doc.tables.split(';')
     ids = (journal_doc.ids.blank? ? [] : journal_doc.ids.split(';') ) << journal_doc.doc_id
-# find document
+    # find document
     doc = nil
     tables.each_index do |i|
       doc = if doc.nil?
@@ -188,10 +190,10 @@ def restore_from_journal
         doc.send(tables[i].pluralize).find(ids[i])
       end
     end
-# restore and save values
+    # restore and save values
     restore.each { |field,value| doc.send("#{field}=",value) }
     doc.save
-# TODO Error checking    
+    # TODO Error checking
     { 'msg_info' => (t ('drgcms.dc_journal.restored')) }
   end
   render plain: result.to_json
@@ -202,10 +204,11 @@ end
 # window with data formatted as json.
 ########################################################################
 def copy_clipboard
-# Only administrators can perform this operation  
+  # Only administrators can perform this operation
   return render(plain: t('drgcms.not_authorized') )  unless dc_user_can(DcPermission::CAN_ADMIN,'dc_site')
+
   respond_to do |format|
-# just open new window to same url and come back with html request    
+    # just open new window to same url and come back with html request
     format.json { dc_render_ajax(operation: 'window', url: request.url ) }
     
     format.html do
@@ -213,7 +216,6 @@ def copy_clipboard
       text = "<br><br>[#{params[:table]},#{params[:id]},#{params[:ids]}]<br>"
       render plain: text + doc.as_document.to_json
     end
-    
   end  
 end
 
@@ -223,17 +225,19 @@ end
 # ajax call for processing data.
 ########################################################################
 def paste_clipboard
-# Only administrators can perform this operation  
+  # Only administrators can perform this operation
   return render(plain: t('drgcms.not_authorized') )  unless dc_user_can(DcPermission::CAN_ADMIN,'dc_site')
+
   result = ''
   respond_to do |format|
-# just open new window to same url and come back with html request    
+    # just open new window to same url and come back with html request
     format.html { return render('paste_clipboard', layout: 'cms') }
     format.json {
       table, id, ids = nil
       params[:data].split("\n").each do |line|
         line.chomp!
         next if line.size < 5                 # empty line. Skip
+
         begin
           if line[0] == '['                   # id(s)
             result << "<br>#{line}"
@@ -260,7 +264,7 @@ 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') )
   schema_data = yaml[params[:schema]]
-# Existing document  
+  # Existing document
   if edited_document.dc_json_lds.find_by(type: "@#{params[:schema]}")
     return render json: {'msg_error' => t('helpers.help.dc_json_ld.add_error', schema: params[:schema] ) }
   else
@@ -337,7 +341,7 @@ def update_json(json, is_update=false) #:nodoc:
   json.each do |k,v|
     if v.class == Hash
       result[k] = v['$oid'] unless is_update
-#TODO Double check if unless works as expected
+      # TODO Double check if unless works as expected
     elsif v.class == Array
       result[k] = []
       v.each {|e| result[k] << update_json(e, is_update)}
@@ -354,22 +358,22 @@ end
 def process_document(line, table, id, ids)
   if params[:do_update] == '1' 
     doc = dc_find_document(table, id, ids)
-# document found. Update it and return
+    # document found. Update it and return
     if doc
       doc.update( update_json(ActiveSupport::JSON.decode(line), true) )
       msg = dc_check_model(doc)
       return (msg ? " ERROR! #{msg}" : " UPDATE. OK.")
     end
   end
-# document will be added to collection      
+  # document will be added to collection
   if ids.to_s.size > 5
-#TODO Add embedded document
+    #TODO Add embedded document
     " NOT SUPPORTED YET!"
   else
     doc = table.classify.constantize.new( update_json(ActiveSupport::JSON.decode(line)) )
     doc.save
   end
-  msg = dc_check_model(doc)
+  msg = DrgCms.model_check(doc)
   msg ? " ERROR! #{msg}" : " NEW. OK." 
 end