drg_cms 0.4.39

data/app/assets/stylesheets/drg_cms/theme.css

@@ -0,0 +1,49 @@
+/**
+ * MacOS X like theme for elFinder.
+ * Required jquery ui "smoothness" theme.
+ *
+ * @author Dmitry (dio) Levashov
+ **/
+
+/* dialogs */
+.std42-dialog, .std42-dialog .ui-widget-content { background-color:#ededed; background-image:none; background-clip: content-box; }
+
+/* navbar */
+.elfinder .elfinder-navbar { background:#dde4eb; }
+.elfinder-navbar .ui-state-hover  { background:transparent; border-color:transparent; }
+.elfinder-navbar .ui-state-active { background: #3875d7;    border-color:#3875d7; color:#fff; }
+/* disabled elfinder */
+.elfinder-disabled .elfinder-navbar .ui-state-active { background: #dadada; border-color:#aaa; color:#fff; }
+
+
+/* current directory */
+/* selected file in "icons" view */
+.elfinder-cwd-view-icons .elfinder-cwd-file .ui-state-hover { background:#ccc; }
+/* list view*/
+.elfinder-cwd table tr:nth-child(odd) { background-color:#edf3fe; }
+.elfinder-cwd table tr { border-top:1px solid #fff; }
+
+/* common selected background/color */
+.elfinder-cwd-view-icons .elfinder-cwd-file .elfinder-cwd-filename.ui-state-hover,
+.elfinder-cwd table td.ui-state-hover,
+.elfinder-button-menu .ui-state-hover { background: #3875d7; color:#fff;}
+/* disabled elfinder */
+.elfinder-disabled .elfinder-cwd-view-icons .elfinder-cwd-file .elfinder-cwd-filename.ui-state-hover,
+.elfinder-disabled .elfinder-cwd table td.ui-state-hover { background:#dadada;}
+
+/* statusbar */
+.elfinder .elfinder-statusbar { color:#555; }
+.elfinder .elfinder-statusbar a { text-decoration:none; color:#555;}
+
+
+.std42-dialog .elfinder-help, .std42-dialog .elfinder-help .ui-widget-content { background:#fff;}
+
+/* contextmenu */
+.elfinder-contextmenu .ui-state-hover { background: #3875d7; color:#fff; }
+.elfinder-contextmenu .ui-state-hover .elfinder-contextmenu-arrow { background-image:url('../img/arrows-active.png'); }
+
+
+
+
+
+

data/app/assets/stylesheets/drg_cms_application.css

@@ -0,0 +1,12 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require drg_cms/drg_cms
+*/

data/app/assets/stylesheets/drg_cms_cms.css

@@ -0,0 +1,26 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require drg_cms/drg_cms
+ *= require drg_cms/jquery.datetimepicker.css
+ *= #require jquery-ui/all  
+ *= require jquery-ui/tooltip
+ *= require jquery-ui/autocomplete
+ *= #require ../javascripts/drg_cms/elfinder/css/elfinder.min.css
+ *= #require ../javascripts/drg_cms/elfinder/css/theme.css
+*/
+
+
+/* IMPORTANT
+
+  Don't forget to update elfinder.min.css and replace all occurences of ../img/ with /assets/elfinder/
+  and copy elfinder/img to images/elfinder folder. 
+
+*/   

data/app/controllers/cmsedit_controller.rb

@@ -0,0 +1,673 @@
+#coding: utf-8
+#--
+# 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
+# "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.
+#++
+
+class CmseditController < DcApplicationController
+#before_filter :check_authorization, :except => [:login]
+before_action :check_authorization, :except => [:show, :login]
+
+########################################################################
+# check_sort_options
+########################################################################
+def check_sort_options()
+  table_name = @tables.first[1]
+  old_sort = session[table_name][:sort].to_s
+  sort, direction = old_sort.split(' ')
+# sort is requested
+  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]
+  params['sort'] = nil # otherwise there is problem with other links
+end
+
+########################################################################
+# check_filter_options. As simple as possible
+########################################################################
+def check_filter_options()
+  table_name = @tables.first[1]
+  session[table_name] ||= {}
+# process page
+  session[table_name][:page] = params[:page] if params[:page]
+# new filter is applied
+  if params[:filter]
+    session[table_name][:filter] =
+    if params[:filter] == 'off' # clear all values
+      nil
+    else
+      [ params[:filter_field], params[:filter_oper], params[:record][params[:filter_field]] ].join("\t")
+    end
+    session[table_name][:page] = 1
+    params[:filter] = nil # must be. Otherwise kaminari includes parameter on paging and everything goes wrong
+  end
+# if data model has field dc_site_id ensure that only records which belong to the site
+# are selected.
+  t = @tables.first[0]
+  site_id = dc_get_site._id if dc_get_site
+# dont't filter site if no dc_site_id field or user is ADMIN
+  site_id = nil if !t.method_defined?('dc_site_id') or dc_user_can(DcPermission::CAN_ADMIN)
+  if session[table_name][:filter]
+    field, oper, value = session[table_name][:filter].split( "\t")
+    value = /#{value}/ if oper == 'like' # change to regex if like
+    @records =  if site_id
+      t.where(dc_site_id: site_id, field => value)
+    else
+      t.where(field => value)
+    end
+  else
+    @records = if site_id
+      t.where(dc_site_id: site_id)
+    else
+      t
+    end
+  end
+# pagination if required
+  per_page = (@form['result_set']['per_page'] || 30).to_i
+  if per_page > 0
+    @records = @records.page(session[table_name][:page]).per(per_page)
+  end
+end
+
+########################################################################
+# Index action.
+########################################################################
+def index
+# If result_set is not defined on form, then it will fail. :return_to should know where to go
+  return process_return_to(params[:return_to]) if @form['result_set'].nil?
+#  
+  if @form['result_set']['filter']
+    if respond_to?(@form['result_set']['filter'])
+      @records = send @form['result_set']['filter']
+    else
+      p "Error: result_set:filter: #{@form['result_set']['filter']} not found in controls!"
+    end
+  else
+    if @tables.size == 1 # for now enable only filtering of main tables
+      check_filter_options()
+      check_sort_options()
+    else
+      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
+      @records = rec.send(@tables.last[1].pluralize)   # current embedded set
+# 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
+    end
+  end
+#
+  respond_to do |format|
+    format.html { render action:  :index }
+    format.js   { render partial: :result }
+  end
+end
+
+########################################################################
+# Filter
+########################################################################
+def filter
+  index
+end
+
+########################################################################
+# Show is (ab)used to do some usefull things
+########################################################################
+def show
+  case
+  when params[:id].in?(%w(login logout)) then # show login menu
+    session[:edit_mode] = 0 
+#    dc_collect_menu_forms
+    render action: 'show', layout: 'cms'
+#  when params[:id] == 'copy_clipboard'
+#    return copy_clipboard
+#  when params[:id] == 'paste_clipboard'
+#    return paste_clipboard
+  end
+end
+
+########################################################################
+# Show is used to display menu
+########################################################################
+def login
+#  session[:edit_mode] = 0 if params[:id].in? %w(login logout) # show login menu
+#  dc_collect_menu_forms
+  render action: 'show', layout: 'cms'
+end
+
+########################################################################
+# New action
+########################################################################
+def new
+  if (m = callback_method('before_new') )
+    ret = call_callback_method(m)
+# Don't do anything if return is false
+    return index if ret.class == FalseClass
+  end  
+# clear flash messages.
+  flash[:error] = flash[:warning] = flash[:info] = nil 
+  create_new_empty_record
+  table = @tables.last[1] + '.'
+# initial values set on page
+  if cookies[:record] and cookies[:record].size > 0
+    Marshal.load(cookies[:record]).each do |k,v|
+      k = k.to_s
+      if k.match(table)
+        field = k.split('.').last
+        @record.send("#{field}=", v) if @record.respond_to?(field)
+      end
+    end
+  end
+# initial values set in url
+  params.each do |k,v|
+    if k.match(table)
+      field = k.split('.').last
+      @record.send("#{field}=", v) if @record.respond_to?(field)
+    end
+  end
+# This is how we set default values for new record
+  dc_new_record() if respond_to?('dc_new_record') 
+  @parms['action'] = 'create'
+end
+
+########################################################################
+# duplicate_record. For now not needed
+########################################################################
+=begin
+def duplicate_record(source, dest)
+# params['dup_fields'] += ',' if params['dup_fields'] # for easier field matching
+  source.attribute_names.each do |attr_name|
+    next if attr_name == '_id'
+    p [attr_name, source[attr_name].class]
+    if source[attr_name].class == Array
+#      dest.save
+       source[attr_name].each do |a|
+         p a
+         rec = dest.send(source[attr_name]).new
+         duplicate_record(a, rec)
+         rec.save!
+       end
+    else
+# if duplicate string must be added. Usefull for unique attributes
+      add_duplicate = params['dup_fields'].to_s.match(attr_name + ',')
+      p ["*",add_duplicate]
+      dest.send("#{attr_name}=", source[attr_name])# + (add_duplicate ? ' duplicate' : '')) if source[attr_name] # can be nil
+    end
+  end
+  dest.save!
+end
+=end
+
+########################################################################
+# 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')
+    return index
+  end
+#
+  if params['id'].nil? # create record
+    create_new_empty_record
+    params[:return_to] = 'index' if params[:commit] == t('drgcms.save&back') # save & back
+    if save_data
+      @parms['action'] = 'update'
+      @parms['id'] = @record.id     # must be set, for proper update link
+      flash[:info] = t('drgcms.doc_saved')
+      return process_return_to(params[:return_to]) if params[:return_to]
+      render action: :edit
+    else
+      render action: :new
+    end
+  else # duplicate record
+    find_record
+    #create_new_empty_record
+    #duplicate_record(@source, @record)
+    dup = @record.dup
+    dup.created_at = Time.now if dup.respond_to?('created_at') # yep it is also duplicated
+
+    params['dup_fields'].to_s.split(',').each do |df|
+      dup[df] = dup[df] + ' duplicate' if dup.respond_to?(df) # avoid errors
+    end
+    update_standards(dup)
+    dup.save!
+    index
+  end
+end
+
+########################################################################
+# Edit action.
+########################################################################
+def edit
+  find_record
+  if (m = callback_method('before_edit') )
+    ret = call_callback_method(m)
+# Don't do anything if return is false
+    return index if ret.class == FalseClass
+  end  
+  @parms['action'] = 'update'
+end
+
+=begin
+########################################################################
+# TODO Think of better way for loginng and displaying menu
+# Show action.
+########################################################################
+def show
+  find_record
+#  @parms['action'] = 'show'
+end
+=end
+
+########################################################################
+# Update action.
+########################################################################
+def update
+  find_record
+  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 save_data
+      params[:return_to] = 'index' if params[:commit] == t('drgcms.save&back') # save & back
+      @parms['action'] = 'update'
+    end
+# Process return_to link
+    return process_return_to(params[:return_to]) if params[:return_to] 
+  else
+    flash[:error] = t('drgcms.not_authorized')
+  end
+  render action: :edit
+end
+
+########################################################################
+# Destroy document
+########################################################################
+def destroy
+  find_record
+# Which permission is required to delete 
+  permission = if params['operation'].nil?
+    if @record.respond_to?('created_by') # needs can_delete_all if created_by is present and not owner
+      (@record.created_by == session[:user_id]) ? DcPermission::CAN_DELETE : DcPermission::CAN_DELETE_ALL
+    else
+      DcPermission::CAN_DELETE    # by default
+    end
+  else # enable or disable record
+    if @record.respond_to?('created_by')
+      (@record.created_by == session[:user_id]) ? DcPermission::CAN_EDIT : DcPermission::CAN_EDIT_ALL
+    else
+      DcPermission::CAN_EDIT      # by default
+    end
+  end
+  ok2delete = dc_user_can(permission)
+#
+  case
+# not authorized    
+  when !ok2delete then
+    flash[:error] = t('drgcms.not_authorized')
+    return index
+  when params['operation'].nil? then
+# Process before delete callback
+    if (m = callback_method('before_delete') )
+      ret = call_callback_method(m)
+# Don't do anything if return is false
+      return index if ret.class == FalseClass
+    end
+# document deleted
+    if @record.destroy
+      save_journal(:delete)
+      flash[:info] = t('drgcms.record_deleted')
+# Process after delete callback
+      if (m = callback_method('after_delete') ) then call_callback_method(m) end
+# Process return_to link
+      return process_return_to(params[:return_to]) if params[:return_to]
+    else
+      flash[:error] = dc_error_messages_for(@record)
+    end
+    return index
+# deaktivate document    
+  when params['operation'] == 'disable' then
+    if @record.respond_to?('active')
+      @record.active = false
+      save_journal(:update, @record.changes)
+      update_standards()
+      @record.save
+      flash[:info] = t('drgcms.doc_disabled')
+    end
+# reaktivate document
+  when params['operation'] == 'enable' then
+    if @record.respond_to?('active')
+      @record.active = true
+      update_standards()
+      save_journal(:update, @record.changes)
+      @record.save
+      flash[:info] = t('drgcms.doc_enabled')
+    end
+  end
+#
+  @parms['action'] = 'update'
+  render action: :edit
+end
+
+protected
+
+########################################################################
+# Processes on_save_ok form directive. Data is saved to session for
+# safety reasons.
+########################################################################
+def process_on_save_ok
+  session[:on_save_ok_id]     = @record_id
+  session[:on_save_ok_commit] = params[:commit]
+  eval(params[:on_save_ok])
+end
+
+########################################################################
+# Merges two forms. 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
+
+########################################################################
+# Read yaml form file
+########################################################################
+def read_yaml
+  table_name = decamelize_type(params[:table].strip)
+  @tables = table_name.split(';').inject([]) { |r,v| r << [v.classify.constantize, v] }
+# split ids passed when embedded document
+  ids = params[:ids].to_s.strip.downcase
+  @ids = ids.split(';').inject([]) { |r,v| r << v }
+# formname defaults to last table specified
+  formname = params[:formname] || @tables.last[1]
+  @form  = YAML.load_file( dc_find_form_file(formname) )
+# when form extends another form file. 
+  if @form['extend']
+    form = YAML.load_file( dc_find_form_file(@form['extend']) )
+    @form = forms_merge(form, @form)
+  end
+# add readonly key to form if readonly parameter is passed  
+  @form['readonly'] = 1 if @form['readonly'] and %w(1 yes true).include?(@form['readonly'].to_s.downcase.strip)
+#  p '2',@form
+# !!!!!! Always use strings for key names since @parms['table'] != @parms[:table]
+  @parms = { 'table' => table_name, 'ids' => ids, 'formname' => formname,
+             'return_to' => params['return_to'], 'edit_only' => params['edit_only'] }
+end
+
+############################################################################
+# Check if user is authorized for the action.
+# If everything is OK it also loads form definition.
+############################################################################
+def check_authorization
+# Extend class with methods defined in drgcms_controls module. May include embedded forms therefor ; => _ 
+  controls_string = params[:table].gsub(';','_') + '_control'
+  controls = ("DrgcmsControls::#{controls_string.classify}".constantize rescue nil)
+  extend controls if controls 
+# Just show menu
+  return show if params[:action] == 'show'
+# request shouldn't pass
+  if session[:user_roles].nil? or params[:table].to_s.strip.downcase.size < 3
+    return render(action: 'error', locals: { error: t('drgcms.not_authorized')} )
+  end
+
+# If user has permission to view table (collection) load form
+  if dc_user_can(DcPermission::CAN_VIEW)
+    read_yaml
+# Permissions can be also defined on form
+    return if @form['permissions'].nil? or @form['permissions']['can_view'].nil?
+    return if dc_user_has_role(@form['permissions']['can_view'])
+  end
+  render(action: 'error', locals: {error: t('drgcms.not_authorized')} )
+end
+
+########################################################################
+# Find record for edit, update or delete.
+########################################################################
+def find_record
+  if @tables.size == 1
+    @record = @tables.first[0].find(params[:id])
+  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
+    @record = rec.send(@tables.last[1].pluralize).find(params[:id])   # record to edit
+  end
+end
+
+########################################################################
+# Creates new empty record for new and create action.
+########################################################################
+def create_new_empty_record
+  if @tables.size == 1
+    @record = @tables.first[0].new
+  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
+    @record = rec.send(@tables.last[1].pluralize).new   # new record
+  end
+end
+=begin
+########################################################################
+# Get data for multitext_autocomplete field. That is field which is saved as record[kats_****]
+#
+# @param [ name ] Name of field
+########################################################################
+def get_data_multitext_autocomplete(name)
+  r = []
+  params['record'].each do |k,v|
+# if it starts with - then it was removed
+    r << BSON::ObjectId(v) if k.match("#{name}_") and v[0,1] != '-'
+  end
+  r.uniq!
+  r
+end
+=end
+########################################################################
+# update_standard fields like updated_by, created_by
+########################################################################
+def update_standards(record = @record)
+  record.updated_by = session[:user_id] if record.respond_to?('updated_by')
+  if record.new_record?
+    record.created_by = session[:user_id] if record.respond_to?('created_by')
+# set this only initialy. Allow to be set to nil on updates. This documents can then belong to all sites
+# and will be directly visible only to admins
+    record.dc_site_id = dc_get_site._id if record.respond_to?('dc_site_id') and record.dc_site_id.nil?
+  end
+end
+
+########################################################################
+# Since tabs have been introduced on form it is a little more complicated
+# to get all active field names on form. This method does it.
+########################################################################
+def fields_on_form()
+  fields = []
+  if @form['form']['fields']
+# second element of array is hash. Get only hash element
+    @form['form']['fields'].each {|field| fields << field[1]}
+  else
+    @form['form']['tabs'].keys.each do |key|
+      @form['form']['tabs'][key].each {|field| fields << field[1]}
+    end  
+  end
+  fields
+end
+
+########################################################################
+# Save changes to journal table. Saves all parameters to retrive record if needed.
+#
+# @example usage before save
+#   save_journal(@record.changes)
+# @example usage on delete
+#   save_journal(true)
+#
+# @param [ changes ] Changes for the record
+########################################################################
+def save_journal(operation, changes = {})
+#  return unless session[:save_journal]
+  if operation == :delete
+    @record.attributes.each {|k,v| changes[k] = v}
+#  elsif operation == :new
+#    changes = {}
+  end
+#
+  if (operation != :update) or changes.size > 0
+# determine site_id
+    site_id = @record.site_id if @record.respond_to?('site_id')
+    site_id = dc_get_site._id if site_id.nil? and dc_get_site
+    DcJournal.create(site_id: site_id,
+                     operation: operation,
+                     user_id: session[:user_id],
+                     tables:  params[:table],
+                     ids:     params[:ids],
+                     doc_id:  params[:id],
+                     ip:      request.remote_ip,
+                     time:    Time.now,
+                     diff:    changes.to_json)
+  end
+end
+
+########################################################################
+# Determines if callback method is defined in parameters or in model. 
+# Returns callback method name or nil if not defined.
+########################################################################
+def callback_method(key)
+  data_key = key.gsub('_','-') # data fields translate _ to -
+  cb = case
+    when params['data'] && params['data'][data_key] then params['data'][data_key]
+# if dc_ + key method is present in model then it will be called automatically     
+    when respond_to?('dc_' + key) then 'dc_' + key
+    when params[key] then params[key]
+    else nil
+  end
+#  p [ '***********************',key, cb, params['data'],params['key']]
+#  
+  ret = case
+    when cb.nil? then cb # otherwise there will be errors in next lines
+    when cb.match('eval ') then cb.sub('eval ','')
+    when cb.match('return_to ')
+      params[:return_to] = cb.sub('return_to ','')
+      return nil
+    else cb
+  end
+  ret
+end
+
+########################################################################
+# Calls callback method.
+########################################################################
+def call_callback_method(m)
+  send(m) if respond_to?(m)  
+end
+
+########################################################################
+# Same as javascript_tag helper
+########################################################################
+def js_tag(script)
+  "<script type=\"text/javascript\">#{script}</script>"
+end
+
+########################################################################
+# Process return_to parameter when set on a form or set by callbacks.
+########################################################################
+def process_return_to(return_to)
+  script = case
+    when return_to == 'index' then return index
+    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;'
+    else "location.href='#{return_to}'"
+  end
+  render text: js_tag(script)
+end
+
+########################################################################
+# Save_data. Save only fields on form.
+########################################################################
+def save_data
+  fields = fields_on_form()
+  p fields
+  return true unless fields.size > 0
+#
+  fields.each do |v|
+    next if v['type'].match('embedded') # don't wipe embedded fields
+    next if params[:edit_only] and params[:edit_only] != v['name'] # otherwise other fields would be wiped
+    next unless @record.respond_to?(v['name']) # there can be temporary fields on the form
+#
+# TODO I used to ignore readonly fields. check if this is OK
+#    next if v['type'] == 'readonly' or v['readonly'] # ignore readonly fields
+# return value from form field definition
+    value = DrgcmsFormField.const_get(v['type'].camelize).get_data(params, v['name'])
+    @record.send("#{v['name']}=", value)
+  end
+#
+  update_standards()
+  operation = @record.new_record? ? :new : :update
+# callback methods
+  if (m = callback_method('before_save') )
+    ret = call_callback_method(m)
+# dont's save if callback method returns false    
+    return false if ret.class == FalseClass
+  end
+# check if model has dc_before_save method
+  @record.dc_before_save(self) if @record.respond_to?('dc_before_save')
+#
+  changes = @record.changes
+  if (saved = @record.save)
+    save_journal(operation, changes)
+# callback methods
+    if (m = callback_method('after_save') ) then call_callback_method(m)  end
+# check if model has dc_after_save method
+    @record.dc_after_save(self) if @record.respond_to?('dc_after_save')
+  end
+  saved
+end
+
+########################################################################
+# Returns true if model has field defined. This might be defined by mongoid,
+# but I didn't found method.
+#
+# @param [model] Model object
+# @param [field_name] Field name to be checked
+########################################################################
+def model_has_field?(model, field_name)
+  model.fields.each {|f| return true if f.first == field_name.to_s}
+  false
+end
+
+end