fix(gitea-api): authorize for issues in private repositories / organizations

This also fixes an issue with the taskwarrior filters to not overwrite
existing other tasks from other repositories.

internal/gitea/comment.go

@@ -25,16 +25,17 @@ type Comment struct {
 }
 
 func (gitea *Gitea) GetComments(repo Repository) ([]Comment, error) {
+	client := &http.Client{}
 	url := fmt.Sprintf("%s/repos/%s/issues/comments", gitea.Url(), repo.Full_name)
-	response, err := http.Get(url)
+	request, err := http.NewRequest(http.MethodGet, url, nil)
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	response, err := client.Do(request)
 	if err != nil {
 		return nil, err
 	}
 	defer response.Body.Close()
 	var data []Comment
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&data); err != nil {
 		return nil, err
 	}
@@ -45,16 +46,17 @@ func (gitea *Gitea) GetComments(repo Repository) ([]Comment, error) {
 }
 
 func (gitea *Gitea) GetComment(repo Repository, id uint) (Comment, error) {
+	client := &http.Client{}
 	url := fmt.Sprintf("%s/repos/%s/issues/comments/%d", gitea.Url(), repo.Full_name, id)
-	response, err := http.Get(url)
+	request, err := http.NewRequest(http.MethodGet, url, nil)
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	response, err := client.Do(request)
 	var comment Comment
 	if err != nil {
 		return comment, err
 	}
 	defer response.Body.Close()
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&comment); err != nil {
 		return comment, err
 	}
@@ -113,8 +115,6 @@ func (gitea *Gitea) NewComment(repo Repository, issue Issue, comment Comment) (C
 		return res, errors.New(fmt.Sprintf("\tRequest returned status: %s\n", result.Status))
 	}
 	decoder := json.NewDecoder(result.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&res); err != nil {
 		return res, err
 	}

internal/gitea/issue.go

@@ -48,16 +48,17 @@ type Issue struct {
 }
 
 func (gitea *Gitea) GetIssues(repo Repository) ([]Issue, error) {
+	client := &http.Client{}
 	url := fmt.Sprintf("%s/repos/%s/issues?state=all", gitea.Url(), repo.Full_name)
-	response, err := http.Get(url)
+	request, err := http.NewRequest(http.MethodGet, url, nil)
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	response, err := client.Do(request)
 	if err != nil {
 		return nil, err
 	}
 	defer response.Body.Close()
 	var data []Issue
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&data); err != nil {
 		return nil, err
 	}
@@ -66,15 +67,16 @@ func (gitea *Gitea) GetIssues(repo Repository) ([]Issue, error) {
 
 func (gitea *Gitea) GetIssue(repo Repository, id uint) (Issue, error) {
 	var issue Issue
+	client := &http.Client{}
 	url := fmt.Sprintf("%s/repos/%s/issues/%d", gitea.Url(), repo.Full_name, id)
-	response, err := http.Get(url)
+	request, err := http.NewRequest(http.MethodGet, url, nil)
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	response, err := client.Do(request)
 	if err != nil {
 		return issue, err
 	}
 	defer response.Body.Close()
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&issue); err != nil {
 		return issue, err
 	}
@@ -132,14 +134,16 @@ func (gitea *Gitea) NewIssue(repo Repository, issue Issue) (Issue, error) {
 	if err != nil {
 		return res, err
 	}
-	response, err := http.Post(url, "appliaction/json", bytes.NewBuffer(json_payload))
+	client := &http.Client{}
+	request, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(json_payload))
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	request.Header.Set("content-type", "application/json")
+	response, err := client.Do(request)
 	if err != nil {
 		return res, err
 	}
 	defer response.Body.Close()
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&res); err != nil {
 		return res, err
 	}

internal/gitea/milestone.go

@@ -81,16 +81,17 @@ func (milestone *Milestone) MergeTask(task taskwarrior.Task) taskwarrior.Task {
 }
 
 func (gitea *Gitea) GetMilestones(repo Repository) ([]Milestone, error) {
+	client := &http.Client{}
 	url := fmt.Sprintf("%s/repos/%s/milestones?state=all", gitea.Url(), repo.Full_name)
-	response, err := http.Get(url)
+	request, err := http.NewRequest(http.MethodGet, url, nil)
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	response, err := client.Do(request)
 	if err != nil {
 		return nil, err
 	}
 	defer response.Body.Close()
 	var data []Milestone
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&data); err != nil {
 		return nil, err
 	}
@@ -98,16 +99,17 @@ func (gitea *Gitea) GetMilestones(repo Repository) ([]Milestone, error) {
 }
 
 func (gitea *Gitea) GetMilestone(repo Repository, id uint) (Milestone, error) {
+	client := &http.Client{}
 	url := fmt.Sprintf("%s/repos/%s/milestones/%d", gitea.Url(), repo.Full_name, id)
-	response, err := http.Get(url)
+	request, err := http.NewRequest(http.MethodGet, url, nil)
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	response, err := client.Do(request)
 	var milestone Milestone
 	if err != nil {
 		return milestone, err
 	}
 	defer response.Body.Close()
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to store everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&milestone); err != nil {
 		return milestone, err
 	}
@@ -155,14 +157,16 @@ func (gitea *Gitea) NewMilestone(repo Repository, milestone Milestone) (Mileston
 	if err != nil {
 		return res, err
 	}
-	response, err := http.Post(url, "application/json", bytes.NewBuffer(payload))
+	client := &http.Client{}
+	request, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(payload))
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	request.Header.Set("content-type", "application/json")
+	response, err := client.Do(request)
 	if err != nil {
 		return res, err
 	}
 	defer response.Body.Close()
 	decoder := json.NewDecoder(response.Body)
-	// NOTE: remove this if I do not want to stare everything from the json result in the struct
-	decoder.DisallowUnknownFields() // remain if every field shall be extracted
 	if err = decoder.Decode(&res); err != nil {
 		return res, err
 	}

internal/gitea/repository.go

@@ -2,6 +2,7 @@ package gitea
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 )
@@ -22,11 +23,20 @@ func NewRepository(name, owner string) (repo Repository) {
 
 func (gitea *Gitea) VerifyRepository(repository Repository) (Repository, error) {
 	url := fmt.Sprintf("%s/repos/%s", gitea.Url(), repository.Full_name)
-	response, err := http.Get(url)
+	client := &http.Client{}
+	request, err := http.NewRequest(http.MethodGet, url, nil)
+	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
+	if err != nil {
+		return repository, err
+	}
+	response, err := client.Do(request)
 	if err != nil {
 		return repository, err
 	}
 	defer response.Body.Close()
+	if response.StatusCode != 200 {
+		return repository, errors.New(fmt.Sprintf("\tCould not verify repository with returned status: %s\n", response.Status))
+	}
 	var data map[string]interface{}
 	decoder := json.NewDecoder(response.Body)
 	if err = decoder.Decode(&data); err != nil {

internal/gitw/project.go

@@ -233,6 +233,7 @@ func (project *Project) merge(dry_run bool) error {
 	// NOTE: merge tasks
 	for _, issue := range project.issues {
 		filter.Reset()
+		filter.IncludeProjects(project.repository.Name)
 		filter.IncludeGitNumber(issue.git_issue.Number)
 		filter.IncludeGitType(taskwarrior.ISSUE)
 		git_tasks, err := taskwarrior.GetTasks(filter)
@@ -275,6 +276,7 @@ func (project *Project) merge(dry_run bool) error {
 	// TODO: merge milestones
 	for _, milestone := range project.milestones {
 		filter.Reset()
+		filter.IncludeProjects(project.repository.Name)
 		filter.IncludeGitNumber(milestone.Id)
 		filter.IncludeGitType(taskwarrior.MILESTONE)
 		git_tasks, err := taskwarrior.GetTasks(filter)
@@ -296,6 +298,7 @@ func (project *Project) merge(dry_run bool) error {
 				}
 				// link to the corresponding task
 				filter.Reset()
+				filter.IncludeProjects(project.repository.Name)
 				filter.IncludeGitNumber(issue.git_issue.Number)
 				filter.IncludeGitType(taskwarrior.ISSUE)
 				tasks, err := taskwarrior.GetTasks(filter)

internal/taskwarrior/task.go

@@ -113,7 +113,6 @@ func GetTasks(filter Filter) ([]Task, error) {
 	}
 	var tasks []Task
 	decoder := json.NewDecoder(bytes.NewBuffer(out))
-	decoder.DisallowUnknownFields()
 	if err = decoder.Decode(&tasks); err != nil {
 		return nil, err
 	}