taskjuggler 0.0.4 → 0.0.5

data/lib/Resource.rb

@@ -36,6 +36,163 @@ class TaskJuggler
       @data[scenarioIdx].method(func).call(*args)
     end
 
+    def query_journal(query)
+      journalMessages(query, true)
+    end
+
+    def query_dashboard(query)
+      dashboard(query)
+    end
+
+    private
+
+    # Create a blog-style list of all alert messages that match the Query.
+    def journalMessages(query, longVersion)
+      # The components of the message are either UTF-8 text or RichText. For
+      # the RichText components, we use the originally provided markup since
+      # we compose the result as RichText markup first.
+      rText = ''
+      list = @project['journal'].entriesByResource(self, query.start, query.end)
+      # Sort all entries in buckets by their alert level.
+      numberOfLevels = project['alertLevels'].length
+      listByLevel = []
+      0.upto(numberOfLevels - 1) { |i| listByLevel[i] = [] }
+      list.each do |entry|
+        listByLevel[entry.alertLevel] << entry
+      end
+      (numberOfLevels - 1).downto(0) do |level|
+        levelList = listByLevel[level]
+        levelRecord = @project['alertLevels'][level]
+        alertName = "[[File:icons/flag-#{levelRecord[0]}.png|" +
+                    "alt=[#{levelRecord[1]}]|text-bottom]]"
+        levelList.each do |entry|
+          # The TimeSheetRecords associated with this entry.
+          tsRecord = entry.timeSheetRecord
+          if entry.property.is_a?(Task)
+            rText += "== #{alertName} <nowiki>#{entry.property.name}</nowiki> "+
+              "(ID: #{entry.property.fullId}) ==\n\n"
+            if tsRecord
+              rText += "'''Work:''' #{tsRecord.actualWorkPercent.to_i}% "
+              if tsRecord.actualWorkPercent != tsRecord.planWorkPercent
+                rText += "(#{tsRecord.planWorkPercent.to_i}%) "
+              end
+              if tsRecord.remaining
+                rText += "'''Remaining:''' #{tsRecord.actualRemaining}d "
+                if tsRecord.actualRemaining !=  tsRecord.planRemaining
+                  rText += "(#{tsRecord.planRemaining}d) "
+                end
+              else
+                rText += "'''End:''' " +
+                         "#{tsRecord.actualEnd.to_s(query.timeFormat)} "
+                if tsRecord.actualEnd != tsRecord.planEnd
+                  rText += "(#{tsRecord.planEnd.to_s(query.timeFormat)}) "
+                end
+              end
+              rText += "\n\n"
+            end
+          elsif !(tsRecord = entry.timeSheetRecord).nil? &&
+                entry.timeSheetRecord.task.is_a?(String)
+            rText += "== #{alertName} <nowiki>[New Task] #{tsRecord.name} " +
+                     "</nowiki> "+
+              "(ID: #{tsRecord.task}) ==\n\n"
+            if tsRecord
+              rText += "'''Work:''' #{tsRecord.actualWorkPercent}% "
+              if tsRecord.remaining
+                rText += "'''Remaining:''' #{tsRecord.actualRemaining}d "
+              else
+                rText += "'''End:''' " +
+                         "#{tsRecord.actualEnd.to_s(query.timeFormat)} "
+              end
+              rText += "\n\n"
+            end
+          else
+            rText += "== #{alertName} Personal Notes ==\n\n"
+          end
+          unless entry.headline.empty?
+            rText += "'''<nowiki>#{entry.headline}</nowiki>'''\n\n"
+          end
+          if entry.summary
+            rText += entry.summary.richText.inputText + "\n\n"
+          end
+          if longVersion && entry.details
+            rText += entry.details.richText.inputText + "\n\n"
+          end
+        end
+      end
+
+      # Now convert the RichText markup String into RichTextIntermediate
+      # format.
+      handlers = [
+        RTFNavigator.new(@project),
+        RTFQuery.new(@project),
+        RTFReport.new(@project)
+      ]
+      begin
+        rti = RichText.new(rText, handlers).generateIntermediateFormat
+      rescue RichTextException => msg
+        $stderr.puts "Error while processing Rich Text\n" +
+                     "Line #{msg.lineNo}: #{msg.text}\n" +
+                     "#{msg.line}"
+        return nil
+      end
+      # No section numbers, please!
+      rti.sectionNumbers = false
+      # We use a special class to allow CSS formating.
+      rti.cssClass = 'tj_journal'
+      query.rti = rti
+    end
+
+    # Create a dashboard-like list of all task that have a current alert
+    # status.
+    def dashboard(query)
+      scenarioIdx = @project['trackingScenarioIdx']
+      taskList = []
+      @project.tasks.each do |task|
+        if task['responsible', scenarioIdx].include?(self) &&
+           !@project['journal'].currentEntries(query.end, task,
+                                              0, query.start).empty?
+          taskList << task
+        end
+      end
+
+      if taskList.empty?
+        rText = "We have no current status for any task that #{name} " +
+                "is responsible for."
+      else
+        # The components of the message are either UTF-8 text or RichText. For
+        # the RichText components, we use the originally provided markup since
+        # we compose the result as RichText markup first.
+        rText = ''
+
+        taskList.each do |task|
+          rText += "== <nowiki>[#{task.query_alert(query)}] Task: " +
+            "#{task.name}</nowiki> (#{task.fullId}) ==\n\n"
+            rText += task.query_alertmessage(query).richText.inputText + "\n\n"
+        end
+      end
+
+      # Now convert the RichText markup String into RichTextIntermediate
+      # format.
+      handlers = [
+        RTFNavigator.new(@project),
+        RTFQuery.new(@project),
+        RTFReport.new(@project)
+      ]
+      begin
+        rti = RichText.new(rText, handlers).generateIntermediateFormat
+      rescue RichTextException => msg
+        $stderr.puts "Error while processing Rich Text\n" +
+                     "Line #{msg.lineNo}: #{msg.text}\n" +
+                     "#{msg.line}"
+        return nil
+      end
+      # No section numbers, please!
+      rti.sectionNumbers = false
+      # We use a special class to allow CSS formating.
+      rti.cssClass = 'tj_journal'
+      query.rti = rti
+    end
+
   end
 
 end

data/lib/ResourceScenario.rb

@@ -20,11 +20,18 @@ class TaskJuggler
     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
+      # Scoreboard may be nil, a Task, or a bit vector encoded as a Fixnum
+      # nil:        Value has not been determined yet.
+      # Task:       A reference to a Task object
+      # Bit 0:      Reserved
+      # Bit 1:      0: Work time
+      #             1: Off time
+      # Bit 2 - 5:  0: No vacation or leave time
+      #             1: Regular vacation
+      #             2 - 15: Reserved
+      # Bit 6:      Reserved
+      # Bit 7:      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.
@@ -39,6 +46,8 @@ class TaskJuggler
     def prepareScheduling
       @property['effort', @scenarioIdx] = 0
       initScoreboard
+
+      setDirectReports
     end
 
     # The criticalness of a resource is a measure for the probabilty that all
@@ -60,6 +69,72 @@ class TaskJuggler
       end
     end
 
+    def setDirectReports
+      # Only leaf resources have reporting lines.
+      return unless @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.
+      a('managers').each do |manager|
+        unless manager['directreports', @scenarioIdx].include?(@property)
+          manager['directreports', @scenarioIdx] << @property
+        end
+      end
+    end
+
+    def setReports
+      return unless a('directreports').empty?
+
+      a('managers').each do |r|
+        r.setReports_i(@scenarioIdx, [ @property ])
+      end
+    end
+
+
+    def preScheduleCheck
+      a('managers').each do |manager|
+        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
+      end
+    end
+
+    def postScheduleCheck
+      if a('fail') || a('warn')
+        queryAttrs = { 'project' => @project,
+                       'scenarioIdx' => @scenarioIdx,
+                       'property' => @property,
+                       'scopeProperty' => nil,
+                       'start' => @project['start'],
+                       'end' => @project['end'],
+                       'loadUnit' => :days,
+                       'numberFormat' => @project['numberFormat'],
+                       'timeFormat' => @project['timeFormat'],
+                       'currencyFormat' => @project['currencyFormat'] }
+        query = Query.new(queryAttrs)
+        if a('fail') && a('fail').eval(query)
+          error('resource_fail_check',
+                "User defined check failed for resource #{@property.fullId} \n" +
+                "Condition: #{a('fail').to_s}\n" +
+                "Result:    #{a('fail').to_s(query)}")
+        end
+        if a('warn') && a('warn').eval(query)
+          warning('resource_warn_check',
+                  "User defined warning triggered for resource " +
+                  "#{@property.fullId} \n" +
+                  "Condition: #{a('warn').to_s}\n" +
+                  "Result:    #{a('warn').to_s(query)}")
+        end
+      end
+    end
+
     # Returns true if the resource is available at the time specified by
     # _sbIdx_.
     def available?(sbIdx)
@@ -96,7 +171,9 @@ class TaskJuggler
       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)
+      unless a('duties').include?(task)
+        @property['duties', @scenarioIdx] << task
+      end
 
       if @firstBookedSlot.nil? || @firstBookedSlot > sbIdx
         @firstBookedSlot = sbIdx
@@ -118,14 +195,22 @@ class TaskJuggler
                 "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
+        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)}.", true,
                   booking.sourceFileInfo)
           end
-          if @scoreboard[sbIdx] == 2 && booking.sloppy <= 1
+          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)}.", true,
@@ -195,6 +280,14 @@ class TaskJuggler
       end
     end
 
+    # The work time of the Resource that was blocked by a vacation during the
+    # specified Interval. The result is in working days (effort).
+    def query_vacationdays(query)
+      query.sortable = query.numerical = time =
+        getVacationDays(query.startIdx, query.endIdx)
+      query.string = query.scaleLoad(time)
+    end
+
     # Returns the work of the resource (and its children) weighted by their
     # efficiency.
     def getEffectiveWork(startIdx, endIdx, task = nil)
@@ -272,8 +365,6 @@ class TaskJuggler
                                                     endIdx)
         end
       else
-        initScoreboard if @scoreboard.nil?
-
         freeTime = getFreeSlots(startIdx, endIdx) *
           @project['scheduleGranularity']
       end
@@ -293,8 +384,6 @@ class TaskJuggler
           work += resource.getEffectiveFreeWork(@scenarioIdx, startIdx, endIdx)
         end
       else
-        initScoreboard if @scoreboard.nil?
-
         work = @project.convertToDailyLoad(
                  getFreeSlots(startIdx, endIdx) *
                  @project['scheduleGranularity']) * a('efficiency')
@@ -302,6 +391,28 @@ class TaskJuggler
       work
     end
 
+    # Return the number of working days that are blocked by vacations.
+    def getVacationDays(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)
+
+      vacationDays = 0.0
+      if @property.container?
+        @property.children.each do |resource|
+          vacationDays += resource.getVacationDays(@scenarioIdx,
+                                                   startIdx, endIdx)
+        end
+      else
+        initScoreboard if @scoreboard.nil?
+
+        vacationDays = @project.convertToDailyLoad(
+          getVacationSlots(startIdx, endIdx) *
+          @project['scheduleGranularity']) * a('efficiency')
+      end
+      vacationDays
+    end
+
     def turnover(startIdx, endIdx, account, task = nil)
       amount = 0.0
       if @property.container?
@@ -391,12 +502,63 @@ class TaskJuggler
     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.
+    # and contain only off-duty and vacation slots. The result is an Array of
+    # [ start, end ] TjTime values.
     def collectTimeOffIntervals(iv, minDuration)
       initScoreboard if @scoreboard.nil?
 
-      @scoreboard.collectTimeOffIntervals(iv, minDuration, [ 1, 2 ])
+      @scoreboard.collectIntervals(iv, minDuration) do |val|
+        val.is_a?(Fixnum) && (val & 0x3E) != 0
+      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
+
+      initScoreboard if @scoreboard.nil?
+      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)
+      initScoreboard if @scoreboard.nil?
+
+      freeSlots = 0
+      startIdx.upto(endIdx - 1) do |idx|
+        freeSlots += 1 if @scoreboard[idx].nil?
+      end
+
+      freeSlots
+    end
+
+    # Count the regular work time slots between the start and end index that
+    # have been blocked by a vacation.
+    def getVacationSlots(startIdx, endIdx)
+      initScoreboard if @scoreboard.nil?
+
+      vacationSlots = 0
+      startIdx.upto(endIdx - 1) do |idx|
+        val = @scoreboard[idx]
+        # Bit 1 needs to be unset and the vacation bits must not be 0.
+        vacationSlots += 1 if val.is_a?(Fixnum) && (val & 0x2) == 0 &&
+                                                   (val & 0x3C) != 0
+      end
+      vacationSlots
     end
 
   private
@@ -404,7 +566,7 @@ class TaskJuggler
     def initScoreboard
       # Create scoreboard and mark all slots as unavailable
       @scoreboard = Scoreboard.new(@project['start'], @project['end'],
-                                   @project['scheduleGranularity'], 1)
+                                   @project['scheduleGranularity'], 2)
 
       # We'll need this frequently and can savely cache it here.
       @shifts = a('shifts')
@@ -418,21 +580,24 @@ class TaskJuggler
         date += delta
       end
 
-      # Mark all resource specific vacation slots as such (2)
+      # Mark all resource specific vacation slots as such
       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
+          # If the slot is nil, we don't set the time-off bit.
+          @scoreboard[i] = (@scoreboard[i].nil? ? 0 : 2) | (1 << 2)
         end
       end
 
-      # Mark all global vacation slots as such (2)
+      # Mark all global vacation slots as such
       @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
+          # If the slot is nil or set to 4 then don't set the time-off bit.
+          sb = @scoreboard[i]
+          @scoreboard[i] = ((sb.nil? || sb == 4) ? 0 : 2) | (1 << 2)
         end
       end
 
@@ -441,65 +606,47 @@ class TaskJuggler
         @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
+          # the whole 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
+          if (v & (1 << 8)) != 0
+            if (v & 0x3E) == 0
+              @scoreboard[i] = nil
+            else
+              @scoreboard[i] = v & 0x3E
+            end
+          elsif ((sbV = @scoreboard[i]).nil? || (sbV & 0x3C) == 0) &&
+                (v & 0x3C) != 0
+            # We only add the shift vacations but don't turn global vacation
+            # slots into working slots again.
+            @scoreboard[i] = v & 0x3E
           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)
+    def setReports_i(reports)
+      if reports.include?(@property)
+        # A manager must never show up in the list of his/her own reports.
+        error('manager_loop',
+              "Management loop detected. #{@property.fullId} has self " +
+              "in list of reports")
       end
-    end
+      @property['reports', @scenarioIdx] += reports
+      # Resources can end up multiple times in the list if they have multiple
+      # reporting chains. We only need them once in the list.
+      a('reports').uniq!
 
-    # 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
+      a('managers').each do |r|
+        r.setReports_i(@scenarioIdx, a('reports'))
       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?
+    def onShift?(date)
+      if @shifts && @shifts.assigned?(date)
+        return @shifts.onShift?(date)
+      else
+        @workinghours.onShift?(date)
       end
-
-      freeSlots
     end
 
     # Returns true if the resource or any of its children is allocated during

data/lib/RichText.rb

@@ -125,8 +125,10 @@ class TaskJuggler
   class RichTextIntermediate
 
     attr_reader :richText
-    attr_accessor :blockMode, :sectionNumbers, :lineWidth, :linkTarget,
-                  :cssClass, :tree
+    attr_accessor :blockMode, :sectionNumbers,
+                  :lineWidth, :indent, :titleIndent, :parIndent, :listIndent,
+                  :preIndent,
+                  :linkTarget, :cssClass, :tree
 
     def initialize(richText)
       # A reference to the corresponding RichText object the RTI is derived
@@ -140,8 +142,18 @@ class TaskJuggler
       @blockMode = true
       # Set this to false to disable automatically generated section numbers.
       @sectionNumbers = true
-      # Set this to the width of your text area. Needed for horizonal lines.
+      # Set this to the maximum width used for text output.
       @lineWidth = 80
+      # The indentation used for all text output.
+      @indent = 0
+      # Additional indentation used for titles in text output.
+      @titleIndent = 0
+      # Additional indentation used for paragraph text output.
+      @parIndent = 0
+      # Additional indentation used for lists in text output.
+      @listIndent = 1
+      # Additional indentation used for <pre> sections in text output.
+      @preIndent = 0
       # The target used for hypertext links.
       @linkTarget = nil
       # The CSS class used for some key HTML elements.

data/lib/RichTextDocument.rb

@@ -47,6 +47,7 @@ class TaskJuggler
       @snippets << (snippet = RichTextSnip.new(self, file, @sectionCounter))
       snippet.linkTarget = @linkTarget
       @dirty = true
+      snippet
     end
 
     # Call this method to generate a table of contents for all files that were
@@ -119,10 +120,7 @@ class TaskJuggler
     # Generate a HTML file with the table of contense for all registered files.
     def generateHTMLTableOfContents(directory)
       html = HTMLDocument.new
-      html << (head = XMLElement.new('head'))
-      head << XMLNamedText.new('Index', 'title') <<
-        XMLElement.new('meta', 'http-equiv' => 'Content-Type',
-                       'content' => 'text/html; charset=utf-8')
+      head = html.generateHead('Index')
       html << (body = XMLElement.new('body'))
 
       body << generateHTMLCover <<