This is an article on how to use TrackStudio and Git to organize a convenient software development process. In the article considered a variant for OS Windows. But if you wish, it is not difficult to do everything for other OC.
For this we need:

1. TrackStudio is a universal task management system.
2. Git - VCS.
3. Blat - Small (70kB) open source console program for Windows, which allows you to send e-Mail via SMTP protocol from the command line, with attached files.
4. STunnel - A program that allows you to encrypt arbitrary TCP connections inside SSL. The tool is available for Unix and Windows.
   It is necessary if you use gmail.com as a mail service. Since blat cannot work directly with gmail.

Task:

Organize the workflow in such a way that when you commit to git, comments were automatically added to the TrackStudio task with different types of messages and the text of this comment was the text of the commit message.

Installation

TrackStudio

We do everything as it is written here.
Installation of all other applications is very simple, I note only one thing: blat should be put in the folder with git.exe (I have C: / Program files / Git / bin), or the folder in which blat is added to PATH.

Customization

TrackStudio

TrackStudio is able to pick up emails from emails and import them as tasks.
To configure this process, you need to set the mail collection parameters in the TS_HOME \ etc \ trackstudio.mail.properties file (if you do not have one):

mail.pop3.apop.enable=\ mail.store.forward=     email mail.store.fwdaddress=email      mail.store.host=pop  mail.store.password=  mail.store.port= mail.store.protocol= mail.store.user= , email,    trackstudio.emailSubmission=yes trackstudio.mailimport.interval=   

Here is an example for gmail.com:

 mail.pop3.apop.enable=\ mail.store.forward=yes mail.store.fwdaddress=mymail@gmail.com mail.store.host=pop.gmail.com mail.store.password=password mail.store.port=995 mail.store.protocol=pop3s mail.store.user=srvmail@gmail.com 

More details are described in the documentation .

Script to create an import rule

Now in TS, for an ancestor of each task with the category category “Change” or “Error”, it is necessary to create an import rule and it is desirable that they are created as administrator. But to do it every time, it is expensive with pens - we solve this problem by writing a plug-in. In the TS_HOME \ plugins \ scripts \ after_create_task folder (it contains scripts that are executed after creating tasks) create the file createRuleImport.bsh with the following code:

1. / **
2. * The script creates an import rule for the ancestor task when creating a child task.
3. * /
4. import com.trackstudio.app.adapter.AdapterManager;
5. import com.trackstudio.exception.GranException;
6. import com.trackstudio.secured. *;
7. import com.trackstudio.securedkernel.SecuredMailImportAdapterManager;
8. import com.trackstudio.securedkernel.SecuredStepAdapterManager;
9. import java.util. *;
10. import com.trackstudio.secured.SecuredUserBean;
11. import com.trackstudio.app.session. *;
12. import com.trackstudio.app.csv.CSVImport;
14. try {
15. // object for working with mail import rules
16. SecuredMailImportAdapterManager mam = AdapterManager.getInstance ()
17. .getSecuredMailImportAdapterManager ();
19. // contains methods for working with message types
20. SecuredStepAdapterManager sam = AdapterManager.getInstance ()
21. .getSecuredStepAdapterManager ();
23. // list of available message types for task and current user
24. ArrayList arrMS = sam.getAvailableMstatusList (task.getSecure (), task.getId ());
26. // type of message
27. SecuredMstatusBean curMS = null ;
29. String pefixStr = "new" ;
30. / **
31. * Check the type of category of the created task.
32. * If the task category is “Error” = category name in TS
33. * /
34. if (task.getCategory (). getName (). equals ( "Error" ))
35. pefixStr = "bug" ;
37. / **
38. * Generate a key for importing messages from the current task:
39. * prefix + parent task number + # + task number
40. * this key should be in the subject line
41. * eg:
42. * new759 # 2845 any text, anyway it will be ignored when adding a message.
43. * /
44. String mailimKey = pefixStr + task.getParent (). GetNumber () + "#" + task.getNumber ();
46. / **
47. * Do I need to create a rule.
48. * Since an ancestor task can have several subtasks,
49. * it is necessary to check the existence of the import rule,
50. * so as not to produce them.
51. * /
52. boolean found = false ;
54. for ( int i = 0; i <arrMS.size (); i ++) {
55. curMS = (SecuredMstatusBean) arrMS.get (i);
57. msn = curMS.getName ();
59. // "Commentary" or "Comment" is the name of the message type
60. if (msn.compareToIgnoreCase ( "Comment" ) == 0 || msn.compareToIgnoreCase ( "Comment" ) == 0) {
61. // Get data by root user
62. SecuredUserBean adminUser = new SecuredUserBean (CSVImport.findUserIdByLogin ( "root" ), sc);
63. // Current user context
64. SessionContext needSc = task.getSecure ();
65. // check whether root has logged in
66. if (SessionManager.getInstance (). existUserSession (adminUser.getUser ())) {
67. for (SessionContext curSc: SessionManager.getInstance (). getSessions ()) {
68. if (curSc.getUser (). getLogin (). equals ( "root" )) {
69. // if yes then we get its context
70. needSc = curSc;
71. break ;
72. }
73. }
74. }
75. else {
76. // if not, create its context
77. needSc = SessionManager.getInstance (). getSessionContext (
78. SessionManager.getInstance (). Create (adminUser.getUser ()));
79. }
81. if (! found)
82. for (SecuredMailImportBean curMailS: mam.getAllAvailableMailImportList (needSc, task.getParentId ())) {
83. // We are looking for the rule of importing new tasks from the ancestor.
84. found = curMailS.getKeywords (). equals (pefixStr + task.getParent (). getNumber ());
85. if (found)
86. break ;
87. }
89. if (! found) {
90. / **
91. * if not found, then create a new import rule for the ancestor
92. * as root, as TS supports the ability to create
93. * users of individual rules for importing mail, you must
94. * so that this rule could be seen by everyone.
95. * /
96. mam.createMailImport (needSc, pefixStr + task.getParent (). getNumber (),
97. task.getParentId (), pefixStr + task.getParent (). getNumber (), 1, i,
98. task.getCategoryId (), curMS.getId (), "" , true , false );
99. found = true ;
100. }
101. }
102. }
103. // Add a value for the UDF field with the name "Branch name in git".
104. AdapterManager.getInstance (). GetSecuredUDFAdapterManager (). SetTaskUDFValueSimple (
105. task.getSecure (), task.getId (), “Branch Name in git” , mailimKey);
106. }
107. catch (GranException e) {
108. throw new com.trackstudio.exception.UserMessageException (e.getMessage ());
109. }
110. return task;

The script has been created, now in TS we select in the menu “Task management -> Categories”,
first click on the category with the name "Change",

open the "Triggers" tab and in the "AFTER Trigger" list, mark the trigger, which is called createRuleImport.bsh .

Do the same for the category "Error".
')
If everything is done correctly, then when you create a new task, the Preda will have an import rule newNUMBER_PREACH or bugNUMP_REAL. When sending a letter to the email from which mail is imported, with the theme “newNUMBER_PREACH new task”, TS will create a task in the ANCIENT with a name that is equal to the subject of the letter. And if you send a letter in the subject, which is the key newNUMBER_BOOK # NUMBER_TASK (the task exists), TS imports the letter as comments to the task and the comment message will be the body of the letter. Moreover, if you attach a file to a letter, TS will attach it to the task.

How to add a UDF field

To do this, in TS top menu select “Task management -> Processes”, open the process of interest to you and in the “Additional fields” tab click on the “Line” button.

In the title, specify the name you need, in our case “Branch Name in git”, and click the Save button. But this is all just to copy and quickly paste into sh when creating a new branch in git, such as convenient.

Script for processing messages received via mail

TS already knows how to create messages from the “comments” type to the tasks from the letters.
Now we need to make TS change the message type to “Complete” or “Correct” for the category “Change” or “Error”, respectively (“Comments”, “Finish”, “Change” and “Error” - the names of the message type and categories , they depend on how you set up your workflow in TS; if you use the demo Russian database, they will be exactly like that). We need to create a script that will search in the message body, some sort of key, which will inform TS that it is necessary to change the type of message. I propose to use the [new_state = done] construct, but this is up to you. Create in the TS_HOME \ plugins \ scripts \ before_add_message folder , in which the scripts to be executed before adding the message are placed, changeType.bsh file with the code:

1. / **
2. * The script changes the type of the message being imported if it finds it in the message body.
3. * construct [new_state = type], where type can be done or start
4. * /
5. import java.util. *;
6. import java.util.regex. *;
7. import java.io. *;
9. try {
10. if (message.description! = null )
11. {
12. String [] tempArr = null ;
13. // Looking for the construction we need in the message
14. String pattern = ". * \\ [(\\ w *) = (\\ w *) \\]. *" ;
15. Pattern p = Pattern.compile (pattern, Pattern.MULTILINE);
16. Matcher m = p.matcher (message.description);
17. if (m.find ())
18. tempArr = new String [] {m.group (1), m.group (2)};
19. // whether the first parameter is scanned by the directive to change the type of message
20. if (tempArr! = null && tempArr [0] .toLowerCase (). equals ( "new_state" )) {
21. // determine what type to change the current message type
22. if (tempArr [1] .toLowerCase (). equals ( "done" )) {
23. // Remove the directive from the message
24. message.description = message.description.replaceFirst ( "\\ [new_state = done \\]" , "" );
25. // check which task belongs to
26. if (message.getTask (). getCategory (). getName (). equals ( "Change" ))
27. // set the new message type by its name
28. message.setMstatus ( “Finish” );
29. if (message.getTask (). getCategory (). getName (). equals ( "Error" ))
30. message.setMstatus ( “Fix” );
31. }
32. if (tempArr [1] .toLowerCase (). equals ( "start" )) {
33. message.description = message.description.replaceFirst ( "\\ [new_state = start \\]" , "" );
34. if (message.getTask (). getCategory (). getName (). equals ( "Change" ) ||
35. message.getTask (). getCategory (). getName (). equals ( “Error” ))
36. message.setMstatus ( “Get started” );
37. }
38. }
39. }
40. }
41. catch (Exception e) {
42. throw new com.trackstudio.exception.UserMessageException (e.printStackTrace ());
43. }
44. return message;

The script has been created, now in TS we select in the menu “Task management -> Processes”, first click on the process with the name “Change”, then select the operation types tab and click on the operation with the name “Comment”

open the “Triggers” tab and in the “BEFORE Trigger” list, mark the trigger, which is called changeType.bsh .

We do the same for the “Error” process.

Like everything you can try.
Create a task -> copy from the field "Branch name in git" value ->

we create a letter with a topic into which we paste the copied value -> then in the body of the letter we write any text and add the directive [new_state = done].

In theory, after importing a letter for a task to change state, it should go to the state completed and the message body will be the message to this state.

Total

We have expanded TS abilities, now she can:

• Automatically create import rules for creating new messages and tasks.
• Change the status of the message depending on the directive found in the message body.
• Attach files to the task, if they are attached to the letter.
  This ability of TS was given to developers, but we will need it in the future.

Stunnel

If you are not using gmail.com as your mail server, then skip this step!
In the folder where you installed stunnel find the file stunnle.conf (C: \ Program Files \ stunnel \ stunnel.conf). We change its contents to the following:

 socket = l:TCP_NODELAY=1 socket = r:TCP_NODELAY=1 debug = 7 output = stunnel.log client = yes [ssmtp] accept = 127.0.0.1:465 connect = smtp.gmail.com:465 

And in order for stunnel to start as a service, we automatically execute on the command line:

"C: \ Program Files \ stunnel \ stunnel.exe" –install

source: Sending letters from the Windows command line using a GMail account

Git

Everything related to TS was performed on the server side. And now all the settings will be at a specific workplace.
In order to configure the git behavior when committing a commit, we need to change 2 hooks first post-commit and prepare-commit-msg , the first is executed at the time of the commit, the second when the commit message is generated. The hook files are in the DIR_YOUR_REPO / .git / hooks directory.

• In the prepare-commit-msg file, generate a message header.
  

  #! / bin / sh
  case "$ 2, $ 3" in
  merge ,)
  perl - i.bak - ne 's / ^ / # /, s / ^ # # / # / if / ^ Conflicts / ... / # /; print ' "$ 1" ;;
  *) ;;
  esac
  
  if [ "` git branch | grep -e "^ \ *. \ (new \ | bug \) [0-9] \ + # [0-9] \ +" | cut -f2 -d '' `"! = "" ]; then
  # Put the keys to send the letter to the beginning of the file with the message.
  echo sendmail > temp_msg
  echo "to = srvemail@gmail.com" >> temp_msg
  echo "[new_state = done]" >> temp_msg
  cat $ 1 >> temp_msg
  cat temp_msg > $ 1
  rm temp_msg
  fi

• In the post-commit file, we configure the collection of information about changes and sending mail.
  

  #! / bin / sh
  # we get from the variable GIT_AUTHOR_IDENT email of the current committer
  sender = `git var GIT_COMMITTER_IDENT | cut -f1 -d '>' | cut -f 2 -d '<' `
  
  # check the presence of the sendmail text in the first line of the message
  if [ `git log -1 | sed "s / [] * // g" | grep -e "^ sendmail $" ` == " sendmail " ]; then
  
  # form the subject of the message, which is taken from the name of the branch
  # but this is a wish, you can make the topic be taken from the first line of the main text of the message
  subject = `git branch | grep -e "^ \ *. \ (new \ | bug \) [0-9] \ + # [0-9] \ +" | cut -f2 -d '' `
  if [ "` git log -1 | sed " s / [ ] * // g " | gre grep -e " ^ newroot \ = " | cut -f2 -d '= "` " ! = " " ]; then
  subject = `git log -1 | sed "s / [] * // g" | grep -e "^ newroot \ =" | cut -f2 -d '=' | cut -f1 -d '#' `
  subject = "$ subject #` git branch | grep -e "^ \ *. \ (new \ | bug \) [0-9] \ + # [0-9] \ +" | cut -f2 -d '# '`"
  fi
  
  # determined from the third line of the message of the commit mail,
  # to which you need to send a letter
  # by default put the current commitr's email.
  to = $ sender
  if [ "` git log -1 | sed "s / [] * // g" | grep -e "^ [Tt] [Oo] \ =" | cut -f2 -d '= "` " ! = " " ]; then
  to = `git log -1 | sed "s / [] * // g" | grep -e "^ [Tt] [Oo] \ =" | cut -f2 -d '=' "`
  fi
  
  # create patch file name
  patchname = "$ (date +% j% H% M% s) .patch"
  
  # save the diff commitcomit,
  ( git diff-index -p -M HEAD ^) > $ patchname
  
  # take the last message from the git log with the exception of the control text
  git log - 1 | grep - v "^ Date:" | grep - v "^ commit" | grep - v "^ Author:" | grep - v "* Signed-off-by:" | grep - v "^ [] * sendmail [] * $" | grep - v "^ [] * newroot \ =" | grep - v "^ [] * [Tt] [Oo] \ =" | grep - v ". * $ subject. *" | sed -e "/ ^ [] * $ / d" -e "/ ^ $ / d" >> temp.tmp
  echo "shortstat" >> temp.tmp
  git diff-index - stat HEAD ^ >> temp.tmp
  
  # send by means of blat
  blat - charset "utf-8" -f $ sender - server localhost - port 465 - u useremail@gmail.com - pw password - to $ body - temp.tmp - subject $ subject - base64 - attach $ patchname > logSendMail. log
  
  rm $ patchname
  rm temp.tmp
  edit logSendMail.log
  sleep 2 s
  rm logSendMail.log
  fi

These files should lie with all programmers working on the project.

How it works

Most importantly, when starting work on a new task, it is necessary in the operational repository of the current programmer to create a branch with the name that TS created when creating the task.
The prepare-commit-msg hook inserts in the beginning of the commit message the parameters for sending a letter, such as:

• sendmail - whether to send a letter. If the message does not contain a line containing only this word, the letter will not be sent.
• to - what email to send to. If it is not, then the letter will be sent to the sender.
• [new_state = done] - a directive for TS, which should be assigned to the type “Completed” or “Fixed” for a new message.
  This parameter can be omitted, then TS will add new messages with the type “Comment”.
• newroot - this parameter denotes the need to remake the subject of the letter. In TS, it is possible to move subtasks from one task to another, so as not to create a new branch, you can simply specify the new parent of the current task.
  For example, you created a subtask (number 2084, ancestor number 754, key new754 # 2084) and started working on it, and then you realized that the subtask should belong to another parent task (number 458, new key new458 # 2084) and moved it to her. In order for git not to start a new branch, you can add the following code in the commit message

  newroot=new458

  Important: each parameter must be on a separate line, the number of spaces or tabs do not affect its detection.

The post-commit hook checks the commit message for sending options. creates a patch file with the changes made and a letter, then sends a letter on behalf of the committer to the email specified in the “to” parameter. Here's an example of applying the changes:
Enter in the command line

$ git add --all & git gui

Then press Ctrl + Enter and at the interval that you set the mail collector in TS, check the status of the task.

Here the comment is decorated with html, but this is a topic for a separate post.

Conclusion

A standard workflow consists of 4 main steps:

1. Setting a task in TS and copying the branch name for git.
2. Creating a branch in git and going to it.
   You can execute one command:

   $ git checkout -b _

3. Doing the task.
4. Completion of work on a task in TS, committing a commit in git.

Step 3 can be extended by intermediate commits in the message, which will not be a directive [new_state = done] - TS will add comments to the task.

Why use just such a mechanism

The reason is that TS does not yet have integration with SCM GIT.
And when to appear, it is not clear how the work with distributed repositories will be implemented.
And this solution allows you to work on a task for several programmers who have their own zoo repositories. And then combine them into one central, in which order and cleanliness.
In addition, it is very convenient to work without having direct access to TS.
A project manager can create tasks and assign specific people to them as responsible. They will receive emails stating that a task has been created or that he has been appointed responsible. He sees in the message of the letter what task is set and the name of the branch for git, begins work on the task. At the end of the work, it quietly makes a commit in the repository and may no longer worry that the task should be completed. Moreover, he can also remotely create subtasks knowing the key of the ancestor's task by sending emails from which mail is imported into TS with the subject in which the required key is present. In response, they will also receive letters that he has created a task.

Sources

• ProGit is an online git book .
• TrackStudio documentation .
• TS_HOME \ docs \ javadoc \ index.html - TrackStudio API manual, comes with TS.
• Sending letters from the Windows command line using a GMail account .