🔖 Libera la versión 2.2.1

Se ajustan los div's #wrapper y #content aprovechando que al maximizar
el editor los bloques principales se quedan sin clases. Básicamente se
asegura de que quedan debajo del editor. Las líneas #wiki_form... se
incluyen sólo por estética, para evitar la visualización de algunos
elementos del formulario del wiki por debajo de la línea de separación
del editor.

Resuelve #527

.gitignore

@@ -1,2 +0,0 @@
-.vscode
-config/database.yml

.hgignore

@@ -1,43 +0,0 @@
-syntax: glob
-
-.project
-.idea
-.loadpath
-.powrc
-.rvmrc
-.ruby-version
-config/additional_environment.rb
-config/configuration.yml
-config/database.yml
-config/email.yml
-config/secrets.yml
-config/initializers/session_store.rb
-config/initializers/secret_token.rb
-coverage
-db/*.db
-db/*.sqlite3
-db/schema.rb
-files/*
-lib/redmine/scm/adapters/mercurial/redminehelper.pyc
-lib/redmine/scm/adapters/mercurial/redminehelper.pyo
-log/*.log*
-log/mongrel_debug
-public/dispatch.*
-public/plugin_assets/*
-tmp/*
-tmp/cache/*
-tmp/pdf/*
-tmp/sessions/*
-tmp/sockets/*
-tmp/test/*
-tmp/thumbnails/*
-vendor/cache
-*.rbc
-
-.svn/
-.git/
-
-.bundle
-Gemfile.lock
-Gemfile.local
-

.rubocop.yml

@@ -1,103 +0,0 @@
-inherit_from: .rubocop_todo.yml
-
-AllCops:
-  TargetRubyVersion: 2.3
-  TargetRailsVersion: 5.2
-
-  Exclude:
-    - '**/vendor/**/*'
-    - '**/tmp/**/*'
-    - '**/bin/**/*'
-    - '**/plugins/**/*'
-    - '**/extra/**/*'
-    - '**/lib/generators/**/templates/*'
-    - '**/lib/tasks/**/*'
-    - '**/files/**/*'
-    - 'db/schema.rb'
-
-# Enable extensions
-
-require:
-  - rubocop-performance
-  - rubocop-rails
-
-# Rules for Redmine
-
-Bundler/OrderedGems:
-  Enabled: false
-
-Layout/EmptyLineBetweenDefs:
-  AllowAdjacentOneLineDefs: true
-
-Layout/SpaceBeforeBlockBraces:
-  # "space" is used more than "no_space".
-  # But "no_space" is more natural in one liner.
-  #   str = path.to_s.split(%r{[/\\]}).select{|p| !p.blank?}.join("/")
-  Enabled: false
-
-# You can see results by "rubocop --only Layout/SpaceInsideBlockBraces"
-Layout/SpaceInsideBlockBraces:
-  EnforcedStyle: no_space
-  SpaceBeforeBlockParameters: false
-
-# You can see results by "rubocop --only Layout/SpaceInsideHashLiteralBraces"
-Layout/SpaceInsideHashLiteralBraces:
-  EnforcedStyle: no_space
-
-Layout/TrailingWhitespace:
-  AllowInHeredoc: true
-
-Lint/HandleExceptions:
-  AllowComments: true
-
-Metrics:
-  Enabled: false
-
-Naming/AccessorMethodName:
-  Enabled: false
-
-Naming/BinaryOperatorParameterName:
-  Enabled: false
-
-Naming/PredicateName:
-  Enabled: false
-
-Rails/BulkChangeTable:
-  Exclude:
-    - 'db/migrate/20120714122200_add_workflows_rule_fields.rb'
-    - 'db/migrate/20131214094309_remove_custom_fields_min_max_length_default_values.rb'
-
-Rails/HelperInstanceVariable:
-  Enabled: false
-
-# Configuration parameters: AllowedChars.
-Style/AsciiComments:
-  Exclude:
-    # Copyright credit has non ascii character.
-    # We can not change nor remove it.
-    - 'app/models/repository/git.rb'
-
-Style/FormatStringToken:
-  Enabled: false
-
-Style/FrozenStringLiteralComment:
-  Enabled: true
-  EnforcedStyle: always
-  Exclude:
-    - 'db/**/*.rb'
-    - 'Gemfile'
-    - 'Rakefile'
-    - 'config.ru'
-    - 'config/additional_environment.rb'
-
-Style/HashSyntax:
-  Enabled: true
-  EnforcedStyle: no_mixed_keys
-
-Style/IdenticalConditionalBranches:
-  Exclude:
-    - 'config/initializers/10-patches.rb'
-    - 'lib/redmine/wiki_formatting/textile/redcloth3.rb'
-
-Style/TrailingCommaInArrayLiteral:
-  Enabled: false

CONTRIBUTING.md

@@ -1,10 +0,0 @@
-Your contributions to Redmine are welcome!
-
-Please **open an issue on the [official website]** instead of sending pull requests.
-
-Since the development of Redmine is not conducted on GitHub but on the [official website] and core developers are not monitoring the GitHub repo, pull requests might not get reviewed.
-
-For more detail about how to contribute, please see the wiki page [Contribute] on the [official website].
-
-[official website]: https://www.redmine.org/
-[Contribute]: https://www.redmine.org/projects/redmine/wiki/Contribute

Dockerfile

@@ -0,0 +1,59 @@
+# Usar la imagen oficial de Redmine como base
+FROM redmine:4.1.7
+
+RUN apt-get update && apt-get install -y \
+    shared-mime-info \
+    git \
+    build-essential \
+    mariadb-client \
+    libxml2-dev \
+    libxslt-dev \
+    zlib1g-dev \
+    libpq-dev \
+    libmariadb-dev-compat \
+    libmariadb-dev \
+    libssl-dev \
+    libreadline-dev \
+    libffi-dev \
+    imagemagick \
+    && rm -rf /var/lib/apt/lists/*
+
+# Definir el directorio de trabajo
+WORKDIR /usr/src/redmine
+
+# Copiar archivos personalizados dentro del contenedor
+COPY app/controllers/wiki_controller.rb /usr/src/redmine/app/controllers/wiki_controller.rb
+COPY app/helpers/search_helper.rb /usr/src/redmine/app/helpers/search_helper.rb
+COPY app/views/account/login.html.erb /usr/src/redmine/app/views/account/login.html.erb
+COPY app/views/issues/tabs/_changesets.html.erb /usr/src/redmine/app/views/issues/tabs/_changesets.html.erb
+COPY app/views/layouts/base.html.erb /usr/src/redmine/app/views/layouts/base.html.erb
+COPY app/views/repositories/_changeset.html.erb /usr/src/redmine/app/views/repositories/_changeset.html.erb
+COPY app/views/wiki/show.html.erb /usr/src/redmine/app/views/wiki/show.html.erb
+
+COPY config/database.yml /usr/src/redmine/config/database.yml
+COPY config/secrets.yml /usr/src/redmine/config/secrets.yml
+COPY config/locales/en.yml /usr/src/redmine/config/locales/en.yml
+COPY config/locales/es.yml /usr/src/redmine/config/locales/es.yml
+
+COPY plugins /usr/src/redmine/plugins
+
+COPY public/themes/circlepro /usr/src/redmine/public/themes/circlepro
+
+# Clonar el plugin "rich"
+RUN git clone https://github.com/a-ono/rich.git /usr/src/redmine/vendor/rich
+
+# Establecer permisos adecuados (opcional)
+RUN chown -R redmine:redmine /usr/src/redmine
+
+# Instalar dependencias de Ruby
+RUN bundle install --without development test --path vendor/bundle
+
+# Copiar el backup de la base de datos
+COPY suitepro-backup.sql /suitepro-backup.sql
+
+# Copiar el script de inicialización
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+# Configurar el punto de entrada
+ENTRYPOINT ["/entrypoint.sh"]

Gemfile

@@ -1,102 +0,0 @@
-source 'https://rubygems.org'
-
-ruby '>= 2.3.0', '< 2.7.0' if Bundler::VERSION >= '1.12.0'
-gem "bundler", ">= 1.5.0"
-
-gem 'rails', '5.2.4.2'
-gem 'sprockets', '~> 3.7.2' if RUBY_VERSION < '2.5'
-gem "rouge", "~> 3.12.0"
-gem "request_store", "~> 1.4.1"
-gem "mini_mime", "~> 1.0.1"
-gem "actionpack-xml_parser"
-gem "roadie-rails", (RUBY_VERSION < "2.5" ? "~> 1.3.0" : "~> 2.1.0")
-gem "mimemagic"
-gem "mail", "~> 2.7.1"
-gem "csv", "~> 3.1.1"
-gem "nokogiri", "~> 1.10.0"
-gem "i18n", "~> 1.6.0"
-gem "rbpdf", "~> 1.20.0"
-
-# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
-gem 'tzinfo-data', platforms: [:mingw, :x64_mingw, :mswin]
-
-# Optional gem for LDAP authentication
-group :ldap do
-  gem "net-ldap", "~> 0.16.0"
-end
-
-# Optional gem for OpenID authentication
-group :openid do
-  gem "ruby-openid", "~> 2.9.2", :require => "openid"
-  gem "rack-openid"
-end
-
-# Optional gem for exporting the gantt to a PNG file
-group :minimagick do
-  gem "mini_magick", "~> 4.9.5"
-end
-
-# Optional Markdown support, not for JRuby
-group :markdown do
-  gem "redcarpet", "~> 3.5.0"
-end
-
-# Include database gems for the adapters found in the database
-# configuration file
-require 'erb'
-require 'yaml'
-database_file = File.join(File.dirname(__FILE__), "config/database.yml")
-if File.exist?(database_file)
-  database_config = YAML::load(ERB.new(IO.read(database_file)).result)
-  adapters = database_config.values.map {|c| c['adapter']}.compact.uniq
-  if adapters.any?
-    adapters.each do |adapter|
-      case adapter
-      when 'mysql2'
-        gem "mysql2", "~> 0.5.0", :platforms => [:mri, :mingw, :x64_mingw]
-      when /postgresql/
-        gem "pg", "~> 1.1.4", :platforms => [:mri, :mingw, :x64_mingw]
-      when /sqlite3/
-        gem "sqlite3", "~> 1.4.0", :platforms => [:mri, :mingw, :x64_mingw]
-      when /sqlserver/
-        gem "tiny_tds", "~> 2.1.2", :platforms => [:mri, :mingw, :x64_mingw]
-        gem "activerecord-sqlserver-adapter", "~> 5.2.1", :platforms => [:mri, :mingw, :x64_mingw]
-      else
-        warn("Unknown database adapter `#{adapter}` found in config/database.yml, use Gemfile.local to load your own database gems")
-      end
-    end
-  else
-    warn("No adapter found in config/database.yml, please configure it first")
-  end
-else
-  warn("Please configure your config/database.yml first")
-end
-
-group :development do
-  gem "yard"
-end
-
-group :test do
-  gem "rails-dom-testing"
-  gem 'mocha', '>= 1.4.0'
-  gem "simplecov", "~> 0.17.0", :require => false
-  gem "ffi", platforms: [:mingw, :x64_mingw, :mswin]
-  # For running system tests
-  gem 'puma', '~> 3.7'
-  gem "capybara", (RUBY_VERSION < "2.4" ? "~> 3.15.1" : "~> 3.25.0")
-  gem "selenium-webdriver"
-  # RuboCop
-  gem 'rubocop', '~> 0.76.0'
-  gem 'rubocop-performance', '~> 1.5.0'
-  gem 'rubocop-rails', '~> 2.3.0'
-end
-
-local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
-if File.exists?(local_gemfile)
-  eval_gemfile local_gemfile
-end
-
-# Load plugins' Gemfiles
-Dir.glob File.expand_path("../plugins/*/{Gemfile,PluginGemfile}", __FILE__) do |file|
-  eval_gemfile file
-end

README.md

@@ -13,7 +13,7 @@ En **SuitePro** concurren potencia y sencillez para planificar, compartir
 conocimiento, prestar soporte a clientes y acelerar la productividad, apremiando
 la finalización de las tareas y manteniendo la información en un único sitio.
 
-**SuitePro** está instalado y operativo en https://suitepro.cillero.es
+**SuitePro 2.2.1** está instalado y operativo en https://suitepro.cillero.es
 
 ## SuitePro es software libre
 
@@ -27,44 +27,45 @@ License v2* (GPL).
 
 # Código fuente
 
-  * Repositorio: https://suitepro.cillero.es/projects/suitepro/repository
-  * GitLab: https://gitlab.com/manuelcillero/suitepro
+  * Proyecto: https://suitepro.cillero.es/projects/suitepro
+  * Repositorio: https://git.cillero.es/manuelcillero/suitepro
 
 ## Plugins incluidos
 
 ### Redmine Additionals plugin
 
-  * additionals 2.0.20
+  * additionals 3.0.2-master
   * https://alphanodes.com/redmine-additionals
   * https://github.com/alphanodes/additionals.git
 
 ### Redmine Checklists plugin (Light version)
 
-  * checklists 3.1.10
+  * checklists 3.1.18
   * https://www.redmine.org/plugins/redmine_checklists
   * https://www.redmineup.com/pages/plugins/checklists
 
 ### Redmine CKEditor plugin
 
-  * ckeditor 1.1.5
+  * ckeditor 1.2.3
   * https://www.redmine.org/plugins/redmine-ckeditor
   * http://github.com/a-ono/redmine_ckeditor
 
 ### Redmine Glossary Plugin
 
-  * glossary 0.9.2
+  * glossary 1.1.0
   * https://www.r-labs.org/projects/rp-glossary/wiki/UsageEn
   * https://github.com/torutk/redmine_glossary
 
 ### Redmine Private Wiki Plugin
 
-  * private_wiki 0.2.0
+  * private_wiki 0.2.0 (mistraloz)
   * http://www.redmine.org/plugins/redmine_private_wiki
-  * https://github.com/BlueXML/redmine_private_wiki
+  * https://github.com/mistraloz/redmine_private_wiki (*fork* con ajustes para
+    Redmine >= 4.0.3)
 
 ### Redmine Q&A plugin
 
-  * questions 1.0.0
+  * questions 1.0.2
   * https://www.redmine.org/plugins/redmine_questions
   * http://www.redminecrm.com/projects/questions
 

Rakefile

@@ -1,7 +0,0 @@
-#!/usr/bin/env rake
-# Add your own tasks in files placed in lib/tasks ending in .rake,
-# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
-
-require File.expand_path('../config/application', __FILE__)
-
-RedmineApp::Application.load_tasks

app/controllers/account_controller.rb

@@ -1,383 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class AccountController < ApplicationController
-  helper :custom_fields
-  include CustomFieldsHelper
-
-  self.main_menu = false
-
-  # prevents login action to be filtered by check_if_login_required application scope filter
-  skip_before_action :check_if_login_required, :check_password_change
-
-  # Overrides ApplicationController#verify_authenticity_token to disable
-  # token verification on openid callbacks
-  def verify_authenticity_token
-    unless using_open_id?
-      super
-    end
-  end
-
-  # Login request and validation
-  def login
-    if request.post?
-      authenticate_user
-    else
-      if User.current.logged?
-        redirect_back_or_default home_url, :referer => true
-      end
-    end
-  rescue AuthSourceException => e
-    logger.error "An error occurred when authenticating #{params[:username]}: #{e.message}"
-    render_error :message => e.message
-  end
-
-  # Log out current user and redirect to welcome page
-  def logout
-    if User.current.anonymous?
-      redirect_to home_url
-    elsif request.post?
-      logout_user
-      redirect_to home_url
-    end
-    # display the logout form
-  end
-
-  # Lets user choose a new password
-  def lost_password
-    (redirect_to(home_url); return) unless Setting.lost_password?
-    if prt = (params[:token] || session[:password_recovery_token])
-      @token = Token.find_token("recovery", prt.to_s)
-      if @token.nil?
-        redirect_to home_url
-        return
-      elsif @token.expired?
-        # remove expired token from session and let user try again
-        session[:password_recovery_token] = nil
-        flash[:error] = l(:error_token_expired)
-        redirect_to lost_password_url
-        return
-      end
-
-      # redirect to remove the token query parameter from the URL and add it to the session
-      if request.query_parameters[:token].present?
-        session[:password_recovery_token] = @token.value
-        redirect_to lost_password_url
-        return
-      end
-
-      @user = @token.user
-      unless @user && @user.active?
-        redirect_to home_url
-        return
-      end
-      if request.post?
-        if @user.must_change_passwd? && @user.check_password?(params[:new_password])
-          flash.now[:error] = l(:notice_new_password_must_be_different)
-        else
-          @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]
-          @user.must_change_passwd = false
-          if @user.save
-            @token.destroy
-            Mailer.deliver_password_updated(@user, User.current)
-            flash[:notice] = l(:notice_account_password_updated)
-            redirect_to signin_path
-            return
-          end
-        end
-      end
-      render :template => "account/password_recovery"
-      return
-    else
-      if request.post?
-        email = params[:mail].to_s.strip
-        user = User.find_by_mail(email)
-        # user not found
-        unless user
-          flash.now[:error] = l(:notice_account_unknown_email)
-          return
-        end
-        unless user.active?
-          handle_inactive_user(user, lost_password_path)
-          return
-        end
-        # user cannot change its password
-        unless user.change_password_allowed?
-          flash.now[:error] = l(:notice_can_t_change_password)
-          return
-        end
-        # create a new token for password recovery
-        token = Token.new(:user => user, :action => "recovery")
-        if token.save
-          # Don't use the param to send the email
-          recipent = user.mails.detect {|e| email.casecmp(e) == 0} || user.mail
-          Mailer.deliver_lost_password(user, token, recipent)
-          flash[:notice] = l(:notice_account_lost_email_sent)
-          redirect_to signin_path
-          return
-        end
-      end
-    end
-  end
-
-  # User self-registration
-  def register
-    (redirect_to(home_url); return) unless Setting.self_registration? || session[:auth_source_registration]
-    if !request.post?
-      session[:auth_source_registration] = nil
-      @user = User.new(:language => current_language.to_s)
-    else
-      user_params = params[:user] || {}
-      @user = User.new
-      @user.safe_attributes = user_params
-      @user.pref.safe_attributes = params[:pref]
-      @user.admin = false
-      @user.register
-      if session[:auth_source_registration]
-        @user.activate
-        @user.login = session[:auth_source_registration][:login]
-        @user.auth_source_id = session[:auth_source_registration][:auth_source_id]
-        if @user.save
-          session[:auth_source_registration] = nil
-          self.logged_user = @user
-          flash[:notice] = l(:notice_account_activated)
-          redirect_to my_account_path
-        end
-      else
-        unless user_params[:identity_url].present? && user_params[:password].blank? && user_params[:password_confirmation].blank?
-          @user.password, @user.password_confirmation = user_params[:password], user_params[:password_confirmation]
-        end
-
-        case Setting.self_registration
-        when '1'
-          register_by_email_activation(@user)
-        when '3'
-          register_automatically(@user)
-        else
-          register_manually_by_administrator(@user)
-        end
-      end
-    end
-  end
-
-  # Token based account activation
-  def activate
-    (redirect_to(home_url); return) unless Setting.self_registration? && params[:token].present?
-    token = Token.find_token('register', params[:token].to_s)
-    (redirect_to(home_url); return) unless token and !token.expired?
-    user = token.user
-    (redirect_to(home_url); return) unless user.registered?
-    user.activate
-    if user.save
-      token.destroy
-      flash[:notice] = l(:notice_account_activated)
-    end
-    redirect_to signin_path
-  end
-
-  # Sends a new account activation email
-  def activation_email
-    if session[:registered_user_id] && Setting.self_registration == '1'
-      user_id = session.delete(:registered_user_id).to_i
-      user = User.find_by_id(user_id)
-      if user && user.registered?
-        register_by_email_activation(user)
-        return
-      end
-    end
-    redirect_to(home_url)
-  end
-
-  private
-
-  def authenticate_user
-    if Setting.openid? && using_open_id?
-      open_id_authenticate(params[:openid_url])
-    else
-      password_authentication
-    end
-  end
-
-  def password_authentication
-    user = User.try_to_login(params[:username], params[:password], false)
-
-    if user.nil?
-      invalid_credentials
-    elsif user.new_record?
-      onthefly_creation_failed(user, {:login => user.login, :auth_source_id => user.auth_source_id })
-    else
-      # Valid user
-      if user.active?
-        successful_authentication(user)
-        update_sudo_timestamp! # activate Sudo Mode
-      else
-        handle_inactive_user(user)
-      end
-    end
-  end
-
-  def open_id_authenticate(openid_url)
-    back_url = signin_url(:autologin => params[:autologin])
-    authenticate_with_open_id(
-          openid_url, :required => [:nickname, :fullname, :email],
-          :return_to => back_url, :method => :post
-    ) do |result, identity_url, registration|
-      if result.successful?
-        user = User.find_or_initialize_by_identity_url(identity_url)
-        if user.new_record?
-          # Self-registration off
-          (redirect_to(home_url); return) unless Setting.self_registration?
-          # Create on the fly
-          user.login = registration['nickname'] unless registration['nickname'].nil?
-          user.mail = registration['email'] unless registration['email'].nil?
-          user.firstname, user.lastname = registration['fullname'].split(' ') unless registration['fullname'].nil?
-          user.random_password
-          user.register
-          case Setting.self_registration
-          when '1'
-            register_by_email_activation(user) do
-              onthefly_creation_failed(user)
-            end
-          when '3'
-            register_automatically(user) do
-              onthefly_creation_failed(user)
-            end
-          else
-            register_manually_by_administrator(user) do
-              onthefly_creation_failed(user)
-            end
-          end
-        else
-          # Existing record
-          if user.active?
-            successful_authentication(user)
-          else
-            handle_inactive_user(user)
-          end
-        end
-      end
-    end
-  end
-
-  def successful_authentication(user)
-    logger.info "Successful authentication for '#{user.login}' from #{request.remote_ip} at #{Time.now.utc}"
-    # Valid user
-    self.logged_user = user
-    # generate a key and set cookie if autologin
-    if params[:autologin] && Setting.autologin?
-      set_autologin_cookie(user)
-    end
-    call_hook(:controller_account_success_authentication_after, {:user => user })
-    redirect_back_or_default my_page_path
-  end
-
-  def set_autologin_cookie(user)
-    token = user.generate_autologin_token
-    secure = Redmine::Configuration['autologin_cookie_secure']
-    if secure.nil?
-      secure = request.ssl?
-    end
-    cookie_options = {
-      :value => token,
-      :expires => 1.year.from_now,
-      :path => (Redmine::Configuration['autologin_cookie_path'] || RedmineApp::Application.config.relative_url_root || '/'),
-      :secure => secure,
-      :httponly => true
-    }
-    cookies[autologin_cookie_name] = cookie_options
-  end
-
-  # Onthefly creation failed, display the registration form to fill/fix attributes
-  def onthefly_creation_failed(user, auth_source_options = { })
-    @user = user
-    session[:auth_source_registration] = auth_source_options unless auth_source_options.empty?
-    render :action => 'register'
-  end
-
-  def invalid_credentials
-    logger.warn "Failed login for '#{params[:username]}' from #{request.remote_ip} at #{Time.now.utc}"
-    flash.now[:error] = l(:notice_account_invalid_credentials)
-  end
-
-  # Register a user for email activation.
-  #
-  # Pass a block for behavior when a user fails to save
-  def register_by_email_activation(user, &block)
-    token = Token.new(:user => user, :action => "register")
-    if user.save and token.save
-      Mailer.deliver_register(user, token)
-      flash[:notice] = l(:notice_account_register_done, :email => ERB::Util.h(user.mail))
-      redirect_to signin_path
-    else
-      yield if block_given?
-    end
-  end
-
-  # Automatically register a user
-  #
-  # Pass a block for behavior when a user fails to save
-  def register_automatically(user, &block)
-    # Automatic activation
-    user.activate
-    user.last_login_on = Time.now
-    if user.save
-      self.logged_user = user
-      flash[:notice] = l(:notice_account_activated)
-      redirect_to my_account_path
-    else
-      yield if block_given?
-    end
-  end
-
-  # Manual activation by the administrator
-  #
-  # Pass a block for behavior when a user fails to save
-  def register_manually_by_administrator(user, &block)
-    if user.save
-      # Sends an email to the administrators
-      Mailer.deliver_account_activation_request(user)
-      account_pending(user)
-    else
-      yield if block_given?
-    end
-  end
-
-  def handle_inactive_user(user, redirect_path=signin_path)
-    if user.registered?
-      account_pending(user, redirect_path)
-    else
-      account_locked(user, redirect_path)
-    end
-  end
-
-  def account_pending(user, redirect_path=signin_path)
-    if Setting.self_registration == '1'
-      flash[:error] = l(:notice_account_not_activated_yet, :url => activation_email_path)
-      session[:registered_user_id] = user.id
-    else
-      flash[:error] = l(:notice_account_pending)
-    end
-    redirect_to redirect_path
-  end
-
-  def account_locked(user, redirect_path=signin_path)
-    flash[:error] = l(:notice_account_locked)
-    redirect_to redirect_path
-  end
-end

app/controllers/activities_controller.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class ActivitiesController < ApplicationController
-  menu_item :activity
-  before_action :find_optional_project_by_id, :authorize_global
-  accept_rss_auth :index
-
-  def index
-    @days = Setting.activity_days_default.to_i
-
-    if params[:from]
-      begin; @date_to = params[:from].to_date + 1; rescue; end
-    end
-
-    @date_to ||= User.current.today + 1
-    @date_from = @date_to - @days
-    @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')
-    if params[:user_id].present?
-      @author = User.active.find(params[:user_id])
-    end
-
-    @activity = Redmine::Activity::Fetcher.new(User.current, :project => @project,
-                                                             :with_subprojects => @with_subprojects,
-                                                             :author => @author)
-    pref = User.current.pref
-    @activity.scope_select {|t| !params["show_#{t}"].nil?}
-    if @activity.scope.present?
-      if params[:submit].present?
-        pref.activity_scope = @activity.scope
-        pref.save
-      end
-    else
-      if @author.nil?
-        scope = pref.activity_scope & @activity.event_types
-        @activity.scope = scope.present? ? scope : :default
-      else
-        @activity.scope = :all
-      end
-    end
-
-    events = @activity.events(@date_from, @date_to)
-
-    if events.empty? || stale?(:etag => [@activity.scope, @date_to, @date_from, @with_subprojects, @author, events.first, events.size, User.current, current_language])
-      respond_to do |format|
-        format.html {
-          @events_by_day = events.group_by {|event| User.current.time_to_date(event.event_datetime)}
-          render :layout => false if request.xhr?
-        }
-        format.atom {
-          title = l(:label_activity)
-          if @author
-            title = @author.name
-          elsif @activity.scope.size == 1
-            title = l("label_#{@activity.scope.first.singularize}_plural")
-          end
-          render_feed(events, :title => "#{@project || Setting.app_title}: #{title}")
-        }
-      end
-    end
-
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/admin_controller.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class AdminController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-  menu_item :projects, :only => :projects
-  menu_item :plugins, :only => :plugins
-  menu_item :info, :only => :info
-
-  before_action :require_admin
-
-  def index
-    @no_configuration_data = Redmine::DefaultData::Loader::no_data?
-  end
-
-  def projects
-    @status = params[:status] || 1
-
-    scope = Project.status(@status).sorted
-    scope = scope.like(params[:name]) if params[:name].present?
-
-    @project_count = scope.count
-    @project_pages = Paginator.new @project_count, per_page_option, params['page']
-    @projects = scope.limit(@project_pages.per_page).offset(@project_pages.offset).to_a
-
-    render :action => "projects", :layout => false if request.xhr?
-  end
-
-  def plugins
-    @plugins = Redmine::Plugin.all
-  end
-
-  # Loads the default configuration
-  # (roles, trackers, statuses, workflow, enumerations)
-  def default_configuration
-    if request.post?
-      begin
-        Redmine::DefaultData::Loader::load(params[:lang])
-        flash[:notice] = l(:notice_default_data_loaded)
-      rescue => e
-        flash[:error] = l(:error_can_t_load_default_data, ERB::Util.h(e.message))
-      end
-    end
-    redirect_to admin_path
-  end
-
-  def test_email
-    begin
-      Mailer.deliver_test_email(User.current)
-      flash[:notice] = l(:notice_email_sent, ERB::Util.h(User.current.mail))
-    rescue => e
-      flash[:error] = l(:notice_email_error, ERB::Util.h(Redmine::CodesetUtil.replace_invalid_utf8(e.message.dup)))
-    end
-    redirect_to settings_path(:tab => 'notifications')
-  end
-
-  def info
-    @checklist = [
-      [:text_default_administrator_account_changed, User.default_admin_account_changed?],
-      [:text_file_repository_writable, File.writable?(Attachment.storage_path)],
-      ["#{l :text_plugin_assets_writable} (./public/plugin_assets)",   File.writable?(Redmine::Plugin.public_directory)],
-      [:text_minimagick_available,     Object.const_defined?(:MiniMagick)],
-      [:text_convert_available,        Redmine::Thumbnail.convert_available?],
-      [:text_gs_available,             Redmine::Thumbnail.gs_available?]
-    ]
-  end
-end

app/controllers/application_controller.rb

@@ -1,714 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-require 'uri'
-require 'cgi'
-
-class Unauthorized < StandardError; end
-
-class ApplicationController < ActionController::Base
-  include Redmine::I18n
-  include Redmine::Pagination
-  include Redmine::Hook::Helper
-  include RoutesHelper
-  include AvatarsHelper
-
-  helper :routes
-  helper :avatars
-
-  class_attribute :accept_api_auth_actions
-  class_attribute :accept_rss_auth_actions
-  class_attribute :model_object
-
-  layout 'base'
-
-  protect_from_forgery
-
-  def verify_authenticity_token
-    unless api_request?
-      super
-    end
-  end
-
-  def handle_unverified_request
-    unless api_request?
-      super
-      cookies.delete(autologin_cookie_name)
-      self.logged_user = nil
-      set_localization
-      render_error :status => 422, :message => "Invalid form authenticity token."
-    end
-  end
-
-  before_action :session_expiration, :user_setup, :check_if_login_required, :set_localization, :check_password_change
-  after_action :record_project_usage
-
-  rescue_from ::Unauthorized, :with => :deny_access
-  rescue_from ::ActionView::MissingTemplate, :with => :missing_template
-
-  include Redmine::Search::Controller
-  include Redmine::MenuManager::MenuController
-  helper Redmine::MenuManager::MenuHelper
-
-  include Redmine::SudoMode::Controller
-
-  def session_expiration
-    if session[:user_id] && Rails.application.config.redmine_verify_sessions != false
-      if session_expired? && !try_to_autologin
-        set_localization(User.active.find_by_id(session[:user_id]))
-        self.logged_user = nil
-        flash[:error] = l(:error_session_expired)
-        require_login
-      end
-    end
-  end
-
-  def session_expired?
-    ! User.verify_session_token(session[:user_id], session[:tk])
-  end
-
-  def start_user_session(user)
-    session[:user_id] = user.id
-    session[:tk] = user.generate_session_token
-    if user.must_change_password?
-      session[:pwd] = '1'
-    end
-  end
-
-  def user_setup
-    # Check the settings cache for each request
-    Setting.check_cache
-    # Find the current user
-    User.current = find_current_user
-    logger.info("  Current user: " + (User.current.logged? ? "#{User.current.login} (id=#{User.current.id})" : "anonymous")) if logger
-  end
-
-  # Returns the current user or nil if no user is logged in
-  # and starts a session if needed
-  def find_current_user
-    user = nil
-    unless api_request?
-      if session[:user_id]
-        # existing session
-        user = (User.active.find(session[:user_id]) rescue nil)
-      elsif autologin_user = try_to_autologin
-        user = autologin_user
-      elsif params[:format] == 'atom' && params[:key] && request.get? && accept_rss_auth?
-        # RSS key authentication does not start a session
-        user = User.find_by_rss_key(params[:key])
-      end
-    end
-    if user.nil? && Setting.rest_api_enabled? && accept_api_auth?
-      if (key = api_key_from_request)
-        # Use API key
-        user = User.find_by_api_key(key)
-      elsif /\ABasic /i.match?(request.authorization.to_s)
-        # HTTP Basic, either username/password or API key/random
-        authenticate_with_http_basic do |username, password|
-          user = User.try_to_login(username, password) || User.find_by_api_key(username)
-        end
-        if user && user.must_change_password?
-          render_error :message => 'You must change your password', :status => 403
-          return
-        end
-      end
-      # Switch user if requested by an admin user
-      if user && user.admin? && (username = api_switch_user_from_request)
-        su = User.find_by_login(username)
-        if su && su.active?
-          logger.info("  User switched by: #{user.login} (id=#{user.id})") if logger
-          user = su
-        else
-          render_error :message => 'Invalid X-Redmine-Switch-User header', :status => 412
-        end
-      end
-    end
-    # store current ip address in user object ephemerally
-    user.remote_ip = request.remote_ip if user
-    user
-  end
-
-  def autologin_cookie_name
-    Redmine::Configuration['autologin_cookie_name'].presence || 'autologin'
-  end
-
-  def try_to_autologin
-    if cookies[autologin_cookie_name] && Setting.autologin?
-      # auto-login feature starts a new session
-      user = User.try_to_autologin(cookies[autologin_cookie_name])
-      if user
-        reset_session
-        start_user_session(user)
-      end
-      user
-    end
-  end
-
-  # Sets the logged in user
-  def logged_user=(user)
-    reset_session
-    if user && user.is_a?(User)
-      User.current = user
-      start_user_session(user)
-    else
-      User.current = User.anonymous
-    end
-  end
-
-  # Logs out current user
-  def logout_user
-    if User.current.logged?
-      if autologin = cookies.delete(autologin_cookie_name)
-        User.current.delete_autologin_token(autologin)
-      end
-      User.current.delete_session_token(session[:tk])
-      self.logged_user = nil
-    end
-  end
-
-  # check if login is globally required to access the application
-  def check_if_login_required
-    # no check needed if user is already logged in
-    return true if User.current.logged?
-    require_login if Setting.login_required?
-  end
-
-  def check_password_change
-    if session[:pwd]
-      if User.current.must_change_password?
-        flash[:error] = l(:error_password_expired)
-        redirect_to my_password_path
-      else
-        session.delete(:pwd)
-      end
-    end
-  end
-
-  def set_localization(user=User.current)
-    lang = nil
-    if user && user.logged?
-      lang = find_language(user.language)
-    end
-    if lang.nil? && !Setting.force_default_language_for_anonymous? && request.env['HTTP_ACCEPT_LANGUAGE']
-      accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first
-      if !accept_lang.blank?
-        accept_lang = accept_lang.downcase
-        lang = find_language(accept_lang) || find_language(accept_lang.split('-').first)
-      end
-    end
-    lang ||= Setting.default_language
-    set_language_if_valid(lang)
-  end
-
-  def require_login
-    if !User.current.logged?
-      # Extract only the basic url parameters on non-GET requests
-      if request.get?
-        url = request.original_url
-      else
-        url = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id], :project_id => params[:project_id])
-      end
-      respond_to do |format|
-        format.html {
-          if request.xhr?
-            head :unauthorized
-          else
-            redirect_to signin_path(:back_url => url)
-          end
-        }
-        format.any(:atom, :pdf, :csv) {
-          redirect_to signin_path(:back_url => url)
-        }
-        format.api  {
-          if Setting.rest_api_enabled? && accept_api_auth?
-            head(:unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"')
-          else
-            head(:forbidden)
-          end
-        }
-        format.js   { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
-        format.any  { head :unauthorized }
-      end
-      return false
-    end
-    true
-  end
-
-  def require_admin
-    return unless require_login
-    if !User.current.admin?
-      render_403
-      return false
-    end
-    true
-  end
-
-  def deny_access
-    User.current.logged? ? render_403 : require_login
-  end
-
-  # Authorize the user for the requested action
-  def authorize(ctrl = params[:controller], action = params[:action], global = false)
-    allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project || @projects, :global => global)
-    if allowed
-      true
-    else
-      if @project && @project.archived?
-        @archived_project = @project
-        render_403 :message => :notice_not_authorized_archived_project
-      elsif @project && !@project.allows_to?(:controller => ctrl, :action => action)
-        # Project module is disabled
-        render_403
-      else
-        deny_access
-      end
-    end
-  end
-
-  # Authorize the user for the requested action outside a project
-  def authorize_global(ctrl = params[:controller], action = params[:action], global = true)
-    authorize(ctrl, action, global)
-  end
-
-  # Find project of id params[:id]
-  def find_project(project_id=params[:id])
-    @project = Project.find(project_id)
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  # Find project of id params[:project_id]
-  def find_project_by_project_id
-    find_project(params[:project_id])
-  end
-
-  # Find project of id params[:id] if present
-  def find_optional_project_by_id
-    if params[:id].present?
-      find_project(params[:id])
-    end
-  end
-
-  # Find a project based on params[:project_id]
-  # and authorize the user for the requested action
-  def find_optional_project
-    if params[:project_id].present?
-      find_project(params[:project_id])
-    end
-    authorize_global
-  end
-
-  # Finds and sets @project based on @object.project
-  def find_project_from_association
-    render_404 unless @object.present?
-
-    @project = @object.project
-  end
-
-  def find_model_object
-    model = self.class.model_object
-    if model
-      @object = model.find(params[:id])
-      self.instance_variable_set('@' + controller_name.singularize, @object) if @object
-    end
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def self.model_object(model)
-    self.model_object = model
-  end
-
-  # Find the issue whose id is the :id parameter
-  # Raises a Unauthorized exception if the issue is not visible
-  def find_issue
-    # Issue.visible.find(...) can not be used to redirect user to the login form
-    # if the issue actually exists but requires authentication
-    @issue = Issue.find(params[:id])
-    raise Unauthorized unless @issue.visible?
-    @project = @issue.project
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  # Find issues with a single :id param or :ids array param
-  # Raises a Unauthorized exception if one of the issues is not visible
-  def find_issues
-    @issues = Issue.
-      where(:id => (params[:id] || params[:ids])).
-      preload(:project, :status, :tracker, :priority, :author, :assigned_to, :relations_to, {:custom_values => :custom_field}).
-      to_a
-    raise ActiveRecord::RecordNotFound if @issues.empty?
-    raise Unauthorized unless @issues.all?(&:visible?)
-    @projects = @issues.collect(&:project).compact.uniq
-    @project = @projects.first if @projects.size == 1
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def find_attachments
-    if (attachments = params[:attachments]).present?
-      att = attachments.values.collect do |attachment|
-        Attachment.find_by_token( attachment[:token] ) if attachment[:token].present?
-      end
-      att.compact!
-    end
-    @attachments = att || []
-  end
-
-  def parse_params_for_bulk_update(params)
-    attributes = (params || {}).reject {|k,v| v.blank?}
-    attributes.keys.each {|k| attributes[k] = '' if attributes[k] == 'none'}
-    if custom = attributes[:custom_field_values]
-      custom.reject! {|k,v| v.blank?}
-      custom.keys.each do |k|
-        if custom[k].is_a?(Array)
-          custom[k] << '' if custom[k].delete('__none__')
-        else
-          custom[k] = '' if custom[k] == '__none__'
-        end
-      end
-    end
-    attributes
-  end
-
-  # make sure that the user is a member of the project (or admin) if project is private
-  # used as a before_action for actions that do not require any particular permission on the project
-  def check_project_privacy
-    if @project && !@project.archived?
-      if @project.visible?
-        true
-      else
-        deny_access
-      end
-    else
-      @project = nil
-      render_404
-      false
-    end
-  end
-
-  def record_project_usage
-    if @project && @project.id && User.current.logged? && User.current.allowed_to?(:view_project, @project)
-      Redmine::ProjectJumpBox.new(User.current).project_used(@project)
-    end
-    true
-  end
-
-  def back_url
-    url = params[:back_url]
-    if url.nil? && referer = request.env['HTTP_REFERER']
-      url = CGI.unescape(referer.to_s)
-      # URLs that contains the utf8=[checkmark] parameter added by Rails are
-      # parsed as invalid by URI.parse so the redirect to the back URL would
-      # not be accepted (ApplicationController#validate_back_url would return
-      # false)
-      url.gsub!(/(\?|&)utf8=\u2713&?/, '\1')
-    end
-    url
-  end
-  helper_method :back_url
-
-  def redirect_back_or_default(default, options={})
-    if back_url = validate_back_url(params[:back_url].to_s)
-      redirect_to(back_url)
-      return
-    elsif options[:referer]
-      redirect_to_referer_or default
-      return
-    end
-    redirect_to default
-    false
-  end
-
-  # Returns a validated URL string if back_url is a valid url for redirection,
-  # otherwise false
-  def validate_back_url(back_url)
-    return false if back_url.blank?
-
-    if CGI.unescape(back_url).include?('..')
-      return false
-    end
-
-    begin
-      uri = URI.parse(back_url)
-    rescue URI::InvalidURIError
-      return false
-    end
-
-    [:scheme, :host, :port].each do |component|
-      if uri.send(component).present? && uri.send(component) != request.send(component)
-        return false
-      end
-      uri.send(:"#{component}=", nil)
-    end
-    # Always ignore basic user:password in the URL
-    uri.userinfo = nil
-
-    path = uri.to_s
-    # Ensure that the remaining URL starts with a slash, followed by a
-    # non-slash character or the end
-    if !%r{\A/([^/]|\z)}.match?(path)
-      return false
-    end
-
-    if %r{/(login|account/register|account/lost_password)}.match?(path)
-      return false
-    end
-
-    if relative_url_root.present? && !path.starts_with?(relative_url_root)
-      return false
-    end
-
-    return path
-  end
-  private :validate_back_url
-  helper_method :validate_back_url
-
-  def valid_back_url?(back_url)
-    !!validate_back_url(back_url)
-  end
-  private :valid_back_url?
-  helper_method :valid_back_url?
-
-  # Redirects to the request referer if present, redirects to args or call block otherwise.
-  def redirect_to_referer_or(*args, &block)
-    if referer = request.headers["Referer"]
-      redirect_to referer
-    else
-      if args.any?
-        redirect_to *args
-      elsif block_given?
-        yield
-      else
-        raise "#redirect_to_referer_or takes arguments or a block"
-      end
-    end
-  end
-
-  def render_403(options={})
-    @project = nil
-    render_error({:message => :notice_not_authorized, :status => 403}.merge(options))
-    return false
-  end
-
-  def render_404(options={})
-    render_error({:message => :notice_file_not_found, :status => 404}.merge(options))
-    return false
-  end
-
-  # Renders an error response
-  def render_error(arg)
-    arg = {:message => arg} unless arg.is_a?(Hash)
-
-    @message = arg[:message]
-    @message = l(@message) if @message.is_a?(Symbol)
-    @status = arg[:status] || 500
-
-    respond_to do |format|
-      format.html {
-        render :template => 'common/error', :layout => use_layout, :status => @status
-      }
-      format.any { head @status }
-    end
-  end
-
-  # Handler for ActionView::MissingTemplate exception
-  def missing_template(exception)
-    logger.warn "Missing template, responding with 404: #{exception}"
-    @project = nil
-    render_404
-  end
-
-  # Filter for actions that provide an API response
-  # but have no HTML representation for non admin users
-  def require_admin_or_api_request
-    return true if api_request?
-    if User.current.admin?
-      true
-    elsif User.current.logged?
-      render_error(:status => 406)
-    else
-      deny_access
-    end
-  end
-
-  # Picks which layout to use based on the request
-  #
-  # @return [boolean, string] name of the layout to use or false for no layout
-  def use_layout
-    request.xhr? ? false : 'base'
-  end
-
-  def render_feed(items, options={})
-    @items = (items || []).to_a
-    @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
-    @items = @items.slice(0, Setting.feeds_limit.to_i)
-    @title = options[:title] || Setting.app_title
-    render :template => "common/feed", :formats => [:atom], :layout => false,
-           :content_type => 'application/atom+xml'
-  end
-
-  def self.accept_rss_auth(*actions)
-    if actions.any?
-      self.accept_rss_auth_actions = actions
-    else
-      self.accept_rss_auth_actions || []
-    end
-  end
-
-  def accept_rss_auth?(action=action_name)
-    self.class.accept_rss_auth.include?(action.to_sym)
-  end
-
-  def self.accept_api_auth(*actions)
-    if actions.any?
-      self.accept_api_auth_actions = actions
-    else
-      self.accept_api_auth_actions || []
-    end
-  end
-
-  def accept_api_auth?(action=action_name)
-    self.class.accept_api_auth.include?(action.to_sym)
-  end
-
-  # Returns the number of objects that should be displayed
-  # on the paginated list
-  def per_page_option
-    per_page = nil
-    if params[:per_page] && Setting.per_page_options_array.include?(params[:per_page].to_s.to_i)
-      per_page = params[:per_page].to_s.to_i
-      session[:per_page] = per_page
-    elsif session[:per_page]
-      per_page = session[:per_page]
-    else
-      per_page = Setting.per_page_options_array.first || 25
-    end
-    per_page
-  end
-
-  # Returns offset and limit used to retrieve objects
-  # for an API response based on offset, limit and page parameters
-  def api_offset_and_limit(options=params)
-    if options[:offset].present?
-      offset = options[:offset].to_i
-      if offset < 0
-        offset = 0
-      end
-    end
-    limit = options[:limit].to_i
-    if limit < 1
-      limit = 25
-    elsif limit > 100
-      limit = 100
-    end
-    if offset.nil? && options[:page].present?
-      offset = (options[:page].to_i - 1) * limit
-      offset = 0 if offset < 0
-    end
-    offset ||= 0
-
-    [offset, limit]
-  end
-
-  # qvalues http header parser
-  # code taken from webrick
-  def parse_qvalues(value)
-    tmp = []
-    if value
-      parts = value.split(/,\s*/)
-      parts.each {|part|
-        if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
-          val = m[1]
-          q = (m[2] or 1).to_f
-          tmp.push([val, q])
-        end
-      }
-      tmp = tmp.sort_by{|val, q| -q}
-      tmp.collect!{|val, q| val}
-    end
-    return tmp
-  rescue
-    nil
-  end
-
-  # Returns a string that can be used as filename value in Content-Disposition header
-  def filename_for_content_disposition(name)
-    %r{(MSIE|Trident|Edge)}.match?(request.env['HTTP_USER_AGENT']) ? ERB::Util.url_encode(name) : name
-  end
-
-  def api_request?
-    %w(xml json).include? params[:format]
-  end
-
-  # Returns the API key present in the request
-  def api_key_from_request
-    if params[:key].present?
-      params[:key].to_s
-    elsif request.headers["X-Redmine-API-Key"].present?
-      request.headers["X-Redmine-API-Key"].to_s
-    end
-  end
-
-  # Returns the API 'switch user' value if present
-  def api_switch_user_from_request
-    request.headers["X-Redmine-Switch-User"].to_s.presence
-  end
-
-  # Renders a warning flash if obj has unsaved attachments
-  def render_attachment_warning_if_needed(obj)
-    flash[:warning] = l(:warning_attachments_not_saved, obj.unsaved_attachments.size) if obj.unsaved_attachments.present?
-  end
-
-  # Rescues an invalid query statement. Just in case...
-  def query_statement_invalid(exception)
-    logger.error "Query::StatementInvalid: #{exception.message}" if logger
-    session.delete(:issue_query)
-    render_error "An error occurred while executing the query and has been logged. Please report this error to your Redmine administrator."
-  end
-
-  # Renders a 204 response for successful updates or deletions via the API
-  def render_api_ok
-    render_api_head :no_content
-  end
-
-  # Renders a head API response
-  def render_api_head(status)
-    head status
-  end
-
-  # Renders API response on validation failure
-  # for an object or an array of objects
-  def render_validation_errors(objects)
-    messages = Array.wrap(objects).map {|object| object.errors.full_messages}.flatten
-    render_api_errors(messages)
-  end
-
-  def render_api_errors(*messages)
-    @error_messages = messages.flatten
-    render :template => 'common/error_messages.api', :status => :unprocessable_entity, :layout => nil
-  end
-
-  # Overrides #_include_layout? so that #render with no arguments
-  # doesn't use the layout for api requests
-  def _include_layout?(*args)
-    api_request? ? false : super
-  end
-end

app/controllers/attachments_controller.rb

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class AttachmentsController < ApplicationController
-  before_action :find_attachment, :only => [:show, :download, :thumbnail, :update, :destroy]
-  before_action :find_editable_attachments, :only => [:edit_all, :update_all]
-  before_action :file_readable, :read_authorize, :only => [:show, :download, :thumbnail]
-  before_action :update_authorize, :only => :update
-  before_action :delete_authorize, :only => :destroy
-  before_action :authorize_global, :only => :upload
-
-  # Disable check for same origin requests for JS files, i.e. attachments with
-  # MIME type text/javascript.
-  skip_after_action :verify_same_origin_request, :only => :download
-
-  accept_api_auth :show, :download, :thumbnail, :upload, :update, :destroy
-
-  def show
-    respond_to do |format|
-      format.html {
-        if @attachment.container.respond_to?(:attachments)
-          @attachments = @attachment.container.attachments.to_a
-          if index = @attachments.index(@attachment)
-            @paginator = Redmine::Pagination::Paginator.new(
-              @attachments.size, 1, index+1
-            )
-          end
-        end
-        if @attachment.is_diff?
-          @diff = File.read(@attachment.diskfile, :mode => "rb")
-          @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
-          @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
-          # Save diff type as user preference
-          if User.current.logged? && @diff_type != User.current.pref[:diff_type]
-            User.current.pref[:diff_type] = @diff_type
-            User.current.preference.save
-          end
-          render :action => 'diff'
-        elsif @attachment.is_text? && @attachment.filesize <= Setting.file_max_size_displayed.to_i.kilobyte
-          @content = File.read(@attachment.diskfile, :mode => "rb")
-          render :action => 'file'
-        elsif @attachment.is_image?
-          render :action => 'image'
-        else
-          render :action => 'other'
-        end
-      }
-      format.api
-    end
-  end
-
-  def download
-    if @attachment.container.is_a?(Version) || @attachment.container.is_a?(Project)
-      @attachment.increment_download
-    end
-
-    if stale?(:etag => @attachment.digest, :template => false)
-      # images are sent inline
-      send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),
-                                      :type => detect_content_type(@attachment),
-                                      :disposition => disposition(@attachment)
-    end
-  end
-
-  def thumbnail
-    if @attachment.thumbnailable? && tbnail = @attachment.thumbnail(:size => params[:size])
-      if stale?(:etag => tbnail, :template => false)
-        send_file(
-          tbnail,
-          :filename => filename_for_content_disposition(@attachment.filename),
-          :type => detect_content_type(@attachment, true),
-          :disposition => 'inline')
-      end
-    else
-      # No thumbnail for the attachment or thumbnail could not be created
-      head 404
-    end
-  end
-
-  def upload
-    # Make sure that API users get used to set this content type
-    # as it won't trigger Rails' automatic parsing of the request body for parameters
-    unless request.content_type == 'application/octet-stream'
-      head 406
-      return
-    end
-
-    @attachment = Attachment.new(:file => request.raw_post)
-    @attachment.author = User.current
-    @attachment.filename = params[:filename].presence || Redmine::Utils.random_hex(16)
-    @attachment.content_type = params[:content_type].presence
-    saved = @attachment.save
-
-    respond_to do |format|
-      format.js
-      format.api {
-        if saved
-          render :action => 'upload', :status => :created
-        else
-          render_validation_errors(@attachment)
-        end
-      }
-    end
-  end
-
-  # Edit all the attachments of a container
-  def edit_all
-  end
-
-  # Update all the attachments of a container
-  def update_all
-    if Attachment.update_attachments(@attachments, update_all_params)
-      redirect_back_or_default home_path
-      return
-    end
-    render :action => 'edit_all'
-  end
-
-  def update
-    @attachment.safe_attributes = params[:attachment]
-    saved = @attachment.save
-
-    respond_to do |format|
-      format.api {
-        if saved
-          render_api_ok
-        else
-          render_validation_errors(@attachment)
-        end
-      }
-    end
-  end
-
-  def destroy
-    if @attachment.container.respond_to?(:init_journal)
-      @attachment.container.init_journal(User.current)
-    end
-    if @attachment.container
-      # Make sure association callbacks are called
-      @attachment.container.attachments.delete(@attachment)
-    else
-      @attachment.destroy
-    end
-
-    respond_to do |format|
-      format.html { redirect_to_referer_or project_path(@project) }
-      format.js
-      format.api { render_api_ok }
-    end
-  end
-
-  # Returns the menu item that should be selected when viewing an attachment
-  def current_menu_item
-    container = @attachment.try(:container) || @container
-
-    if container
-      case container
-      when WikiPage
-        :wiki
-      when Message
-        :boards
-      when Project, Version
-        :files
-      else
-        container.class.name.pluralize.downcase.to_sym
-      end
-    end
-  end
-
-  private
-
-  def find_attachment
-    @attachment = Attachment.find(params[:id])
-    # Show 404 if the filename in the url is wrong
-    raise ActiveRecord::RecordNotFound if params[:filename] && params[:filename] != @attachment.filename
-    @project = @attachment.project
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def find_editable_attachments
-    klass = params[:object_type].to_s.singularize.classify.constantize rescue nil
-    unless klass && klass.reflect_on_association(:attachments)
-      render_404
-      return
-    end
-
-    @container = klass.find(params[:object_id])
-    if @container.respond_to?(:visible?) && !@container.visible?
-      render_403
-      return
-    end
-    @attachments = @container.attachments.select(&:editable?)
-    if @container.respond_to?(:project)
-      @project = @container.project
-    end
-    render_404 if @attachments.empty?
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  # Checks that the file exists and is readable
-  def file_readable
-    if @attachment.readable?
-      true
-    else
-      logger.error "Cannot send attachment, #{@attachment.diskfile} does not exist or is unreadable."
-      render_404
-    end
-  end
-
-  def read_authorize
-    @attachment.visible? ? true : deny_access
-  end
-
-  def update_authorize
-    @attachment.editable? ? true : deny_access
-  end
-
-  def delete_authorize
-    @attachment.deletable? ? true : deny_access
-  end
-
-  def detect_content_type(attachment, is_thumb = false)
-    content_type = attachment.content_type
-    if content_type.blank? || content_type == "application/octet-stream"
-      content_type =
-        Redmine::MimeType.of(attachment.filename).presence ||
-        "application/octet-stream"
-    end
-
-    if is_thumb && content_type == "application/pdf"
-      # PDF previews are stored in PNG format
-      content_type = "image/png"
-    end
-
-    content_type
-  end
-
-  def disposition(attachment)
-    if attachment.is_pdf?
-      'inline'
-    else
-      'attachment'
-    end
-  end
-
-  # Returns attachments param for #update_all
-  def update_all_params
-    params.permit(:attachments => [:filename, :description]).require(:attachments)
-  end
-end

app/controllers/auth_sources_controller.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class AuthSourcesController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-  menu_item :ldap_authentication
-
-  before_action :require_admin
-  before_action :build_new_auth_source, :only => [:new, :create]
-  before_action :find_auth_source, :only => [:edit, :update, :test_connection, :destroy]
-  require_sudo_mode :update, :destroy
-
-  def index
-    @auth_source_pages, @auth_sources = paginate AuthSource, :per_page => 25
-  end
-
-  def new
-  end
-
-  def create
-    if @auth_source.save
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to auth_sources_path
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @auth_source.safe_attributes = params[:auth_source]
-    if @auth_source.save
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to auth_sources_path
-    else
-      render :action => 'edit'
-    end
-  end
-
-  def test_connection
-    begin
-      @auth_source.test_connection
-      flash[:notice] = l(:notice_successful_connection)
-    rescue => e
-      flash[:error] = l(:error_unable_to_connect, e.message)
-    end
-    redirect_to auth_sources_path
-  end
-
-  def destroy
-    unless @auth_source.users.exists?
-      @auth_source.destroy
-      flash[:notice] = l(:notice_successful_delete)
-    else
-      flash[:error] = l(:error_can_not_delete_auth_source)
-    end
-    redirect_to auth_sources_path
-  end
-
-  def autocomplete_for_new_user
-    results = AuthSource.search(params[:term])
-    render :json => results.map {|result|
-      {
-        'value' => result[:login],
-        'label' => "#{result[:login]} (#{result[:firstname]} #{result[:lastname]})",
-        'login' => result[:login].to_s,
-        'firstname' => result[:firstname].to_s,
-        'lastname' => result[:lastname].to_s,
-        'mail' => result[:mail].to_s,
-        'auth_source_id' => result[:auth_source_id].to_s
-      }
-    }
-  end
-
-  private
-
-  def build_new_auth_source
-    @auth_source = AuthSource.new_subclass_instance(params[:type] || 'AuthSourceLdap')
-    if @auth_source
-      @auth_source.safe_attributes = params[:auth_source]
-    else
-      render_404
-    end
-  end
-
-  def find_auth_source
-    @auth_source = AuthSource.find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/auto_completes_controller.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class AutoCompletesController < ApplicationController
-  before_action :find_project
-
-  def issues
-    issues = []
-    q = (params[:q] || params[:term]).to_s.strip
-    status = params[:status].to_s
-    issue_id = params[:issue_id].to_s
-
-    scope = Issue.cross_project_scope(@project, params[:scope]).visible
-    scope = scope.open(status == 'o') if status.present?
-    scope = scope.where.not(:id => issue_id.to_i) if issue_id.present?
-    if q.present?
-      if q =~ /\A#?(\d+)\z/
-        issues << scope.find_by(:id => $1.to_i)
-      end
-      issues += scope.like(q).order(:id => :desc).limit(10).to_a
-      issues.compact!
-    else
-      issues += scope.order(:id => :desc).limit(10).to_a
-    end
-
-    render :json => format_issues_json(issues)
-  end
-
-  private
-
-  def find_project
-    if params[:project_id].present?
-      @project = Project.find(params[:project_id])
-    end
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def format_issues_json(issues)
-    issues.map {|issue|
-      {
-        'id' => issue.id,
-        'label' => "#{issue.tracker} ##{issue.id}: #{issue.subject.to_s.truncate(60)}",
-        'value' => issue.id
-      }
-    }
-  end
-end

app/controllers/boards_controller.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class BoardsController < ApplicationController
-  default_search_scope :messages
-  before_action :find_project_by_project_id, :find_board_if_available, :authorize
-  accept_rss_auth :index, :show
-
-  helper :sort
-  include SortHelper
-  helper :watchers
-
-  def index
-    @boards = @project.boards.preload(:last_message => :author).to_a
-    # show the board if there is only one
-    if @boards.size == 1
-      @board = @boards.first
-      show
-    end
-  end
-
-  def show
-    respond_to do |format|
-      format.html {
-        sort_init 'updated_on', 'desc'
-        sort_update 'created_on' => "#{Message.table_name}.id",
-                    'replies' => "#{Message.table_name}.replies_count",
-                    'updated_on' => "COALESCE(#{Message.table_name}.last_reply_id, #{Message.table_name}.id)"
-
-        @topic_count = @board.topics.count
-        @topic_pages = Paginator.new @topic_count, per_page_option, params['page']
-        @topics =  @board.topics.
-          reorder(:sticky => :desc).
-          limit(@topic_pages.per_page).
-          offset(@topic_pages.offset).
-          order(sort_clause).
-          preload(:author, {:last_reply => :author}).
-          to_a
-        @message = Message.new(:board => @board)
-        render :action => 'show', :layout => !request.xhr?
-      }
-      format.atom {
-        @messages = @board.messages.
-          reorder(:id => :desc).
-          includes(:author, :board).
-          limit(Setting.feeds_limit.to_i).
-          to_a
-        render_feed(@messages, :title => "#{@project}: #{@board}")
-      }
-    end
-  end
-
-  def new
-    @board = @project.boards.build
-    @board.safe_attributes = params[:board]
-  end
-
-  def create
-    @board = @project.boards.build
-    @board.safe_attributes = params[:board]
-    if @board.save
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to_settings_in_projects
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @board.safe_attributes = params[:board]
-    if @board.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to_settings_in_projects
-        }
-        format.js { head 200 }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.js { head 422 }
-      end
-    end
-  end
-
-  def destroy
-    if @board.destroy
-      flash[:notice] = l(:notice_successful_delete)
-    end
-    redirect_to_settings_in_projects
-  end
-
-  private
-
-  def redirect_to_settings_in_projects
-    redirect_to settings_project_path(@project, :tab => 'boards')
-  end
-
-  def find_board_if_available
-    @board = @project.boards.find(params[:id]) if params[:id]
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/calendars_controller.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class CalendarsController < ApplicationController
-  menu_item :calendar
-  before_action :find_optional_project
-
-  rescue_from Query::StatementInvalid, :with => :query_statement_invalid
-
-  helper :issues
-  helper :projects
-  helper :queries
-  include QueriesHelper
-
-  def show
-    if params[:year] and params[:year].to_i > 1900
-      @year = params[:year].to_i
-      if params[:month] and params[:month].to_i > 0 and params[:month].to_i < 13
-        @month = params[:month].to_i
-      end
-    end
-    @year ||= User.current.today.year
-    @month ||= User.current.today.month
-
-    @calendar = Redmine::Helpers::Calendar.new(Date.civil(@year, @month, 1), current_language, :month)
-    retrieve_query
-    @query.group_by = nil
-    @query.sort_criteria = nil
-    if @query.valid?
-      events = []
-      events += @query.issues(:include => [:tracker, :assigned_to, :priority],
-                              :conditions => ["((start_date BETWEEN ? AND ?) OR (due_date BETWEEN ? AND ?))", @calendar.startdt, @calendar.enddt, @calendar.startdt, @calendar.enddt]
-                              )
-      events += @query.versions(:conditions => ["effective_date BETWEEN ? AND ?", @calendar.startdt, @calendar.enddt])
-
-      @calendar.events = events
-    end
-
-    render :action => 'show', :layout => false if request.xhr?
-  end
-end

app/controllers/comments_controller.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class CommentsController < ApplicationController
-  default_search_scope :news
-  model_object News
-  before_action :find_model_object
-  before_action :find_project_from_association
-  before_action :authorize
-
-  def create
-    raise Unauthorized unless @news.commentable?
-
-    @comment = Comment.new
-    @comment.safe_attributes = params[:comment]
-    @comment.author = User.current
-    if @news.comments << @comment
-      flash[:notice] = l(:label_comment_added)
-    end
-
-    redirect_to news_path(@news)
-  end
-
-  def destroy
-    @news.comments.find(params[:comment_id]).destroy
-    redirect_to news_path(@news)
-  end
-
-  private
-
-  # ApplicationController's find_model_object sets it based on the controller
-  # name so it needs to be overridden and set to @news instead
-  def find_model_object
-    super
-    @news = @object
-    @comment = nil
-    @news
-  end
-end

app/controllers/context_menus_controller.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class ContextMenusController < ApplicationController
-  helper :watchers
-  helper :issues
-
-  before_action :find_issues, :only => :issues
-
-  def issues
-    if @issues.size == 1
-      @issue = @issues.first
-    end
-    @issue_ids = @issues.map(&:id).sort
-
-    @allowed_statuses = @issues.map(&:new_statuses_allowed_to).reduce(:&)
-
-    @can = {:edit => @issues.all?(&:attributes_editable?),
-            :log_time => (@project && User.current.allowed_to?(:log_time, @project)),
-            :copy => User.current.allowed_to?(:copy_issues, @projects) && Issue.allowed_target_projects.any?,
-            :add_watchers => User.current.allowed_to?(:add_issue_watchers, @projects),
-            :delete => @issues.all?(&:deletable?)
-            }
-
-    @assignables = @issues.map(&:assignable_users).reduce(:&)
-    @trackers = @projects.map {|p| Issue.allowed_target_trackers(p) }.reduce(:&)
-    @versions = @projects.map {|p| p.shared_versions.open}.reduce(:&)
-
-    @priorities = IssuePriority.active.reverse
-    @back = back_url
-
-    @columns = params[:c]
-
-    @options_by_custom_field = {}
-    if @can[:edit]
-      custom_fields = @issues.map(&:editable_custom_fields).reduce(:&).reject(&:multiple?).select {|field| field.format.bulk_edit_supported}
-      custom_fields.each do |field|
-        values = field.possible_values_options(@projects)
-        if values.present?
-          @options_by_custom_field[field] = values
-        end
-      end
-    end
-
-    @safe_attributes = @issues.map(&:safe_attribute_names).reduce(:&)
-    render :layout => false
-  end
-
-  def time_entries
-    @time_entries = TimeEntry.where(:id => params[:ids]).
-      preload(:project => :time_entry_activities).
-      preload(:user).to_a
-
-    (render_404; return) unless @time_entries.present?
-    if @time_entries.size == 1
-      @time_entry = @time_entries.first
-    end
-
-    @projects = @time_entries.collect(&:project).compact.uniq
-    @project = @projects.first if @projects.size == 1
-    @activities = @projects.map(&:activities).reduce(:&)
-
-    edit_allowed = @time_entries.all? {|t| t.editable_by?(User.current)}
-    @can = {:edit => edit_allowed, :delete => edit_allowed}
-    @back = back_url
-
-    @options_by_custom_field = {}
-    if @can[:edit]
-      custom_fields = @time_entries.map(&:editable_custom_fields).reduce(:&).reject(&:multiple?).select {|field| field.format.bulk_edit_supported}
-      custom_fields.each do |field|
-        values = field.possible_values_options(@projects)
-        if values.present?
-          @options_by_custom_field[field] = values
-        end
-      end
-    end
-
-    render :layout => false
-  end
-end

app/controllers/custom_field_enumerations_controller.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class CustomFieldEnumerationsController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin
-  before_action :find_custom_field
-  before_action :find_enumeration, :only => :destroy
-
-  helper :custom_fields
-
-  def index
-    @values = @custom_field.enumerations.order(:position)
-  end
-
-  def create
-    @value = @custom_field.enumerations.build
-    @value.attributes = enumeration_params
-    @value.save
-    respond_to do |format|
-      format.html { redirect_to custom_field_enumerations_path(@custom_field) }
-      format.js
-    end
-  end
-
-  def update_each
-    saved = CustomFieldEnumeration.update_each(@custom_field, update_each_params)
-    if saved
-      flash[:notice] = l(:notice_successful_update)
-    end
-    redirect_to :action => 'index'
-  end
-
-  def destroy
-    reassign_to = @custom_field.enumerations.find_by_id(params[:reassign_to_id])
-    if reassign_to.nil? && @value.in_use?
-      @enumerations = @custom_field.enumerations - [@value]
-      render :action => 'destroy'
-      return
-    end
-    @value.destroy(reassign_to)
-    redirect_to custom_field_enumerations_path(@custom_field)
-  end
-
-  private
-
-  def find_custom_field
-    @custom_field = CustomField.find(params[:custom_field_id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def find_enumeration
-    @value = @custom_field.enumerations.find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def enumeration_params
-    params.require(:custom_field_enumeration).permit(:name, :active, :position)
-  end
-
-  def update_each_params
-    # params.require(:custom_field_enumerations).permit(:name, :active, :position) does not work here with param like this:
-    # "custom_field_enumerations":{"0":{"name": ...}, "1":{"name...}}
-    params.permit(:custom_field_enumerations => [:name, :active, :position]).require(:custom_field_enumerations)
-  end
-end

app/controllers/custom_fields_controller.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class CustomFieldsController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin
-  before_action :build_new_custom_field, :only => [:new, :create]
-  before_action :find_custom_field, :only => [:edit, :update, :destroy]
-  accept_api_auth :index
-
-  def index
-    respond_to do |format|
-      format.html {
-        @custom_fields_by_type = CustomField.all.group_by {|f| f.class.name }
-        @custom_fields_projects_count =
-          IssueCustomField.where(is_for_all: false).joins(:projects).group(:custom_field_id).count
-      }
-      format.api {
-        @custom_fields = CustomField.all
-      }
-    end
-  end
-
-  def new
-    @custom_field.field_format = 'string' if @custom_field.field_format.blank?
-    @custom_field.default_value = nil
-  end
-
-  def create
-    if @custom_field.save
-      flash[:notice] = l(:notice_successful_create)
-      call_hook(:controller_custom_fields_new_after_save, :params => params, :custom_field => @custom_field)
-      if params[:continue]
-        redirect_to new_custom_field_path({:type => @custom_field.type})
-      else
-        redirect_to edit_custom_field_path(@custom_field)
-      end
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @custom_field.safe_attributes = params[:custom_field]
-    if @custom_field.save
-      call_hook(:controller_custom_fields_edit_after_save, :params => params, :custom_field => @custom_field)
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_back_or_default edit_custom_field_path(@custom_field)
-        }
-        format.js { head 200 }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.js { head 422 }
-      end
-    end
-  end
-
-  def destroy
-    begin
-      if @custom_field.destroy
-        flash[:notice] = l(:notice_successful_delete)
-      end
-    rescue
-      flash[:error] = l(:error_can_not_delete_custom_field)
-    end
-    redirect_to custom_fields_path(:tab => @custom_field.class.name)
-  end
-
-  private
-
-  def build_new_custom_field
-    @custom_field = CustomField.new_subclass_instance(params[:type])
-    if @custom_field.nil?
-      render :action => 'select_type'
-    else
-      @custom_field.safe_attributes = params[:custom_field]
-    end
-  end
-
-  def find_custom_field
-    @custom_field = CustomField.find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/documents_controller.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class DocumentsController < ApplicationController
-  default_search_scope :documents
-  model_object Document
-  before_action :find_project_by_project_id, :only => [:index, :new, :create]
-  before_action :find_model_object, :except => [:index, :new, :create]
-  before_action :find_project_from_association, :except => [:index, :new, :create]
-  before_action :authorize
-
-  helper :attachments
-  helper :custom_fields
-
-  def index
-    @sort_by = %w(category date title author).include?(params[:sort_by]) ? params[:sort_by] : 'category'
-    documents = @project.documents.includes(:attachments, :category).to_a
-    case @sort_by
-    when 'date'
-      documents.sort!{|a,b| b.updated_on <=> a.updated_on}
-      @grouped = documents.group_by {|d| d.updated_on.to_date}
-    when 'title'
-      @grouped = documents.group_by {|d| d.title.first.upcase}
-    when 'author'
-      @grouped = documents.select{|d| d.attachments.any?}.group_by {|d| d.attachments.last.author}
-    else
-      @grouped = documents.group_by(&:category)
-    end
-    @document = @project.documents.build
-    render :layout => false if request.xhr?
-  end
-
-  def show
-    @attachments = @document.attachments.to_a
-  end
-
-  def new
-    @document = @project.documents.build
-    @document.safe_attributes = params[:document]
-  end
-
-  def create
-    @document = @project.documents.build
-    @document.safe_attributes = params[:document]
-    @document.save_attachments(params[:attachments])
-    if @document.save
-      render_attachment_warning_if_needed(@document)
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to project_documents_path(@project)
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @document.safe_attributes = params[:document]
-    if @document.save
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to document_path(@document)
-    else
-      render :action => 'edit'
-    end
-  end
-
-  def destroy
-    @document.destroy if request.delete?
-    redirect_to project_documents_path(@project)
-  end
-
-  def add_attachment
-    attachments = Attachment.attach_files(@document, params[:attachments])
-    render_attachment_warning_if_needed(@document)
-
-    if attachments.present? && attachments[:files].present? && Setting.notified_events.include?('document_added')
-      Mailer.deliver_attachments_added(attachments[:files])
-    end
-    redirect_to document_path(@document)
-  end
-end

app/controllers/email_addresses_controller.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class EmailAddressesController < ApplicationController
-  self.main_menu = false
-  before_action :find_user, :require_admin_or_current_user
-  before_action :find_email_address, :only => [:update, :destroy]
-  require_sudo_mode :create, :update, :destroy
-
-  def index
-    @addresses = @user.email_addresses.order(:id).where(:is_default => false).to_a
-    @address ||= EmailAddress.new
-  end
-
-  def create
-    saved = false
-    if @user.email_addresses.count <= Setting.max_additional_emails.to_i
-      @address = EmailAddress.new(:user => @user, :is_default => false)
-      @address.safe_attributes = params[:email_address]
-      saved = @address.save
-    end
-
-    respond_to do |format|
-      format.html {
-        if saved
-          redirect_to user_email_addresses_path(@user)
-        else
-          index
-          render :action => 'index'
-        end
-      }
-      format.js {
-        @address = nil if saved
-        index
-        render :action => 'index'
-      }
-    end
-  end
-
-  def update
-    if params[:notify].present?
-      @address.notify = params[:notify].to_s
-    end
-    @address.save
-
-    respond_to do |format|
-      format.html {
-        redirect_to user_email_addresses_path(@user)
-      }
-      format.js {
-        @address = nil
-        index
-        render :action => 'index'
-      }
-    end
-  end
-
-  def destroy
-    @address.destroy
-
-    respond_to do |format|
-      format.html {
-        redirect_to user_email_addresses_path(@user)
-      }
-      format.js {
-        @address = nil
-        index
-        render :action => 'index'
-      }
-    end
-  end
-
-  private
-
-  def find_user
-    @user = User.find(params[:user_id])
-  end
-
-  def find_email_address
-    @address = @user.email_addresses.where(:is_default => false).find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def require_admin_or_current_user
-    unless @user == User.current
-      require_admin
-    end
-  end
-end

app/controllers/enumerations_controller.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class EnumerationsController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin, :except => :index
-  before_action :require_admin_or_api_request, :only => :index
-  before_action :build_new_enumeration, :only => [:new, :create]
-  before_action :find_enumeration, :only => [:edit, :update, :destroy]
-  accept_api_auth :index
-
-  helper :custom_fields
-
-  def index
-    respond_to do |format|
-      format.html
-      format.api {
-        @klass = Enumeration.get_subclass(params[:type])
-        if @klass
-          @enumerations = @klass.shared.sorted.to_a
-        else
-          render_404
-        end
-      }
-    end
-  end
-
-  def new
-  end
-
-  def create
-    if request.post? && @enumeration.save
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to enumerations_path
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    if @enumeration.update(enumeration_params)
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to enumerations_path
-        }
-        format.js { head 200 }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.js { head 422 }
-      end
-    end
-  end
-
-  def destroy
-    if !@enumeration.in_use?
-      # No associated objects
-      @enumeration.destroy
-      redirect_to enumerations_path
-      return
-    elsif params[:reassign_to_id].present? && (reassign_to = @enumeration.class.find_by_id(params[:reassign_to_id].to_i))
-      @enumeration.destroy(reassign_to)
-      redirect_to enumerations_path
-      return
-    end
-    @enumerations = @enumeration.class.system.to_a - [@enumeration]
-  end
-
-  private
-
-  def build_new_enumeration
-    class_name = params[:enumeration] && params[:enumeration][:type] || params[:type]
-    @enumeration = Enumeration.new_subclass_instance(class_name)
-    if @enumeration
-      @enumeration.attributes = enumeration_params || {}
-    else
-      render_404
-    end
-  end
-
-  def find_enumeration
-    @enumeration = Enumeration.find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def enumeration_params
-    # can't require enumeration on #new action
-    cf_ids = @enumeration.available_custom_fields.map {|c| c.multiple? ? {c.id.to_s => []} : c.id.to_s}
-    params.permit(:enumeration => [:name, :active, :is_default, :position, :custom_field_values => cf_ids])[:enumeration]
-  end
-end

app/controllers/files_controller.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class FilesController < ApplicationController
-  menu_item :files
-
-  before_action :find_project_by_project_id
-  before_action :authorize
-  accept_api_auth :index, :create
-
-  helper :attachments
-  helper :sort
-  include SortHelper
-
-  def index
-    sort_init 'filename', 'asc'
-    sort_update 'filename' => "#{Attachment.table_name}.filename",
-                'created_on' => "#{Attachment.table_name}.created_on",
-                'size' => "#{Attachment.table_name}.filesize",
-                'downloads' => "#{Attachment.table_name}.downloads"
-
-    @containers = [Project.includes(:attachments).
-                     references(:attachments).reorder(sort_clause).find(@project.id)]
-    @containers += @project.versions.includes(:attachments).
-                    references(:attachments).reorder(sort_clause).to_a.sort.reverse
-    respond_to do |format|
-      format.html { render :layout => !request.xhr? }
-      format.api
-    end
-  end
-
-  def new
-    @versions = @project.versions.sorted
-  end
-
-  def create
-    version_id = params[:version_id] || (params[:file] && params[:file][:version_id])
-    container = version_id.blank? ? @project : @project.versions.find_by_id(version_id)
-    attachments = Attachment.attach_files(container, (params[:attachments] || (params[:file] && params[:file][:token] && params)))
-    render_attachment_warning_if_needed(container)
-
-    if attachments[:files].present?
-      if Setting.notified_events.include?('file_added')
-        Mailer.deliver_attachments_added(attachments[:files])
-      end
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:label_file_added)
-          redirect_to project_files_path(@project)
-        }
-        format.api { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html {
-          flash.now[:error] = l(:label_attachment) + " " + l('activerecord.errors.messages.invalid')
-          new
-          render :action => 'new'
-        }
-        format.api { render :status => :bad_request }
-      end
-    end
-  end
-end

app/controllers/gantts_controller.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class GanttsController < ApplicationController
-  menu_item :gantt
-  before_action :find_optional_project
-
-  rescue_from Query::StatementInvalid, :with => :query_statement_invalid
-
-  helper :gantt
-  helper :issues
-  helper :projects
-  helper :queries
-  include QueriesHelper
-  include Redmine::Export::PDF
-
-  def show
-    @gantt = Redmine::Helpers::Gantt.new(params)
-    @gantt.project = @project
-    retrieve_query
-    @query.group_by = nil
-    @gantt.query = @query if @query.valid?
-
-    basename = (@project ? "#{@project.identifier}-" : '') + 'gantt'
-
-    respond_to do |format|
-      format.html { render :action => "show", :layout => !request.xhr? }
-      format.png  { send_data(@gantt.to_image, :disposition => 'inline', :type => 'image/png', :filename => "#{basename}.png") } if @gantt.respond_to?('to_image')
-      format.pdf  { send_data(@gantt.to_pdf, :type => 'application/pdf', :filename => "#{basename}.pdf") }
-    end
-  end
-end

app/controllers/groups_controller.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class GroupsController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin
-  before_action :find_group, :except => [:index, :new, :create]
-  accept_api_auth :index, :show, :create, :update, :destroy, :add_users, :remove_user
-
-  require_sudo_mode :add_users, :remove_user, :create, :update, :destroy, :edit_membership, :destroy_membership
-
-  helper :custom_fields
-  helper :principal_memberships
-
-  def index
-    respond_to do |format|
-      format.html {
-        scope = Group.sorted
-        scope = scope.like(params[:name]) if params[:name].present?
-
-        @group_count = scope.count
-        @group_pages = Paginator.new @group_count, per_page_option, params['page']
-        @groups = scope.limit(@group_pages.per_page).offset(@group_pages.offset).to_a
-        @user_count_by_group_id = user_count_by_group_id
-      }
-      format.api {
-        scope = Group.sorted
-        scope = scope.givable unless params[:builtin] == '1'
-        @groups = scope.to_a
-      }
-    end
-  end
-
-  def show
-    respond_to do |format|
-      format.html
-      format.api
-    end
-  end
-
-  def new
-    @group = Group.new
-  end
-
-  def create
-    @group = Group.new
-    @group.safe_attributes = params[:group]
-
-    respond_to do |format|
-      if @group.save
-        format.html {
-          flash[:notice] = l(:notice_successful_create)
-          redirect_to(params[:continue] ? new_group_path : groups_path)
-        }
-        format.api  { render :action => 'show', :status => :created, :location => group_url(@group) }
-      else
-        format.html { render :action => "new" }
-        format.api  { render_validation_errors(@group) }
-      end
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @group.safe_attributes = params[:group]
-
-    respond_to do |format|
-      if @group.save
-        flash[:notice] = l(:notice_successful_update)
-        format.html { redirect_to_referer_or(groups_path) }
-        format.api  { render_api_ok }
-      else
-        format.html { render :action => "edit" }
-        format.api  { render_validation_errors(@group) }
-      end
-    end
-  end
-
-  def destroy
-    @group.destroy
-
-    respond_to do |format|
-      format.html { redirect_to_referer_or(groups_path) }
-      format.api  { render_api_ok }
-    end
-  end
-
-  def new_users
-  end
-
-  def add_users
-    @users = User.not_in_group(@group).where(:id => (params[:user_id] || params[:user_ids])).to_a
-    @group.users << @users
-    respond_to do |format|
-      format.html { redirect_to edit_group_path(@group, :tab => 'users') }
-      format.js
-      format.api {
-        if @users.any?
-          render_api_ok
-        else
-          render_api_errors "#{l(:label_user)} #{l('activerecord.errors.messages.invalid')}"
-        end
-      }
-    end
-  end
-
-  def remove_user
-    @group.users.delete(User.find(params[:user_id])) if request.delete?
-    respond_to do |format|
-      format.html { redirect_to edit_group_path(@group, :tab => 'users') }
-      format.js
-      format.api { render_api_ok }
-    end
-  end
-
-  def autocomplete_for_user
-    respond_to do |format|
-      format.js
-    end
-  end
-
-  private
-
-  def find_group
-    @group = Group.find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def user_count_by_group_id
-    h = User.joins(:groups).group('group_id').count
-    h.keys.each do |key|
-      h[key.to_i] = h.delete(key)
-    end
-    h
-  end
-end

app/controllers/imports_controller.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-require 'csv'
-
-class ImportsController < ApplicationController
-  before_action :find_import, :only => [:show, :settings, :mapping, :run]
-  before_action :authorize_import
-
-  layout :import_layout
-
-  helper :issues
-  helper :queries
-
-  def new
-    @import = import_type.new
-  end
-
-  def create
-    @import = import_type.new
-    @import.user = User.current
-    @import.file = params[:file]
-    @import.set_default_settings(:project_id => params[:project_id])
-
-    if @import.save
-      redirect_to import_settings_path(@import)
-    else
-      render :action => 'new'
-    end
-  end
-
-  def show
-  end
-
-  def settings
-    if request.post? && @import.parse_file
-      redirect_to import_mapping_path(@import)
-    end
-
-  rescue CSV::MalformedCSVError, EncodingError => e
-    if e.is_a?(CSV::MalformedCSVError) && e.message !~ /Invalid byte sequence/
-      flash.now[:error] = l(:error_invalid_csv_file_or_settings)
-    else
-      flash.now[:error] = l(:error_invalid_file_encoding, :encoding => ERB::Util.h(@import.settings['encoding']))
-    end
-  rescue SystemCallError => e
-    flash.now[:error] = l(:error_can_not_read_import_file)
-  end
-
-  def mapping
-    @custom_fields = @import.mappable_custom_fields
-
-    if request.post?
-      respond_to do |format|
-        format.html {
-          if params[:previous]
-            redirect_to import_settings_path(@import)
-          else
-            redirect_to import_run_path(@import)
-          end
-        }
-        format.js # updates mapping form on project or tracker change
-      end
-    end
-  end
-
-  def run
-    if request.post?
-      @current = @import.run(
-        :max_items => max_items_per_request,
-        :max_time => 10.seconds
-      )
-      respond_to do |format|
-        format.html {
-          if @import.finished?
-            redirect_to import_path(@import)
-          else
-            redirect_to import_run_path(@import)
-          end
-        }
-        format.js
-      end
-    end
-  end
-
-  def current_menu(project)
-    if import_layout == 'admin'
-      nil
-    else
-      :application_menu
-    end
-  end
-
-  private
-
-  def find_import
-    @import = Import.where(:user_id => User.current.id, :filename => params[:id]).first
-    if @import.nil?
-      render_404
-      return
-    elsif @import.finished? && action_name != 'show'
-      redirect_to import_path(@import)
-      return
-    end
-    update_from_params if request.post?
-  end
-
-  def update_from_params
-    if params[:import_settings].present?
-      @import.settings ||= {}
-      @import.settings.merge!(params[:import_settings].to_unsafe_hash)
-      @import.save!
-    end
-  end
-
-  def max_items_per_request
-    5
-  end
-
-  def import_layout
-    import_type && import_type.layout || 'base'
-  end
-
-  def menu_items
-    menu_item = import_type ? import_type.menu_item : nil
-
-    { self.controller_name.to_sym => { :actions => {}, :default => menu_item } }
-  end
-
-  def authorize_import
-    return render_404 unless import_type
-    return render_403 unless import_type.authorized?(User.current)
-  end
-
-  def import_type
-    return @import_type if defined? @import_type
-
-    @import_type =
-      if @import
-        @import.class
-      else
-        type = Object.const_get(params[:type]) rescue nil
-        type && type < Import ? type : nil
-      end
-  end
-end

app/controllers/issue_categories_controller.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class IssueCategoriesController < ApplicationController
-  menu_item :settings
-  model_object IssueCategory
-  before_action :find_model_object, :except => [:index, :new, :create]
-  before_action :find_project_from_association, :except => [:index, :new, :create]
-  before_action :find_project_by_project_id, :only => [:index, :new, :create]
-  before_action :authorize
-  accept_api_auth :index, :show, :create, :update, :destroy
-
-  def index
-    respond_to do |format|
-      format.html { redirect_to_settings_in_projects }
-      format.api { @categories = @project.issue_categories.to_a }
-    end
-  end
-
-  def show
-    respond_to do |format|
-      format.html { redirect_to_settings_in_projects }
-      format.api
-    end
-  end
-
-  def new
-    @category = @project.issue_categories.build
-    @category.safe_attributes = params[:issue_category]
-
-    respond_to do |format|
-      format.html
-      format.js
-    end
-  end
-
-  def create
-    @category = @project.issue_categories.build
-    @category.safe_attributes = params[:issue_category]
-    if @category.save
-      respond_to do |format|
-        format.html do
-          flash[:notice] = l(:notice_successful_create)
-          redirect_to_settings_in_projects
-        end
-        format.js
-        format.api { render :action => 'show', :status => :created, :location => issue_category_path(@category) }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'new'}
-        format.js   { render :action => 'new'}
-        format.api { render_validation_errors(@category) }
-      end
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @category.safe_attributes = params[:issue_category]
-    if @category.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to_settings_in_projects
-        }
-        format.api { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.api { render_validation_errors(@category) }
-      end
-    end
-  end
-
-  def destroy
-    @issue_count = @category.issues.size
-    if @issue_count == 0 || params[:todo] || api_request?
-      reassign_to = nil
-      if params[:reassign_to_id] && (params[:todo] == 'reassign' || params[:todo].blank?)
-        reassign_to = @project.issue_categories.find_by_id(params[:reassign_to_id])
-      end
-      @category.destroy(reassign_to)
-      respond_to do |format|
-        format.html { redirect_to_settings_in_projects }
-        format.api { render_api_ok }
-      end
-      return
-    end
-    @categories = @project.issue_categories - [@category]
-  end
-
-  private
-
-  def redirect_to_settings_in_projects
-    redirect_to settings_project_path(@project, :tab => 'categories')
-  end
-
-  # Wrap ApplicationController's find_model_object method to set
-  # @category instead of just @issue_category
-  def find_model_object
-    super
-    @category = @object
-  end
-end

app/controllers/issue_relations_controller.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class IssueRelationsController < ApplicationController
-  helper :issues
-
-  before_action :find_issue, :authorize, :only => [:index, :create]
-  before_action :find_relation, :only => [:show, :destroy]
-
-  accept_api_auth :index, :show, :create, :destroy
-
-  def index
-    @relations = @issue.relations
-
-    respond_to do |format|
-      format.html { head 200 }
-      format.api
-    end
-  end
-
-  def show
-    raise Unauthorized unless @relation.visible?
-
-    respond_to do |format|
-      format.html { head 200 }
-      format.api
-    end
-  end
-
-  def create
-    @relation = IssueRelation.new
-    @relation.issue_from = @issue
-    @relation.safe_attributes = params[:relation]
-    @relation.init_journals(User.current)
-
-    begin
-      saved = @relation.save
-    rescue ActiveRecord::RecordNotUnique
-      saved = false
-      @relation.errors.add :base, :taken
-    end
-
-    respond_to do |format|
-      format.html { redirect_to issue_path(@issue) }
-      format.js {
-        @relations = @issue.reload.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }
-      }
-      format.api {
-        if saved
-          render :action => 'show', :status => :created, :location => relation_url(@relation)
-        else
-          render_validation_errors(@relation)
-        end
-      }
-    end
-  end
-
-  def destroy
-    raise Unauthorized unless @relation.deletable?
-    @relation.init_journals(User.current)
-    @relation.destroy
-
-    respond_to do |format|
-      format.html { redirect_to issue_path(@relation.issue_from) }
-      format.js
-      format.api  { render_api_ok }
-    end
-  end
-
-  private
-
-  def find_issue
-    @issue = Issue.find(params[:issue_id])
-    @project = @issue.project
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def find_relation
-    @relation = IssueRelation.find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/issue_statuses_controller.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class IssueStatusesController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin, :except => :index
-  before_action :require_admin_or_api_request, :only => :index
-  accept_api_auth :index
-
-  def index
-    @issue_statuses = IssueStatus.sorted.to_a
-    respond_to do |format|
-      format.html { render :layout => false if request.xhr? }
-      format.api
-    end
-  end
-
-  def new
-    @issue_status = IssueStatus.new
-  end
-
-  def create
-    @issue_status = IssueStatus.new
-    @issue_status.safe_attributes = params[:issue_status]
-    if @issue_status.save
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to issue_statuses_path
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-    @issue_status = IssueStatus.find(params[:id])
-  end
-
-  def update
-    @issue_status = IssueStatus.find(params[:id])
-    @issue_status.safe_attributes = params[:issue_status]
-    if @issue_status.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to issue_statuses_path(:page => params[:page])
-        }
-        format.js { head 200 }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.js { head 422 }
-      end
-    end
-  end
-
-  def destroy
-    IssueStatus.find(params[:id]).destroy
-    redirect_to issue_statuses_path
-  rescue => e
-    flash[:error] = l(:error_unable_delete_issue_status, ERB::Util.h(e.message))
-    redirect_to issue_statuses_path
-  end
-
-  def update_issue_done_ratio
-    if request.post? && IssueStatus.update_issue_done_ratios
-      flash[:notice] = l(:notice_issue_done_ratios_updated)
-    else
-      flash[:error] =  l(:error_issue_done_ratios_not_updated)
-    end
-    redirect_to issue_statuses_path
-  end
-end

app/controllers/issues_controller.rb

@@ -1,626 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class IssuesController < ApplicationController
-  default_search_scope :issues
-
-  before_action :find_issue, :only => [:show, :edit, :update, :issue_tab]
-  before_action :find_issues, :only => [:bulk_edit, :bulk_update, :destroy]
-  before_action :authorize, :except => [:index, :new, :create]
-  before_action :find_optional_project, :only => [:index, :new, :create]
-  before_action :build_new_issue_from_params, :only => [:new, :create]
-  accept_rss_auth :index, :show
-  accept_api_auth :index, :show, :create, :update, :destroy
-
-  rescue_from Query::StatementInvalid, :with => :query_statement_invalid
-
-  helper :journals
-  helper :projects
-  helper :custom_fields
-  helper :issue_relations
-  helper :watchers
-  helper :attachments
-  helper :queries
-  include QueriesHelper
-  helper :repositories
-  helper :timelog
-
-  def index
-    use_session = !request.format.csv?
-    retrieve_query(IssueQuery, use_session)
-
-    if @query.valid?
-      respond_to do |format|
-        format.html {
-          @issue_count = @query.issue_count
-          @issue_pages = Paginator.new @issue_count, per_page_option, params['page']
-          @issues = @query.issues(:offset => @issue_pages.offset, :limit => @issue_pages.per_page)
-          render :layout => !request.xhr?
-        }
-        format.api  {
-          @offset, @limit = api_offset_and_limit
-          @query.column_names = %w(author)
-          @issue_count = @query.issue_count
-          @issues = @query.issues(:offset => @offset, :limit => @limit)
-          Issue.load_visible_relations(@issues) if include_in_api_response?('relations')
-        }
-        format.atom {
-          @issues = @query.issues(:limit => Setting.feeds_limit.to_i)
-          render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}")
-        }
-        format.csv  {
-          @issues = @query.issues(:limit => Setting.issues_export_limit.to_i)
-          send_data(query_to_csv(@issues, @query, params[:csv]), :type => 'text/csv; header=present', :filename => 'issues.csv')
-        }
-        format.pdf  {
-          @issues = @query.issues(:limit => Setting.issues_export_limit.to_i)
-          send_file_headers! :type => 'application/pdf', :filename => 'issues.pdf'
-        }
-      end
-    else
-      respond_to do |format|
-        format.html { render :layout => !request.xhr? }
-        format.any(:atom, :csv, :pdf) { head 422 }
-        format.api { render_validation_errors(@query) }
-      end
-    end
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def show
-    @journals = @issue.visible_journals_with_index
-    @has_changesets = @issue.changesets.visible.preload(:repository, :user).exists?
-    @relations = @issue.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }
-
-    @journals.reverse! if User.current.wants_comments_in_reverse_order?
-
-    if User.current.allowed_to?(:view_time_entries, @project)
-      Issue.load_visible_spent_hours([@issue])
-      Issue.load_visible_total_spent_hours([@issue])
-    end
-
-    respond_to do |format|
-      format.html {
-        @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
-        @priorities = IssuePriority.active
-        @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
-        @time_entries = @issue.time_entries.visible.preload(:activity, :user)
-        @relation = IssueRelation.new
-        retrieve_previous_and_next_issue_ids
-        render :template => 'issues/show'
-      }
-      format.api {
-        @changesets = @issue.changesets.visible.preload(:repository, :user).to_a
-        @changesets.reverse! if User.current.wants_comments_in_reverse_order?
-      }
-      format.atom { render :template => 'journals/index', :layout => false, :content_type => 'application/atom+xml' }
-      format.pdf  {
-        send_file_headers! :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf"
-      }
-    end
-  end
-
-  def new
-    respond_to do |format|
-      format.html { render :action => 'new', :layout => !request.xhr? }
-      format.js
-    end
-  end
-
-  def create
-    unless User.current.allowed_to?(:add_issues, @issue.project, :global => true)
-      raise ::Unauthorized
-    end
-    call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })
-    @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))
-    if @issue.save
-      call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
-      respond_to do |format|
-        format.html {
-          render_attachment_warning_if_needed(@issue)
-          flash[:notice] = l(:notice_issue_successful_create, :id => view_context.link_to("##{@issue.id}", issue_path(@issue), :title => @issue.subject))
-          redirect_after_create
-        }
-        format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
-      end
-      return
-    else
-      respond_to do |format|
-        format.html {
-          if @issue.project.nil?
-            render_error :status => 422
-          else
-            render :action => 'new'
-          end
-        }
-        format.api  { render_validation_errors(@issue) }
-      end
-    end
-  end
-
-  def edit
-    return unless update_issue_from_params
-
-    respond_to do |format|
-      format.html { }
-      format.js
-    end
-  end
-
-  def update
-    return unless update_issue_from_params
-    @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))
-    saved = false
-    begin
-      saved = save_issue_with_child_records
-    rescue ActiveRecord::StaleObjectError
-      @conflict = true
-      if params[:last_journal_id]
-        @conflict_journals = @issue.journals_after(params[:last_journal_id]).to_a
-        @conflict_journals.reject!(&:private_notes?) unless User.current.allowed_to?(:view_private_notes, @issue.project)
-      end
-    end
-
-    if saved
-      render_attachment_warning_if_needed(@issue)
-      flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record? || params[:no_flash]
-
-      respond_to do |format|
-        format.html { redirect_back_or_default issue_path(@issue, previous_and_next_issue_ids_params) }
-        format.api  { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.api  { render_validation_errors(@issue) }
-      end
-    end
-  end
-
-  def issue_tab
-    return render_error :status => 422 unless request.xhr?
-    tab = params[:name]
-
-    case tab
-    when 'time_entries'
-      @time_entries = @issue.time_entries.visible.preload(:activity, :user).to_a
-      render :partial => 'issues/tabs/time_entries', :locals => {:time_entries => @time_entries}
-    when 'changesets'
-      @changesets = @issue.changesets.visible.preload(:repository, :user).to_a
-      @changesets.reverse! if User.current.wants_comments_in_reverse_order?
-      render :partial => 'issues/tabs/changesets', :locals => {:changesets => @changesets}
-    end
-  end
-
-  # Bulk edit/copy a set of issues
-  def bulk_edit
-    @issues.sort!
-    @copy = params[:copy].present?
-    @notes = params[:notes]
-
-    if @copy
-      unless User.current.allowed_to?(:copy_issues, @projects)
-        raise ::Unauthorized
-      end
-    else
-      unless @issues.all?(&:attributes_editable?)
-        raise ::Unauthorized
-      end
-    end
-
-    edited_issues = Issue.where(:id => @issues.map(&:id)).to_a
-
-    @values_by_custom_field = {}
-    edited_issues.each do |issue|
-      issue.custom_field_values.each do |c|
-        if c.value_present?
-          @values_by_custom_field[c.custom_field] ||= []
-          @values_by_custom_field[c.custom_field] << issue.id
-        end
-      end
-    end
-
-    @allowed_projects = Issue.allowed_target_projects
-    if params[:issue]
-      @target_project = @allowed_projects.detect {|p| p.id.to_s == params[:issue][:project_id].to_s}
-      if @target_project
-        target_projects = [@target_project]
-        edited_issues.each {|issue| issue.project = @target_project}
-      end
-    end
-    target_projects ||= @projects
-
-    @trackers = target_projects.map {|p| Issue.allowed_target_trackers(p) }.reduce(:&)
-    if params[:issue]
-      @target_tracker = @trackers.detect {|t| t.id.to_s == params[:issue][:tracker_id].to_s}
-      if @target_tracker
-        edited_issues.each {|issue| issue.tracker = @target_tracker}
-      end
-    end
-
-    if @copy
-      # Copied issues will get their default statuses
-      @available_statuses = []
-    else
-      @available_statuses = edited_issues.map(&:new_statuses_allowed_to).reduce(:&)
-    end
-    if params[:issue]
-      @target_status = @available_statuses.detect {|t| t.id.to_s == params[:issue][:status_id].to_s}
-      if @target_status
-        edited_issues.each {|issue| issue.status = @target_status}
-      end
-    end
-
-    edited_issues.each do |issue|
-      issue.custom_field_values.each do |c|
-        if c.value_present? && @values_by_custom_field[c.custom_field]
-          @values_by_custom_field[c.custom_field].delete(issue.id)
-        end
-      end
-    end
-    @values_by_custom_field.delete_if {|k,v| v.blank?}
-
-    @custom_fields = edited_issues.map{|i| i.editable_custom_fields}.reduce(:&).select {|field| field.format.bulk_edit_supported}
-    @assignables = target_projects.map(&:assignable_users).reduce(:&)
-    @versions = target_projects.map {|p| p.shared_versions.open}.reduce(:&)
-    @categories = target_projects.map {|p| p.issue_categories}.reduce(:&)
-    if @copy
-      @attachments_present = @issues.detect {|i| i.attachments.any?}.present?
-      @subtasks_present = @issues.detect {|i| !i.leaf?}.present?
-      @watchers_present = User.current.allowed_to?(:add_issue_watchers, @projects) &&
-                            Watcher.where(:watchable_type => 'Issue',
-                                          :watchable_id => @issues.map(&:id)).exists?
-    end
-
-    @safe_attributes = edited_issues.map(&:safe_attribute_names).reduce(:&)
-
-    @issue_params = params[:issue] || {}
-    @issue_params[:custom_field_values] ||= {}
-  end
-
-  def bulk_update
-    @issues.sort!
-    @copy = params[:copy].present?
-
-    attributes = parse_params_for_bulk_update(params[:issue])
-    copy_subtasks = (params[:copy_subtasks] == '1')
-    copy_attachments = (params[:copy_attachments] == '1')
-    copy_watchers = (params[:copy_watchers] == '1')
-
-    if @copy
-      unless User.current.allowed_to?(:copy_issues, @projects)
-        raise ::Unauthorized
-      end
-      target_projects = @projects
-      if attributes['project_id'].present?
-        target_projects = Project.where(:id => attributes['project_id']).to_a
-      end
-      unless User.current.allowed_to?(:add_issues, target_projects)
-        raise ::Unauthorized
-      end
-      unless User.current.allowed_to?(:add_issue_watchers, @projects)
-        copy_watchers = false
-      end
-    else
-      unless @issues.all?(&:attributes_editable?)
-        raise ::Unauthorized
-      end
-    end
-
-    unsaved_issues = []
-    saved_issues = []
-
-    if @copy && copy_subtasks
-      # Descendant issues will be copied with the parent task
-      # Don't copy them twice
-      @issues.reject! {|issue| @issues.detect {|other| issue.is_descendant_of?(other)}}
-    end
-
-    @issues.each do |orig_issue|
-      orig_issue.reload
-      if @copy
-        issue = orig_issue.copy(
-          {},
-          :attachments => copy_attachments,
-          :subtasks => copy_subtasks,
-          :watchers => copy_watchers,
-          :link => link_copy?(params[:link_copy])
-        )
-      else
-        issue = orig_issue
-      end
-      journal = issue.init_journal(User.current, params[:notes])
-      issue.safe_attributes = attributes
-      call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
-      if issue.save
-        saved_issues << issue
-      else
-        unsaved_issues << orig_issue
-      end
-    end
-
-    if unsaved_issues.empty?
-      flash[:notice] = l(:notice_successful_update) unless saved_issues.empty?
-      if params[:follow]
-        if @issues.size == 1 && saved_issues.size == 1
-          redirect_to issue_path(saved_issues.first)
-        elsif saved_issues.map(&:project).uniq.size == 1
-          redirect_to project_issues_path(saved_issues.map(&:project).first)
-        end
-      else
-        redirect_back_or_default _project_issues_path(@project)
-      end
-    else
-      @saved_issues = @issues
-      @unsaved_issues = unsaved_issues
-      @issues = Issue.visible.where(:id => @unsaved_issues.map(&:id)).to_a
-      bulk_edit
-      render :action => 'bulk_edit'
-    end
-  end
-
-  def destroy
-    raise Unauthorized unless @issues.all?(&:deletable?)
-
-    # all issues and their descendants are about to be deleted
-    issues_and_descendants_ids = Issue.self_and_descendants(@issues).pluck(:id)
-    time_entries = TimeEntry.where(:issue_id => issues_and_descendants_ids)
-    @hours = time_entries.sum(:hours).to_f
-
-    if @hours > 0
-      case params[:todo]
-      when 'destroy'
-        # nothing to do
-      when 'nullify'
-        if Setting.timelog_required_fields.include?('issue_id')
-          flash.now[:error] = l(:field_issue) + " " + ::I18n.t('activerecord.errors.messages.blank')
-          return
-        else
-        time_entries.update_all(:issue_id => nil)
-        end
-      when 'reassign'
-        reassign_to = @project && @project.issues.find_by_id(params[:reassign_to_id])
-        if reassign_to.nil?
-          flash.now[:error] = l(:error_issue_not_found_in_project)
-          return
-        elsif issues_and_descendants_ids.include?(reassign_to.id)
-          flash.now[:error] = l(:error_cannot_reassign_time_entries_to_an_issue_about_to_be_deleted)
-          return
-        else
-          time_entries.update_all(:issue_id => reassign_to.id, :project_id => reassign_to.project_id)
-        end
-      else
-        # display the destroy form if it's a user request
-        return unless api_request?
-      end
-    end
-    @issues.each do |issue|
-      begin
-        issue.reload.destroy
-      rescue ::ActiveRecord::RecordNotFound # raised by #reload if issue no longer exists
-        # nothing to do, issue was already deleted (eg. by a parent)
-      end
-    end
-    respond_to do |format|
-      format.html { redirect_back_or_default _project_issues_path(@project) }
-      format.api  { render_api_ok }
-    end
-  end
-
-  # Overrides Redmine::MenuManager::MenuController::ClassMethods for
-  # when the "New issue" tab is enabled
-  def current_menu_item
-    if Setting.new_item_menu_tab == '1' && [:new, :create].include?(action_name.to_sym)
-      :new_issue
-    else
-      super
-    end
-  end
-
-  private
-
-  def retrieve_previous_and_next_issue_ids
-    if params[:prev_issue_id].present? || params[:next_issue_id].present?
-      @prev_issue_id = params[:prev_issue_id].presence.try(:to_i)
-      @next_issue_id = params[:next_issue_id].presence.try(:to_i)
-      @issue_position = params[:issue_position].presence.try(:to_i)
-      @issue_count = params[:issue_count].presence.try(:to_i)
-    else
-      retrieve_query_from_session
-      if @query
-        @per_page = per_page_option
-        limit = 500
-        issue_ids = @query.issue_ids(:limit => (limit + 1))
-        if (idx = issue_ids.index(@issue.id)) && idx < limit
-          if issue_ids.size < 500
-            @issue_position = idx + 1
-            @issue_count = issue_ids.size
-          end
-          @prev_issue_id = issue_ids[idx - 1] if idx > 0
-          @next_issue_id = issue_ids[idx + 1] if idx < (issue_ids.size - 1)
-        end
-        query_params = @query.as_params
-        if @issue_position
-          query_params = query_params.merge(:page => (@issue_position / per_page_option) + 1, :per_page => per_page_option)
-        end
-        @query_path = _project_issues_path(@query.project, query_params)
-      end
-    end
-  end
-
-  def previous_and_next_issue_ids_params
-    {
-      :prev_issue_id => params[:prev_issue_id],
-      :next_issue_id => params[:next_issue_id],
-      :issue_position => params[:issue_position],
-      :issue_count => params[:issue_count]
-    }.reject {|k,v| k.blank?}
-  end
-
-  # Used by #edit and #update to set some common instance variables
-  # from the params
-  def update_issue_from_params
-    @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
-    if params[:time_entry]
-      @time_entry.safe_attributes = params[:time_entry]
-    end
-
-    @issue.init_journal(User.current)
-
-    issue_attributes = params[:issue]
-    issue_attributes[:assigned_to_id] = User.current.id if issue_attributes && issue_attributes[:assigned_to_id] == 'me'
-    if issue_attributes && params[:conflict_resolution]
-      case params[:conflict_resolution]
-      when 'overwrite'
-        issue_attributes = issue_attributes.dup
-        issue_attributes.delete(:lock_version)
-      when 'add_notes'
-        issue_attributes = issue_attributes.slice(:notes, :private_notes)
-      when 'cancel'
-        redirect_to issue_path(@issue)
-        return false
-      end
-    end
-    @issue.safe_attributes = issue_attributes
-    @priorities = IssuePriority.active
-    @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
-    true
-  end
-
-  # Used by #new and #create to build a new issue from the params
-  # The new issue will be copied from an existing one if copy_from parameter is given
-  def build_new_issue_from_params
-    @issue = Issue.new
-    if params[:copy_from]
-      begin
-        @issue.init_journal(User.current)
-        @copy_from = Issue.visible.find(params[:copy_from])
-        unless User.current.allowed_to?(:copy_issues, @copy_from.project)
-          raise ::Unauthorized
-        end
-        @link_copy = link_copy?(params[:link_copy]) || request.get?
-        @copy_attachments = params[:copy_attachments].present? || request.get?
-        @copy_subtasks = params[:copy_subtasks].present? || request.get?
-        @copy_watchers = User.current.allowed_to?(:add_issue_watchers, @project)
-        @issue.copy_from(@copy_from, :attachments => @copy_attachments, :subtasks => @copy_subtasks, :watchers => @copy_watchers, :link => @link_copy)
-        @issue.parent_issue_id = @copy_from.parent_id
-      rescue ActiveRecord::RecordNotFound
-        render_404
-        return
-      end
-    end
-    @issue.project = @project
-    if request.get?
-      @issue.project ||= @issue.allowed_target_projects.first
-    end
-    @issue.author ||= User.current
-    @issue.start_date ||= User.current.today if Setting.default_issue_start_date_to_creation_date?
-
-    attrs = (params[:issue] || {}).deep_dup
-    if action_name == 'new' && params[:was_default_status] == attrs[:status_id]
-      attrs.delete(:status_id)
-    end
-    if action_name == 'new' && params[:form_update_triggered_by] == 'issue_project_id'
-      # Discard submitted version when changing the project on the issue form
-      # so we can use the default version for the new project
-      attrs.delete(:fixed_version_id)
-    end
-    attrs[:assigned_to_id] = User.current.id if attrs[:assigned_to_id] == 'me'
-    @issue.safe_attributes = attrs
-
-    if @issue.project
-      @issue.tracker ||= @issue.allowed_target_trackers.first
-      if @issue.tracker.nil?
-        if @issue.project.trackers.any?
-          # None of the project trackers is allowed to the user
-          render_error :message => l(:error_no_tracker_allowed_for_new_issue_in_project), :status => 403
-        else
-          # Project has no trackers
-          render_error l(:error_no_tracker_in_project)
-        end
-        return false
-      end
-      if @issue.status.nil?
-        render_error l(:error_no_default_issue_status)
-        return false
-      end
-    elsif request.get?
-      render_error :message => l(:error_no_projects_with_tracker_allowed_for_new_issue), :status => 403
-      return false
-    end
-
-    @priorities = IssuePriority.active
-    @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
-  end
-
-  # Saves @issue and a time_entry from the parameters
-  def save_issue_with_child_records
-    Issue.transaction do
-      if params[:time_entry] && (params[:time_entry][:hours].present? || params[:time_entry][:comments].present?) && User.current.allowed_to?(:log_time, @issue.project)
-        time_entry = @time_entry || TimeEntry.new
-        time_entry.project = @issue.project
-        time_entry.issue = @issue
-        time_entry.author = User.current
-        time_entry.user = User.current
-        time_entry.spent_on = User.current.today
-        time_entry.safe_attributes = params[:time_entry]
-        @issue.time_entries << time_entry
-      end
-
-      call_hook(:controller_issues_edit_before_save, { :params => params, :issue => @issue, :time_entry => time_entry, :journal => @issue.current_journal})
-      if @issue.save
-        call_hook(:controller_issues_edit_after_save, { :params => params, :issue => @issue, :time_entry => time_entry, :journal => @issue.current_journal})
-      else
-        raise ActiveRecord::Rollback
-      end
-    end
-  end
-
-  # Returns true if the issue copy should be linked
-  # to the original issue
-  def link_copy?(param)
-    case Setting.link_copied_issue
-    when 'yes'
-      true
-    when 'no'
-      false
-    when 'ask'
-      param == '1'
-    end
-  end
-
-  # Redirects user after a successful issue creation
-  def redirect_after_create
-    if params[:continue]
-      url_params = {}
-      url_params[:issue] = {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?}
-      url_params[:back_url] = params[:back_url].presence
-
-      if params[:project_id]
-        redirect_to new_project_issue_path(@issue.project, url_params)
-      else
-        url_params[:issue].merge! :project_id => @issue.project_id
-        redirect_to new_issue_path(url_params)
-      end
-    else
-      redirect_back_or_default issue_path(@issue)
-    end
-  end
-end

app/controllers/journals_controller.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class JournalsController < ApplicationController
-  before_action :find_journal, :only => [:edit, :update, :diff]
-  before_action :find_issue, :only => [:new]
-  before_action :find_optional_project, :only => [:index]
-  before_action :authorize, :only => [:new, :edit, :update, :diff]
-  accept_rss_auth :index
-  menu_item :issues
-
-  helper :issues
-  helper :custom_fields
-  helper :queries
-  include QueriesHelper
-
-  def index
-    retrieve_query
-    if @query.valid?
-      @journals = @query.journals(:order => "#{Journal.table_name}.created_on DESC",
-                                  :limit => 25)
-    end
-    @title = (@project ? @project.name : Setting.app_title) + ": " + (@query.new_record? ? l(:label_changes_details) : @query.name)
-    render :layout => false, :content_type => 'application/atom+xml'
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def diff
-    @issue = @journal.issue
-    if params[:detail_id].present?
-      @detail = @journal.details.find_by_id(params[:detail_id])
-    else
-      @detail = @journal.details.detect {|d| d.property == 'attr' && d.prop_key == 'description'}
-    end
-    unless @issue && @detail
-      render_404
-      return false
-    end
-    if @detail.property == 'cf'
-      unless @detail.custom_field && @detail.custom_field.visible_by?(@issue.project, User.current)
-        raise ::Unauthorized
-      end
-    end
-    @diff = Redmine::Helpers::Diff.new(@detail.value, @detail.old_value)
-  end
-
-  def new
-    @journal = Journal.visible.find(params[:journal_id]) if params[:journal_id]
-    if @journal
-      user = @journal.user
-      text = @journal.notes
-      @content = +"#{ll(Setting.default_language, :text_user_wrote_in, {:value => user, :link => "#note-#{params[:journal_indice]}"})}\n> "
-    else
-      user = @issue.author
-      text = @issue.description
-      @content = +"#{ll(Setting.default_language, :text_user_wrote, user)}\n> "
-    end
-    # Replaces pre blocks with [...]
-    text = text.to_s.strip.gsub(%r{<pre>(.*?)</pre>}m, '[...]')
-    @content << text.gsub(/(\r?\n|\r\n?)/, "\n> ") + "\n\n"
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def edit
-    (render_403; return false) unless @journal.editable_by?(User.current)
-    respond_to do |format|
-      # TODO: implement non-JS journal update
-      format.js
-    end
-  end
-
-  def update
-    (render_403; return false) unless @journal.editable_by?(User.current)
-    @journal.safe_attributes = params[:journal]
-    @journal.save
-    @journal.destroy if @journal.details.empty? && @journal.notes.blank?
-    call_hook(:controller_journals_edit_post, { :journal => @journal, :params => params})
-    respond_to do |format|
-      format.html { redirect_to issue_path(@journal.journalized) }
-      format.js
-    end
-  end
-
-  private
-
-  def find_journal
-    @journal = Journal.visible.find(params[:id])
-    @project = @journal.journalized.project
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/mail_handler_controller.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class MailHandlerController < ActionController::Base
-  before_action :check_credential
-
-  # Displays the email submission form
-  def new
-  end
-
-  # Submits an incoming email to MailHandler
-  def index
-    options = params.dup
-    email = options.delete(:email)
-    if MailHandler.safe_receive(email, options)
-      head :created
-    else
-      head :unprocessable_entity
-    end
-  end
-
-  private
-
-  def check_credential
-    User.current = nil
-    unless Setting.mail_handler_api_enabled? && params[:key].to_s == Setting.mail_handler_api_key
-      render :plain => 'Access denied. Incoming emails WS is disabled or key is invalid.', :status => 403
-    end
-  end
-end

app/controllers/members_controller.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class MembersController < ApplicationController
-  model_object Member
-  before_action :find_model_object, :except => [:index, :new, :create, :autocomplete]
-  before_action :find_project_from_association, :except => [:index, :new, :create, :autocomplete]
-  before_action :find_project_by_project_id, :only => [:index, :new, :create, :autocomplete]
-  before_action :authorize
-  accept_api_auth :index, :show, :create, :update, :destroy
-
-  require_sudo_mode :create, :update, :destroy
-
-  def index
-    scope = @project.memberships
-    @offset, @limit = api_offset_and_limit
-    @member_count = scope.count
-    @member_pages = Paginator.new @member_count, @limit, params['page']
-    @offset ||= @member_pages.offset
-    @members =  scope.order(:id).limit(@limit).offset(@offset).to_a
-
-    respond_to do |format|
-      format.html { head 406 }
-      format.api
-    end
-  end
-
-  def show
-    respond_to do |format|
-      format.html { head 406 }
-      format.api
-    end
-  end
-
-  def new
-    @member = Member.new
-  end
-
-  def create
-    members = []
-    if params[:membership]
-      user_ids = Array.wrap(params[:membership][:user_id] || params[:membership][:user_ids])
-      user_ids << nil if user_ids.empty?
-      user_ids.each do |user_id|
-        member = Member.new(:project => @project, :user_id => user_id)
-        member.set_editable_role_ids(params[:membership][:role_ids])
-        members << member
-      end
-      @project.members << members
-    end
-
-    respond_to do |format|
-      format.html { redirect_to_settings_in_projects }
-      format.js {
-        @members = members
-        @member = Member.new
-      }
-      format.api {
-        @member = members.first
-        if @member.valid?
-          render :action => 'show', :status => :created, :location => membership_url(@member)
-        else
-          render_validation_errors(@member)
-        end
-      }
-    end
-  end
-
-  def edit
-    @roles = Role.givable.to_a
-  end
-
-  def update
-    if params[:membership]
-      @member.set_editable_role_ids(params[:membership][:role_ids])
-    end
-    saved = @member.save
-    respond_to do |format|
-      format.html { redirect_to_settings_in_projects }
-      format.js
-      format.api {
-        if saved
-          render_api_ok
-        else
-          render_validation_errors(@member)
-        end
-      }
-    end
-  end
-
-  def destroy
-    if @member.deletable?
-      @member.destroy
-    end
-    respond_to do |format|
-      format.html { redirect_to_settings_in_projects }
-      format.js
-      format.api {
-        if @member.destroyed?
-          render_api_ok
-        else
-          head :unprocessable_entity
-        end
-      }
-    end
-  end
-
-  def autocomplete
-    respond_to do |format|
-      format.js
-    end
-  end
-
-  private
-
-  def redirect_to_settings_in_projects
-    redirect_to settings_project_path(@project, :tab => 'members')
-  end
-end

app/controllers/messages_controller.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class MessagesController < ApplicationController
-  menu_item :boards
-  default_search_scope :messages
-  before_action :find_board, :only => [:new, :preview]
-  before_action :find_attachments, :only => [:preview]
-  before_action :find_message, :except => [:new, :preview]
-  before_action :authorize, :except => [:preview, :edit, :destroy]
-
-  helper :boards
-  helper :watchers
-  helper :attachments
-  include AttachmentsHelper
-
-  REPLIES_PER_PAGE = 25 unless const_defined?(:REPLIES_PER_PAGE)
-
-  # Show a topic and its replies
-  def show
-    page = params[:page]
-    # Find the page of the requested reply
-    if params[:r] && page.nil?
-      offset = @topic.children.where("#{Message.table_name}.id < ?", params[:r].to_i).count
-      page = 1 + offset / REPLIES_PER_PAGE
-    end
-
-    @reply_count = @topic.children.count
-    @reply_pages = Paginator.new @reply_count, REPLIES_PER_PAGE, page
-    @replies =  @topic.children.
-      includes(:author, :attachments, {:board => :project}).
-      reorder("#{Message.table_name}.created_on ASC, #{Message.table_name}.id ASC").
-      limit(@reply_pages.per_page).
-      offset(@reply_pages.offset).
-      to_a
-
-    @reply = Message.new(:subject => "RE: #{@message.subject}")
-    render :action => "show", :layout => false if request.xhr?
-  end
-
-  # Create a new topic
-  def new
-    @message = Message.new
-    @message.author = User.current
-    @message.board = @board
-    @message.safe_attributes = params[:message]
-    if request.post?
-      @message.save_attachments(params[:attachments])
-      if @message.save
-        call_hook(:controller_messages_new_after_save, { :params => params, :message => @message})
-        render_attachment_warning_if_needed(@message)
-        flash[:notice] = l(:notice_successful_create)
-        redirect_to board_message_path(@board, @message)
-      end
-    end
-  end
-
-  # Reply to a topic
-  def reply
-    @reply = Message.new
-    @reply.author = User.current
-    @reply.board = @board
-    @reply.safe_attributes = params[:reply]
-    @topic.children << @reply
-    if !@reply.new_record?
-      call_hook(:controller_messages_reply_after_save, { :params => params, :message => @reply})
-      attachments = Attachment.attach_files(@reply, params[:attachments])
-      render_attachment_warning_if_needed(@reply)
-    end
-    flash[:notice] = l(:notice_successful_update)
-    redirect_to board_message_path(@board, @topic, :r => @reply)
-  end
-
-  # Edit a message
-  def edit
-    (render_403; return false) unless @message.editable_by?(User.current)
-    @message.safe_attributes = params[:message]
-    if request.post? && @message.save
-      attachments = Attachment.attach_files(@message, params[:attachments])
-      render_attachment_warning_if_needed(@message)
-      flash[:notice] = l(:notice_successful_update)
-      @message.reload
-      redirect_to board_message_path(@message.board, @message.root, :r => (@message.parent_id && @message.id))
-    end
-  end
-
-  # Delete a messages
-  def destroy
-    (render_403; return false) unless @message.destroyable_by?(User.current)
-    r = @message.to_param
-    @message.destroy
-    flash[:notice] = l(:notice_successful_delete)
-    if @message.parent
-      redirect_to board_message_path(@board, @message.parent, :r => r)
-    else
-      redirect_to project_board_path(@project, @board)
-    end
-  end
-
-  def quote
-    @subject = @message.subject
-    @subject = "RE: #{@subject}" unless @subject.starts_with?('RE:')
-
-    if @message.root == @message
-      @content = +"#{ll(Setting.default_language, :text_user_wrote, @message.author)}\n> "
-    else
-      @content = +"#{ll(Setting.default_language, :text_user_wrote_in, {:value => @message.author, :link => "message##{@message.id}"})}\n> "
-    end
-    @content << @message.content.to_s.strip.gsub(%r{<pre>(.*?)</pre>}m, '[...]').gsub(/(\r?\n|\r\n?)/, "\n> ") + "\n\n"
-  end
-
-  def preview
-    message = @board.messages.find_by_id(params[:id])
-    @text = params[:text] ? params[:text] : nil
-    @previewed = message
-    render :partial => 'common/preview'
-  end
-
-  private
-
-  def find_message
-    return unless find_board
-    @message = @board.messages.includes(:parent).find(params[:id])
-    @topic = @message.root
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def find_board
-    @board = Board.includes(:project).find(params[:board_id])
-    @project = @board.project
-  rescue ActiveRecord::RecordNotFound
-    render_404
-    nil
-  end
-end

app/controllers/my_controller.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class MyController < ApplicationController
-  self.main_menu = false
-  before_action :require_login
-  # let user change user's password when user has to
-  skip_before_action :check_password_change, :only => :password
-
-  accept_api_auth :account
-
-  require_sudo_mode :account, only: :put
-  require_sudo_mode :reset_rss_key, :reset_api_key, :show_api_key, :destroy
-
-  helper :issues
-  helper :users
-  helper :custom_fields
-  helper :queries
-  helper :activities
-  helper :calendars
-
-  def index
-    page
-    render :action => 'page'
-  end
-
-  # Show user's page
-  def page
-    @user = User.current
-    @groups = @user.pref.my_page_groups
-    @blocks = @user.pref.my_page_layout
-  end
-
-  # Edit user's account
-  def account
-    @user = User.current
-    @pref = @user.pref
-    if request.put?
-      @user.safe_attributes = params[:user]
-      @user.pref.safe_attributes = params[:pref]
-      if @user.save
-        @user.pref.save
-        set_language_if_valid @user.language
-        respond_to do |format|
-          format.html {
-            flash[:notice] = l(:notice_account_updated)
-            redirect_to my_account_path
-          }
-          format.api  { render_api_ok }
-        end
-        return
-      else
-        respond_to do |format|
-          format.html { render :action => :account }
-          format.api  { render_validation_errors(@user) }
-        end
-      end
-    end
-  end
-
-  # Destroys user's account
-  def destroy
-    @user = User.current
-    unless @user.own_account_deletable?
-      redirect_to my_account_path
-      return
-    end
-
-    if request.post? && params[:confirm]
-      @user.destroy
-      if @user.destroyed?
-        logout_user
-        flash[:notice] = l(:notice_account_deleted)
-      end
-      redirect_to home_path
-    end
-  end
-
-  # Manage user's password
-  def password
-    @user = User.current
-    unless @user.change_password_allowed?
-      flash[:error] = l(:notice_can_t_change_password)
-      redirect_to my_account_path
-      return
-    end
-    if request.post?
-      if !@user.check_password?(params[:password])
-        flash.now[:error] = l(:notice_account_wrong_password)
-      elsif params[:password] == params[:new_password]
-        flash.now[:error] = l(:notice_new_password_must_be_different)
-      else
-        @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]
-        @user.must_change_passwd = false
-        if @user.save
-          # The session token was destroyed by the password change, generate a new one
-          session[:tk] = @user.generate_session_token
-          Mailer.deliver_password_updated(@user, User.current)
-          flash[:notice] = l(:notice_account_password_updated)
-          redirect_to my_account_path
-        end
-      end
-    end
-  end
-
-  # Create a new feeds key
-  def reset_rss_key
-    if request.post?
-      if User.current.rss_token
-        User.current.rss_token.destroy
-        User.current.reload
-      end
-      User.current.rss_key
-      flash[:notice] = l(:notice_feeds_access_key_reseted)
-    end
-    redirect_to my_account_path
-  end
-
-  def show_api_key
-    @user = User.current
-  end
-
-  # Create a new API key
-  def reset_api_key
-    if request.post?
-      if User.current.api_token
-        User.current.api_token.destroy
-        User.current.reload
-      end
-      User.current.api_key
-      flash[:notice] = l(:notice_api_access_key_reseted)
-    end
-    redirect_to my_account_path
-  end
-
-  def update_page
-    @user = User.current
-    block_settings = params[:settings] || {}
-
-    block_settings.each do |block, settings|
-      @user.pref.update_block_settings(block, settings.to_unsafe_hash)
-    end
-    @user.pref.save
-    @updated_blocks = block_settings.keys
-  end
-
-  # Add a block to user's page
-  # The block is added on top of the page
-  # params[:block] : id of the block to add
-  def add_block
-    @user = User.current
-    @block = params[:block]
-    if @user.pref.add_block @block
-      @user.pref.save
-      respond_to do |format|
-        format.html { redirect_to my_page_path }
-        format.js
-      end
-    else
-      render_error :status => 422
-    end
-  end
-
-  # Remove a block to user's page
-  # params[:block] : id of the block to remove
-  def remove_block
-    @user = User.current
-    @block = params[:block]
-    @user.pref.remove_block @block
-    @user.pref.save
-    respond_to do |format|
-      format.html { redirect_to my_page_path }
-      format.js
-    end
-  end
-
-  # Change blocks order on user's page
-  # params[:group] : group to order (top, left or right)
-  # params[:blocks] : array of block ids of the group
-  def order_blocks
-    @user = User.current
-    @user.pref.order_blocks params[:group], params[:blocks]
-    @user.pref.save
-    head 200
-  end
-end

app/controllers/news_controller.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class NewsController < ApplicationController
-  default_search_scope :news
-  model_object News
-  before_action :find_model_object, :except => [:new, :create, :index]
-  before_action :find_project_from_association, :except => [:new, :create, :index]
-  before_action :find_project_by_project_id, :only => [:new, :create]
-  before_action :authorize, :except => [:index]
-  before_action :find_optional_project, :only => :index
-  accept_rss_auth :index
-  accept_api_auth :index, :show, :create, :update, :destroy
-
-  helper :watchers
-  helper :attachments
-
-  def index
-    case params[:format]
-    when 'xml', 'json'
-      @offset, @limit = api_offset_and_limit
-    else
-      @limit =  10
-    end
-
-    scope = @project ? @project.news.visible : News.visible
-
-    @news_count = scope.count
-    @news_pages = Paginator.new @news_count, @limit, params['page']
-    @offset ||= @news_pages.offset
-    @newss = scope.includes([:author, :project]).
-                      order("#{News.table_name}.created_on DESC").
-                      limit(@limit).
-                      offset(@offset).
-                      to_a
-    respond_to do |format|
-      format.html {
-        @news = News.new # for adding news inline
-        render :layout => false if request.xhr?
-      }
-      format.api
-      format.atom { render_feed(@newss, :title => (@project ? @project.name : Setting.app_title) + ": #{l(:label_news_plural)}") }
-    end
-  end
-
-  def show
-    @comments = @news.comments.to_a
-    @comments.reverse! if User.current.wants_comments_in_reverse_order?
-  end
-
-  def new
-    @news = News.new(:project => @project, :author => User.current)
-  end
-
-  def create
-    @news = News.new(:project => @project, :author => User.current)
-    @news.safe_attributes = params[:news]
-    @news.save_attachments(params[:attachments] || (params[:news] && params[:news][:uploads]))
-    if @news.save
-      respond_to do |format|
-        format.html {
-          render_attachment_warning_if_needed(@news)
-          flash[:notice] = l(:notice_successful_create)
-          redirect_to project_news_index_path(@project)
-        }
-        format.api  { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'new' }
-        format.api  { render_validation_errors(@news) }
-      end
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @news.safe_attributes = params[:news]
-    @news.save_attachments(params[:attachments] || (params[:news] && params[:news][:uploads]))
-    if @news.save
-      respond_to do |format|
-        format.html {
-          render_attachment_warning_if_needed(@news)
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to news_path(@news)
-        }
-        format.api  { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.api  { render_validation_errors(@news) }
-      end
-    end
-  end
-
-  def destroy
-    @news.destroy
-    respond_to do |format|
-      format.html { redirect_to project_news_index_path(@project) }
-      format.api  { render_api_ok }
-    end
-  end
-end

app/controllers/previews_controller.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class PreviewsController < ApplicationController
-  before_action :find_project, :except => :text
-  before_action :find_attachments
-
-  def issue
-    @issue = Issue.visible.find_by_id(params[:issue_id]) unless params[:issue_id].blank?
-    if @issue
-      @previewed = @issue
-    end
-    @text = params[:text] ? params[:text] : nil
-    render :partial => 'common/preview'
-  end
-
-  def news
-    if params[:id].present? && news = News.visible.find_by_id(params[:id])
-      @previewed = news
-    end
-    @text = params[:text] ? params[:text] : nil
-    render :partial => 'common/preview'
-  end
-
-  def text
-    @text = params[:text] ? params[:text] : nil
-    render :partial => 'common/preview'
-  end
-
-  private
-
-  def find_project
-    project_id = (params[:issue] && params[:issue][:project_id]) || params[:project_id]
-    @project = Project.find(project_id)
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-end

app/controllers/principal_memberships_controller.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class PrincipalMembershipsController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  helper :members
-
-  before_action :require_admin
-  before_action :find_principal, :only => [:new, :create]
-  before_action :find_membership, :only => [:edit, :update, :destroy]
-
-  def new
-    @projects = Project.active.all
-    @roles = Role.find_all_givable
-    respond_to do |format|
-      format.html
-      format.js
-    end
-  end
-
-  def create
-    @members = Member.create_principal_memberships(@principal, params[:membership])
-    respond_to do |format|
-      format.html { redirect_to_principal @principal }
-      format.js
-    end
-  end
-
-  def edit
-    @roles = Role.givable.to_a
-  end
-
-  def update
-    @membership.attributes = params.require(:membership).permit(:role_ids => [])
-    @membership.save
-    respond_to do |format|
-      format.html { redirect_to_principal @principal }
-      format.js
-    end
-  end
-
-  def destroy
-    if @membership.deletable?
-      @membership.destroy
-    end
-    respond_to do |format|
-      format.html { redirect_to_principal @principal }
-      format.js
-    end
-  end
-
-  private
-
-  def find_principal
-    principal_id = params[:user_id] || params[:group_id]
-    @principal = Principal.find(principal_id)
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def find_membership
-    @membership = Member.find(params[:id])
-    @principal = @membership.principal
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def redirect_to_principal(principal)
-    redirect_to edit_polymorphic_path(principal, :tab => 'memberships')
-  end
-end

app/controllers/project_enumerations_controller.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class ProjectEnumerationsController < ApplicationController
-  before_action :find_project_by_project_id
-  before_action :authorize
-
-  def update
-    if @project.update_or_create_time_entry_activities(update_params)
-      flash[:notice] = l(:notice_successful_update)
-    end
-
-    redirect_to settings_project_path(@project, :tab => 'activities')
-  end
-
-  def destroy
-    @project.time_entry_activities.each do |time_entry_activity|
-      time_entry_activity.destroy(time_entry_activity.parent)
-    end
-    flash[:notice] = l(:notice_successful_update)
-    redirect_to settings_project_path(@project, :tab => 'activities')
-  end
-
-  private
-
-  def update_params
-    params.
-      permit(:enumerations => [:parent_id, :active, {:custom_field_values => {}}]).
-      require(:enumerations)
-  end
-end

app/controllers/projects_controller.rb

@@ -1,284 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class ProjectsController < ApplicationController
-  menu_item :overview
-  menu_item :settings, :only => :settings
-  menu_item :projects, :only => [:index, :new, :copy, :create]
-
-  before_action :find_project, :except => [ :index, :autocomplete, :list, :new, :create, :copy ]
-  before_action :authorize, :except => [ :index, :autocomplete, :list, :new, :create, :copy, :archive, :unarchive, :destroy]
-  before_action :authorize_global, :only => [:new, :create]
-  before_action :require_admin, :only => [ :copy, :archive, :unarchive, :destroy ]
-  accept_rss_auth :index
-  accept_api_auth :index, :show, :create, :update, :destroy
-  require_sudo_mode :destroy
-
-  helper :custom_fields
-  helper :issues
-  helper :queries
-  include QueriesHelper
-  helper :projects_queries
-  include ProjectsQueriesHelper
-  helper :repositories
-  helper :members
-  helper :trackers
-
-  # Lists visible projects
-  def index
-    # try to redirect to the requested menu item
-    if params[:jump] && redirect_to_menu_item(params[:jump])
-      return
-    end
-
-    retrieve_project_query
-    scope = project_scope
-
-    respond_to do |format|
-      format.html {
-        # TODO: see what to do with the board view and pagination
-        if @query.display_type == 'board'
-          @entries = scope.to_a
-        else
-          @entry_count = scope.count
-          @entry_pages = Paginator.new @entry_count, per_page_option, params['page']
-          @entries = scope.offset(@entry_pages.offset).limit(@entry_pages.per_page).to_a
-        end
-      }
-      format.api  {
-        @offset, @limit = api_offset_and_limit
-        @project_count = scope.count
-        @projects = scope.offset(@offset).limit(@limit).to_a
-      }
-      format.atom {
-        projects = scope.reorder(:created_on => :desc).limit(Setting.feeds_limit.to_i).to_a
-        render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
-      }
-      format.csv {
-        # Export all entries
-        @entries = scope.to_a
-        send_data(query_to_csv(@entries, @query, params), :type => 'text/csv; header=present', :filename => 'projects.csv')
-      }
-    end
-  end
-
-  def autocomplete
-    respond_to do |format|
-      format.js {
-        if params[:q].present?
-          @projects = Project.visible.like(params[:q]).to_a
-        else
-          @projects = User.current.projects.to_a
-        end
-      }
-    end
-  end
-
-  def new
-    @issue_custom_fields = IssueCustomField.sorted.to_a
-    @trackers = Tracker.sorted.to_a
-    @project = Project.new
-    @project.safe_attributes = params[:project]
-  end
-
-  def create
-    @issue_custom_fields = IssueCustomField.sorted.to_a
-    @trackers = Tracker.sorted.to_a
-    @project = Project.new
-    @project.safe_attributes = params[:project]
-
-    if @project.save
-      unless User.current.admin?
-        @project.add_default_member(User.current)
-      end
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_create)
-          if params[:continue]
-            attrs = {:parent_id => @project.parent_id}.reject {|k,v| v.nil?}
-            redirect_to new_project_path(attrs)
-          else
-            redirect_to settings_project_path(@project)
-          end
-        }
-        format.api  { render :action => 'show', :status => :created, :location => url_for(:controller => 'projects', :action => 'show', :id => @project.id) }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'new' }
-        format.api  { render_validation_errors(@project) }
-      end
-    end
-  end
-
-  def copy
-    @issue_custom_fields = IssueCustomField.sorted.to_a
-    @trackers = Tracker.sorted.to_a
-    @source_project = Project.find(params[:id])
-    if request.get?
-      @project = Project.copy_from(@source_project)
-      @project.identifier = Project.next_identifier if Setting.sequential_project_identifiers?
-    else
-      Mailer.with_deliveries(params[:notifications] == '1') do
-        @project = Project.new
-        @project.safe_attributes = params[:project]
-        if @project.copy(@source_project, :only => params[:only])
-          flash[:notice] = l(:notice_successful_create)
-          redirect_to settings_project_path(@project)
-        elsif !@project.new_record?
-          # Project was created
-          # But some objects were not copied due to validation failures
-          # (eg. issues from disabled trackers)
-          # TODO: inform about that
-          redirect_to settings_project_path(@project)
-        end
-      end
-    end
-  rescue ActiveRecord::RecordNotFound
-    # source_project not found
-    render_404
-  end
-
-  # Show @project
-  def show
-    # try to redirect to the requested menu item
-    if params[:jump] && redirect_to_project_menu_item(@project, params[:jump])
-      return
-    end
-
-    @users_by_role = @project.users_by_role
-    @subprojects = @project.children.visible.to_a
-    @news = @project.news.limit(5).includes(:author, :project).reorder("#{News.table_name}.created_on DESC").to_a
-    @trackers = @project.rolled_up_trackers.visible
-
-    cond = @project.project_condition(Setting.display_subprojects_issues?)
-
-    @open_issues_by_tracker = Issue.visible.open.where(cond).group(:tracker).count
-    @total_issues_by_tracker = Issue.visible.where(cond).group(:tracker).count
-
-    if User.current.allowed_to_view_all_time_entries?(@project)
-      @total_hours = TimeEntry.visible.where(cond).sum(:hours).to_f
-      @total_estimated_hours = Issue.visible.where(cond).sum(:estimated_hours).to_f
-    end
-
-    @key = User.current.rss_key
-
-    respond_to do |format|
-      format.html
-      format.api
-    end
-  end
-
-  def settings
-    @issue_custom_fields = IssueCustomField.sorted.to_a
-    @issue_category ||= IssueCategory.new
-    @member ||= @project.members.new
-    @trackers = Tracker.sorted.to_a
-
-    @version_status = params[:version_status] || 'open'
-    @version_name = params[:version_name]
-    @versions = @project.shared_versions.status(@version_status).like(@version_name).sorted
-  end
-
-  def edit
-  end
-
-  def update
-    @project.safe_attributes = params[:project]
-    if @project.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to settings_project_path(@project, params[:tab])
-        }
-        format.api  { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html {
-          settings
-          render :action => 'settings'
-        }
-        format.api  { render_validation_errors(@project) }
-      end
-    end
-  end
-
-  def archive
-    unless @project.archive
-      flash[:error] = l(:error_can_not_archive_project)
-    end
-    redirect_to_referer_or admin_projects_path(:status => params[:status])
-  end
-
-  def unarchive
-    unless @project.active?
-      @project.unarchive
-    end
-    redirect_to_referer_or admin_projects_path(:status => params[:status])
-  end
-
-  def bookmark
-    jump_box = Redmine::ProjectJumpBox.new User.current
-    if request.delete?
-      jump_box.delete_project_bookmark @project
-    elsif request.post?
-      jump_box.bookmark_project @project
-    end
-    respond_to do |format|
-      format.js
-      format.html { redirect_to project_path(@project) }
-    end
-  end
-
-  def close
-    @project.close
-    redirect_to project_path(@project)
-  end
-
-  def reopen
-    @project.reopen
-    redirect_to project_path(@project)
-  end
-
-  # Delete @project
-  def destroy
-    @project_to_destroy = @project
-    if api_request? || params[:confirm]
-      @project_to_destroy.destroy
-      respond_to do |format|
-        format.html { redirect_to admin_projects_path }
-        format.api  { render_api_ok }
-      end
-    end
-    # hide project in layout
-    @project = nil
-  end
-
-  private
-
-  # Returns the ProjectEntry scope for index
-  def project_scope(options={})
-    @query.results_scope(options)
-  end
-
-  def retrieve_project_query
-    retrieve_query(ProjectQuery, false, :defaults => @default_columns_names)
-  end
-end

app/controllers/queries_controller.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class QueriesController < ApplicationController
-  menu_item :issues
-  before_action :find_query, :only => [:edit, :update, :destroy]
-  before_action :find_optional_project, :only => [:new, :create]
-
-  accept_api_auth :index
-
-  include QueriesHelper
-
-  def index
-    case params[:format]
-    when 'xml', 'json'
-      @offset, @limit = api_offset_and_limit
-    else
-      @limit = per_page_option
-    end
-    scope = query_class.visible
-    @query_count = scope.count
-    @query_pages = Paginator.new @query_count, @limit, params['page']
-    @queries = scope.
-                    order("#{Query.table_name}.name").
-                    limit(@limit).
-                    offset(@offset).
-                    to_a
-    respond_to do |format|
-      format.html {render_error :status => 406}
-      format.api
-    end
-  end
-
-  def new
-    @query = query_class.new
-    @query.user = User.current
-    @query.project = @project
-    @query.build_from_params(params)
-  end
-
-  def create
-    @query = query_class.new
-    @query.user = User.current
-    @query.project = @project
-    update_query_from_params
-
-    if @query.save
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to_items(:query_id => @query)
-    else
-      render :action => 'new', :layout => !request.xhr?
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    update_query_from_params
-
-    if @query.save
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to_items(:query_id => @query)
-    else
-      render :action => 'edit'
-    end
-  end
-
-  def destroy
-    @query.destroy
-    redirect_to_items(:set_filter => 1)
-  end
-
-  # Returns the values for a query filter
-  def filter
-    q = query_class.new
-    if params[:project_id].present?
-      q.project = Project.find(params[:project_id])
-    end
-
-    unless User.current.allowed_to?(q.class.view_permission, q.project, :global => true)
-      raise Unauthorized
-    end
-
-    filter = q.available_filters[params[:name].to_s]
-    values = filter ? filter.values : []
-
-    render :json => values
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def current_menu_item
-    @query ? @query.queried_class.to_s.underscore.pluralize.to_sym : nil
-  end
-
-  private
-
-  def find_query
-    @query = Query.find(params[:id])
-    @project = @query.project
-    render_403 unless @query.editable_by?(User.current)
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def update_query_from_params
-    @query.project = params[:query_is_for_all] ? nil : @project
-    @query.build_from_params(params)
-    @query.column_names = nil if params[:default_columns]
-    @query.sort_criteria = (params[:query] && params[:query][:sort_criteria]) || @query.sort_criteria
-    @query.name = params[:query] && params[:query][:name]
-    if User.current.allowed_to?(:manage_public_queries, @query.project) || User.current.admin?
-      @query.visibility = (params[:query] && params[:query][:visibility]) || Query::VISIBILITY_PRIVATE
-      @query.role_ids = params[:query] && params[:query][:role_ids]
-    else
-      @query.visibility = Query::VISIBILITY_PRIVATE
-    end
-    @query
-  end
-
-  def redirect_to_items(options)
-    method = "redirect_to_#{@query.class.name.underscore}"
-    send method, options
-  end
-
-  def redirect_to_issue_query(options)
-    if params[:gantt]
-      if @project
-        redirect_to project_gantt_path(@project, options)
-      else
-        redirect_to issues_gantt_path(options)
-      end
-    else
-      redirect_to _project_issues_path(@project, options)
-    end
-  end
-
-  def redirect_to_time_entry_query(options)
-    redirect_to _time_entries_path(@project, nil, options)
-  end
-
-  def redirect_to_project_query(options)
-    redirect_to projects_path(options)
-  end
-
-  # Returns the Query subclass, IssueQuery by default
-  # for compatibility with previous behaviour
-  def query_class
-    Query.get_subclass(params[:type] || 'IssueQuery')
-  end
-end

app/controllers/reports_controller.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class ReportsController < ApplicationController
-  menu_item :issues
-  before_action :find_project, :authorize, :find_issue_statuses
-
-  def issue_report
-    @trackers = @project.rolled_up_trackers(false).visible
-    @versions = @project.shared_versions.sorted
-    @priorities = IssuePriority.all.reverse
-    @categories = @project.issue_categories
-    @assignees = (Setting.issue_group_assignment? ? @project.principals : @project.users).sorted
-    @authors = @project.users.sorted
-    @subprojects = @project.descendants.visible
-    with_subprojects = Setting.display_subprojects_issues?
-    @issues_by_tracker = Issue.by_tracker(@project, with_subprojects)
-    @issues_by_version = Issue.by_version(@project, with_subprojects)
-    @issues_by_priority = Issue.by_priority(@project, with_subprojects)
-    @issues_by_category = Issue.by_category(@project, with_subprojects)
-    @issues_by_assigned_to = Issue.by_assigned_to(@project, with_subprojects)
-    @issues_by_author = Issue.by_author(@project, with_subprojects)
-    @issues_by_subproject = Issue.by_subproject(@project) || []
-
-    render :template => "reports/issue_report"
-  end
-
-  def issue_report_details
-    with_subprojects = Setting.display_subprojects_issues?
-    case params[:detail]
-    when "tracker"
-      @field = "tracker_id"
-      @rows = @project.rolled_up_trackers(false).visible
-      @data = Issue.by_tracker(@project, with_subprojects)
-      @report_title = l(:field_tracker)
-    when "version"
-      @field = "fixed_version_id"
-      @rows = @project.shared_versions.sorted
-      @data = Issue.by_version(@project, with_subprojects)
-      @report_title = l(:field_version)
-    when "priority"
-      @field = "priority_id"
-      @rows = IssuePriority.all.reverse
-      @data = Issue.by_priority(@project, with_subprojects)
-      @report_title = l(:field_priority)
-    when "category"
-      @field = "category_id"
-      @rows = @project.issue_categories
-      @data = Issue.by_category(@project, with_subprojects)
-      @report_title = l(:field_category)
-    when "assigned_to"
-      @field = "assigned_to_id"
-      @rows = (Setting.issue_group_assignment? ? @project.principals : @project.users).sorted
-      @data = Issue.by_assigned_to(@project, with_subprojects)
-      @report_title = l(:field_assigned_to)
-    when "author"
-      @field = "author_id"
-      @rows = @project.users.sorted
-      @data = Issue.by_author(@project, with_subprojects)
-      @report_title = l(:field_author)
-    when "subproject"
-      @field = "project_id"
-      @rows = @project.descendants.visible
-      @data = Issue.by_subproject(@project) || []
-      @report_title = l(:field_subproject)
-    else
-      render_404
-    end
-  end
-
-  private
-
-  def find_issue_statuses
-    @statuses = @project.rolled_up_statuses.sorted.to_a
-  end
-end

app/controllers/repositories_controller.rb

@@ -1,413 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-require 'digest/sha1'
-require 'redmine/scm/adapters'
-
-class ChangesetNotFound < StandardError; end
-class InvalidRevisionParam < StandardError; end
-
-class RepositoriesController < ApplicationController
-  menu_item :repository
-  menu_item :settings, :only => [:new, :create, :edit, :update, :destroy, :committers]
-  default_search_scope :changesets
-
-  before_action :find_project_by_project_id, :only => [:new, :create]
-  before_action :build_new_repository_from_params, :only => [:new, :create]
-  before_action :find_repository, :only => [:edit, :update, :destroy, :committers]
-  before_action :find_project_repository, :except => [:new, :create, :edit, :update, :destroy, :committers]
-  before_action :find_changeset, :only => [:revision, :add_related_issue, :remove_related_issue]
-  before_action :authorize
-  accept_rss_auth :revisions
-
-  rescue_from Redmine::Scm::Adapters::CommandFailed, :with => :show_error_command_failed
-
-  def new
-    @repository.is_default = @project.repository.nil?
-  end
-
-  def create
-    if @repository.save
-      redirect_to settings_project_path(@project, :tab => 'repositories')
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @repository.safe_attributes = params[:repository]
-    if @repository.save
-      redirect_to settings_project_path(@project, :tab => 'repositories')
-    else
-      render :action => 'edit'
-    end
-  end
-
-  def committers
-    @committers = @repository.committers
-    @users = @project.users.to_a
-    additional_user_ids = @committers.collect(&:last).collect(&:to_i) - @users.collect(&:id)
-    @users += User.where(:id => additional_user_ids).to_a unless additional_user_ids.empty?
-    @users.compact!
-    @users.sort!
-    if request.post? && params[:committers].present?
-      # Build a hash with repository usernames as keys and corresponding user ids as values
-      @repository.committer_ids = params[:committers].values.inject({}) {|h, c| h[c.first] = c.last; h}
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to settings_project_path(@project, :tab => 'repositories')
-    end
-  end
-
-  def destroy
-    @repository.destroy if request.delete?
-    redirect_to settings_project_path(@project, :tab => 'repositories')
-  end
-
-  def show
-    @repository.fetch_changesets if @project.active? && Setting.autofetch_changesets? && @path.empty?
-
-    @entries = @repository.entries(@path, @rev)
-    @changeset = @repository.find_changeset_by_name(@rev)
-    if request.xhr?
-      @entries ? render(:partial => 'dir_list_content') : head(200)
-    else
-      (show_error_not_found; return) unless @entries
-      @changesets = @repository.latest_changesets(@path, @rev)
-      @properties = @repository.properties(@path, @rev)
-      @repositories = @project.repositories
-      render :action => 'show'
-    end
-  end
-
-  alias_method :browse, :show
-
-  def changes
-    @entry = @repository.entry(@path, @rev)
-    (show_error_not_found; return) unless @entry
-    @changesets = @repository.latest_changesets(@path, @rev, Setting.repository_log_display_limit.to_i)
-    @properties = @repository.properties(@path, @rev)
-    @changeset = @repository.find_changeset_by_name(@rev)
-  end
-
-  def revisions
-    @changeset_count = @repository.changesets.count
-    @changeset_pages = Paginator.new @changeset_count,
-                                     per_page_option,
-                                     params['page']
-    @changesets = @repository.changesets.
-      limit(@changeset_pages.per_page).
-      offset(@changeset_pages.offset).
-      includes(:user, :repository, :parents).
-      to_a
-
-    respond_to do |format|
-      format.html { render :layout => false if request.xhr? }
-      format.atom { render_feed(@changesets, :title => "#{@project.name}: #{l(:label_revision_plural)}") }
-    end
-  end
-
-  def raw
-    entry_and_raw(true)
-  end
-
-  def entry
-    entry_and_raw(false)
-  end
-
-  def entry_and_raw(is_raw)
-    @entry = @repository.entry(@path, @rev)
-    (show_error_not_found; return) unless @entry
-
-    # If the entry is a dir, show the browser
-    (show; return) if @entry.is_dir?
-
-    if is_raw
-      # Force the download
-      send_opt = { :filename => filename_for_content_disposition(@path.split('/').last) }
-      send_type = Redmine::MimeType.of(@path)
-      send_opt[:type] = send_type.to_s if send_type
-      send_opt[:disposition] = disposition(@path)
-      send_data @repository.cat(@path, @rev), send_opt
-    else
-      # set up pagination from entry to entry
-      parent_path = @path.split('/')[0...-1].join('/')
-      @entries = @repository.entries(parent_path, @rev).reject(&:is_dir?)
-      if index = @entries.index{|e| e.name == @entry.name}
-        @paginator = Redmine::Pagination::Paginator.new(@entries.size, 1, index+1)
-      end
-
-      if !@entry.size || @entry.size <= Setting.file_max_size_displayed.to_i.kilobyte
-        content = @repository.cat(@path, @rev)
-        (show_error_not_found; return) unless content
-
-        if content.size <= Setting.file_max_size_displayed.to_i.kilobyte &&
-           is_entry_text_data?(content, @path)
-          # TODO: UTF-16
-          # Prevent empty lines when displaying a file with Windows style eol
-          # Is this needed? AttachmentsController simply reads file.
-          @content = content.gsub("\r\n", "\n")
-        end
-      end
-      @changeset = @repository.find_changeset_by_name(@rev)
-    end
-  end
-  private :entry_and_raw
-
-  def is_entry_text_data?(ent, path)
-    # UTF-16 contains "\x00".
-    # It is very strict that file contains less than 30% of ascii symbols
-    # in non Western Europe.
-    return true if Redmine::MimeType.is_type?('text', path)
-    # Ruby 1.8.6 has a bug of integer divisions.
-    # http://apidock.com/ruby/v1_8_6_287/String/is_binary_data%3F
-    return false if Redmine::Scm::Adapters::ScmData.binary?(ent)
-    true
-  end
-  private :is_entry_text_data?
-
-  def annotate
-    @entry = @repository.entry(@path, @rev)
-    (show_error_not_found; return) unless @entry
-
-    @annotate = @repository.scm.annotate(@path, @rev)
-    if @annotate.nil? || @annotate.empty?
-      @annotate = nil
-      @error_message = l(:error_scm_annotate)
-    else
-      ann_buf_size = 0
-      @annotate.lines.each do |buf|
-        ann_buf_size += buf.size
-      end
-      if ann_buf_size > Setting.file_max_size_displayed.to_i.kilobyte
-        @annotate = nil
-        @error_message = l(:error_scm_annotate_big_text_file)
-      end
-    end
-    @changeset = @repository.find_changeset_by_name(@rev)
-  end
-
-  def revision
-    respond_to do |format|
-      format.html
-      format.js {render :layout => false}
-    end
-  end
-
-  # Adds a related issue to a changeset
-  # POST /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues
-  def add_related_issue
-    issue_id = params[:issue_id].to_s.sub(/^#/,'')
-    @issue = @changeset.find_referenced_issue_by_id(issue_id)
-    if @issue && (!@issue.visible? || @changeset.issues.include?(@issue))
-      @issue = nil
-    end
-
-    if @issue
-      @changeset.issues << @issue
-    end
-  end
-
-  # Removes a related issue from a changeset
-  # DELETE /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues/:issue_id
-  def remove_related_issue
-    @issue = Issue.visible.find_by_id(params[:issue_id])
-    if @issue
-      @changeset.issues.delete(@issue)
-    end
-  end
-
-  def diff
-    if params[:format] == 'diff'
-      @diff = @repository.diff(@path, @rev, @rev_to)
-      (show_error_not_found; return) unless @diff
-      filename = +"changeset_r#{@rev}"
-      filename << "_r#{@rev_to}" if @rev_to
-      send_data @diff.join, :filename => "#{filename}.diff",
-                            :type => 'text/x-patch',
-                            :disposition => 'attachment'
-    else
-      @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
-      @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
-
-      # Save diff type as user preference
-      if User.current.logged? && @diff_type != User.current.pref[:diff_type]
-        User.current.pref[:diff_type] = @diff_type
-        User.current.preference.save
-      end
-      @cache_key = "repositories/diff/#{@repository.id}/" +
-                      Digest::MD5.hexdigest("#{@path}-#{@rev}-#{@rev_to}-#{@diff_type}-#{current_language}")
-      unless read_fragment(@cache_key)
-        @diff = @repository.diff(@path, @rev, @rev_to)
-        (show_error_not_found; return) unless @diff
-      end
-
-      @changeset = @repository.find_changeset_by_name(@rev)
-      @changeset_to = @rev_to ? @repository.find_changeset_by_name(@rev_to) : nil
-      @diff_format_revisions = @repository.diff_format_revisions(@changeset, @changeset_to)
-      render :diff, :formats => :html, :layout => 'base.html.erb'
-    end
-  end
-
-  def stats
-  end
-
-  # Returns JSON data for repository graphs
-  def graph
-    data = nil
-    case params[:graph]
-    when "commits_per_month"
-      data = graph_commits_per_month(@repository)
-    when "commits_per_author"
-      data = graph_commits_per_author(@repository)
-    end
-    if data
-      render :json => data
-    else
-      render_404
-    end
-  end
-
-  private
-
-  def build_new_repository_from_params
-    scm = params[:repository_scm] || (Redmine::Scm::Base.all & Setting.enabled_scm).first
-    unless @repository = Repository.factory(scm)
-      render_404
-      return
-    end
-
-    @repository.project = @project
-    @repository.safe_attributes = params[:repository]
-    @repository
-  end
-
-  def find_repository
-    @repository = Repository.find(params[:id])
-    @project = @repository.project
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  REV_PARAM_RE = %r{\A[a-f0-9]*\Z}i
-
-  def find_project_repository
-    @project = Project.find(params[:id])
-    if params[:repository_id].present?
-      @repository = @project.repositories.find_by_identifier_param(params[:repository_id])
-    else
-      @repository = @project.repository
-    end
-    (render_404; return false) unless @repository
-    @path = params[:path].is_a?(Array) ? params[:path].join('/') : params[:path].to_s
-    @rev = params[:rev].blank? ? @repository.default_branch : params[:rev].to_s.strip
-    @rev_to = params[:rev_to]
-
-    unless REV_PARAM_RE.match?(@rev.to_s) && REV_PARAM_RE.match?(@rev_to.to_s)
-      if @repository.branches.blank?
-        raise InvalidRevisionParam
-      end
-    end
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  rescue InvalidRevisionParam
-    show_error_not_found
-  end
-
-  def find_changeset
-    if @rev.present?
-      @changeset = @repository.find_changeset_by_name(@rev)
-    end
-    show_error_not_found unless @changeset
-  end
-
-  def show_error_not_found
-    render_error :message => l(:error_scm_not_found), :status => 404
-  end
-
-  # Handler for Redmine::Scm::Adapters::CommandFailed exception
-  def show_error_command_failed(exception)
-    render_error l(:error_scm_command_failed, exception.message)
-  end
-
-  def graph_commits_per_month(repository)
-    date_to = User.current.today
-    date_from = date_to << 11
-    date_from = Date.civil(date_from.year, date_from.month, 1)
-    commits_by_day = Changeset.
-      where("repository_id = ? AND commit_date BETWEEN ? AND ?", repository.id, date_from, date_to).
-      group(:commit_date).
-      count
-    commits_by_month = [0] * 12
-    commits_by_day.each {|c| commits_by_month[(date_to.month - c.first.to_date.month) % 12] += c.last }
-
-    changes_by_day = Change.
-      joins(:changeset).
-      where("#{Changeset.table_name}.repository_id = ? AND #{Changeset.table_name}.commit_date BETWEEN ? AND ?", repository.id, date_from, date_to).
-      group(:commit_date).
-      count
-    changes_by_month = [0] * 12
-    changes_by_day.each {|c| changes_by_month[(date_to.month - c.first.to_date.month) % 12] += c.last }
-
-    fields = []
-    today = User.current.today
-    12.times {|m| fields << month_name(((today.month - 1 - m) % 12) + 1)}
-
-    data = {
-      :labels => fields.reverse,
-      :commits => commits_by_month[0..11].reverse,
-      :changes => changes_by_month[0..11].reverse
-    }
-  end
-
-  def graph_commits_per_author(repository)
-    # data
-    stats = repository.stats_by_author
-    fields, commits_data, changes_data = [], [], []
-    stats.each do |name, hsh|
-      fields << name
-      commits_data << hsh[:commits_count]
-      changes_data << hsh[:changes_count]
-    end
-
-    # expand to 10 values if needed
-    fields = fields + [""]*(10 - fields.length) if fields.length<10
-    commits_data = commits_data + [0]*(10 - commits_data.length) if commits_data.length<10
-    changes_data = changes_data + [0]*(10 - changes_data.length) if changes_data.length<10
-
-    # Remove email address in usernames
-    fields = fields.collect {|c| c.gsub(%r{<.+@.+>}, '') }
-
-    data = {
-      :labels => fields.reverse,
-      :commits => commits_data.reverse,
-      :changes => changes_data.reverse
-    }
-  end
-
-  def disposition(path)
-    if Redmine::MimeType.of(@path) == "application/pdf"
-      'inline'
-    else
-      'attachment'
-    end
-  end
-end

app/controllers/roles_controller.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class RolesController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin, :except => [:index, :show]
-  before_action :require_admin_or_api_request, :only => [:index, :show]
-  before_action :find_role, :only => [:show, :edit, :update, :destroy]
-  accept_api_auth :index, :show
-
-  require_sudo_mode :create, :update, :destroy
-
-  def index
-    respond_to do |format|
-      format.html {
-        @roles = Role.sorted.to_a
-        render :layout => false if request.xhr?
-      }
-      format.api {
-        @roles = Role.givable.to_a
-      }
-    end
-  end
-
-  def show
-    respond_to do |format|
-      format.api
-    end
-  end
-
-  def new
-    # Prefills the form with 'Non member' role permissions by default
-    @role = Role.new
-    @role.safe_attributes = params[:role] || {:permissions => Role.non_member.permissions}
-    if params[:copy].present? && @copy_from = Role.find_by_id(params[:copy])
-      @role.copy_from(@copy_from)
-    end
-    @roles = Role.sorted.to_a
-  end
-
-  def create
-    @role = Role.new
-    @role.safe_attributes = params[:role]
-    if request.post? && @role.save
-      # workflow copy
-      if !params[:copy_workflow_from].blank? && (copy_from = Role.find_by_id(params[:copy_workflow_from]))
-        @role.copy_workflow_rules(copy_from)
-      end
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to roles_path
-    else
-      @roles = Role.sorted.to_a
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    @role.safe_attributes = params[:role]
-    if @role.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to roles_path(:page => params[:page])
-        }
-        format.js { head 200 }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.js { head 422 }
-      end
-    end
-  end
-
-  def destroy
-    begin
-      @role.destroy
-    rescue
-      flash[:error] =  l(:error_can_not_remove_role)
-    end
-    redirect_to roles_path
-  end
-
-  def permissions
-    scope = Role.sorted
-    if params[:ids].present?
-      scope = scope.where(:id => params[:ids])
-    end
-    @roles = scope.to_a
-    @permissions = Redmine::AccessControl.permissions.select { |p| !p.public? }
-  end
-
-  def update_permissions
-    @roles = Role.where(:id => params[:permissions].keys)
-    @roles.each do |role|
-      role.permissions = params[:permissions][role.id.to_s]
-      role.save
-    end
-    flash[:notice] = l(:notice_successful_update)
-    redirect_to roles_path
-  end
-
-  private
-
-  def find_role
-    @role = Role.find(params[:id])
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/search_controller.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class SearchController < ApplicationController
-  before_action :find_optional_project_by_id, :authorize_global
-  accept_api_auth :index
-
-  def index
-    @question = params[:q]&.strip || ""
-    @all_words = params[:all_words] ? params[:all_words].present? : true
-    @titles_only = params[:titles_only] ? params[:titles_only].present? : false
-    @search_attachments = params[:attachments].presence || '0'
-    @open_issues = params[:open_issues] ? params[:open_issues].present? : false
-
-    case params[:format]
-    when 'xml', 'json'
-      @offset, @limit = api_offset_and_limit
-    else
-      @offset = nil
-      @limit = Setting.search_results_per_page.to_i
-      @limit = 10 if @limit == 0
-    end
-
-    # quick jump to an issue
-    if !api_request? && (m = @question.match(/^#?(\d+)$/)) && (issue = Issue.visible.find_by_id(m[1].to_i))
-      redirect_to issue_path(issue)
-      return
-    end
-
-    projects_to_search =
-      case params[:scope]
-      when 'all'
-        nil
-      when 'my_projects'
-        User.current.projects
-      when 'subprojects'
-        @project ? (@project.self_and_descendants.to_a) : nil
-      else
-        @project
-      end
-
-    @object_types = Redmine::Search.available_search_types.dup
-    if projects_to_search.is_a? Project
-      # don't search projects
-      @object_types.delete('projects')
-      # only show what the user is allowed to view
-      @object_types = @object_types.select {|o| User.current.allowed_to?("view_#{o}".to_sym, projects_to_search)}
-    end
-
-    @scope = @object_types.select {|t| params[t]}
-    @scope = @object_types if @scope.empty?
-
-    fetcher = Redmine::Search::Fetcher.new(
-      @question, User.current, @scope, projects_to_search,
-      :all_words => @all_words, :titles_only => @titles_only, :attachments => @search_attachments, :open_issues => @open_issues,
-      :cache => params[:page].present?, :params => params.to_unsafe_hash
-    )
-
-    if fetcher.tokens.present?
-      @result_count = fetcher.result_count
-      @result_count_by_type = fetcher.result_count_by_type
-      @tokens = fetcher.tokens
-
-      @result_pages = Paginator.new @result_count, @limit, params['page']
-      @offset ||= @result_pages.offset
-      @results = fetcher.results(@offset, @result_pages.per_page)
-    else
-      @question = ""
-    end
-    respond_to do |format|
-      format.html { render :layout => false if request.xhr? }
-      format.api  { @results ||= []; render :layout => false }
-    end
-  end
-end

app/controllers/settings_controller.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class SettingsController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-  menu_item :plugins, :only => :plugin
-
-  helper :queries
-
-  before_action :require_admin
-
-  require_sudo_mode :index, :edit, :plugin
-
-  def index
-    edit
-    render :action => 'edit'
-  end
-
-  def edit
-    @notifiables = Redmine::Notifiable.all
-    if request.post?
-      errors = Setting.set_all_from_params(params[:settings].to_unsafe_hash)
-      if errors.blank?
-        flash[:notice] = l(:notice_successful_update)
-        redirect_to settings_path(:tab => params[:tab])
-        return
-      else
-        @setting_errors = errors
-        # render the edit form with error messages
-      end
-    end
-
-    @options = {}
-    user_format = User::USER_FORMATS.collect{|key, value| [key, value[:setting_order]]}.sort_by{|f| f[1]}
-    @options[:user_format] = user_format.collect{|f| [User.current.name(f[0]), f[0].to_s]}
-    @deliveries = ActionMailer::Base.perform_deliveries
-
-    @guessed_host_and_path = request.host_with_port.dup
-    @guessed_host_and_path << ('/'+ Redmine::Utils.relative_url_root.gsub(%r{^\/}, '')) unless Redmine::Utils.relative_url_root.blank?
-
-    @commit_update_keywords = Setting.commit_update_keywords.dup
-    @commit_update_keywords = [{}] unless @commit_update_keywords.is_a?(Array) && @commit_update_keywords.any?
-
-    Redmine::Themes.rescan
-  end
-
-  def plugin
-    @plugin = Redmine::Plugin.find(params[:id])
-    unless @plugin.configurable?
-      render_404
-      return
-    end
-
-    if request.post?
-      setting = params[:settings] ? params[:settings].permit!.to_h : {}
-      Setting.send "plugin_#{@plugin.id}=", setting
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to plugin_settings_path(@plugin)
-    else
-      @partial = @plugin.settings[:partial]
-      @settings = Setting.send "plugin_#{@plugin.id}"
-    end
-  rescue Redmine::PluginNotFound
-    render_404
-  end
-end

app/controllers/sys_controller.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class SysController < ActionController::Base
-  before_action :check_enabled
-
-  def projects
-    p = Project.active.has_module(:repository).
-          order("#{Project.table_name}.identifier").preload(:repository).to_a
-    # extra_info attribute from repository breaks activeresource client
-    render :json => p.to_json(
-                       :only => [:id, :identifier, :name, :is_public, :status],
-                       :include => {:repository => {:only => [:id, :url]}}
-                     )
-  end
-
-  def create_project_repository
-    project = Project.find(params[:id])
-    if project.repository
-      head 409
-    else
-      logger.info "Repository for #{project.name} was reported to be created by #{request.remote_ip}."
-      repository = Repository.factory(params[:vendor])
-      repository.safe_attributes = params[:repository]
-      repository.project = project
-      if repository.save
-        render :json => {repository.class.name.underscore.tr('/', '-') => {:id => repository.id, :url => repository.url}}, :status => 201
-      else
-        head 422
-      end
-    end
-  end
-
-  def fetch_changesets
-    projects = []
-    scope = Project.active.has_module(:repository)
-    if params[:id]
-      project = nil
-      if /^\d*$/.match?(params[:id].to_s)
-        project = scope.find(params[:id])
-      else
-        project = scope.find_by_identifier(params[:id])
-      end
-      raise ActiveRecord::RecordNotFound unless project
-      projects << project
-    else
-      projects = scope.to_a
-    end
-    projects.each do |project|
-      project.repositories.each do |repository|
-        repository.fetch_changesets
-      end
-    end
-    head 200
-  rescue ActiveRecord::RecordNotFound
-    head 404
-  end
-
-  protected
-
-  def check_enabled
-    User.current = nil
-    unless Setting.sys_api_enabled? && params[:key].to_s == Setting.sys_api_key
-      render :plain => 'Access denied. Repository management WS is disabled or key is invalid.', :status => 403
-      return false
-    end
-  end
-end

app/controllers/timelog_controller.rb

@@ -1,290 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class TimelogController < ApplicationController
-  menu_item :time_entries
-
-  before_action :find_time_entry, :only => [:show, :edit, :update]
-  before_action :check_editability, :only => [:edit, :update]
-  before_action :find_time_entries, :only => [:bulk_edit, :bulk_update, :destroy]
-  before_action :authorize, :only => [:show, :edit, :update, :bulk_edit, :bulk_update, :destroy]
-
-  before_action :find_optional_issue, :only => [:new, :create]
-  before_action :find_optional_project, :only => [:index, :report]
-
-  accept_rss_auth :index
-  accept_api_auth :index, :show, :create, :update, :destroy
-
-  rescue_from Query::StatementInvalid, :with => :query_statement_invalid
-
-  helper :issues
-  include TimelogHelper
-  helper :custom_fields
-  include CustomFieldsHelper
-  helper :queries
-  include QueriesHelper
-
-  def index
-    retrieve_time_entry_query
-    scope = time_entry_scope.
-      preload(:issue => [:project, :tracker, :status, :assigned_to, :priority]).
-      preload(:project, :user)
-
-    respond_to do |format|
-      format.html {
-        @entry_count = scope.count
-        @entry_pages = Paginator.new @entry_count, per_page_option, params['page']
-        @entries = scope.offset(@entry_pages.offset).limit(@entry_pages.per_page).to_a
-
-        render :layout => !request.xhr?
-      }
-      format.api  {
-        @entry_count = scope.count
-        @offset, @limit = api_offset_and_limit
-        @entries = scope.offset(@offset).limit(@limit).preload(:custom_values => :custom_field).to_a
-      }
-      format.atom {
-        entries = scope.limit(Setting.feeds_limit.to_i).reorder("#{TimeEntry.table_name}.created_on DESC").to_a
-        render_feed(entries, :title => l(:label_spent_time))
-      }
-      format.csv {
-        # Export all entries
-        @entries = scope.to_a
-        send_data(query_to_csv(@entries, @query, params), :type => 'text/csv; header=present', :filename => 'timelog.csv')
-      }
-    end
-  end
-
-  def report
-    retrieve_time_entry_query
-    scope = time_entry_scope
-
-    @report = Redmine::Helpers::TimeReport.new(@project, @issue, params[:criteria], params[:columns], scope)
-
-    respond_to do |format|
-      format.html { render :layout => !request.xhr? }
-      format.csv  { send_data(report_to_csv(@report), :type => 'text/csv; header=present', :filename => 'timelog.csv') }
-    end
-  end
-
-  def show
-    respond_to do |format|
-      # TODO: Implement html response
-      format.html { head 406 }
-      format.api
-    end
-  end
-
-  def new
-    @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :author => User.current, :spent_on => User.current.today)
-    @time_entry.safe_attributes = params[:time_entry]
-  end
-
-  def create
-    @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :author => User.current, :user => User.current, :spent_on => User.current.today)
-    @time_entry.safe_attributes = params[:time_entry]
-    if @time_entry.project && !User.current.allowed_to?(:log_time, @time_entry.project)
-      render_403
-      return
-    end
-
-    call_hook(:controller_timelog_edit_before_save, { :params => params, :time_entry => @time_entry })
-
-    if @time_entry.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_create)
-          if params[:continue]
-            options = {
-              :time_entry => {
-                :project_id => params[:time_entry][:project_id],
-                :issue_id => @time_entry.issue_id,
-                :spent_on => @time_entry.spent_on,
-                :activity_id => @time_entry.activity_id
-              },
-              :back_url => params[:back_url]
-            }
-            if params[:project_id] && @time_entry.project
-              redirect_to new_project_time_entry_path(@time_entry.project, options)
-            elsif params[:issue_id] && @time_entry.issue
-              redirect_to new_issue_time_entry_path(@time_entry.issue, options)
-            else
-              redirect_to new_time_entry_path(options)
-            end
-          else
-            redirect_back_or_default project_time_entries_path(@time_entry.project)
-          end
-        }
-        format.api  { render :action => 'show', :status => :created, :location => time_entry_url(@time_entry) }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'new' }
-        format.api  { render_validation_errors(@time_entry) }
-      end
-    end
-  end
-
-  def edit
-    @time_entry.safe_attributes = params[:time_entry]
-  end
-
-  def update
-    @time_entry.safe_attributes = params[:time_entry]
-    call_hook(:controller_timelog_edit_before_save, { :params => params, :time_entry => @time_entry })
-
-    if @time_entry.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_back_or_default project_time_entries_path(@time_entry.project)
-        }
-        format.api  { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html { render :action => 'edit' }
-        format.api  { render_validation_errors(@time_entry) }
-      end
-    end
-  end
-
-  def bulk_edit
-    @target_projects = Project.allowed_to(:log_time).to_a
-    @custom_fields = TimeEntry.first.available_custom_fields.select {|field| field.format.bulk_edit_supported}
-    if params[:time_entry]
-      @target_project = @target_projects.detect {|p| p.id.to_s == params[:time_entry][:project_id].to_s}
-    end
-    if @target_project
-      @available_activities = @target_project.activities
-    else
-      @available_activities = @projects.map(&:activities).reduce(:&)
-    end
-    @time_entry_params = params[:time_entry] || {}
-    @time_entry_params[:custom_field_values] ||= {}
-  end
-
-  def bulk_update
-    attributes = parse_params_for_bulk_update(params[:time_entry])
-
-    unsaved_time_entries = []
-    saved_time_entries = []
-
-    @time_entries.each do |time_entry|
-      time_entry.reload
-      time_entry.safe_attributes = attributes
-      call_hook(:controller_time_entries_bulk_edit_before_save, { :params => params, :time_entry => time_entry })
-      if time_entry.save
-        saved_time_entries << time_entry
-      else
-        unsaved_time_entries << time_entry
-      end
-    end
-
-    if unsaved_time_entries.empty?
-      flash[:notice] = l(:notice_successful_update) unless saved_time_entries.empty?
-      redirect_back_or_default project_time_entries_path(@projects.first)
-    else
-      @saved_time_entries = @time_entries
-      @unsaved_time_entries = unsaved_time_entries
-      @time_entries = TimeEntry.where(:id => unsaved_time_entries.map(&:id)).
-        preload(:project => :time_entry_activities).
-        preload(:user).to_a
-
-      bulk_edit
-      render :action => 'bulk_edit'
-    end
-  end
-
-  def destroy
-    destroyed = TimeEntry.transaction do
-      @time_entries.each do |t|
-        unless t.destroy && t.destroyed?
-          raise ActiveRecord::Rollback
-        end
-      end
-    end
-
-    respond_to do |format|
-      format.html {
-        if destroyed
-          flash[:notice] = l(:notice_successful_delete)
-        else
-          flash[:error] = l(:notice_unable_delete_time_entry)
-        end
-        redirect_back_or_default project_time_entries_path(@projects.first), :referer => true
-      }
-      format.api  {
-        if destroyed
-          render_api_ok
-        else
-          render_validation_errors(@time_entries)
-        end
-      }
-    end
-  end
-
-  private
-
-  def find_time_entry
-    @time_entry = TimeEntry.find(params[:id])
-    @project = @time_entry.project
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def check_editability
-    unless @time_entry.editable_by?(User.current)
-      render_403
-      return false
-    end
-  end
-
-  def find_time_entries
-    @time_entries = TimeEntry.where(:id => params[:id] || params[:ids]).
-      preload(:project => :time_entry_activities).
-      preload(:user).to_a
-
-    raise ActiveRecord::RecordNotFound if @time_entries.empty?
-    raise Unauthorized unless @time_entries.all? {|t| t.editable_by?(User.current)}
-    @projects = @time_entries.collect(&:project).compact.uniq
-    @project = @projects.first if @projects.size == 1
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def find_optional_issue
-    if params[:issue_id].present?
-      @issue = Issue.find(params[:issue_id])
-      @project = @issue.project
-      authorize
-    else
-      find_optional_project
-    end
-  end
-
-  # Returns the TimeEntry scope for index and report actions
-  def time_entry_scope(options={})
-    @query.results_scope(options)
-  end
-
-  def retrieve_time_entry_query
-    retrieve_query(TimeEntryQuery, false, :defaults => @default_columns_names)
-  end
-end

app/controllers/trackers_controller.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class TrackersController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin, :except => :index
-  before_action :require_admin_or_api_request, :only => :index
-  accept_api_auth :index
-
-  def index
-    @trackers = Tracker.sorted.to_a
-    respond_to do |format|
-      format.html { render :layout => false if request.xhr? }
-      format.api
-    end
-  end
-
-  def new
-    @tracker ||= Tracker.new(:default_status => IssueStatus.sorted.first)
-    @tracker.safe_attributes = params[:tracker]
-    @trackers = Tracker.sorted.to_a
-    @projects = Project.all
-  end
-
-  def create
-    @tracker = Tracker.new
-    @tracker.safe_attributes = params[:tracker]
-    if @tracker.save
-      # workflow copy
-      if !params[:copy_workflow_from].blank? && (copy_from = Tracker.find_by_id(params[:copy_workflow_from]))
-        @tracker.copy_workflow_rules(copy_from)
-      end
-      flash[:notice] = l(:notice_successful_create)
-      redirect_to trackers_path
-      return
-    end
-    new
-    render :action => 'new'
-  end
-
-  def edit
-    @tracker ||= Tracker.find(params[:id])
-    @projects = Project.all
-  end
-
-  def update
-    @tracker = Tracker.find(params[:id])
-    @tracker.safe_attributes = params[:tracker]
-    if @tracker.save
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to trackers_path(:page => params[:page])
-        }
-        format.js { head 200 }
-      end
-    else
-      respond_to do |format|
-        format.html {
-          edit
-          render :action => 'edit'
-        }
-        format.js { head 422 }
-      end
-    end
-  end
-
-  def destroy
-    @tracker = Tracker.find(params[:id])
-    unless @tracker.issues.empty?
-      flash[:error] = l(:error_can_not_delete_tracker)
-    else
-      @tracker.destroy
-    end
-    redirect_to trackers_path
-  end
-
-  def fields
-    if request.post? && params[:trackers]
-      params[:trackers].each do |tracker_id, tracker_params|
-        tracker = Tracker.find_by_id(tracker_id)
-        if tracker
-          tracker.core_fields = tracker_params[:core_fields]
-          tracker.custom_field_ids = tracker_params[:custom_field_ids]
-          tracker.save
-        end
-      end
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to fields_trackers_path
-      return
-    end
-    @trackers = Tracker.sorted.to_a
-    @custom_fields = IssueCustomField.sorted
-  end
-end

app/controllers/users_controller.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class UsersController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin, :except => :show
-  before_action ->{ find_user(false) }, :only => :show
-  before_action :find_user, :only => [:edit, :update, :destroy]
-  accept_api_auth :index, :show, :create, :update, :destroy
-
-  helper :sort
-  include SortHelper
-  helper :custom_fields
-  include CustomFieldsHelper
-  include UsersHelper
-  helper :principal_memberships
-  helper :activities
-  include ActivitiesHelper
-
-  require_sudo_mode :create, :update, :destroy
-
-  def index
-    sort_init 'login', 'asc'
-    sort_update %w(login firstname lastname admin created_on last_login_on)
-
-    case params[:format]
-    when 'xml', 'json'
-      @offset, @limit = api_offset_and_limit
-    else
-      @limit = per_page_option
-    end
-
-    @status = params[:status] || 1
-
-    scope = User.logged.status(@status).preload(:email_address)
-    scope = scope.like(params[:name]) if params[:name].present?
-    scope = scope.in_group(params[:group_id]) if params[:group_id].present?
-
-    @user_count = scope.count
-    @user_pages = Paginator.new @user_count, @limit, params['page']
-    @offset ||= @user_pages.offset
-    @users =  scope.order(sort_clause).limit(@limit).offset(@offset).to_a
-
-    respond_to do |format|
-      format.html {
-        @groups = Group.givable.sort
-        render :layout => !request.xhr?
-      }
-      format.csv {
-        send_data(users_to_csv(scope.order(sort_clause)), :type => 'text/csv; header=present', :filename => 'users.csv')
-      }
-      format.api
-    end
-  end
-
-  def show
-    unless @user.visible?
-      render_404
-      return
-    end
-
-    # show projects based on current user visibility
-    @memberships = @user.memberships.preload(:roles, :project).where(Project.visible_condition(User.current)).to_a
-
-    @issue_counts = {}
-    @issue_counts[:assigned] = {
-      :total  => Issue.visible.assigned_to(@user).count,
-      :open   => Issue.visible.open.assigned_to(@user).count
-    }
-    @issue_counts[:reported] = {
-      :total  => Issue.visible.where(:author_id => @user.id).count,
-      :open   => Issue.visible.open.where(:author_id => @user.id).count
-    }
-
-    respond_to do |format|
-      format.html {
-        events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
-        @events_by_day = events.group_by {|event| User.current.time_to_date(event.event_datetime)}
-        render :layout => 'base'
-      }
-      format.api
-    end
-  end
-
-  def new
-    @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option)
-    @user.safe_attributes = params[:user]
-    @auth_sources = AuthSource.all
-  end
-
-  def create
-    @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option, :admin => false)
-    @user.safe_attributes = params[:user]
-    @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation] unless @user.auth_source_id
-    @user.pref.safe_attributes = params[:pref]
-
-    if @user.save
-      Mailer.deliver_account_information(@user, @user.password) if params[:send_information]
-
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_user_successful_create, :id => view_context.link_to(@user.login, user_path(@user)))
-          if params[:continue]
-            attrs = {:generate_password => @user.generate_password }
-            redirect_to new_user_path(:user => attrs)
-          else
-            redirect_to edit_user_path(@user)
-          end
-        }
-        format.api  { render :action => 'show', :status => :created, :location => user_url(@user) }
-      end
-    else
-      @auth_sources = AuthSource.all
-      # Clear password input
-      @user.password = @user.password_confirmation = nil
-
-      respond_to do |format|
-        format.html { render :action => 'new' }
-        format.api  { render_validation_errors(@user) }
-      end
-    end
-  end
-
-  def edit
-    @auth_sources = AuthSource.all
-    @membership ||= Member.new
-  end
-
-  def update
-    if params[:user][:password].present? && (@user.auth_source_id.nil? || params[:user][:auth_source_id].blank?)
-      @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation]
-    end
-    @user.safe_attributes = params[:user]
-    # Was the account actived ? (do it before User#save clears the change)
-    was_activated = (@user.status_change == [User::STATUS_REGISTERED, User::STATUS_ACTIVE])
-    # TODO: Similar to My#account
-    @user.pref.safe_attributes = params[:pref]
-
-    if @user.save
-      @user.pref.save
-
-      if was_activated
-        Mailer.deliver_account_activated(@user)
-      elsif @user.active? && params[:send_information] && @user != User.current
-        Mailer.deliver_account_information(@user, @user.password)
-      end
-
-      respond_to do |format|
-        format.html {
-          flash[:notice] = l(:notice_successful_update)
-          redirect_to_referer_or edit_user_path(@user)
-        }
-        format.api  { render_api_ok }
-      end
-    else
-      @auth_sources = AuthSource.all
-      @membership ||= Member.new
-      # Clear password input
-      @user.password = @user.password_confirmation = nil
-
-      respond_to do |format|
-        format.html { render :action => :edit }
-        format.api  { render_validation_errors(@user) }
-      end
-    end
-  end
-
-  def destroy
-    @user.destroy
-    respond_to do |format|
-      format.html { redirect_back_or_default(users_path) }
-      format.api  { render_api_ok }
-    end
-  end
-
-  private
-
-  def find_user(logged = true)
-    if params[:id] == 'current'
-      require_login || return
-      @user = User.current
-    elsif logged
-      @user = User.logged.find(params[:id])
-    else
-      @user = User.find(params[:id])
-    end
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-end

app/controllers/versions_controller.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class VersionsController < ApplicationController
-  menu_item :roadmap
-  model_object Version
-  before_action :find_model_object, :except => [:index, :new, :create, :close_completed]
-  before_action :find_project_from_association, :except => [:index, :new, :create, :close_completed]
-  before_action :find_project_by_project_id, :only => [:index, :new, :create, :close_completed]
-  before_action :authorize
-
-  accept_api_auth :index, :show, :create, :update, :destroy
-
-  helper :custom_fields
-  helper :projects
-
-  def index
-    respond_to do |format|
-      format.html {
-        @trackers = @project.trackers.sorted.to_a
-        retrieve_selected_tracker_ids(@trackers, @trackers.select {|t| t.is_in_roadmap?})
-        @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')
-        project_ids = @with_subprojects ? @project.self_and_descendants.pluck(:id) : [@project.id]
-
-        @versions = @project.shared_versions.preload(:custom_values)
-        @versions += @project.rolled_up_versions.visible.preload(:custom_values) if @with_subprojects
-        @versions = @versions.to_a.uniq.sort
-        unless params[:completed]
-          @completed_versions = @versions.select(&:completed?).reverse
-          @versions -= @completed_versions
-        end
-
-        @issues_by_version = {}
-        if @selected_tracker_ids.any? && @versions.any?
-          issues = Issue.visible.
-            includes(:project, :tracker).
-            preload(:status, :priority, :fixed_version).
-            where(:tracker_id => @selected_tracker_ids, :project_id => project_ids, :fixed_version_id => @versions.map(&:id)).
-            order("#{Project.table_name}.lft, #{Tracker.table_name}.position, #{Issue.table_name}.id")
-          @issues_by_version = issues.group_by(&:fixed_version)
-        end
-        @versions.reject! {|version| !project_ids.include?(version.project_id) && @issues_by_version[version].blank?}
-      }
-      format.api {
-        @versions = @project.shared_versions.to_a
-      }
-    end
-  end
-
-  def show
-    respond_to do |format|
-      format.html {
-        @issues = @version.fixed_issues.visible.
-          includes(:status, :tracker, :priority).
-          preload(:project).
-          reorder("#{Tracker.table_name}.position, #{Issue.table_name}.id").
-          to_a
-      }
-      format.api
-    end
-  end
-
-  def new
-    @version = @project.versions.build
-    @version.safe_attributes = params[:version]
-
-    respond_to do |format|
-      format.html
-      format.js
-    end
-  end
-
-  def create
-    @version = @project.versions.build
-    if params[:version]
-      attributes = params[:version].dup
-      attributes.delete('sharing') unless attributes.nil? || @version.allowed_sharings.include?(attributes['sharing'])
-      @version.safe_attributes = attributes
-    end
-
-    if request.post?
-      if @version.save
-        respond_to do |format|
-          format.html do
-            flash[:notice] = l(:notice_successful_create)
-            redirect_back_or_default settings_project_path(@project, :tab => 'versions')
-          end
-          format.js
-          format.api do
-            render :action => 'show', :status => :created, :location => version_url(@version)
-          end
-        end
-      else
-        respond_to do |format|
-          format.html { render :action => 'new' }
-          format.js   { render :action => 'new' }
-          format.api  { render_validation_errors(@version) }
-        end
-      end
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    if params[:version]
-      attributes = params[:version].dup
-      attributes.delete('sharing') unless @version.allowed_sharings.include?(attributes['sharing'])
-      @version.safe_attributes = attributes
-      if @version.save
-        respond_to do |format|
-          format.html {
-            flash[:notice] = l(:notice_successful_update)
-            redirect_back_or_default settings_project_path(@project, :tab => 'versions')
-          }
-          format.api  { render_api_ok }
-        end
-      else
-        respond_to do |format|
-          format.html { render :action => 'edit' }
-          format.api  { render_validation_errors(@version) }
-        end
-      end
-    end
-  end
-
-  def close_completed
-    if request.put?
-      @project.close_completed_versions
-    end
-    redirect_to settings_project_path(@project, :tab => 'versions')
-  end
-
-  def destroy
-    if @version.deletable?
-      @version.destroy
-      respond_to do |format|
-        format.html { redirect_back_or_default settings_project_path(@project, :tab => 'versions') }
-        format.api  { render_api_ok }
-      end
-    else
-      respond_to do |format|
-        format.html {
-          flash[:error] = l(:notice_unable_delete_version)
-          redirect_to settings_project_path(@project, :tab => 'versions')
-        }
-        format.api  { head :unprocessable_entity }
-      end
-    end
-  end
-
-  def status_by
-    respond_to do |format|
-      format.html { render :action => 'show' }
-      format.js
-    end
-  end
-
-  private
-
-  def retrieve_selected_tracker_ids(selectable_trackers, default_trackers=nil)
-    if ids = params[:tracker_ids]
-      @selected_tracker_ids = (ids.is_a? Array) ? ids.collect { |id| id.to_i.to_s } : ids.split('/').collect { |id| id.to_i.to_s }
-    else
-      @selected_tracker_ids = (default_trackers || selectable_trackers).collect {|t| t.id.to_s }
-    end
-  end
-end

app/controllers/watchers_controller.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class WatchersController < ApplicationController
-  before_action :require_login, :find_watchables, :only => [:watch, :unwatch]
-
-  def watch
-    set_watcher(@watchables, User.current, true)
-  end
-
-  def unwatch
-    set_watcher(@watchables, User.current, false)
-  end
-
-  before_action :find_project, :authorize, :only => [:new, :create, :append, :destroy, :autocomplete_for_user]
-  accept_api_auth :create, :destroy
-
-  def new
-    @users = users_for_new_watcher
-  end
-
-  def create
-    user_ids = []
-    if params[:watcher]
-      user_ids << (params[:watcher][:user_ids] || params[:watcher][:user_id])
-    else
-      user_ids << params[:user_id]
-    end
-    users = User.active.visible.where(:id => user_ids.flatten.compact.uniq)
-    users.each do |user|
-      @watchables.each do |watchable|
-        Watcher.create(:watchable => watchable, :user => user)
-      end
-    end
-    respond_to do |format|
-      format.html { redirect_to_referer_or {render :html => 'Watcher added.', :status => 200, :layout => true}}
-      format.js { @users = users_for_new_watcher }
-      format.api { render_api_ok }
-    end
-  end
-
-  def append
-    if params[:watcher]
-      user_ids = params[:watcher][:user_ids] || [params[:watcher][:user_id]]
-      @users = User.active.visible.where(:id => user_ids).to_a
-    end
-    if @users.blank?
-      head 200
-    end
-  end
-
-  def destroy
-    user = User.find(params[:user_id])
-    @watchables.each do |watchable|
-      watchable.set_watcher(user, false)
-    end
-    respond_to do |format|
-      format.html { redirect_to_referer_or {render :html => 'Watcher removed.', :status => 200, :layout => true} }
-      format.js
-      format.api { render_api_ok }
-    end
-  rescue ActiveRecord::RecordNotFound
-    render_404
-  end
-
-  def autocomplete_for_user
-    @users = users_for_new_watcher
-    render :layout => false
-  end
-
-  private
-
-  def find_project
-    if params[:object_type] && params[:object_id]
-      @watchables = find_objets_from_params
-      @projects = @watchables.map(&:project).uniq
-      if @projects.size == 1
-        @project = @projects.first
-      end
-    elsif params[:project_id]
-      @project = Project.visible.find_by_param(params[:project_id])
-    end
-  end
-
-  def find_watchables
-    @watchables = find_objets_from_params
-    unless @watchables.present?
-      render_404
-    end
-  end
-
-  def set_watcher(watchables, user, watching)
-    watchables.each do |watchable|
-      watchable.set_watcher(user, watching)
-    end
-    respond_to do |format|
-      format.html {
-        text = watching ? 'Watcher added.' : 'Watcher removed.'
-        redirect_to_referer_or {render :html => text, :status => 200, :layout => true}
-      }
-      format.js { render :partial => 'set_watcher', :locals => {:user => user, :watched => watchables} }
-    end
-  end
-
-  def users_for_new_watcher
-    scope = nil
-    if params[:q].blank? && @project.present?
-      scope = @project.users
-    else
-      scope = User.all.limit(100)
-    end
-    users = scope.active.visible.sorted.like(params[:q]).to_a
-    if @watchables && @watchables.size == 1
-      users -= @watchables.first.watcher_users
-    end
-    users
-  end
-
-  def find_objets_from_params
-    klass = Object.const_get(params[:object_type].camelcase) rescue nil
-    return unless klass && klass.respond_to?('watched_by')
-
-    scope = klass.where(:id => Array.wrap(params[:object_id]))
-    if klass.reflect_on_association(:project)
-      scope = scope.preload(:project => :enabled_modules)
-    end
-    objects = scope.to_a
-
-    raise Unauthorized if objects.any? do |w|
-      if w.respond_to?(:visible?)
-        !w.visible?
-      elsif w.respond_to?(:project) && w.project
-        !w.project.visible?
-      end
-    end
-    objects
-  end
-end

app/controllers/welcome_controller.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class WelcomeController < ApplicationController
-  self.main_menu = false
-
-  def index
-    @news = News.latest User.current
-  end
-
-  def robots
-    @projects = Project.all_public.active
-    render :layout => false, :content_type => 'text/plain'
-  end
-end

app/controllers/wiki_controller.rb

@@ -91,7 +91,7 @@ class WikiController < ApplicationController
     end
     @content = @page.content_for_version(params[:version])
     if @content.nil?
-      if User.current.allowed_to?(:edit_wiki_pages, @project) && editable? && !api_request?
+      if params[:version].blank? && User.current.allowed_to?(:edit_wiki_pages, @project) && editable? && !api_request?
         edit
         render :action => 'edit'
       else

app/controllers/wikis_controller.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class WikisController < ApplicationController
-  menu_item :settings
-  before_action :find_project, :authorize
-
-  # Delete a project's wiki
-  def destroy
-    if request.post? && params[:confirm] && @project.wiki
-      @project.wiki.destroy
-      redirect_to settings_project_path(@project, :tab => 'wiki')
-    end
-  end
-end

app/controllers/workflows_controller.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class WorkflowsController < ApplicationController
-  layout 'admin'
-  self.main_menu = false
-
-  before_action :require_admin
-
-  def index
-    @roles = Role.sorted.select(&:consider_workflow?)
-    @trackers = Tracker.sorted
-    @workflow_counts = WorkflowTransition.group(:tracker_id, :role_id).count
-  end
-
-  def edit
-    find_trackers_roles_and_statuses_for_edit
-
-    if request.post? && @roles && @trackers && params[:transitions]
-      transitions = params[:transitions].deep_dup
-      transitions.each do |old_status_id, transitions_by_new_status|
-        transitions_by_new_status.each do |new_status_id, transition_by_rule|
-          transition_by_rule.reject! {|rule, transition| transition == 'no_change'}
-        end
-      end
-      WorkflowTransition.replace_transitions(@trackers, @roles, transitions)
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to_referer_or workflows_edit_path
-      return
-    end
-
-    if @trackers && @roles && @statuses.any?
-      workflows = WorkflowTransition.
-        where(:role_id => @roles.map(&:id), :tracker_id => @trackers.map(&:id)).
-        preload(:old_status, :new_status)
-      @workflows = {}
-      @workflows['always'] = workflows.select {|w| !w.author && !w.assignee}
-      @workflows['author'] = workflows.select {|w| w.author}
-      @workflows['assignee'] = workflows.select {|w| w.assignee}
-    end
-  end
-
-  def permissions
-    find_trackers_roles_and_statuses_for_edit
-
-    if request.post? && @roles && @trackers && params[:permissions]
-      permissions = params[:permissions].deep_dup
-      permissions.each { |field, rule_by_status_id|
-        rule_by_status_id.reject! {|status_id, rule| rule == 'no_change'}
-      }
-      WorkflowPermission.replace_permissions(@trackers, @roles, permissions)
-      flash[:notice] = l(:notice_successful_update)
-      redirect_to_referer_or workflows_permissions_path
-      return
-    end
-
-    if @roles && @trackers
-      @fields = (Tracker::CORE_FIELDS_ALL - @trackers.map(&:disabled_core_fields).reduce(:&)).map {|field| [field, l("field_"+field.sub(/_id$/, ''))]}
-      @custom_fields = @trackers.map(&:custom_fields).flatten.uniq.sort
-      @permissions = WorkflowPermission.rules_by_status_id(@trackers, @roles)
-      @statuses.each {|status| @permissions[status.id] ||= {}}
-    end
-  end
-
-  def copy
-    @roles = Role.sorted.select(&:consider_workflow?)
-    @trackers = Tracker.sorted
-
-    if params[:source_tracker_id].blank? || params[:source_tracker_id] == 'any'
-      @source_tracker = nil
-    else
-      @source_tracker = Tracker.find_by_id(params[:source_tracker_id].to_i)
-    end
-    if params[:source_role_id].blank? || params[:source_role_id] == 'any'
-      @source_role = nil
-    else
-      @source_role = Role.find_by_id(params[:source_role_id].to_i)
-    end
-    @target_trackers = params[:target_tracker_ids].blank? ?
-        nil : Tracker.where(:id => params[:target_tracker_ids]).to_a
-    @target_roles = params[:target_role_ids].blank? ?
-        nil : Role.where(:id => params[:target_role_ids]).to_a
-    if request.post?
-      if params[:source_tracker_id].blank? || params[:source_role_id].blank? || (@source_tracker.nil? && @source_role.nil?)
-        flash.now[:error] = l(:error_workflow_copy_source)
-      elsif @target_trackers.blank? || @target_roles.blank?
-        flash.now[:error] = l(:error_workflow_copy_target)
-      else
-        WorkflowRule.copy(@source_tracker, @source_role, @target_trackers, @target_roles)
-        flash[:notice] = l(:notice_successful_update)
-        redirect_to workflows_copy_path(:source_tracker_id => @source_tracker, :source_role_id => @source_role)
-      end
-    end
-  end
-
-  private
-
-  def find_trackers_roles_and_statuses_for_edit
-    find_roles
-    find_trackers
-    find_statuses
-  end
-
-  def find_roles
-    ids = Array.wrap(params[:role_id])
-    if ids == ['all']
-      @roles = Role.sorted.select(&:consider_workflow?)
-    elsif ids.present?
-      @roles = Role.where(:id => ids).to_a
-    end
-    @roles = nil if @roles.blank?
-  end
-
-  def find_trackers
-    ids = Array.wrap(params[:tracker_id])
-    if ids == ['all']
-      @trackers = Tracker.sorted.to_a
-    elsif ids.present?
-      @trackers = Tracker.where(:id => ids).to_a
-    end
-    @trackers = nil if @trackers.blank?
-  end
-
-  def find_statuses
-    @used_statuses_only = (params[:used_statuses_only] == '0' ? false : true)
-    if @trackers && @used_statuses_only
-      role_ids = Role.all.select(&:consider_workflow?).map(&:id)
-      status_ids = WorkflowTransition.where(
-        :tracker_id => @trackers.map(&:id), :role_id => role_ids
-      ).distinct.pluck(:old_status_id, :new_status_id).flatten.uniq
-      @statuses = IssueStatus.where(:id => status_ids).sorted.to_a.presence
-    end
-    @statuses ||= IssueStatus.sorted.to_a
-  end
-end

app/helpers/account_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module AccountHelper
-end

app/helpers/activities_helper.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module ActivitiesHelper
-  def sort_activity_events(events)
-    events_by_group = events.group_by(&:event_group)
-    sorted_events = []
-    events.sort_by(&:event_datetime).reverse_each do |event|
-      if group_events = events_by_group.delete(event.event_group)
-        group_events.sort_by(&:event_datetime).reverse.each_with_index do |e, i|
-          sorted_events << [e, i > 0]
-        end
-      end
-    end
-    sorted_events
-  end
-end

app/helpers/admin_helper.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module AdminHelper
-  def project_status_options_for_select(selected)
-    options_for_select([[l(:label_all), ''],
-                        [l(:project_status_active), '1'],
-                        [l(:project_status_closed), '5'],
-                        [l(:project_status_archived), '9']], selected.to_s)
-  end
-
-  def plugin_data_for_updates(plugins)
-    data = {"v" => Redmine::VERSION.to_s, "p" => {}}
-    plugins.each do |plugin|
-      data["p"].merge! plugin.id => {"v" => plugin.version, "n" => plugin.name, "a" => plugin.author}
-    end
-    data
-  end
-end

app/helpers/attachments_helper.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module AttachmentsHelper
-
-  def container_attachments_edit_path(container)
-    object_attachments_edit_path container.class.name.underscore.pluralize, container.id
-  end
-
-  def container_attachments_path(container)
-    object_attachments_path container.class.name.underscore.pluralize, container.id
-  end
-
-  # Displays view/delete links to the attachments of the given object
-  # Options:
-  #   :author -- author names are not displayed if set to false
-  #   :thumbails -- display thumbnails if enabled in settings
-  def link_to_attachments(container, options = {})
-    options.assert_valid_keys(:author, :thumbnails)
-    attachments =
-      if container.attachments.loaded?
-        container.attachments
-      else
-        container.attachments.preload(:author).to_a
-      end
-    if attachments.any?
-      options = {
-        :editable => container.attachments_editable?,
-        :deletable => container.attachments_deletable?,
-        :author => true
-      }.merge(options)
-      render :partial => 'attachments/links',
-        :locals => {
-          :container => container,
-          :attachments => attachments,
-          :options => options,
-          :thumbnails => (options[:thumbnails] && Setting.thumbnails_enabled?)
-        }
-    end
-  end
-
-  def render_pagination
-    pagination_links_each @paginator do |text, parameters, options|
-      if att = @attachments[parameters[:page] - 1]
-        link_to text, named_attachment_path(att, att.filename)
-      end
-    end if @paginator
-  end
-
-  def render_api_attachment(attachment, api, options={})
-    api.attachment do
-      render_api_attachment_attributes(attachment, api)
-      options.each { |key, value| eval("api.#{key} value") }
-    end
-  end
-
-  def render_api_attachment_attributes(attachment, api)
-    api.id attachment.id
-    api.filename attachment.filename
-    api.filesize attachment.filesize
-    api.content_type attachment.content_type
-    api.description attachment.description
-    api.content_url download_named_attachment_url(attachment, attachment.filename)
-    if attachment.thumbnailable?
-      api.thumbnail_url thumbnail_url(attachment)
-    end
-    if attachment.author
-      api.author(:id => attachment.author.id, :name => attachment.author.name)
-    end
-    api.created_on attachment.created_on
-  end
-
-  def render_file_content(attachment, content)
-    if attachment.is_markdown?
-      render :partial => 'common/markup', :locals => {:markup_text_formatting => 'markdown', :markup_text => content}
-    elsif attachment.is_textile?
-      render :partial => 'common/markup', :locals => {:markup_text_formatting => 'textile', :markup_text => content}
-    else
-      render :partial => 'common/file', :locals => {:content => content, :filename => attachment.filename}
-    end
-  end
-end

app/helpers/auth_sources_helper.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module AuthSourcesHelper
-  def auth_source_partial_name(auth_source)
-    "form_#{auth_source.class.name.underscore}"
-  end
-end

app/helpers/avatars_helper.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module AvatarsHelper
-  include GravatarHelper::PublicMethods
-
-  def assignee_avatar(user, options={})
-    return '' unless user
-
-    options.merge!(:title => l(:field_assigned_to) + ": " + user.name)
-    avatar(user, options).to_s.html_safe
-  end
-
-  def author_avatar(user, options={})
-    return '' unless user
-
-    options.merge!(:title => l(:field_author) + ": " + user.name)
-    avatar(user, options).to_s.html_safe
-  end
-
-  # Returns the avatar image tag for the given +user+ if avatars are enabled
-  # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
-  def avatar(user, options = { })
-    if Setting.gravatar_enabled?
-      options.merge!(:default => Setting.gravatar_default)
-      options[:class] = GravatarHelper::DEFAULT_OPTIONS[:class] + " " + options[:class] if options[:class]
-      email = nil
-      if user.respond_to?(:mail)
-        email = user.mail
-        options[:title] = user.name unless options[:title]
-      elsif user.to_s =~ %r{<(.+?)>}
-        email = $1
-      end
-      if email.present?
-        gravatar(email.to_s.downcase, options) rescue nil
-      elsif user.is_a?(AnonymousUser)
-        anonymous_avatar(options)
-      else
-        nil
-      end
-    else
-      ''
-    end
-  end
-
-  # Returns a link to edit user's avatar if avatars are enabled
-  def avatar_edit_link(user, options={})
-    if Setting.gravatar_enabled?
-      url = Redmine::Configuration['avatar_server_url']
-      link_to avatar(user, {:title => l(:button_edit)}.merge(options)), url, :target => '_blank'
-    end
-  end
-
-  private
-
-  def anonymous_avatar(options={})
-    image_tag 'anonymous.png', GravatarHelper::DEFAULT_OPTIONS.except(:default, :rating, :ssl).merge(options)
-  end
-end

app/helpers/boards_helper.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module BoardsHelper
-  def board_breadcrumb(item)
-    board = item.is_a?(Message) ? item.board : item
-    links = [link_to(l(:label_board_plural), project_boards_path(item.project))]
-    boards = board.ancestors.reverse
-    if item.is_a?(Message)
-      boards << board
-    end
-    links += boards.map {|ancestor| link_to(h(ancestor.name), project_board_path(ancestor.project, ancestor))}
-    breadcrumb links
-  end
-
-  def boards_options_for_select(boards)
-    options = []
-    Board.board_tree(boards) do |board, level|
-      label = (level > 0 ? '&nbsp;' * 2 * level + '&#187; ' : '').html_safe
-      label << board.name
-      options << [label, board.id]
-    end
-    options
-  end
-end

app/helpers/calendars_helper.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module CalendarsHelper
-  include Redmine::Utils::DateCalculation
-
-  def calendar_day_css_classes(calendar, day)
-    css = day.month==calendar.month ? +'even' : +'odd'
-    css << " today" if User.current.today == day
-    css << " nwday" if non_working_week_days.include?(day.cwday)
-    css
-  end
-end

app/helpers/context_menus_helper.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module ContextMenusHelper
-  def context_menu_link(name, url, options={})
-    options[:class] ||= ''
-    if options.delete(:selected)
-      options[:class] += ' icon-checked disabled'
-      options[:disabled] = true
-    end
-    if options.delete(:disabled)
-      options.delete(:method)
-      options.delete(:data)
-      options[:onclick] = 'return false;'
-      options[:class] += ' disabled'
-      url = '#'
-    end
-    link_to h(name), url, options
-  end
-
-  def bulk_update_custom_field_context_menu_link(field, text, value)
-    context_menu_link(
-      h(text),
-      bulk_update_issues_path(:ids => @issue_ids,
-                              :issue => {'custom_field_values' => {field.id => value}},
-                              :back_url => @back),
-      :method => :post,
-      :selected => (@issue && @issue.custom_field_value(field) == value)
-    )
-  end
-
-  def bulk_update_time_entry_custom_field_context_menu_link(field, text, value)
-    context_menu_link(
-      h(text),
-      bulk_update_time_entries_path(:ids => @time_entries.map(&:id).sort,
-                                    :time_entry => {'custom_field_values' => {field.id => value}},
-                                    :back_url => @back),
-      :method => :post,
-      :selected => (@time_entry && @time_entry.custom_field_value(field) == value)
-    )
-  end
-end

app/helpers/custom_fields_helper.rb

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module CustomFieldsHelper
-
-  CUSTOM_FIELDS_TABS = [
-    {:name => 'IssueCustomField', :partial => 'custom_fields/index',
-     :label => :label_issue_plural},
-    {:name => 'TimeEntryCustomField', :partial => 'custom_fields/index',
-     :label => :label_spent_time},
-    {:name => 'ProjectCustomField', :partial => 'custom_fields/index',
-     :label => :label_project_plural},
-    {:name => 'VersionCustomField', :partial => 'custom_fields/index',
-     :label => :label_version_plural},
-    {:name => 'DocumentCustomField', :partial => 'custom_fields/index',
-     :label => :label_document_plural},
-    {:name => 'UserCustomField', :partial => 'custom_fields/index',
-     :label => :label_user_plural},
-    {:name => 'GroupCustomField', :partial => 'custom_fields/index',
-     :label => :label_group_plural},
-    {:name => 'TimeEntryActivityCustomField', :partial => 'custom_fields/index',
-     :label => TimeEntryActivity::OptionName},
-    {:name => 'IssuePriorityCustomField', :partial => 'custom_fields/index',
-     :label => IssuePriority::OptionName},
-    {:name => 'DocumentCategoryCustomField', :partial => 'custom_fields/index',
-     :label => DocumentCategory::OptionName}
-  ]
-
-  def render_custom_fields_tabs(types)
-    tabs = CUSTOM_FIELDS_TABS.select {|h| types.include?(h[:name]) }
-    render_tabs tabs
-  end
-
-  def custom_field_type_options
-    CUSTOM_FIELDS_TABS.map {|h| [l(h[:label]), h[:name]]}
-  end
-
-  def custom_field_title(custom_field)
-    items = []
-    items << [l(:label_custom_field_plural), custom_fields_path]
-    items << [l(custom_field.type_name), custom_fields_path(:tab => custom_field.class.name)] if custom_field
-    items << (custom_field.nil? || custom_field.new_record? ? l(:label_custom_field_new) : custom_field.name)
-
-    title(*items)
-  end
-
-  def render_custom_field_format_partial(form, custom_field)
-    partial = custom_field.format.form_partial
-    if partial
-      render :partial => custom_field.format.form_partial, :locals => {:f => form, :custom_field => custom_field}
-    end
-  end
-
-  def custom_field_tag_name(prefix, custom_field)
-    name = "#{prefix}[custom_field_values][#{custom_field.id}]"
-    name += "[]" if custom_field.multiple?
-    name
-  end
-
-  def custom_field_tag_id(prefix, custom_field)
-    "#{prefix}_custom_field_values_#{custom_field.id}"
-  end
-
-  # Return custom field html tag corresponding to its format
-  def custom_field_tag(prefix, custom_value)
-    css = "#{custom_value.custom_field.field_format}_cf"
-    data = nil
-    if custom_value.custom_field.full_text_formatting?
-      css += ' wiki-edit'
-      data = {
-        :auto_complete => true,
-        :issues_url => auto_complete_issues_path(:project_id => custom_value.customized.project, :q => '')
-      } if custom_value.customized&.try(:project)
-    end
-    custom_value.custom_field.format.edit_tag(
-      self,
-      custom_field_tag_id(prefix, custom_value.custom_field),
-      custom_field_tag_name(prefix, custom_value.custom_field),
-      custom_value,
-      :class => css,
-      :data => data)
-  end
-
-  # Return custom field name tag
-  def custom_field_name_tag(custom_field)
-    title = custom_field.description.presence
-    css = title ? "field-description" : nil
-    content_tag 'span', custom_field.name, :title => title, :class => css
-  end
-
-  # Return custom field label tag
-  def custom_field_label_tag(name, custom_value, options={})
-    required = options[:required] || custom_value.custom_field.is_required?
-    for_tag_id = options.fetch(:for_tag_id, "#{name}_custom_field_values_#{custom_value.custom_field.id}")
-    content = custom_field_name_tag custom_value.custom_field
-    content_tag(
-      "label", content +
-      (required ? " <span class=\"required\">*</span>".html_safe : ""),
-      :for => for_tag_id)
-  end
-
-  # Return custom field tag with its label tag
-  def custom_field_tag_with_label(name, custom_value, options={})
-    tag = custom_field_tag(name, custom_value)
-    tag_id = nil
-    ids = tag.scan(/ id="(.+?)"/)
-    if ids.size == 1
-      tag_id = ids.first.first
-    end
-    custom_field_label_tag(name, custom_value, options.merge(:for_tag_id => tag_id)) + tag
-  end
-
-  # Returns the custom field tag for when bulk editing objects
-  def custom_field_tag_for_bulk_edit(prefix, custom_field, objects=nil, value='')
-    custom_field.format.bulk_edit_tag(
-      self,
-      custom_field_tag_id(prefix, custom_field),
-      custom_field_tag_name(prefix, custom_field),
-      custom_field,
-      objects,
-      value,
-      :class => "#{custom_field.field_format}_cf")
-  end
-
-  # Returns custom field value tag
-  def custom_field_value_tag(value)
-    attr_value = show_value(value)
-
-    if !attr_value.blank? && value.custom_field.full_text_formatting?
-      content_tag('div', attr_value, :class => 'wiki')
-    else
-      attr_value
-    end
-  end
-
-  # Return a string used to display a custom value
-  def show_value(custom_value, html=true)
-    format_object(custom_value, html)
-  end
-
-  # Return a string used to display a custom value
-  def format_value(value, custom_field)
-    format_object(custom_field.format.formatted_value(self, custom_field, value, false), false)
-  end
-
-  # Return an array of custom field formats which can be used in select_tag
-  def custom_field_formats_for_select(custom_field)
-    Redmine::FieldFormat.as_select(custom_field.class.customized_class.name)
-  end
-
-  # Yields the given block for each custom field value of object that should be
-  # displayed, with the custom field and the formatted value as arguments
-  def render_custom_field_values(object, &block)
-    object.visible_custom_field_values.each do |custom_value|
-      formatted = show_value(custom_value)
-      if formatted.present?
-        yield custom_value.custom_field, formatted
-      end
-    end
-  end
-
-  # Renders the custom_values in api views
-  def render_api_custom_values(custom_values, api)
-    api.array :custom_fields do
-      custom_values.each do |custom_value|
-        attrs = {:id => custom_value.custom_field_id, :name => custom_value.custom_field.name}
-        attrs.merge!(:multiple => true) if custom_value.custom_field.multiple?
-        api.custom_field attrs do
-          if custom_value.value.is_a?(Array)
-            api.array :value do
-              custom_value.value.each do |value|
-                api.value value unless value.blank?
-              end
-            end
-          else
-            api.value custom_value.value
-          end
-        end
-      end
-    end unless custom_values.empty?
-  end
-
-  def edit_tag_style_tag(form, options={})
-    select_options = [[l(:label_drop_down_list), ''], [l(:label_checkboxes), 'check_box']]
-    if options[:include_radio]
-      select_options << [l(:label_radio_buttons), 'radio']
-    end
-    form.select :edit_tag_style, select_options, :label => :label_display
-  end
-
-  def select_type_radio_buttons(default_type)
-    if CUSTOM_FIELDS_TABS.none? {|tab| tab[:name] == default_type}
-      default_type = 'IssueCustomField'
-    end
-    custom_field_type_options.map do |name, type|
-      content_tag(:label, :style => 'display:block;') do
-        radio_button_tag('type', type, type == default_type) + name
-      end
-    end.join("\n").html_safe
-  end
-end

app/helpers/documents_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module DocumentsHelper
-end

app/helpers/email_addresses_helper.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module EmailAddressesHelper
-
-  # Returns a link to enable or disable notifications for the address
-  def toggle_email_address_notify_link(address)
-    if address.notify?
-      link_to(
-        l(:label_disable_notifications),
-        user_email_address_path(address.user, address, :notify => '0'),
-        :method => :put, :remote => true,
-        :title => l(:label_disable_notifications),
-        :class => 'icon-only icon-email')
-    else
-      link_to(
-        l(:label_enable_notifications),
-        user_email_address_path(address.user, address, :notify => '1'),
-        :method => :put, :remote => true,
-        :title => l(:label_enable_notifications),
-        :class => 'icon-only icon-email-disabled')
-    end
-  end
-end

app/helpers/enumerations_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module EnumerationsHelper
-end

app/helpers/gantt_helper.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module GanttHelper
-
-  def gantt_zoom_link(gantt, in_or_out)
-    case in_or_out
-    when :in
-      if gantt.zoom < 4
-        link_to(
-          l(:text_zoom_in),
-          {:params => request.query_parameters.merge(gantt.params.merge(:zoom => (gantt.zoom + 1)))},
-          :class => 'icon icon-zoom-in')
-      else
-        content_tag(:span, l(:text_zoom_in), :class => 'icon icon-zoom-in').html_safe
-      end
-
-    when :out
-      if gantt.zoom > 1
-        link_to(
-          l(:text_zoom_out),
-          {:params => request.query_parameters.merge(gantt.params.merge(:zoom => (gantt.zoom - 1)))},
-          :class => 'icon icon-zoom-out')
-      else
-        content_tag(:span, l(:text_zoom_out), :class => 'icon icon-zoom-out').html_safe
-      end
-    end
-  end
-end

app/helpers/groups_helper.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module GroupsHelper
-  def group_settings_tabs(group)
-    tabs = []
-    tabs << {:name => 'general', :partial => 'groups/general', :label => :label_general}
-    tabs << {:name => 'users', :partial => 'groups/users', :label => :label_user_plural} if group.givable?
-    tabs << {:name => 'memberships', :partial => 'groups/memberships', :label => :label_project_plural}
-    tabs
-  end
-
-  def render_principals_for_new_group_users(group, limit=100)
-    scope = User.active.sorted.not_in_group(group).like(params[:q])
-    principal_count = scope.count
-    principal_pages = Redmine::Pagination::Paginator.new principal_count, limit, params['page']
-    principals = scope.offset(principal_pages.offset).limit(principal_pages.per_page).to_a
-    s = content_tag(
-      'div',
-      content_tag('div', principals_check_box_tags('user_ids[]', principals), :id => 'principals'),
-      :class => 'objects-selection'
-    )
-    links = pagination_links_full(principal_pages, principal_count, :per_page_links => false) {|text, parameters, options|
-      link_to text, autocomplete_for_user_group_path(group, parameters.merge(:q => params[:q], :format => 'js')), :remote => true
-    }
-    s + content_tag('span', links, :class => 'pagination')
-  end
-end

app/helpers/imports_helper.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module ImportsHelper
-  def import_title
-    l(:"label_import_#{import_partial_prefix}")
-  end
-
-  def import_partial_prefix
-    @import.class.name.sub('Import', '').underscore.pluralize
-  end
-
-  def options_for_mapping_select(import, field, options={})
-    tags = "".html_safe
-    blank_text = options[:required] ? "-- #{l(:actionview_instancetag_blank_option)} --" : " ".html_safe
-    tags << content_tag('option', blank_text, :value => '')
-    tags << options_for_select(import.columns_options, import.mapping[field])
-    if values = options[:values]
-      tags << content_tag('option', '--', :disabled => true)
-      tags << options_for_select(values.map {|text, value| [text, "value:#{value}"]}, import.mapping[field] || options[:default_value])
-    end
-    tags
-  end
-
-  def mapping_select_tag(import, field, options={})
-    name = "import_settings[mapping][#{field}]"
-    select_tag name, options_for_mapping_select(import, field, options), :id => "import_mapping_#{field}"
-  end
-
-  # Returns the options for the date_format setting
-  def date_format_options
-    Import::DATE_FORMATS.map do |f|
-      format = f.gsub('%', '').gsub(/[dmY]/) do
-        {'d' => 'DD', 'm' => 'MM', 'Y' => 'YYYY'}[$&]
-      end
-      [format, f]
-    end
-  end
-end

app/helpers/issue_categories_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module IssueCategoriesHelper
-end

app/helpers/issue_relations_helper.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module IssueRelationsHelper
-  def collection_for_relation_type_select
-    values = IssueRelation::TYPES
-    values.keys.sort_by{|k| values[k][:order]}.collect{|k| [l(values[k][:name]), k]}
-  end
-end

app/helpers/issue_statuses_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module IssueStatusesHelper
-end

app/helpers/issues_helper.rb

@@ -1,641 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module IssuesHelper
-  include ApplicationHelper
-  include Redmine::Export::PDF::IssuesPdfHelper
-
-  def issue_list(issues, &block)
-    ancestors = []
-    issues.each do |issue|
-      while ancestors.any? &&
-            !issue.is_descendant_of?(ancestors.last)
-        ancestors.pop
-      end
-      yield issue, ancestors.size
-      ancestors << issue unless issue.leaf?
-    end
-  end
-
-  def grouped_issue_list(issues, query, &block)
-    ancestors = []
-    grouped_query_results(issues, query) do |issue, group_name, group_count, group_totals|
-      while ancestors.any? &&
-            !issue.is_descendant_of?(ancestors.last)
-        ancestors.pop
-      end
-      yield issue, ancestors.size, group_name, group_count, group_totals
-      ancestors << issue unless issue.leaf?
-    end
-  end
-
-  # Renders a HTML/CSS tooltip
-  #
-  # To use, a trigger div is needed.  This is a div with the class of "tooltip"
-  # that contains this method wrapped in a span with the class of "tip"
-  #
-  #    <div class="tooltip"><%= link_to_issue(issue) %>
-  #      <span class="tip"><%= render_issue_tooltip(issue) %></span>
-  #    </div>
-  #
-  def render_issue_tooltip(issue)
-    @cached_label_status ||= l(:field_status)
-    @cached_label_start_date ||= l(:field_start_date)
-    @cached_label_due_date ||= l(:field_due_date)
-    @cached_label_assigned_to ||= l(:field_assigned_to)
-    @cached_label_priority ||= l(:field_priority)
-    @cached_label_project ||= l(:field_project)
-
-    link_to_issue(issue) + "<br /><br />".html_safe +
-      "<strong>#{@cached_label_project}</strong>: #{link_to_project(issue.project)}<br />".html_safe +
-      "<strong>#{@cached_label_status}</strong>: #{h(issue.status.name) + (" (#{format_date(issue.closed_on)})" if issue.closed?)}<br />".html_safe +
-      "<strong>#{@cached_label_start_date}</strong>: #{format_date(issue.start_date)}<br />".html_safe +
-      "<strong>#{@cached_label_due_date}</strong>: #{format_date(issue.due_date)}<br />".html_safe +
-      "<strong>#{@cached_label_assigned_to}</strong>: #{avatar(issue.assigned_to, :size => '13', :title => l(:field_assigned_to)) if issue.assigned_to} #{h(issue.assigned_to)}<br />".html_safe +
-      "<strong>#{@cached_label_priority}</strong>: #{h(issue.priority.name)}".html_safe
-  end
-
-  def issue_heading(issue)
-    h("#{issue.tracker} ##{issue.id}")
-  end
-
-  def render_issue_subject_with_tree(issue)
-    s = +''
-    ancestors = issue.root? ? [] : issue.ancestors.visible.to_a
-    ancestors.each do |ancestor|
-      s << '<div>' + content_tag('p', link_to_issue(ancestor, :project => (issue.project_id != ancestor.project_id)))
-    end
-    s << '<div>'
-    subject = h(issue.subject)
-    if issue.is_private?
-      subject = subject + ' ' + content_tag('span', l(:field_is_private), :class => 'badge badge-private private')
-    end
-    s << content_tag('h3', subject)
-    s << '</div>' * (ancestors.size + 1)
-    s.html_safe
-  end
-
-  def render_descendants_tree(issue)
-    manage_relations = User.current.allowed_to?(:manage_subtasks, issue.project)
-    s = +'<table class="list issues odd-even">'
-    issue_list(
-      issue.descendants.visible.
-        preload(:status, :priority, :tracker,
-                :assigned_to).sort_by(&:lft)) do |child, level|
-      css = +"issue issue-#{child.id} hascontextmenu #{child.css_classes}"
-      css << " idnt idnt-#{level}" if level > 0
-      buttons =
-        if manage_relations
-          link_to(l(:label_delete_link_to_subtask),
-                  issue_path(
-                    {:id => child.id, :issue => {:parent_issue_id => ''},
-                     :back_url => issue_path(issue.id), :no_flash => '1'}),
-                  :method => :put,
-                  :data => {:confirm => l(:text_are_you_sure)},
-                  :title => l(:label_delete_link_to_subtask),
-                  :class => 'icon-only icon-link-break'
-                  )
-        else
-          "".html_safe
-        end
-      buttons << link_to_context_menu
-      s <<
-        content_tag(
-          'tr',
-          content_tag('td', check_box_tag("ids[]", child.id, false, :id => nil),
-                      :class => 'checkbox') +
-             content_tag('td',
-                         link_to_issue(
-                           child,
-                           :project => (issue.project_id != child.project_id)),
-                         :class => 'subject') +
-             content_tag('td', h(child.status), :class => 'status') +
-             content_tag('td', link_to_user(child.assigned_to), :class => 'assigned_to') +
-             content_tag('td', format_date(child.start_date), :class => 'start_date') +
-             content_tag('td', format_date(child.due_date), :class => 'due_date') +
-             content_tag('td',
-                         (if child.disabled_core_fields.include?('done_ratio')
-                            ''
-                          else
-                             progress_bar(child.done_ratio)
-                          end),
-                         :class=> 'done_ratio') +
-             content_tag('td', buttons, :class => 'buttons'),
-          :class => css)
-    end
-    s << '</table>'
-    s.html_safe
-  end
-
-  # Renders the list of related issues on the issue details view
-  def render_issue_relations(issue, relations)
-    manage_relations = User.current.allowed_to?(:manage_issue_relations, issue.project)
-    s = ''.html_safe
-    relations.each do |relation|
-      other_issue = relation.other_issue(issue)
-      css = "issue hascontextmenu #{other_issue.css_classes}"
-      buttons =
-        if manage_relations
-          link_to(
-            l(:label_relation_delete),
-            relation_path(relation),
-            :remote => true,
-            :method => :delete,
-            :data => {:confirm => l(:text_are_you_sure)},
-            :title => l(:label_relation_delete),
-            :class => 'icon-only icon-link-break'
-          )
-        else
-          "".html_safe
-        end
-      buttons << link_to_context_menu
-      s <<
-        content_tag(
-          'tr',
-          content_tag('td',
-                      check_box_tag(
-                        "ids[]", other_issue.id,
-                        false, :id => nil),
-                      :class => 'checkbox') +
-             content_tag('td',
-                         relation.to_s(@issue) {|other|
-                           link_to_issue(
-                             other,
-                             :project => Setting.cross_project_issue_relations?)
-                         }.html_safe,
-                         :class => 'subject') +
-             content_tag('td', other_issue.status, :class => 'status') +
-             content_tag('td', link_to_user(other_issue.assigned_to), :class => 'assigned_to') +
-             content_tag('td', format_date(other_issue.start_date), :class => 'start_date') +
-             content_tag('td', format_date(other_issue.due_date), :class => 'due_date') +
-             content_tag('td',
-                         (if other_issue.disabled_core_fields.include?('done_ratio')
-                            ''
-                          else
-                            progress_bar(other_issue.done_ratio)
-                          end),
-                         :class=> 'done_ratio') +
-             content_tag('td', buttons, :class => 'buttons'),
-          :id => "relation-#{relation.id}",
-          :class => css)
-    end
-    content_tag('table', s, :class => 'list issues odd-even')
-  end
-
-  def issue_estimated_hours_details(issue)
-    if issue.total_estimated_hours.present?
-      if issue.total_estimated_hours == issue.estimated_hours
-        l_hours_short(issue.estimated_hours)
-      else
-        s = issue.estimated_hours.present? ? l_hours_short(issue.estimated_hours) : ""
-        s += " (#{l(:label_total)}: #{l_hours_short(issue.total_estimated_hours)})"
-        s.html_safe
-      end
-    end
-  end
-
-  def issue_spent_hours_details(issue)
-    if issue.total_spent_hours > 0
-      path = project_time_entries_path(issue.project, :issue_id => "~#{issue.id}")
-
-      if issue.total_spent_hours == issue.spent_hours
-        link_to(l_hours_short(issue.spent_hours), path)
-      else
-        s = issue.spent_hours > 0 ? l_hours_short(issue.spent_hours) : ""
-        s += " (#{l(:label_total)}: #{link_to l_hours_short(issue.total_spent_hours), path})"
-        s.html_safe
-      end
-    end
-  end
-
-  def issue_due_date_details(issue)
-    return if issue&.due_date.nil?
-    s = format_date(issue.due_date)
-    s += " (#{due_date_distance_in_words(issue.due_date)})" unless issue.closed?
-    s
-  end
-
-  # Returns a link for adding a new subtask to the given issue
-  def link_to_new_subtask(issue)
-    attrs = {
-      :parent_issue_id => issue
-    }
-    attrs[:tracker_id] = issue.tracker unless issue.tracker.disabled_core_fields.include?('parent_issue_id')
-    link_to(l(:button_add), new_project_issue_path(issue.project, :issue => attrs, :back_url => issue_path(issue)))
-  end
-
-  def trackers_options_for_select(issue)
-    trackers = trackers_for_select(issue)
-    trackers.collect {|t| [t.name, t.id]}
-  end
-
-  def trackers_for_select(issue)
-    trackers = issue.allowed_target_trackers
-    if issue.new_record? && issue.parent_issue_id.present?
-      trackers = trackers.reject do |tracker|
-        issue.tracker_id != tracker.id && tracker.disabled_core_fields.include?('parent_issue_id')
-      end
-    end
-    trackers
-  end
-
-  class IssueFieldsRows
-    include ActionView::Helpers::TagHelper
-
-    def initialize
-      @left = []
-      @right = []
-    end
-
-    def left(*args)
-      args.any? ? @left << cells(*args) : @left
-    end
-
-    def right(*args)
-      args.any? ? @right << cells(*args) : @right
-    end
-
-    def size
-      @left.size > @right.size ? @left.size : @right.size
-    end
-
-    def to_html
-      content =
-        content_tag('div', @left.reduce(&:+), :class => 'splitcontentleft') +
-        content_tag('div', @right.reduce(&:+), :class => 'splitcontentleft')
-
-      content_tag('div', content, :class => 'splitcontent')
-    end
-
-    def cells(label, text, options={})
-      options[:class] = [options[:class] || "", 'attribute'].join(' ')
-      content_tag(
-        'div',
-        content_tag('div', label + ":", :class => 'label') +
-          content_tag('div', text, :class => 'value'),
-        options)
-    end
-  end
-
-  def issue_fields_rows
-    r = IssueFieldsRows.new
-    yield r
-    r.to_html
-  end
-
-  def render_half_width_custom_fields_rows(issue)
-    values = issue.visible_custom_field_values.reject {|value| value.custom_field.full_width_layout?}
-    return if values.empty?
-    half = (values.size / 2.0).ceil
-    issue_fields_rows do |rows|
-      values.each_with_index do |value, i|
-        m = (i < half ? :left : :right)
-        rows.send m, custom_field_name_tag(value.custom_field), custom_field_value_tag(value), :class => value.custom_field.css_classes
-      end
-    end
-  end
-
-  def render_full_width_custom_fields_rows(issue)
-    values = issue.visible_custom_field_values.select {|value| value.custom_field.full_width_layout?}
-    return if values.empty?
-    s = ''.html_safe
-    values.each_with_index do |value, i|
-      attr_value_tag = custom_field_value_tag(value)
-      next if attr_value_tag.blank?
-      content =
-        content_tag('hr') +
-        content_tag('p', content_tag('strong', custom_field_name_tag(value.custom_field) )) +
-        content_tag('div', attr_value_tag, class: 'value')
-      s << content_tag('div', content, class: "#{value.custom_field.css_classes} attribute")
-    end
-    s
-  end
-
-  # Returns the path for updating the issue form
-  # with project as the current project
-  def update_issue_form_path(project, issue)
-    options = {:format => 'js'}
-    if issue.new_record?
-      if project
-        new_project_issue_path(project, options)
-      else
-        new_issue_path(options)
-      end
-    else
-      edit_issue_path(issue, options)
-    end
-  end
-
-  # Returns the number of descendants for an array of issues
-  def issues_descendant_count(issues)
-    ids = issues.reject(&:leaf?).map {|issue| issue.descendants.ids}.flatten.uniq
-    ids -= issues.map(&:id)
-    ids.size
-  end
-
-  def issues_destroy_confirmation_message(issues)
-    issues = [issues] unless issues.is_a?(Array)
-    message = l(:text_issues_destroy_confirmation)
-
-    descendant_count = issues_descendant_count(issues)
-    if descendant_count > 0
-      message << "\n" + l(:text_issues_destroy_descendants_confirmation, :count => descendant_count)
-    end
-    message
-  end
-
-  # Returns an array of users that are proposed as watchers
-  # on the new issue form
-  def users_for_new_issue_watchers(issue)
-    users = issue.watcher_users.select{|u| u.status == User::STATUS_ACTIVE}
-    if issue.project.users.count <= 20
-      users = (users + issue.project.users.sort).uniq
-    end
-    users
-  end
-
-  def email_issue_attributes(issue, user, html)
-    items = []
-    %w(author status priority assigned_to category fixed_version start_date due_date).each do |attribute|
-      if issue.disabled_core_fields.grep(/^#{attribute}(_id)?$/).empty?
-        attr_value = (issue.send attribute).to_s
-        next if attr_value.blank?
-        if html
-          items << content_tag('strong', "#{l("field_#{attribute}")}: ") + attr_value
-        else
-          items << "#{l("field_#{attribute}")}: #{attr_value}"
-        end
-      end
-    end
-    issue.visible_custom_field_values(user).each do |value|
-      cf_value = show_value(value, false)
-      next if cf_value.blank?
-      if html
-        items << content_tag('strong', "#{value.custom_field.name}: ") + cf_value
-      else
-        items << "#{value.custom_field.name}: #{cf_value}"
-      end
-    end
-    items
-  end
-
-  def render_email_issue_attributes(issue, user, html=false)
-    items = email_issue_attributes(issue, user, html)
-    if html
-      content_tag('ul', items.map{|s| content_tag('li', s)}.join("\n").html_safe, :class => "details")
-    else
-      items.map{|s| "* #{s}"}.join("\n")
-    end
-  end
-
-  MultipleValuesDetail = Struct.new(:property, :prop_key, :custom_field, :old_value, :value)
-
-  # Returns the textual representation of a journal details
-  # as an array of strings
-  def details_to_strings(details, no_html=false, options={})
-    options[:only_path] = !(options[:only_path] == false)
-    strings = []
-    values_by_field = {}
-    details.each do |detail|
-      if detail.property == 'cf'
-        field = detail.custom_field
-        if field && field.multiple?
-          values_by_field[field] ||= {:added => [], :deleted => []}
-          if detail.old_value
-            values_by_field[field][:deleted] << detail.old_value
-          end
-          if detail.value
-            values_by_field[field][:added] << detail.value
-          end
-          next
-        end
-      end
-      strings << show_detail(detail, no_html, options)
-    end
-    if values_by_field.present?
-      values_by_field.each do |field, changes|
-        if changes[:added].any?
-          detail = MultipleValuesDetail.new('cf', field.id.to_s, field)
-          detail.value = changes[:added]
-          strings << show_detail(detail, no_html, options)
-        end
-        if changes[:deleted].any?
-          detail = MultipleValuesDetail.new('cf', field.id.to_s, field)
-          detail.old_value = changes[:deleted]
-          strings << show_detail(detail, no_html, options)
-        end
-      end
-    end
-    strings
-  end
-
-  # Returns the textual representation of a single journal detail
-  def show_detail(detail, no_html=false, options={})
-    multiple = false
-    show_diff = false
-    no_details = false
-
-    case detail.property
-    when 'attr'
-      field = detail.prop_key.to_s.gsub(/\_id$/, "")
-      label = l(("field_" + field).to_sym)
-      case detail.prop_key
-      when 'due_date', 'start_date'
-        value = format_date(detail.value.to_date) if detail.value
-        old_value = format_date(detail.old_value.to_date) if detail.old_value
-
-      when 'project_id', 'status_id', 'tracker_id', 'assigned_to_id',
-            'priority_id', 'category_id', 'fixed_version_id'
-        value = find_name_by_reflection(field, detail.value)
-        old_value = find_name_by_reflection(field, detail.old_value)
-
-      when 'estimated_hours'
-        value = l_hours_short(detail.value.to_f) unless detail.value.blank?
-        old_value = l_hours_short(detail.old_value.to_f) unless detail.old_value.blank?
-
-      when 'parent_id'
-        label = l(:field_parent_issue)
-        value = "##{detail.value}" unless detail.value.blank?
-        old_value = "##{detail.old_value}" unless detail.old_value.blank?
-
-      when 'is_private'
-        value = l(detail.value == "0" ? :general_text_No : :general_text_Yes) unless detail.value.blank?
-        old_value = l(detail.old_value == "0" ? :general_text_No : :general_text_Yes) unless detail.old_value.blank?
-
-      when 'description'
-        show_diff = true
-      end
-    when 'cf'
-      custom_field = detail.custom_field
-      if custom_field
-        label = custom_field.name
-        if custom_field.format.class.change_no_details
-          no_details = true
-        elsif custom_field.format.class.change_as_diff
-          show_diff = true
-        else
-          multiple = custom_field.multiple?
-          value = format_value(detail.value, custom_field) if detail.value
-          old_value = format_value(detail.old_value, custom_field) if detail.old_value
-        end
-      end
-    when 'attachment'
-      label = l(:label_attachment)
-    when 'relation'
-      if detail.value && !detail.old_value
-        rel_issue = Issue.visible.find_by_id(detail.value)
-        value =
-          if rel_issue.nil?
-            "#{l(:label_issue)} ##{detail.value}"
-          else
-            (no_html ? rel_issue : link_to_issue(rel_issue, :only_path => options[:only_path]))
-          end
-      elsif detail.old_value && !detail.value
-        rel_issue = Issue.visible.find_by_id(detail.old_value)
-        old_value =
-          if rel_issue.nil?
-            "#{l(:label_issue)} ##{detail.old_value}"
-          else
-            (no_html ? rel_issue : link_to_issue(rel_issue, :only_path => options[:only_path]))
-          end
-      end
-      relation_type = IssueRelation::TYPES[detail.prop_key]
-      label = l(relation_type[:name]) if relation_type
-    end
-    call_hook(:helper_issues_show_detail_after_setting,
-              {:detail => detail, :label => label, :value => value, :old_value => old_value })
-
-    label ||= detail.prop_key
-    value ||= detail.value
-    old_value ||= detail.old_value
-
-    unless no_html
-      label = content_tag('strong', label)
-      old_value = content_tag("i", h(old_value)) if detail.old_value
-      if detail.old_value && detail.value.blank? && detail.property != 'relation'
-        old_value = content_tag("del", old_value)
-      end
-      if detail.property == 'attachment' && value.present? &&
-          atta = detail.journal.journalized.attachments.detect {|a| a.id == detail.prop_key.to_i}
-        # Link to the attachment if it has not been removed
-        value = link_to_attachment(atta, only_path: options[:only_path])
-        if options[:only_path] != false
-          value += ' '
-          value += link_to_attachment atta, class: 'icon-only icon-download', title: l(:button_download), download: true
-        end
-      else
-        value = content_tag("i", h(value)) if value
-      end
-    end
-
-    if no_details
-      s = l(:text_journal_changed_no_detail, :label => label).html_safe
-    elsif show_diff
-      s = l(:text_journal_changed_no_detail, :label => label)
-      unless no_html
-        diff_link =
-          link_to(
-            'diff',
-            diff_journal_url(detail.journal_id, :detail_id => detail.id,
-                             :only_path => options[:only_path]),
-            :title => l(:label_view_diff))
-        s << " (#{diff_link})"
-      end
-      s.html_safe
-    elsif detail.value.present?
-      case detail.property
-      when 'attr', 'cf'
-        if detail.old_value.present?
-          l(:text_journal_changed, :label => label, :old => old_value, :new => value).html_safe
-        elsif multiple
-          l(:text_journal_added, :label => label, :value => value).html_safe
-        else
-          l(:text_journal_set_to, :label => label, :value => value).html_safe
-        end
-      when 'attachment', 'relation'
-        l(:text_journal_added, :label => label, :value => value).html_safe
-      end
-    else
-      l(:text_journal_deleted, :label => label, :old => old_value).html_safe
-    end
-  end
-
-  # Find the name of an associated record stored in the field attribute
-  def find_name_by_reflection(field, id)
-    return nil if id.blank?
-    @detail_value_name_by_reflection ||= Hash.new do |hash, key|
-      association = Issue.reflect_on_association(key.first.to_sym)
-      name = nil
-      if association
-        record = association.klass.find_by_id(key.last)
-        if record
-          name = record.name.force_encoding('UTF-8')
-        end
-      end
-      hash[key] = name
-    end
-    @detail_value_name_by_reflection[[field, id]]
-  end
-
-  # Renders issue children recursively
-  def render_api_issue_children(issue, api)
-    return if issue.leaf?
-    api.array :children do
-      issue.children.each do |child|
-        api.issue(:id => child.id) do
-          api.tracker(:id => child.tracker_id, :name => child.tracker.name) unless child.tracker.nil?
-          api.subject child.subject
-          render_api_issue_children(child, api)
-        end
-      end
-    end
-  end
-
-  # Issue history tabs
-  def issue_history_tabs
-    tabs = []
-    if @journals.present?
-      journals_without_notes = @journals.select{|value| value.notes.blank?}
-      journals_with_notes = @journals.reject{|value| value.notes.blank?}
-
-      tabs << {:name => 'history', :label => :label_history, :onclick => 'showIssueHistory("history", this.href)', :partial => 'issues/tabs/history', :locals => {:issue => @issue, :journals => @journals}}
-      tabs << {:name => 'notes', :label => :label_issue_history_notes, :onclick => 'showIssueHistory("notes", this.href)'} if journals_with_notes.any?
-      tabs << {:name => 'properties', :label => :label_issue_history_properties, :onclick => 'showIssueHistory("properties", this.href)'} if journals_without_notes.any?
-    end
-    tabs << {:name => 'time_entries', :label => :label_time_entry_plural, :remote => true, :onclick => "getRemoteTab('time_entries', '#{tab_issue_path(@issue, :name => 'time_entries')}', '#{issue_path(@issue, :tab => 'time_entries')}')"} if User.current.allowed_to?(:view_time_entries, @project) && @issue.spent_hours > 0
-    tabs << {:name => 'changesets', :label => :label_associated_revisions, :remote => true, :onclick => "getRemoteTab('changesets', '#{tab_issue_path(@issue, :name => 'changesets')}', '#{issue_path(@issue, :tab => 'changesets')}')"} if @has_changesets
-    tabs
-  end
-
-  def issue_history_default_tab
-    # tab params overrides user default tab preference
-    return params[:tab] if params[:tab].present?
-    user_default_tab = User.current.pref.history_default_tab
-
-    case user_default_tab
-    when 'last_tab_visited'
-      cookies['history_last_tab'].presence || 'notes'
-    when ''
-      'notes'
-    else
-      user_default_tab
-    end
-  end
-
-end

app/helpers/journals_helper.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module JournalsHelper
-
-  # Returns the attachments of a journal that are displayed as thumbnails
-  def journal_thumbnail_attachments(journal)
-    ids = journal.details.select {|d| d.property == 'attachment' && d.value.present?}.map(&:prop_key)
-    ids.any? ? Attachment.where(:id => ids).select(&:thumbnailable?) : []
-  end
-
-  # Returns the action links for an issue journal
-  def render_journal_actions(issue, journal, options={})
-    links = []
-    if journal.notes.present?
-      if options[:reply_links]
-        indice = journal.indice || @journal.issue.visible_journals_with_index.find{|j| j.id == @journal.id}.indice
-        links << link_to(l(:button_quote),
-                         quoted_issue_path(issue, :journal_id => journal, :journal_indice => indice),
-                         :remote => true,
-                         :method => 'post',
-                         :title => l(:button_quote),
-                         :class => 'icon-only icon-comment'
-                        )
-      end
-      if journal.editable_by?(User.current)
-        links << link_to(l(:button_edit),
-                         edit_journal_path(journal),
-                         :remote => true,
-                         :method => 'get',
-                         :title => l(:button_edit),
-                         :class => 'icon-only icon-edit'
-                        )
-        links << link_to(l(:button_delete),
-                         journal_path(journal, :journal => {:notes => ""}),
-                         :remote => true,
-                         :method => 'put', :data => {:confirm => l(:text_are_you_sure)},
-                         :title => l(:button_delete),
-                         :class => 'icon-only icon-del'
-                        )
-      end
-    end
-    safe_join(links, ' ')
-  end
-
-  def render_notes(issue, journal, options={})
-    content_tag('div', textilizable(journal, :notes), :id => "journal-#{journal.id}-notes", :class => "wiki")
-  end
-
-  def render_private_notes_indicator(journal)
-    content = journal.private_notes? ? l(:field_is_private) : ''
-    css_classes = journal.private_notes? ? 'badge badge-private private' : ''
-    content_tag('span', content.html_safe, :id => "journal-#{journal.id}-private_notes", :class => css_classes)
-  end
-end

app/helpers/mail_handler_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module MailHandlerHelper
-end

app/helpers/members_helper.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module MembersHelper
-  def render_principals_for_new_members(project, limit=100)
-    scope = Principal.active.visible.sorted.not_member_of(project).like(params[:q])
-    principal_count = scope.count
-    principal_pages = Redmine::Pagination::Paginator.new principal_count, limit, params['page']
-    principals = scope.offset(principal_pages.offset).limit(principal_pages.per_page).to_a
-    s = content_tag(
-          'div',
-          content_tag(
-            'div',
-            principals_check_box_tags('membership[user_ids][]', principals), :id => 'principals'),
-          :class => 'objects-selection'
-    )
-    links =
-      pagination_links_full(principal_pages,
-                            principal_count,
-                            :per_page_links => false) {|text, parameters, options|
-        link_to(
-          text,
-          autocomplete_project_memberships_path(
-            project,
-            parameters.merge(:q => params[:q], :format => 'js')
-          ),
-          :remote => true)
-      }
-    s + content_tag('span', links, :class => 'pagination')
-  end
-
-  # Returns inheritance information for an inherited member role
-  def render_role_inheritance(member, role)
-    content = member.role_inheritance(role).map do |h|
-      if h.is_a?(Project)
-        l(:label_inherited_from_parent_project)
-      elsif h.is_a?(Group)
-        l(:label_inherited_from_group, :name => h.name.to_s)
-      end
-    end.compact.uniq
-
-    if content.present?
-      content_tag('em', content.join(", "), :class => "info")
-    end
-  end
-end

app/helpers/messages_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module MessagesHelper
-end

app/helpers/my_helper.rb

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module MyHelper
-  # Renders the blocks
-  def render_blocks(blocks, user, options={})
-    s = ''.html_safe
-
-    if blocks.present?
-      blocks.each do |block|
-        s << render_block(block, user).to_s
-      end
-    end
-    s
-  end
-
-  # Renders a single block
-  def render_block(block, user)
-    content = render_block_content(block, user)
-    if content.present?
-      handle = content_tag('span', '', :class => 'icon-only icon-sort-handle sort-handle', :title => l(:button_move))
-      close = link_to(l(:button_delete),
-                      {:action => "remove_block", :block => block},
-                      :remote => true, :method => 'post',
-                      :class => "icon-only icon-close", :title => l(:button_delete))
-      content = content_tag('div', handle + close, :class => 'contextual') + content
-
-      content_tag('div', content, :class => "mypage-box", :id => "block-#{block}")
-    end
-  end
-
-  # Renders a single block content
-  def render_block_content(block, user)
-    unless block_definition = Redmine::MyPage.find_block(block)
-      Rails.logger.warn("Unknown block \"#{block}\" found in #{user.login} (id=#{user.id}) preferences")
-      return
-    end
-
-    settings = user.pref.my_page_settings(block)
-    if partial = block_definition[:partial]
-      begin
-        render(:partial => partial, :locals => {:user => user, :settings => settings, :block => block})
-      rescue ActionView::MissingTemplate
-        Rails.logger.warn("Partial \"#{partial}\" missing for block \"#{block}\" found in #{user.login} (id=#{user.id}) preferences")
-        return nil
-      end
-    else
-      send "render_#{block_definition[:name]}_block", block, settings
-    end
-  end
-
-  # Returns the select tag used to add a block to My page
-  def block_select_tag(user)
-    blocks_in_use = user.pref.my_page_layout.values.flatten
-    options = content_tag('option')
-    Redmine::MyPage.block_options(blocks_in_use).each do |label, block|
-      options << content_tag('option', label, :value => block, :disabled => block.blank?)
-    end
-    select_tag('block', options, :id => "block-select", :onchange => "$('#block-form').submit();")
-  end
-
-  def render_calendar_block(block, settings)
-    calendar = Redmine::Helpers::Calendar.new(User.current.today, current_language, :week)
-    calendar.events = Issue.visible.
-      where(:project => User.current.projects).
-      where("(start_date>=? and start_date<=?) or (due_date>=? and due_date<=?)", calendar.startdt, calendar.enddt, calendar.startdt, calendar.enddt).
-      includes(:project, :tracker, :priority, :assigned_to).
-      references(:project, :tracker, :priority, :assigned_to).
-      to_a
-
-    render :partial => 'my/blocks/calendar', :locals => {:calendar => calendar, :block => block}
-  end
-
-  def render_documents_block(block, settings)
-    documents = Document.visible.order("#{Document.table_name}.created_on DESC").limit(10).to_a
-
-    render :partial => 'my/blocks/documents', :locals => {:block => block, :documents => documents}
-  end
-
-  def render_issuesassignedtome_block(block, settings)
-    query = IssueQuery.new(:name => l(:label_assigned_to_me_issues), :user => User.current)
-    query.add_filter 'assigned_to_id', '=', ['me']
-    query.add_filter 'project.status', '=', ["#{Project::STATUS_ACTIVE}"]
-    query.column_names = settings[:columns].presence || ['project', 'tracker', 'status', 'subject']
-    query.sort_criteria = settings[:sort].presence || [['priority', 'desc'], ['updated_on', 'desc']]
-    issues = query.issues(:limit => 10)
-
-    render :partial => 'my/blocks/issues', :locals => {:query => query, :issues => issues, :block => block}
-  end
-
-  def render_issuesreportedbyme_block(block, settings)
-    query = IssueQuery.new(:name => l(:label_reported_issues), :user => User.current)
-    query.add_filter 'author_id', '=', ['me']
-    query.add_filter 'project.status', '=', ["#{Project::STATUS_ACTIVE}"]
-    query.column_names = settings[:columns].presence || ['project', 'tracker', 'status', 'subject']
-    query.sort_criteria = settings[:sort].presence || [['updated_on', 'desc']]
-    issues = query.issues(:limit => 10)
-
-    render :partial => 'my/blocks/issues', :locals => {:query => query, :issues => issues, :block => block}
-  end
-
-  def render_issuesupdatedbyme_block(block, settings)
-    query = IssueQuery.new(:name => l(:label_updated_issues), :user => User.current)
-    query.add_filter 'updated_by', '=', ['me']
-    query.add_filter 'project.status', '=', ["#{Project::STATUS_ACTIVE}"]
-    query.column_names = settings[:columns].presence || ['project', 'tracker', 'status', 'subject']
-    query.sort_criteria = settings[:sort].presence || [['updated_on', 'desc']]
-    issues = query.issues(:limit => 10)
-
-    render :partial => 'my/blocks/issues', :locals => {:query => query, :issues => issues, :block => block}
-  end
-
-  def render_issueswatched_block(block, settings)
-    query = IssueQuery.new(:name => l(:label_watched_issues), :user => User.current)
-    query.add_filter 'watcher_id', '=', ['me']
-    query.add_filter 'project.status', '=', ["#{Project::STATUS_ACTIVE}"]
-    query.column_names = settings[:columns].presence || ['project', 'tracker', 'status', 'subject']
-    query.sort_criteria = settings[:sort].presence || [['updated_on', 'desc']]
-    issues = query.issues(:limit => 10)
-
-    render :partial => 'my/blocks/issues', :locals => {:query => query, :issues => issues, :block => block}
-  end
-
-  def render_issuequery_block(block, settings)
-    query = IssueQuery.visible.find_by_id(settings[:query_id])
-
-    if query
-      query.column_names = settings[:columns] if settings[:columns].present?
-      query.sort_criteria = settings[:sort] if settings[:sort].present?
-      issues = query.issues(:limit => 10)
-      render :partial => 'my/blocks/issues', :locals => {:query => query, :issues => issues, :block => block, :settings => settings}
-    else
-      queries = IssueQuery.visible.sorted
-      render :partial => 'my/blocks/issue_query_selection', :locals => {:queries => queries, :block => block, :settings => settings}
-    end
-  end
-
-  def render_news_block(block, settings)
-    news = News.visible.
-      where(:project => User.current.projects).
-      limit(10).
-      includes(:project, :author).
-      references(:project, :author).
-      order("#{News.table_name}.created_on DESC").
-      to_a
-
-    render :partial => 'my/blocks/news', :locals => {:block => block, :news => news}
-  end
-
-  def render_timelog_block(block, settings)
-    days = settings[:days].to_i
-    days = 7 if days < 1 || days > 365
-
-    entries = TimeEntry.
-      where("#{TimeEntry.table_name}.user_id = ? AND #{TimeEntry.table_name}.spent_on BETWEEN ? AND ?", User.current.id, User.current.today - (days - 1), User.current.today).
-      joins(:activity, :project).
-      references(:issue => [:tracker, :status]).
-      includes(:issue => [:tracker, :status]).
-      order("#{TimeEntry.table_name}.spent_on DESC, #{Project.table_name}.name ASC, #{Tracker.table_name}.position ASC, #{Issue.table_name}.id ASC").
-      to_a
-    entries_by_day = entries.group_by(&:spent_on)
-
-    render :partial => 'my/blocks/timelog', :locals => {:block => block, :entries => entries, :entries_by_day => entries_by_day, :days => days}
-  end
-
-  def render_activity_block(block, settings)
-    events_by_day = Redmine::Activity::Fetcher.new(User.current, :author => User.current).events(nil, nil, :limit => 10).group_by {|event| User.current.time_to_date(event.event_datetime)}
-
-    render :partial => 'my/blocks/activity', :locals => {:events_by_day => events_by_day}
-  end
-end

app/helpers/news_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module NewsHelper
-end

app/helpers/principal_memberships_helper.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module PrincipalMembershipsHelper
-  def render_principal_memberships(principal)
-    render :partial => 'principal_memberships/index', :locals => {:principal => principal}
-  end
-
-  def call_table_header_hook(principal)
-    if principal.is_a?(Group)
-      call_hook :view_groups_memberships_table_header, :group => principal
-    else
-      call_hook :view_users_memberships_table_header, :user => principal
-    end
-  end
-
-  def call_table_row_hook(principal, membership)
-    if principal.is_a?(Group)
-      call_hook :view_groups_memberships_table_row, :group => principal, :membership => membership
-    else
-      call_hook :view_users_memberships_table_row, :user => principal, :membership => membership
-    end
-  end
-
-  def new_principal_membership_path(principal, *args)
-    if principal.is_a?(Group)
-      new_group_membership_path(principal, *args)
-    else
-      new_user_membership_path(principal, *args)
-    end
-  end
-
-  def edit_principal_membership_path(principal, *args)
-    if principal.is_a?(Group)
-      edit_group_membership_path(principal, *args)
-    else
-      edit_user_membership_path(principal, *args)
-    end
-  end
-
-  def principal_membership_path(principal, membership, *args)
-    if principal.is_a?(Group)
-      group_membership_path(principal, membership, *args)
-    else
-      user_membership_path(principal, membership, *args)
-    end
-  end
-end

app/helpers/projects_helper.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module ProjectsHelper
-  def project_settings_tabs
-    tabs =
-      [
-        {:name => 'info', :action => :edit_project,
-         :partial => 'projects/edit', :label => :label_project},
-        {:name => 'members', :action => :manage_members,
-         :partial => 'projects/settings/members', :label => :label_member_plural},
-        {:name => 'issues', :action => :edit_project, :module => :issue_tracking,
-         :partial => 'projects/settings/issues', :label => :label_issue_tracking},
-        {:name => 'versions', :action => :manage_versions,
-         :partial => 'projects/settings/versions', :label => :label_version_plural,
-         :url => {:tab => 'versions', :version_status => params[:version_status],
-                  :version_name => params[:version_name]}},
-        {:name => 'categories', :action => :manage_categories,
-         :partial => 'projects/settings/issue_categories',
-         :label => :label_issue_category_plural},
-        {:name => 'repositories', :action => :manage_repository,
-         :partial => 'projects/settings/repositories', :label => :label_repository_plural},
-        {:name => 'boards', :action => :manage_boards,
-         :partial => 'projects/settings/boards', :label => :label_board_plural},
-        {:name => 'activities', :action => :manage_project_activities,
-         :partial => 'projects/settings/activities', :label => :label_time_tracking}
-      ]
-    tabs.
-      select {|tab| User.current.allowed_to?(tab[:action], @project)}.
-      select {|tab| tab[:module].nil? || @project.module_enabled?(tab[:module])}
-  end
-
-  def parent_project_select_tag(project)
-    selected = project.parent
-    # retrieve the requested parent project
-    parent_id = (params[:project] && params[:project][:parent_id]) || params[:parent_id]
-    if parent_id
-      selected = (parent_id.blank? ? nil : Project.find(parent_id))
-    end
-
-    options = +''
-    options << "<option value=''>&nbsp;</option>" if project.allowed_parents.include?(nil)
-    options << project_tree_options_for_select(project.allowed_parents.compact, :selected => selected)
-    content_tag('select', options.html_safe, :name => 'project[parent_id]', :id => 'project_parent_id')
-  end
-
-  def render_project_action_links
-    links = (+"").html_safe
-    if User.current.allowed_to?(:add_project, nil, :global => true)
-      links << link_to(l(:label_project_new), new_project_path, :class => 'icon icon-add')
-    end
-    if User.current.admin?
-      links << link_to(l(:label_administration), admin_projects_path, :class => 'icon icon-settings')
-    end
-    links
-  end
-
-  # Renders the projects index
-  def render_project_hierarchy(projects)
-    render_project_nested_lists(projects) do |project|
-      s = link_to_project(project, {}, :class => "#{project.css_classes} #{User.current.member_of?(project) ? 'icon icon-user my-project' : nil}")
-      if project.description.present?
-        s << content_tag('div', textilizable(project.short_description, :project => project), :class => 'wiki description')
-      end
-      s
-    end
-  end
-
-  # Returns a set of options for a select field, grouped by project.
-  def version_options_for_select(versions, selected=nil)
-    grouped = Hash.new {|h,k| h[k] = []}
-    versions.each do |version|
-      grouped[version.project.name] << [version.name, version.id]
-    end
-
-    selected = selected.is_a?(Version) ? selected.id : selected
-    if grouped.keys.size > 1
-      grouped_options_for_select(grouped, selected)
-    else
-      options_for_select((grouped.values.first || []), selected)
-    end
-  end
-
-  def project_default_version_options(project)
-    versions = project.shared_versions.open.to_a
-    if project.default_version && !versions.include?(project.default_version)
-      versions << project.default_version
-    end
-    version_options_for_select(versions, project.default_version)
-  end
-
-  def project_default_assigned_to_options(project)
-    assignable_users = (project.assignable_users.to_a + [project.default_assigned_to]).uniq.compact
-    principals_options_for_select(assignable_users, project.default_assigned_to)
-  end
-
-  def format_version_sharing(sharing)
-    sharing = 'none' unless Version::VERSION_SHARINGS.include?(sharing)
-    l("label_version_sharing_#{sharing}")
-  end
-
-  def render_boards_tree(boards, parent=nil, level=0, &block)
-    selection = boards.select {|b| b.parent == parent}
-    return '' if selection.empty?
-
-    s = ''.html_safe
-    selection.each do |board|
-      node = capture(board, level, &block)
-      node << render_boards_tree(boards, board, level+1, &block)
-      s << content_tag('div', node)
-    end
-    content_tag('div', s, :class => 'sort-level')
-  end
-
-  def render_api_includes(project, api)
-    api.array :trackers do
-      project.trackers.each do |tracker|
-        api.tracker(:id => tracker.id, :name => tracker.name)
-      end
-    end if include_in_api_response?('trackers')
-
-    api.array :issue_categories do
-      project.issue_categories.each do |category|
-        api.issue_category(:id => category.id, :name => category.name)
-      end
-    end if include_in_api_response?('issue_categories')
-
-    api.array :time_entry_activities do
-      project.activities.each do |activity|
-        api.time_entry_activity(:id => activity.id, :name => activity.name)
-      end
-    end if include_in_api_response?('time_entry_activities')
-
-    api.array :enabled_modules do
-      project.enabled_modules.each do |enabled_module|
-        api.enabled_module(:id => enabled_module.id, :name => enabled_module.name)
-      end
-    end if include_in_api_response?('enabled_modules')
-  end
-
-  def bookmark_link(project, user = User.current)
-    return '' unless user && user.logged?
-    @jump_box ||= Redmine::ProjectJumpBox.new user
-    bookmarked = @jump_box.bookmark?(project)
-    css = +"icon bookmark "
-
-    if bookmarked
-      css << "icon-bookmark"
-      method = "delete"
-      text = l(:button_project_bookmark_delete)
-    else
-      css << "icon-bookmark-off"
-      method = "post"
-      text = l(:button_project_bookmark)
-    end
-
-    url = bookmark_project_path(project)
-    link_to text, url, remote: true, method: method, class: css
-  end
-
-  def grouped_project_list(projects, query, &block)
-    ancestors = []
-    grouped_query_results(projects, query) do |project, group_name, group_count, group_totals|
-      ancestors.pop while ancestors.any? && !project.is_descendant_of?(ancestors.last)
-      yield project, ancestors.size, group_name, group_count, group_totals
-      ancestors << project unless project.leaf?
-    end
-  end
-end

app/helpers/projects_queries_helper.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2017  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-module ProjectsQueriesHelper
-  include ApplicationHelper
-
-  def column_value(column, item, value)
-    if item.is_a?(Project)
-      case column.name
-      when :name
-        link_to_project(item) + (content_tag('span', '', :class => 'icon icon-user my-project', :title => l(:label_my_projects)) if User.current.member_of?(item))
-      when :short_description
-        item.description? ? content_tag('div', textilizable(item, :short_description), :class => "wiki") : ''
-      when :homepage
-        item.homepage? ? content_tag('div', textilizable(item, :homepage), :class => "wiki") : ''
-      when :status
-        get_project_status_label[column.value_object(item)]
-      when :parent_id
-        link_to_project(item.parent) unless item.parent.nil?
-      else
-        super
-      end
-    end
-  end
-
-  def csv_value(column, object, value)
-    if object.is_a?(Project)
-      case column.name
-      when :status
-        get_project_status_label[column.value_object(object)]
-      when :parent_id
-        object.parent.name unless object.parent.nil?
-      else
-        super
-      end
-    end
-  end
-
-  private
-
-  def get_project_status_label
-    {
-      Project::STATUS_ACTIVE => l(:project_status_active),
-      Project::STATUS_CLOSED => l(:project_status_closed)
-    }
-  end
-end

app/helpers/queries_helper.rb

@@ -1,443 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-require 'redmine/export/csv'
-
-module QueriesHelper
-  include ApplicationHelper
-
-  def filters_options_for_select(query)
-    ungrouped = []
-    grouped = {}
-    query.available_filters.map do |field, field_options|
-      if field_options[:type] == :relation
-        group = :label_relations
-      elsif field_options[:type] == :tree
-        group = query.is_a?(IssueQuery) ? :label_relations : nil
-      elsif /^cf_\d+\./.match?(field)
-        group = (field_options[:through] || field_options[:field]).try(:name)
-      elsif field =~ /^(.+)\./
-        # association filters
-        group = "field_#{$1}".to_sym
-      elsif %w(member_of_group assigned_to_role).include?(field)
-        group = :field_assigned_to
-      elsif field_options[:type] == :date_past || field_options[:type] == :date
-        group = :label_date
-      elsif %w(estimated_hours spent_time).include?(field)
-        group = :label_time_tracking
-      end
-      if group
-        (grouped[group] ||= []) << [field_options[:name], field]
-      else
-        ungrouped << [field_options[:name], field]
-      end
-    end
-    # Don't group dates if there's only one (eg. time entries filters)
-    if grouped[:label_date].try(:size) == 1
-      ungrouped << grouped.delete(:label_date).first
-    end
-    s = options_for_select([[]] + ungrouped)
-    if grouped.present?
-      localized_grouped = grouped.map {|k,v| [k.is_a?(Symbol) ? l(k) : k.to_s, v]}
-      s << grouped_options_for_select(localized_grouped)
-    end
-    s
-  end
-
-  def query_filters_hidden_tags(query)
-    tags = ''.html_safe
-    query.filters.each do |field, options|
-      tags << hidden_field_tag("f[]", field, :id => nil)
-      tags << hidden_field_tag("op[#{field}]", options[:operator], :id => nil)
-      options[:values].each do |value|
-        tags << hidden_field_tag("v[#{field}][]", value, :id => nil)
-      end
-    end
-    tags
-  end
-
-  def query_columns_hidden_tags(query)
-    tags = ''.html_safe
-    query.columns.each do |column|
-      tags << hidden_field_tag("c[]", column.name, :id => nil)
-    end
-    tags
-  end
-
-  def query_hidden_tags(query)
-    query_filters_hidden_tags(query) + query_columns_hidden_tags(query)
-  end
-
-  def group_by_column_select_tag(query)
-    options = [[]] + query.groupable_columns.collect {|c| [c.caption, c.name.to_s]}
-    select_tag('group_by', options_for_select(options, @query.group_by))
-  end
-
-  def available_block_columns_tags(query)
-    tags = ''.html_safe
-    query.available_block_columns.each do |column|
-      tags << content_tag('label', check_box_tag('c[]', column.name.to_s, query.has_column?(column), :id => nil) + " #{column.caption}", :class => 'inline')
-    end
-    tags
-  end
-
-  def available_totalable_columns_tags(query, options={})
-    tag_name = (options[:name] || 't') + '[]'
-    tags = ''.html_safe
-    query.available_totalable_columns.each do |column|
-      tags << content_tag('label', check_box_tag(tag_name, column.name.to_s, query.totalable_columns.include?(column), :id => nil) + " #{column.caption}", :class => 'inline')
-    end
-    tags << hidden_field_tag(tag_name, '')
-    tags
-  end
-
-  def query_available_inline_columns_options(query)
-    (query.available_inline_columns - query.columns).reject(&:frozen?).collect {|column| [column.caption, column.name]}
-  end
-
-  def query_selected_inline_columns_options(query)
-    (query.inline_columns & query.available_inline_columns).reject(&:frozen?).collect {|column| [column.caption, column.name]}
-  end
-
-  def render_query_columns_selection(query, options={})
-    tag_name = (options[:name] || 'c') + '[]'
-    render :partial => 'queries/columns', :locals => {:query => query, :tag_name => tag_name}
-  end
-
-  def available_display_types_tags(query)
-    tags = ''.html_safe
-    query.available_display_types.each do |t|
-      tags << radio_button_tag('display_type', t, @query.display_type == t, :id => "display_type_#{t}") +
-        content_tag('label', l(:"label_display_type_#{t}"), :for => "display_type_#{t}", :class => "inline")
-    end
-    tags
-  end
-
-  def grouped_query_results(items, query, &block)
-    result_count_by_group = query.result_count_by_group
-    previous_group, first = false, true
-    totals_by_group = query.totalable_columns.inject({}) do |h, column|
-      h[column] = query.total_by_group_for(column)
-      h
-    end
-    items.each do |item|
-      group_name = group_count = nil
-      if query.grouped?
-        group = query.group_by_column.group_value(item)
-        if first || group != previous_group
-          if group.blank? && group != false
-            group_name = "(#{l(:label_blank_value)})"
-          else
-            group_name = format_object(group)
-          end
-          group_name ||= ""
-          group_count = result_count_by_group ? result_count_by_group[group] : nil
-          group_totals = totals_by_group.map {|column, t| total_tag(column, t[group] || 0)}.join(" ").html_safe
-        end
-      end
-      yield item, group_name, group_count, group_totals
-      previous_group, first = group, false
-    end
-  end
-
-  def render_query_totals(query)
-    return unless query.totalable_columns.present?
-    totals = query.totalable_columns.map do |column|
-      total_tag(column, query.total_for(column))
-    end
-    content_tag('p', totals.join(" ").html_safe, :class => "query-totals")
-  end
-
-  def total_tag(column, value)
-    label = content_tag('span', "#{column.caption}:")
-    value =
-      if [:hours, :spent_hours, :total_spent_hours, :estimated_hours].include? column.name
-        format_hours(value)
-      else
-        format_object(value)
-      end
-    value = content_tag('span', value, :class => 'value')
-    content_tag('span', label + " " + value, :class => "total-for-#{column.name.to_s.dasherize}")
-  end
-
-  def column_header(query, column, options={})
-    if column.sortable?
-      css, order = nil, column.default_order
-      if column.name.to_s == query.sort_criteria.first_key
-        if query.sort_criteria.first_asc?
-          css = 'sort asc icon icon-sorted-desc'
-          order = 'desc'
-        else
-          css = 'sort desc icon icon-sorted-asc'
-          order = 'asc'
-        end
-      end
-      param_key = options[:sort_param] || :sort
-      sort_param = {param_key => query.sort_criteria.add(column.name, order).to_param}
-      sort_param = {$1 => {$2 => sort_param.values.first}} while sort_param.keys.first.to_s =~ /^(.+)\[(.+)\]$/
-      link_options = {
-          :title => l(:label_sort_by, "\"#{column.caption}\""),
-          :class => css
-        }
-      if options[:sort_link_options]
-        link_options.merge! options[:sort_link_options]
-      end
-      content = link_to(
-          column.caption,
-          {:params => request.query_parameters.deep_merge(sort_param)},
-          link_options
-        )
-    else
-      content = column.caption
-    end
-    content_tag('th', content, :class => column.css_classes)
-  end
-
-  def column_content(column, item)
-    value = column.value_object(item)
-    if value.is_a?(Array)
-      values = value.collect {|v| column_value(column, item, v)}.compact
-      safe_join(values, ', ')
-    else
-      column_value(column, item, value)
-    end
-  end
-
-  def column_value(column, item, value)
-    case column.name
-    when :id
-      link_to value, issue_path(item)
-    when :subject
-      link_to value, issue_path(item)
-    when :parent
-      value ? (value.visible? ? link_to_issue(value, :subject => false) : "##{value.id}") : ''
-    when :description
-      item.description? ? content_tag('div', textilizable(item, :description), :class => "wiki") : ''
-    when :last_notes
-      item.last_notes.present? ? content_tag('div', textilizable(item, :last_notes), :class => "wiki") : ''
-    when :done_ratio
-      progress_bar(value)
-    when :relations
-      content_tag(
-        'span',
-        value.to_s(item) {|other| link_to_issue(other, :subject => false, :tracker => false)}.html_safe,
-        :class => value.css_classes_for(item))
-    when :hours, :estimated_hours
-      format_hours(value)
-    when :spent_hours
-      link_to_if(value > 0, format_hours(value), project_time_entries_path(item.project, :issue_id => "#{item.id}"))
-    when :total_spent_hours
-      link_to_if(value > 0, format_hours(value), project_time_entries_path(item.project, :issue_id => "~#{item.id}"))
-    when :attachments
-      value.to_a.map {|a| format_object(a)}.join(" ").html_safe
-    else
-      format_object(value)
-    end
-  end
-
-  def csv_content(column, item)
-    value = column.value_object(item)
-    if value.is_a?(Array)
-      value.collect {|v| csv_value(column, item, v)}.compact.join(', ')
-    else
-      csv_value(column, item, value)
-    end
-  end
-
-  def csv_value(column, object, value)
-    case column.name
-    when :attachments
-      value.to_a.map {|a| a.filename}.join("\n")
-    else
-      format_object(value, false) do |value|
-        case value.class.name
-        when 'Float'
-          sprintf("%.2f", value).gsub('.', l(:general_csv_decimal_separator))
-        when 'IssueRelation'
-          value.to_s(object)
-        when 'Issue'
-          if object.is_a?(TimeEntry)
-            value.visible? ? "#{value.tracker} ##{value.id}: #{value.subject}" : "##{value.id}"
-          else
-            value.id
-          end
-        else
-          value
-        end
-      end
-    end
-  end
-
-  def query_to_csv(items, query, options={})
-    columns = query.columns
-
-    Redmine::Export::CSV.generate(:encoding => params[:encoding]) do |csv|
-      # csv header fields
-      csv << columns.map {|c| c.caption.to_s}
-      # csv lines
-      items.each do |item|
-        csv << columns.map {|c| csv_content(c, item)}
-      end
-    end
-  end
-
-  # Retrieve query from session or build a new query
-  def retrieve_query(klass=IssueQuery, use_session=true, options={})
-    session_key = klass.name.underscore.to_sym
-
-    if params[:query_id].present?
-      scope = klass.where(:project_id => nil)
-      scope = scope.or(klass.where(:project_id => @project)) if @project
-      @query = scope.find(params[:query_id])
-      raise ::Unauthorized unless @query.visible?
-      @query.project = @project
-      session[session_key] = {:id => @query.id, :project_id => @query.project_id} if use_session
-    elsif api_request? || params[:set_filter] || !use_session || session[session_key].nil? || session[session_key][:project_id] != (@project ? @project.id : nil)
-      # Give it a name, required to be valid
-      @query = klass.new(:name => "_", :project => @project)
-      @query.build_from_params(params, options[:defaults])
-      session[session_key] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names, :totalable_names => @query.totalable_names, :sort => @query.sort_criteria.to_a} if use_session
-    else
-      # retrieve from session
-      @query = nil
-      @query = klass.find_by_id(session[session_key][:id]) if session[session_key][:id]
-      @query ||= klass.new(:name => "_", :filters => session[session_key][:filters], :group_by => session[session_key][:group_by], :column_names => session[session_key][:column_names], :totalable_names => session[session_key][:totalable_names], :sort_criteria => session[session_key][:sort])
-      @query.project = @project
-    end
-    if params[:sort].present?
-      @query.sort_criteria = params[:sort]
-      if use_session
-        session[session_key] ||= {}
-        session[session_key][:sort] = @query.sort_criteria.to_a
-      end
-    end
-    @query
-  end
-
-  def retrieve_query_from_session(klass=IssueQuery)
-    session_key = klass.name.underscore.to_sym
-    session_data = session[session_key]
-
-    if session_data
-      if session_data[:id]
-        @query = IssueQuery.find_by_id(session_data[:id])
-        return unless @query
-      else
-        @query = IssueQuery.new(:name => "_", :filters => session_data[:filters], :group_by => session_data[:group_by], :column_names => session_data[:column_names], :totalable_names => session_data[:totalable_names], :sort_criteria => session[session_key][:sort])
-      end
-      if session_data.has_key?(:project_id)
-        @query.project_id = session_data[:project_id]
-      else
-        @query.project = @project
-      end
-      @query
-    end
-  end
-
-  # Returns the query definition as hidden field tags
-  def query_as_hidden_field_tags(query)
-    tags = hidden_field_tag("set_filter", "1", :id => nil)
-
-    if query.filters.present?
-      query.filters.each do |field, filter|
-        tags << hidden_field_tag("f[]", field, :id => nil)
-        tags << hidden_field_tag("op[#{field}]", filter[:operator], :id => nil)
-        filter[:values].each do |value|
-          tags << hidden_field_tag("v[#{field}][]", value, :id => nil)
-        end
-      end
-    else
-      tags << hidden_field_tag("f[]", "", :id => nil)
-    end
-    query.columns.each do |column|
-      tags << hidden_field_tag("c[]", column.name, :id => nil)
-    end
-    if query.totalable_names.present?
-      query.totalable_names.each do |name|
-        tags << hidden_field_tag("t[]", name, :id => nil)
-      end
-    end
-    if query.group_by.present?
-      tags << hidden_field_tag("group_by", query.group_by, :id => nil)
-    end
-    if query.sort_criteria.present?
-      tags << hidden_field_tag("sort", query.sort_criteria.to_param, :id => nil)
-    end
-
-    tags
-  end
-
-  def query_hidden_sort_tag(query)
-    hidden_field_tag("sort", query.sort_criteria.to_param, :id => nil)
-  end
-
-  # Returns the queries that are rendered in the sidebar
-  def sidebar_queries(klass, project)
-    klass.visible.global_or_on_project(@project).sorted.to_a
-  end
-
-  # Renders a group of queries
-  def query_links(title, queries)
-    return '' if queries.empty?
-    # links to #index on issues/show
-    url_params =
-      if controller_name == 'issues'
-        {:controller => 'issues', :action => 'index', :project_id => @project}
-      else
-        {}
-      end
-    content_tag('h3', title) + "\n" +
-      content_tag(
-        'ul',
-        queries.collect {|query|
-          css = +'query'
-          clear_link = +''
-          if query == @query
-            css << ' selected'
-            clear_link += link_to_clear_query
-          end
-          content_tag('li',
-                      link_to(query.name,
-                              url_params.merge(:query_id => query),
-                              :class => css) +
-                        clear_link.html_safe)
-        }.join("\n").html_safe,
-        :class => 'queries'
-      ) + "\n"
-  end
-
-  def link_to_clear_query
-    link_to(
-      l(:button_clear),
-      {:set_filter => 1, :sort => '', :project_id => @project},
-      :class => 'icon-only icon-clear-query',
-      :title => l(:button_clear)
-    )
-  end
-
-  # Renders the list of queries for the sidebar
-  def render_sidebar_queries(klass, project)
-    queries = sidebar_queries(klass, project)
-
-    out = ''.html_safe
-    out << query_links(l(:label_my_queries), queries.select(&:is_private?))
-    out << query_links(l(:label_query_plural), queries.reject(&:is_private?))
-    out
-  end
-end

app/helpers/reports_helper.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module ReportsHelper
-
-  def aggregate(data, criteria)
-    a = 0
-    data.each { |row|
-      match = 1
-      criteria.each { |k, v|
-        match = 0 unless (row[k].to_s == v.to_s) || (k == 'closed' &&  (v == 0 ? ['f', false] : ['t', true]).include?(row[k]))
-      } unless criteria.nil?
-      a = a + row["total"].to_i if match == 1
-    } unless data.nil?
-    a
-  end
-
-  def aggregate_link(data, criteria, *args)
-    a = aggregate data, criteria
-    a > 0 ? link_to(h(a), *args) : '-'
-  end
-
-  def aggregate_path(project, field, row, options={})
-    parameters = {:set_filter => 1, :subproject_id => '!*', field => row.id}.merge(options)
-    project_issues_path(row.is_a?(Project) ? row : project, parameters)
-  end
-end

app/helpers/repositories_helper.rb

@@ -1,310 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module RepositoriesHelper
-  def format_revision(revision)
-    if revision.respond_to? :format_identifier
-      revision.format_identifier
-    else
-      revision.to_s
-    end
-  end
-
-  def truncate_at_line_break(text, length = 255)
-    if text
-      text.gsub(%r{^(.{#{length}}[^\n]*)\n.+$}m, '\\1...')
-    end
-  end
-
-  def render_pagination
-    pagination_links_each @paginator do |text, parameters, options|
-      if entry = @entries[parameters[:page] - 1]
-        ent_path = Redmine::CodesetUtil.replace_invalid_utf8(entry.path)
-        link_to text, {action: 'entry', id: @project, repository_id: @repository.identifier_param, path: to_path_param(ent_path), rev: @rev}
-      end
-    end if @paginator
-  end
-
-  def render_properties(properties)
-    unless properties.nil? || properties.empty?
-      content = +''
-      properties.keys.sort.each do |property|
-        content << content_tag('li', "<b>#{h property}</b>: <span>#{h properties[property]}</span>".html_safe)
-      end
-      content_tag('ul', content.html_safe, :class => 'properties')
-    end
-  end
-
-  def render_changeset_changes
-    changes = @changeset.filechanges.limit(1000).reorder('path').collect do |change|
-      case change.action
-      when 'A'
-        # Detects moved/copied files
-        if !change.from_path.blank?
-          change.action =
-            @changeset.filechanges.detect {|c| c.action == 'D' && c.path == change.from_path} ? 'R' : 'C'
-        end
-        change
-      when 'D'
-        @changeset.filechanges.detect {|c| c.from_path == change.path} ? nil : change
-      else
-        change
-      end
-    end.compact
-
-    tree = { }
-    changes.each do |change|
-      p = tree
-      dirs = change.path.to_s.split('/').select {|d| !d.blank?}
-      path = ''
-      dirs.each do |dir|
-        path += '/' + dir
-        p[:s] ||= {}
-        p = p[:s]
-        p[path] ||= {}
-        p = p[path]
-      end
-      p[:c] = change
-    end
-    render_changes_tree(tree[:s])
-  end
-
-  def render_changes_tree(tree)
-    return '' if tree.nil?
-    output = +''
-    output << '<ul>'
-    tree.keys.sort.each do |file|
-      style = +'change'
-      text = File.basename(h(file))
-      if s = tree[file][:s]
-        style << ' folder'
-        path_param = to_path_param(@repository.relative_path(file))
-        text = link_to(h(text), :controller => 'repositories',
-                             :action => 'show',
-                             :id => @project,
-                             :repository_id => @repository.identifier_param,
-                             :path => path_param,
-                             :rev => @changeset.identifier)
-        output << "<li class='#{style}'>#{text}"
-        output << render_changes_tree(s)
-        output << "</li>"
-      elsif c = tree[file][:c]
-        style << " change-#{c.action}"
-        path_param = to_path_param(@repository.relative_path(c.path))
-        text = link_to(h(text), :controller => 'repositories',
-                             :action => 'entry',
-                             :id => @project,
-                             :repository_id => @repository.identifier_param,
-                             :path => path_param,
-                             :rev => @changeset.identifier) unless c.action == 'D'
-        text << " - #{h(c.revision)}" unless c.revision.blank?
-        text << ' ('.html_safe + link_to(l(:label_diff), :controller => 'repositories',
-                                       :action => 'diff',
-                                       :id => @project,
-                                       :repository_id => @repository.identifier_param,
-                                       :path => path_param,
-                                       :rev => @changeset.identifier) + ') '.html_safe if c.action == 'M'
-        text << ' '.html_safe + content_tag('span', h(c.from_path), :class => 'copied-from') unless c.from_path.blank?
-        output << "<li class='#{style}'>#{text}</li>"
-      end
-    end
-    output << '</ul>'
-    output.html_safe
-  end
-
-  def repository_field_tags(form, repository)
-    method = repository.class.name.demodulize.underscore + "_field_tags"
-    if repository.is_a?(Repository) &&
-        respond_to?(method) && method != 'repository_field_tags'
-      send(method, form, repository)
-    end
-  end
-
-  def scm_select_tag(repository)
-    scm_options = [["--- #{l(:actionview_instancetag_blank_option)} ---", '']]
-    Redmine::Scm::Base.all.each do |scm|
-      if Setting.enabled_scm.include?(scm) ||
-          (repository && repository.class.name.demodulize == scm)
-        scm_options << ["Repository::#{scm}".constantize.scm_name, scm]
-      end
-    end
-    select_tag('repository_scm',
-               options_for_select(scm_options, repository.class.name.demodulize),
-               :disabled => (repository && !repository.new_record?),
-               :data => {:remote => true, :method => 'get', :url => new_project_repository_path(repository.project)})
-  end
-
-  def with_leading_slash(path)
-    path.to_s.starts_with?('/') ? path : "/#{path}"
-  end
-
-  def subversion_field_tags(form, repository)
-      content_tag('p', form.text_field(:url, :size => 60, :required => true,
-                       :disabled => !repository.safe_attribute?('url')) +
-                       scm_path_info_tag(repository)) +
-      content_tag('p', form.text_field(:login, :size => 30)) +
-      content_tag('p', form.password_field(
-                            :password, :size => 30, :name => 'ignore',
-                            :value => ((repository.new_record? || repository.password.blank?) ? '' : ('x'*15)),
-                            :onfocus => "this.value=''; this.name='repository[password]';",
-                            :onchange => "this.name='repository[password]';"))
-  end
-
-  def mercurial_field_tags(form, repository)
-    content_tag('p', form.text_field(
-                       :url, :label => l(:field_path_to_repository),
-                       :size => 60, :required => true,
-                       :disabled => !repository.safe_attribute?('url')
-                         ) +
-                     scm_path_info_tag(repository)) +
-    scm_path_encoding_tag(form, repository)
-  end
-
-  def git_field_tags(form, repository)
-    content_tag('p', form.text_field(
-                       :url, :label => l(:field_path_to_repository),
-                       :size => 60, :required => true,
-                       :disabled => !repository.safe_attribute?('url')
-                         ) +
-                      scm_path_info_tag(repository)) +
-    scm_path_encoding_tag(form, repository) +
-    content_tag('p', form.check_box(
-                        :report_last_commit,
-                        :label => l(:label_git_report_last_commit)
-                         ))
-  end
-
-  def cvs_field_tags(form, repository)
-    content_tag('p', form.text_field(
-                     :root_url,
-                     :label => l(:field_cvsroot),
-                     :size => 60, :required => true,
-                     :disabled => !repository.safe_attribute?('root_url')) +
-                     scm_path_info_tag(repository)) +
-    content_tag('p', form.text_field(
-                     :url,
-                     :label => l(:field_cvs_module),
-                     :size => 30, :required => true,
-                     :disabled => !repository.safe_attribute?('url'))) +
-    scm_log_encoding_tag(form, repository) +
-    scm_path_encoding_tag(form, repository)
-  end
-
-  def bazaar_field_tags(form, repository)
-    content_tag('p', form.text_field(
-                     :url, :label => l(:field_path_to_repository),
-                     :size => 60, :required => true,
-                     :disabled => !repository.safe_attribute?('url')) +
-                     scm_path_info_tag(repository)) +
-    scm_log_encoding_tag(form, repository)
-  end
-
-  def filesystem_field_tags(form, repository)
-    content_tag('p', form.text_field(
-                     :url, :label => l(:field_root_directory),
-                     :size => 60, :required => true,
-                     :disabled => !repository.safe_attribute?('url')) +
-                     scm_path_info_tag(repository)) +
-    scm_path_encoding_tag(form, repository)
-  end
-
-  def scm_path_info_tag(repository)
-    text = scm_path_info(repository)
-    if text.present?
-      content_tag('em', text, :class => 'info')
-    else
-      ''
-    end
-  end
-
-  def scm_path_info(repository)
-    scm_name = repository.scm_name.to_s.downcase
-
-    info_from_config = Redmine::Configuration["scm_#{scm_name}_path_info"].presence
-    return info_from_config.html_safe if info_from_config
-
-    l("text_#{scm_name}_repository_note", :default => '')
-  end
-
-  def scm_log_encoding_tag(form, repository)
-    select = form.select(
-      :log_encoding,
-      [nil] + Setting::ENCODINGS,
-      :label => l(:field_commit_logs_encoding),
-      :required => true
-    )
-    content_tag('p', select)
-  end
-
-  def scm_path_encoding_tag(form, repository)
-    select = form.select(
-      :path_encoding,
-      [nil] + Setting::ENCODINGS,
-      :label => l(:field_scm_path_encoding)
-    )
-    content_tag('p', select + content_tag('em', l(:text_scm_path_encoding_note), :class => 'info'))
-  end
-
-  def index_commits(commits, heads)
-    return nil if commits.nil? or commits.first.parents.nil?
-    refs_map = {}
-    heads.each do |head|
-      refs_map[head.scmid] ||= []
-      refs_map[head.scmid] << head
-    end
-    commits_by_scmid = {}
-    commits.reverse.each_with_index do |commit, commit_index|
-      commits_by_scmid[commit.scmid] = {
-        :parent_scmids => commit.parents.collect { |parent| parent.scmid },
-        :rdmid => commit_index,
-        :refs  => refs_map.include?(commit.scmid) ? refs_map[commit.scmid].join(" ") : nil,
-        :scmid => commit.scmid,
-        :href  => block_given? ? yield(commit.scmid) : commit.scmid
-      }
-    end
-    heads.sort_by!(&:to_s)
-    space = nil
-    heads.each do |head|
-      if commits_by_scmid.include? head.scmid
-        space = index_head((space || -1) + 1, head, commits_by_scmid)
-      end
-    end
-    # when no head matched anything use first commit
-    space ||= index_head(0, commits.first, commits_by_scmid)
-    return commits_by_scmid, space
-  end
-
-  def index_head(space, commit, commits_by_scmid)
-    stack = [[space, commits_by_scmid[commit.scmid]]]
-    max_space = space
-    until stack.empty?
-      space, commit = stack.pop
-      commit[:space] = space if commit[:space].nil?
-      space -= 1
-      commit[:parent_scmids].each_with_index do |parent_scmid, parent_index|
-        parent_commit = commits_by_scmid[parent_scmid]
-        if parent_commit and parent_commit[:space].nil?
-          stack.unshift [space += 1, parent_commit]
-        end
-      end
-      max_space = space if max_space < space
-    end
-    max_space
-  end
-end

app/helpers/roles_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module RolesHelper
-end

app/helpers/routes_helper.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module RoutesHelper
-
-  # Returns the path to project issues or to the cross-project
-  # issue list if project is nil
-  def _project_issues_path(project, *args)
-    if project
-      project_issues_path(project, *args)
-    else
-      issues_path(*args)
-    end
-  end
-
-  def _project_news_path(project, *args)
-    if project
-      project_news_index_path(project, *args)
-    else
-      news_index_path(*args)
-    end
-  end
-
-  def _new_project_issue_path(project, *args)
-    if project
-      new_project_issue_path(project, *args)
-    else
-      new_issue_path(*args)
-    end
-  end
-
-  def _project_calendar_path(project, *args)
-    project ? project_calendar_path(project, *args) : issues_calendar_path(*args)
-  end
-
-  def _project_gantt_path(project, *args)
-    project ? project_gantt_path(project, *args) : issues_gantt_path(*args)
-  end
-
-  def _time_entries_path(project, issue, *args)
-    if project
-      project_time_entries_path(project, *args)
-    else
-      time_entries_path(*args)
-    end
-  end
-
-  def _report_time_entries_path(project, issue, *args)
-    if project
-      report_project_time_entries_path(project, *args)
-    else
-      report_time_entries_path(*args)
-    end
-  end
-
-  def _new_time_entry_path(project, issue, *args)
-    if issue
-      new_issue_time_entry_path(issue, *args)
-    elsif project
-      new_project_time_entry_path(project, *args)
-    else
-      new_time_entry_path(*args)
-    end
-  end
-
-  def board_path(board, *args)
-    project_board_path(board.project, board, *args)
-  end
-end

app/helpers/settings_helper.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module SettingsHelper
-  def administration_settings_tabs
-    tabs = [{:name => 'general', :partial => 'settings/general', :label => :label_general},
-            {:name => 'display', :partial => 'settings/display', :label => :label_display},
-            {:name => 'authentication', :partial => 'settings/authentication', :label => :label_authentication},
-            {:name => 'api', :partial => 'settings/api', :label => :label_api},
-            {:name => 'projects', :partial => 'settings/projects', :label => :label_project_plural},
-            {:name => 'users', :partial => 'settings/users', :label => :label_user_plural},
-            {:name => 'issues', :partial => 'settings/issues', :label => :label_issue_tracking},
-            {:name => 'timelog', :partial => 'settings/timelog', :label => :label_time_tracking},
-            {:name => 'attachments', :partial => 'settings/attachments', :label => :label_attachment_plural},
-            {:name => 'notifications', :partial => 'settings/notifications', :label => :field_mail_notification},
-            {:name => 'mail_handler', :partial => 'settings/mail_handler', :label => :label_incoming_emails},
-            {:name => 'repositories', :partial => 'settings/repositories', :label => :label_repository_plural}
-            ]
-  end
-
-  def render_settings_error(errors)
-    return if errors.blank?
-    s = ''.html_safe
-    errors.each do |name, message|
-      s << content_tag('li', content_tag('b', l("setting_#{name}")) + " " + message)
-    end
-    content_tag('div', content_tag('ul', s), :id => 'errorExplanation')
-  end
-
-  def setting_value(setting)
-    value = nil
-    if params[:settings]
-      value = params[:settings][setting]
-    end
-    value || Setting.send(setting)
-  end
-
-  def setting_select(setting, choices, options={})
-    if blank_text = options.delete(:blank)
-      choices = [[blank_text.is_a?(Symbol) ? l(blank_text) : blank_text, '']] + choices
-    end
-    setting_label(setting, options).html_safe +
-      select_tag("settings[#{setting}]",
-                 options_for_select(choices, setting_value(setting).to_s),
-                 options).html_safe
-  end
-
-  def setting_multiselect(setting, choices, options={})
-    setting_values = setting_value(setting)
-    setting_values = [] unless setting_values.is_a?(Array)
-
-    content_tag("label", l(options[:label] || "setting_#{setting}")) +
-      hidden_field_tag("settings[#{setting}][]", '').html_safe +
-      choices.collect do |choice|
-        text, value = (choice.is_a?(Array) ? choice : [choice, choice])
-        content_tag(
-          'label',
-          check_box_tag(
-             "settings[#{setting}][]",
-             value,
-             setting_values.include?(value),
-             :id => nil
-           ) + text.to_s,
-          :class => (options[:inline] ? 'inline' : 'block')
-         )
-      end.join.html_safe
-  end
-
-  def setting_text_field(setting, options={})
-    setting_label(setting, options).html_safe +
-      text_field_tag("settings[#{setting}]", setting_value(setting), options).html_safe
-  end
-
-  def setting_text_area(setting, options={})
-    setting_label(setting, options).html_safe +
-      text_area_tag("settings[#{setting}]", setting_value(setting), options).html_safe
-  end
-
-  def setting_check_box(setting, options={})
-    setting_label(setting, options).html_safe +
-      hidden_field_tag("settings[#{setting}]", 0, :id => nil).html_safe +
-        check_box_tag("settings[#{setting}]", 1, setting_value(setting).to_s != '0', options).html_safe
-  end
-
-  def setting_label(setting, options={})
-    label = options.delete(:label)
-    if label == false
-      ''
-    else
-      text = label.is_a?(String) ? label : l(label || "setting_#{setting}")
-      label_tag("settings_#{setting}", text, options[:label_options])
-    end
-  end
-
-  # Renders a notification field for a Redmine::Notifiable option
-  def notification_field(notifiable)
-    tag_data = notifiable.parent.present? ?
-      {:parent_notifiable => notifiable.parent} :
-      {:disables => "input[data-parent-notifiable=#{notifiable.name}]"}
-    tag = check_box_tag('settings[notified_events][]',
-                        notifiable.name,
-                        setting_value('notified_events').include?(notifiable.name),
-                        :id => nil,
-                        :data => tag_data)
-    text = l_or_humanize(notifiable.name, :prefix => 'label_')
-    options = {}
-    if notifiable.parent.present?
-      options[:class] = "parent"
-    end
-    content_tag(:label, tag + text, options)
-  end
-
-  def session_lifetime_options
-    options = [[l(:label_disabled), 0]]
-    options += [4, 8, 12].map {|hours|
-      [l('datetime.distance_in_words.x_hours', :count => hours), (hours * 60).to_s]
-    }
-    options += [1, 7, 30, 60, 365].map {|days|
-      [l('datetime.distance_in_words.x_days', :count => days), (days * 24 * 60).to_s]
-    }
-    options
-  end
-
-  def session_timeout_options
-    options = [[l(:label_disabled), 0]]
-    options += [1, 2, 4, 8, 12, 24, 48].map {|hours|
-      [l('datetime.distance_in_words.x_hours', :count => hours), (hours * 60).to_s]
-    }
-    options
-  end
-
-  def link_copied_issue_options
-    options = [
-      [:general_text_Yes, 'yes'],
-      [:general_text_No, 'no'],
-      [:label_ask, 'ask']
-    ]
-
-    options.map {|label, value| [l(label), value.to_s]}
-  end
-
-  def cross_project_subtasks_options
-    options = [
-      [:label_disabled, ''],
-      [:label_cross_project_system, 'system'],
-      [:label_cross_project_tree, 'tree'],
-      [:label_cross_project_hierarchy, 'hierarchy'],
-      [:label_cross_project_descendants, 'descendants']
-    ]
-
-    options.map {|label, value| [l(label), value.to_s]}
-  end
-
-  def parent_issue_dates_options
-    options = [
-      [:label_parent_task_attributes_derived, 'derived'],
-      [:label_parent_task_attributes_independent, 'independent']
-    ]
-
-    options.map {|label, value| [l(label), value.to_s]}
-  end
-
-  def parent_issue_priority_options
-    options = [
-      [:label_parent_task_attributes_derived, 'derived'],
-      [:label_parent_task_attributes_independent, 'independent']
-    ]
-
-    options.map {|label, value| [l(label), value.to_s]}
-  end
-
-  def parent_issue_done_ratio_options
-    options = [
-      [:label_parent_task_attributes_derived, 'derived'],
-      [:label_parent_task_attributes_independent, 'independent']
-    ]
-
-    options.map {|label, value| [l(label), value.to_s]}
-  end
-
-  # Returns the options for the date_format setting
-  def date_format_setting_options(locale)
-    Setting::DATE_FORMATS.map do |f|
-      today = ::I18n.l(User.current.today, :locale => locale, :format => f)
-      format = f.gsub('%', '').gsub(/[dmY]/) do
-        {'d' => 'dd', 'm' => 'mm', 'Y' => 'yyyy'}[$&]
-      end
-      ["#{today} (#{format})", f]
-    end
-  end
-
-  def gravatar_default_setting_options
-    [['Identicons', 'identicon'],
-     ['Monster ids', 'monsterid'],
-     ['Mystery man', 'mm'],
-     ['Retro', 'retro'],
-     ['Robohash', 'robohash'],
-     ['Wavatars', 'wavatar']]
-  end
-end

app/helpers/sort_helper.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-# Helpers to sort tables using clickable column headers.
-#
-# Author:  Stuart Rackham <srackham@methods.co.nz>, March 2005.
-#          Jean-Philippe Lang, 2009
-# License: This source code is released under the MIT license.
-#
-# - Consecutive clicks toggle the column's sort order.
-# - Sort state is maintained by a session hash entry.
-# - CSS classes identify sort column and state.
-# - Typically used in conjunction with the Pagination module.
-#
-# Example code snippets:
-#
-# Controller:
-#
-#   helper :sort
-#   include SortHelper
-#
-#   def list
-#     sort_init 'last_name'
-#     sort_update %w(first_name last_name)
-#     @items = Contact.find_all nil, sort_clause
-#   end
-#
-# Controller (using Pagination module):
-#
-#   helper :sort
-#   include SortHelper
-#
-#   def list
-#     sort_init 'last_name'
-#     sort_update %w(first_name last_name)
-#     @contact_pages, @items = paginate :contacts,
-#       :order_by => sort_clause,
-#       :per_page => 10
-#   end
-#
-# View (table header in list.rhtml):
-#
-#   <thead>
-#     <tr>
-#       <%= sort_header_tag('id', :title => 'Sort by contact ID') %>
-#       <%= sort_header_tag('last_name', :caption => 'Name') %>
-#       <%= sort_header_tag('phone') %>
-#       <%= sort_header_tag('address', :width => 200) %>
-#     </tr>
-#   </thead>
-#
-# - Introduces instance variables: @sort_default, @sort_criteria
-# - Introduces param :sort
-#
-
-module SortHelper
-  def sort_name
-    controller_name + '_' + action_name + '_sort'
-  end
-
-  # Initializes the default sort.
-  # Examples:
-  #
-  #   sort_init 'name'
-  #   sort_init 'id', 'desc'
-  #   sort_init ['name', ['id', 'desc']]
-  #   sort_init [['name', 'desc'], ['id', 'desc']]
-  #
-  def sort_init(*args)
-    case args.size
-    when 1
-      @sort_default = args.first.is_a?(Array) ? args.first : [[args.first]]
-    when 2
-      @sort_default = [[args.first, args.last]]
-    else
-      raise ArgumentError
-    end
-  end
-
-  # Updates the sort state. Call this in the controller prior to calling
-  # sort_clause.
-  # - criteria can be either an array or a hash of allowed keys
-  #
-  def sort_update(criteria, sort_name=nil)
-    sort_name ||= self.sort_name
-    @sort_criteria = Redmine::SortCriteria.new(params[:sort] || session[sort_name] || @sort_default)
-    @sortable_columns = criteria
-    session[sort_name] = @sort_criteria.to_param
-  end
-
-  # Clears the sort criteria session data
-  #
-  def sort_clear
-    session[sort_name] = nil
-  end
-
-  # Returns an SQL sort clause corresponding to the current sort state.
-  # Use this to sort the controller's table items collection.
-  #
-  def sort_clause
-    @sort_criteria.sort_clause(@sortable_columns)
-  end
-
-  def sort_criteria
-    @sort_criteria
-  end
-
-  # Returns a link which sorts by the named column.
-  #
-  # - column is the name of an attribute in the sorted record collection.
-  # - the optional caption explicitly specifies the displayed link text.
-  # - 2 CSS classes reflect the state of the link: sort and asc or desc
-  #
-  def sort_link(column, caption, default_order)
-    css, order = nil, default_order
-
-    if column.to_s == @sort_criteria.first_key
-      if @sort_criteria.first_asc?
-        css = 'sort asc icon icon-sorted-desc'
-        order = 'desc'
-      else
-        css = 'sort desc icon icon-sorted-asc'
-        order = 'asc'
-      end
-    end
-    caption = column.to_s.humanize unless caption
-
-    sort_options = { :sort => @sort_criteria.add(column.to_s, order).to_param }
-    link_to(caption, {:params => request.query_parameters.merge(sort_options)}, :class => css)
-  end
-
-  # Returns a table header <th> tag with a sort link for the named column
-  # attribute.
-  #
-  # Options:
-  #   :caption     The displayed link name (defaults to titleized column name).
-  #   :title       The tag's 'title' attribute (defaults to 'Sort by :caption').
-  #
-  # Other options hash entries generate additional table header tag attributes.
-  #
-  # Example:
-  #
-  #   <%= sort_header_tag('id', :title => 'Sort by contact ID', :width => 40) %>
-  #
-  def sort_header_tag(column, options = {})
-    caption = options.delete(:caption) || column.to_s.humanize
-    default_order = options.delete(:default_order) || 'asc'
-    options[:title] = l(:label_sort_by, "\"#{caption}\"") unless options[:title]
-    content_tag('th', sort_link(column, caption, default_order), options)
-  end
-
-  # Returns the css classes for the current sort order
-  #
-  # Example:
-  #
-  #   sort_css_classes
-  #   # => "sort-by-created-on sort-desc"
-  def sort_css_classes
-    if @sort_criteria.first_key
-      "sort-by-#{@sort_criteria.first_key.to_s.dasherize} sort-#{@sort_criteria.first_asc? ? 'asc' : 'desc'}"
-    end
-  end
-end

app/helpers/timelog_helper.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module TimelogHelper
-  include ApplicationHelper
-
-  # Returns a collection of activities for a select field.  time_entry
-  # is optional and will be used to check if the selected TimeEntryActivity
-  # is active.
-  def activity_collection_for_select_options(time_entry=nil, project=nil)
-    project ||= time_entry.try(:project)
-    project ||= @project
-    if project.nil?
-      activities = TimeEntryActivity.shared.active
-    else
-      activities = project.activities
-    end
-
-    collection = []
-    if time_entry && time_entry.activity && !time_entry.activity.active?
-      collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ]
-    else
-      collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ] unless activities.detect(&:is_default)
-    end
-    activities.each { |a| collection << [a.name, a.id] }
-    collection
-  end
-
-  def user_collection_for_select_options(time_entry)
-    collection = time_entry.assignable_users
-    collection << time_entry.user unless time_entry.user.nil? && !collection.include?(time_entry.user)
-    principals_options_for_select(collection, time_entry.user_id.to_s)
-  end
-
-  def select_hours(data, criteria, value)
-    if value.to_s.empty?
-      data.select {|row| row[criteria].blank? }
-    else
-      data.select {|row| row[criteria].to_s == value.to_s}
-    end
-  end
-
-  def sum_hours(data)
-    sum = 0
-    data.each do |row|
-      sum += row['hours'].to_f
-    end
-    sum
-  end
-
-  def format_criteria_value(criteria_options, value, html=true)
-    if value.blank?
-      "[#{l(:label_none)}]"
-    elsif k = criteria_options[:klass]
-      obj = k.find_by_id(value.to_i)
-      if obj.is_a?(Issue)
-        if obj.visible?
-          html ? link_to_issue(obj) : "#{obj.tracker} ##{obj.id}: #{obj.subject}"
-        else
-          "##{obj.id}"
-        end
-      else
-        format_object(obj, html)
-      end
-    elsif cf = criteria_options[:custom_field]
-      format_value(value, cf)
-    else
-      value.to_s
-    end
-  end
-
-  def report_to_csv(report)
-    Redmine::Export::CSV.generate(:encoding => params[:encoding]) do |csv|
-      # Column headers
-      headers = report.criteria.collect {|criteria| l_or_humanize(report.available_criteria[criteria][:label]) }
-      headers += report.periods
-      headers << l(:label_total_time)
-      csv << headers
-      # Content
-      report_criteria_to_csv(csv, report.available_criteria, report.columns, report.criteria, report.periods, report.hours)
-      # Total row
-      str_total = l(:label_total_time)
-      row = [ str_total ] + [''] * (report.criteria.size - 1)
-      total = 0
-      report.periods.each do |period|
-        sum = sum_hours(select_hours(report.hours, report.columns, period.to_s))
-        total += sum
-        row << (sum > 0 ? sum : '')
-      end
-      row << total
-      csv << row
-    end
-  end
-
-  def report_criteria_to_csv(csv, available_criteria, columns, criteria, periods, hours, level=0)
-    hours.collect {|h| h[criteria[level]].to_s}.uniq.each do |value|
-      hours_for_value = select_hours(hours, criteria[level], value)
-      next if hours_for_value.empty?
-      row = [''] * level
-      row << format_criteria_value(available_criteria[criteria[level]], value, false).to_s
-      row += [''] * (criteria.length - level - 1)
-      total = 0
-      periods.each do |period|
-        sum = sum_hours(select_hours(hours_for_value, columns, period.to_s))
-        total += sum
-        row << (sum > 0 ? sum : '')
-      end
-      row << total
-      csv << row
-      if criteria.length > level + 1
-        report_criteria_to_csv(csv, available_criteria, columns, criteria, periods, hours_for_value, level + 1)
-      end
-    end
-  end
-
-  def cancel_button_tag_for_time_entry(project)
-    fallback_path = project ? project_time_entries_path(project) : time_entries_path
-    cancel_button_tag(fallback_path)
-  end
-
-end

app/helpers/trackers_helper.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module TrackersHelper
-
-  def tracker_name_tag(tracker)
-    title = tracker.description.presence
-    css = title ? "field-description" : nil
-    content_tag 'span', tracker.name, :class => css, :title => title
-  end
-end

app/helpers/users_helper.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module UsersHelper
-  include ApplicationHelper
-
-  def users_status_options_for_select(selected)
-    user_count_by_status = User.group('status').count.to_hash
-    options_for_select([[l(:label_all), '']] + (User.valid_statuses.map {|c| ["#{l('status_' + User::LABEL_BY_STATUS[c])} (#{user_count_by_status[c].to_i})", c]}), selected.to_s)
-  end
-
-  def user_mail_notification_options(user)
-    user.valid_notification_options.collect {|o| [l(o.last), o.first]}
-  end
-
-  def textarea_font_options
-    [[l(:label_font_default), '']] + UserPreference::TEXTAREA_FONT_OPTIONS.map {|o| [l("label_font_#{o}"), o]}
-  end
-
-  def history_default_tab_options
-    [[l('label_issue_history_notes'), 'notes'],
-     [l('label_history'), 'history'],
-     [l('label_issue_history_properties'), 'properties'],
-     [l('label_time_entry_plural'), 'time_entries'],
-     [l('label_associated_revisions'), 'changesets'],
-     [l('label_last_tab_visited'), 'last_tab_visited']]
-  end
-
-  def change_status_link(user)
-    url = {:controller => 'users', :action => 'update', :id => user, :page => params[:page], :status => params[:status], :tab => nil}
-
-    if user.locked?
-      link_to l(:button_unlock), url.merge(:user => {:status => User::STATUS_ACTIVE}), :method => :put, :class => 'icon icon-unlock'
-    elsif user.registered?
-      link_to l(:button_activate), url.merge(:user => {:status => User::STATUS_ACTIVE}), :method => :put, :class => 'icon icon-unlock'
-    elsif user != User.current
-      link_to l(:button_lock), url.merge(:user => {:status => User::STATUS_LOCKED}), :method => :put, :class => 'icon icon-lock'
-    end
-  end
-
-  def additional_emails_link(user)
-    if user.email_addresses.count > 1 || Setting.max_additional_emails.to_i > 0
-      link_to l(:label_email_address_plural), user_email_addresses_path(@user), :class => 'icon icon-email-add', :remote => true
-    end
-  end
-
-  def user_settings_tabs
-    tabs = [{:name => 'general', :partial => 'users/general', :label => :label_general},
-            {:name => 'memberships', :partial => 'users/memberships', :label => :label_project_plural}
-            ]
-    if Group.givable.any?
-      tabs.insert 1, {:name => 'groups', :partial => 'users/groups', :label => :label_group_plural}
-    end
-    tabs
-  end
-
-  def users_to_csv(users)
-    Redmine::Export::CSV.generate(:encoding => params[:encoding]) do |csv|
-      columns = [
-        'login',
-        'firstname',
-        'lastname',
-        'mail',
-        'admin',
-        'created_on',
-        'last_login_on',
-        'status'
-      ]
-
-      # csv header fields
-      csv << columns.map{|column| l('field_' + column)}
-      # csv lines
-      users.each do |user|
-        csv << columns.map do |column|
-          if column == 'status'
-            l(("status_#{User::LABEL_BY_STATUS[user.status]}"))
-          else
-            format_object(user.send(column), false)
-          end
-        end
-      end
-    end
-  end
-end

app/helpers/versions_helper.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-# Redmine - project management software
-# Copyright (C) 2006-2019  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-module VersionsHelper
-
-  def version_anchor(version)
-    if @project == version.project
-      anchor version.name
-    else
-      anchor "#{version.project.try(:identifier)}-#{version.name}"
-    end
-  end
-
-  def version_filtered_issues_path(version, options = {})
-    options = {:fixed_version_id => version, :set_filter => 1}.merge(options)
-    project =
-      case version.sharing
-      when 'hierarchy', 'tree'
-        if version.project && version.project.root.visible?
-          version.project.root
-        else
-          version.project
-        end
-      when 'system'
-        nil
-      else
-        version.project
-      end
-    if project
-      project_issues_path(project, options)
-    else
-      issues_path(options)
-    end
-  end
-
-  STATUS_BY_CRITERIAS = %w(tracker status priority author assigned_to category)
-
-  def render_issue_status_by(version, criteria)
-    criteria = 'tracker' unless STATUS_BY_CRITERIAS.include?(criteria)
-    h = Hash.new {|k,v| k[v] = [0, 0]}
-    begin
-      # Total issue count
-      version.visible_fixed_issues.group(criteria).count.each {|c,s| h[c][0] = s}
-      # Open issues count
-      version.visible_fixed_issues.open.group(criteria).count.each {|c,s| h[c][1] = s}
-    rescue ActiveRecord::RecordNotFound
-      # When grouping by an association, Rails throws this exception if there's no result (bug)
-    end
-    # Sort with nil keys in last position
-    sorted_keys =
-      h.keys.sort {|a, b|
-        if a.nil?
-          1
-        else
-          b.nil? ? -1 : a <=> b
-        end
-      }
-    counts =
-      sorted_keys.collect {|k|
-          {:group => k, :total => h[k][0], :open => h[k][1], :closed => (h[k][0] - h[k][1])}
-      }
-    max = counts.collect {|c| c[:total]}.max
-    render :partial => 'issue_counts', :locals => {:version => version, :criteria => criteria, :counts => counts, :max => max}
-  end
-
-  def status_by_options_for_select(value)
-    options_for_select(STATUS_BY_CRITERIAS.collect {|criteria| [l("field_#{criteria}".to_sym), criteria]}, value)
-  end
-
-  def link_to_new_issue(version, project)
-    if version.open? && User.current.allowed_to?(:add_issues, project)
-      trackers = Issue.allowed_target_trackers(project)
-
-      unless trackers.empty?
-        issue = Issue.new(:project => project)
-        new_issue_tracker = trackers.detect do |tracker|
-          issue.tracker = tracker
-          issue.safe_attribute?('fixed_version_id')
-        end
-      end
-
-      if new_issue_tracker
-        attrs = {
-          :tracker_id => new_issue_tracker,
-          :fixed_version_id => version.id
-        }
-        link_to l(:label_issue_new), new_project_issue_path(project, :issue => attrs, :back_url => version_path(version)), :class => 'icon icon-add'
-      end
-    end
-  end
-end