Redmine

  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

  end

  def new

    @time_entry.safe_attributes = params[:time_entry]

  end

  def create

    @time_entry.safe_attributes = params[:time_entry]

    if @time_entry.project && !User.current.allowed_to?(:log_time, @time_entry.project)

      render_403

  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

    end

  end

  def find_time_entries

    @time_entries = TimeEntry.where(:id => params[:id] || params[:ids]).

      preload(:project => :time_entry_activities).

    collection

  end

  def select_hours(data, criteria, value)

    if value.to_s.empty?

      data.select {|row| row[criteria].blank? }

  belongs_to :project

  belongs_to :issue

  belongs_to :user

  belongs_to :activity, :class_name => 'TimeEntryActivity'

  acts_as_customizable

                            :author_key => :user_id,

                            :scope => joins(:project).preload(:project)

  validates_presence_of :issue_id, :if => lambda { Setting.timelog_required_fields.include?('issue_id') }

  validates_presence_of :comments, :if => lambda { Setting.timelog_required_fields.include?('comments') }

  validates_numericality_of :hours, :allow_nil => true, :message => :invalid

  validates_length_of :comments, :maximum => 1024, :allow_nil => true

  validates :spent_on, :date => true

  before_validation :set_project_if_nil

  validate :validate_time_entry

  scope :visible, lambda {|*args|

    where("#{Issue.table_name}.root_id = #{issue.root_id} AND #{Issue.table_name}.lft >= #{issue.lft} AND #{Issue.table_name}.rgt <= #{issue.rgt}")

  }

  # Returns a SQL conditions string used to find all time entries visible by the specified user

  def self.visible_condition(user, options={})

    self.project = issue.project if issue && project.nil?

  end

  def validate_time_entry

    if hours

      errors.add :hours, :invalid if hours < 0

      end

    end

    errors.add :project_id, :invalid if project.nil?

    errors.add :issue_id, :invalid if (issue_id && !issue) || (issue && project!=issue.project) || @invalid_issue_id

    errors.add :activity_id, :inclusion if activity_id_changed? && project && !project.activities.include?(activity)

  end

    editable_custom_field_values(user).map(&:custom_field).uniq

  end

  private

  # Returns the hours that were logged in other time entries for the same user and the same day

    QueryColumn.new(:spent_on, :sortable => ["#{TimeEntry.table_name}.spent_on", "#{TimeEntry.table_name}.created_on"], :default_order => 'desc', :groupable => true),

    QueryColumn.new(:created_on, :sortable => "#{TimeEntry.table_name}.created_on", :default_order => 'desc'),

    QueryColumn.new(:tweek, :sortable => ["#{TimeEntry.table_name}.spent_on", "#{TimeEntry.table_name}.created_on"], :caption => :label_week),

    QueryColumn.new(:user, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),

    QueryColumn.new(:activity, :sortable => "#{TimeEntryActivity.table_name}.position", :groupable => true),

    QueryColumn.new(:issue, :sortable => "#{Issue.table_name}.id"),

      :type => :list_optional, :values => lambda { author_values }

    )

    activities = (project ? project.activities : TimeEntryActivity.shared)

    add_available_filter("activity_id",

      :type => :list, :values => activities.map {|a| [a.name, a.id.to_s]}

      <%=  link_to_issue(@time_entry.issue) if @time_entry.issue.try(:visible?) %>

    </span>

  </p>

  <p><%= f.date_field :spent_on, :size => 10, :required => true %><%= calendar_for('time_entry_spent_on') %></p>

  <p><%= f.hours_field :hours, :size => 6, :required => true %></p>

  <p><%= f.text_field :comments, :size => 100, :maxlength => 1024, :required => Setting.timelog_required_fields.include?('comments') %></p>

  warning_fields_cleared_on_bulk_edit: "Changes will result in the automatic deletion of values from one or more fields on the selected objects"

  error_exceeds_maximum_hours_per_day: "Cannot log more than %{max_hours} hours on the same day (%{logged_hours} hours have already been logged)"

  error_can_not_delete_auth_source: "This authentication mode is in use and cannot be deleted."

  mail_subject_lost_password: "Your %{value} password"

  mail_body_lost_password: 'To change your password, click on the following link:'

  permission_manage_subtasks: Manage subtasks

  permission_manage_related_issues: Manage related issues

  permission_import_issues: Import issues

  project_module_issue_tracking: Issue tracking

  project_module_time_tracking: Time tracking

    map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member

    map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin

    map.permission :manage_project_activities, {:projects => :settings, :project_enumerations => [:update, :destroy]}, :require => :member

  end

  map.project_module :news do |map|

  created_on: 2007-03-23 12:54:18 +01:00

  tweek: 12

  tmonth: 3

  id: 1

  hours: 4.25

  user_id: 2

  tyear: 2007

  created_on: 2007-03-23 14:11:04 +01:00

  tweek: 11

  tmonth: 3

  id: 2

  hours: 150.0

  user_id: 1

  tyear: 2007

  created_on: 2007-04-21 12:20:48 +02:00

  tweek: 16

  tmonth: 4

  id: 3

  hours: 1.0

  user_id: 1

  tyear: 2007

  created_on: 2007-04-22 12:20:48 +02:00

  tweek: 16

  tmonth: 4

  updated_on: 2007-04-22 12:20:48 +02:00

  activity_id: 10

  spent_on: 2007-04-22

  id: 4

  hours: 7.65

  user_id: 1

  tyear: 2007

  created_on: 2011-03-22 12:20:48 +02:00

  tweek: 12

  tmonth: 3

  updated_on: 2011-03-22 12:20:48 +02:00

  activity_id: 10

  spent_on: 2011-03-22

  id: 5

  hours: 7.65

  user_id: 1

  tyear: 2011

        :enumerations => {

          "9"=> {

            "parent_id"=>"9", "custom_field_values"=> {

          }

      }

    assert_response :redirect

    # TODO: Need to cause an exception on create but these tests

    # aren't setup for mocking.  Just create a record now so the

    # second one is a dupicate

    parent = TimeEntryActivity.find(9)

    TimeEntryActivity.create!({:name => parent.name, :project_id => 1,

                               :position => parent.position, :active => true, :parent_id => 9})

                       :issue_id => 3, :activity_id => 10, :spent_on => '2009-01-01'})

    assert_equal 3, TimeEntry.where(:activity_id => 9, :project_id => 1).count

    assert_equal 1, TimeEntry.where(:activity_id => 10, :project_id => 1).count

    assert_select 'option', :text => 'Inactive Activity', :count => 0

  end

  def test_post_new_as_js_should_update_activity_options

    @request.session[:user_id] = 3

    post :new, :params => {:time_entry => {:project_id => 1}, :format => 'js'}

    assert !response.body.include?('issue_that_is_not_visible')

  end

  def test_create_and_continue_at_project_level

    @request.session[:user_id] = 2

    assert_difference 'TimeEntry.count' do

    assert_select_error /Issue is invalid/

  end

  def test_get_bulk_edit

    @request.session[:user_id] = 2

  end

  def test_index_should_sort_by_spent_on_and_created_on

    get :index, :params => {

      :project_id => 1,

    assert_select 'td.issue-category', :text => 'Printing'

  end

  def test_index_with_issue_category_sort

    issue = Issue.find(3)

    issue.category_id = 2

  def TimeEntry.generate(attributes={})

    entry = TimeEntry.new(attributes)

    entry.user ||= User.find(2)

    entry.issue ||= Issue.find(1) unless entry.project

    entry.project ||= entry.issue.project

    entry.activity ||= TimeEntryActivity.first

    query = IssueQuery.new(:project => Project.find(1), :name => '_')

    query.column_names = [:subject, :spent_hours]

    issue = Issue.find(2)

                     :project_id => 1, :issue => issue, :activity => TimeEntryActivity.first)

    results = fetch_row_values(issue, query, 0)

    assert_equal ["2", "Add ingredients categories", "4.34"], results

  end

                          :issue    => issue,

                          :project  => project,

                          :user     => anon,

                          :activity => activity)

    assert_equal 1, te.errors.count

  end

  def test_create_with_required_issue_id_and_comment_should_be_validated

    set_language_if_valid 'en'

    with_settings :timelog_required_fields => ['issue_id' , 'comments'] do

      assert !entry.save

      assert_equal ["Comment cannot be blank", "Issue cannot be blank"], entry.errors.full_messages.sort

    end

  end

end