drg_cms 0.6.0.6 → 0.6.1.4

data/app/controllers/dc_common_controller.rb

@@ -1,6 +1,5 @@
-#coding: utf-8
 #--
-# Copyright (c) 2012-2013 Damjan Rems
+# Copyright (c) 2012+ Damjan Rems
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -46,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
@@ -93,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
@@ -117,14 +118,16 @@ 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)
     if user and user.authenticate(params[:record][:password])
       fill_login_data(user, params[:record][:remember_me].to_i == 1)
       return redirect_to params[:return_to] ||  '/'
+    else
+      clear_login_data # on the safe side
     end
   end
   flash[:error] = t('drgcms.invalid_username')
@@ -149,12 +152,11 @@ def login
     if user and user.active
       fill_login_data(user, true)
       return redirect_to params[:return_to]
-
     else
       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
@@ -269,8 +273,37 @@ def add_json_ld_schema
   render json: {'reload_' => 1}
 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)
+  @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?
+
+  render json: { popup: render_to_string(partial: 'help') }
+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
 ########################################################################
@@ -308,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)}
@@ -325,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
 

data/app/controls/dc_help_control.rb

@@ -0,0 +1,126 @@
+#--
+# Copyright (c) 2021+ Damjan Rems
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+######################################################################
+# Controls for creating help files
+######################################################################
+module DcHelpControl
+
+######################################################################
+# Will fill dc_temp with help documents found in a defined project directory.
+######################################################################
+def project_refresh
+  DcTemp.clear(temp_key)
+  if params[:record][:select_project].present?
+    # far less complicated if saved to session
+    session[:help_project] = params[:record][:select_project]
+    session[:help_lang] = params[:record][:lang_1]
+    help_dir_name = "#{session[:help_project]}/help/"
+    # create help directory if not yet exists
+    FileUtils.mkdir(help_dir_name) unless File.exist?(help_dir_name)
+    Dir["#{help_dir_name}*"].each do |file_name|
+      lang = File.extname(file_name).sub('.','')
+      next unless lang == session[:help_lang]
+
+      DcTemp.new(key: temp_key,
+                 project: session[:help_project],
+                 form_name: File.basename(file_name,'.*'),
+                 lang: lang,
+                 updated_at: File.mtime(file_name)).save
+    end
+  end
+  render json: { url: url_for(controller: :cmsedit, table: :dc_temp, form_name: :dc_help_1) }
+end
+
+######################################################################
+# Will populate fields with default values
+######################################################################
+def dc_new_record
+  @record.project = session[:help_project]
+  @record.lang = session[:help_lang]
+end
+
+######################################################################
+# Will read data from help file
+######################################################################
+def dc_before_edit
+  file_name = "#{session[:help_project]}/help/#{@record.form_name}.#{session[:help_lang]}"
+  data = YAML.load_file(file_name)
+  @record.index = data['index']
+  @record.form = data['form']
+  flash[:warning] = "Use only in development!" unless Rails.env.development?
+end
+
+######################################################################
+# Will save data to help file
+######################################################################
+def dc_before_save
+  rec = params[:record]
+  file_name = "#{session[:help_project]}/help/#{@record.form_name}.#{@record.lang}"
+  data = { 'index' => @record.index, 'form' => @record.form }
+  File.write(file_name, data.to_yaml)
+end
+
+######################################################################
+# Will return query to report data
+######################################################################
+def data_filter
+  DcTemp.where(key: temp_key).order_by(order: 1)
+end
+
+private
+
+######################################################################
+# Will return choices for select project input field on a form
+######################################################################
+def self.choices_for_project
+  r = DrgCms.paths(:forms).map do |path|
+    path = path.to_s
+    a = path.split('/')
+    project = a[a.size - 3]
+    project = if project == 'app'
+                a[a.size - 4] + ' : ' + a.last(2).join('/')
+              else
+                project + ' : ' + a.last
+              end
+    [project, path]
+  end
+  [[I18n.t('drgcms.dc_help.project'), nil]] + r.sort
+end
+
+######################################################################
+# Will return choices for selecting help file name, based on forms already
+# present in forms directory.
+######################################################################
+def self.choices_for_form_name(session)
+  Dir["#{session[:help_project]}/*.yml"].map { |file_name| File.basename(file_name,'.*') }.sort
+end
+
+######################################################################
+# Will return temp key for data saved in dc_temp file
+######################################################################
+def temp_key
+  "dc-help-#{session[:user_id]}"
+end
+
+end 

data/app/controls/dc_report.rb

@@ -0,0 +1,223 @@
+#--
+# Copyright (c) 2020+ Damjan Rems
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+######################################################################
+# Common methods required by reports
+######################################################################
+module DcReport
+attr_accessor :report_id
+attr_accessor :bulk
+
+######################################################################
+# Clear result if params[:clear] is 'yes' when form is first displayed
+######################################################################
+def dc_new_record
+  DcTemp.clear(temp_key) unless params[:clear].to_s == 'no'
+end
+
+######################################################################
+# If exists, set report section as form, so it can be used to display result.
+######################################################################
+def dc_update_form
+  return unless @form && @form['report'] && params[:table] == 'dc_temp'
+
+  @form = @form['report']
+end
+
+######################################################################
+# Print to PDF action
+######################################################################
+def print
+  begin
+    pdf_do
+  rescue Exception => e
+    dc_dump_exception(e)
+    render json: { msg_error: t('drgcms.runtime_error') } and return
+  end
+
+  pdf_file = "tmp/dokument-#{Time.now.to_i}.pdf"
+  @pdf.render_file Rails.root.join('public', pdf_file)
+
+  render json: print_response(pdf_file)
+end
+
+######################################################################
+# Export data do excel action
+######################################################################
+def export
+  export_to_excel( temp_key )
+end
+
+######################################################################
+# Default filter to select data for result.
+######################################################################
+def data_filter
+  params['clear'].to_s == 'yes' ? DcTemp.where(key: false) : DcTemp.where(key: temp_key).order_by(order: 1)
+end
+
+private
+
+######################################################################
+# Will create response message for print action. Response consists of
+# opening pdf file in new browser tab and additional print_message if defined.
+######################################################################
+def print_response(pdf_file)
+  response = { window: "/#{pdf_file}" }
+  response.merge!(report_message) if respond_to?(:report_message, true)
+  response
+end
+
+######################################################################
+# Temp key consists of report name and user's id. Key should be added
+# to every dc_temp document and is used to define data, which belongs
+# to current user.
+######################################################################
+def temp_key
+  "#{@report_id}-#{session[:user_id]}"
+end
+
+######################################################################
+# Initialize report. Set report_id internal variable and initialize bulk
+# for bulk saving data to dc_temp collection.
+######################################################################
+def init_report(id)
+  @report_id = id
+  @bulk = []
+end
+
+######################################################################
+# Check if all send fields are blank.
+######################################################################
+def all_blank?(*fields)
+  fields.each {|e| e.blank? ? true : (break false) }
+end
+
+######################################################################
+# Will write bulk data to dc_temp collection.
+######################################################################
+def bulk_write(doc, the_end = false)
+  if doc.nil? || doc.class == TrueClass
+    the_end = true
+  else
+    @bulk << doc
+  end
+
+  if (the_end && @bulk.size > 0) || @bulk.size > 100
+    DcTemp.collection.insert_many(@bulk) 
+    @bulk = []
+  end
+end
+
+######################################################################
+# Export data to Excel
+######################################################################
+def export_to_excel(report_id)
+  read_drg_form if @form.blank?
+  # use report options if present
+  columns = (@form['report'] ? @form['report'] : @form)['result_set']['columns'].sort
+
+  n, workbook = 0, Spreadsheet::Workbook.new
+  excel = workbook.create_worksheet(name: report_id)
+  # header
+  columns.each_with_index do |column, i|
+    caption = column.last['caption'] || column.last['label']
+    label = t(caption)
+    excel[n, i] = label.match('translation missing') ? caption : label
+  end
+
+  data_filter.each do |doc|
+    n += 1
+    columns.each_with_index do |column, i|
+      value = doc[column.last['name']].to_s.gsub('<br>', ";")
+      value = value.gsub(/\<\/strong\>|\<strong\>|\<\/b\>|\<b\>/, '')
+      excel[n, i] = value
+    end
+  end
+  file_name = "#{report_id}-#{Time.now.to_i}.xls"
+  workbook.write Rails.root.join('public', 'tmp', file_name)
+  dc_render_ajax(operation: :window, value: "/tmp/#{file_name}")
+end
+
+############################################################################
+# Returns html code for displaying date/time formatted by strftime. Will return '' if value is nil.
+# 
+# Parameters:
+# [value] Date/DateTime/Time.  
+# [format] String. strftime format mask. Defaults to locale's default format.
+############################################################################
+def dc_format_date_time(value, format = nil)
+  return '' if value.nil?
+
+  format ||= value.class == Date ? t('date.formats.default') : t('time.formats.default')
+  value.strftime(format)
+end
+
+##############################################################################
+# Initialize PDF document for print
+##############################################################################
+def pdf_init(opts={})
+  opts[:margin] ||= [30,30,30,30]
+  opts[:page_size] ||= 'A4'
+
+  pdf = Prawn::Document.new(opts)
+  pdf.font_size = opts[:font_size] if opts[:font_size]
+
+  pdf.encrypt_document( owner_password: :random,
+                        permissions: { print_document: true,
+                                       modify_contents: false,
+                                       copy_contents: false,
+                                       modify_annotations: false })
+  pdf.font_families.update(
+    'Arial' => { normal: Rails.root.join('public', 'arial.ttf'),
+                 bold: Rails.root.join('public', 'arialbd.ttf') }
+  )
+  pdf.font 'Arial'
+  pdf
+end
+
+################################################################################
+# Prints out single text (or object) on report.
+#
+# @param [Object] txt : Text or object. Result of to_s method of the object is
+# @param [Hash] opts
+###############################################################################
+def pdf_text(txt, opts = {})
+  box_opts = opts.dup
+  ypos = @pdf.cursor
+  xpos = opts.delete(:atx) || 0
+  box_opts[:single_line] ||= true
+  box_opts[:at] ||= [xpos, ypos]
+
+  @pdf.text_box(txt.to_s, box_opts)
+end
+
+################################################################################
+# Skip line on report
+#
+# @param [Integer] skip . Number of lines to skip. Default 1.
+###############################################################################
+def pdf_skip(skip = 1)
+  @pdf.text('<br>' * skip, inline_format: true)
+end 
+
+end