taskjuggler 0.0.2

data/lib/Query.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Query.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'TjException'
+
+class TaskJuggler
+
+  # A query can be used to retrieve any property attribute after the scheduling
+  # run has been completed. It is possible to make a Query before the scheduling
+  # run has been completed, but it only produces good results for static
+  # attributes. And for such queries, the PropertyTreeNode.get and [] functions
+  # are a lot more efficient.
+  # # When constructing a Query, a set of variables need to be set that is
+  # sufficient enough to identify a unique attribute. Some attribute are
+  # computed dynamically and further variables such as a start and end time will
+  # be incorporated into the result computation.
+  #
+  # The result is returned as String (Query#result), in numerical form
+  # (Query#numericalResult) if available as number, and as an entity that can be
+  # used for sorting (Query#sortableResult). To get the result, Query#process
+  # needs to be called. In case an error occured, Query#ok is set to false and
+  # Query#errorMessage contains an error message.
+  class Query
+
+    attr_accessor :project, :propertyType, :propertyId, :property,
+                  :scopePropertyType, :scopePropertyId, :scopeProperty,
+                  :attributeId, :scenarioIdx, :start, :end, :startIdx, :endIdx,
+                  :numberFormat, :currencyFormat, :costAccount, :revenueAccount,
+                  :loadUnit,
+                  :result, :numericalResult, :sortableResult, :ok, :errorMessage
+
+    # Create a new Query object. The _parameters_ need to be sufficent to
+    # uniquely identify an attribute.
+    def initialize(parameters = { })
+      ps = %w( project propertyType propertyId property scopePropertyId
+               scopeProperty attributeId scenarioIdx start end startIdx endIdx
+               loadUnit numberFormat currencyFormat costAccount revenueAccount)
+      ps.each do |p|
+        instance_variable_set('@' + p, parameters[p] ? parameters[p] : nil)
+      end
+
+      reset
+    end
+
+    # Queries object can be reused. Calling this function will clear the query
+    # result data.
+    def reset
+      @result = nil
+      @numericalResult = nil
+      @sortableResult = nil
+      @loadUnit = :days
+      @ok = nil
+      @errorMessage = nil
+    end
+
+    # This method tries to resolve the query and return a result. In case it
+    # finds an attribute that matches the query, it returns true; false
+    # otherwise. The actual result data is put into the Query object.
+    def process
+      begin
+        # Resolve property reference from property ID.
+        if !@property.nil? && !@propertyId.nil?
+          @property = resolvePropertyId(@propertyType, @propertyId)
+        end
+        # Same for the scope property.
+        if !@scopeProperty.nil? && !@scopePropertyId.nil?
+          @scopeProperty = resolvePropertyId(@scopePropertyType, @scopePropertyId)
+        end
+        # Make sure the have a reference to the project.
+        @project = @property.project unless @project
+
+        @startIdx = @project.dateToIdx(@start, true) if @startIdx.nil? && @start
+        @endIdx = @project.dateToIdx(@end, true) - 1 if @endIdx.nil? && @end
+
+        if @property.hasQuery?(@attributeId, @scenarioIdx)
+          # Call the property query function to get the result.
+          if @scenarioIdx
+            @property.send('query_' + @attributeId, scenarioIdx, self)
+          else
+            @property.send('query_' + @attributeId, self)
+          end
+        else
+          # There is no query function. We simply use the property attribute
+          # value.
+          @sortableResult =
+            if @scenarioIdx
+              @property[@attributeId, @scenarioIdx]
+            else
+              @property.get(@attributeId)
+            end
+          if @sortableResult.is_a?(Array)
+            # This ugly special case is needed for custom attributes of type
+            # reference.
+            @sortableResult = @sortableResult[0]
+          end
+          @result = @sortableResult.to_s
+          @numericalResult = @result if @result.is_a?(Fixnum) or
+                                        @result.is_a?(Float)
+        end
+      rescue TjException
+        @errorMessage = $!
+        @result = ''
+        return @ok = false
+      end
+      @ok = true
+    end
+
+    # Convert a duration to the format specified by @loadUnit.  _work_ is the
+    # effort in man days. The return value is the converted value with optional
+    # unit as a String.
+    def scaleDuration(value)
+      scaleValue(value, [ 24 * 60, 24, 1, 1.0 / 7, 1.0 / 30.42, 1.0 / 365 ])
+    end
+
+    # Convert a load or effort value to the format specified by @loadUnit.
+    # _work_ is the effort in man days. The return value is the converted value
+    # with optional unit as a String.
+    def scaleLoad(value)
+      scaleValue(value, [ @project.dailyWorkingHours * 60,
+                          @project.dailyWorkingHours,
+                          1.0,
+                          1.0 / @project.weeklyWorkingDays,
+                          1.0 / @project.monthlyWorkingDays,
+                          1.0 / @project.yearlyWorkingDays ])
+    end
+
+  private
+
+    def resolvePropertyId(pType, pId)
+      unless @project
+        raise TjException.new, "Need Project reference to process the query"
+      end
+      case pType
+      when :Account
+        @project.account[pId]
+      when :Task
+        @project.task[pId]
+      when:Resource
+        @project.resource[pId]
+      else
+        raise TjException.new, "Unknown property type #{pType}"
+      end
+    end
+
+    # This function converts number to strings that may include a unit. The
+    # unit is determined by @loadUnit. In the automatic modes, the shortest
+    # possible result is shown and the unit is always appended. _value_ is the
+    # value to convert. _factors_ determines the conversion factors for the
+    # different units.
+    def scaleValue(value, factors)
+      if @loadUnit == :shortauto || @loadUnit == :longauto
+        # We try all possible units and store the resulting strings here.
+        options = []
+        # For each option we also save the delta between the String value and
+        # the original value.
+        delta = []
+        # For each of the units we can define a maximum value that the value
+        # should not exceed. nil means no limit.
+        max = [ 60, 48, nil, 8, 24, nil ]
+
+        i = 0
+        factors.each do |factor|
+          scaledValue = value * factor
+          str = @numberFormat.format(scaledValue)
+          delta[i] = ((scaledValue - str.to_f).abs * 1000).to_i
+          # We ignore results that are 0 or exceed the maximum. To ensure that
+          # we have at least one result the unscaled value is always taken.
+          if (factor != 1.0 && /^[0.]*$/ =~ str) ||
+             (max[i] && scaledValue > max[i])
+            options << nil
+          else
+            options << str
+          end
+          i += 1
+        end
+
+        # Find the value that is the closest to the original value. This will be
+        # the default if all values have the same length.
+        shortest = 2
+        delta.length.times do |j|
+          shortest = j if options[j] && options[j][0, 2] != '0.' &&
+                          delta[j] <= delta[shortest]
+        end
+
+        # Find the shortest option.
+        6.times do |j|
+          shortest = j if options[j] && options[j][0, 2] != '0.' &&
+                          options[j].length < options[shortest].length
+        end
+
+        str = options[shortest]
+        if @loadUnit == :longauto
+          # For the long units we handle singular and plural properly. For
+          # English we just need to append an 's', but this code will work for
+          # other languages as well.
+          units = []
+          if str == "1"
+            units = %w( minute hour day week month year )
+          else
+            units = %w( minutes hours days weeks months years )
+          end
+          str += ' ' + units[shortest]
+        else
+          str += %w( min h d w m y )[shortest]
+        end
+      else
+        # For fixed units we just need to do the conversion. No unit is
+        # included.
+        units = [ :minutes, :hours, :days, :weeks, :months, :years ]
+        str = @numberFormat.format(value * factors[units.index(@loadUnit)])
+      end
+      str
+    end
+
+  end
+
+end
+

data/lib/RealFormat.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = RealFormat.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+class TaskJuggler
+
+  # This class provides the functionality to format a Float according to certain
+  # rules. These rules determine how negative values are represented, how the
+  # fractional part is shown and how to structure the mantissa. The result is
+  # always a String.
+  class RealFormat
+
+    # Create a new RealFormat object and define the formating rules.
+    def initialize(args)
+      # Prefix used for negative numbers. (String)
+      @signPrefix = args[0]
+      # Suffix used for negative numbers. (String)
+      @signSuffix = args[1]
+      # Separator used after 3 integer digits. (String)
+      @thousandsSeparator = args[2]
+      # Separator used between the inter part and the fractional part. (String)
+      @fractionSeparator = args[3]
+      # Number of fractional digits to show. (Fixnum)
+      @fractionDigits = args[4]
+    end
+
+    # Converts the Float _number_ into a String representation according to the
+    # formating rules.
+    def format(number)
+      # Check for negative number. Continue with the absolute part.
+      if number < 0
+        negate = true
+        number = -number
+      else
+        negate = false
+      end
+
+      # Determine the integer part.
+      intNumber = (number * (10 ** @fractionDigits)).round.to_i.to_s
+      if intNumber.length <= @fractionDigits
+        intNumber = '0' * (@fractionDigits - intNumber.length + 1) + intNumber
+      end
+      intPart = intNumber[0..-(@fractionDigits + 1)]
+      fracPart =
+        @fractionDigits > 0 ? '.' + intNumber[-(@fractionDigits)..-1] : ''
+
+      if @thousandsSeparator.empty?
+        out = intPart
+      else
+        out = ''
+        1.upto(intPart.length) do |i|
+          out = intPart[-i, 1] + out
+          out = @thousandsSeparator + out if i % 3 == 0 && i < intPart.length
+        end
+      end
+      out += fracPart
+      # Now compose the result.
+      out = @signPrefix + out + @signSuffix if negate
+      out
+    end
+
+  end
+
+end
+

data/lib/Resource.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Resource.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+
+require 'PropertyTreeNode'
+require 'ResourceScenario'
+
+class TaskJuggler
+
+  class Resource < PropertyTreeNode
+
+    def initialize(project, id, name, parent)
+      super(project.resources, id, name, parent)
+      project.addResource(self)
+
+      @data = Array.new(@project.scenarioCount, nil)
+      @project.scenarioCount.times do |i|
+        @data[i] = ResourceScenario.new(self, i, @scenarioAttributes[i])
+      end
+    end
+
+    # Many Resource functions are scenario specific. These functions are
+    # provided by the class ResourceScenario. In case we can't find a
+    # function called for the Resource class we try to find it in
+    # ResourceScenario.
+    def method_missing(func, scenarioIdx, *args)
+      @data[scenarioIdx].method(func).call(*args)
+    end
+
+  end
+
+end
+

data/lib/ResourceScenario.rb

@@ -0,0 +1,511 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ResourceScenario.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+
+require 'ScenarioData'
+
+class TaskJuggler
+
+  class ResourceScenario < ScenarioData
+
+    def initialize(resource, scenarioIdx, attributes)
+      super
+
+      # The scoreboard entries are either nil, a number or a task reference. nil
+      # means the slot is unassigned. The task reference means assigned to this
+      # task. The numbers have the following values:
+      # 1: Off hour
+      # 2: Vacation
+      # 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
+
+      @firstBookedSlot = nil
+      @lastBookedSlot = nil
+    end
+
+    # This method must be called at the beginning of each scheduling run. It
+    # initializes variables used during the scheduling process.
+    def prepareScheduling
+      @property['effort', @scenarioIdx] = 0
+      initScoreboard
+    end
+
+    # 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.
+    def calcCriticalness
+      if @scoreboard.nil?
+        # Resources that are not allocated are not critical at all.
+        @property['criticalness', @scenarioIdx] = 0.0
+      else
+        freeSlots = 0
+        @scoreboard.each do |slot|
+          freeSlots += 1 if slot.nil?
+        end
+        @property['criticalness', @scenarioIdx] = freeSlots == 0 ? 1.0 :
+          a('alloctdeffort') / freeSlots
+      end
+    end
+
+    # Returns true if the resource is available at the time specified by
+    # _sbIdx_.
+    def available?(sbIdx)
+      return false unless @scoreboard[sbIdx].nil?
+
+      limits = a('limits')
+      return false if limits && !limits.ok?(@scoreboard.idxToDate(sbIdx))
+
+      true
+    end
+
+    # Return true if the resource is booked for a tasks at the time specified by
+    # _sbIdx_.
+    def booked?(sbIdx)
+      @scoreboard[sbIdx].is_a?(Task)
+    end
+
+    # 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.
+    def book(sbIdx, task, force = false)
+      return false if !force && !available?(sbIdx)
+
+      #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 and all parent
+      # resources.
+      t = @property
+      while t
+        t['effort', @scenarioIdx] += 1
+        t = t.parent
+      end
+      a('limits').inc(@scoreboard.idxToDate(sbIdx)) if a('limits')
+
+      # Make sure the task is in the list of duties.
+      @property['duties', @scenarioIdx] << task unless a('duties').include?(task)
+
+      if @firstBookedSlot.nil? || @firstBookedSlot > sbIdx
+        @firstBookedSlot = sbIdx
+      end
+      if @lastBookedSlot.nil? || @lastBookedSlot < sbIdx
+        @lastBookedSlot = sbIdx
+      end
+      true
+    end
+
+    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}.", true, booking.sourceFileInfo)
+        end
+        if @scoreboard[sbIdx] > booking.overtime
+          if @scoreboard[sbIdx] == 1 && booking.sloppy == 0
+            error('booking_no_duty',
+                  "Resource #{@property.fullId} has no duty at " +
+                  "#{@scoreboard.idxToDate(sbIdx)}.", true,
+                  booking.sourceFileInfo)
+          end
+          if @scoreboard[sbIdx] == 2 && booking.sloppy <= 1
+            error('booking_on_vacation',
+                  "Resource #{@property.fullId} is on vacation at " +
+                  "#{@scoreboard.idxToDate(sbIdx)}.", true,
+                  booking.sourceFileInfo)
+          end
+          return false
+        end
+      end
+
+      book(sbIdx, booking.task, true)
+    end
+
+    # 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.
+    def query_cost(query)
+      if query.costAccount
+        query.sortableResult = query.numericalResult =
+          turnover(query.startIdx, query.endIdx, query.costAccount,
+                   query.scopeProperty)
+        query.result = query.currencyFormat.format(query.sortableResult)
+      else
+        query.result = 'No cost account'
+      end
+    end
+
+    # 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.
+    def query_effort(query)
+      query.sortableResult = query.numericalResult =
+        getEffectiveWork(query.startIdx, query.endIdx, query.scopeProperty)
+      query.result = query.scaleLoad(query.sortableResult)
+    end
+
+    # The unallocated effort of the Resource in the specified interval.
+    def query_freework(query)
+      query.sortableResult = query.numericalResult =
+        getEffectiveFreeWork(query.startIdx, query.endIdx)
+      query.result = query.scaleLoad(query.sortableResult)
+    end
+
+    # Get the rate of the resource.
+    def query_rate(query)
+      query.sortableResult = query.numericalResult = rate
+      query.result = query.currencyFormat.format(query.sortableResult)
+    end
+
+    # 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.
+    def query_revenue(query)
+      if query.revenueAccount
+        query.sortableResult = query.numericalResult =
+          turnover(query.startIdx, query.endIdx, query.revenueAccount,
+                   query.scopeProperty)
+        query.result = query.currencyFormat.format(query.sortableResult)
+      else
+        query.result = 'No revenue account'
+      end
+    end
+
+    # Returns the work of the resource (and its children) weighted by their
+    # efficiency.
+    def getEffectiveWork(startIdx, endIdx, task = nil)
+      # Convert the interval dates to indexes if needed.
+      startIdx = @project.dateToIdx(startIdx, true) if startIdx.is_a?(TjTime)
+      endIdx = @project.dateToIdx(endIdx, true) if endIdx.is_a?(TjTime)
+
+      work = 0.0
+      if @property.container?
+        @property.children.each do |resource|
+          work += resource.getEffectiveWork(@scenarioIdx, startIdx, endIdx, task)
+        end
+      else
+        return 0.0 if @scoreboard.nil?
+
+        work = @project.convertToDailyLoad(
+                 getAllocatedSlots(startIdx, endIdx, task) *
+                 @project['scheduleGranularity']) * a('efficiency')
+      end
+      work
+    end
+
+    # Returns the allocated work of the resource (and its children).
+    def getAllocatedWork(startIdx, endIdx, task = nil)
+      # Convert the interval dates to indexes if needed.
+      startIdx = @project.dateToIdx(startIdx, true) if startIdx.is_a?(TjTime)
+      endIdx = @project.dateToIdx(endIdx, true) if endIdx.is_a?(TjTime)
+
+      work = 0.0
+      if @property.container?
+        @property.children.each do |resource|
+          work += resource.getAllocatedWork(@scenarioIdx, startIdx, endIdx, task)
+        end
+      else
+        return 0.0 if @scoreboard.nil?
+
+        work = @project.convertToDailyLoad(
+                 getAllocatedSlots(startIdx, endIdx, task) *
+                 @project['scheduleGranularity'])
+      end
+      work
+    end
+
+    # Returns the allocated accumulated time of this resource and its children.
+    def getAllocatedTime(startIdx, endIdx, task = nil)
+      # Convert the interval dates to indexes if needed.
+      startIdx = @project.dateToIdx(startIdx, true) if startIdx.is_a?(TjTime)
+      endIdx = @project.dateToIdx(endIdx, true) if endIdx.is_a?(TjTime)
+
+      time = 0
+      if @property.container?
+        @property.children.each do |resource|
+          time += resource.getAllocatedWork(@scenarioIdx, startIdx, endIdx, task)
+        end
+      else
+        return 0 if @scoreboard.nil?
+
+        time = @project.convertToDailyLoad(@project['scheduleGranularity'] *
+            getAllocatedSlots(startIdx, endIdx, task))
+      end
+      time
+    end
+
+    # Return the unallocated work of the resource and its children wheighted by
+    # their efficiency.
+    def getEffectiveFreeWork(startIdx, endIdx)
+      # Convert the interval dates to indexes if needed.
+      startIdx = @project.dateToIdx(startIdx, true) if startIdx.is_a?(TjTime)
+      endIdx = @project.dateToIdx(endIdx, true) if endIdx.is_a?(TjTime)
+
+      work = 0.0
+      if @property.container?
+        @property.children.each do |resource|
+          work += resource.getEffectiveFreeWork(@scenarioIdx, startIdx, endIdx)
+        end
+      else
+        initScoreboard if @scoreboard.nil?
+
+        work = @project.convertToDailyLoad(
+                 getFreeSlots(startIdx, endIdx) *
+                 @project['scheduleGranularity']) * a('efficiency')
+      end
+      work
+    end
+
+    def turnover(startIdx, endIdx, account, task = nil)
+      amount = 0.0
+      if @property.container?
+        @property.children.each do |child|
+          amount += child.turnover(@scenarioIdx, startIdx, endIdx, account, task)
+        end
+      else
+        a('duties').each do |duty|
+          amount += duty.turnover(@scenarioIdx, startIdx, endIdx, account,
+                                  @property)
+        end
+      end
+
+      amount
+    end
+
+    # Returns the cost for using this resource during the specified Interval
+    # _period_. If a Task _task_ is provided, only the work on this particular
+    # task is considered.
+    def cost(startIdx, endIdx, task = nil)
+      getAllocatedTime(startIdx, endIdx, task) * a('rate')
+    end
+
+    # Returns true if the resource or any of its children is allocated during
+    # the period specified with the Interval _iv_. If task is not nil
+    # only allocations to this tasks are respected.
+    def allocated?(iv, task = nil)
+      initScoreboard if @scoreboard.nil?
+
+      startIdx = @scoreboard.dateToIdx(iv.start, true)
+      endIdx = @scoreboard.dateToIdx(iv.end, true)
+
+      startIdx = @firstBookedSlot if @firstBookedSlot &&
+                                     startIdx < @firstBookedSlot
+      endIdx = @lastBookedSlot + 1 if @lastBookedSlot &&
+                                      endIdx < @lastBookedSlot + 1
+      return false if startIdx > endIdx
+
+      return allocatedSub(startIdx, endIdx, task)
+    end
+
+    # Iterate over the scoreboard and turn its content into a set of Bookings.
+    def getBookings
+      return {} if @property.container? || @scoreboard.nil? ||
+                   @firstBookedSlot.nil? || @lastBookedSlot.nil?
+
+      bookings = {}
+      lastTask = nil
+      bookingStart = nil
+
+      # To speedup the collection we start with the first booked slot and end
+      # with the last booked slot.
+      startIdx = @firstBookedSlot
+      endIdx = @lastBookedSlot + 1
+
+      # In case the index markers are still uninitialized, we have no bookings.
+      return [] if startIdx.nil? || endIdx.nil?
+
+      startIdx.upto(endIdx - 1) do |idx|
+        task = @scoreboard[idx]
+        # Now we watch for task changes.
+        if task != lastTask || (lastTask == nil && task.is_a?(Task)) ||
+           (task.is_a?(Task) && idx == endIdx - 1)
+          unless lastTask.nil?
+            # If we don't have a Booking for the task yet, we create one.
+            if bookings[lastTask].nil?
+              bookings[lastTask] = Booking.new(@property, lastTask, [])
+            end
+
+            # Make sure the index is correct even for the last task block.
+            idx += 1 if idx == endIdx - 1
+            # Append the new interval to the Booking.
+            bookings[lastTask].intervals <<
+              Interval.new(@scoreboard.idxToDate(bookingStart),
+                           @scoreboard.idxToDate(idx))
+          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
+
+    # Return a list of scoreboard intervals that are at least _minDuration_ long
+    # and contain only 1 and 2. These values determine off-hours of the
+    # resource. The result is an Array of [ start, end ] TjTime values.
+    def collectTimeOffIntervals(iv, minDuration)
+      initScoreboard if @scoreboard.nil?
+
+      @scoreboard.collectTimeOffIntervals(iv, minDuration, [ 1, 2 ])
+    end
+
+  private
+
+    def initScoreboard
+      # Create scoreboard and mark all slots as unavailable
+      @scoreboard = Scoreboard.new(@project['start'], @project['end'],
+                                   @project['scheduleGranularity'], 1)
+
+      # We'll need this frequently and can savely cache it here.
+      @shifts = a('shifts')
+      @workinghours = a('workinghours')
+
+      # Change all work time slots to nil (available) again.
+      date = @scoreboard.idxToDate(0)
+      delta = @project['scheduleGranularity']
+      @project.scoreboardSize.times do |i|
+        @scoreboard[i] = nil if onShift?(date)
+        date += delta
+      end
+
+      # Mark all resource specific vacation slots as such (2)
+      a('vacations').each do |vacation|
+        startIdx = @scoreboard.dateToIdx(vacation.start, true)
+        endIdx = @scoreboard.dateToIdx(vacation.end, true)
+        startIdx.upto(endIdx - 1) do |i|
+           @scoreboard[i] = 2
+        end
+      end
+
+      # Mark all global vacation slots as such (2)
+      @project['vacations'].each do |vacation|
+        startIdx = @scoreboard.dateToIdx(vacation.start, true)
+        endIdx = @scoreboard.dateToIdx(vacation.end, true)
+        startIdx.upto(endIdx - 1) do |i|
+           @scoreboard[i] = 2
+        end
+      end
+
+      unless @shifts.nil?
+        # Mark the vacations from all the shifts the resource is assigned to.
+        @project.scoreboardSize.times do |i|
+          v = @shifts.getSbSlot(@scoreboard.idxToDate(i))
+          # Check if the vacation replacement bit is set. In that case we copy
+          # the while interval over to the resource scoreboard overriding any
+          # global vacations.
+          if (v & (1 << 8)) > 0
+            # The ShiftAssignments scoreboard and the ResourceScenario scoreboard
+            # unfortunately can't use the same values for a certain meaning. So,
+            # we have to use a map to translate the values.
+            map = [ nil, nil, 1, 2 ]
+            @scoreboard[i] = map[v & 0xFF]
+          elsif (v & 0xFF) == 3
+            # 3 in ShiftAssignments means 2 in ResourceScenario (on vacation)
+            @scoreboard[i] = 2
+          end
+        end
+      end
+    end
+
+    def onShift?(date)
+      # The more redable but slower form would be:
+      # if @shifts.assigned?(date)
+      #   return @shifts.onShift?(date)
+      # else
+      #   @workinghours.onShift?(date)
+      # end
+      if @shifts && (v = (@shifts.getSbSlot(date) & 0xFF)) > 0
+        v == 1
+      else
+        @workinghours.onShift?(date)
+      end
+    end
+
+    # 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.
+    def getAllocatedSlots(startIdx, endIdx, task)
+      # To speedup the counting we start with the first booked slot and end
+      # with the last booked slot.
+      startIdx = @firstBookedSlot if @firstBookedSlot &&
+                                     startIdx < @firstBookedSlot
+      endIdx = @lastBookedSlot + 1 if @lastBookedSlot &&
+                                      endIdx > @lastBookedSlot + 1
+
+      bookedSlots = 0
+      startIdx.upto(endIdx - 1) do |idx|
+        if (task.nil? && @scoreboard[idx].is_a?(Task)) ||
+           (task && @scoreboard[idx] == task)
+          bookedSlots += 1
+        end
+      end
+
+      bookedSlots
+    end
+
+    # Count the free slots between the start and end index.
+    def getFreeSlots(startIdx, endIdx)
+      freeSlots = 0
+      startIdx.upto(endIdx - 1) do |idx|
+        freeSlots += 1 if @scoreboard[idx].nil?
+      end
+
+      freeSlots
+    end
+
+    # Returns true if the resource or any of its children is allocated during
+    # the period specified with _startIdx_ and _endIdx_. If task is not nil
+    # only allocations to this tasks are respected.
+    def allocatedSub(startIdx, endIdx, task)
+      if @property.container?
+        @property.children.each do |resource|
+          return true if resource.allocatedSub(@scenarioIdx, startIdx, endIdx,
+                                               task)
+        end
+      else
+        return false unless a('duties').include?(task)
+
+        startIdx.upto(endIdx - 1) do |idx|
+          return true if @scoreboard[idx] == task
+        end
+      end
+      false
+    end
+
+    # Return the daily cost of a resource or resource group.
+    def rate
+      if @property.container?
+        dailyRate = 0.0
+        @property.children.each do |resource|
+          dailyRate += resource.rate(@scenarioIdx)
+        end
+        dailyRate
+      else
+        a('rate')
+      end
+    end
+
+  end
+
+end
+