SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine

  module AccessControl

    class << self

      def map

        mapper = Mapper.new

        yield mapper

        @permissions ||= []

        @permissions += mapper.mapped_permissions

      end

      def permissions

        @permissions

      end

      # Returns the permission of given name or nil if it wasn't found

      # Argument should be a symbol

      def permission(name)

        permissions.detect {|p| p.name == name}

      end

      # Returns the actions that are allowed by the permission of given name

      def allowed_actions(permission_name)

        perm = permission(permission_name)

        perm ? perm.actions : []

      end

      def public_permissions

        @public_permissions ||= @permissions.select {|p| p.public?}

      end

      def members_only_permissions

        @members_only_permissions ||= @permissions.select {|p| p.require_member?}

      end

      def loggedin_only_permissions

        @loggedin_only_permissions ||= @permissions.select {|p| p.require_loggedin?}

      end

      def read_action?(action)

        if action.is_a?(Symbol)

          perm = permission(action)

          !perm.nil? && perm.read?

        else

          s = "#{action[:controller]}/#{action[:action]}"

          permissions.detect {|p| p.actions.include?(s) && p.read?}.present?

        end

      end

      def available_project_modules

        @available_project_modules ||= @permissions.collect(&:project_module).uniq.compact

      end

      def modules_permissions(modules)

        @permissions.select {|p| p.project_module.nil? || modules.include?(p.project_module.to_s)}

      end

    end

    class Mapper

      def initialize

        @project_module = nil

      end

      def permission(name, hash, options={})

        @permissions ||= []

        options.merge!(:project_module => @project_module)

        @permissions << Permission.new(name, hash, options)

      end

      def project_module(name, options={})

        @project_module = name

        yield self

        @project_module = nil

      end

      def mapped_permissions

        @permissions

      end

    end

    class Permission

      attr_reader :name, :actions, :project_module

      def initialize(name, hash, options)

        @name = name

        @actions = []

        @public = options[:public] || false

        @require = options[:require]

        @read = options[:read] || false

        @project_module = options[:project_module]

        hash.each do |controller, actions|

          if actions.is_a? Array

            @actions << actions.collect {|action| "#{controller}/#{action}"}

          else

            @actions << "#{controller}/#{actions}"

          end

        end

        @actions.flatten!

      end

      def public?

        @public

      end

      def require_member?

        @require && @require == :member

      end

      def require_loggedin?

        @require && (@require == :member || @require == :loggedin)

      end

      def read?

        @read

      end

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine

  module AccessKeys

    ACCESSKEYS = {:edit => 'e',

                  :preview => 'r',

                  :quick_search => 'f',

                  :search => '4',

                  :new_issue => '7'

                 }.freeze unless const_defined?(:ACCESSKEYS)

    def self.key_for(action)

      ACCESSKEYS[action]

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine

  module Activity

    mattr_accessor :available_event_types, :default_event_types, :providers

    @@available_event_types = []

    @@default_event_types = []

    @@providers = Hash.new {|h,k| h[k]=[] }

    class << self

      def map(&block)

        yield self

      end

      # Registers an activity provider

      def register(event_type, options={})

        options.assert_valid_keys(:class_name, :default)

        event_type = event_type.to_s

        providers = options[:class_name] || event_type.classify

        providers = ([] << providers) unless providers.is_a?(Array)

        @@available_event_types << event_type unless @@available_event_types.include?(event_type)

        @@default_event_types << event_type unless options[:default] == false

        @@providers[event_type] += providers

      end

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine

  module Activity

    # Class used to retrieve activity events

    class Fetcher

      attr_reader :user, :project, :scope

      # Needs to be unloaded in development mode

      @@constantized_providers = Hash.new {|h,k| h[k] = Redmine::Activity.providers[k].collect {|t| t.constantize } }

      def initialize(user, options={})

        options.assert_valid_keys(:project, :with_subprojects, :author)

        @user = user

        @project = options[:project]

        @options = options

        @scope = event_types

      end

      # Returns an array of available event types

      def event_types

        return @event_types unless @event_types.nil?

        @event_types = Redmine::Activity.available_event_types

        @event_types = @event_types.select {|o| @project.self_and_descendants.detect {|p| @user.allowed_to?("view_#{o}".to_sym, p)}} if @project

        @event_types

      end

      # Yields to filter the activity scope

      def scope_select(&block)

        @scope = @scope.select {|t| yield t }

      end

      # Sets the scope

      # Argument can be :all, :default or an array of event types

      def scope=(s)

        case s

        when :all

          @scope = event_types

        when :default

          default_scope!

        else

          @scope = s & event_types

        end

      end

      # Resets the scope to the default scope

      def default_scope!

        @scope = Redmine::Activity.default_event_types

      end

      # Returns an array of events for the given date range

      # sorted in reverse chronological order

      def events(from = nil, to = nil, options={})

        e = []

        @options[:limit] = options[:limit]

        @scope.each do |event_type|

          constantized_providers(event_type).each do |provider|

            e += provider.find_events(event_type, @user, from, to, @options)

          end

        end

        e.sort! {|a,b| b.event_datetime <=> a.event_datetime}

        if options[:limit]

          e = e.slice(0, options[:limit])

        end

        e

      end

      private

      def constantized_providers(event_type)

        @@constantized_providers[event_type]

      end

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine

  module Ciphering

    def self.included(base)

      base.extend ClassMethods

    end

    class << self

      def encrypt_text(text)

        if cipher_key.blank? || text.blank?

          text

        else

          c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")

          iv = c.random_iv

          c.encrypt

          c.key = cipher_key

          c.iv = iv

          e = c.update(text.to_s)

          e << c.final

          "aes-256-cbc:" + [e, iv].map {|v| Base64.encode64(v).strip}.join('--')

        end

      end

      def decrypt_text(text)

        if text && match = text.match(/\Aaes-256-cbc:(.+)\Z/)

          if cipher_key.blank?

            logger.error "Attempt to decrypt a ciphered text with no cipher key configured in config/configuration.yml" if logger

            return text

          end

          text = match[1]

          c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")

          e, iv = text.split("--").map {|s| Base64.decode64(s)}

          c.decrypt

          c.key = cipher_key

          c.iv = iv

          d = c.update(e)

          d << c.final

        else

          text

        end

      end

      def cipher_key

        key = Redmine::Configuration['database_cipher_key'].to_s

        key.blank? ? nil : Digest::SHA256.hexdigest(key)

      end

      def logger

        Rails.logger

      end

    end

    module ClassMethods

      def encrypt_all(attribute)

        transaction do

          all.each do |object|

            clear = object.send(attribute)

            object.send "#{attribute}=", clear

            raise(ActiveRecord::Rollback) unless object.save(:validation => false)

          end

        end ? true : false

      end

      def decrypt_all(attribute)

        transaction do

          all.each do |object|

            clear = object.send(attribute)

            object.send :write_attribute, attribute, clear

            raise(ActiveRecord::Rollback) unless object.save(:validation => false)

          end

        end

      end ? true : false

    end

    private

    # Returns the value of the given ciphered attribute

    def read_ciphered_attribute(attribute)

      Redmine::Ciphering.decrypt_text(read_attribute(attribute))

    end

    # Sets the value of the given ciphered attribute

    def write_ciphered_attribute(attribute, value)

      write_attribute(attribute, Redmine::Ciphering.encrypt_text(value))

    end

  end

end

if RUBY_VERSION < '1.9'

  require 'iconv'

end

module Redmine

  module CodesetUtil

    def self.replace_invalid_utf8(str)

      return str if str.nil?

      if str.respond_to?(:force_encoding)

        str.force_encoding('UTF-8')

        if ! str.valid_encoding?

          str = str.encode("US-ASCII", :invalid => :replace,

                :undef => :replace, :replace => '?').encode("UTF-8")

        end

      elsif RUBY_PLATFORM == 'java'

        begin

          ic = Iconv.new('UTF-8', 'UTF-8')

          str = ic.iconv(str)

        rescue

          str = str.gsub(%r{[^\r\n\t\x20-\x7e]}, '?')

        end

      else

        ic = Iconv.new('UTF-8', 'UTF-8')

        txtar = ""

        begin

          txtar += ic.iconv(str)

        rescue Iconv::IllegalSequence

          txtar += $!.success

          str = '?' + $!.failed[1,$!.failed.length]

          retry

        rescue

          txtar += $!.success

        end

        str = txtar

      end

      str

    end

    def self.to_utf8(str, encoding)

      return str if str.nil?

      str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)

      if str.empty?

        str.force_encoding("UTF-8") if str.respond_to?(:force_encoding)

        return str

      end

      enc = encoding.blank? ? "UTF-8" : encoding

      if str.respond_to?(:force_encoding)

        if enc.upcase != "UTF-8"

          str.force_encoding(enc)

          str = str.encode("UTF-8", :invalid => :replace,

                :undef => :replace, :replace => '?')

        else

          str.force_encoding("UTF-8")

          if ! str.valid_encoding?

            str = str.encode("US-ASCII", :invalid => :replace,

                  :undef => :replace, :replace => '?').encode("UTF-8")

          end

        end

      elsif RUBY_PLATFORM == 'java'

        begin

          ic = Iconv.new('UTF-8', enc)

          str = ic.iconv(str)

        rescue

          str = str.gsub(%r{[^\r\n\t\x20-\x7e]}, '?')

        end

      else

        ic = Iconv.new('UTF-8', enc)

        txtar = ""

        begin

          txtar += ic.iconv(str)

        rescue Iconv::IllegalSequence

          txtar += $!.success

          str = '?' + $!.failed[1,$!.failed.length]

          retry

        rescue

          txtar += $!.success

        end

        str = txtar

      end

      str

    end

    def self.to_utf8_by_setting(str)

      return str if str.nil?

      str = self.to_utf8_by_setting_internal(str)

      if str.respond_to?(:force_encoding)

        str.force_encoding('UTF-8')

      end

      str

    end

    def self.to_utf8_by_setting_internal(str)

      return str if str.nil?

      if str.respond_to?(:force_encoding)

        str.force_encoding('ASCII-8BIT')

      end

      return str if str.empty?

      return str if /\A[\r\n\t\x20-\x7e]*\Z/n.match(str) # for us-ascii

      if str.respond_to?(:force_encoding)

        str.force_encoding('UTF-8')

      end

      encodings = Setting.repositories_encodings.split(',').collect(&:strip)

      encodings.each do |encoding|

        if str.respond_to?(:force_encoding)

          begin

            str.force_encoding(encoding)

            utf8 = str.encode('UTF-8')

            return utf8 if utf8.valid_encoding?

          rescue

            # do nothing here and try the next encoding

          end

        else

          begin

            return Iconv.conv('UTF-8', encoding, str)

          rescue Iconv::Failure

            # do nothing here and try the next encoding

          end

        end

      end

      str = self.replace_invalid_utf8(str)

      if str.respond_to?(:force_encoding)

        str.force_encoding('UTF-8')

      end

      str

    end

    def self.from_utf8(str, encoding)

      str ||= ''

      if str.respond_to?(:force_encoding)

        str.force_encoding('UTF-8')

        if encoding.upcase != 'UTF-8'

          str = str.encode(encoding, :invalid => :replace,

                           :undef => :replace, :replace => '?')

        else

          str = self.replace_invalid_utf8(str)

        end

      elsif RUBY_PLATFORM == 'java'

        begin

          ic = Iconv.new(encoding, 'UTF-8')

          str = ic.iconv(str)

        rescue

          str = str.gsub(%r{[^\r\n\t\x20-\x7e]}, '?')

        end

      else

        ic = Iconv.new(encoding, 'UTF-8')

        txtar = ""

        begin

          txtar += ic.iconv(str)

        rescue Iconv::IllegalSequence

          txtar += $!.success

          str = '?' + $!.failed[1, $!.failed.length]

          retry

        rescue

          txtar += $!.success

        end

        str = txtar

      end

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine

  module Configuration

    # Configuration default values

    @defaults = {

      'email_delivery' => nil,

      'max_concurrent_ajax_uploads' => 2

    }

    @config = nil

    class << self

      # Loads the Redmine configuration file

      # Valid options:

      # * <tt>:file</tt>: the configuration file to load (default: config/configuration.yml)

      # * <tt>:env</tt>: the environment to load the configuration for (default: Rails.env)

      def load(options={})

        filename = options[:file] || File.join(Rails.root, 'config', 'configuration.yml')

        env = options[:env] || Rails.env

        @config = @defaults.dup

        load_deprecated_email_configuration(env)

        if File.file?(filename)

          @config.merge!(load_from_yaml(filename, env))

        end

        # Compatibility mode for those who copy email.yml over configuration.yml

        %w(delivery_method smtp_settings sendmail_settings).each do |key|

          if value = @config.delete(key)

            @config['email_delivery'] ||= {}

            @config['email_delivery'][key] = value

          end

        end

        if @config['email_delivery']

          ActionMailer::Base.perform_deliveries = true

          @config['email_delivery'].each do |k, v|

            v.symbolize_keys! if v.respond_to?(:symbolize_keys!)

            ActionMailer::Base.send("#{k}=", v)

          end

        end

        @config

      end

      # Returns a configuration setting

      def [](name)

        load unless @config

        @config[name]

      end

      # Yields a block with the specified hash configuration settings

      def with(settings)

        settings.stringify_keys!

        load unless @config

        was = settings.keys.inject({}) {|h,v| h[v] = @config[v]; h}

        @config.merge! settings

        yield if block_given?

        @config.merge! was

      end

      private

      def load_from_yaml(filename, env)

        yaml = nil

        begin

          yaml = YAML::load_file(filename)

        rescue ArgumentError

          $stderr.puts "Your Redmine configuration file located at #{filename} is not a valid YAML file and could not be loaded."

          exit 1

        end

        conf = {}

        if yaml.is_a?(Hash)

          if yaml['default']

            conf.merge!(yaml['default'])

          end

          if yaml[env]

            conf.merge!(yaml[env])

          end

        else

          $stderr.puts "Your Redmine configuration file located at #{filename} is not a valid Redmine configuration file."

          exit 1

        end

        conf

      end

      def load_deprecated_email_configuration(env)

        deprecated_email_conf = File.join(Rails.root, 'config', 'email.yml')

        if File.file?(deprecated_email_conf)

          warn "Storing outgoing emails configuration in config/email.yml is deprecated. You should now store it in config/configuration.yml using the email_delivery setting."

          @config.merge!({'email_delivery' => load_from_yaml(deprecated_email_conf, env)})

        end

      end

    end

  end

end

Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].each { |file| require(file) }

# Redmine - project management software

# Copyright (C) 2006-2014  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 ActiveRecord

  module FinderMethods

    def find_ids(*args)

      find_ids_with_associations

    end

    private

    def find_ids_with_associations

        join_dependency = construct_join_dependency_for_association_find

        relation = construct_relation_for_association_find_ids(join_dependency)

        rows = connection.select_all(relation, 'SQL', relation.bind_values)

        rows.map {|row| row["id"].to_i}

      rescue ThrowResult

        []

    end

    def construct_relation_for_association_find_ids(join_dependency)

      relation = except(:includes, :eager_load, :preload, :select).select("#{table_name}.id")

      apply_join_dependency(relation, join_dependency)

    end

  end

end

class DateValidator < ActiveModel::EachValidator

  def validate_each(record, attribute, value)

    before_type_cast = record.attributes_before_type_cast[attribute.to_s]

    if before_type_cast.is_a?(String) && before_type_cast.present?

      # TODO: #*_date_before_type_cast returns a Mysql::Time with ruby1.8+mysql gem

      unless before_type_cast =~ /\A\d{4}-\d{2}-\d{2}( 00:00:00)?\z/ && value

        record.errors.add attribute, :not_a_date

      end

    end

  end

end

require File.dirname(__FILE__) + '/date/calculations'

class Date #:nodoc:

  include Redmine::CoreExtensions::Date::Calculations

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine #:nodoc:

  module CoreExtensions #:nodoc:

    module Date #:nodoc:

      # Custom date calculations

      module Calculations

        # Returns difference with specified date in months

        def months_ago(date = self.class.today)

          (date.year - self.year)*12 + (date.month - self.month)

        end

        # Returns difference with specified date in weeks

        def weeks_ago(date = self.class.today)

          (date.year - self.year)*52 + (date.cweek - self.cweek)

        end

      end

    end

  end

end

require File.dirname(__FILE__) + '/string/conversions'

require File.dirname(__FILE__) + '/string/inflections'

class String #:nodoc:

  include Redmine::CoreExtensions::String::Conversions

  include Redmine::CoreExtensions::String::Inflections

  def is_binary_data?

    ( self.count( "^ -~", "^\r\n" ).fdiv(self.size) > 0.3 || self.index( "\x00" ) ) unless empty?

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine #:nodoc:

  module CoreExtensions #:nodoc:

    module String #:nodoc:

      # Custom string conversions

      module Conversions

        # Parses hours format and returns a float

        def to_hours

          s = self.dup

          s.strip!

          if s =~ %r{^(\d+([.,]\d+)?)h?$}

            s = $1

          else

            # 2:30 => 2.5

            s.gsub!(%r{^(\d+):(\d+)$}) { $1.to_i + $2.to_i / 60.0 }

            # 2h30, 2h, 30m => 2.5, 2, 0.5

            s.gsub!(%r{^((\d+)\s*(h|hours?))?\s*((\d+)\s*(m|min)?)?$}i) { |m| ($1 || $4) ? ($2.to_i + $5.to_i / 60.0) : m[0] }

          end

          # 2,5 => 2.5

          s.gsub!(',', '.')

          begin; Kernel.Float(s); rescue; nil; end

        end

        # Object#to_a removed in ruby1.9

        if RUBY_VERSION > '1.9'

          def to_a

            [self.dup]

          end

        end

      end

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine #:nodoc:

  module CoreExtensions #:nodoc:

    module String #:nodoc:

      # Custom string inflections

      module Inflections

        def with_leading_slash

          starts_with?('/') ? self : "/#{ self }"

        end

      end

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  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 Redmine

  module DefaultData

    class DataAlreadyLoaded < Exception; end

    module Loader

      include Redmine::I18n

      class << self

        # Returns true if no data is already loaded in the database

        # otherwise false

        def no_data?

          !Role.where(:builtin => 0).exists? &&

            !Tracker.exists? &&

            !IssueStatus.exists? &&

            !Enumeration.exists?

        end

        # Loads the default data

        # Raises a RecordNotSaved exception if something goes wrong

        def load(lang=nil)

          raise DataAlreadyLoaded.new("Some configuration data is already loaded.") unless no_data?

          set_language_if_valid(lang)

          Role.transaction do

            # Roles

            manager = Role.create! :name => l(:default_role_manager),

                                   :issues_visibility => 'all',

                                   :position => 1

            manager.permissions = manager.setable_permissions.collect {|p| p.name}

            manager.save!

            developer = Role.create!  :name => l(:default_role_developer),

                                      :position => 2,

                                      :permissions => [:manage_versions,

                                                      :manage_categories,

                                                      :view_issues,

                                                      :add_issues,

                                                      :edit_issues,

                                                      :view_private_notes,

                                                      :set_notes_private,

                                                      :manage_issue_relations,

                                                      :manage_subtasks,

                                                      :add_issue_notes,

                                                      :save_queries,

                                                      :view_gantt,

                                                      :view_calendar,

                                                      :log_time,

                                                      :view_time_entries,

                                                      :comment_news,

                                                      :view_documents,

                                                      :view_wiki_pages,

                                                      :view_wiki_edits,

                                                      :edit_wiki_pages,

                                                      :delete_wiki_pages,

                                                      :add_messages,

                                                      :edit_own_messages,

                                                      :view_files,

                                                      :manage_files,

                                                      :browse_repository,

                                                      :view_changesets,

                                                      :commit_access,

                                                      :manage_related_issues]

            reporter = Role.create! :name => l(:default_role_reporter),

                                    :position => 3,

                                    :permissions => [:view_issues,

                                                    :add_issues,

                                                    :add_issue_notes,

                                                    :save_queries,

                                                    :view_gantt,

                                                    :view_calendar,

                                                    :log_time,

                                                    :view_time_entries,

                                                    :comment_news,

                                                    :view_documents,

                                                    :view_wiki_pages,

                                                    :view_wiki_edits,

                                                    :add_messages,

                                                    :edit_own_messages,

                                                    :view_files,

                                                    :browse_repository,

                                                    :view_changesets]

            Role.non_member.update_attribute :permissions, [:view_issues,

                                                            :add_issues,

                                                            :add_issue_notes,

                                                            :save_queries,

                                                            :view_gantt,

                                                            :view_calendar,

                                                            :view_time_entries,

                                                            :comment_news,

                                                            :view_documents,

                                                            :view_wiki_pages,

                                                            :view_wiki_edits,

                                                            :add_messages,

                                                            :view_files,

                                                            :browse_repository,

                                                            :view_changesets]

            Role.anonymous.update_attribute :permissions, [:view_issues,

                                                           :view_gantt,

                                                           :view_calendar,

                                                           :view_time_entries,

                                                           :view_documents,

                                                           :view_wiki_pages,

                                                           :view_wiki_edits,

                                                           :view_files,

                                                           :browse_repository,

                                                           :view_changesets]

            # Trackers

            Tracker.create!(:name => l(:default_tracker_bug),     :is_in_chlog => true,  :is_in_roadmap => false, :position => 1)

            Tracker.create!(:name => l(:default_tracker_feature), :is_in_chlog => true,  :is_in_roadmap => true,  :position => 2)

            Tracker.create!(:name => l(:default_tracker_support), :is_in_chlog => false, :is_in_roadmap => false, :position => 3)

            # Issue statuses

            new       = IssueStatus.create!(:name => l(:default_issue_status_new), :is_closed => false, :is_default => true, :position => 1)

            in_progress  = IssueStatus.create!(:name => l(:default_issue_status_in_progress), :is_closed => false, :is_default => false, :position => 2)

            resolved  = IssueStatus.create!(:name => l(:default_issue_status_resolved), :is_closed => false, :is_default => false, :position => 3)

            feedback  = IssueStatus.create!(:name => l(:default_issue_status_feedback), :is_closed => false, :is_default => false, :position => 4)

            closed    = IssueStatus.create!(:name => l(:default_issue_status_closed), :is_closed => true, :is_default => false, :position => 5)

            rejected  = IssueStatus.create!(:name => l(:default_issue_status_rejected), :is_closed => true, :is_default => false, :position => 6)

            # Workflow

            Tracker.all.each { |t|

              IssueStatus.all.each { |os|

                IssueStatus.all.each { |ns|

                  WorkflowTransition.create!(:tracker_id => t.id, :role_id => manager.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns

                }

              }

            }

            Tracker.all.each { |t|

              [new, in_progress, resolved, feedback].each { |os|

                [in_progress, resolved, feedback, closed].each { |ns|

                  WorkflowTransition.create!(:tracker_id => t.id, :role_id => developer.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns

                }

              }

            }

            Tracker.all.each { |t|

              [new, in_progress, resolved, feedback].each { |os|

                [closed].each { |ns|

                  WorkflowTransition.create!(:tracker_id => t.id, :role_id => reporter.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns

                }

              }

              WorkflowTransition.create!(:tracker_id => t.id, :role_id => reporter.id, :old_status_id => resolved.id, :new_status_id => feedback.id)

            }

            # Enumerations

            IssuePriority.create!(:name => l(:default_priority_low), :position => 1)

            IssuePriority.create!(:name => l(:default_priority_normal), :position => 2, :is_default => true)

            IssuePriority.create!(:name => l(:default_priority_high), :position => 3)

            IssuePriority.create!(:name => l(:default_priority_urgent), :position => 4)

            IssuePriority.create!(:name => l(:default_priority_immediate), :position => 5)

            DocumentCategory.create!(:name => l(:default_doc_category_user), :position => 1)

            DocumentCategory.create!(:name => l(:default_doc_category_tech), :position => 2)

            TimeEntryActivity.create!(:name => l(:default_activity_design), :position => 1)

            TimeEntryActivity.create!(:name => l(:default_activity_development), :position => 2)

          end

          true

        end

      end

    end

  end

end

# encoding: utf-8

#

# Redmine - project management software

# Copyright (C) 2006-2014  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 'tcpdf'

require 'fpdf/chinese'

require 'fpdf/japanese'

require 'fpdf/korean'

if RUBY_VERSION < '1.9'

  require 'iconv'

end

module Redmine

  module Export

    module PDF

      include ActionView::Helpers::TextHelper

      include ActionView::Helpers::NumberHelper