bridge/gitlab: add exporter implementation

1 files changed, 518 insertions, 2 deletions

diff --git a/bridge/gitlab/export.go b/bridge/gitlab/export.go
index 85b5ee2e..723b7b6a 100644
--- a/bridge/gitlab/export.go
+++ b/bridge/gitlab/export.go
@@ -1,12 +1,17 @@
 package gitlab
 
 import (
+	"fmt"
+	"strconv"
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/xanzy/go-gitlab"
 
 	"github.com/MichaelMure/git-bug/bridge/core"
+	"github.com/MichaelMure/git-bug/bug"
 	"github.com/MichaelMure/git-bug/cache"
+	"github.com/MichaelMure/git-bug/util/git"
 )
 
 var (
@@ -14,14 +19,525 @@ var (
 )
 
 // gitlabExporter implement the Exporter interface
-type gitlabExporter struct{}
+type gitlabExporter struct {
+	conf core.Configuration
+
+	// cache identities clients
+	identityClient map[string]*gitlab.Client
+
+	// map identities with their tokens
+	identityToken map[string]string
+
+	// gitlab repository ID
+	repositoryID string
+
+	// cache identifiers used to speed up exporting operations
+	// cleared for each bug
+	cachedOperationIDs map[string]string
+
+	// cache labels used to speed up exporting labels events
+	cachedLabels map[string]string
+}
 
 // Init .
 func (ge *gitlabExporter) Init(conf core.Configuration) error {
+	ge.conf = conf
+	//TODO: initialize with multiple tokens
+	ge.identityToken = make(map[string]string)
+	ge.identityClient = make(map[string]*gitlab.Client)
+	ge.cachedOperationIDs = make(map[string]string)
+	ge.cachedLabels = make(map[string]string)
+
 	return nil
 }
 
+// getIdentityClient return a gitlab v4 API client configured with the access token of the given identity.
+// if no client were found it will initialize it from the known tokens map and cache it for next use
+func (ge *gitlabExporter) getIdentityClient(id string) (*gitlab.Client, error) {
+	client, ok := ge.identityClient[id]
+	if ok {
+		return client, nil
+	}
+
+	// get token
+	token, ok := ge.identityToken[id]
+	if !ok {
+		return nil, ErrMissingIdentityToken
+	}
+
+	// create client
+	client = buildClient(token)
+	// cache client
+	ge.identityClient[id] = client
+
+	return client, nil
+}
+
 // ExportAll export all event made by the current user to Gitlab
 func (ge *gitlabExporter) ExportAll(repo *cache.RepoCache, since time.Time) (<-chan core.ExportResult, error) {
-	return nil, nil
+	out := make(chan core.ExportResult)
+
+	user, err := repo.GetUserIdentity()
+	if err != nil {
+		return nil, err
+	}
+
+	ge.identityToken[user.Id()] = ge.conf[keyToken]
+
+	// get repository node id
+	ge.repositoryID = ge.conf[keyProjectID]
+
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		defer close(out)
+
+		var allIdentitiesIds []string
+		for id := range ge.identityToken {
+			allIdentitiesIds = append(allIdentitiesIds, id)
+		}
+
+		allBugsIds := repo.AllBugsIds()
+
+		for _, id := range allBugsIds {
+			b, err := repo.ResolveBug(id)
+			if err != nil {
+				out <- core.NewExportError(err, id)
+				return
+			}
+
+			snapshot := b.Snapshot()
+
+			// ignore issues created before since date
+			// TODO: compare the Lamport time instead of using the unix time
+			if snapshot.CreatedAt.Before(since) {
+				out <- core.NewExportNothing(b.Id(), "bug created before the since date")
+				continue
+			}
+
+			if snapshot.HasAnyActor(allIdentitiesIds...) {
+				// try to export the bug and it associated events
+				ge.exportBug(b, since, out)
+			} else {
+				out <- core.NewExportNothing(id, "not an actor")
+			}
+		}
+	}()
+
+	return out, nil
+}
+
+// exportBug publish bugs and related events
+func (ge *gitlabExporter) exportBug(b *cache.BugCache, since time.Time, out chan<- core.ExportResult) {
+	snapshot := b.Snapshot()
+
+	var err error
+	var bugGitlabID int
+	var bugGitlabIDString string
+	var bugGitlabURL string
+	var bugCreationHash string
+	//labels := make([]string, 0)
+
+	// Special case:
+	// if a user try to export a bug that is not already exported to Gitlab (or imported
+	// from Gitlab) and we do not have the token of the bug author, there is nothing we can do.
+
+	// skip bug if origin is not allowed
+	origin, ok := snapshot.GetCreateMetadata(core.KeyOrigin)
+	if ok && origin != target {
+		out <- core.NewExportNothing(b.Id(), fmt.Sprintf("issue tagged with origin: %s", origin))
+		return
+	}
+
+	// first operation is always createOp
+	createOp := snapshot.Operations[0].(*bug.CreateOperation)
+	author := snapshot.Author
+
+	// get gitlab bug ID
+	gitlabID, ok := snapshot.GetCreateMetadata(keyGitlabId)
+	if ok {
+		gitlabURL, ok := snapshot.GetCreateMetadata(keyGitlabUrl)
+		if !ok {
+			// if we find gitlab ID, gitlab URL must be found too
+			err := fmt.Errorf("expected to find gitlab issue URL")
+			out <- core.NewExportError(err, b.Id())
+		}
+
+		//FIXME:
+		// ignore issue comming from other repositories
+
+		out <- core.NewExportNothing(b.Id(), "bug already exported")
+		// will be used to mark operation related to a bug as exported
+		bugGitlabIDString = gitlabID
+		bugGitlabID, err = strconv.Atoi(bugGitlabIDString)
+		if err != nil {
+			panic("unexpected gitlab id format")
+		}
+
+		bugGitlabURL = gitlabURL
+
+	} else {
+		// check that we have a token for operation author
+		client, err := ge.getIdentityClient(author.Id())
+		if err != nil {
+			// if bug is still not exported and we do not have the author stop the execution
+			out <- core.NewExportNothing(b.Id(), fmt.Sprintf("missing author token"))
+			return
+		}
+
+		// create bug
+		id, url, err := createGitlabIssue(client, ge.repositoryID, createOp.Title, createOp.Message)
+		if err != nil {
+			err := errors.Wrap(err, "exporting gitlab issue")
+			out <- core.NewExportError(err, b.Id())
+			return
+		}
+
+		idString := strconv.Itoa(id)
+
+		out <- core.NewExportBug(b.Id())
+
+		hash, err := createOp.Hash()
+		if err != nil {
+			err := errors.Wrap(err, "comment hash")
+			out <- core.NewExportError(err, b.Id())
+			return
+		}
+
+		// mark bug creation operation as exported
+		if err := markOperationAsExported(b, hash, idString, url); err != nil {
+			err := errors.Wrap(err, "marking operation as exported")
+			out <- core.NewExportError(err, b.Id())
+			return
+		}
+
+		// commit operation to avoid creating multiple issues with multiple pushes
+		if err := b.CommitAsNeeded(); err != nil {
+			err := errors.Wrap(err, "bug commit")
+			out <- core.NewExportError(err, b.Id())
+			return
+		}
+
+		// cache bug gitlab ID and URL
+		bugGitlabID = id
+		bugGitlabIDString = idString
+		bugGitlabURL = url
+	}
+
+	// get createOp hash
+	hash, err := createOp.Hash()
+	if err != nil {
+		out <- core.NewExportError(err, b.Id())
+		return
+	}
+
+	bugCreationHash = hash.String()
+
+	// cache operation gitlab id
+	ge.cachedOperationIDs[bugCreationHash] = bugGitlabIDString
+
+	for _, op := range snapshot.Operations[1:] {
+		// ignore SetMetadata operations
+		if _, ok := op.(*bug.SetMetadataOperation); ok {
+			continue
+		}
+
+		// get operation hash
+		hash, err := op.Hash()
+		if err != nil {
+			err := errors.Wrap(err, "operation hash")
+			out <- core.NewExportError(err, b.Id())
+			return
+		}
+
+		// ignore operations already existing in gitlab (due to import or export)
+		// cache the ID of already exported or imported issues and events from Gitlab
+		if id, ok := op.GetMetadata(keyGitlabId); ok {
+			ge.cachedOperationIDs[hash.String()] = id
+			out <- core.NewExportNothing(hash.String(), "already exported operation")
+			continue
+		}
+
+		opAuthor := op.GetAuthor()
+		client, err := ge.getIdentityClient(opAuthor.Id())
+		if err != nil {
+			out <- core.NewExportNothing(hash.String(), "missing operation author token")
+			continue
+		}
+
+		var id int
+		var idString, url string
+		switch op.(type) {
+		case *bug.AddCommentOperation:
+			opr := op.(*bug.AddCommentOperation)
+
+			// send operation to gitlab
+			id, err = addCommentGitlabIssue(client, ge.repositoryID, bugGitlabID, opr.Message)
+			if err != nil {
+				err := errors.Wrap(err, "adding comment")
+				out <- core.NewExportError(err, b.Id())
+				return
+			}
+
+			idString = strconv.Itoa(id)
+			out <- core.NewExportComment(hash.String())
+
+			// cache comment id
+			ge.cachedOperationIDs[hash.String()] = idString
+
+		case *bug.EditCommentOperation:
+
+			opr := op.(*bug.EditCommentOperation)
+			targetHash := opr.Target.String()
+
+			// Since gitlab doesn't consider the issue body as a comment
+			if targetHash == bugCreationHash {
+
+				// case bug creation operation: we need to edit the Gitlab issue
+				if err := updateGitlabIssueBody(client, ge.repositoryID, id, opr.Message); err != nil {
+					err := errors.Wrap(err, "editing issue")
+					out <- core.NewExportError(err, b.Id())
+					return
+				}
+
+				out <- core.NewExportCommentEdition(hash.String())
+
+				id = bugGitlabID
+				url = bugGitlabURL
+
+			} else {
+
+				// case comment edition operation: we need to edit the Gitlab comment
+				_, ok := ge.cachedOperationIDs[targetHash]
+				if !ok {
+					panic("unexpected error: comment id not found")
+				}
+
+				err := editCommentGitlabIssue(client, ge.repositoryID, id, id, opr.Message)
+				if err != nil {
+					err := errors.Wrap(err, "editing comment")
+					out <- core.NewExportError(err, b.Id())
+					return
+				}
+
+				out <- core.NewExportCommentEdition(hash.String())
+
+				// use comment id/url instead of issue id/url
+				//id = eid
+				//url = eurl
+			}
+
+		case *bug.SetStatusOperation:
+			opr := op.(*bug.SetStatusOperation)
+			if err := updateGitlabIssueStatus(client, idString, id, opr.Status); err != nil {
+				err := errors.Wrap(err, "editing status")
+				out <- core.NewExportError(err, b.Id())
+				return
+			}
+
+			out <- core.NewExportStatusChange(hash.String())
+
+			id = bugGitlabID
+			url = bugGitlabURL
+
+		case *bug.SetTitleOperation:
+			opr := op.(*bug.SetTitleOperation)
+			if err := updateGitlabIssueTitle(client, ge.repositoryID, id, opr.Title); err != nil {
+				err := errors.Wrap(err, "editing title")
+				out <- core.NewExportError(err, b.Id())
+				return
+			}
+
+			out <- core.NewExportTitleEdition(hash.String())
+
+			id = bugGitlabID
+			url = bugGitlabURL
+
+		case *bug.LabelChangeOperation:
+			_ = op.(*bug.LabelChangeOperation)
+			if err := updateGitlabIssueLabels(client, ge.repositoryID, bugGitlabID, []string{}); err != nil {
+				err := errors.Wrap(err, "updating labels")
+				out <- core.NewExportError(err, b.Id())
+				return
+			}
+
+			out <- core.NewExportLabelChange(hash.String())
+
+			id = bugGitlabID
+			url = bugGitlabURL
+
+		default:
+			panic("unhandled operation type case")
+		}
+
+		// mark operation as exported
+		if err := markOperationAsExported(b, hash, idString, url); err != nil {
+			err := errors.Wrap(err, "marking operation as exported")
+			out <- core.NewExportError(err, b.Id())
+			return
+		}
+
+		// commit at each operation export to avoid exporting same events multiple times
+		if err := b.CommitAsNeeded(); err != nil {
+			err := errors.Wrap(err, "bug commit")
+			out <- core.NewExportError(err, b.Id())
+			return
+		}
+	}
+}
+
+func markOperationAsExported(b *cache.BugCache, target git.Hash, gitlabID, gitlabURL string) error {
+	_, err := b.SetMetadata(
+		target,
+		map[string]string{
+			keyGitlabId:  gitlabID,
+			keyGitlabUrl: gitlabURL,
+		},
+	)
+
+	return err
+}
+
+func (ge *gitlabExporter) getGitlabLabelID(label string) (string, error) {
+	id, ok := ge.cachedLabels[label]
+	if !ok {
+		return "", fmt.Errorf("non cached label")
+	}
+
+	return id, nil
+}
+
+// get label from gitlab
+func (ge *gitlabExporter) loadLabelsFromGitlab(gc *gitlab.Client) error {
+	labels, _, err := gc.Labels.ListLabels(
+		ge.repositoryID,
+		&gitlab.ListLabelsOptions{
+			Page: 0,
+		},
+	)
+
+	if err != nil {
+		return err
+	}
+
+	for _, label := range labels {
+		ge.cachedLabels[label.Name] = strconv.Itoa(label.ID)
+	}
+
+	for page := 2; len(labels) != 0; page++ {
+
+		labels, _, err = gc.Labels.ListLabels(
+			ge.repositoryID,
+			&gitlab.ListLabelsOptions{
+				Page: page,
+			},
+		)
+
+		if err != nil {
+			return err
+		}
+
+		for _, label := range labels {
+			ge.cachedLabels[label.Name] = strconv.Itoa(label.ID)
+		}
+	}
+
+	return nil
+}
+
+func (ge *gitlabExporter) createGitlabLabel(gc *gitlab.Client, label bug.Label) error {
+	client := buildClient(ge.conf[keyToken])
+
+	// RGBA to hex color
+	rgba := label.RGBA()
+	hexColor := fmt.Sprintf("%.2x%.2x%.2x", rgba.R, rgba.G, rgba.B)
+	name := label.String()
+
+	_, _, err := client.Labels.CreateLabel(ge.repositoryID, &gitlab.CreateLabelOptions{
+		Name:  &name,
+		Color: &hexColor,
+	})
+
+	return err
+}
+
+// create a gitlab. issue and return it ID
+func createGitlabIssue(gc *gitlab.Client, repositoryID, title, body string) (int, string, error) {
+	issue, _, err := gc.Issues.CreateIssue(repositoryID, &gitlab.CreateIssueOptions{
+		Title:       &title,
+		Description: &body,
+	})
+
+	if err != nil {
+		return 0, "", err
+	}
+
+	return issue.IID, issue.WebURL, nil
+}
+
+// add a comment to an issue and return it ID
+func addCommentGitlabIssue(gc *gitlab.Client, repositoryID string, issueID int, body string) (int, error) {
+	note, _, err := gc.Notes.CreateIssueNote(repositoryID, issueID, &gitlab.CreateIssueNoteOptions{
+		Body: &body,
+	})
+
+	if err != nil {
+		return 0, err
+	}
+
+	return note.ID, nil
+}
+
+func editCommentGitlabIssue(gc *gitlab.Client, repositoryID string, issueID, noteID int, body string) error {
+	_, _, err := gc.Notes.UpdateIssueNote(repositoryID, issueID, noteID, &gitlab.UpdateIssueNoteOptions{
+		Body: &body,
+	})
+
+	return err
+}
+
+func updateGitlabIssueStatus(gc *gitlab.Client, repositoryID string, issueID int, status bug.Status) error {
+	var state string
+
+	switch status {
+	case bug.OpenStatus:
+		state = "reopen"
+	case bug.ClosedStatus:
+		state = "close"
+	default:
+		panic("unknown bug state")
+	}
+
+	_, _, err := gc.Issues.UpdateIssue(repositoryID, issueID, &gitlab.UpdateIssueOptions{
+		StateEvent: &state,
+	})
+
+	return err
+}
+
+func updateGitlabIssueBody(gc *gitlab.Client, repositoryID string, issueID int, body string) error {
+	_, _, err := gc.Issues.UpdateIssue(repositoryID, issueID, &gitlab.UpdateIssueOptions{
+		Description: &body,
+	})
+
+	return err
+}
+
+func updateGitlabIssueTitle(gc *gitlab.Client, repositoryID string, issueID int, title string) error {
+	_, _, err := gc.Issues.UpdateIssue(repositoryID, issueID, &gitlab.UpdateIssueOptions{
+		Title: &title,
+	})
+
+	return err
+}
+
+// update gitlab. issue labels
+func updateGitlabIssueLabels(gc *gitlab.Client, repositoryID string, issueID int, labels []string) error {
+	_, _, err := gc.Issues.UpdateIssue(repositoryID, issueID, &gitlab.UpdateIssueOptions{
+		Labels: labels,
+	})
+
+	return err
 }