rails_db_admin 3.0.0 → 3.2.0

data/app/assets/javascripts/erp_app/shared/rails_db_admin_shared.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require_tree .

data/{public/stylesheets/erp_app/desktop/applications/rails_db_admin/rails_db_admin.css → app/assets/stylesheets/erp_app/shared/rails_db_admin_shared.css}

@@ -1,14 +1,9 @@
 .icon-rails_db_admin {
-    background-image:url( /images/icons/rails_db_admin/rails_db_admin_16x16.png ) !important;
-    filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='/images/icons/rails_db_admin/rails_db_admin_16x16.png', sizingMethod='crop');
+    background-image:url( /assets/icons/rails_db_admin/rails_db_admin_16x16.png ) !important;
+    filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='/assets/icons/rails_db_admin/rails_db_admin_16x16.png', sizingMethod='crop');
 }
 
 .icon-rails_db_admin-light {
-    background-image:url( /images/icons/rails_db_admin/rails_db_admin_light_16x16.png ) !important;
-    filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='/images/icons/rails_db_admin/rails_db_admin_16x16.png', sizingMethod='crop');
-}
-
-
-
-
-
+    background-image:url( /assets/icons/rails_db_admin/rails_db_admin_light_16x16.png ) !important;
+    filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='/assets/icons/rails_db_admin/rails_db_admin_16x16.png', sizingMethod='crop');
+}

data/app/controllers/rails_db_admin/erp_app/desktop/base_controller.rb

@@ -93,6 +93,7 @@ module RailsDbAdmin
           start = params[:start] || 0
           limit = params[:limit] || 30
           table = params[:table]
+          query_filter = params[:query_filter] || ''
 
           order = nil
 
@@ -102,7 +103,7 @@ module RailsDbAdmin
             order = 'created_at desc'
           end
 
-          @json_data_builder.build_json_data(:table => table, :limit => limit, :offset => start, :order => order)
+          @json_data_builder.build_json_data(:table => table, :limit => limit, :offset => start, :order => order, :query_filter => query_filter)
         end
 
         def create_table_row
@@ -129,15 +130,15 @@ module RailsDbAdmin
 
           if @table_support.primary_key?(table)
             id = @table_support.primary_key(table)
-            id[1] = params[:data][0][id[0]]
-            params[:data][0].delete(id[0])
+            id[1] = params[:data]['id']
+            params[:data].delete('id')
 
-            @table_support.update_table(table, id, params[:data][0])
+            @table_support.update_table(table, id, params[:data])
             record = @json_data_builder.get_row_data(table, id)
           else
-            fake_id = params[:data][0]['fake_id']
+            fake_id = params[:data]['fake_id']
             @table_support.update_table_without_id(table, params[:data])
-            record = @json_data_builder.get_row_data_no_id(table, params[:data][0])
+            record = @json_data_builder.get_row_data_no_id(table, params[:data])
             record['fake_id'] = fake_id
           end
 

data/app/controllers/rails_db_admin/erp_app/desktop/queries_controller.rb

@@ -5,7 +5,7 @@ module RailsDbAdmin
 
         def save_query
           query = params[:query]
-          query_name  = params[:query_name]
+          query_name = params[:query_name]
 
           @query_support.save_query(query, query_name)
 
@@ -25,7 +25,7 @@ module RailsDbAdmin
         end
 
         def delete_query
-          query_name  = params[:query_name]
+          query_name = params[:query_name]
           @query_support.delete_query(query_name)
 
           render :json => {:success => true}
@@ -51,16 +51,12 @@ module RailsDbAdmin
         end
 
         def open_and_execute_query
-          result = {}
           query_name = params[:query_name]
 
           query = @query_support.get_query(query_name)
           columns, values, exception = @query_support.execute_sql(query)
 
-          if columns.blank? || values.blank?
-            result = {:success => false, :query => query,
-              :exception => "Empty result set"}
-          elsif exception.nil?
+          if exception.nil?
 
             columns_array = columns.collect do |column|
               RailsDbAdmin::Extjs::JsonColumnBuilder.build_readonly_column(column)
@@ -71,11 +67,11 @@ module RailsDbAdmin
             end
 
             result = {:success => true, :query => query,
-              :columns => columns_array,
-              :fields => fields_array, :data => values}
+                      :columns => columns_array,
+                      :fields => fields_array, :data => values}
           else
             result = {:success => false, :query => query,
-              :exception => exception.gsub("\n", " ")}
+                      :exception => exception.gsub("\n", " ")}
           end
 
           render :json => result
@@ -88,85 +84,103 @@ module RailsDbAdmin
           columns = @database_connection_class.connection.columns(table)
 
           render :json => {:success => true,
-            :sql => sql,
-            :columns => RailsDbAdmin::Extjs::JsonColumnBuilder.build_grid_columns(columns),
-            :fields => RailsDbAdmin::Extjs::JsonColumnBuilder.build_store_fields(columns),
-            :data => results}
+                           :sql => sql,
+                           :columns => RailsDbAdmin::Extjs::JsonColumnBuilder.build_grid_columns(columns),
+                           :fields => RailsDbAdmin::Extjs::JsonColumnBuilder.build_store_fields(columns),
+                           :data => results}
         end
 
         def execute_query
-          sql = params[:sql]
-          selection = params[:selected_sql]
-          sql = sql.rstrip
-          cursor_pos = params[:cursor_pos].to_i
-
-          #append a semicolon as the last character if the
-          #user forgot
-          if !sql.end_with?(";")
-            sql << ";"
-          end
+          begin
 
-          sql_arr = sql.split("\n")
-          sql_stmt_arry = []
-          sql_str = ""
-
-          #search for the query to run based on cursor position if there
-          #was nothing selected by the user
-          if (selection == nil || selection == "")
-            last_stmt_end = 0
-            sql_arr.each_with_index do |val,idx|
-              if val.match(';')
-                sql_stmt_arry << {:begin => (sql_stmt_arry.length > 0) ? last_stmt_end +1 : 0, :end => idx}
-                last_stmt_end = idx
-              end
+            sql = params[:sql]
+            selection = params[:selected_sql]
+            sql = sql.rstrip
+            cursor_pos = params[:cursor_pos].to_i
+
+            # if we have report params process them
+            if params[:report_params]
+              # add current_user to locals
+              params[:report_params][:current_user] = current_user
+
+              sql = RailsDbAdmin::ErbStringParser.render(sql, locals: params[:report_params])
             end
 
-            last_sql_stmt = sql_stmt_arry.length-1
-            #run the first complete query if we're in whitespace
-            #at the beginning of the text area
-            if cursor_pos <= sql_stmt_arry[0].fetch(:begin)
-              sql_str = sql_arr.values_at(sql_stmt_arry[0].fetch(:begin)..
-                sql_stmt_arry[0].fetch(:end)).join(" ")
-              #run the last query if we're in whitespace at the end of the
-              #textarea
-            elsif cursor_pos > sql_stmt_arry[last_sql_stmt].fetch(:begin)
-              sql_str = sql_arr.values_at(
-                sql_stmt_arry[last_sql_stmt].fetch(:begin)..
-                sql_stmt_arry[last_sql_stmt].fetch(:end)).join(" ")
-              #run query based on cursor position
-            else
-              sql_stmt_arry.each do |sql_stmt|
-                if cursor_pos >= sql_stmt.fetch(:begin) &&
-                    cursor_pos <= sql_stmt.fetch(:end)
-                  sql_str = sql_arr.values_at(sql_stmt.fetch(:begin)..
-                    sql_stmt.fetch(:end)).join(" ")
+            # append a semicolon as the last character if the
+            # user forgot
+            if !sql.end_with?(";")
+              sql << ";"
+            end
+
+            sql_arr = sql.split("\n")
+            sql_stmt_arry = []
+            sql_str = ""
+
+            #search for the query to run based on cursor position if there
+            #was nothing selected by the user
+            if (selection == nil || selection == "")
+              last_stmt_end = 0
+              sql_arr.each_with_index do |val, idx|
+                if val.match(';')
+                  sql_stmt_arry << {:begin => (sql_stmt_arry.length > 0) ? last_stmt_end +1 : 0, :end => idx}
+                  last_stmt_end = idx
                 end
               end
+
+              last_sql_stmt = sql_stmt_arry.length-1
+              #run the first complete query if we're in whitespace
+              #at the beginning of the text area
+              if cursor_pos <= sql_stmt_arry[0].fetch(:begin)
+                sql_str = sql_arr.values_at(sql_stmt_arry[0].fetch(:begin)..
+                                                sql_stmt_arry[0].fetch(:end)).join(" ")
+                #run the last query if we're in whitespace at the end of the
+                #textarea
+              elsif cursor_pos > sql_stmt_arry[last_sql_stmt].fetch(:begin)
+                sql_str = sql_arr.values_at(
+                    sql_stmt_arry[last_sql_stmt].fetch(:begin)..
+                        sql_stmt_arry[last_sql_stmt].fetch(:end)).join(" ")
+                #run query based on cursor position
+              else
+                sql_stmt_arry.each do |sql_stmt|
+                  if cursor_pos >= sql_stmt.fetch(:begin) &&
+                      cursor_pos <= sql_stmt.fetch(:end)
+                    sql_str = sql_arr.values_at(sql_stmt.fetch(:begin)..
+                                                    sql_stmt.fetch(:end)).join(" ")
+                  end
+                end
+              end
+            else
+              sql_str = selection
             end
-          else
-            sql_str = selection
-          end
 
-          columns, values, exception = @query_support.execute_sql(sql_str)
+            columns, values, exception = @query_support.execute_sql(sql_str)
 
-          if !exception.nil?
-            result = {:success => false, :exception => exception.gsub("\n"," ")}
-          elsif columns.empty? || values.empty?
-            result = {:success => false, :exception => "Empty result set"}
-          else exception.nil?
-            columns_array = columns.collect do |column|
-              RailsDbAdmin::Extjs::JsonColumnBuilder.build_readonly_column(column)
-            end
+            if !exception.nil?
+              result = {:success => false, :message => exception.gsub("\n", " ")}
+            else
+              exception.nil?
+              columns_array = columns.collect do |column|
+                RailsDbAdmin::Extjs::JsonColumnBuilder.build_readonly_column(column)
+              end
 
-            fields_array = columns.collect do |column|
-              {:name => column}
+              fields_array = columns.collect do |column|
+                {:name => column}
+              end
+
+              result = {:success => true, :sql => sql,
+                        :columns => columns_array,
+                        :fields => fields_array, :data => values}
             end
+            render :json => result
+          rescue StandardError => ex
+            Rails.logger.error ex.message
+            Rails.logger.error ex.backtrace.join("\n")
+
+            # email notification
+            ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
 
-            result = {:success => true, :sql => sql,
-              :columns => columns_array,
-              :fields => fields_array, :data => values}
+            render :json => {success: false, message: ex.message}
           end
-          render :json => result
         end
 
       end #QueriesController

data/app/controllers/rails_db_admin/erp_app/desktop/reports_controller.rb

@@ -3,43 +3,121 @@ module RailsDbAdmin
     module Desktop
       class ReportsController < QueriesController
 
-        def index
-          reports = Report.all.collect{ |report|{:text => report.name, :id => report.id,
-                                                 :uniqueName => report.internal_identifier,
-                                                 :iconCls => 'icon-document', :leaf => true} }
+        before_filter :set_file_support
 
-          render :json => reports
+        def index
+          if params[:node] == 'root_node'
+            setup_tree
+          else
+            node = File.join(@file_support.root, params[:node])
+            report = get_report(params[:node])
+            unless report.nil?
+              render :json => @file_support.build_tree(node, :file_asset_holder => report, :preload => true)
+            else
+              render :json => {:success => false, :message => 'Could not find report'}
+            end
+          end
         end
 
         def create
-          name = params[:name]
-          internal_identifier = params[:internal_identifier]
+          begin
+            ActiveRecord::Base.transaction do
+
+              if params[:report_data].present?
+                Report.import(params[:report_data])
+                render :inline => {:success => true}.to_json
+              else
+                name = params[:name]
+                internal_identifier = params[:internal_identifier]
+                report = Report.new(:name => name, :internal_identifier => internal_identifier)
+
+                report.save!
+
+                render :json => {:success => true}
+              end
+
+            end
+          rescue ActiveRecord::RecordInvalid => invalid
+            Rails.logger.error invalid.record.errors.full_messages
+
+            render json: {success: false, message: invalid.record.errors.full_messages.join('</br>')}
+
+          rescue StandardError => ex
+            Rails.logger.error ex.message
+            Rails.logger.error ex.backtrace.join("\n")
+
+            ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+            render json: {success: false, message: 'Error creating report'}
 
-          report = Report.new(:name => name, :internal_identifier => internal_identifier)
-          if report.save
-            render :json => {:success => true}
-          else
-            render :json => {:success => false, :msg => 'Error creating report'}
           end
         end
 
-        def edit
-          id  = params[:id]
+        def query
+          render :json => {success: true, query: Report.find(params[:id]).query}
+        end
 
-          report = Report.find(id)
+        def update
+          begin
+            ActiveRecord::Base.transaction do
+              report = Report.find(params[:id])
+
+              report.meta_data['print_page_size'] = params[:print_page_size].strip if params[:print_page_size]
+              report.meta_data['print_margin_top'] = params[:print_margin_top].strip if params[:print_margin_top]
+              report.meta_data['print_margin_right'] = params[:print_margin_right].strip if params[:print_margin_right]
+              report.meta_data['print_margin_bottom'] = params[:print_margin_bottom].strip if params[:print_margin_bottom]
+              report.meta_data['print_margin_left'] = params[:print_margin_left].strip if params[:print_margin_left]
+              report.meta_data['print_orientation'] = params[:print_orientation].strip if params[:print_orientation]
+              report.meta_data['auto_execute'] = params['auto_execute'] == 'on'
+
+              unless params[:report_name].blank?
+                report.name = params[:report_name].squish
+              end
+
+              unless params[:report_iid].blank?
+                report.internal_identifier = params[:report_iid].squish
+              end
+
+              if params.key?(:report_params)
+                report.meta_data['params'] = params[:report_params].nil? ? [] : params[:report_params]
+              end
+
+              report_roles = params[:report_roles]
+              if report_roles
+                available_role_types = report.role_types.pluck(:internal_identifier)
+                # delete all roles associated with the report
+                report.entity_party_roles.destroy_all
+
+                # assign report roles
+                report_roles.split(',').each do |role_type|
+                  report.add_party_with_role(
+                      current_user.party,
+                      RoleType.iid(role_type)
+                  ) unless available_role_types.include?(role_type.to_sym)
+                end
+              end
+
+              render json: {success: report.save!}
+
+            end
+          rescue ActiveRecord::RecordInvalid => invalid
+            Rails.logger.error invalid.record.errors.full_messages
+
+            render json: {success: false, message: invalid.record.errors.full_messages.join('</br>')}
+
+          rescue StandardError => ex
+            Rails.logger.error ex.message
+            Rails.logger.error ex.backtrace.join("\n")
+
+            ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+            render json: {success: false, message: 'Could not save report'}
 
-          if report
-            render :json => {:success => true, :report =>
-                {:title => report.name, :id => report.id, :query => report.query,
-                 :internalIdentifier => report.internal_identifier, :template => report.template}
-            }
-          else
-            render :json => {:success => false}
           end
         end
 
         def save
-          id  = params[:id]
+          id = params[:id]
           query = params[:query]
           template = params[:template]
 
@@ -55,16 +133,199 @@ module RailsDbAdmin
           end
         end
 
-        def delete
-          id  = params[:id]
+        def save_query
+          id = params[:id]
+          query = params[:query]
+
+          report = Report.find(id)
+
+          report.query = query
+
+          if report.save
+            render :json => {:success => true}
+          else
+            render :json => {:success => false}
+          end
+        end
 
-          if Report.find(id).destroy
+        def delete
+          report = Report.find(params[:id])
+          if report.destroy
             render :json => {:success => true}
           else
             render :json => {:success => false}
           end
         end
 
+        def export
+          report = Report.find(params[:id])
+          zip_path = report.export
+          send_file(zip_path.to_s, :stream => false) rescue raise "Error sending #{zip_path} file"
+        end
+
+        def create_file
+          begin
+            path = File.join(@file_support.root, params[:path])
+            name = params[:name]
+
+            report = get_report(path)
+            report.add_file('#Empty File', File.join(path, name))
+
+            render :json => {:success => true, :node => @file_support.find_node(File.join(path, name), {:file_asset_holder => report})}
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def create_folder
+          begin
+            path = File.join(@file_support.root, params[:path])
+            name = params[:name]
+            @file_support.create_folder(path, name)
+            render :json => {:success => true, :node => @file_support.find_node(File.join(path, name), {keep_full_path: false})}
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def update_file
+          begin
+            path = File.join(@file_support.root, params[:node])
+            content = params[:content]
+            @file_support.update_file(path, content)
+            nodes = params[:node].split('/')
+            if nodes.last == 'base.html.erb'
+              report = Report.iid(nodes[nodes.index("compass_ae_reports") + 1])
+              report.template = content
+              report.save
+            end
+            render :json => {:success => true}
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def save_move
+          result = {}
+          nodes_to_move = (params[:selected_nodes] ? JSON(params[:selected_nodes]) : [params[:node]])
+          begin
+            nodes_to_move.each do |node|
+              path = File.join(@file_support.root, node)
+              new_parent_path = File.join(@file_support.root, params[:parent_node])
+
+              unless @file_support.exists? path
+                result = {:success => false, :msg => 'File does not exist.'}
+              else
+                report_file = get_report_file(path)
+                report_file.move(params[:parent_node])
+                result = {:success => true, :msg => "#{File.basename(path)} was moved to #{new_parent_path} successfully"}
+              end
+            end
+            render :json => result
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def get_contents
+          path = File.join(@file_support.root, params[:node])
+          contents, message = @file_support.get_contents(path)
+
+          if contents.nil?
+            render :text => message
+          else
+            render :text => contents
+          end
+        end
+
+        def download_file
+          begin
+            path = File.join(@file_support.root, params[:path])
+            contents, message = @file_support.get_contents(path)
+
+            send_data contents, :filename => File.basename(path)
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def upload_file
+          begin
+            result = {}
+            upload_path = params[:directory]
+            name = params[:name]
+            data = request.raw_post
+
+            report = get_report(upload_path)
+            name = File.join(@file_support.root, upload_path, name)
+
+            begin
+              report.add_file(data, name)
+              result = {:success => true, :node => @file_support.find_node(name, {:file_asset_holder => report})}
+            rescue => ex
+              logger.error ex.message
+              logger.error ex.backtrace.join("\n")
+              result = {:success => false, :error => "Error uploading #{name}"}
+            end
+
+            render :inline => result.to_json
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def delete_file
+          messages = []
+          nodes_to_delete = (params[:selected_nodes] ? JSON(params[:selected_nodes]) : [params[:node]])
+          begin
+            result = false
+            nodes_to_delete.each do |path|
+              begin
+                name = File.basename(path)
+                result, message, is_folder = @file_support.delete_file(File.join(@file_support.root, path), {force: true})
+                if result && !is_folder
+                  report_file = get_report_file(path)
+                  report_file.destroy
+                end
+                messages << message
+              rescue StandardError => ex
+                Rails.logger.error ex.message
+                Rails.logger.error ex.backtrace.join("\n")
+
+                ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+                render :json => {:success => false, :error => "Error deleting #{name}"} and return
+              end
+            end # end nodes_to_delete.each
+            if result
+              render :json => {:success => true, :message => messages.join(',')}
+            else
+              render :json => {:success => false, :error => messages.join(',')}
+            end
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def rename_file
+          begin
+            result = {:success => true, :data => {:success => true}}
+            path = params[:node]
+            name = params[:file_name]
+
+            result, message = @file_support.rename_file(File.join(@file_support.root, path), name)
+            if result
+              report_file = get_report_file(path)
+              report_file.name = name
+              report_file.save
+            end
+
+            render :json => {:success => true, :message => message}
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability => ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
         def open_query
           query_name = params[:query_name]
           query = @query_support.get_query(query_name)
@@ -72,7 +333,77 @@ module RailsDbAdmin
           render :json => {:success => true, :query => query}
         end
 
-      end #QueriesController
-    end #Desktop
-  end #ErpApp
-end #RailsDbAdmin
+        def setup_tree
+          tree = []
+          Report.all.collect do |report|
+            report_data = build_report_data(report)
+
+            ['stylesheets', 'images', 'templates', 'javascripts', 'query'].each do |resource_folder|
+              report_data[:children] << {
+                  :reportId => report.id,
+                  :reportName => report.name,
+                  :reportIid => report.internal_identifier,
+                  :text => resource_folder.titleize,
+                  :iconCls => case resource_folder
+                                when 'query'
+                                  'icon-query'
+                                else
+                                  'icon-content'
+                              end,
+                  :id => "#{report.url}/#{resource_folder}",
+                  :leaf => (resource_folder == 'query'),
+                  :handleContextMenu => (resource_folder == 'query') || (resource_folder == 'preview_report')
+              }
+            end
+
+            tree << report_data
+          end
+
+          render :json => tree
+        end
+
+        def get_report(path)
+          reports_index = path.index('reports')
+          path = path[reports_index..path.length]
+          report_name = path.split('/')[1]
+          @report = Report.iid(report_name)
+
+          @report
+        end
+
+        def get_report_file(path)
+          report = get_report(path)
+          file_dir = ::File.dirname(path).gsub(Regexp.new(Rails.root.to_s), '')
+          report.files.where('name = ? and directory = ?', ::File.basename(path), file_dir).first
+        end
+
+        def set_file_support
+          @file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::Config.file_storage)
+        end
+
+        private
+
+        def build_report_data(report)
+          meta_data = report.meta_data || {}
+          meta_data.merge!({
+                               params: report.meta_data['params'] || [],
+                               roles: report.role_types.pluck(:internal_identifier).join(','),
+                           })
+
+          {
+              text: report.name,
+              reportName: report.name,
+              reportId: report.id,
+              internalIdentifier: report.internal_identifier,
+              iconCls: 'icon-content',
+              isReport: true,
+              handleContextMenu: true,
+              children: [],
+              reportMetaData: meta_data
+          }
+        end
+
+      end # ReportsController
+    end # Desktop
+  end # ErpApp
+end # RailsDbAdmin