Class: TaskJuggler::ResourceScenario

Inherits:
ScenarioData show all
Defined in:
lib/taskjuggler/ResourceScenario.rb

Instance Attribute Summary

Attributes inherited from ScenarioData

#property

Instance Method Summary collapse

Methods inherited from ScenarioData

#a, #deep_clone, #error, #info, #warning

Constructor Details

#initialize(resource, scenarioIdx, attributes) ⇒ ResourceScenario

Returns a new instance of ResourceScenario.



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 21

def initialize(resource, scenarioIdx, attributes)
  super

  # Scoreboard may be nil, a Task, or a bit vector encoded as an Integer
  # nil:        Value has not been determined yet.
  # Task:       A reference to a Task object
  # Bit 0:      Reserved
  # Bit 1:      0: Work time (as defined by working hours)
  #             1: No work time (as defined by working hours)
  # Bit 2 - 5:  See Leave class for acutal values.
  # Bit 6 - 7:  Reserved
  # Bit 8:      0: No global override
  #             1: Override global setting
  # The scoreboard is only created when needed to save memory for projects
  # which read-in the coporate employee database but only need a small
  # subset.
  @scoreboard = nil

  # The index of the earliest booked time slot.
  @firstBookedSlot = nil
  # Same but for each assigned resource.
  @firstBookedSlots = {}
  # The index of the last booked time Slot.
  @lastBookedSlot = nil
  # Same but for each assigned resource.
  @lastBookedSlots = {}

  # First available slot of the resource.
  @minslot = nil
  # Last available slot of the resource.
  @maxslot = nil

  # Attributed are only really created when they are accessed the first
  # time. So make sure some needed attributes really exist so we don't
  # have to check for existance each time we access them.
  %w( alloctdeffort chargeset criticalness directreports duties efficiency
      effort limits managers rate reports shifts
      leaves leaveallowances workinghours ).each do |attr|
    @property[attr, @scenarioIdx]
  end

  @dCache = DataCache.instance
end

Instance Method Details

#allocated?(iv, task = nil) ⇒ Boolean

Returns true if the resource or any of its children is allocated during the period specified with the TimeInterval iv. If task is not nil only allocations to this tasks are respected.

Returns:

  • (Boolean) 


652
653
654
655
656
657
658
659
660
661
662
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 652

def allocated?(iv, task = nil)
  return false if task && !@duties.include?(task)

  startIdx = @project.dateToIdx(iv.start)
  endIdx = @project.dateToIdx(iv.end)

  startIdx, endIdx = fitIndicies(startIdx, endIdx, task)
  return false if startIdx >= endIdx

  return allocatedSub(startIdx, endIdx, task)
end

#available?(sbIdx) ⇒ Boolean

Returns true if the resource is available at the time specified by sbIdx.

Returns:

  • (Boolean) 


162
163
164
165
166
167
168
169
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 162

def available?(sbIdx)
  return false unless @scoreboard[sbIdx].nil?

  limits = @limits
  return false if limits && !limits.ok?(sbIdx)

  true
end

#book(sbIdx, task, force = false) ⇒ Object

Book the slot indicated by the scoreboard index sbIdx for Task task. If force is true, overwrite the existing booking for this slot. The method returns true if the slot was available.



187
188
189
190
191
192
193
194
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
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 187

def book(sbIdx, task, force = false)
  return false if !force && !available?(sbIdx)

  # Make sure the task is in the list of duties.
  unless @duties.include?(task)
    @duties << task
  end

  #puts "Booking resource #{@property.fullId} at " +
  #     "#{@scoreboard.idxToDate(sbIdx)}/#{sbIdx} for task #{task.fullId}\n"
  @scoreboard[sbIdx] = task
  # Track the total allocated slots for this resource.
  @effort += @efficiency
  @limits.inc(sbIdx) if @limits
  task.incLimits(@scenarioIdx, sbIdx, @property)

  # Scoreboard iterations are fairly expensive but they are very frequent
  # operations in later processing. To limit the interations to the
  # relevant intervals, we store the interval for all bookings and for
  # each individual task.
  if @firstBookedSlot.nil? || @firstBookedSlot > sbIdx
    @firstBookedSlot = @firstBookedSlots[task] = sbIdx
  elsif @firstBookedSlots[task].nil? || @firstBookedSlots[task] > sbIdx
    @firstBookedSlots[task] = sbIdx
  end
  if @lastBookedSlot.nil? || @lastBookedSlot < sbIdx
    @lastBookedSlot = @lastBookedSlots[task] = sbIdx
  elsif @lastBookedSlots[task].nil? || @lastBookedSlots[task] < sbIdx
    @lastBookedSlots[task] = sbIdx
  end

  true
end

#bookBooking(sbIdx, booking) ⇒ Object 



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
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 221

def bookBooking(sbIdx, booking)
  initScoreboard if @scoreboard.nil?

  unless @scoreboard[sbIdx].nil?
    if booked?(sbIdx)
      error('booking_conflict',
            "Resource #{@property.fullId} has multiple conflicting " +
            "bookings for #{@scoreboard.idxToDate(sbIdx)}. The " +
            "conflicting tasks are #{@scoreboard[sbIdx].fullId} and " +
            "#{booking.task.fullId}.", booking.sourceFileInfo)
    end
    val = @scoreboard[sbIdx]
    if ((val & 2) != 0 && booking.overtime < 1)
      # The booking is blocked due to the overtime attribute. Now let's
      # see if the user wants to be warned about it.
      if booking.sloppy < 1
        error('booking_no_duty',
              "Resource #{@property.fullId} has no duty at " +
              "#{@scoreboard.idxToDate(sbIdx)}.",
              booking.sourceFileInfo)
      end
      return false
    end
    if ((val & 0x3C) != 0 && booking.overtime < 2)
      # The booking is blocked due to the overtime attribute. Now let's
      # see if the user wants to be warned about it.
      if booking.sloppy < 2
        error('booking_on_vacation',
              "Resource #{@property.fullId} is on vacation at " +
              "#{@scoreboard.idxToDate(sbIdx)}.",
              booking.sourceFileInfo)
      end
      return false
    end
  end

  book(sbIdx, booking.task, true)
end

#booked?(sbIdx) ⇒ Boolean

Return true if the resource is booked for a tasks at the time specified by sbIdx.

Returns:

  • (Boolean) 


173
174
175
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 173

def booked?(sbIdx)
  @scoreboard[sbIdx].is_a?(Task)
end

#bookedEffort ⇒ Object

too expensive to propagate this to the group resources on every booking. If a value for a group effort is needed, it’s computed here.



263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 263

def bookedEffort
  if @property.leaf?
    @effort
  else
    effort = 0
    @property.kids.each do |r|
      effort += r.bookedEffort(@scenarioIdx)
    end
    effort
  end
end

#bookedTask(sbIdx) ⇒ Object

Return the Task that this resource is booked for at the time specified by sbIdx. If not booked to a task, nil is returned.



179
180
181
182
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 179

def bookedTask(sbIdx)
  return nil unless (sb = @scoreboard[sbIdx]).is_a?(Task)
  sb
end

#calcCriticalness ⇒ Object

The criticalness of a resource is a measure for the probabilty that all allocations can be fullfilled. The smaller the value, the more likely will the tasks get the resource. A value above 1.0 means that statistically some tasks will not get their resources. A value between 0 and 1 implies no guarantee, though.



77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 77

def calcCriticalness
  if @scoreboard.nil?
    # Resources that are not allocated are not critical at all.
    @criticalness = 0.0
  else
    freeSlots = 0
    @scoreboard.each do |slot|
      freeSlots += 1 if slot.nil?
    end
    @criticalness = freeSlots == 0 ? 1.0 :
      @alloctdeffort / freeSlots
  end
end

#collectLeaveIntervals(iv, type) ⇒ Object

Return a list of scoreboard intervals that are at least minDuration long and only contain leave slots of the given type. The result is an Array of

start, end

TjTime values.



748
749
750
751
752
753
754
755
756
757
758
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 748

def collectLeaveIntervals(iv, type)
  # Time-off intervals are only useful for leaf resources. Group resources
  # would just default to the global working hours.
  return [] unless @property.leaf?

  initScoreboard if @scoreboard.nil?

  @scoreboard.collectIntervals(iv, 60 * 60) do |val|
    val.is_a?(Integer) && (val & 0x3E) == (Leave::Types[type] << 2)
  end
end

#collectTimeOffIntervals(iv, minDuration) ⇒ Object

Return a list of scoreboard intervals that are at least minDuration long and contain only off-duty and leave slots. The result is an Array of

start, end

TjTime values.



733
734
735
736
737
738
739
740
741
742
743
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 733

def collectTimeOffIntervals(iv, minDuration)
  # Time-off intervals are only useful for leaf resources. Group resources
  # would just default to the global working hours.
  return [] unless @property.leaf?

  initScoreboard if @scoreboard.nil?

  @scoreboard.collectIntervals(iv, minDuration) do |val|
    val.is_a?(Integer) && (val & 0x3E) != 0
  end
end

#cost(startIdx, endIdx, task = nil) ⇒ Object

Returns the cost for using this resource during the specified TimeInterval period. If a Task task is provided, only the work on this particular task is considered.



645
646
647
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 645

def cost(startIdx, endIdx, task = nil)
  getAllocatedTime(startIdx, endIdx, task) * @rate
end

#finishScheduling ⇒ Object

This method does some housekeeping work after the scheduling is completed. It’s meant to be called for top-level resources and then recursively descends into all child resources.



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 137

def finishScheduling
  # Recursively descend into all child resources.
  @property.children.each do |resource|
    resource.finishScheduling(@scenarioIdx)
  end

  # Add the parent tasks of each task to the duties list.
  @duties.each do |task|
    task.ancestors(true).each do |pTask|
      @duties << pTask unless @duties.include?(pTask)
    end
  end

  # Add the assigned task to the parent(s) resource duties list.
  @property.parents.each do |pResource|
    @duties.each do |task|
      unless pResource['duties', @scenarioIdx].include?(task)
        pResource['duties', @scenarioIdx] << task
      end
    end
  end
end

#getAllocatedSlots(startIdx, endIdx, task = nil) ⇒ Object

Count the booked slots between the start and end index. If task is not nil count only those slots that are assigned to this particular task or any of its sub tasks.



763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 763

def getAllocatedSlots(startIdx, endIdx, task = nil)
  # If there is no scoreboard, we don't have any allocations.
  return 0 unless @scoreboard

  startIdx, endIdx = fitIndicies(startIdx, endIdx, task)
  return 0 if startIdx >= endIdx

  bookedSlots = 0
  taskList = task ? task.all : []
  @scoreboard.each(startIdx, endIdx) do |slot|
    if slot.is_a?(Task) && (task.nil? || taskList.include?(slot))
      bookedSlots += 1
    end
  end

  bookedSlots
end

#getAllocatedTime(startIdx, endIdx, task = nil) ⇒ Object

Returns the allocated accumulated time of this resource and its children.



575
576
577
578
579
580
581
582
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 575

def getAllocatedTime(startIdx, endIdx, task = nil)
  treeSum(startIdx, endIdx, task) do
    return 0 if @scoreboard.nil?

    @project.convertToDailyLoad(@project['scheduleGranularity'] *
        getAllocatedSlots(startIdx, endIdx, task))
  end
end

#getBookings(iv = nil, hashByTask = true) ⇒ Object

Iterate over the scoreboard and turn its content into a set of Bookings.

_iv_ can be a TimeInterval to limit the bookings within the provided
period. if _hashByTask_ is true, the result is a Hash of Arrays with
bookings hashed by Task. Otherwise it's just a plain Array with
Bookings.



669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 669

def getBookings(iv = nil, hashByTask = true)
  bookings = hashByTask ? {} : []
  return bookings if @property.container? || @scoreboard.nil? ||
                     @firstBookedSlot.nil? || @lastBookedSlot.nil?

  # To speedup the collection we start with the first booked slot and end
  # with the last booked slot.
  startIdx = @firstBookedSlot
  endIdx = @lastBookedSlot + 1

  # If the user provided a TimeInterval, we only return bookings within
  # this TimeInterval.
  if iv
    ivStartIdx = @project.dateToIdx(iv.start)
    ivEndIdx = @project.dateToIdx(iv.end)
    startIdx = ivStartIdx if ivStartIdx > startIdx
    endIdx = ivEndIdx if ivEndIdx < endIdx
  end

  lastTask = nil
  bookingStart = nil

  startIdx.upto(endIdx) do |idx|
    task = @scoreboard[idx]
    # Now we watch for task changes.
    if task != lastTask ||
       (task.is_a?(Task) && (lastTask.nil? || idx == endIdx))
      if lastTask
        # We've found the end of a task booking series.
        # If we don't have a Booking for the task yet, we create one.
        if hashByTask
          if bookings[lastTask].nil?
            bookings[lastTask] = Booking.new(@property, lastTask, [])
          end
          # Append the new interval to the Booking.
          bookings[lastTask].intervals <<
          TimeInterval.new(@scoreboard.idxToDate(bookingStart),
                           @scoreboard.idxToDate(idx))
        else
          if bookings.empty? || bookings.last.task != lastTask
            bookings << Booking.new(@property, lastTask, [])
          end
          # Append the new interval to the Booking.
          bookings.last.intervals <<
          TimeInterval.new(@scoreboard.idxToDate(bookingStart),
                           @scoreboard.idxToDate(idx))
        end

      end
      # Get ready for the next task booking interval
      if task.is_a?(Task)
        lastTask = task
        bookingStart = idx
      else
        lastTask = bookingStart = nil
      end
    end
  end
  bookings
end

#getEffectiveFreeTime(startIdx, endIdx) ⇒ Object

Return the unallocated work time (in seconds) of the resource and its children.



586
587
588
589
590
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 586

def getEffectiveFreeTime(startIdx, endIdx)
  treeSum(startIdx, endIdx) do
    getFreeSlots(startIdx, endIdx) * @project['scheduleGranularity']
  end
end

#getEffectiveFreeWork(startIdx, endIdx) ⇒ Object

Return the unallocated work of the resource and its children weighted by their efficiency.



594
595
596
597
598
599
600
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 594

def getEffectiveFreeWork(startIdx, endIdx)
  treeSum(startIdx, endIdx) do
    @project.convertToDailyLoad(getFreeSlots(startIdx, endIdx) *
                                @project['scheduleGranularity']) *
                                @efficiency
  end
end

#getEffectiveWork(startIdx, endIdx, task = nil) ⇒ Object

Returns the work of the resource (and its children) weighted by their efficiency. If task is provided, only the work for this task and all its sub tasks are being counted.



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
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 546

def getEffectiveWork(startIdx, endIdx, task = nil)
  # Make sure we have the real Task and not a proxy.
  task = task.ptn if task
  # There can't be any effective work if the start is after the end or the
  # todo list doesn't contain the specified task.
  return 0.0 if startIdx >= endIdx || (task && !@duties.include?(task))
  # Temporary workaround until @duties is fixed again.

  # The unique key we use to address the result in the cache.
  @dCache.cached(self, :ResourceScenarioGetEffectiveWork, startIdx, endIdx,
                 task) do
    work = 0.0
    if @property.container?
      @property.kids.each do |resource|
        work += resource.getEffectiveWork(@scenarioIdx, startIdx, endIdx,
                                          task)
      end
    else
      unless @scoreboard.nil?
        work = @project.convertToDailyLoad(
                 getAllocatedSlots(startIdx, endIdx, task) *
                 @project['scheduleGranularity']) * @efficiency
      end
    end
    work
  end
end

#getFreeSlots(startIdx, endIdx) ⇒ Object

Count the free slots between the start and end index.



799
800
801
802
803
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 799

def getFreeSlots(startIdx, endIdx)
  countSlots(startIdx, endIdx) do |val|
    val.nil?
  end
end

#getLeave(startIdx, endIdx, type) ⇒ Object

Returns the number of leave days for the period described by startIdx and endIdx for the given type of leave.



535
536
537
538
539
540
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 535

def getLeave(startIdx, endIdx, type)
  treeSum(startIdx, endIdx, type) do
    @project.convertToDailyLoad(@project['scheduleGranularity'] *
        getLeaveSlots(startIdx, endIdx, type))
  end
end

#getLeaveSlots(startIdx, endIdx, type) ⇒ Object

Count the number of slots that are work time slots but marked as annual leave.



792
793
794
795
796
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 792

def getLeaveSlots(startIdx, endIdx, type)
  countSlots(startIdx, endIdx) do |val|
    val.is_a?(Integer) && (val & 0x3E) == (Leave::Types[type] << 2)
  end
end

#getMaxSlot ⇒ Object

Get the last available slot of the resource.



822
823
824
825
826
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 822

def getMaxSlot
  initScoreboard unless @maxslot

  @maxslot
end

#getMinSlot ⇒ Object

Get the first available slot of the resource.



815
816
817
818
819
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 815

def getMinSlot
  initScoreboard unless @minslot

  @minslot
end

#getTimeOffDays(startIdx, endIdx) ⇒ Object

Return the number of working days that are blocked by leaves.



603
604
605
606
607
608
609
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 603

def getTimeOffDays(startIdx, endIdx)
  treeSum(startIdx, endIdx) do
    @project.convertToDailyLoad(getTimeOffSlots(startIdx, endIdx) *
                                @project['scheduleGranularity']) *
                                @efficiency
  end
end

#getTimeOffSlots(startIdx, endIdx) ⇒ Object

Count the regular work time slots between the start and end index that have been blocked by leaves.



807
808
809
810
811
812
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 807

def getTimeOffSlots(startIdx, endIdx)
  countSlots(startIdx, endIdx) do |val|
    # Bit 1 needs to be unset and the leave bits must not be 0.
    val.is_a?(Integer) && (val & 0x2) == 0 && (val & 0x3C) != 0
  end
end

#getWorkSlots(startIdx, endIdx) ⇒ Object

Count the number of slots betweend the startIdx and endIdx that can be used for work



783
784
785
786
787
788
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 783

def getWorkSlots(startIdx, endIdx)
  countSlots(startIdx, endIdx) do |val|
    # We count free slots and assigned slots.
    val.nil? || val.is_a?(Task)
  end
end

#prepareScheduling ⇒ Object

This method must be called at the beginning of each scheduling run. It initializes variables used during the scheduling process.



67
68
69
70
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 67

def prepareScheduling
  @effort = 0
  initScoreboard if @property.leaf?
end

#preScheduleCheck ⇒ Object 



131
132
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 131

def preScheduleCheck
end

#query_annualleave(query) ⇒ Object

Compute the annual leave days within the period specified by the query. The result is in days.



277
278
279
280
281
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 277

def query_annualleave(query)
  query.sortable = query.numerical = val =
    getLeave(query.startIdx, query.endIdx, :annual)
  query.string = query.scaleLoad(val)
end

#query_annualleavebalance(query) ⇒ Object 



300
301
302
303
304
305
306
307
308
309
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 300

def query_annualleavebalance(query)
  if @property.leaf?
    leave = getLeave(query.startIdx, query.endIdx, :annual)
    allowanceSlots = @leaveallowances.balance(:annual, query.start,
                                              query.end)
    allowance = @project.slotsToDays(allowanceSlots)
    query.sortable = query.numerical = val = allowance - leave
    query.string = query.scaleLoad(val)
  end
end

#query_annualleavelist(query) ⇒ Object

Compute a list of the annual leave days within the period specified by the query. The result is a list of dates and how much of that day was taken.



286
287
288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 286

def query_annualleavelist(query)
  iv_list = collectLeaveIntervals(Interval.new(query.start, query.end), :annual)
  iv_list.map! do |iv|
    # The interval is at most one working day. We list the date of that
    # day.
    day = iv.start.strftime(@project['timeFormat'])
    # And how much of the working day was taken. A full working day is
    # 1.0, a half working day 0.5.
    days = (iv.end - iv.start) / (60 * 60 * @project['dailyworkinghours'])
    "#{day} (#{'%.1f' % days})"
  end
  query.assignList(iv_list)
end

#query_cost(query) ⇒ Object

Compute the cost generated by this Resource for a given Account during a given interval. If a Task is provided as scopeProperty only the turnover directly assiciated with the Task is taken into account.



315
316
317
318
319
320
321
322
323
324
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 315

def query_cost(query)
  if query.costAccount
    query.sortable = query.numerical = cost =
      turnover(query.startIdx, query.endIdx, query.costAccount,
               query.scopeProperty, true)
    query.string = query.currencyFormat.format(cost)
  else
    query.string = 'No \'balance\' defined!'
  end
end

#query_duties(query) ⇒ Object

A list of the tasks that the resource has been allocated to work on in the report time frame.



328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 328

def query_duties(query)
  list = []
  iv = TimeInterval.new(query.start, query.end)
  @duties.each do |task|
    if task.hasResourceAllocated?(@scenarioIdx, iv, @property)
      if query.listItem
        rti = RichText.new(query.listItem, RTFHandlers.create(@project)).
          generateIntermediateFormat
        unless rti
          error('bad_resource_ts_query',
                "Syntax error in query statement for task attribute " +
                "'resources'.")
        end
        q = query.dup
        q.property = task
        q.scopeProperty = @property
        rti.setQuery(q)
        list << "<nowiki>#{rti.to_s}</nowiki>"
      else
        list << "<nowiki>#{task.name} (#{task.id})</nowiki>"
      end
    end
  end
  query.assignList(list)
end

#query_effort(query) ⇒ Object

The effort allocated to the Resource in the specified interval. In case a Task is given as scope property only the effort allocated to this Task is taken into account.



357
358
359
360
361
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 357

def query_effort(query)
  query.sortable = query.numerical = effort =
    getEffectiveWork(query.startIdx, query.endIdx, query.scopeProperty)
  query.string = query.scaleLoad(effort)
end

#query_effortdone(query) ⇒ Object

The completed (as of ‘now’) effort allocated for the resource in the specified interval. In case a Task is given as scope property only the effort allocated for this Task is taken into account.



366
367
368
369
370
371
372
373
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 366

def query_effortdone(query)
  # For this query, we always override the query period.
  query.sortable = query.numerical = effort =
    getEffectiveWork(@project.dateToIdx(@project['start'], false),
                     @project.dateToIdx(@project['now']),
                     query.scopeProperty)
  query.string = query.scaleLoad(effort)
end

#query_effortleft(query) ⇒ Object

The remaining (as of ‘now’) effort allocated for the resource in the specified interval. In case a Task is given as scope property only the effort allocated for this Task is taken into account.



379
380
381
382
383
384
385
386
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 379

def query_effortleft(query)
  # For this query, we always override the query period.
  query.sortable = query.numerical = effort =
    getEffectiveWork(@project.dateToIdx(@project['now']),
                     @project.dateToIdx(@project['end'], false),
                     query.scopeProperty)
  query.string = query.scaleLoad(effort)
end

#query_freetime(query) ⇒ Object

The unallocated work time of the Resource during the specified interval.



389
390
391
392
393
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 389

def query_freetime(query)
  query.sortable = query.numerical = time =
    getEffectiveFreeTime(query.startIdx, query.endIdx) / (60 * 60 * 24)
  query.string = query.scaleDuration(time)
end

#query_freework(query) ⇒ Object

The unallocated effort of the Resource during the specified interval.



396
397
398
399
400
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 396

def query_freework(query)
  query.sortable = query.numerical = work =
    getEffectiveFreeWork(query.startIdx, query.endIdx)
  query.string = query.scaleLoad(work)
end

#query_fte(query) ⇒ Object

The the Full-time equivalent for the resource or group.



403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 403

def query_fte(query)
  fte = 0.0
  if @property.container?
    # Accumulate the FTEs of all sub-resources.
    @property.kids.each do |resource|
      resource.query_fte(@scenarioIdx, query)
      fte += query.to_num
    end
  else
    # TODO: Getting the globalWorkSlots is relatively expensive. We
    # probably don't need to compute this for every resource.
    globalWorkSlots = @project.getWorkSlots(query.startIdx, query.endIdx)
    workSlots = getWorkSlots(query.startIdx, query.endIdx)
    if globalWorkSlots > 0
      fte = (workSlots.to_f / globalWorkSlots) * @efficiency
    end
  end

  query.sortable = query.numerical = fte
  query.string = query.numberFormat.format(fte)
end

#query_headcount(query) ⇒ Object

The headcount of the resource or group.



426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 426

def query_headcount(query)
  headcount = 0
  if @property.container?
    @property.kids.each do |resource|
      resource.query_headcount(@scenarioIdx, query)
      headcount += query.to_num
    end
  else
    if employed?(@project.dateToIdx(query.start))
      # We only count headcount that is employed at the start date of the
      # query interval.
      headcount += @efficiency.round
    end
  end

  query.sortable = query.numerical = headcount
  query.string = query.numberFormat.format(headcount)
end

#query_rate(query) ⇒ Object

Get the rate of the resource.



446
447
448
449
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 446

def query_rate(query)
  query.sortable = query.numerical = r = rate
  query.string = query.currencyFormat.format(r)
end

#query_revenue(query) ⇒ Object

Compute the revenue generated by this Resource for a given Account during a given interval. If a Task is provided as scopeProperty only the revenue directly associated to this Task is taken into account.



454
455
456
457
458
459
460
461
462
463
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 454

def query_revenue(query)
  if query.revenueAccount
    query.sortable = query.numerical = revenue =
      turnover(query.startIdx, query.endIdx, query.revenueAccount,
               query.scopeProperty)
    query.string = query.currencyFormat.format(revenue)
  else
    query.string = 'No \'balance\' defined!'
  end
end

#query_sickleave(query) ⇒ Object

Compute the sick leave days within the period specified by the query. The result is in days.



467
468
469
470
471
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 467

def query_sickleave(query)
  query.sortable = query.numerical = val =
    getLeave(query.startIdx, query.endIdx, :sick)
  query.string = query.scaleLoad(val)
end

#query_specialleave(query) ⇒ Object

Compute the special leave days within the period specified by the query. The result is in days.



475
476
477
478
479
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 475

def query_specialleave(query)
  query.sortable = query.numerical = val =
    getLeave(query.startIdx, query.endIdx, :special)
  query.string = query.scaleLoad(val)
end

#query_timeoffdays(query) ⇒ Object

The work time of the Resource that was blocked by leaves during the specified TimeInterval. The result is in working days (effort).



483
484
485
486
487
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 483

def query_timeoffdays(query)
  query.sortable = query.numerical = time =
    getTimeOffDays(query.startIdx, query.endIdx)
  query.string = query.scaleLoad(time)
end

#query_unpaidleave(query) ⇒ Object

Compute the unpaid leave days within the period specified by the query. The result is in days.



491
492
493
494
495
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 491

def query_unpaidleave(query)
  query.sortable = query.numerical = val =
    getLeave(query.startIdx, query.endIdx, :unpaid)
  query.string = query.scaleLoad(val)
end

#setDirectReports ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 91

def setDirectReports
  @managers.map! do |managerId|
    # First we need to map 'managerId' to an existing Resource.
    if (manager = @project.resource(managerId)).nil?
      error('resource_id_expected', "#{managerId} is not a defined " +
            'resource.', @sourceFileInfo)
    end
    unless manager.leaf?
      error('manager_is_group',
            "Resource #{@property.fullId} has group #{manager.fullId} " +
            "assigned as manager. Managers must be leaf resources.")
    end
    if manager == @property
      error('manager_is_self',
            "Resource #{@property.fullId} cannot manage itself.")
    end

    # Only leaf resources have reporting lines.
    if @property.leaf?
      # The 'directreports' attribute is the reverse link for the 'managers'
      # attribute. In contrast to the 'managers' attribute, the
      # 'directreports' list has no duplicate entries.
      unless manager['directreports', @scenarioIdx].include?(@property)
        manager['directreports', @scenarioIdx] << @property
      end
    end

    manager
  end
  @managers.uniq!
end

#setReports ⇒ Object 



123
124
125
126
127
128
129
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 123

def setReports
  return unless @directreports.empty?

  @managers.each do |r|
    r.setReports_i(@scenarioIdx, [ @property ])
  end
end

#treeSum(startIdx, endIdx, *args, &block) ⇒ Object

A generic tree iterator that recursively accumulates the result of the block for each leaf object.



499
500
501
502
503
504
505
506
507
508
509
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 499

def treeSum(startIdx, endIdx, *args, &block)
  # Starting with ruby 3.4.0, the out of caller was changed.
  # https://www.ruby-lang.org/en/news/2024/12/25/ruby-3-4-0-released/
  # This ugly bit of code ensure that older versions still work.
  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.4.0')
    cacheTag = caller[0][/'.*'/][1..-2]
  else
    cacheTag = "#{self.class}##{caller[0][/`.*'/][1..-2]}"
  end
  treeSumR(cacheTag, startIdx, endIdx, *args, &block)
end

#treeSumR(cacheTag, startIdx, endIdx, *args, &block) ⇒ Object

Recursing method for treeSum.



512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 512

def treeSumR(cacheTag, startIdx, endIdx, *args, &block)
  # Check if the value to be computed is already in the data cache. If so,
  # return it. Otherwise we have to compute it first and then store it in
  # the cache. We use the signature of the method that called treeSum()
  # and its arguments together with 'self' as index to the cache.
  @dCache.cached(self, cacheTag, startIdx, endIdx, *args) do
    if @property.container?
      sum = 0.0
      # Iterate over all the kids and accumulate the result of the
      # recursively called method.
      @property.kids.each do |resource|
        sum += resource.treeSumR(@scenarioIdx, cacheTag, startIdx, endIdx,
                                 *args, &block)
      end
      sum
    else
      instance_eval(&block)
    end
  end
end

#turnover(startIdx, endIdx, account, task = nil, includeKids = false) ⇒ Object 



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
637
638
639
640
 
# File 'lib/taskjuggler/ResourceScenario.rb', line 611

def turnover(startIdx, endIdx, , task = nil, includeKids = false)
  amount = 0.0
  if @property.container? && includeKids
    @property.kids.each do |child|
      amount += child.turnover(@scenarioIdx, startIdx, endIdx, ,
                               task)
    end
  else
    if task
      # If we have a known task, we only include the amount that is
      # specific to this resource, this task and the chargeset of the
      # task.
      amount += task.turnover(@scenarioIdx, startIdx, endIdx, ,
                              @property)
    elsif !@chargeset.empty?
      # If no tasks was provided, we include the amount of this resource,
      # weighted by the chargeset of this resource.
      totalResourceCost = cost(startIdx, endIdx)
      @chargeset.each do |set|
        set.each do |accnt, share|
          if share > 0.0 && (accnt ==  || accnt.isChildOf?())
            amount += totalResourceCost * share
          end
        end
      end
    end
  end

  amount
end