Changelog v0.5.0 (#205)

Add Changelog for v0.5.0

Update SubComand Descriptions

Co-authored-by: 6543 <6543@obermui.de>
Reviewed-on: https://gitea.com/gitea/tea/pulls/205
Reviewed-by: Norwin <noerw@noreply.gitea.io>
Reviewed-by: Andrew Thornton <art27@cantab.net>

.changelog.yml

@@ -0,0 +1,56 @@
+# The full repository name
+repo: gitea/tea
+
+# Service type (gitea or github)
+service: gitea
+
+# Base URL for Gitea instance if using gitea service type (optional)
+base-url: https://gitea.com
+
+# Changelog groups and which labeled PRs to add to each group
+groups:
+  -
+    name: BREAKING
+    labels:
+      - kind/breaking
+  -
+    name: FEATURES
+    labels:
+      - kind/feature
+  -
+    name: BUGFIXES
+    labels:
+      - kind/bug
+  -
+    name: ENHANCEMENTS
+    labels:
+      - kind/enhancement
+      - kind/refactor
+      - kind/ui
+  -
+    name: SECURITY
+    labels:
+      - kind/security
+  -
+    name: TESTING
+    labels:
+      - kind/testing
+  -
+    name: TRANSLATION
+    labels:
+      - kind/translation
+  -
+    name: BUILD
+    labels:
+      - kind/build
+      - kind/lint
+  -
+    name: DOCS
+    labels:
+    - kind/docs
+  -
+    name: MISC
+    default: true
+
+# regex indicating which labels to skip for the changelog
+skip-labels: skip-changelog|backport\/.+

.drone.yml

@@ -13,7 +13,7 @@ workspace:
 steps:
 - name: build
   pull: always
-  image: golang:1.13
+  image: golang:1.15
   environment:
       GOPROXY: https://goproxy.cn
   commands:
@@ -32,7 +32,7 @@ steps:
 
 - name: unit-test
   pull: always
-  image: golang:1.13
+  image: golang:1.15
   commands:
   - make unit-test-coverage
   settings:
@@ -46,7 +46,7 @@ steps:
 
 - name: release-test
   pull: always
-  image: golang:1.13
+  image: golang:1.15
   commands:
   - make test
   settings:
@@ -60,7 +60,7 @@ steps:
 
 - name: tag-test
   pull: always
-  image: golang:1.13
+  image: golang:1.15
   commands:
   - make test
   settings:
@@ -72,6 +72,8 @@ steps:
 - name: static
   pull: always
   image: techknowlogick/xgo:latest
+  environment:
+    GOPROXY: https://goproxy.cn
   commands:
   - export PATH=$PATH:$GOPATH/bin
   - make release
@@ -163,15 +165,15 @@ steps:
     event:
     - push
 
-- name: github
+- name: gitea
   pull: always
-  image: plugins/gitea-releases:1
+  image: plugins/gitea-release:1
   settings:
     files:
     - "dist/release/*"
-  environment:
-    GITHUB_TOKEN:
-      from_secret: github_token
+    base_url: https://gitea.com
+    api_key:
+      from_secret: gitea_token
   when:
     event:
     - tag

.gitignore

@@ -1,4 +1,6 @@
 tea
+/gitea-vet
+
 .idea/
 .history/
-
+dist/

CHANGELOG.md

@@ -0,0 +1,102 @@
+# Changelog
+
+## [v0.5.0](https://gitea.com/gitea/tea/releases/tag/v0.5.0) - 2020-09-27
+
+* BREAKING
+  * Add Login Manage Functions (#182)
+* FEATURES
+  * Add Release Subcomands (#195)
+  * Render Markdown and colorize labels table (#181)
+  * Add BasicAuth & Interactive for Login (#174)
+  * Add milestones subcomands (#149)
+* BUGFIXES
+  * Fix Pulls Create (#202)
+  * Pulls create: detect head branch repo owner (#193)
+  * Fix Labels Delete (#180)
+* ENHANCEMENTS
+  * Add Pagination Options for List Subcomands (#204)
+  * Issues/Pulls: Details show State (#196)
+  * Make issues & pulls subcommands consistent (#188)
+  * Update SDK to v0.13.0 (#179)
+  * More Options To Specify Repo (#178)
+  * Add Repo Create subcomand & enhancements (#173)
+  * Times: format duration as seconds for machine-readable outputs (#168)
+  * Add user message to login list view (#166)
+
+## [v0.4.1](https://gitea.com/gitea/tea/releases/tag/v0.4.1) - 2020-09-13
+
+* BUGFIXES
+  * Notification don't relay on a repo (#159)
+
+## [v0.4.0](https://gitea.com/gitea/tea/pulls?q=&type=all&state=closed&milestone=1264) - 2020-07-18
+
+* FEATURES
+  * Add notifications subcomand (#148)
+  * Add subcomand 'pulls create' (#144)
+* BUGFIXES
+  * Fix Login Detection By Repo Param (#151)
+  * Fix Login List Output (#150)
+  * Fix --ssh-key Option (#135)
+* ENHANCEMENTS
+  * Subcomand Login Show List By Default (#152)
+* BUILD
+  * Migrate src-d/go-git to go-git/go-git (#128)
+  * Migrate gitea-sdk to v0.12.0 (#133)
+  * Migrate yaml lib (#130)
+  * Add gitea-vet (#121)
+
+## [v0.3.1](https://gitea.com/gitea/tea/pulls?q=&type=all&state=closed&milestone=1265) - 2020-06-15
+
+* BUGFIXES
+  * --ssh-key should be string not bool (#135) (#137)
+  * modules/git: fix dropped error (#127)
+  * Issues details: add missing newline (#126)
+
+## [v0.3.0](https://gitea.com/gitea/tea/pulls?q=&type=all&state=closed&milestone=1227) - 2020-04-22
+
+* FEATURES
+  * Add `tea pulls [checkout | clean]` commands (#93 #97 #107) (#105)
+  * Add `tea open` (#101)
+  * Add `tea issues [open|close]` commands (#99)
+* ENHANCEMENTS
+  * Ignore PRs for `tea issues` (#111)
+  * Add --state flag filter to issue & PR lists (#100)
+
+## [v0.2.0](https://gitea.com/gitea/tea/pulls?q=&type=all&state=closed&milestone=538) - 2020-03-06
+* FEATURES
+  * Add `tea times` command (#54)
+* ENHANCEMENTS
+  * Upgrade urfave/cli to v2 version (#85)
+  * Add --remote flag to add/create subcommands (#77)
+* BUILD
+  * Upgrade gitea/go-sdk to 2020-01-03 (#81)
+  * Update stretchr/testify v1.3.0 -> v1.4.0 (#83)
+  * Improve makefile to enable goproxy when go get tools (#98)
+
+## [v0.1.2](https://gitea.com/gitea/tea/pulls?q=&type=all&state=closed&milestone=59) - 2019-11-15
+* BUILD
+  * Fix typo in drone (#75)
+
+## [v0.1.1](https://gitea.com/gitea/tea/pulls?q=&type=all&state=closed&milestone=59) - 2019-11-15
+* FEATURES
+  * Add repos subcommand (#65)
+* ENHANCEMENTS
+  * Minor improvements to command-line language (#66)
+
+## [v0.1.0](https://gitea.com/gitea/tea/pulls?q=&type=all&state=closed&milestone=59) - 2019-10-28
+* BREAKING
+  * Changed git config determination to go-git (#41) [continue #45] (#62)
+* FEATURES
+  * Add labels commands (#36)
+* BUGFIXES
+  * Fix out -o flag (#53)
+  * Fix log formatting, refactor flag definition in cmd/labels.go (#52)
+* ENHANCEMENTS
+  * List label description (#60)
+  * Use Different Remote Repos (#58)
+  * Unified output (#14) (#40)
+  * Added global appendable Flags (#12) (#39)
+* BUILD
+  * Change .drone.yml to new format (#33)
+* DOCS
+  * Add install guide from brew on README (#61)

Makefile

@@ -1,6 +1,6 @@
 DIST := dist
 IMPORT := code.gitea.io/tea
-export GO111MODULE=off
+export GO111MODULE=on
 
 GO ?= go
 SED_INPLACE := sed -i
@@ -59,7 +59,7 @@ all: build
 
 .PHONY: clean
 clean:
-	$(GO) clean -i ./...
+	$(GO) clean -mod=vendor -i ./...
 	rm -rf $(EXECUTABLE) $(DIST)
 
 .PHONY: fmt
@@ -68,26 +68,30 @@ fmt:
 
 .PHONY: vet
 vet:
-	$(GO) vet $(PACKAGES)
+	# Default vet
+	$(GO) vet -mod=vendor $(PACKAGES)
+	# Custom vet
+	$(GO) build -mod=vendor code.gitea.io/gitea-vet
+	$(GO) vet -vettool=gitea-vet $(PACKAGES)
 
 .PHONY: lint
 lint:
 	@hash revive > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u github.com/mgechev/revive; \
+		cd /tmp && $(GO) get -u github.com/mgechev/revive; \
 	fi
 	revive -config .revive.toml -exclude=./vendor/... ./... || exit 1
 
 .PHONY: misspell-check
 misspell-check:
 	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u github.com/client9/misspell/cmd/misspell; \
+		cd /tmp && $(GO) get -u github.com/client9/misspell/cmd/misspell; \
 	fi
 	misspell -error -i unknwon,destory $(GOFILES)
 
 .PHONY: misspell
 misspell:
 	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u github.com/client9/misspell/cmd/misspell; \
+		cd /tmp && $(GO) get -u github.com/client9/misspell/cmd/misspell; \
 	fi
 	misspell -w -i unknwon $(GOFILES)
 
@@ -103,15 +107,15 @@ fmt-check:
 
 .PHONY: test
 test:
-	GO111MODULE=on $(GO) test -mod=vendor -tags='sqlite sqlite_unlock_notify' $(PACKAGES)
+	$(GO) test -mod=vendor -tags='sqlite sqlite_unlock_notify' $(PACKAGES)
 
 .PHONY: unit-test-coverage
 unit-test-coverage:
-	$(GO) test -tags='sqlite sqlite_unlock_notify' -cover -coverprofile coverage.out $(PACKAGES) && echo "\n==>\033[32m Ok\033[m\n" || exit 1
+	$(GO) test -mod=vendor -tags='sqlite sqlite_unlock_notify' -cover -coverprofile coverage.out $(PACKAGES) && echo "\n==>\033[32m Ok\033[m\n" || exit 1
 
 .PHONY: vendor
 vendor:
-	GO111MODULE=on $(GO) mod tidy && GO111MODULE=on $(GO) mod vendor
+	$(GO) mod tidy && $(GO) mod vendor
 
 .PHONY: test-vendor
 test-vendor: vendor
@@ -133,7 +137,7 @@ install: $(wildcard *.go)
 build: $(EXECUTABLE)
 
 $(EXECUTABLE): $(SOURCES)
-	GO111MODULE=on $(GO) build -mod=vendor $(GOFLAGS) $(EXTRA_GOFLAGS) -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)' -o $@
+	$(GO) build -mod=vendor $(GOFLAGS) $(EXTRA_GOFLAGS) -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)' -o $@
 
 .PHONY: release
 release: release-dirs release-windows release-linux release-darwin release-copy release-compress release-check
@@ -145,9 +149,9 @@ release-dirs:
 .PHONY: release-windows
 release-windows:
 	@hash xgo > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u src.techknowlogick.com/xgo; \
+		cd /tmp && $(GO) get -u src.techknowlogick.com/xgo; \
 	fi
-	xgo -dest $(DIST)/binaries -tags 'netgo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets 'windows/*' -out tea-$(VERSION) .
+	GO111MODULE=off xgo -dest $(DIST)/binaries -tags 'netgo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets 'windows/*' -out tea-$(VERSION) .
 ifeq ($(CI),drone)
 	cp /build/* $(DIST)/binaries
 endif
@@ -155,9 +159,9 @@ endif
 .PHONY: release-linux
 release-linux:
 	@hash xgo > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u src.techknowlogick.com/xgo; \
+		cd /tmp && $(GO) get -u src.techknowlogick.com/xgo; \
 	fi
-	xgo -dest $(DIST)/binaries -tags 'netgo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets 'linux/*' -out tea-$(VERSION) .
+	GO111MODULE=off xgo -dest $(DIST)/binaries -tags 'netgo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets 'linux/amd64,linux/386,linux/arm-5,linux/arm-6,linux/arm64,linux/mips64le,linux/mips,linux/mipsle' -out tea-$(VERSION) .
 ifeq ($(CI),drone)
 	cp /build/* $(DIST)/binaries
 endif
@@ -165,9 +169,9 @@ endif
 .PHONY: release-darwin
 release-darwin:
 	@hash xgo > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u src.techknowlogick.com/xgo; \
+		cd /tmp && $(GO) get -u src.techknowlogick.com/xgo; \
 	fi
-	xgo -dest $(DIST)/binaries -tags 'netgo $(TAGS)' -ldflags '$(LDFLAGS)' -targets 'darwin/*' -out tea-$(VERSION) .
+	GO111MODULE=off xgo -dest $(DIST)/binaries -tags 'netgo $(TAGS)' -ldflags '$(LDFLAGS)' -targets 'darwin/*' -out tea-$(VERSION) .
 ifeq ($(CI),drone)
 	cp /build/* $(DIST)/binaries
 endif
@@ -179,7 +183,7 @@ release-copy:
 .PHONY: release-compress
 release-compress:
 	@hash gxz > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u github.com/ulikunitz/xz/cmd/gxz; \
+		GO111MODULE=off $(GO) get -u github.com/ulikunitz/xz/cmd/gxz; \
 	fi
 	cd $(DIST)/release/; for file in `find . -type f -name "*"`; do echo "compressing $${file}" && gxz -k -9 $${file}; done;
 

README.md

@@ -1,31 +1,35 @@
-# Gitea Command Line Tool for Go
+# <img alt='' src='https://gitea.com/repo-avatars/550-80a3a8c2ab0e2c2d69f296b7f8582485' height="40"/> *T E A*
 
-This project acts as a command line tool for operating one or multiple Gitea instances. It depends on [code.gitea.io/sdk](https://code.gitea.io/sdk) client SDK implementation written in Go to interact with
-the Gitea API implementation.
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![Release](https://raster.shields.io/badge/dynamic/json.svg?label=release&url=https://gitea.com/api/v1/repos/gitea/tea/releases&query=$[0].tag_name)](https://gitea.com/gitea/tea/releases) [![Build Status](https://drone.gitea.com/api/badges/gitea/tea/status.svg)](https://drone.gitea.com/gitea/tea) [![Join the chat at https://img.shields.io/discord/322538954119184384.svg](https://img.shields.io/discord/322538954119184384.svg)](https://discord.gg/Gitea) [![Go Report Card](https://goreportcard.com/badge/code.gitea.io/tea)](https://goreportcard.com/report/code.gitea.io/tea) [![GoDoc](https://godoc.org/code.gitea.io/tea?status.svg)](https://godoc.org/code.gitea.io/tea)
+
+## The official CLI interface for gitea
+
+Tea is a command line tool for interacting on one or more Gitea instances.
+It uses [code.gitea.io/sdk](https://code.gitea.io/sdk) and interacts with the Gitea API
+
+![demo gif](https://dl.gitea.io/screenshots/tea_demo.gif)
 
 ## Installation
 
-Currently no prebuilt binaries are provided.
-To install, a Go installation is needed.
+You can use the prebuilt binaries from [dl.gitea.io](https://dl.gitea.io/tea/)
 
+
+To install from source, go 1.13 or newer is required:
 ```sh
 go get code.gitea.io/tea
 go install code.gitea.io/tea
 ```
 
-If the `tea` executable is not found, you might need to set up your `$GOPATH` and `$PATH` variables first:
 
-```sh
-export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
-```
-
-If you have `brew` installed, you can install tea version via:
+If you have `brew` installed, you can install `tea` via:
 
 ```sh
 brew tap gitea/tap https://gitea.com/gitea/homebrew-gitea
-brew install --devel tea
+brew install tea
 ```
 
+Distribution packages exist for: **alpinelinux ([tea](https://pkgs.alpinelinux.org/packages?name=tea&branch=edge))** and **archlinux ([gitea-tea](https://aur.archlinux.org/packages/gitea-tea))**
+
 ## Usage
 
 First of all, you have to create a token on your `personal settings -> application` page of your gitea instance.
@@ -35,29 +39,44 @@ Use this token to login with `tea`:
 tea login add --name=try --url=https://try.gitea.io --token=xxxxxx
 ```
 
-Now you can use the `tea` commands:
+Now you can use the following `tea` subcommands.
+Detailed usage information is available via `tea <command> --help`.
 
 ```sh
-tea issues
-tea releases
+login            Log in to a Gitea server
+logout           Log out from a Gitea server
+issues           List, create and update issues
+pulls            List, create, checkout and clean pull requests
+releases         List, create, update and delete releases
+repos            Operate with repositories
+labels           Manage issue labels
+times            Operate on tracked times of a repositorys issues and pulls
+open             Open something of the repository on web browser
+notifications    Show notifications
+milestones       List and create milestones
 ```
 
-> If you are inside a git repository hosted on a gitea instance, you don't need to specify the `--login` and `--repo` flags!
+To fetch issues from different repos, use the `--remote` flag (when inside a gitea repository directory) or `--login` & `--repo` flags.
 
 ## Compilation
 
+Make sure you have installed a current go version.
 To compile the sources yourself run the following:
 
 ```sh
-go get code.gitea.io/tea
-cd "${GOPATH}/src/code.gitea.io/tea"
-go build
+git clone https://gitea.com/gitea/tea.git
+cd tea
+make
 ```
 
 ## Contributing
 
 Fork -> Patch -> Push -> Pull Request
 
+- `make test` run testsuite
+- `make vendor` when adding new dependencies
+- ... (for other development tasks, check the `Makefile`)
+
 ## Authors
 
 * [Maintainers](https://github.com/orgs/go-gitea/people)

build.go

@@ -0,0 +1,14 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+//+build vendor
+
+package main
+
+// Libraries that are included to vendor utilities used during build.
+// These libraries will not be included in a normal compilation.
+
+import (
+	// for vet
+	_ "code.gitea.io/gitea-vet"
+)

cmd/config.go

@@ -18,11 +18,12 @@ import (
 	"strings"
 
 	"code.gitea.io/sdk/gitea"
-	local_git "code.gitea.io/tea/modules/git"
+	"code.gitea.io/tea/modules/git"
 	"code.gitea.io/tea/modules/utils"
-	go_git "gopkg.in/src-d/go-git.v4"
 
-	"github.com/go-gitea/yaml"
+	"github.com/muesli/termenv"
+	"github.com/urfave/cli/v2"
+	"gopkg.in/yaml.v2"
 )
 
 // Login represents a login to a gitea server, you even could add multiple logins for one gitea server
@@ -30,23 +31,34 @@ type Login struct {
 	Name    string `yaml:"name"`
 	URL     string `yaml:"url"`
 	Token   string `yaml:"token"`
-	Active   bool   `yaml:"active"`
+	Default bool   `yaml:"default"`
 	SSHHost string `yaml:"ssh_host"`
+	// optional path to the private key
+	SSHKey   string `yaml:"ssh_key"`
 	Insecure bool   `yaml:"insecure"`
+	// optional gitea username
+	User string `yaml:"user"`
 }
 
 // Client returns a client to operate Gitea API
 func (l *Login) Client() *gitea.Client {
-	client := gitea.NewClient(l.URL, l.Token)
+	httpClient := &http.Client{}
 	if l.Insecure {
 		cookieJar, _ := cookiejar.New(nil)
 
-		client.SetHTTPClient(&http.Client{
+		httpClient = &http.Client{
 			Jar: cookieJar,
 			Transport: &http.Transport{
 				TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-			},
-		})
+			}}
+	}
+
+	client, err := gitea.NewClient(l.URL,
+		gitea.SetToken(l.Token),
+		gitea.SetHTTPClient(httpClient),
+	)
+	if err != nil {
+		log.Fatal(err)
 	}
 	return client
 }
@@ -84,26 +96,36 @@ func init() {
 	dir := filepath.Join(homeDir, ".tea")
 	err = os.MkdirAll(dir, os.ModePerm)
 	if err != nil {
-		log.Fatal("Init tea config dir", dir, "failed")
+		log.Fatal("Init tea config dir " + dir + " failed")
 	}
 
 	yamlConfigPath = filepath.Join(dir, "tea.yml")
 }
 
-func splitRepo(repoPath string) (string, string) {
+func getGlamourTheme() string {
+	if termenv.HasDarkBackground() {
+		return "dark"
+	}
+	return "light"
+}
+
+func getOwnerAndRepo(repoPath, user string) (string, string) {
+	if len(repoPath) == 0 {
+		return "", ""
+	}
 	p := strings.Split(repoPath, "/")
 	if len(p) >= 2 {
 		return p[0], p[1]
 	}
-	return repoPath, ""
+	return user, repoPath
 }
 
-func getActiveLogin() (*Login, error) {
+func getDefaultLogin() (*Login, error) {
 	if len(config.Logins) == 0 {
 		return nil, errors.New("No available login")
 	}
 	for _, l := range config.Logins {
-		if l.Active {
+		if l.Default {
 			return &l, nil
 		}
 	}
@@ -126,7 +148,7 @@ func addLogin(login Login) error {
 			if l.URL == login.URL && l.Token == login.Token {
 				return nil
 			}
-			return errors.New("login name has already been  used")
+			return errors.New("Login name has already been used")
 		}
 		if l.URL == login.URL && l.Token == login.Token {
 			return errors.New("URL has been added")
@@ -155,7 +177,7 @@ func isFileExist(fileName string) (bool, error) {
 		return false, err
 	}
 	if f.IsDir() {
-		return false, errors.New("the same name directory exist")
+		return false, errors.New("A directory with the same name exists")
 	}
 	return true, nil
 }
@@ -186,19 +208,25 @@ func saveConfig(ymlPath string) error {
 	return ioutil.WriteFile(ymlPath, bs, 0660)
 }
 
-func curGitRepoPath() (*Login, string, error) {
-	gitPath, err := go_git.PlainOpenWithOptions("./", &go_git.PlainOpenOptions{DetectDotGit: true})
-	if err != nil {
-		return nil, "", errors.New("No Gitea login found")
+func curGitRepoPath(path string) (*Login, string, error) {
+	var err error
+	var repo *git.TeaRepo
+	if len(path) == 0 {
+		repo, err = git.RepoForWorkdir()
+	} else {
+		repo, err = git.RepoFromPath(path)
 	}
-	gitConfig, err := gitPath.Config()
+	if err != nil {
+		return nil, "", err
+	}
+	gitConfig, err := repo.Config()
 	if err != nil {
 		return nil, "", err
 	}
 
 	// if no remote
 	if len(gitConfig.Remotes) == 0 {
-		return nil, "", errors.New("No remote repository set on this git repository")
+		return nil, "", errors.New("No remote(s) found in this Git repository")
 	}
 
 	// if only one remote exists
@@ -219,12 +247,12 @@ func curGitRepoPath() (*Login, string, error) {
 
 	remoteConfig, ok := gitConfig.Remotes[remoteValue]
 	if !ok || remoteConfig == nil {
-		return nil, "", errors.New("No remote " + remoteValue + " found on this git repository")
+		return nil, "", errors.New("Remote " + remoteValue + " not found in this Git repository")
 	}
 
 	for _, l := range config.Logins {
 		for _, u := range remoteConfig.URLs {
-			p, err := local_git.ParseURL(strings.TrimSpace(u))
+			p, err := git.ParseURL(strings.TrimSpace(u))
 			if err != nil {
 				return nil, "", fmt.Errorf("Git remote URL parse failed: %s", err.Error())
 			}
@@ -242,5 +270,17 @@ func curGitRepoPath() (*Login, string, error) {
 		}
 	}
 
-	return nil, "", errors.New("No Gitea login found")
+	return nil, "", errors.New("No Gitea login found. You might want to specify --repo (and --login) to work outside of a repository")
+}
+
+func getListOptions(ctx *cli.Context) gitea.ListOptions {
+	page := ctx.Int("page")
+	limit := ctx.Int("limit")
+	if limit != 0 && page == 0 {
+		page = 1
+	}
+	return gitea.ListOptions{
+		Page:     page,
+		PageSize: limit,
+	}
 }

cmd/flags.go

@@ -7,7 +7,9 @@ package cmd
 import (
 	"log"
 
-	"github.com/urfave/cli"
+	"code.gitea.io/tea/modules/utils"
+
+	"github.com/urfave/cli/v2"
 )
 
 // create global variables for global Flags to simplify
@@ -21,39 +23,64 @@ var (
 
 // LoginFlag provides flag to specify tea login profile
 var LoginFlag = cli.StringFlag{
-	Name:        "login, l",
-	Usage:       "Indicate one login, optional when inside a gitea repository",
+	Name:        "login",
+	Aliases:     []string{"l"},
+	Usage:       "Use a different Gitea login. Optional",
 	Destination: &loginValue,
 }
 
 // RepoFlag provides flag to specify repository
 var RepoFlag = cli.StringFlag{
-	Name:        "repo, r",
-	Usage:       "Indicate one repository, optional when inside a gitea repository",
+	Name:        "repo",
+	Aliases:     []string{"r"},
+	Usage:       "Repository to interact with. Optional",
 	Destination: &repoValue,
 }
 
 // RemoteFlag provides flag to specify remote repository
 var RemoteFlag = cli.StringFlag{
-	Name:        "remote, R",
-	Usage:       "Set a specific remote repository, is optional if not set use git default one",
+	Name:        "remote",
+	Aliases:     []string{"R"},
+	Usage:       "Discover Gitea login from remote. Optional",
 	Destination: &remoteValue,
 }
 
 // OutputFlag provides flag to specify output type
 var OutputFlag = cli.StringFlag{
-	Name:        "output, o",
-	Usage:       "Specify output format. (csv, simple, table, tsv, yaml)",
+	Name:        "output",
+	Aliases:     []string{"o"},
+	Usage:       "Output format. (csv, simple, table, tsv, yaml)",
 	Destination: &outputValue,
 }
 
+// StateFlag provides flag to specify issue/pr state, defaulting to "open"
+var StateFlag = cli.StringFlag{
+	Name:        "state",
+	Usage:       "Filter by state (all|open|closed)",
+	DefaultText: "open",
+}
+
+// PaginationPageFlag provides flag for pagination options
+var PaginationPageFlag = cli.StringFlag{
+	Name:    "page",
+	Aliases: []string{"p"},
+	Usage:   "specify page, default is 1",
+}
+
+// PaginationLimitFlag provides flag for pagination options
+var PaginationLimitFlag = cli.StringFlag{
+	Name:    "limit",
+	Aliases: []string{"lm"},
+	Usage:   "specify limit of items per page",
+}
+
 // LoginOutputFlags defines login and output flags that should
 // added to all subcommands and appended to the flags of the
 // subcommand to work around issue and provide --login and --output:
 // https://github.com/urfave/cli/issues/585
 var LoginOutputFlags = []cli.Flag{
-	LoginFlag,
-	OutputFlag,
+	&LoginFlag,
+	&OutputFlag,
 }
 
 // LoginRepoFlags defines login and repo flags that should
@@ -61,8 +88,9 @@ var LoginOutputFlags = []cli.Flag{
 // the subcommand to work around issue and provide --login and --repo:
 // https://github.com/urfave/cli/issues/585
 var LoginRepoFlags = []cli.Flag{
-	LoginFlag,
-	RepoFlag,
+	&LoginFlag,
+	&RepoFlag,
+	&RemoteFlag,
 }
 
 // AllDefaultFlags defines flags that should be available
@@ -70,12 +98,55 @@ var LoginRepoFlags = []cli.Flag{
 // to work around issue and provide --login, --repo and --output:
 // https://github.com/urfave/cli/issues/585
 var AllDefaultFlags = append([]cli.Flag{
-	RepoFlag,
-	RemoteFlag,
+	&RepoFlag,
+	&RemoteFlag,
 }, LoginOutputFlags...)
 
+// IssuePRFlags defines flags that should be available on issue & pr listing flags.
+var IssuePRFlags = append([]cli.Flag{
+	&StateFlag,
+	&PaginationPageFlag,
+	&PaginationLimitFlag,
+}, AllDefaultFlags...)
+
 // initCommand returns repository and *Login based on flags
 func initCommand() (*Login, string, string) {
+	var login *Login
+
+	err := loadConfig(yamlConfigPath)
+	if err != nil {
+		log.Fatal("load config file failed ", yamlConfigPath)
+	}
+
+	if login, err = getDefaultLogin(); err != nil {
+		log.Fatal(err.Error())
+	}
+
+	exist, err := utils.PathExists(repoValue)
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	if exist || len(repoValue) == 0 {
+		login, repoValue, err = curGitRepoPath(repoValue)
+		if err != nil {
+			log.Fatal(err.Error())
+		}
+	}
+
+	if loginValue != "" {
+		login = getLoginByName(loginValue)
+		if login == nil {
+			log.Fatal("Login name " + loginValue + " does not exist")
+		}
+	}
+
+	owner, repo := getOwnerAndRepo(repoValue, login.User)
+	return login, owner, repo
+}
+
+// initCommandLoginOnly return *Login based on flags
+func initCommandLoginOnly() *Login {
 	err := loadConfig(yamlConfigPath)
 	if err != nil {
 		log.Fatal("load config file failed ", yamlConfigPath)
@@ -83,25 +154,16 @@ func initCommand() (*Login, string, string) {
 
 	var login *Login
 	if loginValue == "" {
-		login, err = getActiveLogin()
+		login, err = getDefaultLogin()
 		if err != nil {
 			log.Fatal(err)
 		}
 	} else {
 		login = getLoginByName(loginValue)
 		if login == nil {
-			log.Fatal("indicated login name ", loginValue, " does not exist")
+			log.Fatal("Login name " + loginValue + " does not exist")
 		}
 	}
 
-	repoPath := repoValue
-	if repoPath == "" {
-		login, repoPath, err = curGitRepoPath()
-		if err != nil {
-			log.Fatal(err.Error())
-		}
-	}
-
-	owner, repo := splitRepo(repoPath)
-	return login, owner, repo
+	return login
 }

cmd/issues.go

@@ -7,26 +7,27 @@ package cmd
 import (
 	"fmt"
 	"log"
-	"os"
 	"strconv"
-	"strings"
 
 	"code.gitea.io/sdk/gitea"
-
-	"github.com/urfave/cli"
+	"github.com/charmbracelet/glamour"
+	"github.com/urfave/cli/v2"
 )
 
 // CmdIssues represents to login a gitea server.
 var CmdIssues = cli.Command{
 	Name:        "issues",
-	Usage:       "Operate with issues of the repository",
-	Description: `Operate with issues of the repository`,
+	Usage:       "List, create and update issues",
+	Description: "List, create and update issues",
+	ArgsUsage:   "[<issue index>]",
 	Action:      runIssues,
-	Subcommands: []cli.Command{
-		CmdIssuesList,
-		CmdIssuesCreate,
+	Subcommands: []*cli.Command{
+		&CmdIssuesList,
+		&CmdIssuesCreate,
+		&CmdIssuesReopen,
+		&CmdIssuesClose,
 	},
-	Flags: AllDefaultFlags,
+	Flags: IssuePRFlags,
 }
 
 // CmdIssuesList represents a sub command of issues to list issues
@@ -35,12 +36,12 @@ var CmdIssuesList = cli.Command{
 	Usage:       "List issues of the repository",
 	Description: `List issues of the repository`,
 	Action:      runIssuesList,
-	Flags:       AllDefaultFlags,
+	Flags:       IssuePRFlags,
 }
 
 func runIssues(ctx *cli.Context) error {
-	if len(os.Args) == 3 {
-		return runIssueDetail(ctx, os.Args[2])
+	if ctx.Args().Len() == 1 {
+		return runIssueDetail(ctx, ctx.Args().First())
 	}
 	return runIssuesList(ctx)
 }
@@ -48,35 +49,44 @@ func runIssues(ctx *cli.Context) error {
 func runIssueDetail(ctx *cli.Context, index string) error {
 	login, owner, repo := initCommand()
 
-	if strings.HasPrefix(index, "#") {
-		index = index[1:]
+	idx, err := argToIndex(index)
+	if err != nil {
+		return err
 	}
-
-	idx, err := strconv.ParseInt(index, 10, 64)
+	issue, _, err := login.Client().GetIssue(owner, repo, idx)
 	if err != nil {
 		return err
 	}
 
-	issue, err := login.Client().GetIssue(owner, repo, idx)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("#%d %s\n%s created %s\n\n%s", issue.Index,
+	in := fmt.Sprintf("# #%d %s (%s)\n%s created %s\n\n%s\n", issue.Index,
 		issue.Title,
+		issue.State,
 		issue.Poster.UserName,
 		issue.Created.Format("2006-01-02 15:04:05"),
 		issue.Body,
 	)
+	out, err := glamour.Render(in, getGlamourTheme())
+	fmt.Print(out)
 	return nil
 }
 
 func runIssuesList(ctx *cli.Context) error {
 	login, owner, repo := initCommand()
 
-	issues, err := login.Client().ListRepoIssues(owner, repo, gitea.ListIssueOption{
-		Page:  0,
-		State: string(gitea.StateOpen),
+	state := gitea.StateOpen
+	switch ctx.String("state") {
+	case "all":
+		state = gitea.StateAll
+	case "open":
+		state = gitea.StateOpen
+	case "closed":
+		state = gitea.StateClosed
+	}
+
+	issues, _, err := login.Client().ListRepoIssues(owner, repo, gitea.ListIssueOption{
+		ListOptions: getListOptions(ctx),
+		State:       state,
+		Type:        gitea.IssueTypeIssue,
 	})
 
 	if err != nil {
@@ -85,9 +95,11 @@ func runIssuesList(ctx *cli.Context) error {
 
 	headers := []string{
 		"Index",
-		"Name",
-		"Updated",
 		"Title",
+		"State",
+		"Author",
+		"Milestone",
+		"Updated",
 	}
 
 	var values [][]string
@@ -98,17 +110,23 @@ func runIssuesList(ctx *cli.Context) error {
 	}
 
 	for _, issue := range issues {
-		name := issue.Poster.FullName
-		if len(name) == 0 {
-			name = issue.Poster.UserName
+		author := issue.Poster.FullName
+		if len(author) == 0 {
+			author = issue.Poster.UserName
+		}
+		mile := ""
+		if issue.Milestone != nil {
+			mile = issue.Milestone.Title
 		}
 		values = append(
 			values,
 			[]string{
 				strconv.FormatInt(issue.Index, 10),
-				name,
-				issue.Updated.Format("2006-01-02 15:04:05"),
 				issue.Title,
+				string(issue.State),
+				author,
+				mile,
+				issue.Updated.Format("2006-01-02 15:04:05"),
 			},
 		)
 	}
@@ -124,12 +142,14 @@ var CmdIssuesCreate = cli.Command{
 	Description: `Create an issue on repository`,
 	Action:      runIssuesCreate,
 	Flags: append([]cli.Flag{
-		cli.StringFlag{
-			Name:  "title, t",
+		&cli.StringFlag{
+			Name:    "title",
+			Aliases: []string{"t"},
 			Usage:   "issue title to create",
 		},
-		cli.StringFlag{
-			Name:  "body, b",
+		&cli.StringFlag{
+			Name:    "body",
+			Aliases: []string{"b"},
 			Usage:   "issue body to create",
 		},
 	}, LoginRepoFlags...),
@@ -138,7 +158,7 @@ var CmdIssuesCreate = cli.Command{
 func runIssuesCreate(ctx *cli.Context) error {
 	login, owner, repo := initCommand()
 
-	_, err := login.Client().CreateIssue(owner, repo, gitea.CreateIssueOption{
+	_, _, err := login.Client().CreateIssue(owner, repo, gitea.CreateIssueOption{
 		Title: ctx.String("title"),
 		Body:  ctx.String("body"),
 		// TODO:
@@ -156,3 +176,46 @@ func runIssuesCreate(ctx *cli.Context) error {
 
 	return nil
 }
+
+// CmdIssuesReopen represents a sub command of issues to open an issue
+var CmdIssuesReopen = cli.Command{
+	Name:        "reopen",
+	Aliases:     []string{"open"},
+	Usage:       "Change state of an issue to 'open'",
+	Description: `Change state of an issue to 'open'`,
+	ArgsUsage:   "<issue index>",
+	Action: func(ctx *cli.Context) error {
+		var s = gitea.StateOpen
+		return editIssueState(ctx, gitea.EditIssueOption{State: &s})
+	},
+	Flags: AllDefaultFlags,
+}
+
+// CmdIssuesClose represents a sub command of issues to close an issue
+var CmdIssuesClose = cli.Command{
+	Name:        "close",
+	Usage:       "Change state of an issue to 'closed'",
+	Description: `Change state of an issue to 'closed'`,
+	ArgsUsage:   "<issue index>",
+	Action: func(ctx *cli.Context) error {
+		var s = gitea.StateClosed
+		return editIssueState(ctx, gitea.EditIssueOption{State: &s})
+	},
+	Flags: AllDefaultFlags,
+}
+
+// editIssueState abstracts the arg parsing to edit the given issue
+func editIssueState(ctx *cli.Context, opts gitea.EditIssueOption) error {
+	login, owner, repo := initCommand()
+	if ctx.Args().Len() == 0 {
+		log.Fatal(ctx.Command.ArgsUsage)
+	}
+
+	index, err := argToIndex(ctx.Args().First())
+	if err != nil {
+		return err
+	}
+
+	_, _, err = login.Client().EditIssue(owner, repo, index, opts)
+	return err
+}

cmd/labels.go

@@ -14,25 +14,29 @@ import (
 
 	"code.gitea.io/sdk/gitea"
 
-	"github.com/urfave/cli"
+	"github.com/muesli/termenv"
+	"github.com/urfave/cli/v2"
 )
 
 // CmdLabels represents to operate repositories' labels.
 var CmdLabels = cli.Command{
 	Name:        "labels",
-	Usage:       "Operate with labels of the repository",
-	Description: `Operate with labels of the repository`,
+	Usage:       "Manage issue labels",
+	Description: `Manage issue labels`,
 	Action:      runLabels,
-	Subcommands: []cli.Command{
-		CmdLabelCreate,
-		CmdLabelUpdate,
-		CmdLabelDelete,
+	Subcommands: []*cli.Command{
+		&CmdLabelCreate,
+		&CmdLabelUpdate,
+		&CmdLabelDelete,
 	},
 	Flags: append([]cli.Flag{
-		cli.StringFlag{
-			Name:  "save, s",
+		&cli.StringFlag{
+			Name:    "save",
+			Aliases: []string{"s"},
 			Usage:   "Save all the labels as a file",
 		},
+		&PaginationPageFlag,
+		&PaginationLimitFlag,
 	}, AllDefaultFlags...),
 }
 
@@ -48,7 +52,7 @@ func runLabels(ctx *cli.Context) error {
 
 	var values [][]string
 
-	labels, err := login.Client().ListRepoLabels(owner, repo)
+	labels, _, err := login.Client().ListRepoLabels(owner, repo, gitea.ListLabelsOptions{ListOptions: getListOptions(ctx)})
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -58,6 +62,8 @@ func runLabels(ctx *cli.Context) error {
 		return nil
 	}
 
+	p := termenv.ColorProfile()
+
 	fPath := ctx.String("save")
 	if len(fPath) > 0 {
 		f, err := os.Create(fPath)
@@ -71,11 +77,13 @@ func runLabels(ctx *cli.Context) error {
 		}
 	} else {
 		for _, label := range labels {
+			color := termenv.String(label.Color)
+
 			values = append(
 				values,
 				[]string{
 					strconv.FormatInt(label.ID, 10),
-					label.Color,
+					fmt.Sprint(color.Background(p.Color("#" + label.Color))),
 					label.Name,
 					label.Description,
 				},
@@ -90,23 +98,23 @@ func runLabels(ctx *cli.Context) error {
 // CmdLabelCreate represents a sub command of labels to create label.
 var CmdLabelCreate = cli.Command{
 	Name:        "create",
-	Usage:       "Create a label in repository",
-	Description: `Create a label in repository`,
+	Usage:       "Create a label",
+	Description: `Create a label`,
 	Action:      runLabelCreate,
 	Flags: []cli.Flag{
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "name",
 			Usage: "label name",
 		},
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "color",
 			Usage: "label color value",
 		},
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "description",
 			Usage: "label description",
 		},
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "file",
 			Usage: "indicate a label file",
 		},
@@ -140,7 +148,7 @@ func runLabelCreate(ctx *cli.Context) error {
 	labelFile := ctx.String("file")
 	var err error
 	if len(labelFile) == 0 {
-		_, err = login.Client().CreateLabel(owner, repo, gitea.CreateLabelOption{
+		_, _, err = login.Client().CreateLabel(owner, repo, gitea.CreateLabelOption{
 			Name:        ctx.String("name"),
 			Color:       ctx.String("color"),
 			Description: ctx.String("description"),
@@ -161,7 +169,7 @@ func runLabelCreate(ctx *cli.Context) error {
 			if color == "" || name == "" {
 				log.Printf("Line %d ignored because lack of enough fields: %s\n", i, line)
 			} else {
-				_, err = login.Client().CreateLabel(owner, repo, gitea.CreateLabelOption{
+				_, _, err = login.Client().CreateLabel(owner, repo, gitea.CreateLabelOption{
 					Name:        name,
 					Color:       color,
 					Description: description,
@@ -182,23 +190,23 @@ func runLabelCreate(ctx *cli.Context) error {
 // CmdLabelUpdate represents a sub command of labels to update label.
 var CmdLabelUpdate = cli.Command{
 	Name:        "update",
-	Usage:       "Update a label in repository",
-	Description: `Update a label in repository`,
+	Usage:       "Update a label",
+	Description: `Update a label`,
 	Action:      runLabelUpdate,
 	Flags: []cli.Flag{
-		cli.IntFlag{
+		&cli.IntFlag{
 			Name:  "id",
 			Usage: "label id",
 		},
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "name",
 			Usage: "label name",
 		},
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "color",
 			Usage: "label color value",
 		},
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "description",
 			Usage: "label description",
 		},
@@ -226,7 +234,7 @@ func runLabelUpdate(ctx *cli.Context) error {
 	}
 
 	var err error
-	_, err = login.Client().EditLabel(owner, repo, id, gitea.EditLabelOption{
+	_, _, err = login.Client().EditLabel(owner, repo, id, gitea.EditLabelOption{
 		Name:        pName,
 		Color:       pColor,
 		Description: pDescription,
@@ -242,11 +250,11 @@ func runLabelUpdate(ctx *cli.Context) error {
 // CmdLabelDelete represents a sub command of labels to delete label.
 var CmdLabelDelete = cli.Command{
 	Name:        "delete",
-	Usage:       "Delete a label in repository",
-	Description: `Delete a label in repository`,
-	Action:      runLabelCreate,
+	Usage:       "Delete a label",
+	Description: `Delete a label`,
+	Action:      runLabelDelete,
 	Flags: []cli.Flag{
-		cli.IntFlag{
+		&cli.IntFlag{
 			Name:  "id",
 			Usage: "label id",
 		},
@@ -256,7 +264,7 @@ var CmdLabelDelete = cli.Command{
 func runLabelDelete(ctx *cli.Context) error {
 	login, owner, repo := initCommand()
 
-	err := login.Client().DeleteLabel(owner, repo, ctx.Int64("id"))
+	_, err := login.Client().DeleteLabel(owner, repo, ctx.Int64("id"))
 	if err != nil {
 		log.Fatal(err)
 	}

cmd/log.go

@@ -17,8 +17,6 @@ var (
 	showLog bool
 )
 
-const outputUsage = "Specify output format - table (default), csv, simple, tsv or yaml."
-
 // Println println content according the flag
 func Println(a ...interface{}) {
 	if showLog {

cmd/login.go

@@ -10,95 +10,304 @@ import (
 	"log"
 	"net/http"
 	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"strings"
+	"time"
 
 	"code.gitea.io/sdk/gitea"
 
-	"github.com/urfave/cli"
+	"github.com/skratchdot/open-golang/open"
+	"github.com/urfave/cli/v2"
 )
 
 // CmdLogin represents to login a gitea server.
 var CmdLogin = cli.Command{
 	Name:        "login",
-	Usage:       "Log in a Gitea server",
-	Description: `Log in a Gitea server`,
-	Action:      runLoginList,
-	Subcommands: []cli.Command{
-		cmdLoginList,
-		cmdLoginAdd,
+	Usage:       "Log in to a Gitea server",
+	Description: `Log in to a Gitea server`,
+	Action:      runLoginAddInteractive,
+	Subcommands: []*cli.Command{
+		&cmdLoginList,
+		&cmdLoginAdd,
+		&cmdLoginEdit,
+		&cmdLoginSetDefault,
 	},
 }
 
+// cmdLoginEdit represents to login a gitea server.
+var cmdLoginEdit = cli.Command{
+	Name:        "edit",
+	Usage:       "Edit Gitea logins",
+	Description: `Edit Gitea logins`,
+	Action:      runLoginEdit,
+	Flags:       []cli.Flag{&OutputFlag},
+}
+
+func runLoginEdit(ctx *cli.Context) error {
+	return open.Start(yamlConfigPath)
+}
+
+// cmdLoginSetDefault represents to login a gitea server.
+var cmdLoginSetDefault = cli.Command{
+	Name:        "default",
+	Usage:       "Get or Set Default Login",
+	Description: `Get or Set Default Login`,
+	ArgsUsage:   "<Login>",
+	Action:      runLoginSetDefault,
+	Flags:       []cli.Flag{&OutputFlag},
+}
+
+func runLoginSetDefault(ctx *cli.Context) error {
+	if err := loadConfig(yamlConfigPath); err != nil {
+		return err
+	}
+	if ctx.Args().Len() == 0 {
+		l, err := getDefaultLogin()
+		if err != nil {
+			return err
+		}
+		fmt.Printf("Default Login: %s\n", l.Name)
+		return nil
+	}
+	loginExist := false
+	for i := range config.Logins {
+		config.Logins[i].Default = false
+		if config.Logins[i].Name == ctx.Args().First() {
+			config.Logins[i].Default = true
+			loginExist = true
+		}
+	}
+
+	if !loginExist {
+		return fmt.Errorf("login '%s' not found", ctx.Args().First())
+	}
+
+	return saveConfig(yamlConfigPath)
+}
+
 // CmdLogin represents to login a gitea server.
 var cmdLoginAdd = cli.Command{
 	Name:        "add",
-	Usage:       "Add a Login of a Gitea server",
-	Description: `Add a Login of a Gitea server`,
+	Usage:       "Add a Gitea login",
+	Description: `Add a Gitea login`,
 	Flags: []cli.Flag{
-		cli.StringFlag{
-			Name:  "name, n",
-			Usage: "Name for the gitea login",
+		&cli.StringFlag{
+			Name:    "name",
+			Aliases: []string{"n"},
+			Usage:   "Login name",
 		},
-		cli.StringFlag{
-			Name:   "url, u",
+		&cli.StringFlag{
+			Name:     "url",
+			Aliases:  []string{"u"},
 			Value:    "https://try.gitea.io",
-			EnvVar: "GITEA_SERVER_URL",
-			Usage:  "Gitea server URL",
+			EnvVars:  []string{"GITEA_SERVER_URL"},
+			Usage:    "Server URL",
+			Required: true,
 		},
-		cli.StringFlag{
-			Name:   "token, t",
+		&cli.StringFlag{
+			Name:    "token",
+			Aliases: []string{"t"},
 			Value:   "",
-			EnvVar: "GITEA_SERVER_TOKEN",
-			Usage:  "token for operating the Gitea login",
+			EnvVars: []string{"GITEA_SERVER_TOKEN"},
+			Usage:   "Access token. Can be obtained from Settings > Applications",
 		},
-		cli.BoolFlag{
-			Name:  "insecure, i",
-			Usage: "insecure visit gitea server",
+		&cli.StringFlag{
+			Name:    "user",
+			Value:   "",
+			EnvVars: []string{"GITEA_SERVER_USER"},
+			Usage:   "User for basic auth (will create token)",
+		},
+		&cli.StringFlag{
+			Name:    "password",
+			Aliases: []string{"pwd"},
+			Value:   "",
+			EnvVars: []string{"GITEA_SERVER_PASSWORD"},
+			Usage:   "Password for basic auth (will create token)",
+		},
+		&cli.StringFlag{
+			Name:    "ssh-key",
+			Aliases: []string{"s"},
+			Usage:   "Path to a SSH key to use for pull/push operations",
+		},
+		&cli.BoolFlag{
+			Name:    "insecure",
+			Aliases: []string{"i"},
+			Usage:   "Disable TLS verification",
 		},
 	},
 	Action: runLoginAdd,
 }
 
 func runLoginAdd(ctx *cli.Context) error {
-	if !ctx.IsSet("url") {
+	return runLoginAddMain(
+		ctx.String("name"),
+		ctx.String("token"),
+		ctx.String("user"),
+		ctx.String("password"),
+		ctx.String("ssh-key"),
+		ctx.String("url"),
+		ctx.Bool("insecure"))
+}
+
+func runLoginAddInteractive(ctx *cli.Context) error {
+	var stdin, name, token, user, passwd, sshKey, giteaURL string
+	var insecure = false
+
+	fmt.Print("URL of Gitea instance: ")
+	if _, err := fmt.Scanln(&stdin); err != nil {
+		stdin = ""
+	}
+	giteaURL = strings.TrimSpace(stdin)
+	if len(giteaURL) == 0 {
+		fmt.Println("URL is required!")
+		return nil
+	}
+
+	parsedURL, err := url.Parse(giteaURL)
+	if err != nil {
+		return err
+	}
+	name = strings.ReplaceAll(strings.Title(parsedURL.Host), ".", "")
+
+	fmt.Print("Name of new Login [" + name + "]: ")
+	if _, err := fmt.Scanln(&stdin); err != nil {
+		stdin = ""
+	}
+	if len(strings.TrimSpace(stdin)) != 0 {
+		name = strings.TrimSpace(stdin)
+	}
+
+	fmt.Print("Do you have a token [Yes/no]: ")
+	if _, err := fmt.Scanln(&stdin); err != nil {
+		stdin = ""
+	}
+	if len(stdin) != 0 && strings.ToLower(stdin[:1]) == "n" {
+		fmt.Print("Username: ")
+		if _, err := fmt.Scanln(&stdin); err != nil {
+			stdin = ""
+		}
+		user = strings.TrimSpace(stdin)
+
+		fmt.Print("Password: ")
+		if _, err := fmt.Scanln(&stdin); err != nil {
+			stdin = ""
+		}
+		passwd = strings.TrimSpace(stdin)
+	} else {
+		fmt.Print("Token: ")
+		if _, err := fmt.Scanln(&stdin); err != nil {
+			stdin = ""
+		}
+		token = strings.TrimSpace(stdin)
+	}
+
+	fmt.Print("Set Optional settings [yes/No]: ")
+	if _, err := fmt.Scanln(&stdin); err != nil {
+		stdin = ""
+	}
+	if len(stdin) != 0 && strings.ToLower(stdin[:1]) == "y" {
+		fmt.Print("SSH Key Path: ")
+		if _, err := fmt.Scanln(&stdin); err != nil {
+			stdin = ""
+		}
+		sshKey = strings.TrimSpace(stdin)
+
+		fmt.Print("Allow Insecure connections  [yes/No]: ")
+		if _, err := fmt.Scanln(&stdin); err != nil {
+			stdin = ""
+		}
+		insecure = len(stdin) != 0 && strings.ToLower(stdin[:1]) == "y"
+	}
+
+	return runLoginAddMain(name, token, user, passwd, sshKey, giteaURL, insecure)
+}
+
+func runLoginAddMain(name, token, user, passwd, sshKey, giteaURL string, insecure bool) error {
+
+	if len(giteaURL) == 0 {
 		log.Fatal("You have to input Gitea server URL")
 	}
-
-	if !ctx.IsSet("token") {
-		log.Fatal("No token found")
-	}
-
-	if !ctx.IsSet("name") {
-		log.Fatal("You have to set a name for the login")
+	if len(token) == 0 && (len(user)+len(passwd)) == 0 {
+		log.Fatal("No token set")
+	} else if len(user) != 0 && len(passwd) == 0 {
+		log.Fatal("No password set")
+	} else if len(user) == 0 && len(passwd) != 0 {
+		log.Fatal("No user set")
 	}
 
 	err := loadConfig(yamlConfigPath)
 	if err != nil {
-		log.Fatal("load config file failed", yamlConfigPath)
+		log.Fatal("Unable to load config file " + yamlConfigPath)
 	}
 
-	client := gitea.NewClient(ctx.String("url"), ctx.String("token"))
-	if ctx.Bool("insecure") {
+	httpClient := &http.Client{}
+	if insecure {
 		cookieJar, _ := cookiejar.New(nil)
-
-		client.SetHTTPClient(&http.Client{
+		httpClient = &http.Client{
 			Jar: cookieJar,
 			Transport: &http.Transport{
 				TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-			},
-		})
+			}}
 	}
-	u, err := client.GetMyUserInfo()
+	client, err := gitea.NewClient(giteaURL,
+		gitea.SetToken(token),
+		gitea.SetBasicAuth(user, passwd),
+		gitea.SetHTTPClient(httpClient),
+	)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	fmt.Println("Login successful! Login name", u.UserName)
+	u, _, err := client.GetMyUserInfo()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if len(token) == 0 {
+		// create token
+		host, _ := os.Hostname()
+		tl, _, err := client.ListAccessTokens(gitea.ListAccessTokensOptions{})
+		if err != nil {
+			return err
+		}
+		tokenName := host + "-tea"
+		for i := range tl {
+			if tl[i].Name == tokenName {
+				tokenName += time.Now().Format("2006-01-02_15-04-05")
+				break
+			}
+		}
+		t, _, err := client.CreateAccessToken(gitea.CreateAccessTokenOption{Name: tokenName})
+		if err != nil {
+			return err
+		}
+		token = t.Token
+	}
+
+	fmt.Println("Login successful! Login name " + u.UserName)
+
+	if len(name) == 0 {
+		parsedURL, err := url.Parse(giteaURL)
+		if err != nil {
+			return err
+		}
+		name = strings.ReplaceAll(strings.Title(parsedURL.Host), ".", "")
+		for _, l := range config.Logins {
+			if l.Name == name {
+				name += "_" + u.UserName
+				break
+			}
+		}
+	}
 
 	err = addLogin(Login{
-		Name:     ctx.String("name"),
-		URL:      ctx.String("url"),
-		Token:    ctx.String("token"),
-		Insecure: ctx.Bool("insecure"),
+		Name:     name,
+		URL:      giteaURL,
+		Token:    token,
+		Insecure: insecure,
+		SSHKey:   sshKey,
+		User:     u.UserName,
 	})
 	if err != nil {
 		log.Fatal(err)
@@ -115,21 +324,39 @@ func runLoginAdd(ctx *cli.Context) error {
 // CmdLogin represents to login a gitea server.
 var cmdLoginList = cli.Command{
 	Name:        "ls",
-	Usage:       "List all Logins of Gitea servers",
-	Description: `List all Logins of Gitea servers`,
+	Usage:       "List Gitea logins",
+	Description: `List Gitea logins`,
 	Action:      runLoginList,
+	Flags:       []cli.Flag{&OutputFlag},
 }
 
 func runLoginList(ctx *cli.Context) error {
 	err := loadConfig(yamlConfigPath)
 	if err != nil {
-		log.Fatal("load config file failed", yamlConfigPath)
+		log.Fatal("Unable to load config file " + yamlConfigPath)
 	}
 
-	fmt.Printf("Name\tURL\tSSHHost\n")
-	for _, l := range config.Logins {
-		fmt.Printf("%s\t%s\t%s\n", l.Name, l.URL, l.GetSSHHost())
+	headers := []string{
+		"Name",
+		"URL",
+		"SSHHost",
+		"User",
+		"Default",
 	}
 
+	var values [][]string
+
+	for _, l := range config.Logins {
+		values = append(values, []string{
+			l.Name,
+			l.URL,
+			l.GetSSHHost(),
+			l.User,
+			fmt.Sprint(l.Default),
+		})
+	}
+
+	Output(outputValue, headers, values)
+
 	return nil
 }

cmd/logout.go

@@ -9,7 +9,7 @@ import (
 	"log"
 	"os"
 
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // CmdLogout represents to logout a gitea server.
@@ -19,9 +19,10 @@ var CmdLogout = cli.Command{
 	Description: `Log out from a Gitea server`,
 	Action:      runLogout,
 	Flags: []cli.Flag{
-		cli.StringFlag{
-			Name:  "name, n",
-			Usage: "name wants to log out",
+		&cli.StringFlag{
+			Name:    "name",
+			Aliases: []string{"n"},
+			Usage:   "Login name to remove",
 		},
 	},
 }
@@ -33,12 +34,12 @@ func runLogout(ctx *cli.Context) error {
 	} else if ctx.IsSet("name") {
 		name = ctx.String("name")
 	} else {
-		return errors.New("need log out server name")
+		return errors.New("Please specify a login name")
 	}
 
 	err := loadConfig(yamlConfigPath)
 	if err != nil {
-		log.Fatal("load config file failed", yamlConfigPath)
+		log.Fatal("Unable to load config file " + yamlConfigPath)
 	}
 
 	var idx = -1
@@ -52,7 +53,7 @@ func runLogout(ctx *cli.Context) error {
 		config.Logins = append(config.Logins[:idx], config.Logins[idx+1:]...)
 		err = saveConfig(yamlConfigPath)
 		if err != nil {
-			log.Fatal("save config file failed", yamlConfigPath)
+			log.Fatal("Unable to save config file " + yamlConfigPath)
 		}
 	}
 

cmd/milestone_issues.go

@@ -0,0 +1,202 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"strconv"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v2"
+)
+
+// CmdMilestonesIssues represents a sub command of milestones to manage issue/pull of an milestone
+var CmdMilestonesIssues = cli.Command{
+	Name:        "issues",
+	Aliases:     []string{"i"},
+	Usage:       "manage issue/pull of an milestone",
+	Description: "manage issue/pull of an milestone",
+	ArgsUsage:   "<milestone name>",
+	Action:      runMilestoneIssueList,
+	Subcommands: []*cli.Command{
+		&CmdMilestoneAddIssue,
+		&CmdMilestoneRemoveIssue,
+	},
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:        "state",
+			Usage:       "Filter by issue state (all|open|closed)",
+			DefaultText: "open",
+		},
+		&cli.StringFlag{
+			Name:  "kind",
+			Usage: "Filter by kind (issue|pull)",
+		},
+		&PaginationPageFlag,
+		&PaginationLimitFlag,
+	}, AllDefaultFlags...),
+}
+
+// CmdMilestoneAddIssue represents a sub command of milestone issues to add an issue/pull to an milestone
+var CmdMilestoneAddIssue = cli.Command{
+	Name:        "add",
+	Aliases:     []string{"a"},
+	Usage:       "Add an issue/pull to an milestone",
+	Description: "Add an issue/pull to an milestone",
+	ArgsUsage:   "<milestone name> <issue/pull index>",
+	Action:      runMilestoneIssueAdd,
+	Flags:       AllDefaultFlags,
+}
+
+// CmdMilestoneRemoveIssue represents a sub command of milestones to remove an issue/pull from an milestone
+var CmdMilestoneRemoveIssue = cli.Command{
+	Name:        "remove",
+	Aliases:     []string{"r"},
+	Usage:       "Remove an issue/pull to an milestone",
+	Description: "Remove an issue/pull to an milestone",
+	ArgsUsage:   "<milestone name> <issue/pull index>",
+	Action:      runMilestoneIssueRemove,
+	Flags:       AllDefaultFlags,
+}
+
+func runMilestoneIssueList(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	state := gitea.StateOpen
+	switch ctx.String("state") {
+	case "all":
+		state = gitea.StateAll
+	case "closed":
+		state = gitea.StateClosed
+	}
+
+	kind := gitea.IssueTypeAll
+	switch ctx.String("kind") {
+	case "issue":
+		kind = gitea.IssueTypeIssue
+	case "pull":
+		kind = gitea.IssueTypePull
+	}
+
+	fmt.Println(state)
+
+	milestone := ctx.Args().First()
+	// make sure milestone exist
+	_, _, err := client.GetMilestoneByName(owner, repo, milestone)
+	if err != nil {
+		return err
+	}
+
+	issues, _, err := client.ListRepoIssues(owner, repo, gitea.ListIssueOption{
+		ListOptions: getListOptions(ctx),
+		Milestones:  []string{milestone},
+		Type:        kind,
+		State:       state,
+	})
+	if err != nil {
+		return err
+	}
+
+	headers := []string{
+		"Index",
+		"State",
+		"Kind",
+		"Author",
+		"Updated",
+		"Title",
+	}
+
+	var values [][]string
+
+	if len(issues) == 0 {
+		Output(outputValue, headers, values)
+		return nil
+	}
+
+	for _, issue := range issues {
+		name := issue.Poster.FullName
+		if len(name) == 0 {
+			name = issue.Poster.UserName
+		}
+		kind := "Issue"
+		if issue.PullRequest != nil {
+			kind = "Pull"
+		}
+		values = append(
+			values,
+			[]string{
+				strconv.FormatInt(issue.Index, 10),
+				string(issue.State),
+				kind,
+				name,
+				issue.Updated.Format("2006-01-02 15:04:05"),
+				issue.Title,
+			},
+		)
+	}
+	Output(outputValue, headers, values)
+	return nil
+}
+
+func runMilestoneIssueAdd(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+	if ctx.Args().Len() == 0 {
+		return fmt.Errorf("need two arguments")
+	}
+
+	mileName := ctx.Args().Get(0)
+	issueIndex := ctx.Args().Get(1)
+	idx, err := argToIndex(issueIndex)
+	if err != nil {
+		return err
+	}
+
+	// make sure milestone exist
+	mile, _, err := client.GetMilestoneByName(owner, repo, mileName)
+	if err != nil {
+		return err
+	}
+
+	_, _, err = client.EditIssue(owner, repo, idx, gitea.EditIssueOption{
+		Milestone: &mile.ID,
+	})
+	return err
+}
+
+func runMilestoneIssueRemove(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+	if ctx.Args().Len() == 0 {
+		return fmt.Errorf("need two arguments")
+	}
+
+	mileName := ctx.Args().Get(0)
+	issueIndex := ctx.Args().Get(1)
+	idx, err := argToIndex(issueIndex)
+	if err != nil {
+		return err
+	}
+
+	issue, _, err := client.GetIssue(owner, repo, idx)
+	if err != nil {
+		return err
+	}
+
+	if issue.Milestone == nil {
+		return fmt.Errorf("issue is not assigned to a milestone")
+	}
+
+	if issue.Milestone.Title != mileName {
+		return fmt.Errorf("issue is not assigned to this milestone")
+	}
+
+	zero := int64(0)
+	_, _, err = client.EditIssue(owner, repo, idx, gitea.EditIssueOption{
+		Milestone: &zero,
+	})
+	return err
+}

cmd/milestones.go

@@ -0,0 +1,255 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"log"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v2"
+)
+
+// CmdMilestones represents to operate repositories milestones.
+var CmdMilestones = cli.Command{
+	Name:        "milestones",
+	Aliases:     []string{"ms", "mile"},
+	Usage:       "List and create milestones",
+	Description: `List and create milestones`,
+	ArgsUsage:   "[<milestone name>]",
+	Action:      runMilestones,
+	Subcommands: []*cli.Command{
+		&CmdMilestonesList,
+		&CmdMilestonesCreate,
+		&CmdMilestonesClose,
+		&CmdMilestonesDelete,
+		&CmdMilestonesReopen,
+		&CmdMilestonesIssues,
+	},
+	Flags: AllDefaultFlags,
+}
+
+// CmdMilestonesList represents a sub command of milestones to list milestones
+var CmdMilestonesList = cli.Command{
+	Name:        "ls",
+	Usage:       "List milestones of the repository",
+	Description: `List milestones of the repository`,
+	Action:      runMilestonesList,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:        "state",
+			Usage:       "Filter by milestone state (all|open|closed)",
+			DefaultText: "open",
+		},
+		&PaginationPageFlag,
+		&PaginationLimitFlag,
+	}, AllDefaultFlags...),
+}
+
+func runMilestones(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runMilestoneDetail(ctx, ctx.Args().First())
+	}
+	return runMilestonesList(ctx)
+}
+
+func runMilestoneDetail(ctx *cli.Context, name string) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	milestone, _, err := client.GetMilestoneByName(owner, repo, name)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("%s\n",
+		milestone.Title,
+	)
+	if len(milestone.Description) != 0 {
+		fmt.Printf("\n%s\n", milestone.Description)
+	}
+	if milestone.Deadline != nil && !milestone.Deadline.IsZero() {
+		fmt.Printf("\nDeadline: %s\n", milestone.Deadline.Format("2006-01-02 15:04:05"))
+	}
+	return nil
+}
+
+func runMilestonesList(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+
+	state := gitea.StateOpen
+	switch ctx.String("state") {
+	case "all":
+		state = gitea.StateAll
+	case "closed":
+		state = gitea.StateClosed
+	}
+
+	milestones, _, err := login.Client().ListRepoMilestones(owner, repo, gitea.ListMilestoneOption{
+		ListOptions: getListOptions(ctx),
+		State:       state,
+	})
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	headers := []string{
+		"Title",
+	}
+	if state == gitea.StateAll {
+		headers = append(headers, "State")
+	}
+	headers = append(headers,
+		"Open/Closed Issues",
+		"DueDate",
+	)
+
+	var values [][]string
+
+	for _, m := range milestones {
+		var deadline = ""
+
+		if m.Deadline != nil && !m.Deadline.IsZero() {
+			deadline = m.Deadline.Format("2006-01-02 15:04:05")
+		}
+
+		item := []string{
+			m.Title,
+		}
+		if state == gitea.StateAll {
+			item = append(item, string(m.State))
+		}
+		item = append(item,
+			fmt.Sprintf("%d/%d", m.OpenIssues, m.ClosedIssues),
+			deadline,
+		)
+
+		values = append(values, item)
+	}
+	Output(outputValue, headers, values)
+
+	return nil
+}
+
+// CmdMilestonesCreate represents a sub command of milestones to create milestone
+var CmdMilestonesCreate = cli.Command{
+	Name:        "create",
+	Usage:       "Create an milestone on repository",
+	Description: `Create an milestone on repository`,
+	Action:      runMilestonesCreate,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:    "title",
+			Aliases: []string{"t"},
+			Usage:   "milestone title to create",
+		},
+		&cli.StringFlag{
+			Name:    "description",
+			Aliases: []string{"d"},
+			Usage:   "milestone description to create",
+		},
+		&cli.StringFlag{
+			Name:        "state",
+			Usage:       "set milestone state (default is open)",
+			DefaultText: "open",
+		},
+	}, AllDefaultFlags...),
+}
+
+func runMilestonesCreate(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+
+	title := ctx.String("title")
+	if len(title) == 0 {
+		fmt.Printf("Title is required\n")
+		return nil
+	}
+
+	state := gitea.StateOpen
+	if ctx.String("state") == "closed" {
+		state = gitea.StateClosed
+	}
+
+	mile, _, err := login.Client().CreateMilestone(owner, repo, gitea.CreateMilestoneOption{
+		Title:       title,
+		Description: ctx.String("description"),
+		State:       state,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return runMilestoneDetail(ctx, mile.Title)
+}
+
+// CmdMilestonesClose represents a sub command of milestones to close an milestone
+var CmdMilestonesClose = cli.Command{
+	Name:        "close",
+	Usage:       "Change state of an milestone to 'closed'",
+	Description: `Change state of an milestone to 'closed'`,
+	ArgsUsage:   "<milestone name>",
+	Action: func(ctx *cli.Context) error {
+		if ctx.Bool("force") {
+			return deleteMilestone(ctx)
+		}
+		return editMilestoneStatus(ctx, true)
+	},
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:    "force",
+			Aliases: []string{"f"},
+			Usage:   "delete milestone",
+		},
+	}, AllDefaultFlags...),
+}
+
+func editMilestoneStatus(ctx *cli.Context, close bool) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	state := gitea.StateOpen
+	if close {
+		state = gitea.StateClosed
+	}
+	_, _, err := client.EditMilestoneByName(owner, repo, ctx.Args().First(), gitea.EditMilestoneOption{
+		State: &state,
+		Title: ctx.Args().First(),
+	})
+
+	return err
+}
+
+// CmdMilestonesDelete represents a sub command of milestones to delete an milestone
+var CmdMilestonesDelete = cli.Command{
+	Name:        "delete",
+	Aliases:     []string{"rm"},
+	Usage:       "delete a milestone",
+	Description: "delete a milestone",
+	ArgsUsage:   "<milestone name>",
+	Action:      deleteMilestone,
+	Flags:       AllDefaultFlags,
+}
+
+func deleteMilestone(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	_, err := client.DeleteMilestoneByName(owner, repo, ctx.Args().First())
+	return err
+}
+
+// CmdMilestonesReopen represents a sub command of milestones to open an milestone
+var CmdMilestonesReopen = cli.Command{
+	Name:        "reopen",
+	Aliases:     []string{"open"},
+	Usage:       "Change state of an milestone to 'open'",
+	Description: `Change state of an milestone to 'open'`,
+	ArgsUsage:   "<milestone name>",
+	Action: func(ctx *cli.Context) error {
+		return editMilestoneStatus(ctx, false)
+	},
+	Flags: AllDefaultFlags,
+}

cmd/notifications.go

@@ -0,0 +1,113 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"log"
+	"strings"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v2"
+)
+
+// CmdNotifications is the main command to operate with notifications
+var CmdNotifications = cli.Command{
+	Name:        "notifications",
+	Usage:       "Show notifications",
+	Description: "Show notifications, by default based of the current repo and unread one",
+	Action:      runNotifications,
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:    "all",
+			Aliases: []string{"a"},
+			Usage:   "show all notifications of related gitea instance",
+		},
+		&cli.BoolFlag{
+			Name:    "read",
+			Aliases: []string{"rd"},
+			Usage:   "show read notifications instead unread",
+		},
+		&cli.BoolFlag{
+			Name:    "pinned",
+			Aliases: []string{"pd"},
+			Usage:   "show pinned notifications instead unread",
+		},
+		&PaginationPageFlag,
+		&PaginationLimitFlag,
+	}, AllDefaultFlags...),
+}
+
+func runNotifications(ctx *cli.Context) error {
+	var news []*gitea.NotificationThread
+	var err error
+
+	listOpts := getListOptions(ctx)
+	if listOpts.Page == 0 {
+		listOpts.Page = 1
+	}
+
+	var status []gitea.NotifyStatus
+	if ctx.Bool("read") {
+		status = []gitea.NotifyStatus{gitea.NotifyStatusRead}
+	}
+	if ctx.Bool("pinned") {
+		status = append(status, gitea.NotifyStatusPinned)
+	}
+
+	if ctx.Bool("all") {
+		login := initCommandLoginOnly()
+		news, _, err = login.Client().ListNotifications(gitea.ListNotificationOptions{
+			ListOptions: listOpts,
+			Status:      status,
+		})
+	} else {
+		login, owner, repo := initCommand()
+		news, _, err = login.Client().ListRepoNotifications(owner, repo, gitea.ListNotificationOptions{
+			ListOptions: listOpts,
+			Status:      status,
+		})
+	}
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	headers := []string{
+		"Type",
+		"Index",
+		"Title",
+	}
+	if ctx.Bool("all") {
+		headers = append(headers, "Repository")
+	}
+
+	var values [][]string
+
+	for _, n := range news {
+		if n.Subject == nil {
+			continue
+		}
+		// if pull or Issue get Index
+		var index string
+		if n.Subject.Type == "Issue" || n.Subject.Type == "Pull" {
+			index = n.Subject.URL
+			urlParts := strings.Split(n.Subject.URL, "/")
+			if len(urlParts) != 0 {
+				index = urlParts[len(urlParts)-1]
+			}
+			index = "#" + index
+		}
+
+		item := []string{n.Subject.Type, index, n.Subject.Title}
+		if ctx.Bool("all") {
+			item = append(item, n.Repository.FullName)
+		}
+		values = append(values, item)
+	}
+
+	if len(values) != 0 {
+		Output(outputValue, headers, values)
+	}
+	return nil
+}

cmd/open.go

@@ -0,0 +1,81 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"log"
+	"path"
+	"strings"
+
+	local_git "code.gitea.io/tea/modules/git"
+
+	"github.com/skratchdot/open-golang/open"
+	"github.com/urfave/cli/v2"
+)
+
+// CmdOpen represents a sub command of issues to open issue on the web browser
+var CmdOpen = cli.Command{
+	Name:        "open",
+	Usage:       "Open something of the repository on web browser",
+	Description: `Open something of the repository on web browser`,
+	Action:      runOpen,
+	Flags:       append([]cli.Flag{}, LoginRepoFlags...),
+}
+
+func runOpen(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+
+	var suffix string
+	number := ctx.Args().Get(0)
+	switch {
+	case strings.EqualFold(number, "issues"):
+		suffix = "issues"
+	case strings.EqualFold(number, "pulls"):
+		suffix = "pulls"
+	case strings.EqualFold(number, "releases"):
+		suffix = "releases"
+	case strings.EqualFold(number, "commits"):
+		repo, err := local_git.RepoForWorkdir()
+		if err != nil {
+			log.Fatal(err)
+		}
+		b, err := repo.Head()
+		if err != nil {
+			log.Fatal(err)
+			return nil
+		}
+		name := b.Name()
+		switch {
+		case name.IsBranch():
+			suffix = "commits/branch/" + name.Short()
+		case name.IsTag():
+			suffix = "commits/tag/" + name.Short()
+		}
+	case strings.EqualFold(number, "branches"):
+		suffix = "branches"
+	case strings.EqualFold(number, "wiki"):
+		suffix = "wiki"
+	case strings.EqualFold(number, "activity"):
+		suffix = "activity"
+	case strings.EqualFold(number, "settings"):
+		suffix = "settings"
+	case strings.EqualFold(number, "labels"):
+		suffix = "labels"
+	case strings.EqualFold(number, "milestones"):
+		suffix = "milestones"
+	case number != "":
+		suffix = "issues/" + number
+	default:
+		suffix = number
+	}
+
+	u := path.Join(login.URL, owner, repo, suffix)
+	err := open.Run(u)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return nil
+}

cmd/pulls.go

@@ -5,29 +5,90 @@
 package cmd
 
 import (
+	"fmt"
 	"log"
 	"strconv"
+	"strings"
+
+	local_git "code.gitea.io/tea/modules/git"
 
 	"code.gitea.io/sdk/gitea"
-
-	"github.com/urfave/cli"
+	"github.com/charmbracelet/glamour"
+	"github.com/go-git/go-git/v5"
+	git_config "github.com/go-git/go-git/v5/config"
+	"github.com/urfave/cli/v2"
 )
 
-// CmdPulls represents to login a gitea server.
+// CmdPulls is the main command to operate on PRs
 var CmdPulls = cli.Command{
 	Name:        "pulls",
-	Usage:       "Operate with pulls of the repository",
-	Description: `Operate with pulls of the repository`,
+	Aliases:     []string{"pull", "pr"},
+	Usage:       "List, create, checkout and clean pull requests",
+	Description: `List, create, checkout and clean pull requests`,
+	ArgsUsage:   "[<pull index>]",
 	Action:      runPulls,
-	Flags:       AllDefaultFlags,
+	Flags:       IssuePRFlags,
+	Subcommands: []*cli.Command{
+		&CmdPullsList,
+		&CmdPullsCheckout,
+		&CmdPullsClean,
+		&CmdPullsCreate,
+	},
 }
 
 func runPulls(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runPullDetail(ctx, ctx.Args().First())
+	}
+	return runPullsList(ctx)
+}
+
+// CmdPullsList represents a sub command of issues to list pulls
+var CmdPullsList = cli.Command{
+	Name:        "ls",
+	Usage:       "List pull requests of the repository",
+	Description: `List pull requests of the repository`,
+	Action:      runPullsList,
+	Flags:       IssuePRFlags,
+}
+
+func runPullDetail(ctx *cli.Context, index string) error {
 	login, owner, repo := initCommand()
 
-	prs, err := login.Client().ListRepoPullRequests(owner, repo, gitea.ListPullRequestsOptions{
-		Page:  0,
-		State: string(gitea.StateOpen),
+	idx, err := argToIndex(index)
+	if err != nil {
+		return err
+	}
+	pr, _, err := login.Client().GetPullRequest(owner, repo, idx)
+	if err != nil {
+		return err
+	}
+
+	// TODO: use glamour once #181 is merged
+	fmt.Printf("#%d %s\n%s created %s\n\n%s\n", pr.Index,
+		pr.Title,
+		pr.Poster.UserName,
+		pr.Created.Format("2006-01-02 15:04:05"),
+		pr.Body,
+	)
+	return nil
+}
+
+func runPullsList(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+
+	state := gitea.StateOpen
+	switch ctx.String("state") {
+	case "all":
+		state = gitea.StateAll
+	case "open":
+		state = gitea.StateOpen
+	case "closed":
+		state = gitea.StateClosed
+	}
+
+	prs, _, err := login.Client().ListRepoPullRequests(owner, repo, gitea.ListPullRequestsOptions{
+		State: state,
 	})
 
 	if err != nil {
@@ -36,9 +97,11 @@ func runPulls(ctx *cli.Context) error {
 
 	headers := []string{
 		"Index",
-		"Name",
-		"Updated",
 		"Title",
+		"State",
+		"Author",
+		"Milestone",
+		"Updated",
 	}
 
 	var values [][]string
@@ -52,17 +115,23 @@ func runPulls(ctx *cli.Context) error {
 		if pr == nil {
 			continue
 		}
-		name := pr.Poster.FullName
-		if len(name) == 0 {
-			name = pr.Poster.UserName
+		author := pr.Poster.FullName
+		if len(author) == 0 {
+			author = pr.Poster.UserName
+		}
+		mile := ""
+		if pr.Milestone != nil {
+			mile = pr.Milestone.Title
 		}
 		values = append(
 			values,
 			[]string{
 				strconv.FormatInt(pr.Index, 10),
-				name,
-				pr.Updated.Format("2006-01-02 15:04:05"),
 				pr.Title,
+				string(pr.State),
+				author,
+				mile,
+				pr.Updated.Format("2006-01-02 15:04:05"),
 			},
 		)
 	}
@@ -70,3 +139,309 @@ func runPulls(ctx *cli.Context) error {
 
 	return nil
 }
+
+// CmdPullsCheckout is a command to locally checkout the given PR
+var CmdPullsCheckout = cli.Command{
+	Name:        "checkout",
+	Usage:       "Locally check out the given PR",
+	Description: `Locally check out the given PR`,
+	Action:      runPullsCheckout,
+	ArgsUsage:   "<pull index>",
+	Flags:       AllDefaultFlags,
+}
+
+func runPullsCheckout(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	if ctx.Args().Len() != 1 {
+		log.Fatal("Must specify a PR index")
+	}
+
+	// fetch PR source-repo & -branch from gitea
+	idx, err := argToIndex(ctx.Args().First())
+	if err != nil {
+		return err
+	}
+	pr, _, err := login.Client().GetPullRequest(owner, repo, idx)
+	if err != nil {
+		return err
+	}
+	remoteURL := pr.Head.Repository.CloneURL
+	remoteBranchName := pr.Head.Ref
+
+	// open local git repo
+	localRepo, err := local_git.RepoForWorkdir()
+	if err != nil {
+		return nil
+	}
+
+	// verify related remote is in local repo, otherwise add it
+	newRemoteName := fmt.Sprintf("pulls/%v", pr.Head.Repository.Owner.UserName)
+	localRemote, err := localRepo.GetOrCreateRemote(remoteURL, newRemoteName)
+	if err != nil {
+		return err
+	}
+
+	localRemoteName := localRemote.Config().Name
+	localBranchName := fmt.Sprintf("pulls/%v-%v", idx, remoteBranchName)
+
+	// fetch remote
+	fmt.Printf("Fetching PR %v (head %s:%s) from remote '%s'\n",
+		idx, remoteURL, remoteBranchName, localRemoteName)
+
+	url, err := local_git.ParseURL(localRemote.Config().URLs[0])
+	if err != nil {
+		return err
+	}
+	auth, err := local_git.GetAuthForURL(url, login.User, login.SSHKey)
+	if err != nil {
+		return err
+	}
+
+	err = localRemote.Fetch(&git.FetchOptions{Auth: auth})
+	if err == git.NoErrAlreadyUpToDate {
+		fmt.Println(err)
+	} else if err != nil {
+		return err
+	}
+
+	// checkout local branch
+	fmt.Printf("Creating branch '%s'\n", localBranchName)
+	err = localRepo.TeaCreateBranch(localBranchName, remoteBranchName, localRemoteName)
+	if err == git.ErrBranchExists {
+		fmt.Println(err)
+	} else if err != nil {
+		return err
+	}
+
+	fmt.Printf("Checking out PR %v\n", idx)
+	err = localRepo.TeaCheckout(localBranchName)
+
+	return err
+}
+
+// CmdPullsClean removes the remote and local feature branches, if a PR is merged.
+var CmdPullsClean = cli.Command{
+	Name:        "clean",
+	Usage:       "Deletes local & remote feature-branches for a closed pull request",
+	Description: `Deletes local & remote feature-branches for a closed pull request`,
+	ArgsUsage:   "<pull index>",
+	Action:      runPullsClean,
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:  "ignore-sha",
+			Usage: "Find the local branch by name instead of commit hash (less precise)",
+		},
+	}, AllDefaultFlags...),
+}
+
+func runPullsClean(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	if ctx.Args().Len() != 1 {
+		return fmt.Errorf("Must specify a PR index")
+	}
+
+	// fetch PR source-repo & -branch from gitea
+	idx, err := argToIndex(ctx.Args().First())
+	if err != nil {
+		return err
+	}
+	pr, _, err := login.Client().GetPullRequest(owner, repo, idx)
+	if err != nil {
+		return err
+	}
+	if pr.State == gitea.StateOpen {
+		return fmt.Errorf("PR is still open, won't delete branches")
+	}
+
+	// IDEA: abort if PR.Head.Repository.CloneURL does not match login.URL?
+
+	r, err := local_git.RepoForWorkdir()
+	if err != nil {
+		return err
+	}
+
+	// find a branch with matching sha or name, that has a remote matching the repo url
+	var branch *git_config.Branch
+	if ctx.Bool("ignore-sha") {
+		branch, err = r.TeaFindBranchByName(pr.Head.Ref, pr.Head.Repository.CloneURL)
+	} else {
+		branch, err = r.TeaFindBranchBySha(pr.Head.Sha, pr.Head.Repository.CloneURL)
+	}
+	if err != nil {
+		return err
+	}
+	if branch == nil {
+		if ctx.Bool("ignore-sha") {
+			return fmt.Errorf("Remote branch %s not found in local repo", pr.Head.Ref)
+		}
+		return fmt.Errorf(`Remote branch %s not found in local repo.
+Either you don't track this PR, or the local branch has diverged from the remote.
+If you still want to continue & are sure you don't loose any important commits,
+call me again with the --ignore-sha flag`, pr.Head.Ref)
+	}
+
+	// prepare deletion of local branch:
+	headRef, err := r.Head()
+	if err != nil {
+		return err
+	}
+	if headRef.Name().Short() == branch.Name {
+		fmt.Printf("Checking out 'master' to delete local branch '%s'\n", branch.Name)
+		err = r.TeaCheckout("master")
+		if err != nil {
+			return err
+		}
+	}
+
+	// remove local & remote branch
+	fmt.Printf("Deleting local branch %s and remote branch %s\n", branch.Name, pr.Head.Ref)
+	url, err := r.TeaRemoteURL(branch.Remote)
+	if err != nil {
+		return err
+	}
+	auth, err := local_git.GetAuthForURL(url, login.User, login.SSHKey)
+	if err != nil {
+		return err
+	}
+	return r.TeaDeleteBranch(branch, pr.Head.Ref, auth)
+}
+
+// CmdPullsCreate creates a pull request
+var CmdPullsCreate = cli.Command{
+	Name:        "create",
+	Usage:       "Create a pull-request",
+	Description: "Create a pull-request",
+	Action:      runPullsCreate,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:  "head",
+			Usage: "Set head branch (default is current one)",
+		},
+		&cli.StringFlag{
+			Name:    "base",
+			Aliases: []string{"b"},
+			Usage:   "Set base branch (default is default branch)",
+		},
+		&cli.StringFlag{
+			Name:    "title",
+			Aliases: []string{"t"},
+			Usage:   "Set title of pull (default is head branch name)",
+		},
+		&cli.StringFlag{
+			Name:    "description",
+			Aliases: []string{"d"},
+			Usage:   "Set body of new pull",
+		},
+	}, AllDefaultFlags...),
+}
+
+func runPullsCreate(ctx *cli.Context) error {
+	login, ownerArg, repoArg := initCommand()
+	client := login.Client()
+
+	repo, _, err := client.GetRepo(ownerArg, repoArg)
+	if err != nil {
+		log.Fatal("could not fetch repo meta: ", err)
+	}
+
+	// open local git repo
+	localRepo, err := local_git.RepoForWorkdir()
+	if err != nil {
+		log.Fatal("could not open local repo: ", err)
+	}
+
+	// push if possible
+	log.Println("git push")
+	err = localRepo.Push(&git.PushOptions{})
+	if err != nil && err != git.NoErrAlreadyUpToDate {
+		log.Printf("Error occurred during 'git push':\n%s\n", err.Error())
+	}
+
+	base := ctx.String("base")
+	// default is default branch
+	if len(base) == 0 {
+		base = repo.DefaultBranch
+	}
+
+	head := ctx.String("head")
+	// default is current one
+	if len(head) == 0 {
+		headBranch, err := localRepo.Head()
+		if err != nil {
+			log.Fatal(err)
+		}
+		sha := headBranch.Hash().String()
+
+		remote, err := localRepo.TeaFindBranchRemote("", sha)
+		if err != nil {
+			log.Fatal("could not determine remote for current branch: ", err)
+		}
+
+		if remote == nil {
+			// if no remote branch is found for the local hash, we abort:
+			// user has probably not configured a remote for the local branch,
+			// or local branch does not represent remote state.
+			log.Fatal("no matching remote found for this branch. try git push -u <remote> <branch>")
+		}
+
+		branchName, err := localRepo.TeaGetCurrentBranchName()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		url, err := local_git.ParseURL(remote.Config().URLs[0])
+		if err != nil {
+			log.Fatal(err)
+		}
+		owner, _ := getOwnerAndRepo(strings.TrimLeft(url.Path, "/"), "")
+		head = fmt.Sprintf("%s:%s", owner, branchName)
+	}
+
+	title := ctx.String("title")
+	// default is head branch name
+	if len(title) == 0 {
+		title = head
+		if strings.Contains(title, ":") {
+			title = strings.SplitN(title, ":", 2)[1]
+		}
+		title = strings.Replace(title, "-", " ", -1)
+		title = strings.Replace(title, "_", " ", -1)
+		title = strings.Title(strings.ToLower(title))
+	}
+	// title is required
+	if len(title) == 0 {
+		fmt.Printf("Title is required")
+		return nil
+	}
+
+	pr, _, err := client.CreatePullRequest(ownerArg, repoArg, gitea.CreatePullRequestOption{
+		Head:  head,
+		Base:  base,
+		Title: title,
+		Body:  ctx.String("description"),
+	})
+
+	if err != nil {
+		log.Fatalf("could not create PR from %s to %s:%s: %s", head, ownerArg, base, err)
+	}
+
+	in := fmt.Sprintf("# #%d %s (%s)\n%s created %s\n\n%s\n", pr.Index,
+		pr.Title,
+		pr.State,
+		pr.Poster.UserName,
+		pr.Created.Format("2006-01-02 15:04:05"),
+		pr.Body,
+	)
+	out, err := glamour.Render(in, getGlamourTheme())
+	fmt.Print(out)
+
+	fmt.Println(pr.HTMLURL)
+	return err
+}
+
+func argToIndex(arg string) (int64, error) {
+	if strings.HasPrefix(arg, "#") {
+		arg = arg[1:]
+	}
+	return strconv.ParseInt(arg, 10, 64)
+}

cmd/releases.go

@@ -5,31 +5,50 @@
 package cmd
 
 import (
+	"fmt"
 	"log"
+	"net/http"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"code.gitea.io/sdk/gitea"
 
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // CmdReleases represents to login a gitea server.
 var CmdReleases = cli.Command{
-	Name:        "releases",
-	Usage:       "Operate with releases of the repository",
-	Description: `Operate with releases of the repository`,
+	Name:        "release",
+	Aliases:     []string{"releases"},
+	Usage:       "Manage releases",
+	Description: "Manage releases",
 	Action:      runReleases,
-	Subcommands: []cli.Command{
-		CmdReleaseCreate,
+	Subcommands: []*cli.Command{
+		&CmdReleaseList,
+		&CmdReleaseCreate,
+		&CmdReleaseDelete,
+		&CmdReleaseEdit,
 	},
 	Flags: AllDefaultFlags,
 }
 
+// CmdReleaseList represents a sub command of Release to list releases
+var CmdReleaseList = cli.Command{
+	Name:        "ls",
+	Usage:       "List Releases",
+	Description: "List Releases",
+	Action:      runReleases,
+	Flags: append([]cli.Flag{
+		&PaginationPageFlag,
+		&PaginationLimitFlag,
+	}, AllDefaultFlags...),
+}
+
 func runReleases(ctx *cli.Context) error {
 	login, owner, repo := initCommand()
 
-	releases, err := login.Client().ListReleases(owner, repo)
+	releases, _, err := login.Client().ListReleases(owner, repo, gitea.ListReleasesOptions{ListOptions: getListOptions(ctx)})
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -38,6 +57,7 @@ func runReleases(ctx *cli.Context) error {
 		"Tag-Name",
 		"Title",
 		"Published At",
+		"Status",
 		"Tar URL",
 	}
 
@@ -49,12 +69,19 @@ func runReleases(ctx *cli.Context) error {
 	}
 
 	for _, release := range releases {
+		status := "released"
+		if release.IsDraft {
+			status = "draft"
+		} else if release.IsPrerelease {
+			status = "prerelease"
+		}
 		values = append(
 			values,
 			[]string{
 				release.TagName,
 				release.Title,
 				release.PublishedAt.Format("2006-01-02 15:04:05"),
+				status,
 				release.TarURL,
 			},
 		)
@@ -64,48 +91,53 @@ func runReleases(ctx *cli.Context) error {
 	return nil
 }
 
-// CmdReleaseCreate represents a sub command of Release to create release.
+// CmdReleaseCreate represents a sub command of Release to create release
 var CmdReleaseCreate = cli.Command{
 	Name:        "create",
-	Usage:       "Create a release in repository",
-	Description: `Create a release in repository`,
+	Usage:       "Create a release",
+	Description: `Create a release`,
 	Action:      runReleaseCreate,
 	Flags: append([]cli.Flag{
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "tag",
-			Usage: "release tag name",
+			Usage: "Tag name",
 		},
-		cli.StringFlag{
+		&cli.StringFlag{
 			Name:  "target",
-			Usage: "release target refs, branch name or commit id",
+			Usage: "Target refs, branch name or commit id",
 		},
-		cli.StringFlag{
-			Name:  "title, t",
-			Usage: "release title to create",
+		&cli.StringFlag{
+			Name:    "title",
+			Aliases: []string{"t"},
+			Usage:   "Release title",
 		},
-		cli.StringFlag{
-			Name:  "note, n",
-			Usage: "release note to create",
+		&cli.StringFlag{
+			Name:    "note",
+			Aliases: []string{"n"},
+			Usage:   "Release notes",
 		},
-		cli.BoolFlag{
-			Name:  "draft, d",
-			Usage: "the release is a draft",
+		&cli.BoolFlag{
+			Name:    "draft",
+			Aliases: []string{"d"},
+			Usage:   "Is a draft",
 		},
-		cli.BoolFlag{
-			Name:  "prerelease, p",
-			Usage: "the release is a prerelease",
+		&cli.BoolFlag{
+			Name:    "prerelease",
+			Aliases: []string{"p"},
+			Usage:   "Is a pre-release",
 		},
-		cli.StringSliceFlag{
-			Name:  "asset, a",
-			Usage: "a list of files to attach to the release",
+		&cli.StringSliceFlag{
+			Name:    "asset",
+			Aliases: []string{"a"},
+			Usage:   "List of files to attach",
 		},
-	}, LoginRepoFlags...),
+	}, AllDefaultFlags...),
 }
 
 func runReleaseCreate(ctx *cli.Context) error {
 	login, owner, repo := initCommand()
 
-	release, err := login.Client().CreateRelease(owner, repo, gitea.CreateReleaseOption{
+	release, resp, err := login.Client().CreateRelease(owner, repo, gitea.CreateReleaseOption{
 		TagName:      ctx.String("tag"),
 		Target:       ctx.String("target"),
 		Title:        ctx.String("title"),
@@ -115,10 +147,10 @@ func runReleaseCreate(ctx *cli.Context) error {
 	})
 
 	if err != nil {
-		if err.Error() == "409 Conflict" {
-			log.Fatal("error: There already is a release for this tag")
+		if resp != nil && resp.StatusCode == http.StatusConflict {
+			fmt.Println("error: There already is a release for this tag")
+			return nil
 		}
-
 		log.Fatal(err)
 	}
 
@@ -131,7 +163,7 @@ func runReleaseCreate(ctx *cli.Context) error {
 
 		filePath := filepath.Base(asset)
 
-		if _, err = login.Client().CreateReleaseAttachment(owner, repo, release.ID, file, filePath); err != nil {
+		if _, _, err = login.Client().CreateReleaseAttachment(owner, repo, release.ID, file, filePath); err != nil {
 			file.Close()
 			log.Fatal(err)
 		}
@@ -141,3 +173,139 @@ func runReleaseCreate(ctx *cli.Context) error {
 
 	return nil
 }
+
+// CmdReleaseDelete represents a sub command of Release to delete a release
+var CmdReleaseDelete = cli.Command{
+	Name:        "delete",
+	Usage:       "Delete a release",
+	Description: `Delete a release`,
+	ArgsUsage:   "<release tag>",
+	Action:      runReleaseDelete,
+	Flags:       AllDefaultFlags,
+}
+
+func runReleaseDelete(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	tag := ctx.Args().First()
+	if len(tag) == 0 {
+		fmt.Println("Release tag needed to delete")
+		return nil
+	}
+
+	release, err := getReleaseByTag(owner, repo, tag, client)
+	if err != nil {
+		return err
+	}
+	if release == nil {
+		return nil
+	}
+
+	_, err = client.DeleteRelease(owner, repo, release.ID)
+	return err
+}
+
+func getReleaseByTag(owner, repo, tag string, client *gitea.Client) (*gitea.Release, error) {
+	rl, _, err := client.ListReleases(owner, repo, gitea.ListReleasesOptions{})
+	if err != nil {
+		return nil, err
+	}
+	if len(rl) == 0 {
+		fmt.Println("Repo does not have any release")
+		return nil, nil
+	}
+	for _, r := range rl {
+		if r.TagName == tag {
+			return r, nil
+		}
+	}
+	fmt.Println("Release tag does not exist")
+	return nil, nil
+}
+
+// CmdReleaseEdit represents a sub command of Release to edit releases
+var CmdReleaseEdit = cli.Command{
+	Name:        "edit",
+	Usage:       "Edit a release",
+	Description: `Edit a release`,
+	ArgsUsage:   "<release tag>",
+	Action:      runReleaseEdit,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:  "tag",
+			Usage: "Change Tag",
+		},
+		&cli.StringFlag{
+			Name:  "target",
+			Usage: "Change Target",
+		},
+		&cli.StringFlag{
+			Name:    "title",
+			Aliases: []string{"t"},
+			Usage:   "Change Title",
+		},
+		&cli.StringFlag{
+			Name:    "note",
+			Aliases: []string{"n"},
+			Usage:   "Change Notes",
+		},
+		&cli.StringFlag{
+			Name:        "draft",
+			Aliases:     []string{"d"},
+			Usage:       "Mark as Draft [True/false]",
+			DefaultText: "true",
+		},
+		&cli.StringFlag{
+			Name:        "prerelease",
+			Aliases:     []string{"p"},
+			Usage:       "Mark as Pre-Release [True/false]",
+			DefaultText: "true",
+		},
+	}, AllDefaultFlags...),
+}
+
+func runReleaseEdit(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	tag := ctx.Args().First()
+	if len(tag) == 0 {
+		fmt.Println("Release tag needed to edit")
+		return nil
+	}
+
+	release, err := getReleaseByTag(owner, repo, tag, client)
+	if err != nil {
+		return err
+	}
+	if release == nil {
+		return nil
+	}
+
+	var isDraft, isPre *bool
+	bTrue := true
+	bFalse := false
+	if ctx.IsSet("draft") {
+		isDraft = &bFalse
+		if strings.ToLower(ctx.String("draft"))[:1] == "t" {
+			isDraft = &bTrue
+		}
+	}
+	if ctx.IsSet("prerelease") {
+		isPre = &bFalse
+		if strings.ToLower(ctx.String("prerelease"))[:1] == "t" {
+			isPre = &bTrue
+		}
+	}
+
+	_, _, err = client.EditRelease(owner, repo, release.ID, gitea.EditReleaseOption{
+		TagName:      ctx.String("tag"),
+		Target:       ctx.String("target"),
+		Title:        ctx.String("title"),
+		Note:         ctx.String("note"),
+		IsDraft:      isDraft,
+		IsPrerelease: isPre,
+	})
+	return err
+}

cmd/repos.go

@@ -0,0 +1,316 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+
+	"code.gitea.io/tea/modules/utils"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v2"
+)
+
+// CmdRepos represents to login a gitea server.
+var CmdRepos = cli.Command{
+	Name:        "repos",
+	Usage:       "Show repositories details",
+	Description: "Show repositories details",
+	ArgsUsage:   "[<repo owner>/<repo name>]",
+	Action:      runRepos,
+	Subcommands: []*cli.Command{
+		&CmdReposList,
+		&CmdRepoCreate,
+	},
+	Flags: LoginOutputFlags,
+}
+
+// CmdReposList represents a sub command of repos to list them
+var CmdReposList = cli.Command{
+	Name:        "ls",
+	Usage:       "List available repositories",
+	Description: `List available repositories`,
+	Action:      runReposList,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:     "mode",
+			Aliases:  []string{"m"},
+			Required: false,
+			Usage:    "Filter by mode: fork, mirror, source",
+		},
+		&cli.StringFlag{
+			Name:     "owner",
+			Aliases:  []string{"O"},
+			Required: false,
+			Usage:    "Filter by owner",
+		},
+		&cli.StringFlag{
+			Name:     "private",
+			Required: false,
+			Usage:    "Filter private repos (true|false)",
+		},
+		&cli.StringFlag{
+			Name:     "archived",
+			Required: false,
+			Usage:    "Filter archived repos (true|false)",
+		},
+		&PaginationPageFlag,
+		&PaginationLimitFlag,
+	}, LoginOutputFlags...),
+}
+
+// CmdRepoCreate represents a sub command of repos to create one
+var CmdRepoCreate = cli.Command{
+	Name:        "create",
+	Aliases:     []string{"c"},
+	Usage:       "Create a repository",
+	Description: "Create a repository",
+	Action:      runRepoCreate,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:     "name",
+			Aliases:  []string{""},
+			Required: true,
+			Usage:    "name of new repo",
+		},
+		&cli.StringFlag{
+			Name:     "owner",
+			Aliases:  []string{"O"},
+			Required: false,
+			Usage:    "name of repo owner",
+		},
+		&cli.BoolFlag{
+			Name:     "private",
+			Required: false,
+			Value:    false,
+			Usage:    "make repo private",
+		},
+		&cli.StringFlag{
+			Name:     "description",
+			Aliases:  []string{"desc"},
+			Required: false,
+			Usage:    "add description to repo",
+		},
+		&cli.BoolFlag{
+			Name:     "init",
+			Required: false,
+			Value:    false,
+			Usage:    "initialize repo",
+		},
+		&cli.StringFlag{
+			Name:     "labels",
+			Required: false,
+			Usage:    "name of label set to add",
+		},
+		&cli.StringFlag{
+			Name:     "gitignores",
+			Aliases:  []string{"git"},
+			Required: false,
+			Usage:    "list of gitignore templates (need --init)",
+		},
+		&cli.StringFlag{
+			Name:     "license",
+			Required: false,
+			Usage:    "add license (need --init)",
+		},
+		&cli.StringFlag{
+			Name:     "readme",
+			Required: false,
+			Usage:    "use readme template (need --init)",
+		},
+		&cli.StringFlag{
+			Name:     "branch",
+			Required: false,
+			Usage:    "use custom default branch (need --init)",
+		},
+	}, LoginOutputFlags...),
+}
+
+func runRepos(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runRepoDetail(ctx, ctx.Args().First())
+	}
+	return runReposList(ctx)
+}
+
+// runReposList list repositories
+func runReposList(ctx *cli.Context) error {
+	login := initCommandLoginOnly()
+	client := login.Client()
+
+	var ownerID int64
+	if ctx.IsSet("owner") {
+		// test if owner is a organisation
+		org, resp, err := client.GetOrg(ctx.String("owner"))
+		if err != nil {
+			if resp == nil || resp.StatusCode != http.StatusNotFound {
+				return err
+			}
+			// if owner is no org, its a user
+			user, _, err := client.GetUserInfo(ctx.String("owner"))
+			if err != nil {
+				return err
+			}
+			ownerID = user.ID
+		} else {
+			ownerID = org.ID
+		}
+	} else {
+		me, _, err := client.GetMyUserInfo()
+		if err != nil {
+			return err
+		}
+		ownerID = me.ID
+	}
+
+	var isArchived *bool
+	if ctx.IsSet("archived") {
+		archived := strings.ToLower(ctx.String("archived"))[:1] == "t"
+		isArchived = &archived
+	}
+
+	var isPrivate *bool
+	if ctx.IsSet("private") {
+		private := strings.ToLower(ctx.String("private"))[:1] == "t"
+		isArchived = &private
+	}
+
+	mode := gitea.RepoTypeNone
+	switch ctx.String("mode") {
+	case "fork":
+		mode = gitea.RepoTypeFork
+	case "mirror":
+		mode = gitea.RepoTypeMirror
+	case "source":
+		mode = gitea.RepoTypeSource
+	}
+
+	rps, _, err := client.SearchRepos(gitea.SearchRepoOptions{
+		ListOptions: getListOptions(ctx),
+		OwnerID:     ownerID,
+		IsPrivate:   isPrivate,
+		IsArchived:  isArchived,
+		Type:        mode,
+	})
+	if err != nil {
+		return err
+	}
+
+	if len(rps) == 0 {
+		log.Fatal("No repositories found", rps)
+		return nil
+	}
+
+	headers := []string{
+		"Name",
+		"Type",
+		"SSH",
+		"Owner",
+	}
+	var values [][]string
+
+	for _, rp := range rps {
+		var mode = "source"
+		if rp.Fork {
+			mode = "fork"
+		}
+		if rp.Mirror {
+			mode = "mirror"
+		}
+
+		values = append(
+			values,
+			[]string{
+				rp.FullName,
+				mode,
+				rp.SSHURL,
+				rp.Owner.UserName,
+			},
+		)
+	}
+	Output(outputValue, headers, values)
+
+	return nil
+}
+
+func runRepoDetail(_ *cli.Context, path string) error {
+	login := initCommandLoginOnly()
+	client := login.Client()
+	repoOwner, repoName := getOwnerAndRepo(path, login.User)
+	repo, _, err := client.GetRepo(repoOwner, repoName)
+	if err != nil {
+		return err
+	}
+	topics, _, err := client.ListRepoTopics(repo.Owner.UserName, repo.Name, gitea.ListRepoTopicsOptions{})
+	if err != nil {
+		return err
+	}
+
+	output := repo.FullName
+	if repo.Mirror {
+		output += " (mirror)"
+	}
+	if repo.Fork {
+		output += " (fork)"
+	}
+	if repo.Archived {
+		output += " (archived)"
+	}
+	if repo.Empty {
+		output += " (empty)"
+	}
+	output += "\n"
+	if len(topics) != 0 {
+		output += "Topics: " + strings.Join(topics, ", ") + "\n"
+	}
+	output += "\n"
+	output += repo.Description + "\n\n"
+	output += fmt.Sprintf(
+		"Open Issues: %d, Stars: %d, Forks: %d, Size: %s\n\n",
+		repo.OpenIssues,
+		repo.Stars,
+		repo.Forks,
+		utils.FormatSize(int64(repo.Size)),
+	)
+
+	fmt.Print(output)
+	return nil
+}
+
+func runRepoCreate(ctx *cli.Context) error {
+	login := initCommandLoginOnly()
+	client := login.Client()
+	var (
+		repo *gitea.Repository
+		err  error
+	)
+	opts := gitea.CreateRepoOption{
+		Name:          ctx.String("name"),
+		Description:   ctx.String("description"),
+		Private:       ctx.Bool("private"),
+		AutoInit:      ctx.Bool("init"),
+		IssueLabels:   ctx.String("labels"),
+		Gitignores:    ctx.String("gitignores"),
+		License:       ctx.String("license"),
+		Readme:        ctx.String("readme"),
+		DefaultBranch: ctx.String("branch"),
+	}
+	if len(ctx.String("owner")) != 0 {
+		repo, _, err = client.CreateOrgRepo(ctx.String("owner"), opts)
+	} else {
+		repo, _, err = client.CreateRepo(opts)
+	}
+	if err != nil {
+		return err
+	}
+	if err = runRepoDetail(ctx, repo.FullName); err != nil {
+		return err
+	}
+	fmt.Printf("%s\n", repo.HTMLURL)
+	return nil
+}

cmd/times.go

@@ -0,0 +1,271 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+
+	"code.gitea.io/sdk/gitea"
+
+	"github.com/araddon/dateparse"
+	"github.com/urfave/cli/v2"
+)
+
+// CmdTrackedTimes represents the command to operate repositories' times.
+var CmdTrackedTimes = cli.Command{
+	Name:    "times",
+	Aliases: []string{"time"},
+	Usage:   "Operate on tracked times of a repository's issues & pulls",
+	Description: `Operate on tracked times of a repository's issues & pulls.
+		 Depending on your permissions on the repository, only your own tracked
+		 times might be listed.`,
+	ArgsUsage: "[username | #issue]",
+	Action:    runTrackedTimes,
+	Subcommands: []*cli.Command{
+		&CmdTrackedTimesAdd,
+		&CmdTrackedTimesDelete,
+		&CmdTrackedTimesReset,
+	},
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:    "from",
+			Aliases: []string{"f"},
+			Usage:   "Show only times tracked after this date",
+		},
+		&cli.StringFlag{
+			Name:    "until",
+			Aliases: []string{"u"},
+			Usage:   "Show only times tracked before this date",
+		},
+		&cli.BoolFlag{
+			Name:    "total",
+			Aliases: []string{"t"},
+			Usage:   "Print the total duration at the end",
+		},
+	}, AllDefaultFlags...),
+}
+
+func runTrackedTimes(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	if err := client.CheckServerVersionConstraint(">= 1.11"); err != nil {
+		return err
+	}
+
+	var times []*gitea.TrackedTime
+	var err error
+
+	user := ctx.Args().First()
+	fmt.Println(ctx.Command.ArgsUsage)
+	if user == "" {
+		// get all tracked times on the repo
+		times, _, err = client.GetRepoTrackedTimes(owner, repo)
+	} else if strings.HasPrefix(user, "#") {
+		// get all tracked times on the specified issue
+		issue, err := argToIndex(user)
+		if err != nil {
+			return err
+		}
+		times, _, err = client.ListTrackedTimes(owner, repo, issue, gitea.ListTrackedTimesOptions{})
+	} else {
+		// get all tracked times by the specified user
+		times, _, err = client.GetUserTrackedTimes(owner, repo, user)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	var from, until time.Time
+	if ctx.String("from") != "" {
+		from, err = dateparse.ParseLocal(ctx.String("from"))
+		if err != nil {
+			return err
+		}
+	}
+	if ctx.String("until") != "" {
+		until, err = dateparse.ParseLocal(ctx.String("until"))
+		if err != nil {
+			return err
+		}
+	}
+
+	printTrackedTimes(times, outputValue, from, until, ctx.Bool("total"))
+	return nil
+}
+
+func formatDuration(seconds int64, outputType string) string {
+	switch outputType {
+	case "yaml":
+	case "csv":
+		return fmt.Sprint(seconds)
+	}
+	return time.Duration(1e9 * seconds).String()
+}
+
+func printTrackedTimes(times []*gitea.TrackedTime, outputType string, from, until time.Time, printTotal bool) {
+	var outputValues [][]string
+	var totalDuration int64
+
+	localLoc, err := time.LoadLocation("Local") // local timezone for time formatting
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, t := range times {
+		if !from.IsZero() && from.After(t.Created) {
+			continue
+		}
+		if !until.IsZero() && until.Before(t.Created) {
+			continue
+		}
+
+		totalDuration += t.Time
+
+		outputValues = append(
+			outputValues,
+			[]string{
+				t.Created.In(localLoc).Format("2006-01-02 15:04:05"),
+				"#" + strconv.FormatInt(t.Issue.Index, 10),
+				t.UserName,
+				formatDuration(t.Time, outputType),
+			},
+		)
+	}
+
+	if printTotal {
+		outputValues = append(outputValues, []string{
+			"TOTAL", "", "", formatDuration(totalDuration, outputType),
+		})
+	}
+
+	headers := []string{
+		"Created",
+		"Issue",
+		"User",
+		"Duration",
+	}
+	Output(outputType, headers, outputValues)
+}
+
+// CmdTrackedTimesAdd represents a sub command of times to add time to an issue
+var CmdTrackedTimesAdd = cli.Command{
+	Name:      "add",
+	Usage:     "Track spent time on an issue",
+	UsageText: "tea times add <issue> <duration>",
+	Description: `Track spent time on an issue
+	 Example:
+		tea times add 1 1h25m
+	`,
+	Action: runTrackedTimesAdd,
+	Flags:  LoginRepoFlags,
+}
+
+func runTrackedTimesAdd(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+
+	if ctx.Args().Len() < 2 {
+		return fmt.Errorf("No issue or duration specified.\nUsage:\t%s", ctx.Command.UsageText)
+	}
+
+	issue, err := argToIndex(ctx.Args().First())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	duration, err := time.ParseDuration(strings.Join(ctx.Args().Tail(), ""))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	_, _, err = login.Client().AddTime(owner, repo, issue, gitea.AddTimeOption{
+		Time: int64(duration.Seconds()),
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return nil
+}
+
+// CmdTrackedTimesDelete is a sub command of CmdTrackedTimes, and removes time from an issue
+var CmdTrackedTimesDelete = cli.Command{
+	Name:      "delete",
+	Aliases:   []string{"rm"},
+	Usage:     "Delete a single tracked time on an issue",
+	UsageText: "tea times delete <issue> <time ID>",
+	Action:    runTrackedTimesDelete,
+	Flags:     LoginRepoFlags,
+}
+
+func runTrackedTimesDelete(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	if err := client.CheckServerVersionConstraint(">= 1.11"); err != nil {
+		return err
+	}
+
+	if ctx.Args().Len() < 2 {
+		return fmt.Errorf("No issue or time ID specified.\nUsage:\t%s", ctx.Command.UsageText)
+	}
+
+	issue, err := argToIndex(ctx.Args().First())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	timeID, err := strconv.ParseInt(ctx.Args().Get(1), 10, 64)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	_, err = client.DeleteTime(owner, repo, issue, timeID)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return nil
+}
+
+// CmdTrackedTimesReset is a subcommand of CmdTrackedTimes, and
+// clears all tracked times on an issue.
+var CmdTrackedTimesReset = cli.Command{
+	Name:      "reset",
+	Usage:     "Reset tracked time on an issue",
+	UsageText: "tea times reset <issue>",
+	Action:    runTrackedTimesReset,
+	Flags:     LoginRepoFlags,
+}
+
+func runTrackedTimesReset(ctx *cli.Context) error {
+	login, owner, repo := initCommand()
+	client := login.Client()
+
+	if err := client.CheckServerVersionConstraint(">= 1.11"); err != nil {
+		return err
+	}
+
+	if ctx.Args().Len() != 1 {
+		return fmt.Errorf("No issue specified.\nUsage:\t%s", ctx.Command.UsageText)
+	}
+
+	issue, err := argToIndex(ctx.Args().First())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	_, err = client.ResetIssueTime(owner, repo, issue)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return nil
+}

go.mod

@@ -3,12 +3,21 @@ module code.gitea.io/tea
 go 1.12
 
 require (
-	code.gitea.io/sdk/gitea v0.0.0-20191013013401-e41e9ea72caa
-	github.com/go-gitea/yaml v0.0.0-20170812160011-eb3733d160e7
-	github.com/mattn/go-runewidth v0.0.4 // indirect
-	github.com/olekukonko/tablewriter v0.0.1
-	github.com/stretchr/testify v1.3.0
-	github.com/urfave/cli v1.20.0
-	gopkg.in/src-d/go-git.v4 v4.13.1
-	gopkg.in/yaml.v2 v2.2.2 // indirect
+	code.gitea.io/gitea-vet v0.2.0
+	code.gitea.io/sdk/gitea v0.13.0
+	github.com/araddon/dateparse v0.0.0-20200409225146-d820a6159ab1
+	github.com/charmbracelet/glamour v0.2.0
+	github.com/cpuguy83/go-md2man/v2 v2.0.0 // indirect
+	github.com/go-git/go-git/v5 v5.1.0
+	github.com/hashicorp/go-version v1.2.1 // indirect
+	github.com/muesli/termenv v0.7.2
+	github.com/olekukonko/tablewriter v0.0.4
+	github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966
+	github.com/stretchr/testify v1.5.1
+	github.com/urfave/cli/v2 v2.2.0
+	golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899
+	golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect
+	golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae // indirect
+	golang.org/x/tools v0.0.0-20200721032237-77f530d86f9a // indirect
+	gopkg.in/yaml.v2 v2.3.0
 )

go.sum

@@ -1,25 +1,63 @@
-code.gitea.io/sdk/gitea v0.0.0-20191013013401-e41e9ea72caa h1:KgpwNF1StxPXMfCD9M++jvCUPUqHPAbuvQn1q3sWtqw=
-code.gitea.io/sdk/gitea v0.0.0-20191013013401-e41e9ea72caa/go.mod h1:8IxkM1gyiwEjfO0m47bcmr3u3foR15+LoVub43hCHd0=
+code.gitea.io/gitea-vet v0.2.0 h1:xkUePzbHI8e0qp4Aly4GBSd0+6cqEMVTrdZq57fPozo=
+code.gitea.io/gitea-vet v0.2.0/go.mod h1:zcNbT/aJEmivCAhfmkHOlT645KNOf9W2KnkLgFjGGfE=
+code.gitea.io/sdk/gitea v0.13.0 h1:iHognp8ZMhMFLooUUNZFpm8IHaC9qoHJDvAE5vTm5aw=
+code.gitea.io/sdk/gitea v0.13.0/go.mod h1:z3uwDV/b9Ls47NGukYM9XhnHtqPh/J+t40lsUrR6JDY=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7 h1:uSoVVbwJiQipAclBbw+8quDsfcvFjOpI5iCf4p/cqCs=
 github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/ghQa61ZWa/C2Aw3RkjiTBOix7dkqa1VLIs=
+github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38 h1:smF2tmSOzy2Mm+0dGI2AIUHY+w0BUc+4tn40djz7+6U=
+github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38/go.mod h1:r7bzyVFMNntcxPZXK3/+KdruV1H5KSlyVY0gc+NgInI=
+github.com/alecthomas/chroma v0.7.3 h1:NfdAERMy+esYQs8OXk0I868/qDxxCEo7FMz1WIqMAeI=
+github.com/alecthomas/chroma v0.7.3/go.mod h1:sko8vR34/90zvl5QdcUdvzL3J8NKjAUx9va9jPuFNoM=
+github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721 h1:JHZL0hZKJ1VENNfmXvHbgYlbUOvpzYzvy2aZU5gXVeo=
+github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721/go.mod h1:QO9JBoKquHd+jz9nshCh40fOfO+JzsoXy8qTHF68zU0=
+github.com/alecthomas/kong v0.2.4/go.mod h1:kQOmtJgV+Lb4aj+I2LEn40cbtawdWJ9Y8QLq+lElKxE=
+github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897 h1:p9Sln00KOTlrYkxI1zYWl1QLnEqAqEARBEYa8FQnQcY=
+github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897/go.mod h1:xTS7Pm1pD1mvyM075QCDSRqH6qRLXylzS24ZTpRiSzQ=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239 h1:kFOfPq6dUM1hTo4JG6LR5AXSUEsOjtdm0kw0FtQtMJA=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
+github.com/araddon/dateparse v0.0.0-20200409225146-d820a6159ab1 h1:TEBmxO80TM04L8IuMWk77SGL1HomBmKTdzdJLLWznxI=
+github.com/araddon/dateparse v0.0.0-20200409225146-d820a6159ab1/go.mod h1:SLqhdZcd+dF3TEVL2RMoob5bBP5R1P1qkox+HtCBgGI=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
-github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
+github.com/charmbracelet/glamour v0.2.0 h1:mTgaiNiumpqTZp3qVM6DH9UB0NlbY17wejoMf1kM8Pg=
+github.com/charmbracelet/glamour v0.2.0/go.mod h1:UA27Kwj3QHialP74iU6C+Gpc8Y7IOAKupeKMLLBURWM=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.0 h1:EoUDS0afbrsXAZ9YQ9jdu/mZ2sXgT1/2yyNng4PGlyM=
+github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964 h1:y5HC9v93H5EPKqaS1UYVg1uYah5Xf51mBfIoWehClUQ=
+github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964/go.mod h1:Xd9hchkHSWYkEqJwUGisez3G1QY8Ryz0sdWrLPMGjLk=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.2.0 h1:8sAhBGEM0dRWogWqWyQeIJnxjWO6oIjl8FKqREDsGfk=
+github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
 github.com/emirpasic/gods v1.12.0 h1:QAUIPSaCu4G+POclxeqb3F+WPpdKqFGlw36+yOzGlrg=
 github.com/emirpasic/gods v1.12.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjrss6TZTdY2VfCqZPbv5k3iBFa2ZQ=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/gliderlabs/ssh v0.2.2 h1:6zsha5zo/TWhRhwqCD3+EarCAgZ2yN28ipRnGPnwkI0=
 github.com/gliderlabs/ssh v0.2.2/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
-github.com/go-gitea/yaml v0.0.0-20170812160011-eb3733d160e7 h1:/FEVbfrJ50yBk73Lyq1oCZ4VaCc0g1xd9xLHjz+Znf8=
-github.com/go-gitea/yaml v0.0.0-20170812160011-eb3733d160e7/go.mod h1:WjJPyqjAk/UMv+Fk/ZRjEOh5SXszSALnSzKqICd7pNg=
+github.com/go-git/gcfg v1.5.0 h1:Q5ViNfGF8zFgyJWPqYwA7qGFoMTEiBmdlkcfRmpIMa4=
+github.com/go-git/gcfg v1.5.0/go.mod h1:5m20vg6GwYabIxaOonVkTdrILxQMpEShl1xiMF4ua+E=
+github.com/go-git/go-billy/v5 v5.0.0 h1:7NQHvd9FVid8VL4qVUMm8XifBK+2xCoZ2lSk0agRrHM=
+github.com/go-git/go-billy/v5 v5.0.0/go.mod h1:pmpqyWchKfYfrkb/UVH4otLvyi/5gJlGI4Hb3ZqZ3W0=
+github.com/go-git/go-git-fixtures/v4 v4.0.1 h1:q+IFMfLx200Q3scvt2hN79JsEzy4AmBTp/pqnefH+Bc=
+github.com/go-git/go-git-fixtures/v4 v4.0.1/go.mod h1:m+ICp2rF3jDhFgEZ/8yziagdT1C+ZpZcrJjappBCDSw=
+github.com/go-git/go-git/v5 v5.1.0 h1:HxJn9g/E7eYvKW3Fm7Jt4ee8LXfPOm/H1cdDu8vEssk=
+github.com/go-git/go-git/v5 v5.1.0/go.mod h1:ZKfuPUoY1ZqIG4QG9BDBh3G4gLM5zvPuSJAozQrZuyM=
 github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/goterm v0.0.0-20190703233501-fc88cf888a3f h1:5CjVwnuUcp5adK4gmY6i72gpVFVnZDP2h5TmPScB6u4=
+github.com/google/goterm v0.0.0-20190703233501-fc88cf888a3f/go.mod h1:nOFQdrUlIlx6M6ODdSpBj1NVA+VgLC6kmw60mkw34H4=
+github.com/hashicorp/go-version v1.2.0 h1:3vNe/fWF5CBgRIguda1meWhsZHy3m8gCJ5wx+dIzX/E=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go-version v1.2.1 h1:zEfKbn2+PDgroKdiOzqiE8rsmLqU2uwi5PB5pBJ3TkI=
+github.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/imdario/mergo v0.3.9 h1:UauaLniWCFHWd+Jp9oCEkTBj8VO/9DKg3PV3VCNMDIg=
+github.com/imdario/mergo v0.3.9/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
@@ -28,61 +66,120 @@ github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd/go.mod h1:CT
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
-github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/microcosm-cc/bluemonday v1.0.2 h1:5lPfLTTAvAbtS0VqT+94yOtFnGfUWYyx0+iToC3Os3s=
+github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/olekukonko/tablewriter v0.0.1 h1:b3iUnf1v+ppJiOfNX4yxxqfWKMQPZR5yoh8urCTFX88=
-github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
-github.com/pelletier/go-buffruneio v0.2.0/go.mod h1:JkE26KsDizTr40EUHkXVtNPvgGtbSNq5BcowyYOWdKo=
+github.com/muesli/reflow v0.1.0 h1:oQdpLfO56lr5pgLvqD0TcjW85rDjSYSBVdiG1Ch1ddM=
+github.com/muesli/reflow v0.1.0/go.mod h1:I9bWAt7QTg/que/qmUCJBGlj7wEq8OAFBjPNjc6xK4I=
+github.com/muesli/termenv v0.6.0 h1:zxvzTBmo4ZcxhNGGWeMz+Tttm51eF5bmPjfy4MCRYlk=
+github.com/muesli/termenv v0.6.0/go.mod h1:SohX91w6swWA4AYU+QmPx+aSgXhWO0juiyID9UZmbpA=
+github.com/muesli/termenv v0.7.2 h1:r1raklL3uKE7rOvWgSenmEm2px+dnc33OTisZ8YR1fw=
+github.com/muesli/termenv v0.7.2/go.mod h1:ct2L5N2lmix82RaY3bMWwVu/jUFc9Ule0KGDCiKYPh8=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/olekukonko/tablewriter v0.0.4 h1:vHD/YYe1Wolo78koG299f7V/VAS08c6IpCLn+Ejf/w8=
+github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/src-d/gcfg v1.4.0 h1:xXbNR5AlLSA315x2UO+fTSSAXCDf+Ar38/6oyGbDKQ4=
-github.com/src-d/gcfg v1.4.0/go.mod h1:p/UMsR43ujA89BJY9duynAwIpvqEujIH/jFlfL7jWoI=
+github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
+github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966 h1:JIAuq3EEf9cgbU6AtGPK4CTG3Zf6CKMNqf0MHTggAUA=
+github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966/go.mod h1:sUM3LWHvSMaG192sy56D9F7CNvL7jUJVXoqM1QKLnog=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/urfave/cli v1.20.0 h1:fDqGv3UG/4jbVl/QkFwEdddtEDjh/5Ov6X+0B/3bPaw=
-github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/urfave/cli/v2 v2.2.0 h1:JTTnM6wKzdA0Jqodd966MVj4vWbbquZykeX1sKbe2C4=
+github.com/urfave/cli/v2 v2.2.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ=
 github.com/xanzy/ssh-agent v0.2.1 h1:TCbipTQL2JiiCprBWx9frJ2eJlCYT00NmctrHxVAr70=
 github.com/xanzy/ssh-agent v0.2.1/go.mod h1:mLlQY/MoOhWBj+gOGMQkOeiEvkx+8pJSI+0Bx9h2kr4=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.0 h1:WOOcyaJPlzb8fZ8TloxFe8QZkhOOJx87leDa9MIT9dc=
+github.com/yuin/goldmark v1.2.0/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 golang.org/x/crypto v0.0.0-20190219172222-a4c6cb3142f2/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 h1:HuIa8hRrWRSrqYzx1qI49NNxhdi2PrY7gxVSq1JjLDc=
-golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073 h1:xMPOj6Pz6UipU1wXLkrtqpHbR0AVFnyPEQq/wRWz9lM=
+golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899 h1:DZhuSZLsGlFL4CmhA8BcRA0mnthyA/nZ00AqCUo7vHg=
+golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80 h1:Ao/3l156eZf2AW5wK8a7/smtodRU+gha3+BeqJ69lRk=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190221075227-b4e8571b14e0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e h1:D5TXcfTk7xF7hvieo4QErS3qqCB4teTffacDWr7CI+0=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527 h1:uYVVQ9WP/Ds2ROhcaGPeIdVq0RIXVLwsHlnvJ+cT1So=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae h1:Ih9Yo4hSPImZOpfGuA4bR/ORKTAbhZo2AbWNRCnevdo=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190729092621-ff9f1409240a/go.mod h1:jcCCGcm9btYwXyDqrUWc6MKQKKGJCWEQ3AfLSRIbEuI=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200325010219-a49f79bcc224 h1:azwY/v0y0K4mFHVsg5+UrTgchqALYWpqVo6vL5OmkmI=
+golang.org/x/tools v0.0.0-20200325010219-a49f79bcc224/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200721032237-77f530d86f9a h1:kVMPw4f6EVqYdfGQTedjrpw1dbE2PEMfw4jwXsNdn9s=
+golang.org/x/tools v0.0.0-20200721032237-77f530d86f9a/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/src-d/go-billy.v4 v4.3.2 h1:0SQA1pRztfTFx2miS8sA97XvooFeNOmvUenF4o0EcVg=
-gopkg.in/src-d/go-billy.v4 v4.3.2/go.mod h1:nDjArDMp+XMs1aFAESLRjfGSgfvoYN0hDfzEk0GjC98=
-gopkg.in/src-d/go-git-fixtures.v3 v3.5.0 h1:ivZFOIltbce2Mo8IjzUHAFoq/IylO9WHhNOAJK+LsJg=
-gopkg.in/src-d/go-git-fixtures.v3 v3.5.0/go.mod h1:dLBcvytrw/TYZsNTWCnkNF2DSIlzWYqTe3rJR56Ac7g=
-gopkg.in/src-d/go-git.v4 v4.13.1 h1:SRtFyV8Kxc0UP7aCHcijOMQGPxHSmMOPrzulQWolkYE=
-gopkg.in/src-d/go-git.v4 v4.13.1/go.mod h1:nx5NYcxdKxq5fpltdHnPa2Exj4Sx0EclMWZQbYDu2z8=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -13,11 +13,11 @@ import (
 	"code.gitea.io/tea/cmd"
 	"code.gitea.io/tea/modules/setting"
 
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
-// Version holds the current Gitea version
-var Version = "0.1.0-dev"
+// Version holds the current tea version
+var Version = "development"
 
 // Tags holds the build tags used
 var Tags = ""
@@ -29,17 +29,22 @@ func init() {
 
 func main() {
 	app := cli.NewApp()
-	app.Name = "Tea"
+	app.Name = "tea"
 	app.Usage = "Command line tool to interact with Gitea"
 	app.Description = ``
 	app.Version = Version + formatBuiltWith(Tags)
-	app.Commands = []cli.Command{
-		cmd.CmdLogin,
-		cmd.CmdLogout,
-		cmd.CmdIssues,
-		cmd.CmdPulls,
-		cmd.CmdReleases,
-		cmd.CmdLabels,
+	app.Commands = []*cli.Command{
+		&cmd.CmdLogin,
+		&cmd.CmdLogout,
+		&cmd.CmdIssues,
+		&cmd.CmdPulls,
+		&cmd.CmdReleases,
+		&cmd.CmdRepos,
+		&cmd.CmdLabels,
+		&cmd.CmdTrackedTimes,
+		&cmd.CmdOpen,
+		&cmd.CmdNotifications,
+		&cmd.CmdMilestones,
 	}
 	app.EnableBashCompletion = true
 	err := app.Run(os.Args)

modules/git/auth.go

@@ -0,0 +1,120 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"bufio"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strings"
+
+	git_transport "github.com/go-git/go-git/v5/plumbing/transport"
+	gogit_http "github.com/go-git/go-git/v5/plumbing/transport/http"
+	gogit_ssh "github.com/go-git/go-git/v5/plumbing/transport/ssh"
+	"golang.org/x/crypto/ssh"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+// GetAuthForURL returns the appropriate AuthMethod to be used in Push() / Pull()
+// operations depending on the protocol, and prompts the user for credentials if
+// necessary.
+func GetAuthForURL(remoteURL *url.URL, httpUser, keyFile string) (auth git_transport.AuthMethod, err error) {
+	user := remoteURL.User.Username()
+
+	switch remoteURL.Scheme {
+	case "https":
+		if httpUser != "" {
+			user = httpUser
+		}
+		if user == "" {
+			user, err = promptUser(remoteURL.Host)
+			if err != nil {
+				return nil, err
+			}
+		}
+		pass, isSet := remoteURL.User.Password()
+		if !isSet {
+			pass, err = promptPass(remoteURL.Host)
+			if err != nil {
+				return nil, err
+			}
+		}
+		auth = &gogit_http.BasicAuth{Password: pass, Username: user}
+
+	case "ssh":
+		// try to select right key via ssh-agent. if it fails, try to read a key manually
+		auth, err = gogit_ssh.DefaultAuthBuilder(user)
+		if err != nil {
+			signer, err := readSSHPrivKey(keyFile)
+			if err != nil {
+				return nil, err
+			}
+			auth = &gogit_ssh.PublicKeys{User: user, Signer: signer}
+		}
+
+	default:
+		return nil, fmt.Errorf("don't know how to handle url scheme %v", remoteURL.Scheme)
+	}
+
+	return auth, nil
+}
+
+func readSSHPrivKey(keyFile string) (sig ssh.Signer, err error) {
+	if keyFile != "" {
+		keyFile, err = absPathWithExpansion(keyFile)
+	} else {
+		keyFile, err = absPathWithExpansion("~/.ssh/id_rsa")
+	}
+	if err != nil {
+		return nil, err
+	}
+	sshKey, err := ioutil.ReadFile(keyFile)
+	if err != nil {
+		return nil, err
+	}
+	sig, err = ssh.ParsePrivateKey(sshKey)
+	if err != nil {
+		pass, err := promptPass(keyFile)
+		if err != nil {
+			return nil, err
+		}
+		sig, err = ssh.ParsePrivateKeyWithPassphrase(sshKey, []byte(pass))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return sig, err
+}
+
+func promptUser(domain string) (string, error) {
+	reader := bufio.NewReader(os.Stdin)
+	fmt.Printf("%s username: ", domain)
+	username, err := reader.ReadString('\n')
+	return strings.TrimSpace(username), err
+}
+
+func promptPass(domain string) (string, error) {
+	fmt.Printf("%s password: ", domain)
+	pass, err := terminal.ReadPassword(0)
+	return string(pass), err
+}
+
+func absPathWithExpansion(p string) (string, error) {
+	u, err := user.Current()
+	if err != nil {
+		return "", err
+	}
+	if p == "~" {
+		return u.HomeDir, nil
+	} else if strings.HasPrefix(p, "~/") {
+		return filepath.Join(u.HomeDir, p[2:]), nil
+	} else {
+		return filepath.Abs(p)
+	}
+}

modules/git/branch.go

@@ -0,0 +1,233 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-git/go-git/v5"
+	git_config "github.com/go-git/go-git/v5/config"
+	git_plumbing "github.com/go-git/go-git/v5/plumbing"
+	git_transport "github.com/go-git/go-git/v5/plumbing/transport"
+)
+
+// TeaCreateBranch creates a new branch in the repo, tracking from another branch.
+func (r TeaRepo) TeaCreateBranch(localBranchName, remoteBranchName, remoteName string) error {
+	// save in .git/config to assign remote for future pulls
+	localBranchRefName := git_plumbing.NewBranchReferenceName(localBranchName)
+	err := r.CreateBranch(&git_config.Branch{
+		Name:   localBranchName,
+		Merge:  git_plumbing.NewBranchReferenceName(remoteBranchName),
+		Remote: remoteName,
+	})
+	if err != nil {
+		return err
+	}
+
+	// serialize the branch to .git/refs/heads
+	remoteBranchRefName := git_plumbing.NewRemoteReferenceName(remoteName, remoteBranchName)
+	remoteBranchRef, err := r.Storer.Reference(remoteBranchRefName)
+	if err != nil {
+		return err
+	}
+	localHashRef := git_plumbing.NewHashReference(localBranchRefName, remoteBranchRef.Hash())
+	return r.Storer.SetReference(localHashRef)
+}
+
+// TeaCheckout checks out the given branch in the worktree.
+func (r TeaRepo) TeaCheckout(branchName string) error {
+	tree, err := r.Worktree()
+	if err != nil {
+		return err
+	}
+	localBranchRefName := git_plumbing.NewBranchReferenceName(branchName)
+	return tree.Checkout(&git.CheckoutOptions{Branch: localBranchRefName})
+}
+
+// TeaDeleteBranch removes the given branch locally, and if `remoteBranch` is
+// not empty deletes it at it's remote repo.
+func (r TeaRepo) TeaDeleteBranch(branch *git_config.Branch, remoteBranch string, auth git_transport.AuthMethod) error {
+	err := r.DeleteBranch(branch.Name)
+	// if the branch is not found that's ok, as .git/config may have no entry if
+	// no remote tracking branch is configured for it (eg push without -u flag)
+	if err != nil && err.Error() != "branch not found" {
+		return err
+	}
+	err = r.Storer.RemoveReference(git_plumbing.NewBranchReferenceName(branch.Name))
+	if err != nil {
+		return err
+	}
+
+	if remoteBranch != "" {
+		// delete remote branch via git protocol:
+		// an empty source in the refspec means remote deletion to git 🙃
+		refspec := fmt.Sprintf(":%s", git_plumbing.NewBranchReferenceName(remoteBranch))
+		err = r.Push(&git.PushOptions{
+			RemoteName: branch.Remote,
+			RefSpecs:   []git_config.RefSpec{git_config.RefSpec(refspec)},
+			Prune:      true,
+			Auth:       auth,
+		})
+	}
+
+	return err
+}
+
+// TeaFindBranchBySha returns a branch that is at the the given SHA and syncs to the
+// given remote repo.
+func (r TeaRepo) TeaFindBranchBySha(sha, repoURL string) (b *git_config.Branch, err error) {
+	// find remote matching our repoURL
+	remote, err := r.GetRemote(repoURL)
+	if err != nil {
+		return nil, err
+	}
+	if remote == nil {
+		return nil, fmt.Errorf("No remote found for '%s'", repoURL)
+	}
+	remoteName := remote.Config().Name
+
+	// check if the given remote has our branch (.git/refs/remotes/<remoteName>/*)
+	iter, err := r.References()
+	if err != nil {
+		return nil, err
+	}
+	defer iter.Close()
+	var remoteRefName git_plumbing.ReferenceName
+	var localRefName git_plumbing.ReferenceName
+	err = iter.ForEach(func(ref *git_plumbing.Reference) error {
+		if ref.Name().IsRemote() {
+			name := ref.Name().Short()
+			if ref.Hash().String() == sha && strings.HasPrefix(name, remoteName) {
+				remoteRefName = ref.Name()
+			}
+		}
+
+		if ref.Name().IsBranch() && ref.Hash().String() == sha {
+			localRefName = ref.Name()
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if remoteRefName == "" || localRefName == "" {
+		// no remote tracking branch found, so a potential local branch
+		// can't be a match either
+		return nil, nil
+	}
+
+	b = &git_config.Branch{
+		Remote: remoteName,
+		Name:   localRefName.Short(),
+		Merge:  localRefName,
+	}
+	return b, b.Validate()
+}
+
+// TeaFindBranchByName returns a branch that is at the the given local and
+// remote names and syncs to the given remote repo. This method is less precise
+// than TeaFindBranchBySha(), but may be desirable if local and remote branch
+// have diverged.
+func (r TeaRepo) TeaFindBranchByName(branchName, repoURL string) (b *git_config.Branch, err error) {
+	// find remote matching our repoURL
+	remote, err := r.GetRemote(repoURL)
+	if err != nil {
+		return nil, err
+	}
+	if remote == nil {
+		return nil, fmt.Errorf("No remote found for '%s'", repoURL)
+	}
+	remoteName := remote.Config().Name
+
+	// check if the given remote has our branch (.git/refs/remotes/<remoteName>/*)
+	iter, err := r.References()
+	if err != nil {
+		return nil, err
+	}
+	defer iter.Close()
+	var remoteRefName git_plumbing.ReferenceName
+	var localRefName git_plumbing.ReferenceName
+	var remoteSearchingName = fmt.Sprintf("%s/%s", remoteName, branchName)
+	err = iter.ForEach(func(ref *git_plumbing.Reference) error {
+		if ref.Name().IsRemote() && ref.Name().Short() == remoteSearchingName {
+			remoteRefName = ref.Name()
+		}
+		n := ref.Name()
+		if n.IsBranch() && n.Short() == branchName {
+			localRefName = n
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if remoteRefName == "" || localRefName == "" {
+		return nil, nil
+	}
+
+	b = &git_config.Branch{
+		Remote: remoteName,
+		Name:   localRefName.Short(),
+		Merge:  localRefName,
+	}
+	return b, b.Validate()
+}
+
+// TeaFindBranchRemote gives the first remote that has a branch with the same name or sha,
+// depending on what is passed in.
+// This function is needed, as git does not always define branches in .git/config with remote entries.
+func (r TeaRepo) TeaFindBranchRemote(branchName, hash string) (*git.Remote, error) {
+	remotes, err := r.Remotes()
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	case len(remotes) == 0:
+		return nil, nil
+	case len(remotes) == 1:
+		return remotes[0], nil
+	}
+
+	// check if the given remote has our branch (.git/refs/remotes/<remoteName>/*)
+	iter, err := r.References()
+	if err != nil {
+		return nil, err
+	}
+	defer iter.Close()
+
+	var match *git.Remote
+	err = iter.ForEach(func(ref *git_plumbing.Reference) error {
+		if ref.Name().IsRemote() {
+			names := strings.SplitN(ref.Name().Short(), "/", 2)
+			remote := names[0]
+			branch := names[1]
+			hashMatch := hash != "" && hash == ref.Hash().String()
+			nameMatch := branchName != "" && branchName == branch
+			if hashMatch || nameMatch {
+				match, err = r.Remote(remote)
+				return err
+			}
+		}
+		return nil
+	})
+
+	return match, err
+}
+
+// TeaGetCurrentBranchName return the name of the branch witch is currently active
+func (r TeaRepo) TeaGetCurrentBranchName() (string, error) {
+	localHead, err := r.Head()
+	if err != nil {
+		return "", err
+	}
+
+	if !localHead.Name().IsBranch() {
+		return "", fmt.Errorf("active ref is no branch")
+	}
+
+	return strings.TrimPrefix(localHead.Name().String(), "refs/heads/"), nil
+}

modules/git/remote.go

@@ -0,0 +1,76 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"fmt"
+	"net/url"
+
+	"github.com/go-git/go-git/v5"
+	git_config "github.com/go-git/go-git/v5/config"
+)
+
+// GetRemote tries to match a Remote of the repo via the given URL.
+// Matching is based on the normalized URL, accepting different protocols.
+func (r TeaRepo) GetRemote(remoteURL string) (*git.Remote, error) {
+	repoURL, err := ParseURL(remoteURL)
+	if err != nil {
+		return nil, err
+	}
+
+	remotes, err := r.Remotes()
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range remotes {
+		for _, u := range r.Config().URLs {
+			remoteURL, err := ParseURL(u)
+			if err != nil {
+				return nil, err
+			}
+			if remoteURL.Host == repoURL.Host && remoteURL.Path == repoURL.Path {
+				return r, nil
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+// GetOrCreateRemote tries to match a Remote of the repo via the given URL.
+// If no match is found, a new Remote with `newRemoteName` is created.
+// Matching is based on the normalized URL, accepting different protocols.
+func (r TeaRepo) GetOrCreateRemote(remoteURL, newRemoteName string) (*git.Remote, error) {
+	localRemote, err := r.GetRemote(remoteURL)
+	if err != nil {
+		return nil, err
+	}
+
+	// if no match found, create a new remote
+	if localRemote == nil {
+		localRemote, err = r.CreateRemote(&git_config.RemoteConfig{
+			Name: newRemoteName,
+			URLs: []string{remoteURL},
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return localRemote, nil
+}
+
+// TeaRemoteURL returns the first url entry for the given remote name
+func (r TeaRepo) TeaRemoteURL(name string) (auth *url.URL, err error) {
+	remote, err := r.Remote(name)
+	if err != nil {
+		return nil, err
+	}
+	urls := remote.Config().URLs
+	if len(urls) == 0 {
+		return nil, fmt.Errorf("remote %s has no URL configured", name)
+	}
+	return ParseURL(remote.Config().URLs[0])
+}

modules/git/repo.go

@@ -0,0 +1,39 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"github.com/go-git/go-git/v5"
+)
+
+// TeaRepo is a go-git Repository, with an extended high level interface.
+type TeaRepo struct {
+	*git.Repository
+}
+
+// RepoForWorkdir tries to open the git repository in the local directory
+// for reading or modification.
+func RepoForWorkdir() (*TeaRepo, error) {
+	repo, err := git.PlainOpenWithOptions("./", &git.PlainOpenOptions{
+		DetectDotGit: true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &TeaRepo{repo}, nil
+}
+
+// RepoFromPath tries to open the git repository by path
+func RepoFromPath(path string) (*TeaRepo, error) {
+	repo, err := git.PlainOpenWithOptions(path, &git.PlainOpenOptions{
+		DetectDotGit: true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &TeaRepo{repo}, nil
+}

modules/git/url.go

@@ -1,3 +1,7 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
 package git
 
 import (
@@ -36,6 +40,11 @@ func (p *URLParser) Parse(rawURL string) (u *url.URL, err error) {
 		u.Path = strings.TrimPrefix(u.Path, "/")
 	}
 
+	// .git suffix is optional and breaks normalization
+	if strings.HasSuffix(u.Path, ".git") {
+		u.Path = strings.TrimSuffix(u.Path, ".git")
+	}
+
 	return
 }
 

modules/utils/format.go

@@ -0,0 +1,23 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package utils
+
+import "fmt"
+
+// FormatSize get kb in int and return string
+func FormatSize(kb int64) string {
+	if kb < 1024 {
+		return fmt.Sprintf("%d Kb", kb)
+	}
+	mb := kb / 1024
+	if mb < 1024 {
+		return fmt.Sprintf("%d Mb", mb)
+	}
+	gb := mb / 1024
+	if gb < 1024 {
+		return fmt.Sprintf("%d Gb", gb)
+	}
+	return fmt.Sprintf("%d Tb", gb/1024)
+}

modules/utils/path.go

@@ -0,0 +1,21 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package utils
+
+import (
+	"os"
+)
+
+// PathExists returns whether the given file or directory exists or not
+func PathExists(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return true, err
+}

vendor/code.gitea.io/gitea-vet/.changelog.yml

@@ -0,0 +1,30 @@
+# The full repository name
+repo: gitea/gitea-vet
+
+# Service type (gitea or github)
+service: gitea
+
+# Base URL for Gitea instance if using gitea service type (optional)
+base-url: https://gitea.com
+
+# Changelog groups and which labeled PRs to add to each group
+groups:
+  -
+    name: BREAKING
+    labels:
+      - breaking
+  -
+    name: FEATURES
+    labels:
+      - feature
+  -
+    name: BUGFIXES
+    labels:
+      - bug
+  -
+    name: ENHANCEMENTS
+    labels:
+      - enhancement
+
+# regex indicating which labels to skip for the changelog
+skip-labels: skip-changelog|backport\/.+

vendor/code.gitea.io/gitea-vet/.drone.yml

@@ -0,0 +1,45 @@
+---
+kind: pipeline
+name: compliance
+
+platform:
+  os: linux
+  arch: arm64
+
+trigger:
+  event:
+    - pull_request
+
+steps:
+  - name: check
+    pull: always
+    image: golang:1.14
+    environment:
+      GOPROXY: https://goproxy.cn
+    commands:
+      - make build
+      - make lint
+      - make vet
+
+---
+kind: pipeline
+name: build-master
+
+platform:
+  os: linux
+  arch: amd64
+
+trigger:
+  branch:
+    - master
+  event:
+    - push
+
+steps:
+  - name: build
+    pull: always
+    image: techknowlogick/xgo:latest
+    environment:
+      GOPROXY: https://goproxy.cn
+    commands:
+      - make build

vendor/code.gitea.io/gitea-vet/.gitignore

@@ -0,0 +1,5 @@
+# GoLand
+.idea/
+
+# Binaries
+/gitea-vet*

vendor/code.gitea.io/gitea-vet/.golangci.yml

@@ -0,0 +1,23 @@
+linters:
+  enable:
+    - deadcode
+    - dogsled
+    - dupl
+    - errcheck
+    - gocognit
+    - goconst
+    - gocritic
+    - gocyclo
+    - gofmt
+    - golint
+    - gosimple
+    - govet
+    - maligned
+    - misspell
+    - prealloc
+    - staticcheck
+    - structcheck
+    - typecheck
+    - unparam
+    - unused
+    - varcheck

vendor/code.gitea.io/gitea-vet/CHANGELOG.md

@@ -0,0 +1,6 @@
+## [0.2.0](https://gitea.com/gitea/gitea-vet/pulls?q=&type=all&state=closed&milestone=1272) - 2020-07-20
+
+* FEATURES
+  * Add migrations check (#5)
+* BUGFIXES
+  * Correct Import Paths (#6)

vendor/code.gitea.io/gitea-vet/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 The Gitea Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/code.gitea.io/gitea-vet/Makefile

@@ -0,0 +1,22 @@
+GO ?= go
+
+.PHONY: build
+build:
+	$(GO) build
+
+.PHONY: fmt
+fmt:
+	$(GO) fmt ./...
+
+.PHONY: vet
+vet: build
+	$(GO) vet ./...
+	$(GO) vet -vettool=gitea-vet ./...
+
+.PHONY: lint
+lint:
+	@hash golangci-lint > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		export BINARY="golangci-lint"; \
+		curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(shell $(GO) env GOPATH)/bin v1.24.0; \
+	fi
+	golangci-lint run --timeout 5m

vendor/code.gitea.io/gitea-vet/README.md

@@ -0,0 +1,11 @@
+# gitea-vet
+
+[![Build Status](https://drone.gitea.com/api/badges/gitea/gitea-vet/status.svg)](https://drone.gitea.com/gitea/gitea-vet)
+
+`go vet` tool for Gitea
+
+| Analyzer   | Description                                                                 |
+|------------|-----------------------------------------------------------------------------|
+| Imports    | Checks for import sorting. stdlib->code.gitea.io->other                     |
+| License    | Checks file headers for some form of `Copyright...YYYY...Gitea/Gogs`        |
+| Migrations | Checks for black-listed packages in `code.gitea.io/gitea/models/migrations` |

vendor/code.gitea.io/gitea-vet/checks/imports.go

@@ -0,0 +1,46 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package checks
+
+import (
+	"strings"
+
+	"golang.org/x/tools/go/analysis"
+)
+
+var Imports = &analysis.Analyzer{
+	Name: "imports",
+	Doc:  "check for import order",
+	Run:  runImports,
+}
+
+func runImports(pass *analysis.Pass) (interface{}, error) {
+	for _, file := range pass.Files {
+		level := 0
+		for _, im := range file.Imports {
+			var lvl int
+			val := im.Path.Value
+			switch {
+			case importHasPrefix(val, "code.gitea.io"):
+				lvl = 2
+			case strings.Contains(val, "."):
+				lvl = 3
+			default:
+				lvl = 1
+			}
+
+			if lvl < level {
+				pass.Reportf(file.Pos(), "Imports are sorted wrong")
+				break
+			}
+			level = lvl
+		}
+	}
+	return nil, nil
+}
+
+func importHasPrefix(s, p string) bool {
+	return strings.HasPrefix(s, "\""+p)
+}

vendor/code.gitea.io/gitea-vet/checks/license.go

@@ -0,0 +1,73 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package checks
+
+import (
+	"regexp"
+	"strings"
+
+	"golang.org/x/tools/go/analysis"
+)
+
+var (
+	header     = regexp.MustCompile(`.*Copyright.*\d{4}.*(Gitea|Gogs)`)
+	goGenerate = "//go:generate"
+	buildTag   = "// +build"
+)
+
+var License = &analysis.Analyzer{
+	Name: "license",
+	Doc:  "check for a copyright header",
+	Run:  runLicense,
+}
+
+func runLicense(pass *analysis.Pass) (interface{}, error) {
+	for _, file := range pass.Files {
+		if len(file.Comments) == 0 {
+			pass.Reportf(file.Pos(), "Copyright not found")
+			continue
+		}
+
+		if len(file.Comments[0].List) == 0 {
+			pass.Reportf(file.Pos(), "Copyright not found or wrong")
+			continue
+		}
+
+		commentGroup := 0
+		if strings.HasPrefix(file.Comments[0].List[0].Text, goGenerate) {
+			if len(file.Comments[0].List) > 1 {
+				pass.Reportf(file.Pos(), "Must be an empty line between the go:generate and the Copyright")
+				continue
+			}
+			commentGroup++
+		}
+
+		if strings.HasPrefix(file.Comments[0].List[0].Text, buildTag) {
+			commentGroup++
+		}
+
+		if len(file.Comments) < commentGroup+1 {
+			pass.Reportf(file.Pos(), "Copyright not found")
+			continue
+		}
+
+		if len(file.Comments[commentGroup].List) < 1 {
+			pass.Reportf(file.Pos(), "Copyright not found or wrong")
+			continue
+		}
+
+		var check bool
+		for _, comment := range file.Comments[commentGroup].List {
+			if header.MatchString(comment.Text) {
+				check = true
+			}
+		}
+
+		if !check {
+			pass.Reportf(file.Pos(), "Copyright did not match check")
+		}
+	}
+	return nil, nil
+}

vendor/code.gitea.io/gitea-vet/checks/migrations.go

@@ -0,0 +1,59 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package checks
+
+import (
+	"errors"
+	"os/exec"
+	"strings"
+
+	"golang.org/x/tools/go/analysis"
+)
+
+var Migrations = &analysis.Analyzer{
+	Name: "migrations",
+	Doc:  "check migrations for black-listed packages.",
+	Run:  checkMigrations,
+}
+
+var migrationBlacklist = []string{
+	"code.gitea.io/gitea/models",
+	"code.gitea.io/gitea/modules/structs",
+}
+
+func checkMigrations(pass *analysis.Pass) (interface{}, error) {
+	if !strings.EqualFold(pass.Pkg.Path(), "code.gitea.io/gitea/models/migrations") {
+		return nil, nil
+	}
+
+	if _, err := exec.LookPath("go"); err != nil {
+		return nil, errors.New("go was not found in the PATH")
+	}
+
+	depsCmd := exec.Command("go", "list", "-f", `{{join .Deps "\n"}}`, "code.gitea.io/gitea/models/migrations")
+	depsOut, err := depsCmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	deps := strings.Split(string(depsOut), "\n")
+	for _, dep := range deps {
+		if stringInSlice(dep, migrationBlacklist) {
+			pass.Reportf(0, "code.gitea.io/gitea/models/migrations cannot depend on the following packages: %s", migrationBlacklist)
+			return nil, nil
+		}
+	}
+
+	return nil, nil
+}
+
+func stringInSlice(needle string, haystack []string) bool {
+	for _, h := range haystack {
+		if strings.EqualFold(needle, h) {
+			return true
+		}
+	}
+	return false
+}

vendor/code.gitea.io/gitea-vet/go.mod

@@ -0,0 +1,5 @@
+module code.gitea.io/gitea-vet
+
+go 1.14
+
+require golang.org/x/tools v0.0.0-20200325010219-a49f79bcc224

vendor/code.gitea.io/gitea-vet/go.sum

@@ -0,0 +1,20 @@
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200325010219-a49f79bcc224 h1:azwY/v0y0K4mFHVsg5+UrTgchqALYWpqVo6vL5OmkmI=
+golang.org/x/tools v0.0.0-20200325010219-a49f79bcc224/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

vendor/code.gitea.io/gitea-vet/main.go

@@ -0,0 +1,19 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"code.gitea.io/gitea-vet/checks"
+
+	"golang.org/x/tools/go/analysis/unitchecker"
+)
+
+func main() {
+	unitchecker.Main(
+		checks.Imports,
+		checks.License,
+		checks.Migrations,
+	)
+}

vendor/code.gitea.io/sdk/gitea/admin_cron.go

@@ -0,0 +1,44 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"time"
+)
+
+// CronTask represents a Cron task
+type CronTask struct {
+	Name      string    `json:"name"`
+	Schedule  string    `json:"schedule"`
+	Next      time.Time `json:"next"`
+	Prev      time.Time `json:"prev"`
+	ExecTimes int64     `json:"exec_times"`
+}
+
+// ListCronTaskOptions list options for ListCronTasks
+type ListCronTaskOptions struct {
+	ListOptions
+}
+
+// ListCronTasks list available cron tasks
+func (c *Client) ListCronTasks(opt ListCronTaskOptions) ([]*CronTask, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	ct := make([]*CronTask, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/cron?%s", opt.getURLQuery().Encode()), jsonHeader, nil, &ct)
+	return ct, resp, err
+}
+
+// RunCronTasks run a cron task
+func (c *Client) RunCronTasks(task string) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/admin/cron/%s", task), jsonHeader, nil)
+	return resp, err
+}

vendor/code.gitea.io/sdk/gitea/admin_org.go

@@ -11,19 +11,26 @@ import (
 	"fmt"
 )
 
+// AdminListOrgsOptions options for listing admin's organizations
+type AdminListOrgsOptions struct {
+	ListOptions
+}
+
 // AdminListOrgs lists all orgs
-func (c *Client) AdminListOrgs() ([]*Organization, error) {
-	orgs := make([]*Organization, 0, 10)
-	return orgs, c.getParsedResponse("GET", "/admin/orgs", nil, nil, &orgs)
+func (c *Client) AdminListOrgs(opt AdminListOrgsOptions) ([]*Organization, *Response, error) {
+	opt.setDefaults()
+	orgs := make([]*Organization, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
 }
 
 // AdminCreateOrg create an organization
-func (c *Client) AdminCreateOrg(user string, opt CreateOrgOption) (*Organization, error) {
+func (c *Client) AdminCreateOrg(user string, opt CreateOrgOption) (*Organization, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	org := new(Organization)
-	return org, c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/orgs", user),
-		jsonHeader, bytes.NewReader(body), org)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/orgs", user), jsonHeader, bytes.NewReader(body), org)
+	return org, resp, err
 }

vendor/code.gitea.io/sdk/gitea/admin_repo.go

@@ -11,12 +11,12 @@ import (
 )
 
 // AdminCreateRepo create a repo
-func (c *Client) AdminCreateRepo(user string, opt CreateRepoOption) (*Repository, error) {
+func (c *Client) AdminCreateRepo(user string, opt CreateRepoOption) (*Repository, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/repos", user),
-		jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/repos", user), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }

vendor/code.gitea.io/sdk/gitea/admin_user.go

@@ -11,10 +11,17 @@ import (
 	"fmt"
 )
 
+// AdminListUsersOptions options for listing admin users
+type AdminListUsersOptions struct {
+	ListOptions
+}
+
 // AdminListUsers lists all users
-func (c *Client) AdminListUsers() ([]*User, error) {
-	users := make([]*User, 0, 10)
-	return users, c.getParsedResponse("GET", "/admin/users", nil, nil, &users)
+func (c *Client) AdminListUsers(opt AdminListUsersOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/users?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // CreateUserOption create user options
@@ -29,14 +36,29 @@ type CreateUserOption struct {
 	SendNotify         bool   `json:"send_notify"`
 }
 
+// Validate the CreateUserOption struct
+func (opt CreateUserOption) Validate() error {
+	if len(opt.Email) == 0 {
+		return fmt.Errorf("email is empty")
+	}
+	if len(opt.Username) == 0 {
+		return fmt.Errorf("username is empty")
+	}
+	return nil
+}
+
 // AdminCreateUser create a user
-func (c *Client) AdminCreateUser(opt CreateUserOption) (*User, error) {
+func (c *Client) AdminCreateUser(opt CreateUserOption) (*User, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	user := new(User)
-	return user, c.getParsedResponse("POST", "/admin/users", jsonHeader, bytes.NewReader(body), user)
+	resp, err := c.getParsedResponse("POST", "/admin/users", jsonHeader, bytes.NewReader(body), user)
+	return user, resp, err
 }
 
 // EditUserOption edit user options
@@ -59,33 +81,34 @@ type EditUserOption struct {
 }
 
 // AdminEditUser modify user informations
-func (c *Client) AdminEditUser(user string, opt EditUserOption) error {
-	body, err := json.Marshal(&opt)
-	if err != nil {
-		return err
-	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/admin/users/%s", user), jsonHeader, bytes.NewReader(body))
-	return err
-}
-
-// AdminDeleteUser delete one user according name
-func (c *Client) AdminDeleteUser(user string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s", user), nil, nil)
-	return err
-}
-
-// AdminCreateUserPublicKey adds a public key for the user
-func (c *Client) AdminCreateUserPublicKey(user string, opt CreateKeyOption) (*PublicKey, error) {
+func (c *Client) AdminEditUser(user string, opt EditUserOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
 		return nil, err
 	}
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/admin/users/%s", user), jsonHeader, bytes.NewReader(body))
+	return resp, err
+}
+
+// AdminDeleteUser delete one user according name
+func (c *Client) AdminDeleteUser(user string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s", user), nil, nil)
+	return resp, err
+}
+
+// AdminCreateUserPublicKey adds a public key for the user
+func (c *Client) AdminCreateUserPublicKey(user string, opt CreateKeyOption) (*PublicKey, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
 	key := new(PublicKey)
-	return key, c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/keys", user), jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/keys", user), jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // AdminDeleteUserPublicKey deletes a user's public key
-func (c *Client) AdminDeleteUserPublicKey(user string, keyID int) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s/keys/%d", user, keyID), nil, nil)
-	return err
+func (c *Client) AdminDeleteUserPublicKey(user string, keyID int) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s/keys/%d", user, keyID), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/attachment.go

@@ -24,47 +24,53 @@ type Attachment struct {
 	DownloadURL   string    `json:"browser_download_url"`
 }
 
+// ListReleaseAttachmentsOptions options for listing release's attachments
+type ListReleaseAttachmentsOptions struct {
+	ListOptions
+}
+
 // ListReleaseAttachments list release's attachments
-func (c *Client) ListReleaseAttachments(user, repo string, release int64) ([]*Attachment, error) {
-	attachments := make([]*Attachment, 0, 10)
-	err := c.getParsedResponse("GET",
-		fmt.Sprintf("/repos/%s/%s/releases/%d/assets", user, repo, release),
+func (c *Client) ListReleaseAttachments(user, repo string, release int64, opt ListReleaseAttachmentsOptions) ([]*Attachment, *Response, error) {
+	opt.setDefaults()
+	attachments := make([]*Attachment, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases/%d/assets?%s", user, repo, release, opt.getURLQuery().Encode()),
 		nil, nil, &attachments)
-	return attachments, err
+	return attachments, resp, err
 }
 
 // GetReleaseAttachment returns the requested attachment
-func (c *Client) GetReleaseAttachment(user, repo string, release int64, id int64) (*Attachment, error) {
+func (c *Client) GetReleaseAttachment(user, repo string, release int64, id int64) (*Attachment, *Response, error) {
 	a := new(Attachment)
-	err := c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id),
 		nil, nil, &a)
-	return a, err
+	return a, resp, err
 }
 
 // CreateReleaseAttachment creates an attachment for the given release
-func (c *Client) CreateReleaseAttachment(user, repo string, release int64, file io.Reader, filename string) (*Attachment, error) {
+func (c *Client) CreateReleaseAttachment(user, repo string, release int64, file io.Reader, filename string) (*Attachment, *Response, error) {
 	// Write file to body
 	body := new(bytes.Buffer)
 	writer := multipart.NewWriter(body)
 	part, err := writer.CreateFormFile("attachment", filename)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if _, err = io.Copy(part, file); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if err = writer.Close(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	// Send request
 	attachment := new(Attachment)
-	err = c.getParsedResponse("POST",
+	resp, err := c.getParsedResponse("POST",
 		fmt.Sprintf("/repos/%s/%s/releases/%d/assets", user, repo, release),
 		http.Header{"Content-Type": {writer.FormDataContentType()}}, body, &attachment)
-	return attachment, err
+	return attachment, resp, err
 }
 
 // EditAttachmentOptions options for editing attachments
@@ -73,17 +79,18 @@ type EditAttachmentOptions struct {
 }
 
 // EditReleaseAttachment updates the given attachment with the given options
-func (c *Client) EditReleaseAttachment(user, repo string, release int64, attachment int64, form EditAttachmentOptions) (*Attachment, error) {
+func (c *Client) EditReleaseAttachment(user, repo string, release int64, attachment int64, form EditAttachmentOptions) (*Attachment, *Response, error) {
 	body, err := json.Marshal(&form)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	attach := new(Attachment)
-	return attach, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, attachment), jsonHeader, bytes.NewReader(body), attach)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, attachment), jsonHeader, bytes.NewReader(body), attach)
+	return attach, resp, err
 }
 
 // DeleteReleaseAttachment deletes the given attachment including the uploaded file
-func (c *Client) DeleteReleaseAttachment(user, repo string, release int64, id int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id), nil, nil)
-	return err
+func (c *Client) DeleteReleaseAttachment(user, repo string, release int64, id int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/client.go

@@ -1,10 +1,12 @@
 // Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2020 The Gitea Authors. All rights reserved.
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 
 package gitea
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -12,36 +14,108 @@ import (
 	"io/ioutil"
 	"net/http"
 	"strings"
+	"sync"
+
+	"github.com/hashicorp/go-version"
 )
 
 var jsonHeader = http.Header{"content-type": []string{"application/json"}}
 
 // Version return the library version
 func Version() string {
-	return "0.12.3"
+	return "0.13.0"
 }
 
-// Client represents a Gogs API client.
+// Client represents a Gitea API client.
 type Client struct {
 	url           string
 	accessToken   string
+	username      string
+	password      string
+	otp           string
 	sudo          string
 	client        *http.Client
+	ctx           context.Context
+	serverVersion *version.Version
+	versionLock   sync.RWMutex
+}
+
+// Response represents the gitea response
+type Response struct {
+	*http.Response
 }
 
 // NewClient initializes and returns a API client.
-func NewClient(url, token string) *Client {
-	return &Client{
+func NewClient(url string, options ...func(*Client)) (*Client, error) {
+	client := &Client{
 		url:    strings.TrimSuffix(url, "/"),
-		accessToken: token,
 		client: &http.Client{},
+		ctx:    context.Background(),
 	}
+	for _, opt := range options {
+		opt(client)
+	}
+	if err := client.CheckServerVersionConstraint(">=1.10"); err != nil {
+		return nil, err
+	}
+	return client, nil
 }
 
 // NewClientWithHTTP creates an API client with a custom http client
-func NewClientWithHTTP(url string, httpClient *http.Client) {
-	client := NewClient(url, "")
+// Deprecated use SetHTTPClient option
+func NewClientWithHTTP(url string, httpClient *http.Client) *Client {
+	client, _ := NewClient(url, SetHTTPClient(httpClient))
+	return client
+}
+
+// SetHTTPClient is an option for NewClient to set custom http client
+func SetHTTPClient(httpClient *http.Client) func(client *Client) {
+	return func(client *Client) {
 		client.client = httpClient
+	}
+}
+
+// SetToken is an option for NewClient to set token
+func SetToken(token string) func(client *Client) {
+	return func(client *Client) {
+		client.accessToken = token
+	}
+}
+
+// SetBasicAuth is an option for NewClient to set username and password
+func SetBasicAuth(username, password string) func(client *Client) {
+	return func(client *Client) {
+		client.SetBasicAuth(username, password)
+	}
+}
+
+// SetBasicAuth sets username and password
+func (c *Client) SetBasicAuth(username, password string) {
+	c.username, c.password = username, password
+}
+
+// SetOTP is an option for NewClient to set OTP for 2FA
+func SetOTP(otp string) func(client *Client) {
+	return func(client *Client) {
+		client.SetOTP(otp)
+	}
+}
+
+// SetOTP sets OTP for 2FA
+func (c *Client) SetOTP(otp string) {
+	c.otp = otp
+}
+
+// SetContext is an option for NewClient to set context
+func SetContext(ctx context.Context) func(client *Client) {
+	return func(client *Client) {
+		client.SetContext(ctx)
+	}
+}
+
+// SetContext set context witch is used for http requests
+func (c *Client) SetContext(ctx context.Context) {
+	c.ctx = ctx
 }
 
 // SetHTTPClient replaces default http.Client with user given one.
@@ -49,50 +123,82 @@ func (c *Client) SetHTTPClient(client *http.Client) {
 	c.client = client
 }
 
+// SetSudo is an option for NewClient to set sudo header
+func SetSudo(sudo string) func(client *Client) {
+	return func(client *Client) {
+		client.SetSudo(sudo)
+	}
+}
+
 // SetSudo sets username to impersonate.
 func (c *Client) SetSudo(sudo string) {
 	c.sudo = sudo
 }
 
-func (c *Client) doRequest(method, path string, header http.Header, body io.Reader) (*http.Response, error) {
-	req, err := http.NewRequest(method, c.url+"/api/v1"+path, body)
+func (c *Client) getWebResponse(method, path string, body io.Reader) ([]byte, *Response, error) {
+	req, err := http.NewRequestWithContext(c.ctx, method, c.url+path, body)
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	defer resp.Body.Close()
+	data, err := ioutil.ReadAll(resp.Body)
+	return data, &Response{resp}, nil
+}
+
+func (c *Client) doRequest(method, path string, header http.Header, body io.Reader) (*Response, error) {
+	req, err := http.NewRequestWithContext(c.ctx, method, c.url+"/api/v1"+path, body)
 	if err != nil {
 		return nil, err
 	}
 	if len(c.accessToken) != 0 {
 		req.Header.Set("Authorization", "token "+c.accessToken)
 	}
-	if c.sudo != "" {
+	if len(c.otp) != 0 {
+		req.Header.Set("X-GITEA-OTP", c.otp)
+	}
+	if len(c.username) != 0 {
+		req.SetBasicAuth(c.username, c.password)
+	}
+	if len(c.sudo) != 0 {
 		req.Header.Set("Sudo", c.sudo)
 	}
 	for k, v := range header {
 		req.Header[k] = v
 	}
 
-	return c.client.Do(req)
-}
-
-func (c *Client) getResponse(method, path string, header http.Header, body io.Reader) ([]byte, error) {
-	resp, err := c.doRequest(method, path, header, body)
+	resp, err := c.client.Do(req)
 	if err != nil {
 		return nil, err
 	}
+	return &Response{resp}, nil
+}
+
+func (c *Client) getResponse(method, path string, header http.Header, body io.Reader) ([]byte, *Response, error) {
+	resp, err := c.doRequest(method, path, header, body)
+	if err != nil {
+		return nil, nil, err
+	}
 	defer resp.Body.Close()
 
 	data, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
 
 	switch resp.StatusCode {
 	case 403:
-		return nil, errors.New("403 Forbidden")
+		return data, resp, errors.New("403 Forbidden")
 	case 404:
-		return nil, errors.New("404 Not Found")
+		return data, resp, errors.New("404 Not Found")
 	case 409:
-		return nil, errors.New("409 Conflict")
+		return data, resp, errors.New("409 Conflict")
 	case 422:
-		return nil, fmt.Errorf("422 Unprocessable Entity: %s", string(data))
+		return data, resp, fmt.Errorf("422 Unprocessable Entity: %s", string(data))
 	}
 
 	if resp.StatusCode/100 != 2 {
@@ -100,28 +206,28 @@ func (c *Client) getResponse(method, path string, header http.Header, body io.Re
 		if err = json.Unmarshal(data, &errMap); err != nil {
 			// when the JSON can't be parsed, data was probably empty or a plain string,
 			// so we try to return a helpful error anyway
-			return nil, fmt.Errorf("Unknown API Error: %d %s", resp.StatusCode, string(data))
+			return data, resp, fmt.Errorf("Unknown API Error: %d\nRequest: '%s' with '%s' method '%s' header and '%s' body", resp.StatusCode, path, method, header, string(data))
 		}
-		return nil, errors.New(errMap["message"].(string))
+		return data, resp, errors.New(errMap["message"].(string))
 	}
 
-	return data, nil
+	return data, resp, nil
 }
 
-func (c *Client) getParsedResponse(method, path string, header http.Header, body io.Reader, obj interface{}) error {
-	data, err := c.getResponse(method, path, header, body)
+func (c *Client) getParsedResponse(method, path string, header http.Header, body io.Reader, obj interface{}) (*Response, error) {
+	data, resp, err := c.getResponse(method, path, header, body)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	return json.Unmarshal(data, obj)
+	return resp, json.Unmarshal(data, obj)
 }
 
-func (c *Client) getStatusCode(method, path string, header http.Header, body io.Reader) (int, error) {
+func (c *Client) getStatusCode(method, path string, header http.Header, body io.Reader) (int, *Response, error) {
 	resp, err := c.doRequest(method, path, header, body)
 	if err != nil {
-		return -1, err
+		return -1, resp, err
 	}
 	defer resp.Body.Close()
 
-	return resp.StatusCode, nil
+	return resp.StatusCode, resp, nil
 }

vendor/code.gitea.io/sdk/gitea/fork.go

@@ -10,13 +10,19 @@ import (
 	"fmt"
 )
 
+// ListForksOptions options for listing repository's forks
+type ListForksOptions struct {
+	ListOptions
+}
+
 // ListForks list a repository's forks
-func (c *Client) ListForks(user, repo string) ([]*Repository, error) {
-	forks := make([]*Repository, 10)
-	err := c.getParsedResponse("GET",
-		fmt.Sprintf("/repos/%s/%s/forks", user, repo),
+func (c *Client) ListForks(user string, repo string, opt ListForksOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	forks := make([]*Repository, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/forks?%s", user, repo, opt.getURLQuery().Encode()),
 		nil, nil, &forks)
-	return forks, err
+	return forks, resp, err
 }
 
 // CreateForkOption options for creating a fork
@@ -26,14 +32,12 @@ type CreateForkOption struct {
 }
 
 // CreateFork create a fork of a repository
-func (c *Client) CreateFork(user, repo string, form CreateForkOption) (*Repository, error) {
+func (c *Client) CreateFork(user, repo string, form CreateForkOption) (*Repository, *Response, error) {
 	body, err := json.Marshal(form)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	fork := new(Repository)
-	err = c.getParsedResponse("POST",
-		fmt.Sprintf("/repos/%s/%s/forks", user, repo),
-		jsonHeader, bytes.NewReader(body), &fork)
-	return fork, err
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/forks", user, repo), jsonHeader, bytes.NewReader(body), &fork)
+	return fork, resp, err
 }

vendor/code.gitea.io/sdk/gitea/git_blob.go

@@ -0,0 +1,25 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+)
+
+// GitBlobResponse represents a git blob
+type GitBlobResponse struct {
+	Content  string `json:"content"`
+	Encoding string `json:"encoding"`
+	URL      string `json:"url"`
+	SHA      string `json:"sha"`
+	Size     int64  `json:"size"`
+}
+
+// GetBlob get the blob of a repository file
+func (c *Client) GetBlob(user, repo, sha string) (*GitBlobResponse, *Response, error) {
+	blob := new(GitBlobResponse)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/blobs/%s", user, repo, sha), nil, nil, blob)
+	return blob, resp, err
+}

vendor/code.gitea.io/sdk/gitea/git_hook.go

@@ -17,16 +17,24 @@ type GitHook struct {
 	Content  string `json:"content,omitempty"`
 }
 
+// ListRepoGitHooksOptions options for listing repository's githooks
+type ListRepoGitHooksOptions struct {
+	ListOptions
+}
+
 // ListRepoGitHooks list all the Git hooks of one repository
-func (c *Client) ListRepoGitHooks(user, repo string) ([]*GitHook, error) {
-	hooks := make([]*GitHook, 0, 10)
-	return hooks, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git", user, repo), nil, nil, &hooks)
+func (c *Client) ListRepoGitHooks(user, repo string, opt ListRepoGitHooksOptions) ([]*GitHook, *Response, error) {
+	opt.setDefaults()
+	hooks := make([]*GitHook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
 }
 
 // GetRepoGitHook get a Git hook of a repository
-func (c *Client) GetRepoGitHook(user, repo, id string) (*GitHook, error) {
+func (c *Client) GetRepoGitHook(user, repo, id string) (*GitHook, *Response, error) {
 	h := new(GitHook)
-	return h, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil, h)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil, h)
+	return h, resp, err
 }
 
 // EditGitHookOption options when modifying one Git hook
@@ -35,17 +43,17 @@ type EditGitHookOption struct {
 }
 
 // EditRepoGitHook modify one Git hook of a repository
-func (c *Client) EditRepoGitHook(user, repo, id string, opt EditGitHookOption) error {
+func (c *Client) EditRepoGitHook(user, repo, id string, opt EditGitHookOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), jsonHeader, bytes.NewReader(body))
-	return err
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), jsonHeader, bytes.NewReader(body))
+	return resp, err
 }
 
 // DeleteRepoGitHook delete one Git hook from a repository
-func (c *Client) DeleteRepoGitHook(user, repo, id string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil)
-	return err
+func (c *Client) DeleteRepoGitHook(user, repo, id string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/go.mod

@@ -1,3 +1,8 @@
 module code.gitea.io/sdk/gitea
 
 go 1.12
+
+require (
+	github.com/hashicorp/go-version v1.2.0
+	github.com/stretchr/testify v1.4.0
+)

vendor/code.gitea.io/sdk/gitea/go.sum

@@ -0,0 +1,13 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/hashicorp/go-version v1.2.0 h1:3vNe/fWF5CBgRIguda1meWhsZHy3m8gCJ5wx+dIzX/E=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

vendor/code.gitea.io/sdk/gitea/hook.go

@@ -24,28 +24,39 @@ type Hook struct {
 	Created time.Time         `json:"created_at"`
 }
 
+// ListHooksOptions options for listing hooks
+type ListHooksOptions struct {
+	ListOptions
+}
+
 // ListOrgHooks list all the hooks of one organization
-func (c *Client) ListOrgHooks(org string) ([]*Hook, error) {
-	hooks := make([]*Hook, 0, 10)
-	return hooks, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks", org), nil, nil, &hooks)
+func (c *Client) ListOrgHooks(org string, opt ListHooksOptions) ([]*Hook, *Response, error) {
+	opt.setDefaults()
+	hooks := make([]*Hook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks?%s", org, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
 }
 
 // ListRepoHooks list all the hooks of one repository
-func (c *Client) ListRepoHooks(user, repo string) ([]*Hook, error) {
-	hooks := make([]*Hook, 0, 10)
-	return hooks, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks", user, repo), nil, nil, &hooks)
+func (c *Client) ListRepoHooks(user, repo string, opt ListHooksOptions) ([]*Hook, *Response, error) {
+	opt.setDefaults()
+	hooks := make([]*Hook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
 }
 
 // GetOrgHook get a hook of an organization
-func (c *Client) GetOrgHook(org string, id int64) (*Hook, error) {
+func (c *Client) GetOrgHook(org string, id int64) (*Hook, *Response, error) {
 	h := new(Hook)
-	return h, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil, h)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil, h)
+	return h, resp, err
 }
 
 // GetRepoHook get a hook of a repository
-func (c *Client) GetRepoHook(user, repo string, id int64) (*Hook, error) {
+func (c *Client) GetRepoHook(user, repo string, id int64) (*Hook, *Response, error) {
 	h := new(Hook)
-	return h, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil, h)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil, h)
+	return h, resp, err
 }
 
 // CreateHookOption options when create a hook
@@ -57,24 +68,37 @@ type CreateHookOption struct {
 	Active       bool              `json:"active"`
 }
 
+// Validate the CreateHookOption struct
+func (opt CreateHookOption) Validate() error {
+	if len(opt.Type) == 0 {
+		return fmt.Errorf("hook type needed")
+	}
+	return nil
+}
+
 // CreateOrgHook create one hook for an organization, with options
-func (c *Client) CreateOrgHook(org string, opt CreateHookOption) (*Hook, error) {
+func (c *Client) CreateOrgHook(org string, opt CreateHookOption) (*Hook, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	h := new(Hook)
-	return h, c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/hooks", org), jsonHeader, bytes.NewReader(body), h)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/hooks", org), jsonHeader, bytes.NewReader(body), h)
+	return h, resp, err
 }
 
 // CreateRepoHook create one hook for a repository, with options
-func (c *Client) CreateRepoHook(user, repo string, opt CreateHookOption) (*Hook, error) {
+func (c *Client) CreateRepoHook(user, repo string, opt CreateHookOption) (*Hook, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	h := new(Hook)
-	return h, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/hooks", user, repo), jsonHeader, bytes.NewReader(body), h)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/hooks", user, repo), jsonHeader, bytes.NewReader(body), h)
+	return h, resp, err
 }
 
 // EditHookOption options when modify one hook
@@ -86,33 +110,33 @@ type EditHookOption struct {
 }
 
 // EditOrgHook modify one hook of an organization, with hook id and options
-func (c *Client) EditOrgHook(org string, id int64, opt EditHookOption) error {
+func (c *Client) EditOrgHook(org string, id int64, opt EditHookOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), jsonHeader, bytes.NewReader(body))
-	return err
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), jsonHeader, bytes.NewReader(body))
+	return resp, err
 }
 
 // EditRepoHook modify one hook of a repository, with hook id and options
-func (c *Client) EditRepoHook(user, repo string, id int64, opt EditHookOption) error {
+func (c *Client) EditRepoHook(user, repo string, id int64, opt EditHookOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), jsonHeader, bytes.NewReader(body))
-	return err
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), jsonHeader, bytes.NewReader(body))
+	return resp, err
 }
 
 // DeleteOrgHook delete one hook from an organization, with hook id
-func (c *Client) DeleteOrgHook(org string, id int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil)
-	return err
+func (c *Client) DeleteOrgHook(org string, id int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil)
+	return resp, err
 }
 
 // DeleteRepoHook delete one hook from a repository, with hook id
-func (c *Client) DeleteRepoHook(user, repo string, id int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil)
-	return err
+func (c *Client) DeleteRepoHook(user, repo string, id int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/issue.go

@@ -9,6 +9,8 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net/url"
+	"strings"
 	"time"
 )
 
@@ -18,6 +20,14 @@ type PullRequestMeta struct {
 	Merged    *time.Time `json:"merged_at"`
 }
 
+// RepositoryMeta basic repository information
+type RepositoryMeta struct {
+	ID       int64  `json:"id"`
+	Name     string `json:"name"`
+	Owner    string `json:"owner"`
+	FullName string `json:"full_name"`
+}
+
 // Issue represents an issue in a repository
 type Issue struct {
 	ID               int64      `json:"id"`
@@ -34,42 +44,119 @@ type Issue struct {
 	Assignees        []*User    `json:"assignees"`
 	// Whether the issue is open or closed
 	State       StateType        `json:"state"`
+	IsLocked    bool             `json:"is_locked"`
 	Comments    int              `json:"comments"`
 	Created     time.Time        `json:"created_at"`
 	Updated     time.Time        `json:"updated_at"`
 	Closed      *time.Time       `json:"closed_at"`
 	Deadline    *time.Time       `json:"due_date"`
 	PullRequest *PullRequestMeta `json:"pull_request"`
+	Repository  *RepositoryMeta  `json:"repository"`
 }
 
 // ListIssueOption list issue options
 type ListIssueOption struct {
-	Page  int
-	State string
+	ListOptions
+	State      StateType
+	Type       IssueType
+	Labels     []string
+	Milestones []string
+	KeyWord    string
+}
+
+// StateType issue state type
+type StateType string
+
+const (
+	// StateOpen pr/issue is opend
+	StateOpen StateType = "open"
+	// StateClosed pr/issue is closed
+	StateClosed StateType = "closed"
+	// StateAll is all
+	StateAll StateType = "all"
+)
+
+// IssueType is issue a pull or only an issue
+type IssueType string
+
+const (
+	// IssueTypeAll pr and issue
+	IssueTypeAll IssueType = ""
+	// IssueTypeIssue only issues
+	IssueTypeIssue IssueType = "issues"
+	// IssueTypePull only pulls
+	IssueTypePull IssueType = "pulls"
+)
+
+// QueryEncode turns options into querystring argument
+func (opt *ListIssueOption) QueryEncode() string {
+	query := opt.getURLQuery()
+
+	if len(opt.State) > 0 {
+		query.Add("state", string(opt.State))
+	}
+
+	if len(opt.Labels) > 0 {
+		query.Add("labels", strings.Join(opt.Labels, ","))
+	}
+
+	if len(opt.KeyWord) > 0 {
+		query.Add("q", opt.KeyWord)
+	}
+
+	query.Add("type", string(opt.Type))
+
+	if len(opt.Milestones) > 0 {
+		query.Add("milestones", strings.Join(opt.Milestones, ","))
+	}
+
+	return query.Encode()
 }
 
 // ListIssues returns all issues assigned the authenticated user
-func (c *Client) ListIssues(opt ListIssueOption) ([]*Issue, error) {
-	issues := make([]*Issue, 0, 10)
-	return issues, c.getParsedResponse("GET", fmt.Sprintf("/issues?page=%d", opt.Page), nil, nil, &issues)
-}
+func (c *Client) ListIssues(opt ListIssueOption) ([]*Issue, *Response, error) {
+	opt.setDefaults()
+	issues := make([]*Issue, 0, opt.PageSize)
 
-// ListUserIssues returns all issues assigned to the authenticated user
-func (c *Client) ListUserIssues(opt ListIssueOption) ([]*Issue, error) {
-	issues := make([]*Issue, 0, 10)
-	return issues, c.getParsedResponse("GET", fmt.Sprintf("/user/issues?page=%d", opt.Page), nil, nil, &issues)
+	link, _ := url.Parse("/repos/issues/search")
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
+		for i := 0; i < len(issues); i++ {
+			if issues[i].Repository != nil {
+				issues[i].Repository.Owner = strings.Split(issues[i].Repository.FullName, "/")[0]
+			}
+		}
+	}
+	return issues, resp, err
 }
 
 // ListRepoIssues returns all issues for a given repository
-func (c *Client) ListRepoIssues(owner, repo string, opt ListIssueOption) ([]*Issue, error) {
-	issues := make([]*Issue, 0, 10)
-	return issues, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues?page=%d", owner, repo, opt.Page), nil, nil, &issues)
+func (c *Client) ListRepoIssues(owner, repo string, opt ListIssueOption) ([]*Issue, *Response, error) {
+	opt.setDefaults()
+	issues := make([]*Issue, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
+		for i := 0; i < len(issues); i++ {
+			if issues[i].Repository != nil {
+				issues[i].Repository.Owner = strings.Split(issues[i].Repository.FullName, "/")[0]
+			}
+		}
+	}
+	return issues, resp, err
 }
 
 // GetIssue returns a single issue for a given repository
-func (c *Client) GetIssue(owner, repo string, index int64) (*Issue, error) {
+func (c *Client) GetIssue(owner, repo string, index int64) (*Issue, *Response, error) {
 	issue := new(Issue)
-	return issue, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index), nil, nil, issue)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index), nil, nil, issue)
+	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil && issue.Repository != nil {
+		issue.Repository.Owner = strings.Split(issue.Repository.FullName, "/")[0]
+	}
+	return issue, resp, err
 }
 
 // CreateIssueOption options to create one issue
@@ -87,15 +174,27 @@ type CreateIssueOption struct {
 	Closed bool    `json:"closed"`
 }
 
+// Validate the CreateIssueOption struct
+func (opt CreateIssueOption) Validate() error {
+	if len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
 // CreateIssue create a new issue for a given repository
-func (c *Client) CreateIssue(owner, repo string, opt CreateIssueOption) (*Issue, error) {
+func (c *Client) CreateIssue(owner, repo string, opt CreateIssueOption) (*Issue, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	issue := new(Issue)
-	return issue, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues", owner, repo),
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues", owner, repo),
 		jsonHeader, bytes.NewReader(body), issue)
+	return issue, resp, err
 }
 
 // EditIssueOption options for editing an issue
@@ -105,33 +204,30 @@ type EditIssueOption struct {
 	Assignee  *string    `json:"assignee"`
 	Assignees []string   `json:"assignees"`
 	Milestone *int64     `json:"milestone"`
-	State     *string    `json:"state"`
+	State     *StateType `json:"state"`
 	Deadline  *time.Time `json:"due_date"`
 }
 
+// Validate the EditIssueOption struct
+func (opt EditIssueOption) Validate() error {
+	if len(opt.Title) != 0 && len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
 // EditIssue modify an existing issue for a given repository
-func (c *Client) EditIssue(owner, repo string, index int64, opt EditIssueOption) (*Issue, error) {
+func (c *Client) EditIssue(owner, repo string, index int64, opt EditIssueOption) (*Issue, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	issue := new(Issue)
-	return issue, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index),
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), issue)
-}
-
-// StartIssueStopWatch starts a stopwatch for an existing issue for a given
-// repository
-func (c *Client) StartIssueStopWatch(owner, repo string, index int64) error {
-	_, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/start", owner, repo, index),
-		jsonHeader, nil)
-	return err
-}
-
-// StopIssueStopWatch stops an existing stopwatch for an issue in a given
-// repository
-func (c *Client) StopIssueStopWatch(owner, repo string, index int64) error {
-	_, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/stop", owner, repo, index),
-		jsonHeader, nil)
-	return err
+	return issue, resp, err
 }

vendor/code.gitea.io/sdk/gitea/issue_comment.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net/url"
 	"time"
 )
 
@@ -25,16 +26,53 @@ type Comment struct {
 	Updated          time.Time `json:"updated_at"`
 }
 
+// ListIssueCommentOptions list comment options
+type ListIssueCommentOptions struct {
+	ListOptions
+	Since  time.Time
+	Before time.Time
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListIssueCommentOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if !opt.Since.IsZero() {
+		query.Add("since", opt.Since.Format(time.RFC3339))
+	}
+	if !opt.Before.IsZero() {
+		query.Add("before", opt.Before.Format(time.RFC3339))
+	}
+	return query.Encode()
+}
+
 // ListIssueComments list comments on an issue.
-func (c *Client) ListIssueComments(owner, repo string, index int64) ([]*Comment, error) {
-	comments := make([]*Comment, 0, 10)
-	return comments, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), nil, nil, &comments)
+func (c *Client) ListIssueComments(owner, repo string, index int64, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
+	opt.setDefaults()
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index))
+	link.RawQuery = opt.QueryEncode()
+	comments := make([]*Comment, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	return comments, resp, err
 }
 
 // ListRepoIssueComments list comments for a given repo.
-func (c *Client) ListRepoIssueComments(owner, repo string) ([]*Comment, error) {
-	comments := make([]*Comment, 0, 10)
-	return comments, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments", owner, repo), nil, nil, &comments)
+func (c *Client) ListRepoIssueComments(owner, repo string, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
+	opt.setDefaults()
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/comments", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	comments := make([]*Comment, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	return comments, resp, err
+}
+
+// GetIssueComment get a comment for a given repo by id.
+func (c *Client) GetIssueComment(owner, repo string, id int64) (*Comment, *Response, error) {
+	comment := new(Comment)
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return comment, nil, err
+	}
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, id), nil, nil, &comment)
+	return comment, resp, err
 }
 
 // CreateIssueCommentOption options for creating a comment on an issue
@@ -42,14 +80,26 @@ type CreateIssueCommentOption struct {
 	Body string `json:"body"`
 }
 
+// Validate the CreateIssueCommentOption struct
+func (opt CreateIssueCommentOption) Validate() error {
+	if len(opt.Body) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	return nil
+}
+
 // CreateIssueComment create comment on an issue.
-func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, error) {
+func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	comment := new(Comment)
-	return comment, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), jsonHeader, bytes.NewReader(body), comment)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), jsonHeader, bytes.NewReader(body), comment)
+	return comment, resp, err
 }
 
 // EditIssueCommentOption options for editing a comment
@@ -57,18 +107,30 @@ type EditIssueCommentOption struct {
 	Body string `json:"body"`
 }
 
+// Validate the EditIssueCommentOption struct
+func (opt EditIssueCommentOption) Validate() error {
+	if len(opt.Body) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	return nil
+}
+
 // EditIssueComment edits an issue comment.
-func (c *Client) EditIssueComment(owner, repo string, commentID int64, opt EditIssueCommentOption) (*Comment, error) {
+func (c *Client) EditIssueComment(owner, repo string, commentID int64, opt EditIssueCommentOption) (*Comment, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	comment := new(Comment)
-	return comment, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), jsonHeader, bytes.NewReader(body), comment)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), jsonHeader, bytes.NewReader(body), comment)
+	return comment, resp, err
 }
 
 // DeleteIssueComment deletes an issue comment.
-func (c *Client) DeleteIssueComment(owner, repo string, commentID int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), nil, nil)
-	return err
+func (c *Client) DeleteIssueComment(owner, repo string, commentID int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/issue_label.go

@@ -8,6 +8,8 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"regexp"
+	"strings"
 )
 
 // Label a label to an issue or a pr
@@ -20,17 +22,24 @@ type Label struct {
 	URL         string `json:"url"`
 }
 
+// ListLabelsOptions options for listing repository's labels
+type ListLabelsOptions struct {
+	ListOptions
+}
+
 // ListRepoLabels list labels of one repository
-func (c *Client) ListRepoLabels(owner, repo string) ([]*Label, error) {
-	labels := make([]*Label, 0, 10)
-	return labels, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels", owner, repo), nil, nil, &labels)
+func (c *Client) ListRepoLabels(owner, repo string, opt ListLabelsOptions) ([]*Label, *Response, error) {
+	opt.setDefaults()
+	labels := make([]*Label, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels?%s", owner, repo, opt.getURLQuery().Encode()), nil, nil, &labels)
+	return labels, resp, err
 }
 
 // GetRepoLabel get one label of repository by repo it
-// TODO: maybe we need get a label by name
-func (c *Client) GetRepoLabel(owner, repo string, id int64) (*Label, error) {
+func (c *Client) GetRepoLabel(owner, repo string, id int64) (*Label, *Response, error) {
 	label := new(Label)
-	return label, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil, label)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil, label)
+	return label, resp, err
 }
 
 // CreateLabelOption options for creating a label
@@ -41,15 +50,40 @@ type CreateLabelOption struct {
 	Description string `json:"description"`
 }
 
+// Validate the CreateLabelOption struct
+func (opt CreateLabelOption) Validate() error {
+	aw, err := regexp.MatchString("^#?[0-9,a-f,A-F]{6}$", opt.Color)
+	if err != nil {
+		return err
+	}
+	if !aw {
+		return fmt.Errorf("invalid color format")
+	}
+	if len(strings.TrimSpace(opt.Name)) == 0 {
+		return fmt.Errorf("empty name not allowed")
+	}
+	return nil
+}
+
 // CreateLabel create one label of repository
-func (c *Client) CreateLabel(owner, repo string, opt CreateLabelOption) (*Label, error) {
+func (c *Client) CreateLabel(owner, repo string, opt CreateLabelOption) (*Label, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	if len(opt.Color) == 6 {
+		if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+			opt.Color = "#" + opt.Color
+		}
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	label := new(Label)
-	return label, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/labels", owner, repo),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/labels", owner, repo),
 		jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
 }
 
 // EditLabelOption options for editing a label
@@ -59,27 +93,50 @@ type EditLabelOption struct {
 	Description *string `json:"description"`
 }
 
+// Validate the EditLabelOption struct
+func (opt EditLabelOption) Validate() error {
+	if opt.Color != nil {
+		aw, err := regexp.MatchString("^#?[0-9,a-f,A-F]{6}$", *opt.Color)
+		if err != nil {
+			return err
+		}
+		if !aw {
+			return fmt.Errorf("invalid color format")
+		}
+	}
+	if opt.Name != nil {
+		if len(strings.TrimSpace(*opt.Name)) == 0 {
+			return fmt.Errorf("empty name not allowed")
+		}
+	}
+	return nil
+}
+
 // EditLabel modify one label with options
-func (c *Client) EditLabel(owner, repo string, id int64, opt EditLabelOption) (*Label, error) {
+func (c *Client) EditLabel(owner, repo string, id int64, opt EditLabelOption) (*Label, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	label := new(Label)
-	return label, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), label)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
 }
 
 // DeleteLabel delete one label of repository by id
-// TODO: maybe we need delete by name
-func (c *Client) DeleteLabel(owner, repo string, id int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil)
-	return err
+func (c *Client) DeleteLabel(owner, repo string, id int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil)
+	return resp, err
 }
 
 // GetIssueLabels get labels of one issue via issue id
-func (c *Client) GetIssueLabels(owner, repo string, index int64) ([]*Label, error) {
+func (c *Client) GetIssueLabels(owner, repo string, index int64, opts ListLabelsOptions) ([]*Label, *Response, error) {
 	labels := make([]*Label, 0, 5)
-	return labels, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), nil, nil, &labels)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/labels?%s", owner, repo, index, opts.getURLQuery().Encode()), nil, nil, &labels)
+	return labels, resp, err
 }
 
 // IssueLabelsOption a collection of labels
@@ -89,34 +146,36 @@ type IssueLabelsOption struct {
 }
 
 // AddIssueLabels add one or more labels to one issue
-func (c *Client) AddIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, error) {
+func (c *Client) AddIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	var labels []*Label
-	return labels, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	return labels, resp, err
 }
 
 // ReplaceIssueLabels replace old labels of issue with new labels
-func (c *Client) ReplaceIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, error) {
+func (c *Client) ReplaceIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	var labels []*Label
-	return labels, c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	resp, err := c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	return labels, resp, err
 }
 
 // DeleteIssueLabel delete one label of one issue by issue id and label id
 // TODO: maybe we need delete by label name and issue id
-func (c *Client) DeleteIssueLabel(owner, repo string, index, label int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels/%d", owner, repo, index, label), nil, nil)
-	return err
+func (c *Client) DeleteIssueLabel(owner, repo string, index, label int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels/%d", owner, repo, index, label), nil, nil)
+	return resp, err
 }
 
 // ClearIssueLabels delete all the labels of one issue.
-func (c *Client) ClearIssueLabels(owner, repo string, index int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), nil, nil)
-	return err
+func (c *Client) ClearIssueLabels(owner, repo string, index int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/issue_milestone.go

@@ -8,21 +8,11 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net/url"
+	"strings"
 	"time"
 )
 
-// StateType issue state type
-type StateType string
-
-const (
-	// StateOpen pr is opend
-	StateOpen StateType = "open"
-	// StateClosed pr is closed
-	StateClosed StateType = "closed"
-	// StateAll is all
-	StateAll StateType = "all"
-)
-
 // Milestone milestone is a collection of issues on one repository
 type Milestone struct {
 	ID           int64      `json:"id"`
@@ -31,59 +21,193 @@ type Milestone struct {
 	State        StateType  `json:"state"`
 	OpenIssues   int        `json:"open_issues"`
 	ClosedIssues int        `json:"closed_issues"`
+	Created      time.Time  `json:"created_at"`
+	Updated      *time.Time `json:"updated_at"`
 	Closed       *time.Time `json:"closed_at"`
 	Deadline     *time.Time `json:"due_on"`
 }
 
+// ListMilestoneOption list milestone options
+type ListMilestoneOption struct {
+	ListOptions
+	// open, closed, all
+	State StateType
+	Name  string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListMilestoneOption) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.State != "" {
+		query.Add("state", string(opt.State))
+	}
+	if len(opt.Name) != 0 {
+		query.Add("name", opt.Name)
+	}
+	return query.Encode()
+}
+
 // ListRepoMilestones list all the milestones of one repository
-func (c *Client) ListRepoMilestones(owner, repo string) ([]*Milestone, error) {
-	milestones := make([]*Milestone, 0, 10)
-	return milestones, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones", owner, repo), nil, nil, &milestones)
+func (c *Client) ListRepoMilestones(owner, repo string, opt ListMilestoneOption) ([]*Milestone, *Response, error) {
+	opt.setDefaults()
+	milestones := make([]*Milestone, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/milestones", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &milestones)
+	return milestones, resp, err
 }
 
 // GetMilestone get one milestone by repo name and milestone id
-func (c *Client) GetMilestone(owner, repo string, id int64) (*Milestone, error) {
+func (c *Client) GetMilestone(owner, repo string, id int64) (*Milestone, *Response, error) {
 	milestone := new(Milestone)
-	return milestone, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil, milestone)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil, milestone)
+	return milestone, resp, err
+}
+
+// GetMilestoneByName get one milestone by repo and milestone name
+func (c *Client) GetMilestoneByName(owner, repo string, name string) (*Milestone, *Response, error) {
+	if c.CheckServerVersionConstraint(">=1.13") != nil {
+		// backwards compatibility mode
+		m, resp, err := c.resolveMilestoneByName(owner, repo, name)
+		return m, resp, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), nil, nil, milestone)
+	return milestone, resp, err
 }
 
 // CreateMilestoneOption options for creating a milestone
 type CreateMilestoneOption struct {
 	Title       string     `json:"title"`
 	Description string     `json:"description"`
+	State       StateType  `json:"state"`
 	Deadline    *time.Time `json:"due_on"`
 }
 
+// Validate the CreateMilestoneOption struct
+func (opt CreateMilestoneOption) Validate() error {
+	if len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
 // CreateMilestone create one milestone with options
-func (c *Client) CreateMilestone(owner, repo string, opt CreateMilestoneOption) (*Milestone, error) {
+func (c *Client) CreateMilestone(owner, repo string, opt CreateMilestoneOption) (*Milestone, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	milestone := new(Milestone)
-	return milestone, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/milestones", owner, repo), jsonHeader, bytes.NewReader(body), milestone)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/milestones", owner, repo), jsonHeader, bytes.NewReader(body), milestone)
+
+	// make creating closed milestones need gitea >= v1.13.0
+	// this make it backwards compatible
+	if err == nil && opt.State == StateClosed && milestone.State != StateClosed {
+		closed := StateClosed
+		return c.EditMilestone(owner, repo, milestone.ID, EditMilestoneOption{
+			State: &closed,
+		})
+	}
+
+	return milestone, resp, err
 }
 
 // EditMilestoneOption options for editing a milestone
 type EditMilestoneOption struct {
 	Title       string     `json:"title"`
 	Description *string    `json:"description"`
-	State       *string    `json:"state"`
+	State       *StateType `json:"state"`
 	Deadline    *time.Time `json:"due_on"`
 }
 
+// Validate the EditMilestoneOption struct
+func (opt EditMilestoneOption) Validate() error {
+	if len(opt.Title) != 0 && len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
 // EditMilestone modify milestone with options
-func (c *Client) EditMilestone(owner, repo string, id int64, opt EditMilestoneOption) (*Milestone, error) {
+func (c *Client) EditMilestone(owner, repo string, id int64, opt EditMilestoneOption) (*Milestone, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), milestone)
+	return milestone, resp, err
+}
+
+// EditMilestoneByName modify milestone with options
+func (c *Client) EditMilestoneByName(owner, repo string, name string, opt EditMilestoneOption) (*Milestone, *Response, error) {
+	if c.CheckServerVersionConstraint(">=1.13") != nil {
+		// backwards compatibility mode
+		m, _, err := c.resolveMilestoneByName(owner, repo, name)
+		if err != nil {
+			return nil, nil, err
+		}
+		return c.EditMilestone(owner, repo, m.ID, opt)
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), jsonHeader, bytes.NewReader(body), milestone)
+	return milestone, resp, err
+}
+
+// DeleteMilestone delete one milestone by id
+func (c *Client) DeleteMilestone(owner, repo string, id int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil)
+	return resp, err
+}
+
+// DeleteMilestoneByName delete one milestone by name
+func (c *Client) DeleteMilestoneByName(owner, repo string, name string) (*Response, error) {
+	if c.CheckServerVersionConstraint(">=1.13") != nil {
+		// backwards compatibility mode
+		m, _, err := c.resolveMilestoneByName(owner, repo, name)
 		if err != nil {
 			return nil, err
 		}
-	milestone := new(Milestone)
-	return milestone, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), milestone)
+		return c.DeleteMilestone(owner, repo, m.ID)
+	}
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), nil, nil)
+	return resp, err
 }
 
-// DeleteMilestone delete one milestone by milestone id
-func (c *Client) DeleteMilestone(owner, repo string, id int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil)
-	return err
+// resolveMilestoneByName is a fallback method to find milestone id by name
+func (c *Client) resolveMilestoneByName(owner, repo, name string) (*Milestone, *Response, error) {
+	for i := 1; ; i++ {
+		miles, resp, err := c.ListRepoMilestones(owner, repo, ListMilestoneOption{
+			ListOptions: ListOptions{
+				Page: i,
+			},
+			State: "all",
+		})
+		if err != nil {
+			return nil, nil, err
+		}
+		if len(miles) == 0 {
+			return nil, nil, fmt.Errorf("milestone '%s' do not exist", name)
+		}
+		for _, m := range miles {
+			if strings.ToLower(strings.TrimSpace(m.Title)) == strings.ToLower(strings.TrimSpace(name)) {
+				return m, resp, nil
+			}
+		}
+	}
 }

vendor/code.gitea.io/sdk/gitea/issue_reaction.go

@@ -0,0 +1,104 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Reaction contain one reaction
+type Reaction struct {
+	User     *User     `json:"user"`
+	Reaction string    `json:"content"`
+	Created  time.Time `json:"created_at"`
+}
+
+// GetIssueReactions get a list reactions of an issue
+func (c *Client) GetIssueReactions(owner, repo string, index int64) ([]*Reaction, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
+	reactions := make([]*Reaction, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index), nil, nil, &reactions)
+	return reactions, resp, err
+}
+
+// GetIssueCommentReactions get a list of reactions from a comment of an issue
+func (c *Client) GetIssueCommentReactions(owner, repo string, commentID int64) ([]*Reaction, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
+	reactions := make([]*Reaction, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID), nil, nil, &reactions)
+	return reactions, resp, err
+}
+
+// editReactionOption contain the reaction type
+type editReactionOption struct {
+	Reaction string `json:"content"`
+}
+
+// PostIssueReaction add a reaction to an issue
+func (c *Client) PostIssueReaction(owner, repo string, index int64, reaction string) (*Reaction, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
+	reactionResponse := new(Reaction)
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), reactionResponse)
+	return reactionResponse, resp, err
+}
+
+// DeleteIssueReaction remove a reaction from an issue
+func (c *Client) DeleteIssueReaction(owner, repo string, index int64, reaction string) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index), jsonHeader, bytes.NewReader(body))
+	return resp, err
+}
+
+// PostIssueCommentReaction add a reaction to a comment of an issue
+func (c *Client) PostIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Reaction, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
+	reactionResponse := new(Reaction)
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
+		jsonHeader, bytes.NewReader(body), reactionResponse)
+	return reactionResponse, resp, err
+}
+
+// DeleteIssueCommentReaction remove a reaction from a comment of an issue
+func (c *Client) DeleteIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
+		jsonHeader, bytes.NewReader(body))
+	return resp, err
+}

vendor/code.gitea.io/sdk/gitea/issue_stopwatch.go

@@ -0,0 +1,43 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"time"
+)
+
+// StopWatch represents a running stopwatch of an issue / pr
+type StopWatch struct {
+	Created    time.Time `json:"created"`
+	IssueIndex int64     `json:"issue_index"`
+}
+
+// GetMyStopwatches list all stopwatches
+func (c *Client) GetMyStopwatches() ([]*StopWatch, *Response, error) {
+	stopwatches := make([]*StopWatch, 0, 1)
+	resp, err := c.getParsedResponse("GET", "/user/stopwatches", nil, nil, &stopwatches)
+	return stopwatches, resp, err
+}
+
+// DeleteIssueStopwatch delete / cancel a specific stopwatch
+func (c *Client) DeleteIssueStopwatch(owner, repo string, index int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/delete", owner, repo, index), nil, nil)
+	return resp, err
+}
+
+// StartIssueStopWatch starts a stopwatch for an existing issue for a given
+// repository
+func (c *Client) StartIssueStopWatch(owner, repo string, index int64) (*Response, error) {
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/start", owner, repo, index), nil, nil)
+	return resp, err
+}
+
+// StopIssueStopWatch stops an existing stopwatch for an issue in a given
+// repository
+func (c *Client) StopIssueStopWatch(owner, repo string, index int64) (*Response, error) {
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/stop", owner, repo, index), nil, nil)
+	return resp, err
+}

vendor/code.gitea.io/sdk/gitea/issue_subscription.go

@@ -0,0 +1,84 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// GetIssueSubscribers get list of users who subscribed on an issue
+func (c *Client) GetIssueSubscribers(owner, repo string, index int64) ([]*User, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
+	subscribers := make([]*User, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions", owner, repo, index), nil, nil, &subscribers)
+	return subscribers, resp, err
+}
+
+// AddIssueSubscription Subscribe user to issue
+func (c *Client) AddIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusCreated {
+		return resp, nil
+	}
+	if status == http.StatusOK {
+		return resp, fmt.Errorf("already subscribed")
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
+}
+
+// DeleteIssueSubscription unsubscribe user from issue
+func (c *Client) DeleteIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusCreated {
+		return resp, nil
+	}
+	if status == http.StatusOK {
+		return resp, fmt.Errorf("already unsubscribed")
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
+}
+
+// CheckIssueSubscription check if current user is subscribed to an issue
+func (c *Client) CheckIssueSubscription(owner, repo string, index int64) (*WatchInfo, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	wi := new(WatchInfo)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/check", owner, repo, index), nil, nil, wi)
+	return wi, resp, err
+}
+
+// IssueSubscribe subscribe current user to an issue
+func (c *Client) IssueSubscribe(owner, repo string, index int64) (*Response, error) {
+	u, _, err := c.GetMyUserInfo()
+	if err != nil {
+		return nil, err
+	}
+	return c.AddIssueSubscription(owner, repo, index, u.UserName)
+}
+
+// IssueUnSubscribe unsubscribe current user from an issue
+func (c *Client) IssueUnSubscribe(owner, repo string, index int64) (*Response, error) {
+	u, _, err := c.GetMyUserInfo()
+	if err != nil {
+		return nil, err
+	}
+	return c.DeleteIssueSubscription(owner, repo, index, u.UserName)
+}

vendor/code.gitea.io/sdk/gitea/issue_tracked_time.go

@@ -17,47 +17,111 @@ type TrackedTime struct {
 	Created time.Time `json:"created"`
 	// Time in seconds
 	Time int64 `json:"time"`
+	// deprecated (only for backwards compatibility)
 	UserID   int64  `json:"user_id"`
+	UserName string `json:"user_name"`
+	// deprecated (only for backwards compatibility)
 	IssueID int64  `json:"issue_id"`
+	Issue   *Issue `json:"issue"`
 }
 
 // GetUserTrackedTimes list tracked times of a user
-func (c *Client) GetUserTrackedTimes(owner, repo, user string) ([]*TrackedTime, error) {
+func (c *Client) GetUserTrackedTimes(owner, repo, user string) ([]*TrackedTime, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
 	times := make([]*TrackedTime, 0, 10)
-	return times, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times/%s", owner, repo, user), nil, nil, &times)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times/%s", owner, repo, user), nil, nil, &times)
+	return times, resp, err
 }
 
 // GetRepoTrackedTimes list tracked times of a repository
-func (c *Client) GetRepoTrackedTimes(owner, repo string) ([]*TrackedTime, error) {
+func (c *Client) GetRepoTrackedTimes(owner, repo string) ([]*TrackedTime, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
 	times := make([]*TrackedTime, 0, 10)
-	return times, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times", owner, repo), nil, nil, &times)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times", owner, repo), nil, nil, &times)
+	return times, resp, err
 }
 
 // GetMyTrackedTimes list tracked times of the current user
-func (c *Client) GetMyTrackedTimes() ([]*TrackedTime, error) {
+func (c *Client) GetMyTrackedTimes() ([]*TrackedTime, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
 	times := make([]*TrackedTime, 0, 10)
-	return times, c.getParsedResponse("GET", "/user/times", nil, nil, &times)
+	resp, err := c.getParsedResponse("GET", "/user/times", nil, nil, &times)
+	return times, resp, err
 }
 
 // AddTimeOption options for adding time to an issue
 type AddTimeOption struct {
 	// time in seconds
 	Time int64 `json:"time"`
+	// optional
+	Created time.Time `json:"created"`
+	// optional
+	User string `json:"user_name"`
+}
+
+// Validate the AddTimeOption struct
+func (opt AddTimeOption) Validate() error {
+	if opt.Time == 0 {
+		return fmt.Errorf("no time to add")
+	}
+	return nil
 }
 
 // AddTime adds time to issue with the given index
-func (c *Client) AddTime(owner, repo string, index int64, opt AddTimeOption) (*TrackedTime, error) {
+func (c *Client) AddTime(owner, repo string, index int64, opt AddTimeOption) (*TrackedTime, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	t := new(TrackedTime)
-	return t, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
 }
 
-// ListTrackedTimes get tracked times of one issue via issue id
-func (c *Client) ListTrackedTimes(owner, repo string, index int64) ([]*TrackedTime, error) {
-	times := make([]*TrackedTime, 0, 5)
-	return times, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index), nil, nil, &times)
+// ListTrackedTimesOptions options for listing repository's tracked times
+type ListTrackedTimesOptions struct {
+	ListOptions
+}
+
+// ListTrackedTimes list tracked times of a single issue for a given repository
+func (c *Client) ListTrackedTimes(owner, repo string, index int64, opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	times := make([]*TrackedTime, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/times?%s", owner, repo, index, opt.getURLQuery().Encode()), nil, nil, &times)
+	return times, resp, err
+}
+
+// ResetIssueTime reset tracked time of a single issue for a given repository
+func (c *Client) ResetIssueTime(owner, repo string, index int64) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index), nil, nil)
+	return resp, err
+}
+
+// DeleteTime delete a specific tracked time by id of a single issue for a given repository
+func (c *Client) DeleteTime(owner, repo string, index, timeID int64) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times/%d", owner, repo, index, timeID), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/list_options.go

@@ -0,0 +1,37 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+)
+
+const defaultPageSize = 10
+const maxPageSize = 50
+
+// ListOptions options for using Gitea's API pagination
+type ListOptions struct {
+	Page     int
+	PageSize int
+}
+
+func (o ListOptions) getURLQuery() url.Values {
+	query := make(url.Values)
+	query.Add("page", fmt.Sprintf("%d", o.Page))
+	query.Add("limit", fmt.Sprintf("%d", o.PageSize))
+
+	return query
+}
+
+func (o ListOptions) setDefaults() {
+	if o.Page < 1 {
+		o.Page = 1
+	}
+
+	if o.PageSize < 0 || o.PageSize > maxPageSize {
+		o.PageSize = defaultPageSize
+	}
+}

vendor/code.gitea.io/sdk/gitea/miscellaneous.go

@@ -1,13 +0,0 @@
-// Copyright 2015 The Gogs Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package gitea
-
-// ServerVersion returns the version of the server
-func (c *Client) ServerVersion() (string, error) {
-	var v = struct {
-		Version string `json:"version"`
-	}{}
-	return v.Version, c.getParsedResponse("GET", "/api/v1/version", nil, nil, &v)
-}

vendor/code.gitea.io/sdk/gitea/notifications.go

@@ -0,0 +1,198 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// NotificationThread expose Notification on API
+type NotificationThread struct {
+	ID         int64                `json:"id"`
+	Repository *Repository          `json:"repository"`
+	Subject    *NotificationSubject `json:"subject"`
+	Unread     bool                 `json:"unread"`
+	Pinned     bool                 `json:"pinned"`
+	UpdatedAt  time.Time            `json:"updated_at"`
+	URL        string               `json:"url"`
+}
+
+// NotificationSubject contains the notification subject (Issue/Pull/Commit)
+type NotificationSubject struct {
+	Title            string `json:"title"`
+	URL              string `json:"url"`
+	LatestCommentURL string `json:"latest_comment_url"`
+	Type             string `json:"type" binding:"In(Issue,Pull,Commit)"`
+}
+
+// NotifyStatus notification status type
+type NotifyStatus string
+
+const (
+	// NotifyStatusUnread was not read
+	NotifyStatusUnread NotifyStatus = "unread"
+	// NotifyStatusRead was already read by user
+	NotifyStatusRead NotifyStatus = "read"
+	// NotifyStatusPinned notification is pinned by user
+	NotifyStatusPinned NotifyStatus = "pinned"
+)
+
+// ListNotificationOptions represents the filter options
+type ListNotificationOptions struct {
+	ListOptions
+	Since  time.Time
+	Before time.Time
+	Status []NotifyStatus
+}
+
+// MarkNotificationOptions represents the filter & modify options
+type MarkNotificationOptions struct {
+	LastReadAt time.Time
+	Status     []NotifyStatus
+	ToStatus   NotifyStatus
+}
+
+// QueryEncode encode options to url query
+func (opt *ListNotificationOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if !opt.Since.IsZero() {
+		query.Add("since", opt.Since.Format(time.RFC3339))
+	}
+	if !opt.Before.IsZero() {
+		query.Add("before", opt.Before.Format(time.RFC3339))
+	}
+	for _, s := range opt.Status {
+		query.Add("status-types", string(s))
+	}
+	return query.Encode()
+}
+
+// Validate the CreateUserOption struct
+func (opt ListNotificationOptions) Validate(c *Client) error {
+	if len(opt.Status) != 0 {
+		return c.CheckServerVersionConstraint(">=1.12.3")
+	}
+	return nil
+}
+
+// QueryEncode encode options to url query
+func (opt *MarkNotificationOptions) QueryEncode() string {
+	query := make(url.Values)
+	if !opt.LastReadAt.IsZero() {
+		query.Add("last_read_at", opt.LastReadAt.Format(time.RFC3339))
+	}
+	for _, s := range opt.Status {
+		query.Add("status-types", string(s))
+	}
+	if len(opt.ToStatus) != 0 {
+		query.Add("to-status", string(opt.ToStatus))
+	}
+	return query.Encode()
+}
+
+// Validate the CreateUserOption struct
+func (opt MarkNotificationOptions) Validate(c *Client) error {
+	if len(opt.Status) != 0 || len(opt.ToStatus) != 0 {
+		return c.CheckServerVersionConstraint(">=1.12.3")
+	}
+	return nil
+}
+
+// CheckNotifications list users's notification threads
+func (c *Client) CheckNotifications() (int64, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return 0, nil, err
+	}
+	new := struct {
+		New int64 `json:"new"`
+	}{}
+
+	resp, err := c.getParsedResponse("GET", "/notifications/new", jsonHeader, nil, &new)
+	return new.New, resp, err
+}
+
+// GetNotification get notification thread by ID
+func (c *Client) GetNotification(id int64) (*NotificationThread, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	thread := new(NotificationThread)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/notifications/threads/%d", id), nil, nil, thread)
+	return thread, resp, err
+}
+
+// ReadNotification mark notification thread as read by ID
+// It optionally takes a second argument if status has to be set other than 'read'
+func (c *Client) ReadNotification(id int64, status ...NotifyStatus) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, err
+	}
+	link := fmt.Sprintf("/notifications/threads/%d", id)
+	if len(status) != 0 {
+		link += fmt.Sprintf("?to-status=%s", status[0])
+	}
+	_, resp, err := c.getResponse("PATCH", link, nil, nil)
+	return resp, err
+}
+
+// ListNotifications list users's notification threads
+func (c *Client) ListNotifications(opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse("/notifications")
+	link.RawQuery = opt.QueryEncode()
+	threads := make([]*NotificationThread, 0, 10)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	return threads, resp, err
+}
+
+// ReadNotifications mark notification threads as read
+func (c *Client) ReadNotifications(opt MarkNotificationOptions) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, err
+	}
+	link, _ := url.Parse("/notifications")
+	link.RawQuery = opt.QueryEncode()
+	_, resp, err := c.getResponse("PUT", link.String(), nil, nil)
+	return resp, err
+}
+
+// ListRepoNotifications list users's notification threads on a specific repo
+func (c *Client) ListRepoNotifications(owner, reponame string, opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, reponame))
+	link.RawQuery = opt.QueryEncode()
+	threads := make([]*NotificationThread, 0, 10)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	return threads, resp, err
+}
+
+// ReadRepoNotifications mark notification threads as read on a specific repo
+func (c *Client) ReadRepoNotifications(owner, reponame string, opt MarkNotificationOptions) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, reponame))
+	link.RawQuery = opt.QueryEncode()
+	_, resp, err := c.getResponse("PUT", link.String(), nil, nil)
+	return resp, err
+}

vendor/code.gitea.io/sdk/gitea/oauth2.go

@@ -0,0 +1,91 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Oauth2 represents an Oauth2 Application
+type Oauth2 struct {
+	ID           int64     `json:"id"`
+	Name         string    `json:"name"`
+	ClientID     string    `json:"client_id"`
+	ClientSecret string    `json:"client_secret"`
+	RedirectURIs []string  `json:"redirect_uris"`
+	Created      time.Time `json:"created"`
+}
+
+// ListOauth2Option for listing Oauth2 Applications
+type ListOauth2Option struct {
+	ListOptions
+}
+
+// CreateOauth2Option required options for creating an Application
+type CreateOauth2Option struct {
+	Name         string   `json:"name"`
+	RedirectURIs []string `json:"redirect_uris"`
+}
+
+// CreateOauth2 create an Oauth2 Application and returns a completed Oauth2 object.
+func (c *Client) CreateOauth2(opt CreateOauth2Option) (*Oauth2, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	oauth := new(Oauth2)
+	resp, err := c.getParsedResponse("POST", "/user/applications/oauth2", jsonHeader, bytes.NewReader(body), oauth)
+	return oauth, resp, err
+}
+
+// UpdateOauth2 a specific Oauth2 Application by ID and return a completed Oauth2 object.
+func (c *Client) UpdateOauth2(oauth2id int64, opt CreateOauth2Option) (*Oauth2, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	oauth := new(Oauth2)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), jsonHeader, bytes.NewReader(body), oauth)
+	return oauth, resp, err
+}
+
+// GetOauth2 a specific Oauth2 Application by ID.
+func (c *Client) GetOauth2(oauth2id int64) (*Oauth2, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	oauth2s := &Oauth2{}
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil, &oauth2s)
+	return oauth2s, resp, err
+}
+
+// ListOauth2 all of your Oauth2 Applications.
+func (c *Client) ListOauth2(opt ListOauth2Option) ([]*Oauth2, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	oauth2s := make([]*Oauth2, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2?%s", opt.getURLQuery().Encode()), nil, nil, &oauth2s)
+	return oauth2s, resp, err
+}
+
+// DeleteOauth2 delete an Oauth2 application by ID
+func (c *Client) DeleteOauth2(oauth2id int64) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil)
+	return resp, err
+}

vendor/code.gitea.io/sdk/gitea/org.go

@@ -23,44 +23,86 @@ type Organization struct {
 	Visibility  string `json:"visibility"`
 }
 
+// VisibleType defines the visibility
+type VisibleType string
+
+const (
+	// VisibleTypePublic Visible for everyone
+	VisibleTypePublic VisibleType = "public"
+
+	// VisibleTypeLimited Visible for every connected user
+	VisibleTypeLimited VisibleType = "limited"
+
+	// VisibleTypePrivate Visible only for organization's members
+	VisibleTypePrivate VisibleType = "private"
+)
+
+// ListOrgsOptions options for listing organizations
+type ListOrgsOptions struct {
+	ListOptions
+}
+
 // ListMyOrgs list all of current user's organizations
-func (c *Client) ListMyOrgs() ([]*Organization, error) {
-	orgs := make([]*Organization, 0, 5)
-	return orgs, c.getParsedResponse("GET", "/user/orgs", nil, nil, &orgs)
+func (c *Client) ListMyOrgs(opt ListOrgsOptions) ([]*Organization, *Response, error) {
+	opt.setDefaults()
+	orgs := make([]*Organization, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
 }
 
 // ListUserOrgs list all of some user's organizations
-func (c *Client) ListUserOrgs(user string) ([]*Organization, error) {
-	orgs := make([]*Organization, 0, 5)
-	return orgs, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/orgs", user), nil, nil, &orgs)
+func (c *Client) ListUserOrgs(user string, opt ListOrgsOptions) ([]*Organization, *Response, error) {
+	opt.setDefaults()
+	orgs := make([]*Organization, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/orgs?%s", user, opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
 }
 
 // GetOrg get one organization by name
-func (c *Client) GetOrg(orgname string) (*Organization, error) {
+func (c *Client) GetOrg(orgname string) (*Organization, *Response, error) {
 	org := new(Organization)
-	return org, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s", orgname), nil, nil, org)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s", orgname), nil, nil, org)
+	return org, resp, err
 }
 
 // CreateOrgOption options for creating an organization
 type CreateOrgOption struct {
-	UserName    string `json:"username"`
+	Name        string      `json:"username"`
 	FullName    string      `json:"full_name"`
 	Description string      `json:"description"`
 	Website     string      `json:"website"`
 	Location    string      `json:"location"`
-	// possible values are `public` (default), `limited` or `private`
-	// enum: public,limited,private
-	Visibility string `json:"visibility"`
+	Visibility  VisibleType `json:"visibility"`
+}
+
+// checkVisibilityOpt check if mode exist
+func checkVisibilityOpt(v VisibleType) bool {
+	return v == VisibleTypePublic || v == VisibleTypeLimited || v == VisibleTypePrivate
+}
+
+// Validate the CreateOrgOption struct
+func (opt CreateOrgOption) Validate() error {
+	if len(opt.Name) == 0 {
+		return fmt.Errorf("empty org name")
+	}
+	if len(opt.Visibility) != 0 && !checkVisibilityOpt(opt.Visibility) {
+		return fmt.Errorf("infalid bisibility option")
+	}
+	return nil
 }
 
 // CreateOrg creates an organization
-func (c *Client) CreateOrg(opt CreateOrgOption) (*Organization, error) {
+func (c *Client) CreateOrg(opt CreateOrgOption) (*Organization, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	org := new(Organization)
-	return org, c.getParsedResponse("POST", "/orgs", jsonHeader, bytes.NewReader(body), org)
+	resp, err := c.getParsedResponse("POST", "/orgs", jsonHeader, bytes.NewReader(body), org)
+	return org, resp, err
 }
 
 // EditOrgOption options for editing an organization
@@ -69,23 +111,32 @@ type EditOrgOption struct {
 	Description string      `json:"description"`
 	Website     string      `json:"website"`
 	Location    string      `json:"location"`
-	// possible values are `public`, `limited` or `private`
-	// enum: public,limited,private
-	Visibility string `json:"visibility"`
+	Visibility  VisibleType `json:"visibility"`
+}
+
+// Validate the EditOrgOption struct
+func (opt EditOrgOption) Validate() error {
+	if len(opt.Visibility) != 0 && !checkVisibilityOpt(opt.Visibility) {
+		return fmt.Errorf("infalid bisibility option")
+	}
+	return nil
 }
 
 // EditOrg modify one organization via options
-func (c *Client) EditOrg(orgname string, opt EditOrgOption) error {
+func (c *Client) EditOrg(orgname string, opt EditOrgOption) (*Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, bytes.NewReader(body))
-	return err
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, bytes.NewReader(body))
+	return resp, err
 }
 
 // DeleteOrg deletes an organization
-func (c *Client) DeleteOrg(orgname string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s", orgname), nil, nil)
-	return err
+func (c *Client) DeleteOrg(orgname string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/org_member.go

@@ -1,26 +1,101 @@
-// Copyright 2016 The Gogs Authors. All rights reserved.
+// Copyright 2020 The Gitea Authors. All rights reserved.
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 
 package gitea
 
 import (
-	"bytes"
-	"encoding/json"
 	"fmt"
+	"net/http"
+	"net/url"
 )
 
-// AddOrgMembershipOption add user to organization options
-type AddOrgMembershipOption struct {
-	Role string `json:"role"`
+// DeleteOrgMembership remove a member from an organization
+func (c *Client) DeleteOrgMembership(org, user string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	return resp, err
 }
 
-// AddOrgMembership add some one to an organization's member
-func (c *Client) AddOrgMembership(org, user string, opt AddOrgMembershipOption) error {
-	body, err := json.Marshal(&opt)
-	if err != nil {
-		return err
-	}
-	_, err = c.getResponse("PUT", fmt.Sprintf("/orgs/%s/membership/%s", org, user), jsonHeader, bytes.NewReader(body))
-	return err
+// ListOrgMembershipOption list OrgMembership options
+type ListOrgMembershipOption struct {
+	ListOptions
+}
+
+// ListOrgMembership list an organization's members
+func (c *Client) ListOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/members", url.PathEscape(org)))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
+}
+
+// ListPublicOrgMembership list an organization's members
+func (c *Client) ListPublicOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/public_members", url.PathEscape(org)))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
+}
+
+// CheckOrgMembership Check if a user is a member of an organization
+func (c *Client) CheckOrgMembership(org, user string) (bool, *Response, error) {
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	switch status {
+	case http.StatusNoContent:
+		return true, resp, nil
+	case http.StatusNotFound:
+		return false, resp, nil
+	default:
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+}
+
+// CheckPublicOrgMembership Check if a user is a member of an organization
+func (c *Client) CheckPublicOrgMembership(org, user string) (bool, *Response, error) {
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	switch status {
+	case http.StatusNoContent:
+		return true, resp, nil
+	case http.StatusNotFound:
+		return false, resp, nil
+	default:
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+}
+
+// SetPublicOrgMembership publicize/conceal a user's membership
+func (c *Client) SetPublicOrgMembership(org, user string, visible bool) (*Response, error) {
+	var (
+		status int
+		err    error
+		resp   *Response
+	)
+	if visible {
+		status, resp, err = c.getStatusCode("PUT", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	} else {
+		status, resp, err = c.getStatusCode("DELETE", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	}
+	if err != nil {
+		return resp, err
+	}
+	switch status {
+	case http.StatusNoContent:
+		return resp, nil
+	case http.StatusNotFound:
+		return resp, fmt.Errorf("forbidden")
+	default:
+		return resp, fmt.Errorf("unexpected Status: %d", status)
+	}
 }

vendor/code.gitea.io/sdk/gitea/org_team.go

@@ -16,114 +16,187 @@ type Team struct {
 	Name                    string        `json:"name"`
 	Description             string        `json:"description"`
 	Organization            *Organization `json:"organization"`
-	// enum: none,read,write,admin,owner
-	Permission string `json:"permission"`
+	Permission              AccessMode    `json:"permission"`
+	CanCreateOrgRepo        bool          `json:"can_create_org_repo"`
+	IncludesAllRepositories bool          `json:"includes_all_repositories"`
 	// example: ["repo.code","repo.issues","repo.ext_issues","repo.wiki","repo.pulls","repo.releases","repo.ext_wiki"]
 	Units []string `json:"units"`
 }
 
+// ListTeamsOptions options for listing teams
+type ListTeamsOptions struct {
+	ListOptions
+}
+
 // ListOrgTeams lists all teams of an organization
-func (c *Client) ListOrgTeams(org string) ([]*Team, error) {
-	teams := make([]*Team, 0, 10)
-	return teams, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/teams", org), nil, nil, &teams)
+func (c *Client) ListOrgTeams(org string, opt ListTeamsOptions) ([]*Team, *Response, error) {
+	opt.setDefaults()
+	teams := make([]*Team, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/teams?%s", org, opt.getURLQuery().Encode()), nil, nil, &teams)
+	return teams, resp, err
 }
 
 // ListMyTeams lists all the teams of the current user
-func (c *Client) ListMyTeams() ([]*Team, error) {
-	teams := make([]*Team, 0, 10)
-	return teams, c.getParsedResponse("GET", "/user/teams", nil, nil, &teams)
+func (c *Client) ListMyTeams(opt *ListTeamsOptions) ([]*Team, *Response, error) {
+	opt.setDefaults()
+	teams := make([]*Team, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/teams?%s", opt.getURLQuery().Encode()), nil, nil, &teams)
+	return teams, resp, err
 }
 
 // GetTeam gets a team by ID
-func (c *Client) GetTeam(id int64) (*Team, error) {
+func (c *Client) GetTeam(id int64) (*Team, *Response, error) {
 	t := new(Team)
-	return t, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d", id), nil, nil, t)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d", id), nil, nil, t)
+	return t, resp, err
 }
 
 // CreateTeamOption options for creating a team
 type CreateTeamOption struct {
 	Name                    string     `json:"name"`
 	Description             string     `json:"description"`
-	// enum: read,write,admin
-	Permission string `json:"permission"`
+	Permission              AccessMode `json:"permission"`
+	CanCreateOrgRepo        bool       `json:"can_create_org_repo"`
+	IncludesAllRepositories bool       `json:"includes_all_repositories"`
 	// example: ["repo.code","repo.issues","repo.ext_issues","repo.wiki","repo.pulls","repo.releases","repo.ext_wiki"]
 	Units []string `json:"units"`
 }
 
+// Validate the CreateTeamOption struct
+func (opt CreateTeamOption) Validate() error {
+	if opt.Permission == AccessModeOwner {
+		opt.Permission = AccessModeAdmin
+	} else if opt.Permission != AccessModeRead && opt.Permission != AccessModeWrite && opt.Permission != AccessModeAdmin {
+		return fmt.Errorf("permission mode invalid")
+	}
+	if len(opt.Name) == 0 {
+		return fmt.Errorf("name required")
+	}
+	if len(opt.Name) > 30 {
+		return fmt.Errorf("name to long")
+	}
+	if len(opt.Description) > 255 {
+		return fmt.Errorf("description to long")
+	}
+	return nil
+}
+
 // CreateTeam creates a team for an organization
-func (c *Client) CreateTeam(org string, opt CreateTeamOption) (*Team, error) {
+func (c *Client) CreateTeam(org string, opt CreateTeamOption) (*Team, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	t := new(Team)
-	return t, c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/teams", org), jsonHeader, bytes.NewReader(body), t)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/teams", org), jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
 }
 
 // EditTeamOption options for editing a team
 type EditTeamOption struct {
 	Name                    string     `json:"name"`
-	Description string `json:"description"`
-	// enum: read,write,admin
-	Permission string `json:"permission"`
+	Description             *string    `json:"description"`
+	Permission              AccessMode `json:"permission"`
+	CanCreateOrgRepo        *bool      `json:"can_create_org_repo"`
+	IncludesAllRepositories *bool      `json:"includes_all_repositories"`
 	// example: ["repo.code","repo.issues","repo.ext_issues","repo.wiki","repo.pulls","repo.releases","repo.ext_wiki"]
 	Units []string `json:"units"`
 }
 
+// Validate the EditTeamOption struct
+func (opt EditTeamOption) Validate() error {
+	if opt.Permission == AccessModeOwner {
+		opt.Permission = AccessModeAdmin
+	} else if opt.Permission != AccessModeRead && opt.Permission != AccessModeWrite && opt.Permission != AccessModeAdmin {
+		return fmt.Errorf("permission mode invalid")
+	}
+	if len(opt.Name) == 0 {
+		return fmt.Errorf("name required")
+	}
+	if len(opt.Name) > 30 {
+		return fmt.Errorf("name to long")
+	}
+	if opt.Description != nil && len(*opt.Description) > 255 {
+		return fmt.Errorf("description to long")
+	}
+	return nil
+}
+
 // EditTeam edits a team of an organization
-func (c *Client) EditTeam(id int64, opt EditTeamOption) error {
+func (c *Client) EditTeam(id int64, opt EditTeamOption) (*Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/teams/%d", id), jsonHeader, bytes.NewReader(body))
-	return err
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/teams/%d", id), jsonHeader, bytes.NewReader(body))
+	return resp, err
 }
 
 // DeleteTeam deletes a team of an organization
-func (c *Client) DeleteTeam(id int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d", id), nil, nil)
-	return err
+func (c *Client) DeleteTeam(id int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d", id), nil, nil)
+	return resp, err
+}
+
+// ListTeamMembersOptions options for listing team's members
+type ListTeamMembersOptions struct {
+	ListOptions
 }
 
 // ListTeamMembers lists all members of a team
-func (c *Client) ListTeamMembers(id int64) ([]*User, error) {
-	members := make([]*User, 0, 10)
-	return members, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members", id), nil, nil, &members)
+func (c *Client) ListTeamMembers(id int64, opt ListTeamMembersOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	members := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members?%s", id, opt.getURLQuery().Encode()), nil, nil, &members)
+	return members, resp, err
 }
 
 // GetTeamMember gets a member of a team
-func (c *Client) GetTeamMember(id int64, user string) (*User, error) {
+func (c *Client) GetTeamMember(id int64, user string) (*User, *Response, error) {
 	m := new(User)
-	return m, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil, m)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil, m)
+	return m, resp, err
 }
 
 // AddTeamMember adds a member to a team
-func (c *Client) AddTeamMember(id int64, user string) error {
-	_, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
-	return err
+func (c *Client) AddTeamMember(id int64, user string) (*Response, error) {
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
+	return resp, err
 }
 
 // RemoveTeamMember removes a member from a team
-func (c *Client) RemoveTeamMember(id int64, user string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
-	return err
+func (c *Client) RemoveTeamMember(id int64, user string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
+	return resp, err
+}
+
+// ListTeamRepositoriesOptions options for listing team's repositories
+type ListTeamRepositoriesOptions struct {
+	ListOptions
 }
 
 // ListTeamRepositories lists all repositories of a team
-func (c *Client) ListTeamRepositories(id int64) ([]*Repository, error) {
-	repos := make([]*Repository, 0, 10)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/repos", id), nil, nil, &repos)
+func (c *Client) ListTeamRepositories(id int64, opt ListTeamRepositoriesOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/repos?%s", id, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // AddTeamRepository adds a repository to a team
-func (c *Client) AddTeamRepository(id int64, org, repo string) error {
-	_, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
-	return err
+func (c *Client) AddTeamRepository(id int64, org, repo string) (*Response, error) {
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
+	return resp, err
 }
 
 // RemoveTeamRepository removes a repository from a team
-func (c *Client) RemoveTeamRepository(id int64, org, repo string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
-	return err
+func (c *Client) RemoveTeamRepository(id int64, org, repo string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/org_type.go

@@ -1,27 +0,0 @@
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package gitea
-
-// VisibleType defines the visibility (Organization only)
-type VisibleType int
-
-const (
-	// VisibleTypePublic Visible for everyone
-	VisibleTypePublic VisibleType = iota
-
-	// VisibleTypeLimited Visible for every connected user
-	VisibleTypeLimited
-
-	// VisibleTypePrivate Visible only for organization's members
-	VisibleTypePrivate
-)
-
-// ExtractKeysFromMapString provides a slice of keys from map
-func ExtractKeysFromMapString(in map[string]VisibleType) (keys []string) {
-	for k := range in {
-		keys = append(keys, k)
-	}
-	return
-}

vendor/code.gitea.io/sdk/gitea/pull.go

@@ -1,4 +1,5 @@
 // Copyright 2016 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 
@@ -8,6 +9,8 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net/url"
+	"strings"
 	"time"
 )
 
@@ -33,6 +36,7 @@ type PullRequest struct {
 	Assignee  *User      `json:"assignee"`
 	Assignees []*User    `json:"assignees"`
 	State     StateType  `json:"state"`
+	IsLocked  bool       `json:"is_locked"`
 	Comments  int        `json:"comments"`
 
 	HTMLURL  string `json:"html_url"`
@@ -57,24 +61,58 @@ type PullRequest struct {
 
 // ListPullRequestsOptions options for listing pull requests
 type ListPullRequestsOptions struct {
-	Page  int    `json:"page"`
-	State string `json:"state"`
+	ListOptions
+	State StateType `json:"state"`
+	// oldest, recentupdate, leastupdate, mostcomment, leastcomment, priority
+	Sort      string
+	Milestone int64
+}
+
+// MergeStyle is used specify how a pull is merged
+type MergeStyle string
+
+const (
+	// MergeStyleMerge merge pull as usual
+	MergeStyleMerge MergeStyle = "merge"
+	// MergeStyleRebase rebase pull
+	MergeStyleRebase MergeStyle = "rebase"
+	// MergeStyleRebaseMerge rebase and merge pull
+	MergeStyleRebaseMerge MergeStyle = "rebase-merge"
+	// MergeStyleSquash squash and merge pull
+	MergeStyleSquash MergeStyle = "squash"
+)
+
+// QueryEncode turns options into querystring argument
+func (opt *ListPullRequestsOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if len(opt.State) > 0 {
+		query.Add("state", string(opt.State))
+	}
+	if len(opt.Sort) > 0 {
+		query.Add("sort", opt.Sort)
+	}
+	if opt.Milestone > 0 {
+		query.Add("milestone", fmt.Sprintf("%d", opt.Milestone))
+	}
+	return query.Encode()
 }
 
 // ListRepoPullRequests list PRs of one repository
-func (c *Client) ListRepoPullRequests(owner, repo string, opt ListPullRequestsOptions) ([]*PullRequest, error) {
-	body, err := json.Marshal(&opt)
-	if err != nil {
-		return nil, err
-	}
-	prs := make([]*PullRequest, 0, 10)
-	return prs, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls", owner, repo), jsonHeader, bytes.NewReader(body), &prs)
+func (c *Client) ListRepoPullRequests(owner, repo string, opt ListPullRequestsOptions) ([]*PullRequest, *Response, error) {
+	opt.setDefaults()
+	prs := make([]*PullRequest, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &prs)
+	return prs, resp, err
 }
 
 // GetPullRequest get information of one PR
-func (c *Client) GetPullRequest(owner, repo string, index int64) (*PullRequest, error) {
+func (c *Client) GetPullRequest(owner, repo string, index int64) (*PullRequest, *Response, error) {
 	pr := new(PullRequest)
-	return pr, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index), nil, nil, pr)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index), nil, nil, pr)
+	return pr, resp, err
 }
 
 // CreatePullRequestOption options when creating a pull request
@@ -91,52 +129,125 @@ type CreatePullRequestOption struct {
 }
 
 // CreatePullRequest create pull request with options
-func (c *Client) CreatePullRequest(owner, repo string, opt CreatePullRequestOption) (*PullRequest, error) {
+func (c *Client) CreatePullRequest(owner, repo string, opt CreatePullRequestOption) (*PullRequest, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	pr := new(PullRequest)
-	return pr, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/pulls", owner, repo),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls", owner, repo),
 		jsonHeader, bytes.NewReader(body), pr)
+	return pr, resp, err
 }
 
 // EditPullRequestOption options when modify pull request
 type EditPullRequestOption struct {
 	Title     string     `json:"title"`
 	Body      string     `json:"body"`
+	Base      string     `json:"base"`
 	Assignee  string     `json:"assignee"`
 	Assignees []string   `json:"assignees"`
 	Milestone int64      `json:"milestone"`
 	Labels    []int64    `json:"labels"`
-	State     *string    `json:"state"`
+	State     *StateType `json:"state"`
 	Deadline  *time.Time `json:"due_date"`
 }
 
+// Validate the EditPullRequestOption struct
+func (opt EditPullRequestOption) Validate(c *Client) error {
+	if len(opt.Title) != 0 && len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	if len(opt.Base) != 0 {
+		if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+			return fmt.Errorf("can not change base gitea to old")
+		}
+	}
+	return nil
+}
+
 // EditPullRequest modify pull request with PR id and options
-func (c *Client) EditPullRequest(owner, repo string, index int64, opt EditPullRequestOption) (*PullRequest, error) {
+func (c *Client) EditPullRequest(owner, repo string, index int64, opt EditPullRequestOption) (*PullRequest, *Response, error) {
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	pr := new(PullRequest)
-	return pr, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index),
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), pr)
+	return pr, resp, err
+}
+
+// MergePullRequestOption options when merging a pull request
+type MergePullRequestOption struct {
+	Style   MergeStyle `json:"Do"`
+	Title   string     `json:"MergeTitleField"`
+	Message string     `json:"MergeMessageField"`
+}
+
+// Validate the MergePullRequestOption struct
+func (opt MergePullRequestOption) Validate(c *Client) error {
+	if opt.Style == MergeStyleSquash {
+		if err := c.CheckServerVersionConstraint(">=1.11.5"); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 // MergePullRequest merge a PR to repository by PR id
-func (c *Client) MergePullRequest(owner, repo string, index int64) error {
-	_, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
-	return err
+func (c *Client) MergePullRequest(owner, repo string, index int64, opt MergePullRequestOption) (bool, *Response, error) {
+	if err := opt.Validate(c); err != nil {
+		return false, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("POST", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return false, resp, err
+	}
+	return status == 200, resp, nil
 }
 
 // IsPullRequestMerged test if one PR is merged to one repository
-func (c *Client) IsPullRequestMerged(owner, repo string, index int64) (bool, error) {
-	statusCode, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
+func (c *Client) IsPullRequestMerged(owner, repo string, index int64) (bool, *Response, error) {
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
 
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
 
-	return statusCode == 204, nil
+	return status == 204, resp, nil
+}
+
+// getPullRequestDiffOrPatch gets the patch or diff file as bytes for a PR
+func (c *Client) getPullRequestDiffOrPatch(owner, repo, kind string, index int64) ([]byte, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		r, _, err2 := c.GetRepo(owner, repo)
+		if err2 != nil {
+			return nil, nil, err
+		}
+		if r.Private {
+			return nil, nil, err
+		}
+		return c.getWebResponse("GET", fmt.Sprintf("/%s/%s/pulls/%d.%s", owner, repo, index, kind), nil)
+	}
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d.%s", owner, repo, index, kind), nil, nil)
+}
+
+// GetPullRequestPatch gets the .patch file as bytes for a PR
+func (c *Client) GetPullRequestPatch(owner, repo string, index int64) ([]byte, *Response, error) {
+	return c.getPullRequestDiffOrPatch(owner, repo, "patch", index)
+}
+
+// GetPullRequestDiff gets the .diff file as bytes for a PR
+func (c *Client) GetPullRequestDiff(owner, repo string, index int64) ([]byte, *Response, error) {
+	return c.getPullRequestDiffOrPatch(owner, repo, "diff", index)
 }

vendor/code.gitea.io/sdk/gitea/pull_review.go

@@ -0,0 +1,219 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// ReviewStateType review state type
+type ReviewStateType string
+
+const (
+	// ReviewStateApproved pr is approved
+	ReviewStateApproved ReviewStateType = "APPROVED"
+	// ReviewStatePending pr state is pending
+	ReviewStatePending ReviewStateType = "PENDING"
+	// ReviewStateComment is a comment review
+	ReviewStateComment ReviewStateType = "COMMENT"
+	// ReviewStateRequestChanges changes for pr are requested
+	ReviewStateRequestChanges ReviewStateType = "REQUEST_CHANGES"
+	// ReviewStateRequestReview review is requested from user
+	ReviewStateRequestReview ReviewStateType = "REQUEST_REVIEW"
+	// ReviewStateUnknown state of pr is unknown
+	ReviewStateUnknown ReviewStateType = ""
+)
+
+// PullReview represents a pull request review
+type PullReview struct {
+	ID                int64           `json:"id"`
+	Reviewer          *User           `json:"user"`
+	State             ReviewStateType `json:"state"`
+	Body              string          `json:"body"`
+	CommitID          string          `json:"commit_id"`
+	Stale             bool            `json:"stale"`
+	Official          bool            `json:"official"`
+	CodeCommentsCount int             `json:"comments_count"`
+	Submitted         time.Time       `json:"submitted_at"`
+
+	HTMLURL     string `json:"html_url"`
+	HTMLPullURL string `json:"pull_request_url"`
+}
+
+// PullReviewComment represents a comment on a pull request review
+type PullReviewComment struct {
+	ID       int64  `json:"id"`
+	Body     string `json:"body"`
+	Reviewer *User  `json:"user"`
+	ReviewID int64  `json:"pull_request_review_id"`
+
+	Created time.Time `json:"created_at"`
+	Updated time.Time `json:"updated_at"`
+
+	Path         string `json:"path"`
+	CommitID     string `json:"commit_id"`
+	OrigCommitID string `json:"original_commit_id"`
+	DiffHunk     string `json:"diff_hunk"`
+	LineNum      uint64 `json:"position"`
+	OldLineNum   uint64 `json:"original_position"`
+
+	HTMLURL     string `json:"html_url"`
+	HTMLPullURL string `json:"pull_request_url"`
+}
+
+// CreatePullReviewOptions are options to create a pull review
+type CreatePullReviewOptions struct {
+	State    ReviewStateType           `json:"event"`
+	Body     string                    `json:"body"`
+	CommitID string                    `json:"commit_id"`
+	Comments []CreatePullReviewComment `json:"comments"`
+}
+
+// CreatePullReviewComment represent a review comment for creation api
+type CreatePullReviewComment struct {
+	// the tree path
+	Path string `json:"path"`
+	Body string `json:"body"`
+	// if comment to old file line or 0
+	OldLineNum int64 `json:"old_position"`
+	// if comment to new file line or 0
+	NewLineNum int64 `json:"new_position"`
+}
+
+// SubmitPullReviewOptions are options to submit a pending pull review
+type SubmitPullReviewOptions struct {
+	State ReviewStateType `json:"event"`
+	Body  string          `json:"body"`
+}
+
+// ListPullReviewsOptions options for listing PullReviews
+type ListPullReviewsOptions struct {
+	ListOptions
+}
+
+// Validate the CreatePullReviewOptions struct
+func (opt CreatePullReviewOptions) Validate() error {
+	if opt.State != ReviewStateApproved && len(strings.TrimSpace(opt.Body)) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	for i := range opt.Comments {
+		if err := opt.Comments[i].Validate(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Validate the SubmitPullReviewOptions struct
+func (opt SubmitPullReviewOptions) Validate() error {
+	if opt.State != ReviewStateApproved && len(strings.TrimSpace(opt.Body)) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	return nil
+}
+
+// Validate the CreatePullReviewComment struct
+func (opt CreatePullReviewComment) Validate() error {
+	if len(strings.TrimSpace(opt.Body)) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	if opt.NewLineNum != 0 && opt.OldLineNum != 0 {
+		return fmt.Errorf("old and new line num are set, cant identify the code comment position")
+	}
+	return nil
+}
+
+// ListPullReviews lists all reviews of a pull request
+func (c *Client) ListPullReviews(owner, repo string, index int64, opt ListPullReviewsOptions) ([]*PullReview, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	rs := make([]*PullReview, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews", owner, repo, index))
+	link.RawQuery = opt.ListOptions.getURLQuery().Encode()
+
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rs)
+	return rs, resp, err
+}
+
+// GetPullReview gets a specific review of a pull request
+func (c *Client) GetPullReview(owner, repo string, index, id int64) (*PullReview, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+
+	r := new(PullReview)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil, &r)
+	return r, resp, err
+}
+
+// ListPullReviewComments lists all comments of a pull request review
+func (c *Client) ListPullReviewComments(owner, repo string, index, id int64) ([]*PullReviewComment, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	rcl := make([]*PullReviewComment, 0, 4)
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d/comments", owner, repo, index, id))
+
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rcl)
+	return rcl, resp, err
+}
+
+// DeletePullReview delete a specific review from a pull request
+func (c *Client) DeletePullReview(owner, repo string, index, id int64) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, err
+	}
+
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil)
+	return resp, err
+}
+
+// CreatePullReview create a review to an pull request
+func (c *Client) CreatePullReview(owner, repo string, index int64, opt CreatePullReviewOptions) (*PullReview, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(PullReview)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
+}
+
+// SubmitPullReview submit a pending review to an pull request
+func (c *Client) SubmitPullReview(owner, repo string, index, id int64, opt SubmitPullReviewOptions) (*PullReview, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(PullReview)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id),
+		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
+}

vendor/code.gitea.io/sdk/gitea/release.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"strings"
 	"time"
 )
 
@@ -29,22 +30,28 @@ type Release struct {
 	Attachments  []*Attachment `json:"assets"`
 }
 
+// ListReleasesOptions options for listing repository's releases
+type ListReleasesOptions struct {
+	ListOptions
+}
+
 // ListReleases list releases of a repository
-func (c *Client) ListReleases(user, repo string) ([]*Release, error) {
-	releases := make([]*Release, 0, 10)
-	err := c.getParsedResponse("GET",
-		fmt.Sprintf("/repos/%s/%s/releases", user, repo),
+func (c *Client) ListReleases(user, repo string, opt ListReleasesOptions) ([]*Release, *Response, error) {
+	opt.setDefaults()
+	releases := make([]*Release, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases?%s", user, repo, opt.getURLQuery().Encode()),
 		nil, nil, &releases)
-	return releases, err
+	return releases, resp, err
 }
 
 // GetRelease get a release of a repository
-func (c *Client) GetRelease(user, repo string, id int64) (*Release, error) {
+func (c *Client) GetRelease(user, repo string, id int64) (*Release, *Response, error) {
 	r := new(Release)
-	err := c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
 		nil, nil, &r)
-	return r, err
+	return r, resp, err
 }
 
 // CreateReleaseOption options when creating a release
@@ -57,17 +64,28 @@ type CreateReleaseOption struct {
 	IsPrerelease bool   `json:"prerelease"`
 }
 
+// Validate the CreateReleaseOption struct
+func (opt CreateReleaseOption) Validate() error {
+	if len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
 // CreateRelease create a release
-func (c *Client) CreateRelease(user, repo string, form CreateReleaseOption) (*Release, error) {
-	body, err := json.Marshal(form)
+func (c *Client) CreateRelease(user, repo string, opt CreateReleaseOption) (*Release, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	r := new(Release)
-	err = c.getParsedResponse("POST",
+	resp, err := c.getParsedResponse("POST",
 		fmt.Sprintf("/repos/%s/%s/releases", user, repo),
 		jsonHeader, bytes.NewReader(body), r)
-	return r, err
+	return r, resp, err
 }
 
 // EditReleaseOption options when editing a release
@@ -81,22 +99,22 @@ type EditReleaseOption struct {
 }
 
 // EditRelease edit a release
-func (c *Client) EditRelease(user, repo string, id int64, form EditReleaseOption) (*Release, error) {
+func (c *Client) EditRelease(user, repo string, id int64, form EditReleaseOption) (*Release, *Response, error) {
 	body, err := json.Marshal(form)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	r := new(Release)
-	err = c.getParsedResponse("PATCH",
+	resp, err := c.getParsedResponse("PATCH",
 		fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
 		jsonHeader, bytes.NewReader(body), r)
-	return r, err
+	return r, resp, err
 }
 
 // DeleteRelease delete a release from a repository
-func (c *Client) DeleteRelease(user, repo string, id int64) error {
-	_, err := c.getResponse("DELETE",
+func (c *Client) DeleteRelease(user, repo string, id int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE",
 		fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
 		nil, nil)
-	return err
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/repo.go

@@ -1,4 +1,5 @@
 // Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2020 The Gitea Authors. All rights reserved.
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 
@@ -8,6 +9,8 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net/url"
+	"strings"
 	"time"
 )
 
@@ -56,28 +59,187 @@ type Repository struct {
 	AvatarURL                 string      `json:"avatar_url"`
 }
 
+// RepoType represent repo type
+type RepoType string
+
+const (
+	// RepoTypeNone dont specify a type
+	RepoTypeNone RepoType = ""
+	// RepoTypeSource is the default repo type
+	RepoTypeSource RepoType = "source"
+	// RepoTypeFork is a repo witch was forked from an other one
+	RepoTypeFork RepoType = "fork"
+	// RepoTypeMirror represents an mirror repo
+	RepoTypeMirror RepoType = "mirror"
+)
+
+// ListReposOptions options for listing repositories
+type ListReposOptions struct {
+	ListOptions
+}
+
 // ListMyRepos lists all repositories for the authenticated user that has access to.
-func (c *Client) ListMyRepos() ([]*Repository, error) {
-	repos := make([]*Repository, 0, 10)
-	return repos, c.getParsedResponse("GET", "/user/repos", nil, nil, &repos)
+func (c *Client) ListMyRepos(opt ListReposOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/repos?%s", opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // ListUserRepos list all repositories of one user by user's name
-func (c *Client) ListUserRepos(user string) ([]*Repository, error) {
-	repos := make([]*Repository, 0, 10)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/repos", user), nil, nil, &repos)
+func (c *Client) ListUserRepos(user string, opt ListReposOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/repos?%s", user, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// ListOrgReposOptions options for a organization's repositories
+type ListOrgReposOptions struct {
+	ListOptions
 }
 
 // ListOrgRepos list all repositories of one organization by organization's name
-func (c *Client) ListOrgRepos(org string) ([]*Repository, error) {
-	repos := make([]*Repository, 0, 10)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/repos", org), nil, nil, &repos)
+func (c *Client) ListOrgRepos(org string, opt ListOrgReposOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/repos?%s", org, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// SearchRepoOptions options for searching repositories
+type SearchRepoOptions struct {
+	ListOptions
+
+	// The keyword to query
+	Keyword string
+	// Limit search to repositories with keyword as topic
+	KeywordIsTopic bool
+	// Include search of keyword within repository description
+	KeywordInDescription bool
+
+	/*
+		User Filter
+	*/
+
+	// Repo Owner
+	OwnerID int64
+	// Stared By UserID
+	StarredByUserID int64
+
+	/*
+		Repo Attributes
+	*/
+
+	// pubic, private or all repositories (defaults to all)
+	IsPrivate *bool
+	// archived, non-archived or all repositories (defaults to all)
+	IsArchived *bool
+	// Exclude template repos from search
+	ExcludeTemplate bool
+	// Filter by "fork", "source", "mirror"
+	Type RepoType
+
+	/*
+		Sort Filters
+	*/
+
+	// sort repos by attribute. Supported values are "alpha", "created", "updated", "size", and "id". Default is "alpha"
+	Sort string
+	// sort order, either "asc" (ascending) or "desc" (descending). Default is "asc", ignored if "sort" is not specified.
+	Order string
+	// Repo owner to prioritize in the results
+	PrioritizedByOwnerID int64
+
+	/*
+		Cover EdgeCases
+	*/
+	// if set all other options are ignored and this string is used as query
+	RawQuery string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *SearchRepoOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.Keyword != "" {
+		query.Add("q", opt.Keyword)
+	}
+	if opt.KeywordIsTopic {
+		query.Add("topic", "true")
+	}
+	if opt.KeywordInDescription {
+		query.Add("includeDesc", "true")
+	}
+
+	// User Filter
+	if opt.OwnerID > 0 {
+		query.Add("uid", fmt.Sprintf("%d", opt.OwnerID))
+		query.Add("exclusive", "true")
+	}
+	if opt.StarredByUserID > 0 {
+		query.Add("starredBy", fmt.Sprintf("%d", opt.StarredByUserID))
+	}
+
+	// Repo Attributes
+	if opt.IsPrivate != nil {
+		query.Add("is_private", fmt.Sprintf("%v", opt.IsPrivate))
+	}
+	if opt.IsArchived != nil {
+		query.Add("archived", fmt.Sprintf("%v", opt.IsArchived))
+	}
+	if opt.ExcludeTemplate {
+		query.Add("template", "false")
+	}
+	if len(opt.Type) != 0 {
+		query.Add("mode", string(opt.Type))
+	}
+
+	// Sort Filters
+	if opt.Sort != "" {
+		query.Add("sort", opt.Sort)
+	}
+	if opt.PrioritizedByOwnerID > 0 {
+		query.Add("priority_owner_id", fmt.Sprintf("%d", opt.PrioritizedByOwnerID))
+	}
+	if opt.Order != "" {
+		query.Add("order", opt.Order)
+	}
+
+	return query.Encode()
+}
+
+type searchRepoResponse struct {
+	Repos []*Repository `json:"data"`
+}
+
+// SearchRepos searches for repositories matching the given filters
+func (c *Client) SearchRepos(opt SearchRepoOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := new(searchRepoResponse)
+
+	link, _ := url.Parse("/repos/search")
+
+	if len(opt.RawQuery) != 0 {
+		link.RawQuery = opt.RawQuery
+	} else {
+		link.RawQuery = opt.QueryEncode()
+		// IsPrivate only works on gitea >= 1.12.0
+		if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil && opt.IsPrivate != nil {
+			if *opt.IsPrivate {
+				// private repos only not supported on gitea <= 1.11.x
+				return nil, nil, err
+			}
+			link.Query().Add("private", "false")
+		}
+	}
+
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &repos)
+	return repos.Repos, resp, err
 }
 
 // CreateRepoOption options when creating repository
 type CreateRepoOption struct {
 	// Name of the repository to create
-	//
 	Name string `json:"name"`
 	// Description of the repository to create
 	Description string `json:"description"`
@@ -93,32 +255,51 @@ type CreateRepoOption struct {
 	License string `json:"license"`
 	// Readme of the repository to create
 	Readme string `json:"readme"`
+	// DefaultBranch of the repository (used when initializes and in template)
+	DefaultBranch string `json:"default_branch"`
+}
+
+// Validate the CreateRepoOption struct
+func (opt CreateRepoOption) Validate() error {
+	if len(strings.TrimSpace(opt.Name)) == 0 {
+		return fmt.Errorf("name is empty")
+	}
+	return nil
 }
 
 // CreateRepo creates a repository for authenticated user.
-func (c *Client) CreateRepo(opt CreateRepoOption) (*Repository, error) {
+func (c *Client) CreateRepo(opt CreateRepoOption) (*Repository, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", "/user/repos", jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("POST", "/user/repos", jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }
 
 // CreateOrgRepo creates an organization repository for authenticated user.
-func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, error) {
+func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", fmt.Sprintf("/org/%s/repos", org), jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/org/%s/repos", org), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }
 
 // GetRepo returns information of a repository of given owner.
-func (c *Client) GetRepo(owner, reponame string) (*Repository, error) {
+func (c *Client) GetRepo(owner, reponame string) (*Repository, *Response, error) {
 	repo := new(Repository)
-	return repo, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
+	return repo, resp, err
 }
 
 // EditRepoOption options when editing a repository's properties
@@ -156,49 +337,54 @@ type EditRepoOption struct {
 }
 
 // EditRepo edit the properties of a repository
-func (c *Client) EditRepo(owner, reponame string, opt EditRepoOption) (*Repository, error) {
+func (c *Client) EditRepo(owner, reponame string, opt EditRepoOption) (*Repository, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }
 
 // DeleteRepo deletes a repository of user or organization.
-func (c *Client) DeleteRepo(owner, repo string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
-	return err
-}
-
-// MigrateRepoOption options for migrating a repository from an external service
-type MigrateRepoOption struct {
-	CloneAddr    string `json:"clone_addr"`
-	AuthUsername string `json:"auth_username"`
-	AuthPassword string `json:"auth_password"`
-	UID          int    `json:"uid"`
-	RepoName     string `json:"repo_name"`
-	Mirror       bool   `json:"mirror"`
-	Private      bool   `json:"private"`
-	Description  string `json:"description"`
-}
-
-// MigrateRepo migrates a repository from other Git hosting sources for the
-// authenticated user.
-//
-// To migrate a repository for a organization, the authenticated user must be a
-// owner of the specified organization.
-func (c *Client) MigrateRepo(opt MigrateRepoOption) (*Repository, error) {
-	body, err := json.Marshal(&opt)
-	if err != nil {
-		return nil, err
-	}
-	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", "/repos/migrate", jsonHeader, bytes.NewReader(body), repo)
+func (c *Client) DeleteRepo(owner, repo string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
+	return resp, err
 }
 
 // MirrorSync adds a mirrored repository to the mirror sync queue.
-func (c *Client) MirrorSync(owner, repo string) error {
-	_, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/mirror-sync", owner, repo), nil, nil)
-	return err
+func (c *Client) MirrorSync(owner, repo string) (*Response, error) {
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/mirror-sync", owner, repo), nil, nil)
+	return resp, err
+}
+
+// GetRepoLanguages return language stats of a repo
+func (c *Client) GetRepoLanguages(owner, repo string) (map[string]int64, *Response, error) {
+	langMap := make(map[string]int64)
+
+	data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/languages", owner, repo), jsonHeader, nil)
+	if err != nil {
+		return nil, resp, err
+	}
+	if err = json.Unmarshal(data, &langMap); err != nil {
+		return nil, resp, err
+	}
+	return langMap, resp, nil
+}
+
+// ArchiveType represent supported archive formats by gitea
+type ArchiveType string
+
+const (
+	// ZipArchive represent zip format
+	ZipArchive ArchiveType = ".zip"
+	// TarGZArchive represent tar.gz format
+	TarGZArchive ArchiveType = ".tar.gz"
+)
+
+// GetArchive get an archive of a repository by git reference
+// e.g.: ref -> master, 70b7c74b33, v1.2.1, ...
+func (c *Client) GetArchive(owner, repo, ref string, ext ArchiveType) ([]byte, *Response, error) {
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/archive/%s%s", owner, repo, url.PathEscape(ref), ext), nil, nil)
 }

vendor/code.gitea.io/sdk/gitea/repo_branch.go

@@ -1,10 +1,13 @@
 // Copyright 2016 The Gogs Authors. All rights reserved.
+// Copyright 2020 The Gitea Authors. All rights reserved.
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 
 package gitea
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"time"
 )
@@ -47,16 +50,85 @@ type PayloadCommitVerification struct {
 type Branch struct {
 	Name                          string         `json:"name"`
 	Commit                        *PayloadCommit `json:"commit"`
+	Protected                     bool           `json:"protected"`
+	RequiredApprovals             int64          `json:"required_approvals"`
+	EnableStatusCheck             bool           `json:"enable_status_check"`
+	StatusCheckContexts           []string       `json:"status_check_contexts"`
+	UserCanPush                   bool           `json:"user_can_push"`
+	UserCanMerge                  bool           `json:"user_can_merge"`
+	EffectiveBranchProtectionName string         `json:"effective_branch_protection_name"`
+}
+
+// ListRepoBranchesOptions options for listing a repository's branches
+type ListRepoBranchesOptions struct {
+	ListOptions
 }
 
 // ListRepoBranches list all the branches of one repository
-func (c *Client) ListRepoBranches(user, repo string) ([]*Branch, error) {
-	branches := make([]*Branch, 0, 10)
-	return branches, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches", user, repo), nil, nil, &branches)
+func (c *Client) ListRepoBranches(user, repo string, opt ListRepoBranchesOptions) ([]*Branch, *Response, error) {
+	opt.setDefaults()
+	branches := make([]*Branch, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &branches)
+	return branches, resp, err
 }
 
 // GetRepoBranch get one branch's information of one repository
-func (c *Client) GetRepoBranch(user, repo, branch string) (*Branch, error) {
+func (c *Client) GetRepoBranch(user, repo, branch string) (*Branch, *Response, error) {
 	b := new(Branch)
-	return b, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil, &b)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil, &b)
+	if err != nil {
+		return nil, resp, err
+	}
+	return b, resp, nil
+}
+
+// DeleteRepoBranch delete a branch in a repository
+func (c *Client) DeleteRepoBranch(user, repo, branch string) (bool, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	return status == 204, resp, nil
+}
+
+// CreateBranchOption options when creating a branch in a repository
+type CreateBranchOption struct {
+	// Name of the branch to create
+	BranchName string `json:"new_branch_name"`
+	// Name of the old branch to create from (optional)
+	OldBranchName string `json:"old_branch_name"`
+}
+
+// Validate the CreateBranchOption struct
+func (opt CreateBranchOption) Validate() error {
+	if len(opt.BranchName) == 0 {
+		return fmt.Errorf("BranchName is empty")
+	}
+	if len(opt.BranchName) > 100 {
+		return fmt.Errorf("BranchName to long")
+	}
+	if len(opt.OldBranchName) > 100 {
+		return fmt.Errorf("OldBranchName to long")
+	}
+	return nil
+}
+
+// CreateBranch creates a branch for a user's repository
+func (c *Client) CreateBranch(owner, repo string, opt CreateBranchOption) (*Branch, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	branch := new(Branch)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branches", owner, repo), jsonHeader, bytes.NewReader(body), branch)
+	return branch, resp, err
 }

vendor/code.gitea.io/sdk/gitea/repo_branch_protection.go

@@ -0,0 +1,150 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// BranchProtection represents a branch protection for a repository
+type BranchProtection struct {
+	BranchName                  string    `json:"branch_name"`
+	EnablePush                  bool      `json:"enable_push"`
+	EnablePushWhitelist         bool      `json:"enable_push_whitelist"`
+	PushWhitelistUsernames      []string  `json:"push_whitelist_usernames"`
+	PushWhitelistTeams          []string  `json:"push_whitelist_teams"`
+	PushWhitelistDeployKeys     bool      `json:"push_whitelist_deploy_keys"`
+	EnableMergeWhitelist        bool      `json:"enable_merge_whitelist"`
+	MergeWhitelistUsernames     []string  `json:"merge_whitelist_usernames"`
+	MergeWhitelistTeams         []string  `json:"merge_whitelist_teams"`
+	EnableStatusCheck           bool      `json:"enable_status_check"`
+	StatusCheckContexts         []string  `json:"status_check_contexts"`
+	RequiredApprovals           int64     `json:"required_approvals"`
+	EnableApprovalsWhitelist    bool      `json:"enable_approvals_whitelist"`
+	ApprovalsWhitelistUsernames []string  `json:"approvals_whitelist_username"`
+	ApprovalsWhitelistTeams     []string  `json:"approvals_whitelist_teams"`
+	BlockOnRejectedReviews      bool      `json:"block_on_rejected_reviews"`
+	BlockOnOutdatedBranch       bool      `json:"block_on_outdated_branch"`
+	DismissStaleApprovals       bool      `json:"dismiss_stale_approvals"`
+	RequireSignedCommits        bool      `json:"require_signed_commits"`
+	ProtectedFilePatterns       string    `json:"protected_file_patterns"`
+	Created                     time.Time `json:"created_at"`
+	Updated                     time.Time `json:"updated_at"`
+}
+
+// CreateBranchProtectionOption options for creating a branch protection
+type CreateBranchProtectionOption struct {
+	BranchName                  string   `json:"branch_name"`
+	EnablePush                  bool     `json:"enable_push"`
+	EnablePushWhitelist         bool     `json:"enable_push_whitelist"`
+	PushWhitelistUsernames      []string `json:"push_whitelist_usernames"`
+	PushWhitelistTeams          []string `json:"push_whitelist_teams"`
+	PushWhitelistDeployKeys     bool     `json:"push_whitelist_deploy_keys"`
+	EnableMergeWhitelist        bool     `json:"enable_merge_whitelist"`
+	MergeWhitelistUsernames     []string `json:"merge_whitelist_usernames"`
+	MergeWhitelistTeams         []string `json:"merge_whitelist_teams"`
+	EnableStatusCheck           bool     `json:"enable_status_check"`
+	StatusCheckContexts         []string `json:"status_check_contexts"`
+	RequiredApprovals           int64    `json:"required_approvals"`
+	EnableApprovalsWhitelist    bool     `json:"enable_approvals_whitelist"`
+	ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
+	ApprovalsWhitelistTeams     []string `json:"approvals_whitelist_teams"`
+	BlockOnRejectedReviews      bool     `json:"block_on_rejected_reviews"`
+	BlockOnOutdatedBranch       bool     `json:"block_on_outdated_branch"`
+	DismissStaleApprovals       bool     `json:"dismiss_stale_approvals"`
+	RequireSignedCommits        bool     `json:"require_signed_commits"`
+	ProtectedFilePatterns       string   `json:"protected_file_patterns"`
+}
+
+// EditBranchProtectionOption options for editing a branch protection
+type EditBranchProtectionOption struct {
+	EnablePush                  *bool    `json:"enable_push"`
+	EnablePushWhitelist         *bool    `json:"enable_push_whitelist"`
+	PushWhitelistUsernames      []string `json:"push_whitelist_usernames"`
+	PushWhitelistTeams          []string `json:"push_whitelist_teams"`
+	PushWhitelistDeployKeys     *bool    `json:"push_whitelist_deploy_keys"`
+	EnableMergeWhitelist        *bool    `json:"enable_merge_whitelist"`
+	MergeWhitelistUsernames     []string `json:"merge_whitelist_usernames"`
+	MergeWhitelistTeams         []string `json:"merge_whitelist_teams"`
+	EnableStatusCheck           *bool    `json:"enable_status_check"`
+	StatusCheckContexts         []string `json:"status_check_contexts"`
+	RequiredApprovals           *int64   `json:"required_approvals"`
+	EnableApprovalsWhitelist    *bool    `json:"enable_approvals_whitelist"`
+	ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
+	ApprovalsWhitelistTeams     []string `json:"approvals_whitelist_teams"`
+	BlockOnRejectedReviews      *bool    `json:"block_on_rejected_reviews"`
+	BlockOnOutdatedBranch       *bool    `json:"block_on_outdated_branch"`
+	DismissStaleApprovals       *bool    `json:"dismiss_stale_approvals"`
+	RequireSignedCommits        *bool    `json:"require_signed_commits"`
+	ProtectedFilePatterns       *string  `json:"protected_file_patterns"`
+}
+
+// ListBranchProtectionsOptions list branch protection options
+type ListBranchProtectionsOptions struct {
+	ListOptions
+}
+
+// ListBranchProtections list branch protections for a repo
+func (c *Client) ListBranchProtections(owner, repo string, opt ListBranchProtectionsOptions) ([]*BranchProtection, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	bps := make([]*BranchProtection, 0, opt.PageSize)
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/branch_protections", owner, repo))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &bps)
+	return bps, resp, err
+}
+
+// GetBranchProtection gets a branch protection
+func (c *Client) GetBranchProtection(owner, repo, name string) (*BranchProtection, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	bp := new(BranchProtection)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil, bp)
+	return bp, resp, err
+}
+
+// CreateBranchProtection creates a branch protection for a repo
+func (c *Client) CreateBranchProtection(owner, repo string, opt CreateBranchProtectionOption) (*BranchProtection, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	bp := new(BranchProtection)
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branch_protections", owner, repo), jsonHeader, bytes.NewReader(body), bp)
+	return bp, resp, err
+}
+
+// EditBranchProtection edits a branch protection for a repo
+func (c *Client) EditBranchProtection(owner, repo, name string, opt EditBranchProtectionOption) (*BranchProtection, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	bp := new(BranchProtection)
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, bytes.NewReader(body), bp)
+	return bp, resp, err
+}
+
+// DeleteBranchProtection deletes a branch protection for a repo
+func (c *Client) DeleteBranchProtection(owner, repo, name string) (*Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil)
+	return resp, err
+}

vendor/code.gitea.io/sdk/gitea/repo_collaborator.go

@@ -10,48 +10,88 @@ import (
 	"fmt"
 )
 
+// ListCollaboratorsOptions options for listing a repository's collaborators
+type ListCollaboratorsOptions struct {
+	ListOptions
+}
+
 // ListCollaborators list a repository's collaborators
-func (c *Client) ListCollaborators(user, repo string) ([]*User, error) {
-	collaborators := make([]*User, 0, 10)
-	err := c.getParsedResponse("GET",
-		fmt.Sprintf("/repos/%s/%s/collaborators", user, repo),
+func (c *Client) ListCollaborators(user, repo string, opt ListCollaboratorsOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	collaborators := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/collaborators?%s", user, repo, opt.getURLQuery().Encode()),
 		nil, nil, &collaborators)
-	return collaborators, err
+	return collaborators, resp, err
 }
 
 // IsCollaborator check if a user is a collaborator of a repository
-func (c *Client) IsCollaborator(user, repo, collaborator string) (bool, error) {
-	status, err := c.getStatusCode("GET",
-		fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator),
-		nil, nil)
+func (c *Client) IsCollaborator(user, repo, collaborator string) (bool, *Response, error) {
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
 	if status == 204 {
-		return true, nil
+		return true, resp, nil
 	}
-	return false, nil
+	return false, resp, nil
 }
 
 // AddCollaboratorOption options when adding a user as a collaborator of a repository
 type AddCollaboratorOption struct {
-	Permission *string `json:"permission"`
+	Permission *AccessMode `json:"permission"`
+}
+
+// AccessMode represent the grade of access you have to something
+type AccessMode string
+
+const (
+	// AccessModeNone no access
+	AccessModeNone AccessMode = "none"
+	// AccessModeRead read access
+	AccessModeRead AccessMode = "read"
+	// AccessModeWrite write access
+	AccessModeWrite AccessMode = "write"
+	// AccessModeAdmin admin access
+	AccessModeAdmin AccessMode = "admin"
+	// AccessModeOwner owner
+	AccessModeOwner AccessMode = "owner"
+)
+
+// Validate the AddCollaboratorOption struct
+func (opt AddCollaboratorOption) Validate() error {
+	if opt.Permission != nil {
+		if *opt.Permission == AccessModeOwner {
+			*opt.Permission = AccessModeAdmin
+			return nil
+		}
+		if *opt.Permission == AccessModeNone {
+			opt.Permission = nil
+			return nil
+		}
+		if *opt.Permission != AccessModeRead && *opt.Permission != AccessModeWrite && *opt.Permission != AccessModeAdmin {
+			return fmt.Errorf("permission mode invalid")
+		}
+	}
+	return nil
 }
 
 // AddCollaborator add some user as a collaborator of a repository
-func (c *Client) AddCollaborator(user, repo, collaborator string, opt AddCollaboratorOption) error {
+func (c *Client) AddCollaborator(user, repo, collaborator string, opt AddCollaboratorOption) (*Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, bytes.NewReader(body))
-	return err
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), jsonHeader, bytes.NewReader(body))
+	return resp, err
 }
 
 // DeleteCollaborator remove a collaborator from a repository
-func (c *Client) DeleteCollaborator(user, repo, collaborator string) error {
-	_, err := c.getResponse("DELETE",
-		fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator),
-		nil, nil)
-	return err
+func (c *Client) DeleteCollaborator(user, repo, collaborator string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE",
+		fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/repo_commit.go

@@ -7,6 +7,8 @@ package gitea
 
 import (
 	"fmt"
+	"net/url"
+	"time"
 )
 
 // Identity for a person's identity like an author or committer
@@ -46,8 +48,41 @@ type Commit struct {
 	Parents    []*CommitMeta `json:"parents"`
 }
 
-// GetSingleCommit returns a single commit
-func (c *Client) GetSingleCommit(user, repo, commitID string) (*Commit, error) {
-	commit := new(Commit)
-	return commit, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s", user, repo, commitID), nil, nil, &commit)
+// CommitDateOptions store dates for GIT_AUTHOR_DATE and GIT_COMMITTER_DATE
+type CommitDateOptions struct {
+	Author    time.Time `json:"author"`
+	Committer time.Time `json:"committer"`
+}
+
+// GetSingleCommit returns a single commit
+func (c *Client) GetSingleCommit(user, repo, commitID string) (*Commit, *Response, error) {
+	commit := new(Commit)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s", user, repo, commitID), nil, nil, &commit)
+	return commit, resp, err
+}
+
+// ListCommitOptions list commit options
+type ListCommitOptions struct {
+	ListOptions
+	//SHA or branch to start listing commits from (usually 'master')
+	SHA string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListCommitOptions) QueryEncode() string {
+	query := opt.ListOptions.getURLQuery()
+	if opt.SHA != "" {
+		query.Add("sha", opt.SHA)
+	}
+	return query.Encode()
+}
+
+// ListRepoCommits return list of commits from a repo
+func (c *Client) ListRepoCommits(user, repo string, opt ListCommitOptions) ([]*Commit, *Response, error) {
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/commits", user, repo))
+	opt.setDefaults()
+	commits := make([]*Commit, 0, opt.PageSize)
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &commits)
+	return commits, resp, err
 }

vendor/code.gitea.io/sdk/gitea/repo_file.go

@@ -6,11 +6,189 @@
 package gitea
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 )
 
+// FileOptions options for all file APIs
+type FileOptions struct {
+	// message (optional) for the commit of this file. if not supplied, a default message will be used
+	Message string `json:"message"`
+	// branch (optional) to base this file from. if not given, the default branch is used
+	BranchName string `json:"branch"`
+	// new_branch (optional) will make a new branch from `branch` before creating the file
+	NewBranchName string `json:"new_branch"`
+	// `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+	Author    Identity          `json:"author"`
+	Committer Identity          `json:"committer"`
+	Dates     CommitDateOptions `json:"dates"`
+}
+
+// CreateFileOptions options for creating files
+// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+type CreateFileOptions struct {
+	FileOptions
+	// content must be base64 encoded
+	// required: true
+	Content string `json:"content"`
+}
+
+// DeleteFileOptions options for deleting files (used for other File structs below)
+// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+type DeleteFileOptions struct {
+	FileOptions
+	// sha is the SHA for the file that already exists
+	// required: true
+	SHA string `json:"sha"`
+}
+
+// UpdateFileOptions options for updating files
+// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+type UpdateFileOptions struct {
+	FileOptions
+	// sha is the SHA for the file that already exists
+	// required: true
+	SHA string `json:"sha"`
+	// content must be base64 encoded
+	// required: true
+	Content string `json:"content"`
+	// from_path (optional) is the path of the original file which will be moved/renamed to the path in the URL
+	FromPath string `json:"from_path"`
+}
+
+// FileLinksResponse contains the links for a repo's file
+type FileLinksResponse struct {
+	Self    *string `json:"self"`
+	GitURL  *string `json:"git"`
+	HTMLURL *string `json:"html"`
+}
+
+// ContentsResponse contains information about a repo's entry's (dir, file, symlink, submodule) metadata and content
+type ContentsResponse struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+	SHA  string `json:"sha"`
+	// `type` will be `file`, `dir`, `symlink`, or `submodule`
+	Type string `json:"type"`
+	Size int64  `json:"size"`
+	// `encoding` is populated when `type` is `file`, otherwise null
+	Encoding *string `json:"encoding"`
+	// `content` is populated when `type` is `file`, otherwise null
+	Content *string `json:"content"`
+	// `target` is populated when `type` is `symlink`, otherwise null
+	Target      *string `json:"target"`
+	URL         *string `json:"url"`
+	HTMLURL     *string `json:"html_url"`
+	GitURL      *string `json:"git_url"`
+	DownloadURL *string `json:"download_url"`
+	// `submodule_git_url` is populated when `type` is `submodule`, otherwise null
+	SubmoduleGitURL *string            `json:"submodule_git_url"`
+	Links           *FileLinksResponse `json:"_links"`
+}
+
+// FileCommitResponse contains information generated from a Git commit for a repo's file.
+type FileCommitResponse struct {
+	CommitMeta
+	HTMLURL   string        `json:"html_url"`
+	Author    *CommitUser   `json:"author"`
+	Committer *CommitUser   `json:"committer"`
+	Parents   []*CommitMeta `json:"parents"`
+	Message   string        `json:"message"`
+	Tree      *CommitMeta   `json:"tree"`
+}
+
+// FileResponse contains information about a repo's file
+type FileResponse struct {
+	Content      *ContentsResponse          `json:"content"`
+	Commit       *FileCommitResponse        `json:"commit"`
+	Verification *PayloadCommitVerification `json:"verification"`
+}
+
+// FileDeleteResponse contains information about a repo's file that was deleted
+type FileDeleteResponse struct {
+	Content      interface{}                `json:"content"` // to be set to nil
+	Commit       *FileCommitResponse        `json:"commit"`
+	Verification *PayloadCommitVerification `json:"verification"`
+}
+
 // GetFile downloads a file of repository, ref can be branch/tag/commit.
 // e.g.: ref -> master, tree -> macaron.go(no leading slash)
-func (c *Client) GetFile(user, repo, ref, tree string) ([]byte, error) {
+func (c *Client) GetFile(user, repo, ref, tree string) ([]byte, *Response, error) {
 	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/raw/%s/%s", user, repo, ref, tree), nil, nil)
 }
+
+// GetContents get the metadata and contents (if a file) of an entry in a repository, or a list of entries if a dir
+// ref is optional
+func (c *Client) GetContents(owner, repo, ref, filepath string) (*ContentsResponse, *Response, error) {
+	cr := new(ContentsResponse)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/contents/%s?ref=%s", owner, repo, filepath, ref), jsonHeader, nil, cr)
+	return cr, resp, err
+}
+
+// CreateFile create a file in a repository
+func (c *Client) CreateFile(owner, repo, filepath string, opt CreateFileOptions) (*FileResponse, *Response, error) {
+	var err error
+	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
+		return nil, nil, err
+	}
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	fr := new(FileResponse)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	return fr, resp, err
+}
+
+// UpdateFile update a file in a repository
+func (c *Client) UpdateFile(owner, repo, filepath string, opt UpdateFileOptions) (*FileResponse, *Response, error) {
+	var err error
+	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
+		return nil, nil, err
+	}
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	fr := new(FileResponse)
+	resp, err := c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	return fr, resp, err
+}
+
+// DeleteFile delete a file from repository
+func (c *Client) DeleteFile(owner, repo, filepath string, opt DeleteFileOptions) (*Response, error) {
+	var err error
+	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
+		return nil, err
+	}
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != 200 && status != 204 {
+		return resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+	return resp, nil
+}
+
+func (c *Client) setDefaultBranchForOldVersions(owner, repo, branch string) (string, error) {
+	if len(branch) == 0 {
+		// Gitea >= 1.12.0 Use DefaultBranch on "", mimic this for older versions
+		if c.CheckServerVersionConstraint(">=1.12.0") != nil {
+			r, _, err := c.GetRepo(owner, repo)
+			if err != nil {
+				return "", err
+			}
+			return r.DefaultBranch, nil
+		}
+	}
+	return branch, nil
+}

vendor/code.gitea.io/sdk/gitea/repo_key.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net/url"
 	"time"
 )
 
@@ -24,30 +25,55 @@ type DeployKey struct {
 	Repository  *Repository `json:"repository,omitempty"`
 }
 
+// ListDeployKeysOptions options for listing a repository's deploy keys
+type ListDeployKeysOptions struct {
+	ListOptions
+	KeyID       int64
+	Fingerprint string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListDeployKeysOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.KeyID > 0 {
+		query.Add("key_id", fmt.Sprintf("%d", opt.KeyID))
+	}
+	if len(opt.Fingerprint) > 0 {
+		query.Add("fingerprint", opt.Fingerprint)
+	}
+	return query.Encode()
+}
+
 // ListDeployKeys list all the deploy keys of one repository
-func (c *Client) ListDeployKeys(user, repo string) ([]*DeployKey, error) {
-	keys := make([]*DeployKey, 0, 10)
-	return keys, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/keys", user, repo), nil, nil, &keys)
+func (c *Client) ListDeployKeys(user, repo string, opt ListDeployKeysOptions) ([]*DeployKey, *Response, error) {
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/keys", user, repo))
+	opt.setDefaults()
+	link.RawQuery = opt.QueryEncode()
+	keys := make([]*DeployKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // GetDeployKey get one deploy key with key id
-func (c *Client) GetDeployKey(user, repo string, keyID int64) (*DeployKey, error) {
+func (c *Client) GetDeployKey(user, repo string, keyID int64) (*DeployKey, *Response, error) {
 	key := new(DeployKey)
-	return key, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/keys/%d", user, repo, keyID), nil, nil, &key)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/keys/%d", user, repo, keyID), nil, nil, &key)
+	return key, resp, err
 }
 
 // CreateDeployKey options when create one deploy key
-func (c *Client) CreateDeployKey(user, repo string, opt CreateKeyOption) (*DeployKey, error) {
+func (c *Client) CreateDeployKey(user, repo string, opt CreateKeyOption) (*DeployKey, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	key := new(DeployKey)
-	return key, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/keys", user, repo), jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/keys", user, repo), jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // DeleteDeployKey delete deploy key with key id
-func (c *Client) DeleteDeployKey(owner, repo string, keyID int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/keys/%d", owner, repo, keyID), nil, nil)
-	return err
+func (c *Client) DeleteDeployKey(owner, repo string, keyID int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/keys/%d", owner, repo, keyID), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/repo_migrate.go

@@ -0,0 +1,115 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// GitServiceType represents a git service
+type GitServiceType string
+
+const (
+	// GitServicePlain represents a plain git service
+	GitServicePlain GitServiceType = "git"
+	//GitServiceGithub represents github.com
+	GitServiceGithub GitServiceType = "github"
+	// GitServiceGitlab represents a gitlab service
+	GitServiceGitlab GitServiceType = "gitlab"
+
+	// Not supported jet
+	// // GitServiceGitea represents a gitea service
+	// GitServiceGitea GitServiceType = "gitea"
+	// // GitServiceGogs represents a gogs service
+	// GitServiceGogs GitServiceType = "gogs"
+)
+
+// MigrateRepoOption options for migrating a repository from an external service
+type MigrateRepoOption struct {
+	RepoName  string `json:"repo_name"`
+	RepoOwner string `json:"repo_owner"`
+	// deprecated use RepoOwner
+	RepoOwnerID  int64          `json:"uid"`
+	CloneAddr    string         `json:"clone_addr"`
+	Service      GitServiceType `json:"service"`
+	AuthUsername string         `json:"auth_username"`
+	AuthPassword string         `json:"auth_password"`
+	AuthToken    string         `json:"auth_token"`
+	Mirror       bool           `json:"mirror"`
+	Private      bool           `json:"private"`
+	Description  string         `json:"description"`
+	Wiki         bool           `json:"wiki"`
+	Milestones   bool           `json:"milestones"`
+	Labels       bool           `json:"labels"`
+	Issues       bool           `json:"issues"`
+	PullRequests bool           `json:"pull_requests"`
+	Releases     bool           `json:"releases"`
+}
+
+// Validate the MigrateRepoOption struct
+func (opt *MigrateRepoOption) Validate() error {
+	// check user options
+	if len(opt.CloneAddr) == 0 {
+		return fmt.Errorf("CloneAddr required")
+	}
+	if len(opt.RepoName) == 0 {
+		return fmt.Errorf("RepoName required")
+	} else if len(opt.RepoName) > 100 {
+		return fmt.Errorf("RepoName to long")
+	}
+	if len(opt.Description) > 255 {
+		return fmt.Errorf("Description to long")
+	}
+	switch opt.Service {
+	case GitServiceGithub:
+		if len(opt.AuthToken) == 0 {
+			return fmt.Errorf("github require token authentication")
+		}
+	}
+	return nil
+}
+
+// MigrateRepo migrates a repository from other Git hosting sources for the authenticated user.
+//
+// To migrate a repository for a organization, the authenticated user must be a
+// owner of the specified organization.
+func (c *Client) MigrateRepo(opt MigrateRepoOption) (*Repository, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		if len(opt.AuthToken) != 0 {
+			// gitea <= 1.12 dont understand AuthToken
+			opt.AuthUsername = opt.AuthToken
+			opt.AuthPassword, opt.AuthToken = "", ""
+		}
+		if len(opt.RepoOwner) != 0 {
+			// gitea <= 1.12 dont understand RepoOwner
+			u, _, err := c.GetUserInfo(opt.RepoOwner)
+			if err != nil {
+				return nil, nil, err
+			}
+			opt.RepoOwnerID = u.ID
+		} else if opt.RepoOwnerID == 0 {
+			// gitea <= 1.12 require RepoOwnerID
+			u, _, err := c.GetMyUserInfo()
+			if err != nil {
+				return nil, nil, err
+			}
+			opt.RepoOwnerID = u.ID
+		}
+	}
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", "/repos/migrate", jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}

vendor/code.gitea.io/sdk/gitea/repo_refs.go

@@ -26,44 +26,44 @@ type GitObject struct {
 }
 
 // GetRepoRef get one ref's information of one repository
-func (c *Client) GetRepoRef(user, repo, ref string) (*Reference, error) {
+func (c *Client) GetRepoRef(user, repo, ref string) (*Reference, *Response, error) {
 	ref = strings.TrimPrefix(ref, "refs/")
 	r := new(Reference)
-	err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil, &r)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil, &r)
 	if _, ok := err.(*json.UnmarshalTypeError); ok {
 		// Multiple refs
-		return nil, errors.New("no exact match found for this ref")
+		return nil, resp, errors.New("no exact match found for this ref")
 	} else if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
 
-	return r, nil
+	return r, resp, nil
 }
 
 // GetRepoRefs get list of ref's information of one repository
-func (c *Client) GetRepoRefs(user, repo, ref string) ([]*Reference, error) {
+func (c *Client) GetRepoRefs(user, repo, ref string) ([]*Reference, *Response, error) {
 	ref = strings.TrimPrefix(ref, "refs/")
-	resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil)
+	data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil)
 	if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
 
 	// Attempt to unmarshal single returned ref.
 	r := new(Reference)
-	refErr := json.Unmarshal(resp, r)
+	refErr := json.Unmarshal(data, r)
 	if refErr == nil {
-		return []*Reference{r}, nil
+		return []*Reference{r}, resp, nil
 	}
 
 	// Attempt to unmarshal multiple refs.
 	var rs []*Reference
-	refsErr := json.Unmarshal(resp, &rs)
+	refsErr := json.Unmarshal(data, &rs)
 	if refsErr == nil {
 		if len(rs) == 0 {
-			return nil, errors.New("unexpected response: an array of refs with length 0")
+			return nil, resp, errors.New("unexpected response: an array of refs with length 0")
 		}
-		return rs, nil
+		return rs, resp, nil
 	}
 
-	return nil, fmt.Errorf("unmarshalling failed for both single and multiple refs: %s and %s", refErr, refsErr)
+	return nil, resp, fmt.Errorf("unmarshalling failed for both single and multiple refs: %s and %s", refErr, refsErr)
 }

vendor/code.gitea.io/sdk/gitea/repo_tag.go

@@ -17,8 +17,15 @@ type Tag struct {
 	TarballURL string      `json:"tarball_url"`
 }
 
-// ListRepoTags list all the branches of one repository
-func (c *Client) ListRepoTags(user, repo string) ([]*Tag, error) {
-	tags := make([]*Tag, 0, 10)
-	return tags, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tags", user, repo), nil, nil, &tags)
+// ListRepoTagsOptions options for listing a repository's tags
+type ListRepoTagsOptions struct {
+	ListOptions
+}
+
+// ListRepoTags list all the branches of one repository
+func (c *Client) ListRepoTags(user, repo string, opt ListRepoTagsOptions) ([]*Tag, *Response, error) {
+	opt.setDefaults()
+	tags := make([]*Tag, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tags?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &tags)
+	return tags, resp, err
 }

vendor/code.gitea.io/sdk/gitea/repo_topics.go

@@ -0,0 +1,58 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// ListRepoTopicsOptions options for listing repo's topics
+type ListRepoTopicsOptions struct {
+	ListOptions
+}
+
+// topicsList represents a list of repo's topics
+type topicsList struct {
+	Topics []string `json:"topics"`
+}
+
+// ListRepoTopics list all repository's topics
+func (c *Client) ListRepoTopics(user, repo string, opt ListRepoTopicsOptions) ([]string, *Response, error) {
+	opt.setDefaults()
+
+	list := new(topicsList)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/topics?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, list)
+	if err != nil {
+		return nil, resp, err
+	}
+	return list.Topics, resp, nil
+}
+
+// SetRepoTopics replaces the list of repo's topics
+func (c *Client) SetRepoTopics(user, repo string, list []string) (*Response, error) {
+
+	l := topicsList{Topics: list}
+
+	body, err := json.Marshal(&l)
+	if err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/topics", user, repo), jsonHeader, bytes.NewReader(body))
+	return resp, err
+}
+
+// AddRepoTopic adds a topic to a repo's topics list
+func (c *Client) AddRepoTopic(user, repo, topic string) (*Response, error) {
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
+	return resp, err
+}
+
+// DeleteRepoTopic deletes a topic from repo's topics list
+func (c *Client) DeleteRepoTopic(user, repo, topic string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
+	return resp, err
+}

vendor/code.gitea.io/sdk/gitea/repo_transfer.go

@@ -0,0 +1,33 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// TransferRepoOption options when transfer a repository's ownership
+type TransferRepoOption struct {
+	// required: true
+	NewOwner string `json:"new_owner"`
+	// ID of the team or teams to add to the repository. Teams can only be added to organization-owned repositories.
+	TeamIDs *[]int64 `json:"team_ids"`
+}
+
+// TransferRepo transfers the ownership of a repository
+func (c *Client) TransferRepo(owner, reponame string, opt TransferRepoOption) (*Repository, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/transfer", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}

vendor/code.gitea.io/sdk/gitea/repo_tree.go

@@ -30,12 +30,12 @@ type GitTreeResponse struct {
 
 // GetTrees downloads a file of repository, ref can be branch/tag/commit.
 // e.g.: ref -> master, tree -> macaron.go(no leading slash)
-func (c *Client) GetTrees(user, repo, ref string, recursive bool) (*GitTreeResponse, error) {
-	var trees GitTreeResponse
+func (c *Client) GetTrees(user, repo, ref string, recursive bool) (*GitTreeResponse, *Response, error) {
+	trees := new(GitTreeResponse)
 	var path = fmt.Sprintf("/repos/%s/%s/git/trees/%s", user, repo, ref)
 	if recursive {
 		path += "?recursive=1"
 	}
-	err := c.getParsedResponse("GET", path, nil, nil, &trees)
-	return &trees, err
+	resp, err := c.getParsedResponse("GET", path, nil, nil, trees)
+	return trees, resp, err
 }

vendor/code.gitea.io/sdk/gitea/repo_watch.go

@@ -21,21 +21,55 @@ type WatchInfo struct {
 }
 
 // GetWatchedRepos list all the watched repos of user
-func (c *Client) GetWatchedRepos(user, pass string) ([]*Repository, error) {
+func (c *Client) GetWatchedRepos(user string) ([]*Repository, *Response, error) {
 	repos := make([]*Repository, 0, 10)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/subscriptions", user),
-		http.Header{"Authorization": []string{"Basic " + BasicAuthEncode(user, pass)}}, nil, &repos)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/subscriptions", user), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// GetMyWatchedRepos list repositories watched by the authenticated user
+func (c *Client) GetMyWatchedRepos() ([]*Repository, *Response, error) {
+	repos := make([]*Repository, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/subscriptions"), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// CheckRepoWatch check if the current user is watching a repo
+func (c *Client) CheckRepoWatch(repoUser, repoName string) (bool, *Response, error) {
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	switch status {
+	case http.StatusNotFound:
+		return false, resp, nil
+	case http.StatusOK:
+		return true, resp, nil
+	default:
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
+	}
 }
 
 // WatchRepo start to watch a repository
-func (c *Client) WatchRepo(user, pass, repoUser, repoName string) (*WatchInfo, error) {
-	i := new(WatchInfo)
-	return i, c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName),
-		http.Header{"Authorization": []string{"Basic " + BasicAuthEncode(user, pass)}}, nil, i)
+func (c *Client) WatchRepo(repoUser, repoName string) (*Response, error) {
+	status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusOK {
+		return resp, nil
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
 }
 
-// UnWatchRepo start to watch a repository
-func (c *Client) UnWatchRepo(user, pass, repoUser, repoName string) (int, error) {
-	return c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName),
-		http.Header{"Authorization": []string{"Basic " + BasicAuthEncode(user, pass)}}, nil)
+// UnWatchRepo stop to watch a repository
+func (c *Client) UnWatchRepo(repoUser, repoName string) (*Response, error) {
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusNoContent {
+		return resp, nil
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
 }

vendor/code.gitea.io/sdk/gitea/settings.go

@@ -0,0 +1,72 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+// GlobalUISettings represent the global ui settings of a gitea instance witch is exposed by API
+type GlobalUISettings struct {
+	AllowedReactions []string `json:"allowed_reactions"`
+}
+
+// GlobalRepoSettings represent the global repository settings of a gitea instance witch is exposed by API
+type GlobalRepoSettings struct {
+	MirrorsDisabled bool `json:"mirrors_disabled"`
+	HTTPGitDisabled bool `json:"http_git_disabled"`
+}
+
+// GlobalAPISettings contains global api settings exposed by it
+type GlobalAPISettings struct {
+	MaxResponseItems       int   `json:"max_response_items"`
+	DefaultPagingNum       int   `json:"default_paging_num"`
+	DefaultGitTreesPerPage int   `json:"default_git_trees_per_page"`
+	DefaultMaxBlobSize     int64 `json:"default_max_blob_size"`
+}
+
+// GlobalAttachmentSettings contains global Attachment settings exposed by API
+type GlobalAttachmentSettings struct {
+	Enabled      bool   `json:"enabled"`
+	AllowedTypes string `json:"allowed_types"`
+	MaxSize      int64  `json:"max_size"`
+	MaxFiles     int    `json:"max_files"`
+}
+
+// GetGlobalUISettings get global ui settings witch are exposed by API
+func (c *Client) GetGlobalUISettings() (*GlobalUISettings, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalUISettings)
+	resp, err := c.getParsedResponse("GET", "/settings/ui", jsonHeader, nil, &conf)
+	return conf, resp, err
+}
+
+// GetGlobalRepoSettings get global repository settings witch are exposed by API
+func (c *Client) GetGlobalRepoSettings() (*GlobalRepoSettings, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalRepoSettings)
+	resp, err := c.getParsedResponse("GET", "/settings/repository", jsonHeader, nil, &conf)
+	return conf, resp, err
+}
+
+// GetGlobalAPISettings get global api settings witch are exposed by it
+func (c *Client) GetGlobalAPISettings() (*GlobalAPISettings, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalAPISettings)
+	resp, err := c.getParsedResponse("GET", "/settings/api", jsonHeader, nil, &conf)
+	return conf, resp, err
+}
+
+// GetGlobalAttachmentSettings get global repository settings witch are exposed by API
+func (c *Client) GetGlobalAttachmentSettings() (*GlobalAttachmentSettings, *Response, error) {
+	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalAttachmentSettings)
+	resp, err := c.getParsedResponse("GET", "/settings/attachment", jsonHeader, nil, &conf)
+	return conf, resp, err
+}

vendor/code.gitea.io/sdk/gitea/status.go

@@ -50,29 +50,27 @@ type CreateStatusOption struct {
 }
 
 // CreateStatus creates a new Status for a given Commit
-//
-// POST /repos/:owner/:repo/statuses/:sha
-func (c *Client) CreateStatus(owner, repo, sha string, opts CreateStatusOption) (*Status, error) {
+func (c *Client) CreateStatus(owner, repo, sha string, opts CreateStatusOption) (*Status, *Response, error) {
 	body, err := json.Marshal(&opts)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	status := &Status{}
-	return status, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/statuses/%s", owner, repo, sha),
-		jsonHeader, bytes.NewReader(body), status)
+	status := new(Status)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/statuses/%s", owner, repo, sha), jsonHeader, bytes.NewReader(body), status)
+	return status, resp, err
 }
 
-// ListStatusesOption holds pagination information
+// ListStatusesOption options for listing a repository's commit's statuses
 type ListStatusesOption struct {
-	Page int
+	ListOptions
 }
 
 // ListStatuses returns all statuses for a given Commit
-//
-// GET /repos/:owner/:repo/commits/:ref/statuses
-func (c *Client) ListStatuses(owner, repo, sha string, opts ListStatusesOption) ([]*Status, error) {
-	statuses := make([]*Status, 0, 10)
-	return statuses, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/statuses?page=%d", owner, repo, sha, opts.Page), nil, nil, &statuses)
+func (c *Client) ListStatuses(owner, repo, sha string, opt ListStatusesOption) ([]*Status, *Response, error) {
+	opt.setDefaults()
+	statuses := make([]*Status, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/statuses?%s", owner, repo, sha, opt.getURLQuery().Encode()), nil, nil, &statuses)
+	return statuses, resp, err
 }
 
 // CombinedStatus holds the combined state of several statuses for a single commit
@@ -87,9 +85,8 @@ type CombinedStatus struct {
 }
 
 // GetCombinedStatus returns the CombinedStatus for a given Commit
-//
-// GET /repos/:owner/:repo/commits/:ref/status
-func (c *Client) GetCombinedStatus(owner, repo, sha string) (*CombinedStatus, error) {
-	status := &CombinedStatus{}
-	return status, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/status", owner, repo, sha), nil, nil, status)
+func (c *Client) GetCombinedStatus(owner, repo, sha string) (*CombinedStatus, *Response, error) {
+	status := new(CombinedStatus)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/status", owner, repo, sha), nil, nil, status)
+	return status, resp, err
 }

vendor/code.gitea.io/sdk/gitea/user.go

@@ -29,15 +29,15 @@ type User struct {
 }
 
 // GetUserInfo get user info by user's name
-func (c *Client) GetUserInfo(user string) (*User, error) {
+func (c *Client) GetUserInfo(user string) (*User, *Response, error) {
 	u := new(User)
-	err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s", user), nil, nil, u)
-	return u, err
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s", user), nil, nil, u)
+	return u, resp, err
 }
 
 // GetMyUserInfo get user info of current user
-func (c *Client) GetMyUserInfo() (*User, error) {
+func (c *Client) GetMyUserInfo() (*User, *Response, error) {
 	u := new(User)
-	err := c.getParsedResponse("GET", "/user", nil, nil, u)
-	return u, err
+	resp, err := c.getParsedResponse("GET", "/user", nil, nil, u)
+	return u, resp, err
 }

vendor/code.gitea.io/sdk/gitea/user_app.go

@@ -7,17 +7,11 @@ package gitea
 
 import (
 	"bytes"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"net/http"
+	"reflect"
 )
 
-// BasicAuthEncode generate base64 of basic auth head
-func BasicAuthEncode(user, pass string) string {
-	return base64.StdEncoding.EncodeToString([]byte(user + ":" + pass))
-}
-
 // AccessToken represents an API access token.
 type AccessToken struct {
 	ID             int64  `json:"id"`
@@ -26,11 +20,20 @@ type AccessToken struct {
 	TokenLastEight string `json:"token_last_eight"`
 }
 
-// ListAccessTokens lista all the access tokens of user
-func (c *Client) ListAccessTokens(user, pass string) ([]*AccessToken, error) {
-	tokens := make([]*AccessToken, 0, 10)
-	return tokens, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/tokens", user),
-		http.Header{"Authorization": []string{"Basic " + BasicAuthEncode(user, pass)}}, nil, &tokens)
+// ListAccessTokensOptions options for listing a users's access tokens
+type ListAccessTokensOptions struct {
+	ListOptions
+}
+
+// ListAccessTokens lists all the access tokens of user
+func (c *Client) ListAccessTokens(opts ListAccessTokensOptions) ([]*AccessToken, *Response, error) {
+	if len(c.username) == 0 {
+		return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+	}
+	opts.setDefaults()
+	tokens := make([]*AccessToken, 0, opts.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/tokens?%s", c.username, opts.getURLQuery().Encode()), jsonHeader, nil, &tokens)
+	return tokens, resp, err
 }
 
 // CreateAccessTokenOption options when create access token
@@ -39,21 +42,39 @@ type CreateAccessTokenOption struct {
 }
 
 // CreateAccessToken create one access token with options
-func (c *Client) CreateAccessToken(user, pass string, opt CreateAccessTokenOption) (*AccessToken, error) {
+func (c *Client) CreateAccessToken(opt CreateAccessTokenOption) (*AccessToken, *Response, error) {
+	if len(c.username) == 0 {
+		return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	t := new(AccessToken)
-	return t, c.getParsedResponse("POST", fmt.Sprintf("/users/%s/tokens", user),
-		http.Header{
-			"content-type":  []string{"application/json"},
-			"Authorization": []string{"Basic " + BasicAuthEncode(user, pass)}},
-		bytes.NewReader(body), t)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/users/%s/tokens", c.username), jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
 }
 
-// DeleteAccessToken delete token with key id
-func (c *Client) DeleteAccessToken(user string, keyID int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/%s/tokens/%d", user, keyID), nil, nil)
-	return err
+// DeleteAccessToken delete token, identified by ID and if not available by name
+func (c *Client) DeleteAccessToken(value interface{}) (*Response, error) {
+	if len(c.username) == 0 {
+		return nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+	}
+
+	var token = ""
+
+	switch reflect.ValueOf(value).Kind() {
+	case reflect.Int64:
+		token = fmt.Sprintf("%d", value.(int64))
+	case reflect.String:
+		if err := c.CheckServerVersionConstraint(">= 1.13.0"); err != nil {
+			return nil, err
+		}
+		token = value.(string)
+	default:
+		return nil, fmt.Errorf("only string and int64 supported")
+	}
+
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/users/%s/tokens/%s", c.username, token), jsonHeader, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/user_email.go

@@ -7,6 +7,7 @@ package gitea
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 )
 
 // Email an email address belonging to a user
@@ -16,10 +17,17 @@ type Email struct {
 	Primary  bool   `json:"primary"`
 }
 
+// ListEmailsOptions options for listing current's user emails
+type ListEmailsOptions struct {
+	ListOptions
+}
+
 // ListEmails all the email addresses of user
-func (c *Client) ListEmails() ([]*Email, error) {
-	emails := make([]*Email, 0, 3)
-	return emails, c.getParsedResponse("GET", "/user/emails", nil, nil, &emails)
+func (c *Client) ListEmails(opt ListEmailsOptions) ([]*Email, *Response, error) {
+	opt.setDefaults()
+	emails := make([]*Email, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/emails?%s", opt.getURLQuery().Encode()), nil, nil, &emails)
+	return emails, resp, err
 }
 
 // CreateEmailOption options when creating email addresses
@@ -29,13 +37,14 @@ type CreateEmailOption struct {
 }
 
 // AddEmail add one email to current user with options
-func (c *Client) AddEmail(opt CreateEmailOption) ([]*Email, error) {
+func (c *Client) AddEmail(opt CreateEmailOption) ([]*Email, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	emails := make([]*Email, 0, 3)
-	return emails, c.getParsedResponse("POST", "/user/emails", jsonHeader, bytes.NewReader(body), emails)
+	resp, err := c.getParsedResponse("POST", "/user/emails", jsonHeader, bytes.NewReader(body), &emails)
+	return emails, resp, err
 }
 
 // DeleteEmailOption options when deleting email addresses
@@ -45,11 +54,11 @@ type DeleteEmailOption struct {
 }
 
 // DeleteEmail delete one email of current users'
-func (c *Client) DeleteEmail(opt DeleteEmailOption) error {
+func (c *Client) DeleteEmail(opt DeleteEmailOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("DELETE", "/user/emails", jsonHeader, bytes.NewReader(body))
-	return err
+	_, resp, err := c.getResponse("DELETE", "/user/emails", jsonHeader, bytes.NewReader(body))
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/user_follow.go

@@ -6,50 +6,68 @@ package gitea
 
 import "fmt"
 
+// ListFollowersOptions options for listing followers
+type ListFollowersOptions struct {
+	ListOptions
+}
+
 // ListMyFollowers list all the followers of current user
-func (c *Client) ListMyFollowers(page int) ([]*User, error) {
-	users := make([]*User, 0, 10)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/user/followers?page=%d", page), nil, nil, &users)
+func (c *Client) ListMyFollowers(opt ListFollowersOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/followers?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // ListFollowers list all the followers of one user
-func (c *Client) ListFollowers(user string, page int) ([]*User, error) {
-	users := make([]*User, 0, 10)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/followers?page=%d", user, page), nil, nil, &users)
+func (c *Client) ListFollowers(user string, opt ListFollowersOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/followers?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
+}
+
+// ListFollowingOptions options for listing a user's users being followed
+type ListFollowingOptions struct {
+	ListOptions
 }
 
 // ListMyFollowing list all the users current user followed
-func (c *Client) ListMyFollowing(page int) ([]*User, error) {
-	users := make([]*User, 0, 10)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/user/following?page=%d", page), nil, nil, &users)
+func (c *Client) ListMyFollowing(opt ListFollowingOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/following?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // ListFollowing list all the users the user followed
-func (c *Client) ListFollowing(user string, page int) ([]*User, error) {
-	users := make([]*User, 0, 10)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/following?page=%d", user, page), nil, nil, &users)
+func (c *Client) ListFollowing(user string, opt ListFollowingOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/following?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // IsFollowing if current user followed the target
-func (c *Client) IsFollowing(target string) bool {
-	_, err := c.getResponse("GET", fmt.Sprintf("/user/following/%s", target), nil, nil)
-	return err == nil
+func (c *Client) IsFollowing(target string) (bool, *Response) {
+	_, resp, err := c.getResponse("GET", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	return err == nil, resp
 }
 
 // IsUserFollowing if the user followed the target
-func (c *Client) IsUserFollowing(user, target string) bool {
-	_, err := c.getResponse("GET", fmt.Sprintf("/users/%s/following/%s", user, target), nil, nil)
-	return err == nil
+func (c *Client) IsUserFollowing(user, target string) (bool, *Response) {
+	_, resp, err := c.getResponse("GET", fmt.Sprintf("/users/%s/following/%s", user, target), nil, nil)
+	return err == nil, resp
 }
 
 // Follow set current user follow the target
-func (c *Client) Follow(target string) error {
-	_, err := c.getResponse("PUT", fmt.Sprintf("/user/following/%s", target), nil, nil)
-	return err
+func (c *Client) Follow(target string) (*Response, error) {
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	return resp, err
 }
 
 // Unfollow set current user unfollow the target
-func (c *Client) Unfollow(target string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/following/%s", target), nil, nil)
-	return err
+func (c *Client) Unfollow(target string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/user_gpgkey.go

@@ -33,22 +33,32 @@ type GPGKeyEmail struct {
 	Verified bool   `json:"verified"`
 }
 
+// ListGPGKeysOptions options for listing a user's GPGKeys
+type ListGPGKeysOptions struct {
+	ListOptions
+}
+
 // ListGPGKeys list all the GPG keys of the user
-func (c *Client) ListGPGKeys(user string) ([]*GPGKey, error) {
-	keys := make([]*GPGKey, 0, 10)
-	return keys, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/gpg_keys", user), nil, nil, &keys)
+func (c *Client) ListGPGKeys(user string, opt ListGPGKeysOptions) ([]*GPGKey, *Response, error) {
+	opt.setDefaults()
+	keys := make([]*GPGKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/gpg_keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // ListMyGPGKeys list all the GPG keys of current user
-func (c *Client) ListMyGPGKeys() ([]*GPGKey, error) {
-	keys := make([]*GPGKey, 0, 10)
-	return keys, c.getParsedResponse("GET", "/user/gpg_keys", nil, nil, &keys)
+func (c *Client) ListMyGPGKeys(opt *ListGPGKeysOptions) ([]*GPGKey, *Response, error) {
+	opt.setDefaults()
+	keys := make([]*GPGKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // GetGPGKey get current user's GPG key by key id
-func (c *Client) GetGPGKey(keyID int64) (*GPGKey, error) {
+func (c *Client) GetGPGKey(keyID int64) (*GPGKey, *Response, error) {
 	key := new(GPGKey)
-	return key, c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil, &key)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil, &key)
+	return key, resp, err
 }
 
 // CreateGPGKeyOption options create user GPG key
@@ -59,17 +69,18 @@ type CreateGPGKeyOption struct {
 }
 
 // CreateGPGKey create GPG key with options
-func (c *Client) CreateGPGKey(opt CreateGPGKeyOption) (*GPGKey, error) {
+func (c *Client) CreateGPGKey(opt CreateGPGKeyOption) (*GPGKey, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	key := new(GPGKey)
-	return key, c.getParsedResponse("POST", "/user/gpg_keys", jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", "/user/gpg_keys", jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // DeleteGPGKey delete GPG key with key id
-func (c *Client) DeleteGPGKey(keyID int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil)
-	return err
+func (c *Client) DeleteGPGKey(keyID int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/user_key.go

@@ -24,22 +24,32 @@ type PublicKey struct {
 	KeyType     string    `json:"key_type,omitempty"`
 }
 
+// ListPublicKeysOptions options for listing a user's PublicKeys
+type ListPublicKeysOptions struct {
+	ListOptions
+}
+
 // ListPublicKeys list all the public keys of the user
-func (c *Client) ListPublicKeys(user string) ([]*PublicKey, error) {
-	keys := make([]*PublicKey, 0, 10)
-	return keys, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/keys", user), nil, nil, &keys)
+func (c *Client) ListPublicKeys(user string, opt ListPublicKeysOptions) ([]*PublicKey, *Response, error) {
+	opt.setDefaults()
+	keys := make([]*PublicKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // ListMyPublicKeys list all the public keys of current user
-func (c *Client) ListMyPublicKeys() ([]*PublicKey, error) {
-	keys := make([]*PublicKey, 0, 10)
-	return keys, c.getParsedResponse("GET", "/user/keys", nil, nil, &keys)
+func (c *Client) ListMyPublicKeys(opt ListPublicKeysOptions) ([]*PublicKey, *Response, error) {
+	opt.setDefaults()
+	keys := make([]*PublicKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // GetPublicKey get current user's public key by key id
-func (c *Client) GetPublicKey(keyID int64) (*PublicKey, error) {
+func (c *Client) GetPublicKey(keyID int64) (*PublicKey, *Response, error) {
 	key := new(PublicKey)
-	return key, c.getParsedResponse("GET", fmt.Sprintf("/user/keys/%d", keyID), nil, nil, &key)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/keys/%d", keyID), nil, nil, &key)
+	return key, resp, err
 }
 
 // CreateKeyOption options when creating a key
@@ -53,17 +63,18 @@ type CreateKeyOption struct {
 }
 
 // CreatePublicKey create public key with options
-func (c *Client) CreatePublicKey(opt CreateKeyOption) (*PublicKey, error) {
+func (c *Client) CreatePublicKey(opt CreateKeyOption) (*PublicKey, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	key := new(PublicKey)
-	return key, c.getParsedResponse("POST", "/user/keys", jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", "/user/keys", jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // DeletePublicKey delete public key with key id
-func (c *Client) DeletePublicKey(keyID int64) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/keys/%d", keyID), nil, nil)
-	return err
+func (c *Client) DeletePublicKey(keyID int64) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/keys/%d", keyID), nil, nil)
+	return resp, err
 }

vendor/code.gitea.io/sdk/gitea/user_search.go

@@ -1,14 +1,44 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
 package gitea
 
-import "fmt"
+import (
+	"fmt"
+	"net/url"
+)
 
 type searchUsersResponse struct {
 	Users []*User `json:"data"`
 }
 
-// SearchUsers finds users by query
-func (c *Client) SearchUsers(query string, limit int) ([]*User, error) {
-	resp := new(searchUsersResponse)
-	err := c.getParsedResponse("GET", fmt.Sprintf("/users/search?q=%s&limit=%d", query, limit), nil, nil, &resp)
-	return resp.Users, err
+// SearchUsersOption options for SearchUsers
+type SearchUsersOption struct {
+	ListOptions
+	KeyWord string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *SearchUsersOption) QueryEncode() string {
+	query := make(url.Values)
+	if opt.Page > 0 {
+		query.Add("page", fmt.Sprintf("%d", opt.Page))
+	}
+	if opt.PageSize > 0 {
+		query.Add("limit", fmt.Sprintf("%d", opt.PageSize))
+	}
+	if len(opt.KeyWord) > 0 {
+		query.Add("q", opt.KeyWord)
+	}
+	return query.Encode()
+}
+
+// SearchUsers finds users by query
+func (c *Client) SearchUsers(opt SearchUsersOption) ([]*User, *Response, error) {
+	link, _ := url.Parse("/users/search")
+	link.RawQuery = opt.QueryEncode()
+	userResp := new(searchUsersResponse)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &userResp)
+	return userResp.Users, resp, err
 }