391 lines
11 KiB
Go
391 lines
11 KiB
Go
package handler
|
|
|
|
import (
|
|
"esproject"
|
|
"esproject/pkg/util"
|
|
"fmt"
|
|
"net/http"
|
|
"slices"
|
|
"strconv"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type projectRequest struct {
|
|
Name string `json:"name"`
|
|
OwnerId int64 `json:"owner_id"`
|
|
Tags []string `json:"tags"`
|
|
}
|
|
|
|
// project godoc
|
|
// @Summary Create new project
|
|
// @Tags project
|
|
// @Produce json
|
|
// @Param project body handler.projectRequest true "Project data in JSON"
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200 {object} esproject.Project "created project"
|
|
// @Router /api/project [post]
|
|
func (h *Handler) create(c *gin.Context) {
|
|
current, _ := c.Get(userCtx)
|
|
var input projectRequest
|
|
|
|
if (input.OwnerId != current) && (!util.MatchRole(c, "admin")) {
|
|
util.NewErrorResponse(c, http.StatusForbidden, "no perms")
|
|
return
|
|
}
|
|
|
|
if err := c.BindJSON(&input); err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
project, err := h.repo.CreateProject(input.OwnerId, input.Name, input.Tags)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, project)
|
|
}
|
|
|
|
// project/all godoc
|
|
// @Summary Get ids of projects
|
|
// @Tags project
|
|
// @Produce json
|
|
// @Param limit query int true "limit of projects size"
|
|
// @Param start query int true "select offset"
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200 {array} int
|
|
// @Router /api/project/all [get]
|
|
func (h *Handler) all(c *gin.Context) {
|
|
limit, err := strconv.Atoi(c.Query("limit"))
|
|
if err != nil {
|
|
limit = 10
|
|
}
|
|
start, err := strconv.Atoi(c.Query("start"))
|
|
if err != nil {
|
|
start = 0
|
|
}
|
|
|
|
c.JSON(http.StatusOK, h.repo.GetProjects(start, limit))
|
|
}
|
|
|
|
type countResponse struct {
|
|
Count int64 `json:"count"`
|
|
}
|
|
|
|
// user/count godoc
|
|
// @Summary Get count of projects
|
|
// @Tags project
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200 {object} handler.countResponse
|
|
// @Router /api/project/count [get]
|
|
func (h *Handler) count(c *gin.Context) {
|
|
c.JSON(http.StatusOK, countResponse{Count: h.repo.GetProjectsCount()})
|
|
}
|
|
|
|
// project/delete godoc
|
|
// @Summary Delete project by id (only for owner of project)
|
|
// @Tags project
|
|
// @Produce json
|
|
// @Param id path int true "id of project"
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200
|
|
// @Router /api/project/{id} [delete]
|
|
func (h *Handler) delete(c *gin.Context) {
|
|
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
|
|
project, err := h.repo.GetProject(id)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
current, _ := c.Get(userCtx)
|
|
currentUser, err := h.services.AuthorizeById(current.(int64))
|
|
if (err != nil) || ((project.Id != currentUser.Id) && (currentUser.Access != "admin")) {
|
|
util.NewErrorResponse(c, http.StatusForbidden, err.Error())
|
|
return
|
|
}
|
|
|
|
err = h.repo.DeleteProject(id)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, "{ \"status\": \"ok\" }")
|
|
}
|
|
|
|
// project godoc
|
|
// @Summary Get project by id
|
|
// @Tags project
|
|
// @Produce json
|
|
// @Param id path int true "id of project"
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200
|
|
// @Router /api/project/{id} [get]
|
|
func (h *Handler) getProject(c *gin.Context) {
|
|
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
|
|
project, err := h.repo.GetProject(id)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, project)
|
|
}
|
|
|
|
// project godoc
|
|
// @Summary Edit project (only for owner of project)
|
|
// @Tags project
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Param project body esproject.Project true "edited project"
|
|
// @Success 200 {object} esproject.Project
|
|
// @Router /api/project/ [post]
|
|
func (h *Handler) editProject(c *gin.Context) {
|
|
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
|
|
project, err := h.repo.GetProject(id)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
current, _ := c.Get(userCtx)
|
|
currentUser, err := h.services.AuthorizeById(current.(int64))
|
|
if (err != nil) || ((project.Id != currentUser.Id) && (currentUser.Access != "admin")) {
|
|
util.NewErrorResponse(c, http.StatusForbidden, err.Error())
|
|
return
|
|
}
|
|
|
|
var input esproject.Project
|
|
if err := c.BindJSON(&input); err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
input.Id = project.Id
|
|
|
|
response, err := h.repo.SaveProject(&input)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response)
|
|
}
|
|
|
|
type memberRequest struct {
|
|
Project int64 `json:"project"`
|
|
User int64 `json:"user"`
|
|
}
|
|
|
|
// member godoc
|
|
// @Summary invite member (only for owner of project)
|
|
// @Tags member
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Param project body handler.memberRequest true "invite data in json format"
|
|
// @Success 200 {object} esproject.ProjectInvite
|
|
// @Router /api/member/invite/ [post]
|
|
func (h *Handler) invite(c *gin.Context) {
|
|
var input memberRequest
|
|
if err := c.BindJSON(&input); err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
project, err := h.repo.GetProject(input.Project)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
current, _ := c.Get(userCtx)
|
|
currentUser, err := h.services.AuthorizeById(current.(int64))
|
|
if (err != nil) || ((input.User != project.OwnerId) && (currentUser.Access != "admin")) {
|
|
util.NewErrorResponse(c, http.StatusForbidden, err.Error())
|
|
return
|
|
}
|
|
|
|
invite, err := h.repo.CreateInvite(input.Project, input.User)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, invite)
|
|
}
|
|
|
|
// member godoc
|
|
// @Summary invites of current user
|
|
// @Tags member
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200 {array} int
|
|
// @Router /api/member/invite/my [get]
|
|
func (h *Handler) myInvites(c *gin.Context) {
|
|
|
|
current, _ := c.Get(userCtx)
|
|
currentUser, err := h.services.AuthorizeById(current.(int64))
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusForbidden, err.Error())
|
|
return
|
|
}
|
|
|
|
invites, err := h.repo.FindInvites("user = ?", fmt.Sprintf("%d", currentUser.Id))
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
var ans []int64
|
|
for _, inv := range invites {
|
|
ans = append(ans, inv.Id)
|
|
}
|
|
c.JSON(http.StatusOK, ans)
|
|
}
|
|
|
|
// member godoc
|
|
// @Summary accept invite
|
|
// @Tags member
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Param id path int true "id of invite"
|
|
// @Success 200
|
|
// @Router /api/member/invite/accept/{id} [post]
|
|
func (h *Handler) accept(c *gin.Context) {
|
|
current, _ := c.Get(userCtx)
|
|
|
|
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
|
|
invite, err := h.repo.GetInvite(id)
|
|
if (err != nil) || (invite.User != current) {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
project, err := h.repo.GetProject(invite.Project)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
project.Members = append(project.Members, invite.User)
|
|
|
|
err = h.repo.DeleteInvite(invite.Id)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
_, err = h.repo.SaveProject(project)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, "{ \"status\": \"ok\" }")
|
|
}
|
|
|
|
// member godoc
|
|
// @Summary kick member (only for owner of project)
|
|
// @Tags member
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Param project body handler.memberRequest true "invite data in json format"
|
|
// @Success 200
|
|
// @Router /api/member/kick/ [post]
|
|
func (h *Handler) kick(c *gin.Context) {
|
|
var input memberRequest
|
|
if err := c.BindJSON(&input); err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
project, err := h.repo.GetProject(input.Project)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
current, _ := c.Get(userCtx)
|
|
currentUser, err := h.services.AuthorizeById(current.(int64))
|
|
if (err != nil) || ((input.User != project.OwnerId) && (currentUser.Access != "admin")) {
|
|
util.NewErrorResponse(c, http.StatusForbidden, err.Error())
|
|
return
|
|
}
|
|
|
|
if !slices.Contains(project.Members, input.User) {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, "user is not in project")
|
|
return
|
|
}
|
|
|
|
project.Members = removeElement(project.Members, input.User)
|
|
c.JSON(http.StatusOK, "{ \"status\": \"ok\" }")
|
|
}
|
|
|
|
// project/my godoc
|
|
// @Summary Get ids of projects when user is member
|
|
// @Tags project
|
|
// @Produce json
|
|
// @Param limit query int true "limit of projects size"
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200 {array} int
|
|
// @Router /api/project/my [get]
|
|
func (h *Handler) my(c *gin.Context) {
|
|
limit, err := strconv.Atoi(c.Query("limit"))
|
|
current, _ := c.Get(userCtx)
|
|
if err != nil {
|
|
limit = 10
|
|
}
|
|
var result []int64
|
|
for _, p := range h.repo.GetProjects(0, int(h.repo.GetProjectsCount())) {
|
|
if (len(result) == limit) && (limit > 0) {
|
|
break
|
|
}
|
|
project, err := h.repo.GetProject(p)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
if (project.OwnerId == current.(int64)) || containsElement(project.Members, current.(int64)) {
|
|
result = append(result, project.Id)
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, result)
|
|
}
|
|
|
|
// member godoc
|
|
// @Summary invite by id
|
|
// @Tags member
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT Bearer token (authorization)"
|
|
// @Success 200 {array} int
|
|
// @Router /api/member/invite/{id} [get]
|
|
func (h *Handler) getInvite(c *gin.Context) {
|
|
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
|
|
invite, err := h.repo.GetInvite(id)
|
|
if err != nil {
|
|
util.NewErrorResponse(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, invite)
|
|
}
|
|
|
|
func removeElement(slice []int64, value int64) []int64 {
|
|
// Find the index of the value
|
|
for i, v := range slice {
|
|
if v == value {
|
|
return append(slice[:i], slice[i+1:]...)
|
|
}
|
|
}
|
|
return slice
|
|
}
|
|
|
|
func containsElement(slice []int64, value int64) bool {
|
|
// Find the index of the value
|
|
for _, v := range slice {
|
|
if v == value {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|