Class: TheFox::Timr::Model::Task

Inherits:
BasicModel show all
Includes:
Error
Defined in:
lib/timr/model/task.rb

Instance Attribute Summary collapse

Attributes inherited from BasicModel

#file_path, #has_changed

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from BasicModel

#changed, create_path_by_id, #created=, #delete_file, find_file_by_id, get_id_from_path, #id, #id=, #load_from_file, #modified=, #post_save_to_file, #pre_load_from_file, #save_to_file, #short_id

Constructor Details

#initialize ⇒ Task

Returns a new instance of Task.



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/timr/model/task.rb', line 16

def initialize
  super()
  
  # Meta
  @foreign_id = nil # --id
  @name = nil
  @description = nil
  @current_track = nil
  @estimation = nil
  @hourly_rate = nil
  @has_flat_rate = false
  
  # Data
  @tracks = Hash.new
end

Instance Attribute Details

#current_track ⇒ Object (readonly)

Returns the value of attribute current_track.



12
13
14
 
# File 'lib/timr/model/task.rb', line 12

def current_track
  @current_track
end

#description ⇒ Object

Returns the value of attribute description.



11
12
13
 
# File 'lib/timr/model/task.rb', line 11

def description
  @description
end

#foreign_id ⇒ Object

Returns the value of attribute foreign_id.



10
11
12
 
# File 'lib/timr/model/task.rb', line 10

def foreign_id
  @foreign_id
end

#has_flat_rate ⇒ Object

Returns the value of attribute has_flat_rate.



14
15
16
 
# File 'lib/timr/model/task.rb', line 14

def has_flat_rate
  @has_flat_rate
end

#hourly_rate ⇒ Object

Returns the value of attribute hourly_rate.



13
14
15
 
# File 'lib/timr/model/task.rb', line 13

def hourly_rate
  @hourly_rate
end

Class Method Details

.create_task_from_hash(options) ⇒ Object

Create a new Task using a Hash.

Options:

  • ‘:name` (String)

  • ‘:description` (String)

  • ‘:estimation` (String|Integer|Duration)

  • ‘:hourly_rate` (Integer)



1017
1018
1019
1020
1021
1022
1023
1024
1025
 
# File 'lib/timr/model/task.rb', line 1017

def create_task_from_hash(options)
  task = Task.new
  task.name = options.fetch(:name, nil)
  task.description = options.fetch(:description, nil)
  task.estimation = options.fetch(:estimation, nil)
  task.hourly_rate = options.fetch(:hourly_rate, nil)
  task.has_flat_rate = options.fetch(:has_flat_rate, false)
  task
end

.load_task_from_file(path) ⇒ Object

Load a Task from a file into a Task instance.



994
995
996
997
998
 
# File 'lib/timr/model/task.rb', line 994

def load_task_from_file(path)
  task = Task.new
  task.load_from_file(path)
  task
end

.load_task_from_file_with_id(base_path, task_id) ⇒ Object

Search a Task in a base path for a Track by ID. If found a file load it into a Task instance.



1002
1003
1004
1005
1006
1007
 
# File 'lib/timr/model/task.rb', line 1002

def load_task_from_file_with_id(base_path, task_id)
  task_file_path = BasicModel.find_file_by_id(base_path, task_id)
  if task_file_path
    load_task_from_file(task_file_path)
  end
end

Instance Method Details

#add_track(track, set_as_current_track = false) ⇒ Object

Add a Track.



80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/timr/model/task.rb', line 80

def add_track(track, set_as_current_track = false)
  track.task = self
  
  @tracks[track.id] = track
  
  if set_as_current_track
    @current_track = track
  end
  
  # Mark Task as changed.
  changed
end

#begin_datetime(options = Hash.new) ⇒ Object

Uses ‘tracks()` with `options` to filter.

Options:

  • ‘:from`



317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
 
# File 'lib/timr/model/task.rb', line 317

def begin_datetime(options = Hash.new)
  from_opt = options.fetch(:from, nil)
  
  # Cache
  # if @begin_datetime
  #  return @begin_datetime
  # end
  # Cannot use this cache because of :from :to range limitation.
  # It needs always to be direct from child Tracks, because the
  # cache does not know when the begin and end datetimes of the
  # child Tracks change.
  
  # Do not sort. We only need to sort the tracks
  # by begin_datetime and take the first.
  options[:sort] = false
  
  first_track = tracks(options)
    .select{ |track_id, track| track.begin_datetime } # filter nil
    .sort_by{ |track_id, track| track.begin_datetime }
    .to_h # sort_by makes [[]]
    .values # no keys to take the first
    .first
  
  if first_track
    bdt = first_track.begin_datetime(options)
  end
  
  if from_opt && bdt && from_opt > bdt
    bdt = from_opt
  end
  
  bdt
end

#begin_datetime_s(options = Hash.new) ⇒ Object

Options:

  • ‘:format`



354
355
356
357
358
359
360
361
362
363
 
# File 'lib/timr/model/task.rb', line 354

def begin_datetime_s(options = Hash.new)
  format_opt = options.fetch(:format, HUMAN_DATETIME_FOMRAT)
  
  bdt = begin_datetime(options)
  if bdt
    bdt.strftime(format_opt)
  else
    '---'
  end
end

#billed_duration(options = Hash.new) ⇒ Object

Alias for ‘duration` method.

Options:

  • ‘:billed` (Boolean)



660
661
662
 
# File 'lib/timr/model/task.rb', line 660

def billed_duration(options = Hash.new)
  duration(options.merge({:billed => true}))
end

#consumed_budge ⇒ Object

Get the actual consumed budge.



503
504
505
506
507
508
509
 
# File 'lib/timr/model/task.rb', line 503

def consumed_budge
  if @hourly_rate
    duration.to_i.to_f / 3600.0 * @hourly_rate
  else
    0.0
  end
end

#continue(options = Hash.new) ⇒ Object

Continues the current Track. Only if it isn’t already running.



608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
 
# File 'lib/timr/model/task.rb', line 608

def continue(options = Hash.new)
  track_opt = options.fetch(:track, nil)
  
  if @current_track
    if @current_track.stopped?
      
      # Duplicate and start.
      @current_track = @current_track.dup
      @current_track.start(options)
      
      
      add_track(@current_track)
    else
      raise TrackError, "Cannot continue Track #{@current_track.short_id}, is already running."
    end
  else
    unless track_opt
      raise TaskError, 'No Track given.'
    end
    
    # Duplicate and start.
    @current_track = track_opt.dup
    @current_track.start(options)
    
    add_track(@current_track)
  end
  
  @current_track
end

#duration(options = Hash.new) ⇒ Object

Consumed duration.

Options:

  • ‘:billed` (Boolean)



643
644
645
646
647
648
649
650
651
652
653
 
# File 'lib/timr/model/task.rb', line 643

def duration(options = Hash.new)
  billed_opt = options.fetch(:billed, nil)
  
  duration = Duration.new
  @tracks.each do |track_id, track|
    if billed_opt.nil? || (billed_opt && track.is_billed) || (!billed_opt && !track.is_billed)
      duration += track.duration(options)
    end
  end
  duration
end

#end_datetime(options = Hash.new) ⇒ Object

Uses ‘tracks()` with `options` to filter.

Options:

  • ‘:to`



370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
 
# File 'lib/timr/model/task.rb', line 370

def end_datetime(options = Hash.new)
  to_opt = options.fetch(:to, nil)
  
  # Cache
  # if @end_datetime
  #  return @end_datetime
  # end
  # Cannot use this cache because of :from :to range limitation.
  # It needs always to be direct from child Tracks, because the
  # cache does not know when the begin and end datetimes of the
  # child Tracks change.
  
  # Do not sort. We only need to sort the tracks
  # by end_datetime and take the last.
  options[:sort] = false
  
  last_track = tracks(options)
    .select{ |track_id, track| track.end_datetime } # filter nil
    .sort_by{ |track_id, track| track.end_datetime }
    .to_h # sort_by makes [[]]
    .values # no keys to take the last
    .last
  
  if last_track
    edt = last_track.end_datetime(options)
  end
  
  if to_opt && edt && to_opt < edt
    edt = to_opt
  end
  
  edt
end

#end_datetime_s(options = Hash.new) ⇒ Object

Options:

  • ‘:format`



407
408
409
410
411
412
413
414
415
416
 
# File 'lib/timr/model/task.rb', line 407

def end_datetime_s(options = Hash.new)
  format_opt = options.fetch(:format, HUMAN_DATETIME_FOMRAT)
  
  edt = end_datetime(options)
  if edt
    edt.strftime(format_opt)
  else
    '---'
  end
end

#eql?(task) ⇒ Boolean

Are two Tasks equal?

Uses ID for comparision.

Returns:

  • (Boolean) 


767
768
769
770
771
772
773
 
# File 'lib/timr/model/task.rb', line 767

def eql?(task)
  unless task.is_a?(Task)
    raise TaskError, "task variable must be a Task instance. #{task.class} given."
  end
  
  self.id == task.id
end

#estimated_budge ⇒ Object

Calculate the budge based on estimation.



512
513
514
515
516
517
518
 
# File 'lib/timr/model/task.rb', line 512

def estimated_budge
  if @hourly_rate
    estimation.to_i.to_f / 3600.0 * @hourly_rate
  else
    0.0
  end
end

#estimation ⇒ Object

Get estimation.



469
470
471
 
# File 'lib/timr/model/task.rb', line 469

def estimation
  @estimation
end

#estimation=(estimation) ⇒ Object

Set estimation.

Either using a Duration instance, Integer or a String like ‘2h 30m`. Estimation is parsed by [chronic_duration](github.com/henrypoydar/chronic_duration).

Examples:

  • ‘-e 2:10:5`

    Sets Estimation to 2h 10m 5s.

  • ‘-e ’2h 10m 5s’‘

    Sets Estimation to 2h 10m 5s.

Use ‘+` or `-` to calculate with Estimation Times:

  • ‘-e ’-45m’‘

    Subtracts 45 minutes from the original Estimation.

  • ‘-e ’+1h 30m’‘

    Adds 1 hour 30 minutes to the original Estimation.

See [chronic_duration](github.com/henrypoydar/chronic_duration) for more examples.



439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
 
# File 'lib/timr/model/task.rb', line 439

def estimation=(estimation)
  case estimation
  when String
    # Cannot use estimation.strip! because frozen.
    estimation = estimation.strip
    
    if estimation[0] == '+'
      estimation = estimation[1..-1]
      @estimation += Duration.parse(estimation)
    elsif estimation[0] == '-'
      estimation = estimation[1..-1]
      @estimation -= Duration.parse(estimation)
    else
      @estimation = Duration.parse(estimation)
    end
  when Integer
    @estimation = Duration.new(estimation)
  when Duration
    @estimation = estimation
  when nil
    @estimation = estimation
  else
    raise TaskError, "estimation needs to be an instance of String, Integer, Duration or nil, #{estimation.class} given."
  end
  
  # Mark Task as changed.
  changed
end

#estimation_s ⇒ Object

Get estimation as String.



474
475
476
477
478
479
480
 
# File 'lib/timr/model/task.rb', line 474

def estimation_s
  if @estimation
    @estimation.to_human_s
  else
    '---'
  end
end

#find_track_by_id(track_id) ⇒ Object

Find a Track by ID even if the ID is not 40 characters long. When the ID is 40 characters long ‘@tracks` is faster. ;)



739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
 
# File 'lib/timr/model/task.rb', line 739

def find_track_by_id(track_id)
  track_id_len = track_id.length
  
  # puts "search track id '#{track_id}'"
  
  if track_id_len < 40
    found_track_id = nil
    @tracks.keys.each do |key|
      if track_id == key[0, track_id_len]
        if found_track_id
          raise TrackError, "Track ID '#{track_id}' is not a unique identifier."
        else
          found_track_id = key
          
          # Do not break the loop here.
          # Iterate all keys to make sure the ID is unique.
        end
      end
    end
    track_id = found_track_id
  end
  
  @tracks[track_id]
end

#formatted(options = Hash.new) ⇒ Object

Return formatted String.

Options:

  • ‘:format`

  • ‘:prefix` - Default: `%`

Format:

  • ‘%id` - ID

  • ‘%sid` - Short ID

  • ‘%fid` - Foreign ID

  • ‘%n` - Name

  • ‘%d` - Description

  • ‘%ds` - Duration Seconds

  • ‘%dh` - Duration Human Format



962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
 
# File 'lib/timr/model/task.rb', line 962

def formatted(options = Hash.new)
  format = options.fetch(:format, '')
  prefix = options.fetch(:prefix, '%')
  
  formatted_s = format
    .gsub("#{prefix}id", self.id)
    .gsub("#{prefix}sid", self.short_id ? self.short_id : '')
    .gsub("#{prefix}fid", self.foreign_id ? self.foreign_id : '')
    .gsub("#{prefix}n", self.name ? self.name : '')
    .gsub("#{prefix}ds", self.duration(options).to_s)
  
  duration_human = self.duration(options).to_human
  if duration_human
    formatted_s.gsub!('%dh', duration_human)
  else
    formatted_s.gsub!('%dh', '')
  end
  
  # Must not before %dh and %ds.
  formatted_s.gsub!("#{prefix}d", self.description ? self.description : '')
  
  formatted_s
end

#id_foreign_or_short ⇒ Object

Get Foreign ID or Short ID.



33
34
35
 
# File 'lib/timr/model/task.rb', line 33

def id_foreign_or_short
  @foreign_id ? @foreign_id : short_id
end

#inspect ⇒ Object 



986
987
988
 
# File 'lib/timr/model/task.rb', line 986

def inspect
  "#<Task_#{short_id} tracks=#{@tracks.count}>"
end

#is_billed=(is_billed) ⇒ Object

Set is_billed.



731
732
733
734
735
 
# File 'lib/timr/model/task.rb', line 731

def is_billed=(is_billed)
  @tracks.each do |track_id, track|
    track.is_billed = is_billed
  end
end

#loss_budge ⇒ Object

Calculates the budge loss when a Flat Rate is used and the consumed duration is greater than the estimation.



521
522
523
524
525
526
527
528
529
530
531
 
# File 'lib/timr/model/task.rb', line 521

def loss_budge
  if @has_flat_rate && @hourly_rate
    if duration > estimation
      (duration - estimation).to_i.to_f / 3600.0 * @hourly_rate
    else
      0.0
    end
  else
    0.0
  end
end

#move_track(track, target_task) ⇒ Object

Move a Track to another Task.



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/timr/model/task.rb', line 107

def move_track(track, target_task)
  if eql?(target_task)
    return false
  end
  
  unless remove_track(track)
    return false
  end
  
  set_as_current_track = false
  if @current_track && @current_track.eql?(track)
    @current_track = nil
    set_as_current_track = true
  end
  
  target_task.add_track(track, set_as_current_track)
  
  true
end

#name(max_length = nil) ⇒ Object

Get name.



53
54
55
56
57
58
59
 
# File 'lib/timr/model/task.rb', line 53

def name(max_length = nil)
  name = @name
  if name && max_length && name.length > max_length + 2
    name = name[0, max_length] << '...'
  end
  name
end

#name=(name) ⇒ Object

Set name.



45
46
47
48
49
50
 
# File 'lib/timr/model/task.rb', line 45

def name=(name)
  @name = name
  
  # Mark Task as changed.
  changed
end

#name_s(max_length = nil) ⇒ Object

Get name or ‘—` if name is not set.



62
63
64
65
66
67
68
69
 
# File 'lib/timr/model/task.rb', line 62

def name_s(max_length = nil)
  s = name(max_length)
  if s.nil?
    '---'
  else
    s
  end
end

#pause(options = Hash.new) ⇒ Object

Pauses a current running Track.



595
596
597
598
599
600
601
602
603
604
 
# File 'lib/timr/model/task.rb', line 595

def pause(options = Hash.new)
  if @current_track
    @current_track.stop(options)
    
    # Mark Task as changed.
    changed
    
    @current_track
  end
end

#remaining_time ⇒ Object

Get the remaining Time of estimation.

Returns a Duration instance.



676
677
678
679
680
 
# File 'lib/timr/model/task.rb', line 676

def remaining_time
  if @estimation
    estimation - duration
  end
end

#remaining_time_percent ⇒ Object

Get the remaining Time as percent.



696
697
698
699
700
701
 
# File 'lib/timr/model/task.rb', line 696

def remaining_time_percent
  rmt = remaining_time
  if rmt && @estimation
    (rmt.to_i.to_f / @estimation.to_i.to_f) * 100.0
  end
end

#remaining_time_percent_s ⇒ Object

Get the remaining Time Percent as String.



704
705
706
707
708
709
710
711
 
# File 'lib/timr/model/task.rb', line 704

def remaining_time_percent_s
  rmtp = remaining_time_percent
  if rmtp
    '%.1f %%' % [rmtp]
  else
    '---'
  end
end

#remaining_time_s ⇒ Object

Get the remaining Time as Human String.

  • Like ‘2h 30m`.

  • Or ‘—` when `@estimation` is `nil`.



686
687
688
689
690
691
692
693
 
# File 'lib/timr/model/task.rb', line 686

def remaining_time_s
  rmt = remaining_time
  if rmt
    rmt.to_human_s
  else
    '---'
  end
end

#remove_track(track) ⇒ Object

Remove a Track.



94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/timr/model/task.rb', line 94

def remove_track(track)
  track.task = nil
  
  if @tracks.delete(track.id)
    # Mark Task as changed.
    changed
  else
    # Track is not assiged to this Task.
    false
  end
end

#reset ⇒ Object 



127
128
129
130
131
132
133
134
 
# File 'lib/timr/model/task.rb', line 127

def reset
  if @current_track
    @current_track = nil
    
    # Mark Task as changed.
    changed
  end
end

#start(options = Hash.new) ⇒ Object

Start a new Track by given ‘options`.

Options:

  • ‘:foreign_id` (String)

  • ‘:track_id` (String)

  • ‘:no_stop` (Boolean)



540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
 
# File 'lib/timr/model/task.rb', line 540

def start(options = Hash.new)
  foreign_id_opt = options.fetch(:foreign_id, nil)
  track_id_opt = options.fetch(:track_id, nil)
  
  # Used by Push.
  no_stop_opt = options.fetch(:no_stop, false)
  
  unless no_stop_opt
    # End current Track before starting a new one.
    # Leave options empty here for stop().
    stop
  end
  
  if foreign_id_opt && @foreign_id.nil?
    @foreign_id = foreign_id_opt
  end
  
  if track_id_opt
    found_track = find_track_by_id(track_id_opt)
    if found_track
      
      @current_track = found_track.dup
    else
      raise TrackError, "No Track found for Track ID '#{track_id_opt}'."
    end
  else
    @current_track = Track.new
    @current_track.task = self
  end
  
  @tracks[@current_track.id] = @current_track
  
  # Mark Task as changed.
  changed
  
  @current_track.start(options)
  @current_track
end

#status ⇒ Object

Get Task status as Status instance.



714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
 
# File 'lib/timr/model/task.rb', line 714

def status
  stati = @tracks.map{ |track_id, track| track.status.short_status }.to_set
  
  if @tracks.count == 0
    status = ?-
  elsif stati.include?(?R)
    status = ?R
  elsif stati.include?(?S)
    status = ?S
  else
    status = ?U
  end
  
  Status.new(status)
end

#stop(options = Hash.new) ⇒ Object

Stops a current running Track.



580
581
582
583
584
585
586
587
588
589
590
591
592
 
# File 'lib/timr/model/task.rb', line 580

def stop(options = Hash.new)
  if @current_track
    @current_track.stop(options)
    
    # Reset current Track variable.
    @current_track = nil
    
    # Mark Task as changed.
    changed
  end
  
  nil
end

#to_compact_array ⇒ Object

Used to print informations to STDOUT.



806
807
808
809
810
811
812
813
814
815
816
817
818
 
# File 'lib/timr/model/task.rb', line 806

def to_compact_array
  full_id = self.foreign_id ? self.foreign_id : self.short_id
  
  to_ax = Array.new
  to_ax << 'Task: %s %s' % [full_id, self.name]
  if self.description
    to_ax << 'Description: %s' % [self.description]
  end
  if self.estimation
    to_ax << 'Estimation: %s' % [self.estimation.to_human_s]
  end
  to_ax
end

#to_compact_str ⇒ Object

Used to print informations to STDOUT.



801
802
803
 
# File 'lib/timr/model/task.rb', line 801

def to_compact_str
  to_compact_array.join("\n")
end

#to_detailed_array(options = Hash.new) ⇒ Object

Used to print informations to STDOUT.

Options:

  • ‘:full_id` (Boolean) Show full Task ID.



830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
 
# File 'lib/timr/model/task.rb', line 830

def to_detailed_array(options = Hash.new)
  full_id_opt = options.fetch(:full_id, false)
  
  full_id = full_id_opt ? self.id : self.short_id
  
  to_ax = Array.new
  
  to_ax << 'Task: %s' % [full_id]
  
  if self.foreign_id
    to_ax << 'Foreign ID: %s' % [self.foreign_id]
  end
  
  to_ax << 'Name: %s' % [self.name]
  
  if self.description
    to_ax << 'Description: %s' % [self.description]
  end
  
  # Duration
  duration_human = self.duration.to_human_s
  to_ax << 'Duration: %s' % [duration_human]
  
  duration_man_days = self.duration.to_man_days
  if duration_human != duration_man_days
    to_ax << 'Man Unit: %s' % [duration_man_days]
  end
  
  # Billed Duration
  billed_duration_human = self.billed_duration.to_human
  to_ax << 'Billed   Duration: %s' % [billed_duration_human]
  
  # Unbilled Duration
  unbilled_duration_human = self.unbilled_duration.to_human
  to_ax << 'Unbilled Duration: %s' % [unbilled_duration_human]
  
  if self.estimation
    to_ax << 'Estimation:     %s' % [self.estimation.to_human]
    
    to_ax << 'Time Remaining: %s (%s)' % [self.remaining_time_s, self.remaining_time_percent_s]
    
    bar_options = {
      :total => self.estimation.to_i,
      :progress => self.duration.to_i,
      :length => 50,
      :progress_mark => '#',
      :remainder_mark => '-',
    }
    bar = ProgressBar.new(bar_options)
    
    to_ax << '                |%s|' % [bar.render]
  end
  
  if self.hourly_rate
    to_ax << 'Hourly Rate:     %.2f' % [self.hourly_rate]
    to_ax << 'Flat Rate:       %s' % [@has_flat_rate ? 'Yes' : 'No']
    
    to_ax << 'Consumed Budge:  %.2f' % [self.consumed_budge]
    
    if self.estimation
      to_ax << 'Estimated Budge: %.2f' % [self.estimated_budge]
    end
    
    if @has_flat_rate
      to_ax << 'Loss Budge:      %.2f' % [self.loss_budge]
    end
  end
  
  tracks = self.tracks
  first_track = tracks
    .select{ |track_id, track| track.begin_datetime }
    .sort_by{ |track_id, track| track.begin_datetime }
    .to_h
    .values
    .first
  if first_track
    to_ax << 'Begin Track: %s  %s' % [first_track.short_id, first_track.begin_datetime_s]
  end
  
  last_track = tracks
    .select{ |track_id, track| track.end_datetime }
    .sort_by{ |track_id, track| track.end_datetime }
    .to_h
    .values
    .last
  if last_track
    to_ax << 'End   Track: %s  %s' % [last_track.short_id, last_track.end_datetime_s]
  end
  
  status = self.status.colorized
  to_ax << 'Status: %s' % [status]
  
  if @current_track
    to_ax << 'Current Track: %s %s' % [@current_track.short_id, @current_track.title]
  end
  
  tracks_count = tracks.count
  to_ax << 'Tracks:          %d' % [tracks_count]
  
  billed_tracks_count = tracks({:billed => true}).count
  to_ax << 'Billed Tracks:   %d' % [billed_tracks_count]
  
  unbilled_tracks_count = tracks({:billed => false}).count
  to_ax << 'Unbilled Tracks: %d' % [unbilled_tracks_count]
  
  if tracks_count > 0 && @tracks_opt # --tracks
    to_ax << 'Track IDs: %s' % [tracks.map{ |track_id, track| track.short_id }.join(' ')]
  end
  
  if self.file_path
    to_ax << 'File path: %s' % [self.file_path]
  end
  
  to_ax
end

#to_detailed_str ⇒ Object

Used to print informations to STDOUT.



821
822
823
 
# File 'lib/timr/model/task.rb', line 821

def to_detailed_str
  to_detailed_array.join("\n")
end

#to_s ⇒ Object

To String



776
777
778
 
# File 'lib/timr/model/task.rb', line 776

def to_s
  "Task_#{short_id}"
end

#to_track_array(options = Hash.new) ⇒ Object

Use to print informations for Track.

Options:

  • ‘:full_id` (Boolean) Show full Task ID.



785
786
787
788
789
790
791
792
793
794
795
796
797
798
 
# File 'lib/timr/model/task.rb', line 785

def to_track_array(options = Hash.new)
  full_id_opt = options.fetch(:full_id, false) # @TODO full_id unit test
  
  full_id = full_id_opt ? self.id : ( self.foreign_id ? self.foreign_id : self.short_id )
  
  name_a = ['Task:', full_id]
  if self.name
    name_a << self.name
  end
  
  to_ax = Array.new
  to_ax << name_a.join(' ')
  to_ax
end

#tracks(options = Hash.new) ⇒ Object

Select Track by Time Range and/or Status.

Options:

  • ‘:from`, `:to` limit the begin and end datetimes to a specific range.

  • ‘:status` filter Tracks by Short Status.

  • ‘:billed` filter Tracks by is_billed flag.

- ‘true` filter billed Tracks. - `false` filter unbilled Tracks. - `nil` filter off.

Fixed Start and End (‘from != nil && to != nil`)

“‘ Selected Range |———-| Track A ----------------- Track B ------ Track C ------------ Track D ---- Track E --- Track F --- “`

  • Track A is bigger then the Options range. Take it.

  • Track B ends in the Options range. Take it.

  • Track C starts in the Options range. Take it.

  • Track D starts and ends within the Options range. Definitely take this.

  • Track E is out-of-score. Ignore it.

  • Track F is out-of-score. Ignore it.

Open End (‘to == nil`)

Take all except Track E.

“‘ Selected Range |———-> Track A ----------------- Track B ------ Track C ------------ Track D ---- Track E --- Track F --- “`

Open Start (‘from == nil`)

Take all except Track F.

“‘ Selected Range <———-| Track A ----------------- Track B ------ Track C ------------ Track D ---- Track E --- Track F --- “`



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/timr/model/task.rb', line 195

def tracks(options = Hash.new)
  from_opt = options.fetch(:from, nil)
  to_opt = options.fetch(:to, nil)
  status_opt = options.fetch(:status, nil)
  sort_opt = options.fetch(:sort, true)
  billed_opt = options.fetch(:billed, nil)
  
  if status_opt
    case status_opt
    when String
      status_opt = [status_opt]
    when Array
      # OK
    else
      raise TaskError, ":status needs to be an instance of String or Array, #{status_opt.class} given."
    end
  end
  
  if from_opt && to_opt && from_opt > to_opt
    raise TaskError, 'From cannot be bigger than To.'
  end
  
  filtered_tracks = Hash.new
  if from_opt.nil? && to_opt.nil?
    # Take all Tracks.
    filtered_tracks = @tracks.select{ |track_id, track|
      # Filter Tracks with no Begin DateTime.
      # This can happen when 'timr track add' without any DateTime.
      !track.begin_datetime.nil?
    }
  elsif !from_opt.nil? && to_opt.nil?
    # Open End (to_opt == nil)
    filtered_tracks = @tracks.select{ |track_id, track|
      bdt = track.begin_datetime
      edt = track.end_datetime || Time.now
      
      bdt && ( \
        # Track A, B
        bdt <  from_opt && edt >  from_opt || \
        
        # Track C, D, F
        bdt >= from_opt && edt >= from_opt
      )
    }
  elsif from_opt.nil? && !to_opt.nil?
    # Open Start (from_opt == nil)
    filtered_tracks = @tracks.select{ |track_id, track|
      bdt = track.begin_datetime
      edt = track.end_datetime || Time.now
      
      bdt && ( \
        # Track B, D, E
        bdt <  to_opt && edt <= to_opt || \
        
        # Track A, C
        bdt <  to_opt && edt >  to_opt
      )
    }
  elsif !from_opt.nil? && !to_opt.nil?
    # Fixed Start and End (from_opt != nil && to_opt != nil)
    filtered_tracks = @tracks.select{ |track_id, track|
      bdt = track.begin_datetime
      edt = track.end_datetime || Time.now
      
      bdt && ( \
        # Track D
        bdt >= from_opt && edt <= to_opt || \
        
        # Track A
        bdt <  from_opt && edt >  to_opt || \
        
        # Track B
        bdt <  from_opt && edt <= to_opt && edt > from_opt || \
        
        # Track C
        bdt >= from_opt && edt >  to_opt && bdt < to_opt
      )
    }
  else
    raise ThisShouldNeverHappenError, 'Should never happen, bug shit happens.'
  end
  
  if status_opt
    filtered_tracks.select!{ |track_id, track|
      status_opt.include?(track.status.short_status)
    }
  end
  
  unless billed_opt.nil?
    if billed_opt
      filtered_tracks.select!{ |track_id, track|
        track.is_billed
      }
    else
      filtered_tracks.select!{ |track_id, track|
        !track.is_billed
      }
    end
  end
  
  if sort_opt
    filtered_tracks.sort{ |t1, t2|
      t1 = t1.last
      t2 = t2.last
      
      cmp1 = t1.begin_datetime <=> t2.begin_datetime
      if cmp1.nil? || cmp1 == 0
        t1.end_datetime <=> t2.end_datetime
      else
        cmp1
      end
    }.to_h
  else
    filtered_tracks
  end
end

#unbilled_duration(options = Hash.new) ⇒ Object

Alias for ‘duration` method.

Options:

  • ‘:billed` (Boolean)



669
670
671
 
# File 'lib/timr/model/task.rb', line 669

def unbilled_duration(options = Hash.new)
  duration(options.merge({:billed => false}))
end