Actually moving tasks

asanaclient/client.go

@@ -40,15 +40,15 @@ func NewClientFromEnv() *Client {
 }
 
 func (c *Client) InWorkspace(name string) (*WorkspaceClient, error) {
-  wrk, err := c.getWorkspaceByName(name)
+	wrk, err := c.getWorkspaceByName(name)
-  if err != nil {
+	if err != nil {
-    return nil, err
+		return nil, err
-  }
+	}
 
-  return &WorkspaceClient{
+	return &WorkspaceClient{
-    client: c,
+		client:    c,
-    workspace: wrk,
+		workspace: wrk,
-  }, nil
+	}, nil
 }
 
 func (c *Client) getWorkspaces() ([]*workspace, error) {
@@ -66,13 +66,13 @@ func (c *Client) getWorkspaceByName(name string) (*workspace, error) {
 		return nil, err
 	}
 
-  for _, wrk := range wrks {
+	for _, wrk := range wrks {
-    if wrk.Name == name {
+		if wrk.Name == name {
-      return wrk, nil
+			return wrk, nil
-    }
+		}
-  }
+	}
 
-  return nil, fmt.Errorf("Workspace `%s` not found", name)
+	return nil, fmt.Errorf("Workspace `%s` not found", name)
 }
 
 const baseURL = "https://app.asana.com/api/1.0/"
@@ -98,8 +98,8 @@ func (c *Client) get(path string, values *url.Values, out interface{}) error {
 	dec := json.NewDecoder(resp.Body)
 
 	if resp.StatusCode != 200 {
-    errorResp := &errorResponse{}
+		errorResp := &errorResponse{}
-    err = dec.Decode(errorResp)
+		err = dec.Decode(errorResp)
 		if err != nil {
 			return err
 		}

asanaclient/workspaceclient.go

@@ -13,14 +13,16 @@ var _FALSE = false
 var FALSE = &_FALSE
 
 type WorkspaceClient struct {
-  client *Client
+	client    *Client
-  workspace *workspace
+	workspace *workspace
 }
 
 type SearchQuery struct {
 	SectionsAny []*Section
 	Completed   *bool
-  DueOn       *string
+	DueOn       *civil.Date
+	DueBefore   *civil.Date
+	DueAfter    *civil.Date
 }
 
 type Project struct {
@@ -61,11 +63,11 @@ type emptyResponse struct {
 }
 
 type errorDetails struct {
-  Message string `json:"message"`
+	Message string `json:"message"`
 }
 
 type errorResponse struct {
-  Errors []*errorDetails `json:"errors"`
+	Errors []*errorDetails `json:"errors"`
 }
 
 type projectResponse struct {
@@ -135,6 +137,34 @@ func (wc *WorkspaceClient) GetSections(project *Project) ([]*Section, error) {
 	return resp.Data, nil
 }
 
+func (wc *WorkspaceClient) GetSectionsByName(project *Project) (map[string]*Section, error) {
+	secs, err := wc.GetSections(project)
+	if err != nil {
+		return nil, err
+	}
+
+	secsByName := map[string]*Section{}
+	for _, sec := range secs {
+		secsByName[sec.Name] = sec
+	}
+
+	return secsByName, err
+}
+
+func (wc *WorkspaceClient) GetSectionByName(project *Project, name string) (*Section, error) {
+	secsByName, err := wc.GetSectionsByName(project)
+	if err != nil {
+		return nil, err
+	}
+
+	sec, found := secsByName[name]
+	if !found {
+		return nil, fmt.Errorf("Section '%s' not found", name)
+	}
+
+	return sec, nil
+}
+
 func (wc *WorkspaceClient) GetTasksFromSection(section *Section) ([]*Task, error) {
 	path := fmt.Sprintf("sections/%s/tasks", section.GID)
 	resp := &tasksResponse{}
@@ -157,6 +187,15 @@ func (wc *WorkspaceClient) GetUserTaskList(user *User) (*Project, error) {
 	return resp.Data, nil
 }
 
+func (wc *WorkspaceClient) GetMyUserTaskList() (*Project, error) {
+	me, err := wc.GetMe()
+	if err != nil {
+		return nil, err
+	}
+
+	return wc.GetUserTaskList(me)
+}
+
 func (wc *WorkspaceClient) Search(q *SearchQuery) ([]*Task, error) {
 	path := fmt.Sprintf("workspaces/%s/tasks/search", wc.workspace.GID)
 
@@ -176,9 +215,17 @@ func (wc *WorkspaceClient) Search(q *SearchQuery) ([]*Task, error) {
 		values.Add("completed", fmt.Sprintf("%t", *q.Completed))
 	}
 
-  if q.DueOn != nil {
+	if q.DueOn != nil {
-    values.Add("due_on", *q.DueOn)
+		values.Add("due_on", q.DueOn.String())
-  }
+	}
+
+	if q.DueBefore != nil {
+		values.Add("due_on.before", q.DueBefore.String())
+	}
+
+	if q.DueAfter != nil {
+		values.Add("due_on.after", q.DueAfter.String())
+	}
 
 	resp := &tasksResponse{}
 	err := wc.client.get(path, values, resp)

asanarules/rules.go

@@ -14,16 +14,16 @@ type periodic struct {
 	duration time.Duration
 	done     chan bool
 
-  workspaceClientGetter workspaceClientGetter
+	workspaceClientGetter workspaceClientGetter
-  queryMutators []queryMutator
+	queryMutators         []queryMutator
-  taskActors []taskActor
+	taskActors            []taskActor
 }
 
 var periodics = []*periodic{}
 
-func Every(d time.Duration) *periodic {
+func EverySeconds(seconds int) *periodic {
 	ret := &periodic{
-		duration: d,
+		duration: time.Duration(seconds) * time.Second,
 		done:     make(chan bool),
 	}
 
@@ -44,101 +44,156 @@ func Loop() {
 	}
 }
 
+func (p *periodic) InWorkspace(name string) *periodic {
+	if p.workspaceClientGetter != nil {
+		panic("Multiple calls to InWorkspace()")
+	}
+
+	p.workspaceClientGetter = func(c *asanaclient.Client) (*asanaclient.WorkspaceClient, error) {
+		return c.InWorkspace(name)
+	}
+
+	return p
+}
+
+// Query mutators
 func (p *periodic) InMyTasksSections(names ...string) *periodic {
-  p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
+	p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
-		me, err := wc.GetMe()
+		utl, err := wc.GetMyUserTaskList()
 		if err != nil {
-      return err
+			return err
 		}
 
-		utl, err := wc.GetUserTaskList(me)
+		secsByName, err := wc.GetSectionsByName(utl)
 		if err != nil {
-      return err
+			return err
 		}
 
-		secs, err := wc.GetSections(utl)
+		for _, name := range names {
-		if err != nil {
+			sec, found := secsByName[name]
-      return err
+			if !found {
+				return fmt.Errorf("Section '%s' not found", name)
+			}
+
+			q.SectionsAny = append(q.SectionsAny, sec)
 		}
 
-    secsByName := map[string]*asanaclient.Section{}
+		return nil
-    for _, sec := range secs {
+	})
-      secsByName[sec.Name] = sec
-    }
 
-    for _, name := range names {
+	return p
-      sec, found := secsByName[name]
-      if !found {
-        return fmt.Errorf("Section '%s' not found", name)
-      }
-
-      q.SectionsAny = append(q.SectionsAny, sec)
-    }
-
-    return nil
-  })
-
-  return p
 }
 
 func (p *periodic) DueInDays(days int) *periodic {
-  p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
+	p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
-    d := civil.DateOf(time.Now())
+		if q.DueOn != nil {
-    d = d.AddDays(days)
+			return fmt.Errorf("Multiple clauses set DueOn")
-    dueOn := d.String()
+		}
-    q.DueOn = &dueOn
-    return nil
-  })
 
-  return p
+		d := civil.DateOf(time.Now())
+		d = d.AddDays(days)
+		q.DueOn = &d
+		return nil
+	})
+
+	return p
 }
 
-func (p *periodic) InWorkspace(name string) *periodic {
+func (p *periodic) DueInAtLeastDays(days int) *periodic {
-  p.workspaceClientGetter = func(c *asanaclient.Client) (*asanaclient.WorkspaceClient, error) {
+	p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
-    return c.InWorkspace(name)
+		if q.DueAfter != nil {
-  }
+			return fmt.Errorf("Multiple clauses set DueAfter")
+		}
 
-  return p
+		d := civil.DateOf(time.Now())
+		d = d.AddDays(days)
+		q.DueAfter = &d
+		return nil
+	})
+
+	return p
+}
+
+func (p *periodic) DueInAtMostDays(days int) *periodic {
+	p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
+		if q.DueBefore != nil {
+			return fmt.Errorf("Multiple clauses set DueBefore")
+		}
+
+		d := civil.DateOf(time.Now())
+		d = d.AddDays(days)
+		q.DueBefore = &d
+		return nil
+	})
+
+	return p
 }
 
 func (p *periodic) OnlyIncomplete() *periodic {
-  p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
+	p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
-    q.Completed = asanaclient.FALSE
+		if q.Completed != nil {
-    return nil
+			return fmt.Errorf("Multiple clauses set Completed")
-  })
+		}
 
-  return p
+		q.Completed = asanaclient.FALSE
+		return nil
+	})
+
+	return p
 }
 
 func (p *periodic) OnlyComplete() *periodic {
-  p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
+	p.queryMutators = append(p.queryMutators, func(wc *asanaclient.WorkspaceClient, q *asanaclient.SearchQuery) error {
-    q.Completed = asanaclient.TRUE
+		if q.Completed != nil {
-    return nil
+			return fmt.Errorf("Multiple clauses set Completed")
-  })
+		}
 
-  return p
+		q.Completed = asanaclient.TRUE
+		return nil
+	})
+
+	return p
+}
+
+// Task actors
+func (p *periodic) MoveToMyTasksSection(name string) *periodic {
+	p.taskActors = append(p.taskActors, func(wc *asanaclient.WorkspaceClient, t *asanaclient.Task) error {
+		utl, err := wc.GetMyUserTaskList()
+		if err != nil {
+			return err
+		}
+
+		sec, err := wc.GetSectionByName(utl, name)
+		if err != nil {
+			return err
+		}
+
+		return wc.AddTaskToSection(t, sec)
+	})
+
+	return p
 }
 
 func (p *periodic) PrintTasks() *periodic {
-  p.taskActors = append(p.taskActors, func(wc *asanaclient.WorkspaceClient, t *asanaclient.Task) error {
+	p.taskActors = append(p.taskActors, func(wc *asanaclient.WorkspaceClient, t *asanaclient.Task) error {
-    fmt.Printf("%s\n", t)
+		fmt.Printf("%s\n", t)
-    return nil
+		return nil
-  })
+	})
 
-  return p
+	return p
 }
 
 func (p *periodic) start(client *asanaclient.Client) {
-  err := p.validate()
+	err := p.validate()
-  if err != nil {
+	if err != nil {
-    panic(err)
+		panic(err)
-  }
+	}
 
 	go p.loop(client)
 }
 
 func (p *periodic) validate() error {
-  return nil
+	return nil
 }
 
 func (p *periodic) wait() {
@@ -150,44 +205,44 @@ func (p *periodic) loop(client *asanaclient.Client) {
 
 	for {
 		<-ticker.C
-    err := p.exec(client)
+		err := p.exec(client)
-    if err != nil {
+		if err != nil {
-      fmt.Printf("%s\n", err)
+			fmt.Printf("ERROR: %s\n", err)
-      // continue
+			// continue
-    }
+		}
 	}
 
 	close(p.done)
 }
 
 func (p *periodic) exec(c *asanaclient.Client) error {
-  wc, err := p.workspaceClientGetter(c)
+	wc, err := p.workspaceClientGetter(c)
-  if err != nil {
+	if err != nil {
-    return err
+		return err
-  }
+	}
 
-  q := &asanaclient.SearchQuery{}
+	q := &asanaclient.SearchQuery{}
 
-  for _, mut := range p.queryMutators {
+	for _, mut := range p.queryMutators {
-    err = mut(wc, q)
+		err = mut(wc, q)
-    if err != nil {
+		if err != nil {
-      return err
+			return err
-    }
+		}
-  }
+	}
 
-  tasks, err := wc.Search(q)
+	tasks, err := wc.Search(q)
-  if err != nil {
+	if err != nil {
-    return err
+		return err
-  }
+	}
 
-  for _, task := range tasks {
+	for _, task := range tasks {
-    for _, act := range p.taskActors {
+		for _, act := range p.taskActors {
-      err = act(wc, task)
+			err = act(wc, task)
-      if err != nil {
+			if err != nil {
-        return err
+				return err
-      }
+			}
-    }
+		}
-  }
+	}
 
-  return nil
+	return nil
 }

main.go

@@ -1,16 +1,24 @@
 package main
 
-import "time"
-
 import . "github.com/firestuff/asana-rules/asanarules"
 
 func main() {
-	Every(5 * time.Second).
+	EverySeconds(30).
-    InWorkspace("flamingcow.io").
+		InWorkspace("flamingcow.io").
-    InMyTasksSections("Recently Assigned").
+		InMyTasksSections("Recently Assigned").
-    OnlyIncomplete().
+		OnlyIncomplete().
-    DueInDays(0).
+		DueInDays(0).
-    PrintTasks()
+		PrintTasks().
+		MoveToMyTasksSection("Today")
+
+	EverySeconds(30).
+		InWorkspace("flamingcow.io").
+		InMyTasksSections("Recently Assigned").
+		OnlyIncomplete().
+		DueInAtLeastDays(1).
+		DueInAtMostDays(7).
+		PrintTasks().
+		MoveToMyTasksSection("Upcoming")
 
 	Loop()
 }