1 ;;; ox-taskjuggler.el --- TaskJuggler Back-End for Org Export Engine
3 ;; Copyright (C) 2007-2013 Free Software Foundation, Inc.
5 ;; Emacs Lisp Archive Entry
6 ;; Filename: ox-taskjuggler.el
7 ;; Author: Christian Egli
8 ;; Nicolas Goaziou <n dot goaziou at gmail dot com>
9 ;; Maintainer: Christian Egli
10 ;; Keywords: org, taskjuggler, project planning
11 ;; Description: Converts an Org mode buffer into a TaskJuggler project plan
13 ;; This file is not part of GNU Emacs.
15 ;; This program is free software: you can redistribute it and/or modify
16 ;; it under the terms of the GNU General Public License as published by
17 ;; the Free Software Foundation, either version 3 of the License, or
18 ;; (at your option) any later version.
20 ;; This program is distributed in the hope that it will be useful,
21 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
22 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 ;; GNU General Public License for more details.
25 ;; You should have received a copy of the GNU General Public License
26 ;; along with this program. If not, see <http://www.gnu.org/licenses/>.
30 ;; This library implements a TaskJuggler exporter for Org mode.
31 ;; TaskJuggler uses a text format to define projects, tasks and
32 ;; resources, so it is a natural fit for Org mode. It can produce all
33 ;; sorts of reports for tasks or resources in either HTML, CSV or PDF.
34 ;; The current version of TaskJuggler requires KDE but the next
35 ;; version is implemented in Ruby and should therefore run on any
38 ;; The exporter does not export all the nodes of a document or
39 ;; strictly follow the order of the nodes in the document.
41 ;; Instead the TaskJuggler exporter looks for a tree that defines the
42 ;; tasks and a optionally tree that defines the resources for this
43 ;; project. It then creates a TaskJuggler file based on these trees
44 ;; and the attributes defined in all the nodes.
48 ;; Put this file into your load-path and the following line into your
51 ;; (add-to-list 'org-export-backends 'taskjuggler)
53 ;; or customize `org-export-backends' variable.
55 ;; The interactive functions are the following:
57 ;; M-x `org-taskjuggler-export'
58 ;; M-x `org-taskjuggler-export-and-open'
62 ;; Let's illustrate the usage with a small example. Create your tasks
63 ;; as you usually do with org-mode. Assign efforts to each task using
64 ;; properties (it's easiest to do this in the column view). You
65 ;; should end up with something similar to the example by Peter Jones
68 ;; http://www.contextualdevelopment.com/static/artifacts/articles/2008/project-planning/project-planning.org.
70 ;; Now mark the top node of your tasks with a tag named
71 ;; "taskjuggler_project" (or whatever you customized
72 ;; `org-taskjuggler-project-tag' to). You are now ready to export the
73 ;; project plan with `org-taskjuggler-export-and-open' which will
74 ;; export the project plan and open a Gantt chart in TaskJugglerUI.
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-taskjuggler-resource-tag' to). You can optionally
82 ;; assign an identifier (named "resource_id") to the resources (using
83 ;; the standard org properties commands) or you can let the exporter
84 ;; generate identifiers automatically (the exporter picks the first
85 ;; word of the headline as the identifier as long as it is unique, see
86 ;; the documentation of `org-taskjuggler--build-unique-id'). Using that
87 ;; identifier you can then allocate resources to tasks. This is again
88 ;; done with the "allocate" property on the tasks. Do this in column
89 ;; view or when on the task type
91 ;; C-c C-x p allocate RET <resource_id> RET
93 ;; Once the allocations are done you can again export to TaskJuggler
94 ;; and check in the Resource Allocation Graph which person is working
95 ;; on what task at what time.
97 ;; * Export of properties
99 ;; The exporter also takes TODO state information into consideration,
100 ;; i.e. if a task is marked as done it will have the corresponding
101 ;; attribute in TaskJuggler ("complete 100"). Also it will export any
102 ;; property on a task resource or resource node which is known to
103 ;; TaskJuggler, such as limits, vacation, shift, booking, efficiency,
104 ;; journalentry, rate for resources or account, start, note, duration,
105 ;; end, journalentry, milestone, reference, responsible, scheduling,
110 ;; The exporter will handle dependencies that are defined in the tasks
111 ;; either with the ORDERED attribute (see TODO dependencies in the Org
112 ;; mode manual) or with the BLOCKER attribute (see org-depend.el) or
113 ;; alternatively with a depends attribute. Both the BLOCKER and the
114 ;; depends attribute can be either "previous-sibling" or a reference
115 ;; to an identifier (named "task_id") which is defined for another
116 ;; task in the project. BLOCKER and the depends attribute can define
117 ;; multiple dependencies separated by either space or comma. You can
118 ;; also specify optional attributes on the dependency by simply
119 ;; appending it. The following examples should illustrate this:
121 ;; * Training material
123 ;; :task_id: training_material
126 ;; ** Markup Guidelines
130 ;; ** Workflow Guidelines
137 ;; :BLOCKER: training_material { gapduration 1d } some_other_task
141 ;; - Look at org-file-properties, org-global-properties and
142 ;; org-global-properties-fixed
143 ;; - What about property inheritance and org-property-inherit-p?
144 ;; - Use TYPE_TODO as an way to assign resources
148 (eval-when-compile (require 'cl
))
156 (defgroup org-export-taskjuggler nil
157 "Options specific for TaskJuggler export back-end."
158 :tag
"Org Export TaskJuggler"
161 (defcustom org-taskjuggler-extension
".tjp"
162 "Extension of TaskJuggler files."
163 :group
'org-export-taskjuggler
166 (defcustom org-taskjuggler-project-tag
"taskjuggler_project"
167 "Tag marking project's tasks.
168 This tag is used to find the tree containing all the tasks for
170 :group
'org-export-taskjuggler
173 (defcustom org-taskjuggler-resource-tag
"taskjuggler_resource"
174 "Tag marking project's resources.
175 This tag is used to find the tree containing all the resources
177 :group
'org-export-taskjuggler
180 (defcustom org-taskjuggler-report-tag
"taskjuggler_report"
181 "Tag marking project's reports.
182 This tag is used to find the tree containing all the reports for
184 :group
'org-export-taskjuggler
187 (defcustom org-taskjuggler-target-version
3.0
188 "Which version of TaskJuggler the exporter is targeting."
189 :group
'org-export-taskjuggler
192 (defcustom org-taskjuggler-default-project-version
"1.0"
193 "Default version string for the project.
194 This value can also be set with the \":VERSION:\" property
195 associated to the headline defining the project."
196 :group
'org-export-taskjuggler
199 (defcustom org-taskjuggler-default-project-duration
280
200 "Default project duration.
201 The value will be used if no start and end date have been defined
202 in the root node of the task tree, i.e. the tree that has been
203 marked with `org-taskjuggler-project-tag'"
204 :group
'org-export-taskjuggler
207 (defcustom org-taskjuggler-default-reports
208 '("taskreport \"Gantt Chart\" {
209 headline \"Project Gantt Chart\"
210 columns hierarchindex, name, start, end, effort, duration, completed, chart
211 timeformat \"%Y-%m-%d\"
215 "resourcereport \"Resource Graph\" {
216 headline \"Resource Allocation Graph\"
217 columns no, name, utilization, freeload, chart
222 "Default reports for the project."
223 :group
'org-export-taskjuggler
224 :type
'(repeat (string :tag
"Report")))
226 (defcustom org-taskjuggler-default-global-header
""
227 "Default global header for the project.
228 This goes before project declaration, and might be useful for
230 :group
'org-export-taskjuggler
231 :type
'(string :tag
"Preamble"))
233 (defcustom org-taskjuggler-default-global-properties
234 "shift s40 \"Part time shift\" {
235 workinghours wed, thu, fri off
238 "Default global properties for the project.
240 Here you typically define global properties such as shifts,
241 accounts, rates, vacation, macros and flags. Any property that
242 is allowed within the TaskJuggler file can be inserted. You
243 could for example include another TaskJuggler file.
245 The global properties are inserted after the project declaration
246 but before any resource and task declarations."
247 :group
'org-export-taskjuggler
248 :type
'(string :tag
"Preamble"))
250 (defcustom org-taskjuggler-valid-task-attributes
251 '(account start note duration endbuffer endcredit end
252 flags journalentry length limits maxend maxstart minend
253 minstart period reference responsible scheduling
254 startbuffer startcredit statusnote chargeset charge
)
255 "Valid attributes for Taskjuggler tasks.
256 If one of these appears as a property for a headline, it will be
257 exported with the corresponding task."
258 :group
'org-export-taskjuggler
)
260 (defcustom org-taskjuggler-valid-resource-attributes
261 '(limits vacation shift booking efficiency journalentry rate
263 "Valid attributes for Taskjuggler resources.
264 If one of these appears as a property for a headline, it will be
265 exported with the corresponding resource."
266 :group
'org-export-taskjuggler
)
268 (defcustom org-taskjuggler-valid-report-attributes
269 '(headline columns definitions timeformat hideresource hidetask
270 loadunit sorttasks formats period
)
271 "Valid attributes for Taskjuggler reports.
272 If one of these appears as a property for a headline, it will be
273 exported with the corresponding report."
274 :group
'org-export-taskjuggler
)
276 (defcustom org-taskjuggler-keep-project-as-task t
277 "Non-nil keeps the project headline as an umbrella task for all tasks.
278 Setting this to nil will allow maintaining completely separated
279 task buckets, while still sharing the same resources pool."
280 :group
'org-export-taskjuggler
287 (defvar org-taskjuggler-final-hook nil
288 "Hook run after a TaskJuggler files has been saved.
289 This hook is run with the name of the file as argument.")
293 ;;; Back-End Definition
295 (org-export-define-backend taskjuggler
296 ((template . org-taskjuggler-project-plan
))
298 (?J
"Export to TaskJuggler"
299 ((?j
"As TJP file" (lambda (a s v b
) (org-taskjuggler-export a s v
)))
300 (?o
"As TJP file and open"
302 (if a
(org-taskjuggler-export a s v
)
303 (org-taskjuggler-export-and-open s v
))))))
304 ;; This property will be used to store unique ids in communication
305 ;; channel. Ids will be retrieved with `org-taskjuggler-get-id'.
306 :options-alist
((:taskjuggler-unique-ids nil nil nil
)))
312 (defun org-taskjuggler-assign-task-ids (tasks info
)
313 "Assign a unique ID to each task in TASKS.
314 TASKS is a list of headlines. Return value is an alist between
315 headlines and their associated ID. IDs are hierarchical, which
316 means they only need to be unique among the task siblings."
319 (lambda (tasks local-ids
)
320 (org-element-map tasks
'headline
322 (let ((id (org-taskjuggler--build-unique-id task local-ids
)))
324 (push (cons task id
) alist
)
325 (funcall build-id
(org-element-contents task
) nil
)))
326 info nil
'headline
))))
327 (funcall build-id tasks nil
)
330 (defun org-taskjuggler-assign-resource-ids (resources info
)
331 "Assign a unique ID to each resource within RESOURCES.
332 RESOURCES is a list of headlines. Return value is an alist
333 between headlines and their associated ID."
335 (org-element-map resources
'headline
337 (let ((id (org-taskjuggler--build-unique-id resource ids
)))
346 (defun org-taskjuggler-get-project (info)
347 "Return project in parse tree.
348 INFO is a plist used as a communication channel. First headline
349 in buffer with `org-taskjuggler-project-tag' defines the project.
350 If no such task is defined, pick the first headline in buffer.
351 If there is no headline at all, return nil."
352 (or (org-element-map (plist-get info
:parse-tree
) 'headline
354 (and (member org-taskjuggler-project-tag
355 (org-export-get-tags hl info
))
358 (org-element-map tree
'headline
'identity info t
)))
360 (defun org-taskjuggler-get-id (item info
)
361 "Return id for task or resource ITEM.
362 ITEM is a headline. Return value is a string."
363 (cdr (assq item
(plist-get info
:taskjuggler-unique-ids
))))
365 (defun org-taskjuggler-get-name (item)
366 "Return name for task or resource ITEM.
367 ITEM is a headline. Return value is a string."
368 ;; Quote double quotes in name.
369 (replace-regexp-in-string
370 "\"" "\\\"" (org-element-property :raw-value item
) t t
))
372 (defun org-taskjuggler-get-start (item)
373 "Return start date for task or resource ITEM.
374 ITEM is a headline. Return value is a string or nil if ITEM
375 doesn't have any start date defined.."
376 (let ((scheduled (org-element-property :scheduled item
)))
377 (and scheduled
(org-timestamp-format scheduled
"%Y-%02m-%02d"))))
379 (defun org-taskjuggler-get-end (item)
380 "Return end date for task or resource ITEM.
381 ITEM is a headline. Return value is a string or nil if ITEM
382 doesn't have any end date defined.."
383 (let ((deadline (org-element-property :deadline item
)))
384 (and deadline
(org-timestamp-format deadline
"%Y-%02m-%02d"))))
388 ;;; Internal Functions
390 (defun org-taskjuggler--indent-string (s)
391 "Indent string S by 2 spaces.
392 Return new string. If S is the empty string, return it."
393 (if (equal "" s
) s
(replace-regexp-in-string "^ *\\S-" " \\&" s
)))
395 (defun org-taskjuggler--build-attributes (item attributes
)
396 "Return attributes string for task, resource or report ITEM.
397 ITEM is a headline. ATTRIBUTES is a list of symbols
398 representing valid attributes for ITEM."
401 (let ((value (org-element-property
402 (intern (upcase (format ":%s" attribute
)))
404 (and value
(format "%s %s\n" attribute value
))))
405 (remq nil attributes
) ""))
407 (defun org-taskjuggler--build-unique-id (item unique-ids
)
408 "Return a unique id for a given task or a resource.
409 ITEM is an `headline' type element representing the task or
410 resource. Its id is derived from its name and made unique
411 against UNIQUE-IDS. If the (downcased) first token of the
412 headline is not unique try to add more (downcased) tokens of the
413 headline or finally add more underscore characters (\"_\")."
414 (let* ((parts (org-split-string (org-element-property :raw-value item
)))
415 (id (org-taskjuggler--clean-id (downcase (pop parts
)))))
416 ;; Try to add more parts of the headline to make it unique.
417 (while (and (car parts
) (member id unique-ids
))
418 (setq id
(concat id
"_"
419 (org-taskjuggler--clean-id (downcase (pop parts
))))))
420 ;; If it's still not unique, add "_".
421 (while (member id unique-ids
)
422 (setq id
(concat id
"_")))
425 (defun org-taskjuggler--clean-id (id)
426 "Clean and return ID to make it acceptable for TaskJuggler.
428 ;; Replace non-ascii by "_".
429 (replace-regexp-in-string
431 ;; Make sure id doesn't start with a number.
432 (replace-regexp-in-string "^\\([0-9]\\)" "_\\1" id
)))
438 (defun org-taskjuggler-resolve-dependencies (task info
)
439 "Return a list of all tasks TASK depends on.
440 TASK is a headline. INFO is a plist used as a communication
443 ;; Get all dependencies specified in BLOCKER and DEPENDS task
444 ;; properties. Clean options from them.
445 (let ((deps (concat (org-element-property :BLOCKER task
)
446 (org-element-property :DEPENDS task
))))
448 (org-split-string (replace-regexp-in-string "{.*?}" "" deps
)
452 ;; Find tasks with :task_id: property matching id in DEPS-IDS.
453 ;; Add them to DEPENDS.
454 (let* ((project (org-taskjuggler-get-project info
))
455 (tasks (if org-taskjuggler-keep-project-as-task project
456 (org-element-contents project
))))
458 (org-element-map tasks
'headline
460 (let ((task-id (org-element-property :TASK_ID task
)))
461 (and task-id
(member task-id deps-ids
) task
)))
463 ;; Check BLOCKER and DEPENDS properties. If "previous-sibling"
464 ;; belongs to DEPS-ID, add it to DEPENDS.
465 (when (and (member-ignore-case "previous-sibling" deps-ids
)
466 (not (org-export-first-sibling-p task info
)))
467 (let ((prev (org-export-get-previous-element task info
)))
468 (and (not (memq prev depends
)) (push prev depends
)))))
469 ;; Check ORDERED status of parent.
470 (let ((parent (org-export-get-parent task
)))
472 (org-element-property :ORDERED parent
)
473 (not (org-export-first-sibling-p task info
)))
474 (push (org-export-get-previous-element task info
) depends
)))
475 ;; Return dependencies.
478 (defun org-taskjuggler-format-dependencies (dependencies task info
)
479 "Format DEPENDENCIES to match TaskJuggler syntax.
480 DEPENDENCIES is list of dependencies for TASK, as returned by
481 `org-taskjuggler-resolve-depedencies'. TASK is a headline.
482 INFO is a plist used as a communication channel. Return value
483 doesn't include leading \"depends\"."
484 (let ((dep-str (concat (org-element-property :BLOCKER task
)
486 (org-element-property :DEPENDS task
)))
489 ;; Return path to DEP relatively to TASK.
490 (let ((parent (org-export-get-parent dep
))
493 (let ((id (org-element-property :TASK_ID dep
)))
495 (string-match (concat id
" +\\({.*?}\\)") dep-str
)
496 (org-match-string-no-properties 1))))
498 ;; Compute number of exclamation marks.
499 (while (not (org-element-map parent
'headline
500 (lambda (task) (eq task dep
))))
502 (setq parent
(org-export-get-parent parent
)))
503 ;; Build path from DEP to PARENT.
504 (while (not (eq parent dep
))
505 (push (org-taskjuggler-get-id dep info
) path
)
506 (setq dep
(org-export-get-parent dep
)))
507 ;; Return full path. Add dependency options, if any.
508 (concat (make-string exclamations ?
!)
509 (mapconcat 'identity path
".")
510 (and option
(concat " " option
)))))))
511 ;; Return dependencies string, without the leading "depends".
512 (mapconcat (lambda (dep) (funcall get-path dep
)) dependencies
", ")))
516 ;;; Translator Functions
518 (defun org-taskjuggler-project-plan (contents info
)
519 "Build TaskJuggler project plan.
520 CONTENTS is ignored. INFO is a plist holding export options.
521 Return complete project plan as a string in TaskJuggler syntax."
522 (let* ((tree (plist-get info
:parse-tree
))
523 (project (or (org-taskjuggler-get-project info
)
524 (error "No project specified"))))
527 (org-element-normalize-string org-taskjuggler-default-global-header
)
528 ;; 2. Insert project.
529 (org-taskjuggler--build-project project info
)
530 ;; 3. Insert global properties.
531 (org-element-normalize-string org-taskjuggler-default-global-properties
)
532 ;; 4. Insert resources. Provide a default one if none is
534 (let ((main-resources
535 ;; Collect contents from various trees marked with
536 ;; `org-taskjuggler-resource-tag'. Only gather top level
539 (org-element-map tree
'headline
541 (and (member org-taskjuggler-resource-tag
542 (org-export-get-tags hl info
))
543 (org-element-map (org-element-contents hl
) 'headline
544 'identity info nil
'headline
)))
545 info nil
'headline
))))
546 ;; Assign a unique ID to each resource. Store it under
547 ;; `:taskjuggler-unique-ids' property in INFO.
549 (plist-put info
:taskjuggler-unique-ids
550 (org-taskjuggler-assign-resource-ids
551 main-resources info
)))
555 (lambda (resource) (org-taskjuggler--build-resource resource info
))
557 (format "resource %s \"%s\" {\n}\n" (user-login-name) user-full-name
))
560 ;; If `org-taskjuggler-keep-project-as-task' is
561 ;; non-nil, there is only one task. Otherwise, every
562 ;; direct children of PROJECT is a top level task.
563 (if org-taskjuggler-keep-project-as-task
(list project
)
564 (or (org-element-map (org-element-contents project
) 'headline
565 'identity info nil
'headline
)
566 (error "No task specified")))))
567 ;; Assign a unique ID to each task. Add it to
568 ;; `:taskjuggler-unique-ids' property in INFO.
570 (plist-put info
:taskjuggler-unique-ids
572 (org-taskjuggler-assign-task-ids main-tasks info
)
573 (plist-get info
:taskjuggler-unique-ids
))))
574 ;; If no resource is allocated among tasks, allocate one to
576 (unless (org-element-map main-tasks
'headline
577 (lambda (task) (org-element-property :ALLOCATE task
))
579 (org-element-put-property
580 (car main-tasks
) :ALLOCATE
581 (or (org-taskjuggler-get-id (car main-resources
) info
)
584 (lambda (task) (org-taskjuggler--build-task task info
))
586 ;; 6. Insert reports. If no report is defined, insert default
589 ;; Collect contents from various trees marked with
590 ;; `org-taskjuggler-report-tag'. Only gather top level
593 (org-element-map tree
'headline
595 (and (member org-taskjuggler-report-tag
596 (org-export-get-tags hl info
))
597 (org-element-map (org-element-contents hl
)
598 'headline
'identity info nil
'headline
)))
599 info nil
'headline
))))
602 (lambda (report) (org-taskjuggler--build-report report info
))
604 (mapconcat 'org-element-normalize-string
605 org-taskjuggler-default-reports
""))))))))
607 (defun org-taskjuggler--build-project (project info
)
608 "Return a project declaration.
609 PROJECT is a headline. INFO is a plist used as a communication
610 channel. If no start date is specified, start today. If no end
611 date is specified, end `org-taskjuggler-default-project-duration'
613 (format "project %s \"%s\" \"%s\" %s %s {\n}\n"
614 (org-taskjuggler-get-id project info
)
615 (org-taskjuggler-get-name project
)
616 ;; Version is obtained through :TASKJUGGLER_VERSION:
617 ;; property or `org-taskjuggler-default-project-version'.
618 (or (org-element-property :VERSION project
)
619 org-taskjuggler-default-project-version
)
620 (or (org-taskjuggler-get-start project
)
621 (format-time-string "%Y-%m-%d"))
622 (let ((end (org-taskjuggler-get-end project
)))
623 (or (and end
(format "- %s" end
))
624 (format "+%sd" org-taskjuggler-default-project-duration
)))))
626 (defun org-taskjuggler--build-resource (resource info
)
627 "Return a resource declaration.
629 RESOURCE is a headline. INFO is a plist used as a communication
632 All valid attributes from RESOURCE are inserted. If RESOURCE
633 defines a property \"resource_id\" it will be used as the id for
634 this resource. Otherwise it will use the ID property. If
635 neither is defined a unique id will be associated to it."
638 (format "resource %s \"%s\" {\n"
639 (org-taskjuggler--clean-id
640 (or (org-element-property :RESOURCE_ID resource
)
641 (org-element-property :ID resource
)
642 (org-taskjuggler-get-id resource info
)))
643 (org-taskjuggler-get-name resource
))
645 (org-taskjuggler--indent-string
646 (org-taskjuggler--build-attributes
647 resource org-taskjuggler-valid-resource-attributes
))
648 ;; Add inner resources.
649 (org-taskjuggler--indent-string
652 (org-element-map (org-element-contents resource
) 'headline
653 (lambda (hl) (org-taskjuggler--build-resource hl info
))
659 (defun org-taskjuggler--build-report (report)
660 "Return a report declaration.
661 REPORT is a headline. INFO is a plist used as a communication
665 (format "%s \"%s\" {\n"
666 (or (org-element-property :REPORT_KIND report
) "taskreport")
667 (org-taskjuggler-get-name report
))
669 (org-taskjuggler--indent-string
670 (org-taskjuggler--build-attributes
671 report org-taskjuggler-valid-report-attributes
))
672 ;; Add inner reports.
673 (org-taskjuggler--indent-string
676 (org-element-map (org-element-contents report
) 'headline
677 (lambda (hl) (org-taskjuggler--build-report hl info
))
683 (defun org-taskjuggler--build-task (task info
)
684 "Return a task declaration.
686 TASK is a headline. INFO is a plist used as a communication
689 All valid attributes from TASK are inserted. If TASK defines
690 a property \"task_id\" it will be used as the id for this task.
691 Otherwise it will use the ID property. If neither is defined
692 a unique id will be associated to it."
693 (let* ((allocate (org-element-property :ALLOCATE task
))
695 (if (eq (org-element-property :todo-type task
) 'done
) "100"
696 (org-element-property :COMPLETE task
)))
697 (depends (org-taskjuggler-resolve-dependencies task info
))
698 (effort (org-element-property :EFFORT task
))
700 (or (org-element-property :MILESTONE task
)
701 (not (or (org-element-map (org-element-contents task
) 'headline
702 'identity info t
) ; Has task any child?
704 (org-element-property :LENGTH task
)
705 (org-element-property :DURATION task
)
706 (and (org-taskjuggler-get-start task
)
707 (org-taskjuggler-get-end task
))
708 (org-element-property :PERIOD task
)))))
710 (let ((pri (org-element-property :priority task
)))
712 (max 1 (/ (* 1000 (- org-lowest-priority pri
))
713 (- org-lowest-priority org-highest-priority
)))))))
716 (format "task %s \"%s\" {\n"
717 (org-taskjuggler-get-id task info
)
718 (org-taskjuggler-get-name task
))
719 ;; Add default attributes.
721 (format " depends %s\n"
722 (org-taskjuggler-format-dependencies depends task info
)))
724 (format " purge %s\n allocate %s\n"
725 ;; Compatibility for previous TaskJuggler versions.
726 (if (>= org-taskjuggler-target-version
3.0) "allocate"
729 (and complete
(format " complete %s\n" comptete
))
731 (format " effort %s\n"
732 (let* ((minutes (org-duration-string-to-minutes effort
))
733 (hours (/ minutes
60.0)))
734 (format "%.1fh" hours
))))
735 (and priority
(format " priority %s\n" complete
))
736 (and milestone
" milestone\n")
737 ;; Add other valid attributes.
738 (org-taskjuggler--indent-string
739 (org-taskjuggler--build-attributes
740 task org-taskjuggler-valid-task-attributes
))
742 (org-taskjuggler--indent-string
744 (org-element-map (org-element-contents task
) 'headline
745 (lambda (hl) (org-taskjuggler--build-task hl info
))
753 ;;; Interactive Functions
756 (defun org-taskjuggler-export (&optional async subtreep visible-only
)
757 "Export current buffer to a TaskJuggler file.
759 The exporter looks for a tree with tag that matches
760 `org-taskjuggler-project-tag' and takes this as the tasks for
761 this project. The first node of this tree defines the project
762 properties such as project name and project period.
764 If there is a tree with tag that matches
765 `org-taskjuggler-resource-tag' this tree is taken as resources
766 for the project. If no resources are specified, a default
767 resource is created and allocated to the project.
769 Also the TaskJuggler project will be created with default reports
770 as defined in `org-taskjuggler-default-reports'.
772 If narrowing is active in the current buffer, only export its
775 If a region is active, export that region.
777 A non-nil optional argument ASYNC means the process should happen
778 asynchronously. The resulting file should be accessible through
779 the `org-export-stack' interface.
781 When optional argument SUBTREEP is non-nil, export the sub-tree
782 at point, extracting information from the headline properties
785 When optional argument VISIBLE-ONLY is non-nil, don't export
786 contents of hidden elements.
788 Return output file's name."
791 (org-export-output-file-name org-taskjuggler-extension subtreep
)))
793 (org-export-async-start
795 (org-export-add-to-stack f
'taskjuggler
)
796 (run-hook-with-args 'org-taskjuggler-final-hook f
))
798 (org-export-to-file 'taskjuggler
,outfile
,subtreep
,visible-only
)))
799 (org-export-to-file 'taskjuggler outfile subtreep visible-only
)
800 (run-hook-with-args 'org-taskjuggler-final-hook outfile
)
804 (defun org-taskjuggler-export-and-open (&optional subtreep visible-only
)
805 "Export current buffer to a TaskJuggler file and open it.
807 The exporter looks for a tree with tag that matches
808 `org-taskjuggler-project-tag' and takes this as the tasks for
809 this project. The first node of this tree defines the project
810 properties such as project name and project period.
812 If there is a tree with tag that matches
813 `org-taskjuggler-resource-tag' this tree is taken as resources
814 for the project. If no resources are specified, a default
815 resource is created and allocated to the project.
817 Also the TaskJuggler project will be created with default reports
818 as defined in `org-taskjuggler-default-reports'.
820 If narrowing is active in the current buffer, only export its
823 If a region is active, export that region.
825 When optional argument SUBTREEP is non-nil, export the sub-tree
826 at point, extracting information from the headline properties
829 When optional argument VISIBLE-ONLY is non-nil, don't export
830 contents of hidden elements.
832 Open file with the TaskJuggler GUI."
834 (let* ((file (org-taskjuggler-export nil subtreep visible-only
))
835 (process-name "TaskJugglerUI")
836 (command (concat process-name
" " file
)))
837 (start-process-shell-command process-name nil command
)))
840 (provide 'ox-taskjuggler
)
843 ;; sentence-end-double-space: t
846 ;;; ox-taskjuggler.el ends here