lisp/org-taskjuggler.el

   1 ;;; org-taskjuggler.el --- TaskJuggler exporter for org-mode
   2 ;;
   3 ;; Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4 ;;
   5 ;; Emacs Lisp Archive Entry
   6 ;; Filename: org-taskjuggler.el
   7 ;; Version: 7.5
   8 ;; Author: Christian Egli
   9 ;; Maintainer: Christian Egli
  10 ;; Keywords: org, taskjuggler, project planning
  11 ;; Description: Converts an org-mode buffer into a taskjuggler project plan
  12 ;; URL:
  13
  14 ;; This file is part of GNU Emacs.
  15
  16 ;; GNU Emacs is free software: you can redistribute it and/or modify
  17 ;; it under the terms of the GNU General Public License as published by
  18 ;; the Free Software Foundation, either version 3 of the License, or
  19 ;; (at your option) any later version.
  20
  21 ;; GNU Emacs is distributed in the hope that it will be useful,
  22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 ;; GNU General Public License for more details.
  25
  26 ;; You should have received a copy of the GNU General Public License
  27 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  28
  29 ;; Commentary:
  30 ;;
  31 ;; This library implements a TaskJuggler exporter for org-mode.
  32 ;; TaskJuggler uses a text format to define projects, tasks and
  33 ;; resources, so it is a natural fit for org-mode. It can produce all
  34 ;; sorts of reports for tasks or resources in either HTML, CSV or PDF.
  35 ;; The current version of TaskJuggler requires KDE but the next
  36 ;; version is implemented in Ruby and should therefore run on any
  37 ;; platform.
  38 ;;
  39 ;; The exporter is a bit different from other exporters, such as the
  40 ;; HTML and LaTeX exporters for example, in that it does not export
  41 ;; all the nodes of a document or strictly follow the order of the
  42 ;; nodes in the document.
  43 ;;
  44 ;; Instead the TaskJuggler exporter looks for a tree that defines the
  45 ;; tasks and a optionally tree that defines the resources for this
  46 ;; project. It then creates a TaskJuggler file based on these trees
  47 ;; and the attributes defined in all the nodes.
  48 ;;
  49 ;; * Installation
  50 ;;
  51 ;; Put this file into your load-path and the following line into your
  52 ;; ~/.emacs:
  53 ;;
  54 ;;   (require 'org-taskjuggler)
  55 ;;
  56 ;; The interactive functions are similar to those of the HTML and LaTeX
  57 ;; exporters:
  58 ;;
  59 ;; M-x `org-export-as-taskjuggler'
  60 ;; M-x `org-export-as-taskjuggler-and-open'
  61 ;;
  62 ;; * Tasks
  63 ;;
  64 ;; Let's illustrate the usage with a small example. Create your tasks
  65 ;; as you usually do with org-mode. Assign efforts to each task using
  66 ;; properties (it's easiest to do this in the column view). You should
  67 ;; end up with something similar to the example by Peter Jones in
  68 ;; http://www.contextualdevelopment.com/static/artifacts/articles/2008/project-planning/project-planning.org.
  69 ;; Now mark the top node of your tasks with a tag named
  70 ;; "taskjuggler_project" (or whatever you customized
  71 ;; `org-export-taskjuggler-project-tag' to). You are now ready to
  72 ;; export the project plan with `org-export-as-taskjuggler-and-open'
  73 ;; which will export the project plan and open a gant chart in
  74 ;; TaskJugglerUI.
  75 ;;
  76 ;; * Resources
  77 ;;
  78 ;; Next you can define resources and assign those to work on specific
  79 ;; tasks. You can group your resources hierarchically. Tag the top
  80 ;; node of the resources with "taskjuggler_resource" (or whatever you
  81 ;; customized `org-export-taskjuggler-resource-tag' to). You can
  82 ;; optionally assign an identifier (named "resource_id") to the
  83 ;; resources (using the standard org properties commands) or you can
  84 ;; let the exporter generate identifiers automatically (the exporter
  85 ;; picks the first word of the headline as the identifier as long as
  86 ;; it is unique, see the documentation of
  87 ;; `org-taskjuggler-get-unique-id'). Using that identifier you can
  88 ;; then allocate resources to tasks. This is again done with the
  89 ;; "allocate" property on the tasks. Do this in column view or when on
  90 ;; the task type
  91 ;;
  92 ;;  C-c C-x p allocate RET <resource_id> RET
  93 ;;
  94 ;; Once the allocations are done you can again export to TaskJuggler
  95 ;; and check in the Resource Allocation Graph which person is working
  96 ;; on what task at what time.
  97 ;;
  98 ;; * Export of properties
  99 ;;
 100 ;; The exporter also takes TODO state information into consideration,
 101 ;; i.e. if a task is marked as done it will have the corresponding
 102 ;; attribute in TaskJuggler ("complete 100"). Also it will export any
 103 ;; property on a task resource or resource node which is known to
 104 ;; TaskJuggler, such as limits, vacation, shift, booking, efficiency,
 105 ;; journalentry, rate for resources or account, start, note, duration,
 106 ;; end, journalentry, milestone, reference, responsible, scheduling,
 107 ;; etc for tasks.
 108 ;;
 109 ;; * Dependencies
 110 ;;
 111 ;; The exporter will handle dependencies that are defined in the tasks
 112 ;; either with the ORDERED attribute (see TODO dependencies in the Org
 113 ;; mode manual) or with the BLOCKER attribute (see org-depend.el) or
 114 ;; alternatively with a depends attribute. Both the BLOCKER and the
 115 ;; depends attribute can be either "previous-sibling" or a reference
 116 ;; to an identifier (named "task_id") which is defined for another
 117 ;; task in the project. BLOCKER and the depends attribute can define
 118 ;; multiple dependencies separated by either space or comma. You can
 119 ;; also specify optional attributes on the dependency by simply
 120 ;; appending it. The following examples should illustrate this:
 121 ;;
 122 ;; * Training material
 123 ;;   :PROPERTIES:
 124 ;;   :task_id:  training_material
 125 ;;   :ORDERED:  t
 126 ;;   :END:
 127 ;; ** Markup Guidelines
 128 ;;    :PROPERTIES:
 129 ;;    :Effort:   2.0
 130 ;;    :END:
 131 ;; ** Workflow Guidelines
 132 ;;    :PROPERTIES:
 133 ;;    :Effort:   2.0
 134 ;;    :END:
 135 ;; * Presentation
 136 ;;   :PROPERTIES:
 137 ;;   :Effort:   2.0
 138 ;;   :BLOCKER:  training_material { gapduration 1d } some_other_task
 139 ;;   :END:
 140 ;;
 141 ;;;; * TODO
 142 ;;   - Use SCHEDULED and DEADLINE information (not just start and end
 143 ;;     properties).
 144 ;;   - Look at org-file-properties, org-global-properties and
 145 ;;     org-global-properties-fixed
 146 ;;   - What about property inheritance and org-property-inherit-p?
 147 ;;   - Use TYP_TODO as an way to assign resources
 148 ;;   - Make sure multiple dependency definitions (i.e. BLOCKER on
 149 ;;     previous-sibling and on a specific task_id) in multiple
 150 ;;     attributes are properly exported.
 151 ;;
 152 ;;; Code:
 153
 154 (eval-when-compile
 155   (require 'cl))
 156
 157 (require 'org)
 158 (require 'org-exp)
 159
 160 ;;; User variables:
 161
 162 (defgroup org-export-taskjuggler nil
 163   "Options for exporting Org-mode files to TaskJuggler."
 164   :tag "Org Export TaskJuggler"
 165   :group 'org-export)
 166
 167 (defcustom org-export-taskjuggler-extension ".tjp"
 168   "Extension of TaskJuggler files."
 169   :group 'org-export-taskjuggler
 170   :type 'string)
 171
 172 (defcustom org-export-taskjuggler-project-tag "taskjuggler_project"
 173   "Tag, property or todo used to find the tree containing all
 174 the tasks for the project."
 175   :group 'org-export-taskjuggler
 176   :type 'string)
 177
 178 (defcustom org-export-taskjuggler-resource-tag "taskjuggler_resource"
 179   "Tag, property or todo used to find the tree containing all the
 180 resources for the project."
 181   :group 'org-export-taskjuggler
 182   :type 'string)
 183
 184 (defcustom org-export-taskjuggler-target-version 2.4
 185   "Which version of TaskJuggler the exporter is targeting."
 186   :group 'org-export-taskjuggler
 187   :type 'number)
 188
 189 (defcustom org-export-taskjuggler-default-project-version "1.0"
 190   "Default version string for the project."
 191   :group 'org-export-taskjuggler
 192   :type 'string)
 193
 194 (defcustom org-export-taskjuggler-default-project-duration 280
 195   "Default project duration if no start and end date have been defined
 196 in the root node of the task tree, i.e. the tree that has been marked
 197 with `org-export-taskjuggler-project-tag'"
 198   :group 'org-export-taskjuggler
 199   :type 'integer)
 200
 201 (defcustom org-export-taskjuggler-default-reports
 202   '("taskreport \"Gantt Chart\" {
 203   headline \"Project Gantt Chart\"
 204   columns hierarchindex, name, start, end, effort, duration, completed, chart
 205   timeformat \"%Y-%m-%d\"
 206   hideresource 1
 207   loadunit shortauto
 208 }"
 209 "resourcereport \"Resource Graph\" {
 210   headline \"Resource Allocation Graph\"
 211   columns no, name, utilization, freeload, chart
 212   loadunit shortauto
 213   sorttasks startup
 214   hidetask ~isleaf()
 215 }")
 216   "Default reports for the project."
 217   :group 'org-export-taskjuggler
 218   :type '(repeat (string :tag "Report")))
 219
 220 (defcustom org-export-taskjuggler-default-global-properties
 221   "shift s40 \"Part time shift\" {
 222   workinghours wed, thu, fri off
 223 }
 224 "
 225   "Default global properties for the project. Here you typically
 226 define global properties such as shifts, accounts, rates,
 227 vacation, macros and flags. Any property that is allowed within
 228 the TaskJuggler file can be inserted. You could for example
 229 include another TaskJuggler file.
 230
 231 The global properties are inserted after the project declaration
 232 but before any resource and task declarations."
 233   :group 'org-export-taskjuggler
 234   :type '(string :tag "Preamble"))
 235
 236 ;;; Hooks
 237
 238 (defvar org-export-taskjuggler-final-hook nil
 239   "Hook run at the end of TaskJuggler export, in the new buffer.")
 240
 241 ;;; Autoload functions:
 242
 243 ;; avoid compiler warning about free variable
 244 (defvar org-export-taskjuggler-old-level)
 245
 246 ;;;###autoload
 247 (defun org-export-as-taskjuggler ()
 248   "Export parts of the current buffer as a TaskJuggler file.
 249 The exporter looks for a tree with tag, property or todo that
 250 matches `org-export-taskjuggler-project-tag' and takes this as
 251 the tasks for this project. The first node of this tree defines
 252 the project properties such as project name and project period.
 253 If there is a tree with tag, property or todo that matches
 254 `org-export-taskjuggler-resource-tag' this three is taken as
 255 resources for the project. If no resources are specified, a
 256 default resource is created and allocated to the project. Also
 257 the taskjuggler project will be created with default reports as
 258 defined in `org-export-taskjuggler-default-reports'."
 259   (interactive)
 260
 261   (message "Exporting...")
 262   (setq-default org-done-keywords org-done-keywords)
 263   (let* ((tasks
 264           (org-taskjuggler-resolve-dependencies
 265            (org-taskjuggler-assign-task-ids
 266             (org-taskjuggler-compute-task-leafiness
 267              (org-map-entries
 268               '(org-taskjuggler-components)
 269               org-export-taskjuggler-project-tag nil 'archive 'comment)))))
 270          (resources
 271           (org-taskjuggler-assign-resource-ids
 272            (org-map-entries
 273             '(org-taskjuggler-components)
 274             org-export-taskjuggler-resource-tag nil 'archive 'comment)))
 275          (filename (expand-file-name
 276                     (concat
 277                      (file-name-sans-extension
 278                       (file-name-nondirectory buffer-file-name))
 279                      org-export-taskjuggler-extension)))
 280          (buffer (find-file-noselect filename))
 281          (org-export-taskjuggler-old-level 0)
 282          task resource)
 283     (unless tasks
 284       (error "No tasks specified"))
 285     ;; add a default resource
 286     (unless resources
 287       (setq resources
 288             `((("resource_id" . ,(user-login-name))
 289                ("headline" . ,user-full-name)
 290                ("level" . 1)))))
 291     ;; add a default allocation to the first task if none was given
 292     (unless (assoc "allocate" (car tasks))
 293       (let ((task (car tasks))
 294             (resource-id (cdr (assoc "resource_id" (car resources)))))
 295         (setcar tasks (push (cons "allocate" resource-id) task))))
 296     ;; add a default start date to the first task if none was given
 297     (unless (assoc "start" (car tasks))
 298       (let ((task (car tasks))
 299             (time-string (format-time-string "%Y-%m-%d")))
 300         (setcar tasks (push (cons "start" time-string) task))))
 301     ;; add a default version if none was given
 302     (unless (assoc "version" (car tasks))
 303       (let ((task (car tasks))
 304             (version org-export-taskjuggler-default-project-version))
 305         (setcar tasks (push (cons "version" version) task))))
 306     (with-current-buffer buffer
 307       (erase-buffer)
 308       (org-taskjuggler-open-project (car tasks))
 309       (insert org-export-taskjuggler-default-global-properties)
 310       (insert "\n")
 311       (dolist (resource resources)
 312         (let ((level (cdr (assoc "level" resource))))
 313           (org-taskjuggler-close-maybe level)
 314           (org-taskjuggler-open-resource resource)
 315           (setq org-export-taskjuggler-old-level level)))
 316       (org-taskjuggler-close-maybe 1)
 317       (setq org-export-taskjuggler-old-level 0)
 318       (dolist (task tasks)
 319         (let ((level (cdr (assoc "level" task))))
 320           (org-taskjuggler-close-maybe level)
 321           (org-taskjuggler-open-task task)
 322           (setq org-export-taskjuggler-old-level level)))
 323       (org-taskjuggler-close-maybe 1)
 324       (org-taskjuggler-insert-reports)
 325       (save-buffer)
 326       (or (org-export-push-to-kill-ring "TaskJuggler")
 327           (message "Exporting... done"))
 328       (current-buffer))))
 329
 330 ;;;###autoload
 331 (defun org-export-as-taskjuggler-and-open ()
 332   "Export the current buffer as a TaskJuggler file and open it
 333 with the TaskJuggler GUI."
 334   (interactive)
 335   (let* ((file-name (buffer-file-name (org-export-as-taskjuggler)))
 336          (process-name "TaskJugglerUI")
 337          (command (concat process-name " " file-name)))
 338     (start-process-shell-command process-name nil command)))
 339
 340 (defun org-taskjuggler-targeting-tj3-p ()
 341   "Return true if we are targeting TaskJuggler III."
 342   (>= org-export-taskjuggler-target-version 3.0))
 343
 344 (defun org-taskjuggler-parent-is-ordered-p ()
 345   "Return true if the parent of the current node has a property
 346 \"ORDERED\". Return nil otherwise."
 347   (save-excursion
 348     (and (org-up-heading-safe) (org-entry-get (point) "ORDERED"))))
 349
 350 (defun org-taskjuggler-components ()
 351   "Return an alist containing all the pertinent information for
 352 the current node such as the headline, the level, todo state
 353 information, all the properties, etc."
 354   (let* ((props (org-entry-properties))
 355          (components (org-heading-components))
 356          (level (nth 1 components))
 357          (headline
 358           (replace-regexp-in-string
 359            "\"" "\\\"" (nth 4 components) t t)) ; quote double quotes in headlines
 360          (parent-ordered (org-taskjuggler-parent-is-ordered-p)))
 361     (push (cons "level" level) props)
 362     (push (cons "headline" headline) props)
 363     (push (cons "parent-ordered" parent-ordered) props)))
 364
 365 (defun org-taskjuggler-assign-task-ids (tasks)
 366   "Given a list of tasks return the same list assigning a unique id
 367 and the full path to each task. Taskjuggler takes hierarchical ids.
 368 For that reason we have to make ids locally unique and we have to keep
 369 a path to the current task."
 370   (let ((previous-level 0)
 371         unique-ids unique-id
 372         path
 373         task resolved-tasks tmp)
 374     (dolist (task tasks resolved-tasks)
 375       (let ((level (cdr (assoc "level" task))))
 376         (cond
 377          ((< previous-level level)
 378           (setq unique-id (org-taskjuggler-get-unique-id task (car unique-ids)))
 379           (dotimes (tmp (- level previous-level))
 380             (push (list unique-id) unique-ids)
 381             (push unique-id path)))
 382          ((= previous-level level)
 383           (setq unique-id (org-taskjuggler-get-unique-id task (car unique-ids)))
 384           (push unique-id (car unique-ids))
 385           (setcar path unique-id))
 386          ((> previous-level level)
 387           (dotimes (tmp (- previous-level level))
 388             (pop unique-ids)
 389             (pop path))
 390           (setq unique-id (org-taskjuggler-get-unique-id task (car unique-ids)))
 391           (push unique-id (car unique-ids))
 392           (setcar path unique-id)))
 393         (push (cons "unique-id" unique-id) task)
 394         (push (cons "path" (mapconcat 'identity (reverse path) ".")) task)
 395         (setq previous-level level)
 396         (setq resolved-tasks (append resolved-tasks (list task)))))))
 397
 398 (defun org-taskjuggler-compute-task-leafiness (tasks)
 399   "Figure out if each task is a leaf by looking at it's level,
 400 and the level of its successor. If the successor is higher (ie
 401 deeper), then it's not a leaf."
 402   (let (new-list)
 403     (while (car tasks)
 404       (let ((task (car tasks))
 405             (successor (car (cdr tasks))))
 406         (cond
 407          ;; if a task has no successors it is a leaf
 408          ((null successor)
 409           (push (cons (cons "leaf-node" t) task) new-list))
 410          ;; if the successor has a lower level than task it is a leaf
 411          ((<= (cdr (assoc "level" successor)) (cdr (assoc "level" task)))
 412           (push (cons (cons "leaf-node" t) task) new-list))
 413          ;; otherwise examine the rest of the tasks
 414          (t (push task new-list))))
 415       (setq tasks (cdr tasks)))
 416     (nreverse new-list)))
 417
 418 (defun org-taskjuggler-assign-resource-ids (resources)
 419   "Given a list of resources return the same list, assigning a
 420 unique id to each resource."
 421   (cond
 422    ((null resources) nil)
 423    (t
 424     (let* ((resource (car resources))
 425            (unique-id (org-taskjuggler-get-unique-id resource unique-ids)))
 426       (push (cons "unique-id" unique-id) resource)
 427       (cons resource
 428             (org-taskjuggler-assign-resource-ids (cdr resources)
 429                                                  (cons unique-id unique-ids)))))))
 430
 431 (defun org-taskjuggler-resolve-dependencies (tasks)
 432   (let ((previous-level 0)
 433         siblings
 434         task resolved-tasks)
 435     (dolist (task tasks resolved-tasks)
 436       (let* ((level (cdr (assoc "level" task)))
 437              (depends (cdr (assoc "depends" task)))
 438              (parent-ordered (cdr (assoc "parent-ordered" task)))
 439              (blocker (cdr (assoc "BLOCKER" task)))
 440              (blocked-on-previous
 441               (and blocker (string-match "previous-sibling" blocker)))
 442              (dependencies
 443               (org-taskjuggler-resolve-explicit-dependencies
 444                (append
 445                 (and depends (org-taskjuggler-tokenize-dependencies depends))
 446                 (and blocker (org-taskjuggler-tokenize-dependencies blocker)))
 447                tasks))
 448               previous-sibling)
 449         ; update previous sibling info
 450         (cond
 451          ((< previous-level level)
 452           (dotimes (tmp (- level previous-level))
 453             (push task siblings)))
 454          ((= previous-level level)
 455           (setq previous-sibling (car siblings))
 456           (setcar siblings task))
 457          ((> previous-level level)
 458           (dotimes (tmp (- previous-level level))
 459             (pop siblings))
 460           (setq previous-sibling (car siblings))
 461           (setcar siblings task)))
 462         ; insert a dependency on previous sibling if the parent is
 463         ; ordered or if the tasks has a BLOCKER attribute with value "previous-sibling"
 464         (when (or (and previous-sibling parent-ordered) blocked-on-previous)
 465           (push (format "!%s" (cdr (assoc "unique-id" previous-sibling))) dependencies))
 466         ; store dependency information
 467         (when dependencies
 468           (push (cons "depends" (mapconcat 'identity dependencies ", ")) task))
 469         (setq previous-level level)
 470         (setq resolved-tasks (append resolved-tasks (list task)))))))
 471
 472 (defun org-taskjuggler-tokenize-dependencies (dependencies)
 473   "Split a dependency property value DEPENDENCIES into the
 474 individual dependencies and return them as a list while keeping
 475 the optional arguments (such as gapduration) for the
 476 dependencies. A dependency will have to match `[-a-zA-Z0-9_]+'."
 477   (cond
 478    ((string-match "^ *$" dependencies) nil)
 479    ((string-match "^[ \t]*\\([-a-zA-Z0-9_]+\\([ \t]*{[^}]+}\\)?\\)[ \t,]*" dependencies)
 480     (cons
 481      (substring dependencies (match-beginning 1) (match-end 1))
 482      (org-taskjuggler-tokenize-dependencies (substring dependencies (match-end 0)))))
 483    (t (error (format "invalid dependency id %s" dependencies)))))
 484
 485 (defun org-taskjuggler-resolve-explicit-dependencies (dependencies tasks)
 486   "For each dependency in DEPENDENCIES try to find a
 487 corresponding task with a matching property \"task_id\" in TASKS.
 488 Return a list containing the resolved links for all DEPENDENCIES
 489 where a matching tasks was found. If the dependency is
 490 \"previous-sibling\" it is ignored (as this is dealt with in
 491 `org-taskjuggler-resolve-dependencies'). If there is no matching
 492 task the dependency is ignored and a warning is displayed ."
 493   (unless (null dependencies)
 494     (let*
 495         ;; the dependency might have optional attributes such as "{
 496         ;; gapduration 5d }", so only use the first string as id for the
 497         ;; dependency
 498         ((dependency (car dependencies))
 499          (id (car (split-string dependency)))
 500          (optional-attributes
 501           (mapconcat 'identity (cdr (split-string dependency)) " "))
 502          (path (org-taskjuggler-find-task-with-id id tasks)))
 503       (cond
 504        ;; ignore previous sibling dependencies
 505        ((equal (car dependencies) "previous-sibling")
 506         (org-taskjuggler-resolve-explicit-dependencies (cdr dependencies) tasks))
 507        ;; if the id is found in another task use its path
 508        ((not (null path))
 509         (cons (mapconcat 'identity (list path optional-attributes) " ")
 510               (org-taskjuggler-resolve-explicit-dependencies
 511                (cdr dependencies) tasks)))
 512        ;; warn about dangling dependency but otherwise ignore it
 513        (t (display-warning
 514            'org-export-taskjuggler
 515            (format "No task with matching property \"task_id\" found for id %s" id))
 516           (org-taskjuggler-resolve-explicit-dependencies (cdr dependencies) tasks))))))
 517
 518 (defun org-taskjuggler-find-task-with-id (id tasks)
 519   "Find ID in tasks. If found return the path of task. Otherwise
 520 return nil."
 521   (let ((task-id (cdr (assoc "task_id" (car tasks))))
 522         (path (cdr (assoc "path" (car tasks)))))
 523     (cond
 524      ((null tasks) nil)
 525      ((equal task-id id) path)
 526      (t (org-taskjuggler-find-task-with-id id (cdr tasks))))))
 527
 528 (defun org-taskjuggler-get-unique-id (item unique-ids)
 529   "Return a unique id for an ITEM which can be a task or a resource.
 530 The id is derived from the headline and made unique against
 531 UNIQUE-IDS. If the (downcased) first token of the headline is not
 532 unique try to add more (downcased) tokens of the headline or
 533 finally add more underscore characters (\"_\")."
 534   (let* ((headline (cdr (assoc "headline" item)))
 535          (parts (split-string headline))
 536          (id (org-taskjuggler-clean-id (downcase (pop parts)))))
 537     ; try to add more parts of the headline to make it unique
 538     (while (and (member id unique-ids) (car parts))
 539       (setq id (concat id "_" (org-taskjuggler-clean-id (downcase (pop parts))))))
 540     ; if its still not unique add "_"
 541     (while (member id unique-ids)
 542       (setq id (concat id "_")))
 543     id))
 544
 545 (defun org-taskjuggler-clean-id (id)
 546   "Clean and return ID to make it acceptable for taskjuggler."
 547   (and id (replace-regexp-in-string "[^a-zA-Z0-9_]" "_" id)))
 548
 549 (defun org-taskjuggler-open-project (project)
 550   "Insert the beginning of a project declaration. All valid
 551 attributes from the PROJECT alist are inserted. If no end date is
 552 specified it is calculated
 553 `org-export-taskjuggler-default-project-duration' days from now."
 554   (let* ((unique-id (cdr (assoc "unique-id" project)))
 555         (headline (cdr (assoc "headline" project)))
 556         (version (cdr (assoc "version" project)))
 557         (start (cdr (assoc "start" project)))
 558         (end (cdr (assoc "end" project))))
 559     (insert
 560      (format "project %s \"%s\" \"%s\" %s +%sd {\n }\n"
 561              unique-id headline version start
 562              org-export-taskjuggler-default-project-duration))))
 563
 564 (defun org-taskjuggler-filter-and-join (items)
 565   "Filter all nil elements from ITEMS and join the remaining ones
 566 with separator \"\n\"."
 567   (let ((filtered-items (remq nil items)))
 568     (and filtered-items (mapconcat 'identity filtered-items "\n"))))
 569
 570 (defun org-taskjuggler-get-attributes (item attributes)
 571   "Return all attribute as a single formated string. ITEM is an
 572 alist representing either a resource or a task. ATTRIBUTES is a
 573 list of symbols. Only entries from ITEM are considered that are
 574 listed in ATTRIBUTES."
 575   (org-taskjuggler-filter-and-join
 576    (mapcar
 577     (lambda (attribute)
 578       (org-taskjuggler-filter-and-join
 579        (org-taskjuggler-get-attribute item attribute)))
 580     attributes)))
 581
 582 (defun org-taskjuggler-get-attribute (item attribute)
 583   "Return a list of strings containing the properly formatted
 584 taskjuggler declaration for a given ATTRIBUTE in ITEM (an alist).
 585 If the ATTRIBUTE is not in ITEM return nil."
 586   (cond
 587    ((null item) nil)
 588    ((equal (symbol-name attribute) (car (car item)))
 589     (cons (format "%s %s" (symbol-name attribute) (cdr (car item)))
 590           (org-taskjuggler-get-attribute (cdr item) attribute)))
 591    (t (org-taskjuggler-get-attribute (cdr item) attribute))))
 592
 593 (defun org-taskjuggler-open-resource (resource)
 594   "Insert the beginning of a resource declaration. All valid
 595 attributes from the RESOURCE alist are inserted. If the RESOURCE
 596 defines a property \"resource_id\" it will be used as the id for
 597 this resource. Otherwise it will use the ID property. If neither
 598 is defined it will calculate a unique id for the resource using
 599 `org-taskjuggler-get-unique-id'."
 600   (let ((id (org-taskjuggler-clean-id
 601              (or (cdr (assoc "resource_id" resource))
 602                  (cdr (assoc "ID" resource))
 603                  (cdr (assoc "unique-id" resource)))))
 604         (headline (cdr (assoc "headline" resource)))
 605         (attributes '(limits vacation shift booking efficiency journalentry rate)))
 606     (insert
 607      (concat
 608       "resource " id " \"" headline "\" {\n "
 609       (org-taskjuggler-get-attributes resource attributes) "\n"))))
 610
 611 (defun org-taskjuggler-clean-effort (effort)
 612   "Translate effort strings into a format acceptable to taskjuggler,
 613 i.e. REAL UNIT. If the effort string is something like 5:30 it
 614 will be assumed to be hours and will be translated into 5.5h.
 615 Otherwise if it contains something like 3.0 it is assumed to be
 616 days and will be translated into 3.0d. Other formats that
 617 taskjuggler supports (like weeks, months and years) are currently
 618 not supported."
 619   (cond
 620    ((null effort) effort)
 621    ((string-match "\\([0-9]+\\):\\([0-9]+\\)" effort)
 622     (let ((hours (string-to-number (match-string 1 effort)))
 623           (minutes (string-to-number (match-string 2 effort))))
 624       (format "%dh" (+ hours (/ minutes 60.0)))))
 625    ((string-match "\\([0-9]+\\).\\([0-9]+\\)" effort) (concat effort "d"))
 626    (t (error "Not a valid effort (%s)" effort))))
 627
 628 (defun org-taskjuggler-get-priority (priority)
 629   "Return a priority between 1 and 1000 based on PRIORITY, an
 630 org-mode priority string."
 631   (max 1 (/ (* 1000 (- org-lowest-priority (string-to-char priority)))
 632             (- org-lowest-priority org-highest-priority))))
 633
 634 (defun org-taskjuggler-open-task (task)
 635   (let* ((unique-id (cdr (assoc "unique-id" task)))
 636         (headline (cdr (assoc "headline" task)))
 637         (effort (org-taskjuggler-clean-effort (cdr (assoc org-effort-property task))))
 638         (depends (cdr (assoc "depends" task)))
 639         (allocate (cdr (assoc "allocate" task)))
 640         (priority-raw (cdr (assoc "PRIORITY" task)))
 641         (priority (and priority-raw (org-taskjuggler-get-priority priority-raw)))
 642         (state (cdr (assoc "TODO" task)))
 643         (complete (or (and (member state org-done-keywords) "100")
 644                       (cdr (assoc "complete" task))))
 645         (parent-ordered (cdr (assoc "parent-ordered" task)))
 646         (previous-sibling (cdr (assoc "previous-sibling" task)))
 647         (milestone (or (cdr (assoc "milestone" task))
 648                        (and (assoc "leaf-node" task)
 649                             (not (or effort
 650                                      (cdr (assoc "duration" task))
 651                                      (cdr (assoc "end" task))
 652                                      (cdr (assoc "period" task)))))))
 653         (attributes
 654          '(account start note duration endbuffer endcredit end
 655            flags journalentry length maxend maxstart minend
 656            minstart period reference responsible scheduling
 657            startbuffer startcredit statusnote)))
 658     (insert
 659      (concat
 660       "task " unique-id " \"" headline "\" {\n"
 661       (if (and parent-ordered previous-sibling)
 662           (format " depends %s\n" previous-sibling)
 663         (and depends (format " depends %s\n" depends)))
 664       (and allocate (format " purge %s\n allocate %s\n"
 665                             (or (and (org-taskjuggler-targeting-tj3-p) "allocations")
 666                                 "allocate")
 667                             allocate))
 668       (and complete (format " complete %s\n" complete))
 669       (and effort (format " effort %s\n" effort))
 670       (and priority (format " priority %s\n" priority))
 671       (and milestone (format " milestone\n"))
 672
 673       (org-taskjuggler-get-attributes task attributes)
 674       "\n"))))
 675
 676 (defun org-taskjuggler-close-maybe (level)
 677   (while (> org-export-taskjuggler-old-level level)
 678     (insert "}\n")
 679     (setq org-export-taskjuggler-old-level (1- org-export-taskjuggler-old-level)))
 680   (when (= org-export-taskjuggler-old-level level)
 681     (insert "}\n")))
 682
 683 (defun org-taskjuggler-insert-reports ()
 684   (let (report)
 685     (dolist (report org-export-taskjuggler-default-reports)
 686       (insert report "\n"))))
 687
 688 (provide 'org-taskjuggler)
 689
 690 ;;; org-taskjuggler.el ends here