some changes ;]]]]]

controller/issue.go

@@ -2,6 +2,7 @@ package controller
 
 import (
 	"code.gitea.io/sdk/gitea"
+	"fmt"
 	"gitea-issue/giteaClient"
 	"gitea-issue/model"
 	"github.com/gin-gonic/gin"
@@ -9,11 +10,11 @@ import (
 	"github.com/savaki/swag/swagger"
 	"net/http"
 	"strconv"
-	"fmt"
 )
 
 func PostIssue(c *gin.Context) {
 	var issueProxy model.PostCreateIssueProxy
+
 	if err := c.BindJSON(&issueProxy); err != nil {
 		c.AsciiJSON(http.StatusBadRequest, gin.H{
 			"message": "CREATE_ISSUE_ERROR",
@@ -22,6 +23,10 @@ func PostIssue(c *gin.Context) {
 		return
 	}
 
+	sudo := c.GetHeader("X-Sudo")
+	if (sudo != "") {
+		giteaClient.SudoUser(sudo)
+	}
 	giteaIssue, err := issueProxy.TransformToGiteaCreateIssueOption()
 	if err != nil {
 		c.AsciiJSON(http.StatusBadRequest, gin.H{
@@ -39,16 +44,16 @@ func PostIssue(c *gin.Context) {
 		})
 		return
 	}
-	c.AsciiJSON(http.StatusOK, response)
+	c.AsciiJSON(http.StatusOK, model.IssueTransformFromGitea(response))
 }
 
-func PostIssueSwagger() (*swagger.Endpoint){
+func PostIssueSwagger() (*swagger.Endpoint) {
 	return endpoint.New("post", "/issues", "Create issue",
 		endpoint.Handler(PostIssue),
 		endpoint.Description("Post new issue"),
 		endpoint.Body(model.PostCreateIssueProxy{}, "Issue object", true),
 		endpoint.Tags("issues"),
-		endpoint.Response(http.StatusOK, gitea.Issue{}, "Gitea Issue list"),
+		endpoint.Response(http.StatusOK, model.GetCreateIssueProxy{}, "Gitea Issue list"),
 	)
 }
 
@@ -60,16 +65,17 @@ func GetIssues(c *gin.Context) {
 		proxyIssues = append(proxyIssues, model.IssueTransformFromGitea(issue))
 	}
 
-	if(err != nil){
+	if (err != nil) {
 		c.AbortWithStatus(http.StatusNotFound)
 	}
 	c.AsciiJSON(http.StatusOK, proxyIssues)
 }
 
-func GetIssuesSwagger() (*swagger.Endpoint){
+func GetIssuesSwagger() (*swagger.Endpoint) {
 	return endpoint.New("get", "/issues", "List project issues",
 		endpoint.Handler(GetIssues),
 		endpoint.Description("Get all issues"),
+		endpoint.Security("token", "USER"),
 		endpoint.Tags("issues"),
 		endpoint.Response(http.StatusOK, []model.GetCreateIssueProxy{}, "Gitea Issue list"),
 	)
@@ -85,13 +91,14 @@ func GetIssue(c *gin.Context) {
 	if err != nil {
 		c.AbortWithStatus(http.StatusNotFound)
 	}
-	c.AsciiJSON(http.StatusOK, issue)
+	c.AsciiJSON(http.StatusOK, model.IssueTransformFromGitea(issue))
 }
 
-func GetIssueSwagger() (*swagger.Endpoint){
+func GetIssueSwagger() (*swagger.Endpoint) {
-	return endpoint.New("get", "/issue/:id", "Get one issue",
+	return endpoint.New("get", "/issues/:id", "Get one issue",
 		endpoint.Handler(GetIssue),
 		endpoint.Description("Get one issue"),
+		endpoint.Security("token", "USER"),
 		endpoint.Tags("issues"),
 		endpoint.Response(http.StatusOK, model.GetCreateIssueProxy{}, "Gitea Issue"),
 	)
@@ -104,17 +111,79 @@ func GetIssueComments(c *gin.Context) {
 		c.AsciiJSON(http.StatusNotFound, err.Error())
 	}
 	issueComments, err := giteaClient.GetIssueComments(issueId)
+	proxyComments := []model.GetCommentProxy{}
+
+	for _, comment := range issueComments {
+		proxyComments = append(proxyComments, model.CommentTransformFromGitea(comment))
+	}
+
+	if (err != nil) {
+		c.AbortWithStatus(http.StatusNotFound)
+	}
+	c.AsciiJSON(http.StatusOK, proxyComments)
+
 	if err != nil {
 		c.AbortWithStatus(http.StatusNotFound)
 	}
 	c.AsciiJSON(http.StatusOK, issueComments)
 }
 
-func GetIssueCommentsSwagger() (*swagger.Endpoint){
+func GetIssueCommentsSwagger() (*swagger.Endpoint) {
-	return endpoint.New("get", "/issue/:id/comments", "Get issue comments",
+	return endpoint.New("get", "/issues/:id/comments", "Get issue comments",
-		endpoint.Handler(GetIssue),
+		endpoint.Handler(GetIssueComments),
 		endpoint.Description("Get issue comments"),
+		endpoint.Security("token", "USER"),
 		endpoint.Tags("issues"),
 		endpoint.Response(http.StatusOK, []gitea.Comment{}, "Gitea issue comments"),
 	)
 }
+
+func PostIssueComment(c *gin.Context) {
+	var commentProxy model.PostCommentProxy
+
+	if err := c.BindJSON(&commentProxy); err != nil {
+		c.AsciiJSON(http.StatusBadRequest, gin.H{
+			"message": "CREATE_COMMENT_ERROR",
+			"error":   err.Error(),
+		})
+		return
+	}
+	issueId, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		fmt.Println(fmt.Sprintf("ParseInt err: %+v", err))
+		c.AsciiJSON(http.StatusNotFound, err.Error())
+	}
+
+	giteaComment, err := commentProxy.TransformToGiteaComment()
+	if err != nil {
+		c.AsciiJSON(http.StatusBadRequest, gin.H{
+			"message": "CREATE_COMMENT_ERROR",
+			"error":   err.Error(),
+		})
+		return
+	}
+	sudo := c.GetHeader("X-Sudo")
+	if (sudo != "") {
+		giteaClient.SudoUser(sudo)
+	}
+	response, err := giteaClient.CreateComment(issueId, giteaComment)
+	if err != nil {
+		c.AsciiJSON(http.StatusBadRequest, gin.H{
+			"message": "CREATE_ISSUE_ERROR",
+			"error":   err.Error(),
+		})
+		return
+	}
+	c.AsciiJSON(http.StatusOK, model.CommentTransformFromGitea(response))
+}
+
+func PostIssueCommentSwagger() (*swagger.Endpoint) {
+	return endpoint.New("post", "/issues/:id/comments", "Create issue comment",
+		endpoint.Handler(PostIssueComment),
+		endpoint.Description("Add issue comment"),
+		endpoint.Body(model.PostCommentProxy{}, "Comment object", true),
+		endpoint.Security("token", "USER"),
+		endpoint.Tags("issues"),
+		endpoint.Response(http.StatusOK, model.GetCommentProxy{}, "Gitea issue comments"),
+	)
+}

controller/label.go

@@ -17,7 +17,7 @@ func GetLabels(c *gin.Context) {
 	c.AsciiJSON(http.StatusOK, labels)
 }
 
-func GetLabelsSwagger() (*swagger.Endpoint){
+func GetLabelsSwagger() (*swagger.Endpoint) {
 	return endpoint.New("get", "/labels", "List project labels",
 		endpoint.Handler(GetLabels),
 		endpoint.Description("Get all labels"),

controller/user.go

@@ -0,0 +1,42 @@
+package controller
+
+import (
+	"code.gitea.io/sdk/gitea"
+	"gitea-issue/giteaClient"
+	"gitea-issue/model"
+	"github.com/gin-gonic/gin"
+	"github.com/savaki/swag/endpoint"
+	"github.com/savaki/swag/swagger"
+	"net/http"
+)
+
+func PostUser(c *gin.Context) {
+	var userProxy model.PostUserProxy
+
+	if err := c.BindJSON(&userProxy); err != nil {
+		c.AsciiJSON(http.StatusBadRequest, gin.H{
+			"message": "CREATE_USER_ERROR",
+			"error":   err.Error(),
+		})
+		return
+	}
+	response, err := giteaClient.CreateUser(userProxy.TransformToGiteaUser())
+	if err != nil {
+		c.AsciiJSON(http.StatusUnprocessableEntity, gin.H{
+			"message": "CREATE_USER_ERROR",
+			"error":   err.Error(),
+		})
+		return
+	}
+	c.AsciiJSON(http.StatusOK, response)
+}
+
+func PostUserSwagger() (*swagger.Endpoint) {
+	return endpoint.New("post", "/user", "Create user",
+		endpoint.Handler(PostUser),
+		endpoint.Description("Post new user"),
+		endpoint.Body(model.PostUserProxy{}, "User object", true),
+		endpoint.Tags("user"),
+		endpoint.Response(http.StatusOK, gitea.User{}, "Gitea User"),
+	)
+}

giteaClient/giteaClient.go

@@ -5,41 +5,55 @@ import (
 	"fmt"
 )
 
-var(
+var (
 	giteaClient *gitea.Client
 	giteaOwner  string
 	giteaRepo   string
 )
 
-func SetUp(config GiteaConfig){
+func SetUp(config GiteaConfig) {
 	giteaClient = gitea.NewClient(config.GiteaUrl, config.GiteaToken)
 	giteaOwner = config.GiteaOwner
 	giteaRepo = config.GiteaRepo
 }
 
-func GetUserInfo() (*gitea.User, error){
+func GetUserInfo() (*gitea.User, error) {
 	usr, err := giteaClient.GetMyUserInfo()
-	if(err != nil){
+	if (err != nil) {
 		return nil, err
 	}
 	return usr, nil
 }
 
+func SudoUser(username string) {
+	giteaClient.SetSudo(username)
+}
+
 func GetServerInfo() (string, error) {
 	ver, err := giteaClient.ServerVersion()
-	if(err != nil){
+	if (err != nil) {
 		return "", err
 	}
 	return ver, nil
 }
 
-func GetIssues() ([]*gitea.Issue, error){
+func CreateUser(user gitea.CreateUserOption) (*gitea.User, error) {
+
+	giteaUser, err := giteaClient.AdminCreateUser(user)
+	if (err != nil) {
+		fmt.Println(fmt.Sprintf("Gitea error: %+v", err.Error()))
+		return nil, err
+	}
+	return giteaUser, nil
+}
+
+func GetIssues() ([]*gitea.Issue, error) {
 	opt := gitea.ListIssueOption{
 		Page:  0,
-		State: "open",
+		State: "closed",
 	}
 	giteaIssues, err := giteaClient.ListRepoIssues(giteaOwner, giteaRepo, opt)
-	if( err != nil){
+	if (err != nil) {
 		fmt.Println(fmt.Sprintf("Gitea error: %+v", err.Error()))
 		return nil, err
 	}
@@ -48,7 +62,7 @@ func GetIssues() ([]*gitea.Issue, error){
 
 func GetIssue(issueID int64) (*gitea.Issue, error) {
 	giteaIssue, err := giteaClient.GetIssue(giteaOwner, giteaRepo, issueID)
-	if( err != nil){
+	if (err != nil) {
 		fmt.Println(fmt.Sprintf("GetIssue gitea error: %+v", err.Error()))
 		return nil, err
 	}
@@ -57,7 +71,7 @@ func GetIssue(issueID int64) (*gitea.Issue, error) {
 
 func GetIssueComments(issueID int64) ([]*gitea.Comment, error) {
 	giteaIssueComments, err := giteaClient.ListIssueComments(giteaOwner, giteaRepo, issueID)
-	if( err != nil){
+	if (err != nil) {
 		fmt.Println(fmt.Sprintf("Gitea get isse comments error: %+v", err.Error()))
 		return nil, err
 	}
@@ -66,18 +80,28 @@ func GetIssueComments(issueID int64) ([]*gitea.Comment, error) {
 
 func GetLabels() ([]*gitea.Label, error) {
 	giteaLabels, err := giteaClient.ListRepoLabels(giteaOwner, giteaRepo)
-	if( err != nil){
+	if (err != nil) {
 		fmt.Println(fmt.Sprintf("Gitea get labels error: %+v", err.Error()))
 		return nil, err
 	}
 	return giteaLabels, nil
 }
 
-func CreateIssue(issue gitea.CreateIssueOption) (*gitea.Issue, error){
+func CreateIssue(issue gitea.CreateIssueOption) (*gitea.Issue, error) {
 	giteaCreateIssue, err := giteaClient.CreateIssue(giteaOwner, giteaRepo, issue)
-	if( err != nil){
+	if (err != nil) {
 		fmt.Println(fmt.Sprintf("Gitea get labels error: %+v", err.Error()))
 		return nil, err
 	}
 	return giteaCreateIssue, nil
 }
+
+func CreateComment(id int64, option gitea.CreateIssueCommentOption) (*gitea.Comment, error) {
+	giteaComment, err := giteaClient.CreateIssueComment(giteaOwner, giteaRepo, id, option)
+	if (err != nil) {
+		fmt.Println(fmt.Sprintf("Gitea create comment error: %+v", err.Error()))
+		return nil, err
+	}
+	return giteaComment, nil
+
+}

main.go

@@ -4,37 +4,27 @@ import (
 	"fmt"
 	"gitea-issue/controller"
 	"gitea-issue/giteaClient"
+	"gitea-issue/proxy"
+	"gitea-issue/security"
 	"github.com/caarlos0/env"
 	"github.com/gin-contrib/cors"
 	"github.com/gin-gonic/gin"
-	"github.com/jinzhu/gorm"
 	_ "github.com/jinzhu/gorm/dialects/sqlite"
+	"github.com/savaki/swag"
+	"github.com/savaki/swag/swagger"
 	ginSwagger "github.com/swaggo/gin-swagger"
 	"github.com/swaggo/gin-swagger/swaggerFiles"
 	"net/http"
 	"strconv"
-	"github.com/savaki/swag"
-	"github.com/savaki/swag/swagger"
-
 )
 
 var (
-	db *gorm.DB
 	giteaConfig giteaClient.GiteaConfig
-	proxyConfig ProxyConfig
+	proxyConfig proxy.ProxyConfig
 )
 
-type ProxyConfig struct {
-	ProjectOrigin   string `env:"PROJECT_ORIGIN,required"`
-}
-
 func init() {
-	//open a db connection
+
-	var err error
-	db, err := gorm.Open("sqlite3", "./database.db")
-	if err != nil {
-		panic("failed to connect database")
-	}
 	if err := env.Parse(&giteaConfig); err != nil {
 		panic(fmt.Sprintf("ENV error: %+v", err.Error()))
 	}
@@ -43,7 +33,8 @@ func init() {
 	}
 
 	giteaClient.SetUp(giteaConfig)
-	db.AutoMigrate(&userModel{})
+	proxy.SetUp(proxyConfig)
+
 }
 
 func main() {
@@ -53,6 +44,7 @@ func main() {
 	config.AllowOrigins = []string{proxyConfig.ProjectOrigin}
 	router.Use(gin.Logger())
 	router.Use(cors.New(config))
+	router.Use(gin.Recovery())
 
 	proxyApi := swag.New(
 		swag.Title("Gitea issues proxy"),
@@ -62,37 +54,34 @@ func main() {
 		swag.Tag("issues", "Gitea issues proxy endpoints"),
 		swag.Tag("labels", "Gites labels for issue"),
 		swag.Endpoints(
+			controller.PostUserSwagger(),
 			controller.PostIssueSwagger(),
+			controller.PostIssueCommentSwagger(),
 			controller.GetIssuesSwagger(),
 			controller.GetIssueSwagger(),
 			controller.GetIssueCommentsSwagger(),
 			controller.GetLabelsSwagger()),
 	)
 
+	authorizedApi := router.Group("/", security.BearerToken())
+
 	proxyApi.Walk(func(path string, endpoint *swagger.Endpoint) {
 		h := endpoint.Handler.(func(c *gin.Context))
 		path = swag.ColonPath(path)
-		router.Handle(endpoint.Method, path, h)
+		authorizedApi.Handle(endpoint.Method, path, h)
 	})
 
-	router.GET("/swagger.json",  gin.WrapH(proxyApi.Handler(true)))
+	docs := router.Group("/")
+	docs.GET("/swagger.json", gin.WrapH(proxyApi.Handler(true)))
 	url := ginSwagger.URL("/swagger.json")
-	router.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler, url))
+	docs.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler, url))
 	_ = router.Run()
 
 }
 
-type (
-	userModel struct {
-		gorm.Model
-		Email string `json:"email"`
-		Token int    `json:"token"`
-	}
-)
-
 func getIssues(c *gin.Context) {
 	issues, err := giteaClient.GetIssues();
-	if(err != nil){
+	if (err != nil) {
 		c.AbortWithStatus(http.StatusNotFound)
 	}
 	c.AsciiJSON(http.StatusOK, issues)
@@ -131,4 +120,3 @@ func getLabels(c *gin.Context) {
 	}
 	c.AsciiJSON(http.StatusOK, labels)
 }
-

model/commentProxy.go

@@ -0,0 +1,35 @@
+package model
+
+import (
+	"code.gitea.io/sdk/gitea"
+	"time"
+)
+
+type GetCommentProxy struct {
+	Id             int64     `json:"id"`
+	Body           string    `json:"body"`
+	OriginalAuthor string    `json:"original_author"`
+	CreatedAt      time.Time `json:"created_at"`
+}
+
+type PostCommentProxy struct {
+	Body string `json:"body"`
+}
+
+func (c PostCommentProxy) TransformToGiteaComment() (gitea.CreateIssueCommentOption, error) {
+	giteaObject := gitea.CreateIssueCommentOption{
+		Body: c.Body,
+	}
+	return giteaObject, nil
+}
+
+func CommentTransformFromGitea(comment *gitea.Comment) (GetCommentProxy) {
+
+	giteaComment := GetCommentProxy{
+		Id:             comment.ID,
+		Body:           comment.Body,
+		OriginalAuthor: comment.OriginalAuthor,
+		CreatedAt:      comment.Created,
+	}
+	return giteaComment
+}

model/issueProxy.go

@@ -7,6 +7,7 @@ import (
 )
 
 type GetCreateIssueProxy struct {
+	Id     int64          `json:"id"`
 	Title  string         `json:"title"`
 	Body   string         `json:"body"`
 	Labels []*gitea.Label `json:"labels"`
@@ -19,14 +20,14 @@ type PostCreateIssueProxy struct {
 	Labels []*gitea.Label `json:"labels"`
 }
 
-func (c PostCreateIssueProxy) TransformToGiteaCreateIssueOption() (gitea.CreateIssueOption, error){
+func (c PostCreateIssueProxy) TransformToGiteaCreateIssueOption() (gitea.CreateIssueOption, error) {
 	giteaUser, err := giteaClient.GetUserInfo()
-	if( err != nil){
+	if (err != nil) {
 		return gitea.CreateIssueOption{}, err;
 	}
 	labels := []int64{}
 
-	for _, label := range c.Labels{
+	for _, label := range c.Labels {
 		labels = append(labels, label.ID)
 	}
 	giteaObject := gitea.CreateIssueOption{
@@ -43,6 +44,7 @@ func (c PostCreateIssueProxy) TransformToGiteaCreateIssueOption() (gitea.CreateI
 func IssueTransformFromGitea(issue *gitea.Issue) (GetCreateIssueProxy) {
 
 	giteaIssue := GetCreateIssueProxy{
+		Id:     issue.Index,
 		Title:  issue.Title,
 		Body:   issue.Body,
 		Labels: issue.Labels,

model/userProxy.go

@@ -0,0 +1,47 @@
+package model
+
+import (
+	"code.gitea.io/sdk/gitea"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+	"math/rand"
+	"unicode"
+)
+
+var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456!@#$%")
+
+func randSeq(n int) string {
+	b := make([]rune, n)
+	for i := range b {
+		b[i] = letters[rand.Intn(len(letters))]
+	}
+	return string(b)
+}
+
+type PostUserProxy struct {
+	Email     string `json:"email"`
+	FirstName string `json:"first_name"`
+	LastName  string `json:"last_name"`
+}
+
+func isMn(r rune) bool {
+	return unicode.Is(unicode.Mn, r)
+}
+
+func (c PostUserProxy) TransformToGiteaUser() (gitea.CreateUserOption) {
+
+	t := transform.Chain(norm.NFD, transform.RemoveFunc(isMn), norm.NFC)
+	username, _, _ := transform.String(t, c.FirstName+c.LastName)
+
+	giteaObject := gitea.CreateUserOption{
+		SourceID:           0,
+		LoginName:          c.Email,
+		Username:           username,
+		FullName:           c.FirstName + " " + c.LastName,
+		Email:              c.Email,
+		Password:           randSeq(12),
+		MustChangePassword: nil,
+		SendNotify:         false,
+	}
+	return giteaObject
+}

proxy/proxyClient.go

@@ -0,0 +1,9 @@
+package proxy
+
+var (
+	Bearer string
+)
+
+func SetUp(config ProxyConfig) {
+	Bearer = config.ProxyToken
+}

proxy/proxyConfig.go

@@ -0,0 +1,6 @@
+package proxy
+
+type ProxyConfig struct {
+	ProjectOrigin string `env:"PROJECT_ORIGIN,required"`
+	ProxyToken    string `env:"PROXY_TOKEN,required"`
+}

security/tokenMiddleware.go

@@ -0,0 +1,23 @@
+package security
+
+import (
+	"gitea-issue/proxy"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func BearerToken() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		token := c.GetHeader("Authorization")
+		if (token == "") {
+			c.AbortWithStatus(http.StatusBadRequest)
+		}
+		var tokenArr []string
+		tokenArr = strings.Split(token, " ")
+		if (tokenArr[1] != proxy.Bearer) {
+			c.AbortWithStatus(http.StatusUnauthorized)
+		}
+		c.Next()
+	}
+}