func bulkEditStart(issues []*github.Issue) (*github.Issue, []byte) {
common := new(github.Issue)
for i, issue := range issues {
if i == 0 {
common.State = issue.State
common.Assignee = issue.Assignee
common.Labels = issue.Labels
common.Milestone = issue.Milestone
continue
}
if common.State != nil && getString(common.State) != getString(issue.State) {
common.State = nil
}
if common.Assignee != nil && getUserLogin(common.Assignee) != getUserLogin(issue.Assignee) {
common.Assignee = nil
}
if common.Milestone != nil && getMilestoneTitle(common.Milestone) != getMilestoneTitle(issue.Milestone) {
common.Milestone = nil
}
common.Labels = commonLabels(common.Labels, issue.Labels)
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "State: %s\n", getString(common.State))
fmt.Fprintf(&buf, "Assignee: %s\n", getUserLogin(common.Assignee))
fmt.Fprintf(&buf, "Labels: %s\n", strings.Join(getLabelNames(common.Labels), " "))
fmt.Fprintf(&buf, "Milestone: %s\n", getMilestoneTitle(common.Milestone))
fmt.Fprintf(&buf, "\n<optional comment here>\n")
fmt.Fprintf(&buf, "%s\n", bulkHeader)
for _, issue := range issues {
fmt.Fprintf(&buf, "%d\t%s\n", getInt(issue.Number), getString(issue.Title))
}
return common, buf.Bytes()
}
func labelIssue(label string, issue *github.Issue) *github.Issue {
l := github.Label{
Name: stringPtr(label),
}
issue.Labels = append(issue.Labels, l)
return issue
}
func bulkWriteIssue(old *github.Issue, updated []byte, status func(string)) (ids []int, err error) {
i := bytes.Index(updated, []byte(bulkHeader))
if i < 0 {
return nil, fmt.Errorf("cannot find bulk edit issue list")
}
ids = readBulkIDs(updated[i:])
if len(ids) == 0 {
return nil, fmt.Errorf("found no issues in bulk edit issue list")
}
// Make a copy of the issue to modify.
x := *old
old = &x
// Try a write to issue -1, checking for formatting only.
old.Number = new(int)
*old.Number = -1
if _, err := writeIssue(old, updated, true); err != nil {
return nil, err
}
// Apply to all issues in list.
suffix := ""
if len(ids) != 1 {
suffix = "s"
}
status(fmt.Sprintf("updating %d issue%s", len(ids), suffix))
failed := false
for index, number := range ids {
if index%10 == 0 && index > 0 {
status(fmt.Sprintf("updated %d/%d issues", index, len(ids)))
}
// Check rate limits here (in contrast to everywhere else in this program)
// to avoid needless failure halfway through the loop.
// for client.Rate.Limit > 0 && client.Rate.Remaining == 0 {
// delta := (client.Rate.Reset.Sub(time.Now())/time.Minute + 2) * time.Minute
{
delta := time.Duration(0)
if delta < 0 {
delta = 2 * time.Minute
}
status(fmt.Sprintf("updated %d/%d issues; pausing %d minutes to respect GitHub rate limit", index, len(ids), int(delta/time.Minute)))
time.Sleep(delta)
if _, _, err := client.RateLimit(); err != nil {
status(fmt.Sprintf("reading rate limit: %v", err))
}
}
*old.Number = number
if _, err := writeIssue(old, updated, true); err != nil {
status(fmt.Sprintf("writing #%d: %s", number, strings.Replace(err.Error(), "\n", "\n\t", -1)))
failed = true
}
}
if failed {
return ids, fmt.Errorf("failed to update all issues")
}
return ids, nil
}
// Mark issue as open.
func OpenIssue(repo string, issue *github.Issue) (*github.Issue, error) {
temp := "open"
issue.State = &temp
closedIssue, err := EditIssue(repo, issue)
return closedIssue, err
}