d2b09d854f
Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
503 lines
13 KiB
Go
503 lines
13 KiB
Go
// Copyright 2019 Sorint.lab
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"strconv"
|
|
|
|
"agola.io/agola/internal/db"
|
|
"agola.io/agola/internal/errors"
|
|
action "agola.io/agola/internal/services/configstore/action"
|
|
"agola.io/agola/internal/services/configstore/readdb"
|
|
"agola.io/agola/internal/util"
|
|
csapitypes "agola.io/agola/services/configstore/api/types"
|
|
"agola.io/agola/services/configstore/types"
|
|
|
|
"github.com/gorilla/mux"
|
|
"github.com/rs/zerolog"
|
|
)
|
|
|
|
type UserHandler struct {
|
|
log zerolog.Logger
|
|
readDB *readdb.ReadDB
|
|
}
|
|
|
|
func NewUserHandler(log zerolog.Logger, readDB *readdb.ReadDB) *UserHandler {
|
|
return &UserHandler{log: log, readDB: readDB}
|
|
}
|
|
|
|
func (h *UserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
|
|
var user *types.User
|
|
err := h.readDB.Do(ctx, func(tx *db.Tx) error {
|
|
var err error
|
|
user, err = h.readDB.GetUser(tx, userRef)
|
|
return errors.WithStack(err)
|
|
})
|
|
if err != nil {
|
|
h.log.Err(err).Send()
|
|
util.HTTPError(w, err)
|
|
return
|
|
}
|
|
|
|
if user == nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrNotExist, errors.Errorf("user %q doesn't exist", userRef)))
|
|
return
|
|
}
|
|
|
|
if err := util.HTTPResponse(w, http.StatusOK, user); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type CreateUserHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewCreateUserHandler(log zerolog.Logger, ah *action.ActionHandler) *CreateUserHandler {
|
|
return &CreateUserHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *CreateUserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var req *csapitypes.CreateUserRequest
|
|
d := json.NewDecoder(r.Body)
|
|
if err := d.Decode(&req); err != nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, err))
|
|
return
|
|
}
|
|
|
|
creq := &action.CreateUserRequest{
|
|
UserName: req.UserName,
|
|
}
|
|
if req.CreateUserLARequest != nil {
|
|
creq.CreateUserLARequest = &action.CreateUserLARequest{
|
|
RemoteSourceName: req.CreateUserLARequest.RemoteSourceName,
|
|
RemoteUserID: req.CreateUserLARequest.RemoteUserID,
|
|
RemoteUserName: req.CreateUserLARequest.RemoteUserName,
|
|
UserAccessToken: req.CreateUserLARequest.UserAccessToken,
|
|
Oauth2AccessToken: req.CreateUserLARequest.Oauth2AccessToken,
|
|
Oauth2RefreshToken: req.CreateUserLARequest.Oauth2RefreshToken,
|
|
Oauth2AccessTokenExpiresAt: req.CreateUserLARequest.Oauth2AccessTokenExpiresAt,
|
|
}
|
|
}
|
|
|
|
user, err := h.ah.CreateUser(ctx, creq)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
return
|
|
}
|
|
|
|
if err := util.HTTPResponse(w, http.StatusCreated, user); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type UpdateUserHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewUpdateUserHandler(log zerolog.Logger, ah *action.ActionHandler) *UpdateUserHandler {
|
|
return &UpdateUserHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *UpdateUserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
|
|
var req *csapitypes.UpdateUserRequest
|
|
d := json.NewDecoder(r.Body)
|
|
if err := d.Decode(&req); err != nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, err))
|
|
return
|
|
}
|
|
|
|
creq := &action.UpdateUserRequest{
|
|
UserRef: userRef,
|
|
UserName: req.UserName,
|
|
}
|
|
|
|
user, err := h.ah.UpdateUser(ctx, creq)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
return
|
|
}
|
|
|
|
if err := util.HTTPResponse(w, http.StatusCreated, user); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type DeleteUserHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewDeleteUserHandler(log zerolog.Logger, ah *action.ActionHandler) *DeleteUserHandler {
|
|
return &DeleteUserHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *DeleteUserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
|
|
err := h.ah.DeleteUser(ctx, userRef)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
}
|
|
if err := util.HTTPResponse(w, http.StatusNoContent, nil); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
const (
|
|
DefaultUsersLimit = 10
|
|
MaxUsersLimit = 20
|
|
)
|
|
|
|
type UsersHandler struct {
|
|
log zerolog.Logger
|
|
readDB *readdb.ReadDB
|
|
}
|
|
|
|
func NewUsersHandler(log zerolog.Logger, readDB *readdb.ReadDB) *UsersHandler {
|
|
return &UsersHandler{log: log, readDB: readDB}
|
|
}
|
|
|
|
func (h *UsersHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
query := r.URL.Query()
|
|
|
|
limitS := query.Get("limit")
|
|
limit := DefaultUsersLimit
|
|
if limitS != "" {
|
|
var err error
|
|
limit, err = strconv.Atoi(limitS)
|
|
if err != nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, errors.Wrapf(err, "cannot parse limit")))
|
|
return
|
|
}
|
|
}
|
|
if limit < 0 {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, errors.Errorf("limit must be greater or equal than 0")))
|
|
return
|
|
}
|
|
if limit > MaxUsersLimit {
|
|
limit = MaxUsersLimit
|
|
}
|
|
asc := false
|
|
if _, ok := query["asc"]; ok {
|
|
asc = true
|
|
}
|
|
|
|
start := query.Get("start")
|
|
|
|
// handle special queries, like get user by token
|
|
queryType := query.Get("query_type")
|
|
|
|
var users []*types.User
|
|
switch queryType {
|
|
case "bytoken":
|
|
token := query.Get("token")
|
|
var user *types.User
|
|
err := h.readDB.Do(ctx, func(tx *db.Tx) error {
|
|
var err error
|
|
user, err = h.readDB.GetUserByTokenValue(tx, token)
|
|
return errors.WithStack(err)
|
|
})
|
|
if err != nil {
|
|
h.log.Err(err).Send()
|
|
util.HTTPError(w, err)
|
|
return
|
|
}
|
|
if user == nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrNotExist, errors.Errorf("user with required token doesn't exist")))
|
|
return
|
|
}
|
|
users = []*types.User{user}
|
|
case "bylinkedaccount":
|
|
linkedAccountID := query.Get("linkedaccountid")
|
|
var user *types.User
|
|
err := h.readDB.Do(ctx, func(tx *db.Tx) error {
|
|
var err error
|
|
user, err = h.readDB.GetUserByLinkedAccount(tx, linkedAccountID)
|
|
return errors.WithStack(err)
|
|
})
|
|
if err != nil {
|
|
h.log.Err(err).Send()
|
|
util.HTTPError(w, err)
|
|
return
|
|
}
|
|
if user == nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrNotExist, errors.Errorf("user with linked account %q token doesn't exist", linkedAccountID)))
|
|
return
|
|
}
|
|
users = []*types.User{user}
|
|
case "byremoteuser":
|
|
remoteUserID := query.Get("remoteuserid")
|
|
remoteSourceID := query.Get("remotesourceid")
|
|
var user *types.User
|
|
err := h.readDB.Do(ctx, func(tx *db.Tx) error {
|
|
var err error
|
|
user, err = h.readDB.GetUserByLinkedAccountRemoteUserIDandSource(tx, remoteUserID, remoteSourceID)
|
|
return errors.WithStack(err)
|
|
})
|
|
if err != nil {
|
|
h.log.Err(err).Send()
|
|
util.HTTPError(w, err)
|
|
return
|
|
}
|
|
if user == nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrNotExist, errors.Errorf("user with remote user %q for remote source %q token doesn't exist", remoteUserID, remoteSourceID)))
|
|
return
|
|
}
|
|
users = []*types.User{user}
|
|
default:
|
|
// default query
|
|
err := h.readDB.Do(ctx, func(tx *db.Tx) error {
|
|
var err error
|
|
users, err = h.readDB.GetUsers(tx, start, limit, asc)
|
|
return errors.WithStack(err)
|
|
})
|
|
if err != nil {
|
|
h.log.Err(err).Send()
|
|
util.HTTPError(w, err)
|
|
return
|
|
}
|
|
}
|
|
|
|
if err := util.HTTPResponse(w, http.StatusOK, users); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type CreateUserLAHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewCreateUserLAHandler(log zerolog.Logger, ah *action.ActionHandler) *CreateUserLAHandler {
|
|
return &CreateUserLAHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *CreateUserLAHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
|
|
var req csapitypes.CreateUserLARequest
|
|
d := json.NewDecoder(r.Body)
|
|
if err := d.Decode(&req); err != nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, err))
|
|
return
|
|
}
|
|
|
|
creq := &action.CreateUserLARequest{
|
|
UserRef: userRef,
|
|
RemoteSourceName: req.RemoteSourceName,
|
|
RemoteUserID: req.RemoteUserID,
|
|
RemoteUserName: req.RemoteUserName,
|
|
UserAccessToken: req.UserAccessToken,
|
|
Oauth2AccessToken: req.Oauth2AccessToken,
|
|
Oauth2RefreshToken: req.Oauth2RefreshToken,
|
|
Oauth2AccessTokenExpiresAt: req.Oauth2AccessTokenExpiresAt,
|
|
}
|
|
user, err := h.ah.CreateUserLA(ctx, creq)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
return
|
|
}
|
|
|
|
if err := util.HTTPResponse(w, http.StatusCreated, user); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type DeleteUserLAHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewDeleteUserLAHandler(log zerolog.Logger, ah *action.ActionHandler) *DeleteUserLAHandler {
|
|
return &DeleteUserLAHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *DeleteUserLAHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
laID := vars["laid"]
|
|
|
|
err := h.ah.DeleteUserLA(ctx, userRef, laID)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
}
|
|
if err := util.HTTPResponse(w, http.StatusNoContent, nil); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type UpdateUserLAHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewUpdateUserLAHandler(log zerolog.Logger, ah *action.ActionHandler) *UpdateUserLAHandler {
|
|
return &UpdateUserLAHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *UpdateUserLAHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
linkedAccountID := vars["laid"]
|
|
|
|
var req csapitypes.UpdateUserLARequest
|
|
d := json.NewDecoder(r.Body)
|
|
if err := d.Decode(&req); err != nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, err))
|
|
return
|
|
}
|
|
|
|
creq := &action.UpdateUserLARequest{
|
|
UserRef: userRef,
|
|
LinkedAccountID: linkedAccountID,
|
|
RemoteUserID: req.RemoteUserID,
|
|
RemoteUserName: req.RemoteUserName,
|
|
UserAccessToken: req.UserAccessToken,
|
|
Oauth2AccessToken: req.Oauth2AccessToken,
|
|
Oauth2RefreshToken: req.Oauth2RefreshToken,
|
|
Oauth2AccessTokenExpiresAt: req.Oauth2AccessTokenExpiresAt,
|
|
}
|
|
user, err := h.ah.UpdateUserLA(ctx, creq)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
return
|
|
}
|
|
|
|
if err := util.HTTPResponse(w, http.StatusOK, user); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type CreateUserTokenHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewCreateUserTokenHandler(log zerolog.Logger, ah *action.ActionHandler) *CreateUserTokenHandler {
|
|
return &CreateUserTokenHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *CreateUserTokenHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
|
|
var req csapitypes.CreateUserTokenRequest
|
|
d := json.NewDecoder(r.Body)
|
|
if err := d.Decode(&req); err != nil {
|
|
util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, err))
|
|
return
|
|
}
|
|
|
|
token, err := h.ah.CreateUserToken(ctx, userRef, req.TokenName)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
return
|
|
}
|
|
|
|
resp := &csapitypes.CreateUserTokenResponse{
|
|
Token: token,
|
|
}
|
|
if err := util.HTTPResponse(w, http.StatusCreated, resp); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
type DeleteUserTokenHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewDeleteUserTokenHandler(log zerolog.Logger, ah *action.ActionHandler) *DeleteUserTokenHandler {
|
|
return &DeleteUserTokenHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *DeleteUserTokenHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
tokenName := vars["tokenname"]
|
|
|
|
err := h.ah.DeleteUserToken(ctx, userRef, tokenName)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
return
|
|
}
|
|
if err := util.HTTPResponse(w, http.StatusNoContent, nil); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|
|
|
|
func userOrgsResponse(userOrg *action.UserOrgsResponse) *csapitypes.UserOrgsResponse {
|
|
return &csapitypes.UserOrgsResponse{
|
|
Organization: userOrg.Organization,
|
|
Role: userOrg.Role,
|
|
}
|
|
}
|
|
|
|
type UserOrgsHandler struct {
|
|
log zerolog.Logger
|
|
ah *action.ActionHandler
|
|
}
|
|
|
|
func NewUserOrgsHandler(log zerolog.Logger, ah *action.ActionHandler) *UserOrgsHandler {
|
|
return &UserOrgsHandler{log: log, ah: ah}
|
|
}
|
|
|
|
func (h *UserOrgsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
vars := mux.Vars(r)
|
|
userRef := vars["userref"]
|
|
|
|
userOrgs, err := h.ah.GetUserOrgs(ctx, userRef)
|
|
if util.HTTPError(w, err) {
|
|
h.log.Err(err).Send()
|
|
return
|
|
}
|
|
|
|
res := make([]*csapitypes.UserOrgsResponse, len(userOrgs))
|
|
for i, userOrg := range userOrgs {
|
|
res[i] = userOrgsResponse(userOrg)
|
|
}
|
|
|
|
if err := util.HTTPResponse(w, http.StatusOK, res); err != nil {
|
|
h.log.Err(err).Send()
|
|
}
|
|
}
|