Added a bunch of stuff and I now need to store said stuff

cmd/jkl/edit.go

@@ -21,9 +21,9 @@ func NewEditCmd(args []string) (*EditCmd, error) {
 	ccmd := &EditCmd{project: os.Getenv("JIRA_PROJECT")}
 	f := flag.NewFlagSet("x", flag.ExitOnError)
 	f.StringVar(&ccmd.project, "p", "", "Jira project key")
-	f.StringVar(&ccmd.file, "f", "filename", "File to get issue description from")
+	f.StringVar(&ccmd.file, "f", "", "File to get issue description from")
 	f.Parse(args)
-	ccmd.taskKey = flag.Arg(0)
+	ccmd.taskKey = f.Arg(0)
 	return ccmd, nil
 }
 

cmd/jkl/editor.go

@@ -17,6 +17,7 @@ import (
 
 	"otremblay.com/jkl"
 )
+
 // def get_editor do
 // 	[System.get_env("EDITOR"), "nano", "vim", "vi"]
 // 	|> Enum.find(nil, fn (ed) -> System.find_executable(ed) != nil end)
@@ -159,7 +160,12 @@ func IssueFromReader(f io.Reader, editMeta *jkl.EditMeta) *jkl.JiraIssue {
 
 		}
 		if currentField.IsValid() {
-			currentField.SetString(strings.TrimSpace(currentField.String() + "\n" + strings.Join(parts, ":")))
+			newpart := strings.Join(parts, ":")
+			newvalue := currentField.String() + "\n" + newpart
+			if strings.TrimSpace(newpart) != "" {
+				newvalue = strings.TrimSpace(newvalue)
+			}
+			currentField.SetString(newvalue)
 		}
 	}
 	return iss

cmd/jkl/jkl.go

@@ -61,6 +61,14 @@ func getCmd(args []string, depth int) (Runner, error) {
 		return NewCommentCmd(args[1:])
 	case "edit-comment":
 		return NewEditCommentCmd(args[1:])
+	case "assign":
+		return NewAssignCmd(args[1:])
+	case "flag":
+		return NewFlagCmd(args[1:], true)
+	case "unflag":
+		return NewFlagCmd(args[1:], false)
+	case "link":
+		return NewLinkCmd(args[1:])
 	default:
 		// Think about this real hard.
 		// I want `jkl JIRA-1234 done` to move it to done.
@@ -93,6 +101,7 @@ func getCmd(args []string, depth int) (Runner, error) {
 }
 
 var verbs = []string{"list", "create", "task", "edit", "comment", "edit-comment"}
+
 func init() {
 	sort.Strings(verbs)
 }

cmd/jkl/list.go

@@ -21,6 +21,9 @@ func (l *listissue) URL() string {
 }
 
 func (l *listissue) Color() string {
+	if l.Fields == nil || l.Fields.Status == nil {
+		return ""
+	}
 	if os.Getenv("JKLNOCOLOR") == "true" || !terminal.IsTerminal(int(os.Stdout.Fd())) {
 		return ""
 	}
@@ -52,7 +55,7 @@ func NewListCmd(args []string) (*ListCmd, error) {
 	if *verbose {
 		fmt.Println(&ccmd.tmplstr)
 	}
-	f.StringVar(&ccmd.tmplstr, "listTemplate", "{{.Color}}{{.Key}}{{if .Color}}\x1b[39m{{end}}\t({{.Fields.IssueType.Name}}{{if .Fields.Parent}} of {{.Fields.Parent.Key}}{{end}})\t{{.Fields.Summary}}\t{{if .Fields.Assignee}}[{{.Fields.Assignee.Name}}]{{end}}\n", "Go template used in list command")
+	f.StringVar(&ccmd.tmplstr, "listTemplate", "{{.Color}}{{.Key}}{{if .Color}}\x1b[39m{{end}}\t({{if .Fields.IssueType}}{{.Fields.IssueType.Name}}{{end}}{{if .Fields.Parent}} of {{.Fields.Parent.Key}}{{end}})\t{{.Fields.Summary}}\t{{if .Fields.Assignee}}[{{.Fields.Assignee.Name}}]{{end}}\n", "Go template used in list command")
 	f.Parse(args)
 	ccmd.args = f.Args()
 	if len(ccmd.args) == 0 {

issue.go

@@ -58,10 +58,8 @@ type FieldSpec struct {
 	}
 	Operations    []string
 	AllowedValues []*AllowedValue
-	
 }
 
-
 type CreateMeta struct {
 	Projects []*Project
 }
@@ -157,7 +155,14 @@ func (f *Fields) UnmarshalJSON(b []byte) error{
 		return err
 	}
 	f.rawExtraFields = map[string]json.RawMessage{}
-	vf := reflect.ValueOf(f).Elem()
+	if reflect.ValueOf(f) == reflect.Zero(reflect.TypeOf(f)) {
+		fmt.Println("wtf")
+	}
+	v := reflect.ValueOf(f)
+	if !v.IsValid() {
+		fmt.Println("What all the fucks")
+	}
+	vf := v.Elem()
 	for key, mess := range f.rawFields {
 		field := vf.FieldByNameFunc(func(s string) bool { return strings.ToLower(key) == strings.ToLower(s) })
 		if field.IsValid() {
@@ -168,7 +173,12 @@ func (f *Fields) UnmarshalJSON(b []byte) error{
 				fmt.Fprintln(os.Stderr, objType, obj, string(mess))
 				fmt.Fprintln(os.Stderr, errors.New(fmt.Sprintf("%s [%s]: %s", "Error allocating field", key, err)))
 			}
-			field.Set(reflect.ValueOf(obj).Elem())
+			val := reflect.ValueOf(obj)
+			if val == reflect.Zero(reflect.TypeOf(val)) || !val.IsValid() {
+				field.Set(reflect.Zero(objType))
+			} else {
+				field.Set(val.Elem())
+			}
 		} else {
 			f.rawExtraFields[key] = mess
 		}
@@ -223,20 +233,16 @@ type Transition struct{
 	Name string `json:"name"`
 }
 
-
 type Schema struct {
 	System   string
 	Custom   string
 	CustomId int
 }
 
-
 type EditMeta struct {
 	Fields map[string]*FieldSpec
 }
 
-
-
 type JiraIssue struct {
 	Key         string        `json:"key,omitempty"`
 	Fields      *Fields       `json:"fields,omitempty"`
@@ -244,8 +250,8 @@ type JiraIssue struct {
 	EditMeta    *EditMeta     `json:"editmeta,omitempty"`
 }
 
-
 var sprintRegexp = regexp.MustCompile(`name=([^,]+),`)
+
 func (i *JiraIssue) UnmarshalJSON(b []byte) error {
 	tmp := map[string]json.RawMessage{}
 	if len(b) == 0 {
@@ -257,8 +263,14 @@ func (i *JiraIssue) UnmarshalJSON(b []byte) error {
 	if err != nil && *Verbose {
 		fmt.Fprintln(os.Stderr, errors.New(fmt.Sprintf("%s: %s", "Error unpacking raw json", err)))
 	}
+	if _, ok := tmp["fields"]; !ok {
+		fmt.Fprintln(os.Stderr, "Received no fields? wtf?")
+		fmt.Fprintln(os.Stderr, string(b))
+		os.Exit(1)
+	}
 	err = json.Unmarshal(tmp["fields"], &i.Fields)
 	if err != nil && *Verbose {
+		fmt.Println(string(tmp["fields"]))
 		fmt.Fprintln(os.Stderr, errors.New(fmt.Sprintf("%s: %s", "Error unpacking fields", err)))
 	}
 	err = json.Unmarshal(tmp["transitions"], &i.Transitions)
@@ -282,7 +294,8 @@ func (i *JiraIssue) UnmarshalJSON(b []byte) error {
 				if len(results) == 2 {
 					i.Fields.ExtraFields[k] = results[1]
 				}
-			} else {switch f.Schema.Type {
+			} else {
+				switch f.Schema.Type {
 				case "user":
 					a := &Author{}
 					json.Unmarshal(v, &a)
@@ -290,20 +303,24 @@ func (i *JiraIssue) UnmarshalJSON(b []byte) error {
 				case "option":
 					val := &AllowedValue{}
 					err = json.Unmarshal(v, &val)
-		    	if err != nil {panic(err)}
+					if err != nil {
+						panic(err)
+					}
 					i.Fields.ExtraFields[k] = val
 				case "array":
 					if f.Schema.Items == "option" {
 						val := []*AllowedValue{}
 						err = json.Unmarshal(v, &val)
-		    		if err != nil {panic(err)}
+						if err != nil {
+							panic(err)
+						}
 						i.Fields.ExtraFields[k] = val
 						continue
 					}
 					fallthrough
 				default:
 					if string(v) != "null" {
-				i.Fields.ExtraFields[k] = string(v)
+						i.Fields.ExtraFields[k] = strings.Replace(string(v), "\\r\\n", "\n", -1)
 					}
 				}
 			}
@@ -323,6 +340,9 @@ func (i *JiraIssue) String() string {
 	if os.Getenv("JKLNOCOLOR") == "true" {
 		tmpl = issueTmplNoColor
 	}
+	if customTmpl := os.Getenv("JKL_ISSUE_TMPL"); customTmpl != "" {
+		tmpl = template.Must(template.New("customIssueTmpl").Parse(customTmpl))
+	}
 	err := tmpl.Execute(b, i)
 	if err != nil {
 		log.Fatalln(err)

jiraclient.go

@@ -1,6 +1,8 @@
 package jkl
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -9,6 +11,8 @@ import (
 	"net/http/cookiejar"
 	"net/url"
 	"os"
+	"strings"
+	"time"
 )
 
 var j, _ = cookiejar.New(nil)
@@ -26,34 +30,79 @@ func init(){
 }
 
 func NewJiraClient(jiraRoot string) *JiraClient {
-	j := &JiraClient{
+	jc := &JiraClient{
 		&http.Client{
 			Jar: j,
 		},
 		jiraRoot,
 	}
-	if j.jiraRoot == "" {
+	if jc.jiraRoot == "" {
-		j.jiraRoot = os.Getenv("JIRA_ROOT")
+		jc.jiraRoot = os.Getenv("JIRA_ROOT")
 	}
-	if *Verbose {
+	if cookiefile := os.Getenv("JIRA_COOKIEFILE"); cookiefile != "" {
-		fmt.Println("Jira root:", j.jiraRoot)
+		makeNewFile := false
+		f, err := os.Open(cookiefile)
+		server := jc.jiraRoot + "rest/gadget/1.0/login"
+		u, _ := url.Parse(server)
+		if err != nil {
+			makeNewFile = true
+		} else {
+			if stat, err := f.Stat(); err == nil {
+				if time.Now().Sub(stat.ModTime()).Minutes() > 60 {
+					makeNewFile = true
+				} else {
+					var cookies []*http.Cookie
+					dec := json.NewDecoder(f)
+					dec.Decode(&cookies)
+					u, _ = url.Parse(jc.jiraRoot)
+					jc.Jar.SetCookies(u, cookies)
 				}
-	return j
+			}
+			f.Close()
+		}
+		if makeNewFile {
+			f, err = os.Create(cookiefile)
+			if err != nil {
+				panic(err)
 			}
 
-func (j *JiraClient) Do(req *http.Request) (*http.Response, error) {
+			http.DefaultClient.Jar = j
+			form := url.Values{}
+			form.Add("os_username", os.Getenv("JIRA_USER"))
+			form.Add("os_password", os.Getenv("JIRA_PASSWORD"))
+			req, _ := http.NewRequest("POST", server, strings.NewReader(form.Encode()))
+			req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+			resp, err := http.DefaultClient.Do(req)
+			if err != nil || resp.StatusCode >= 400 {
+				fmt.Println(resp.Header)
+				fmt.Println(resp.Status)
+				fmt.Println(err)
+			}
+			b := bytes.NewBuffer(nil)
+			enc := json.NewEncoder(b)
+			enc.Encode(j.Cookies(u))
+			io.Copy(f, b)
+			f.Close()
+		}
+	}
+
+	if *Verbose {
+		fmt.Println("Jira root:", jc.jiraRoot)
+	}
+	return jc
+}
+
+func (j *JiraClient) DoLess(req *http.Request) (*http.Response, error) {
 	var err error
+	if os.Getenv("JIRA_COOKIEFILE") == "" {
 		req.SetBasicAuth(os.Getenv("JIRA_USER"), os.Getenv("JIRA_PASSWORD"))
+	}
 	if *Verbose {
 		fmt.Println("Jira User: ", os.Getenv("JIRA_USER"))
 		fmt.Println("Jira Password: ", os.Getenv("JIRA_PASSWORD"))
 	}
 	req.Header.Add("Content-Type", "application/json")
 	req.Header.Add("Accept", "application/json, text/plain, text/html")
-	req.URL, err = url.Parse(j.jiraRoot + "rest/" + req.URL.RequestURI())
-	if err != nil {
-		return nil, err
-	}
 	resp, err := j.Client.Do(req)
 	if err != nil {
 		return nil, err
@@ -75,6 +124,15 @@ func (j *JiraClient) Do(req *http.Request) (*http.Response, error) {
 	return resp, nil
 }
 
+func (j *JiraClient) Do(req *http.Request) (*http.Response, error) {
+	var err error
+	req.URL, err = url.Parse(j.jiraRoot + "rest/" + req.URL.RequestURI())
+	if err != nil {
+		return nil, err
+	}
+	return j.DoLess(req)
+}
+
 func (j *JiraClient) Put(path string, payload io.Reader) (*http.Response, error) {
 	req, err := http.NewRequest("PUT", path, payload)
 	if err != nil {

jkl.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"io/ioutil"
 	"log"
+	"net/http"
 	"net/url"
 	"os"
 	"strings"
@@ -251,6 +252,76 @@ func LogWork(taskKey string, workAmount string) error {
 	return nil
 }
 
+func Assign(taskKey string, user string) error {
+	bootHttpClient()
+	payload, err := serializePayload(map[string]interface{}{"name": user})
+	resp, err := httpClient.Put("api/2/issue/"+taskKey+"/assignee", payload)
+	if err != nil {
+		fmt.Println(resp.StatusCode)
+		return err
+	}
+	if resp.StatusCode >= 400 {
+		io.Copy(os.Stderr, resp.Body)
+	}
+	return nil
+}
+
+func FlagIssue(taskKeys []string, flg bool) error {
+	bootHttpClient()
+	payload, err := serializePayload(map[string]interface{}{"issueKeys": taskKeys, "flag": flg})
+	req, err := http.NewRequest("POST", "", payload)
+
+	if err != nil {
+		return err
+	}
+	req.URL, err = url.Parse(httpClient.jiraRoot + "rest/" + "greenhopper/1.0/xboard/issue/flag/flag.json")
+	if err != nil {
+		return err
+	}
+	resp, err := httpClient.DoLess(req)
+	if err != nil {
+		fmt.Println(resp.StatusCode)
+		return err
+	}
+	if resp.StatusCode >= 400 {
+		io.Copy(os.Stderr, resp.Body)
+	}
+	return nil
+}
+
+type msi map[string]interface{}
+
+func LinkIssue(params []string) error {
+	bootHttpClient()
+	if len(params) == 0 {
+		resp, err := httpClient.Get("api/2/issueLinkType")
+		if err != nil {
+			if resp != nil {
+				fmt.Println(resp.StatusCode)
+			}
+			return err
+		}
+		io.Copy(os.Stdout, resp.Body)
+		return nil
+	}
+	payload, err := serializePayload(msi{
+		"type":         msi{"name": strings.Join(params[1:len(params)-1], " ")},
+		"inwardIssue":  msi{"key": params[len(params)-1]},
+		"outwardIssue": msi{"key": params[0]},
+	})
+	resp, err := httpClient.Post("api/2/issueLink", payload)
+	if err != nil {
+		if resp != nil {
+			fmt.Println(resp.StatusCode)
+		}
+		return err
+	}
+	if resp.StatusCode >= 400 {
+		io.Copy(os.Stderr, resp.Body)
+	}
+	return nil
+}
+
 func formatPayload(issue *JiraIssue) (io.Reader, error) {
 	if issue.Fields != nil &&
 		issue.Fields.Project != nil &&