fix(api): lint (#3281)

engine/api/action.go

@@ -187,7 +187,7 @@ func (api *API) getActionAuditHandler() service.Handler {
 		// Load action
 		a, err := action.LoadAuditAction(api.mustDB(), actionID, true)
 		if err != nil {
-			return sdk.WrapError(err, "getActionAuditHandler> Cannot load audit for action %s", actionID)
+			return sdk.WrapError(err, "getActionAuditHandler> Cannot load audit for action %d", actionID)
 		}
 		return service.WriteJSON(w, a, http.StatusOK)
 	}

engine/api/application.go

@@ -389,7 +389,7 @@ func (api *API) getApplicationBranchHandler() service.Handler {
 
 		proj, err := project.Load(api.mustDB(), api.Cache, projectKey, getUser(ctx))
 		if err != nil {
-			return sdk.WrapError(err, "getApplicationBranchHandler> Cannot load project %s from db", projectKey, projectKey)
+			return sdk.WrapError(err, "getApplicationBranchHandler> Cannot load project %s from db", projectKey)
 		}
 
 		app, err := application.LoadByName(api.mustDB(), api.Cache, projectKey, applicationName, getUser(ctx), application.LoadOptions.Default)
@@ -560,7 +560,7 @@ func (api *API) addApplicationHandler() service.Handler {
 
 		proj, errl := project.Load(api.mustDB(), api.Cache, key, getUser(ctx))
 		if errl != nil {
-			return sdk.WrapError(errl, "addApplicationHandler> Cannot load %s: %s", key)
+			return sdk.WrapError(errl, "addApplicationHandler> Cannot load %s", key)
 		}
 
 		var app sdk.Application

engine/api/application/application_group.go

@@ -85,12 +85,12 @@ func AddGroup(db gorp.SqlExecutor, store cache.Store, proj *sdk.Project, a *sdk.
 		log.Debug("application.AddGroup> proj=%s app=%s group=%s", proj.Name, a.Name, g.Name)
 		groupAttachedToApp, erra := group.CheckGroupInApplication(db, a.ID, g.ID)
 		if erra != nil {
-			return sdk.WrapError(erra, "AddGroup> Unable to check group in application %s")
+			return sdk.WrapError(erra, "AddGroup> Unable to check group in application %s project:%s", a.Name, proj.Name)
 		}
 
 		if !groupAttachedToApp {
 			if err := group.InsertGroupInApplication(db, a.ID, g.ID, gp.Permission); err != nil {
-				return sdk.WrapError(err, "AddGroup> Unable to inserting in application_group %d %d %d: %s", a.ID, g.ID, gp.Permission)
+				return sdk.WrapError(err, "AddGroup> Unable to inserting in application_group %d %d %d - application %s project:%s", a.ID, g.ID, gp.Permission, a.Name, proj.Name)
 			}
 		}
 		// If the group has only read permission on application, let it go with read permission on projet, pipeline and environment

engine/api/application/dao_dependencies.go

@@ -16,10 +16,10 @@ import (
 var (
 	loadDefaultDependencies = func(db gorp.SqlExecutor, store cache.Store, app *sdk.Application, u *sdk.User) error {
 		if err := loadVariables(db, store, app, u); err != nil && err != sql.ErrNoRows {
-			return sdk.WrapError(err, "application.loadDefaultDependencies", app.Name)
+			return sdk.WrapError(err, "application.loadDefaultDependencies %s", app.Name)
 		}
 		if err := loadTriggers(db, store, app, u); err != nil && err != sql.ErrNoRows {
-			return sdk.WrapError(err, "application.loadDefaultDependencies", app.Name)
+			return sdk.WrapError(err, "application.loadDefaultDependencies %s", app.Name)
 		}
 		return nil
 	}

engine/api/application_pipeline.go

@@ -158,7 +158,7 @@ func (api *API) updatePipelineToApplicationHandler() service.Handler {
 
 		err = application.UpdatePipelineApplicationString(api.mustDB(), api.Cache, app, pipeline.ID, string(data), getUser(ctx))
 		if err != nil {
-			return sdk.WrapError(err, "updatePipelineToApplicationHandler: Cannot update application %s pipeline %s parameters %s", appName, pipelineName)
+			return sdk.WrapError(err, "updatePipelineToApplicationHandler: Cannot update application %s pipeline %s", appName, pipelineName)
 		}
 
 		return service.WriteJSON(w, app, http.StatusOK)

engine/api/artifact.go

@@ -82,7 +82,7 @@ func (api *API) uploadArtifactHandler() service.Handler {
 		}
 
 		if !permission.AccessToEnvironment(key, env.Name, getUser(ctx), permission.PermissionReadExecute) {
-			return sdk.WrapError(sdk.ErrForbidden, "uploadArtifactHandler> No enought right on this environment %s")
+			return sdk.WrapError(sdk.ErrForbidden, "uploadArtifactHandler> No enought right on this environment %s", env.Name)
 		}
 
 		buildNumber, errI := strconv.Atoi(buildNumberString)
@@ -339,12 +339,12 @@ func (api *API) postArtifactWithTempURLHandler() service.Handler {
 		}
 
 		if !permission.AccessToEnvironment(proj, env.Name, getUser(ctx), permission.PermissionReadExecute) {
-			return sdk.WrapError(sdk.ErrForbidden, "postArtifactWithTempURLHandler> No enought right on this environment %s")
+			return sdk.WrapError(sdk.ErrForbidden, "postArtifactWithTempURLHandler> No enought right on this environment %s", env.Name)
 		}
 
 		buildNumber, errI := strconv.Atoi(buildNumberString)
 		if errI != nil {
-			return sdk.WrapError(sdk.ErrWrongRequest, "postArtifactWithTempURLHandler> BuildNumber must be an integer: %s", errI)
+			return sdk.WrapError(sdk.ErrWrongRequest, "postArtifactWithTempURLHandler> BuildNumber must be an integer: %v", errI)
 		}
 
 		hash, errG := generateHash()
@@ -419,7 +419,7 @@ func (api *API) postArtifactWithTempURLCallbackHandler() service.Handler {
 		}
 
 		if !permission.AccessToEnvironment(projKey, env.Name, getUser(ctx), permission.PermissionReadExecute) {
-			return sdk.WrapError(sdk.ErrForbidden, "postArtifactWithTempURLCallbackHandler> No enought right on this environment %s")
+			return sdk.WrapError(sdk.ErrForbidden, "postArtifactWithTempURLCallbackHandler> No enought right on this environment %s", env.Name)
 		}
 
 		pip, errpip := pipeline.LoadPipeline(api.mustDB(), projKey, pipName, false)

engine/api/bootstrap/bootstrap.go

@@ -22,7 +22,7 @@ func InitiliazeDB(defaultValues sdk.DefaultValues, DBFunc func() *gorp.DbMap) er
 
 	if strings.TrimSpace(defaultValues.DefaultGroupName) != "" {
 		if err := group.CreateDefaultGroup(dbGorp, defaultValues.DefaultGroupName); err != nil {
-			return sdk.WrapError(err, "InitiliazeDB> Cannot setup default %s group")
+			return sdk.WrapError(err, "InitiliazeDB> Cannot setup default %s group", defaultValues.DefaultGroupName)
 		}
 	}
 

engine/api/broadcast.go

@@ -78,7 +78,7 @@ func (api *API) updateBroadcastHandler() service.Handler {
 		defer tx.Rollback()
 
 		if bc.ID <= 0 || broadcastID != bc.ID {
-			return sdk.WrapError(sdk.ErrWrongRequest, "requestVarInt> %s is not valid. id in path:%d", bc.ID, broadcastID)
+			return sdk.WrapError(sdk.ErrWrongRequest, "requestVarInt> %d is not valid. id in path:%d", bc.ID, broadcastID)
 		}
 
 		// update broadcast in db

engine/api/environment/environment_importer.go

@@ -108,7 +108,7 @@ func ImportInto(db gorp.SqlExecutor, proj *sdk.Project, env *sdk.Environment, in
 	}
 
 	var updateGroupInEnv = func(groupName string, groupID int64, role int) {
-		log.Debug("ImportInto> Updating group %s", groupID)
+		log.Debug("ImportInto> Updating group %d", groupID)
 		if err := group.UpdateGroupRoleInEnvironment(db, into.ID, groupID, role); err != nil {
 			msgChan <- sdk.NewMessage(sdk.MsgEnvironmentGroupCannotBeUpdated, groupName, into.Name, err)
 			return

engine/api/environment_group.go

@@ -60,7 +60,7 @@ func (api *API) updateGroupRoleOnEnvironmentHandler() service.Handler {
 
 		if groupEnvironment.Permission != permission.PermissionReadWriteExecute {
 			if writeGroupID == 0 {
-				log.Warning("updateGroupRoleOnEnvironmentHandler: Cannot remove write permission on group %s for environment %s :%s", groupName, envName)
+				log.Warning("updateGroupRoleOnEnvironmentHandler: Cannot remove write permission on group %s for environment %s", groupName, envName)
 				return sdk.WrapError(sdk.ErrGroupNeedWrite, "updateGroupRoleOnEnvironmentHandler> Cannot remove write permission on group %s for environment %s", groupName, envName)
 			}
 		}

engine/api/environment_import.go

@@ -142,7 +142,7 @@ func (api *API) importNewEnvironmentHandler() service.Handler {
 		go func() {
 			for {
 				msg, ok := <-msgChan
-				log.Debug("importNewEnvironmentHandler >>> %s", msg)
+				log.Debug("importNewEnvironmentHandler >>> %v", msg)
 				allMsg = append(allMsg, msg)
 				if !ok {
 					done <- true
@@ -245,7 +245,7 @@ func (api *API) importIntoEnvironmentHandler() service.Handler {
 		go func() {
 			for {
 				msg, ok := <-msgChan
-				log.Debug("importIntoEnvironmentHandler >>> %s", msg)
+				log.Debug("importIntoEnvironmentHandler >>> %v", msg)
 				allMsg = append(allMsg, msg)
 				if !ok {
 					done <- true

engine/api/group/group.go

@@ -14,27 +14,27 @@ import (
 // DeleteGroupAndDependencies deletes group and all subsequent group_project, pipeline_project
 func DeleteGroupAndDependencies(db gorp.SqlExecutor, group *sdk.Group) error {
 	if err := DeleteGroupUserByGroup(db, group); err != nil {
-		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group user %s: %s", group.Name)
+		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group user %s", group.Name)
 	}
 
 	if err := deleteGroupEnvironmentByGroup(db, group); err != nil {
-		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group env %s: %s", group.Name)
+		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group env %s", group.Name)
 	}
 
 	if err := deleteGroupPipelineByGroup(db, group); err != nil {
-		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group pipeline %s: %s", group.Name)
+		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group pipeline %s", group.Name)
 	}
 
 	if err := deleteGroupApplicationByGroup(db, group); err != nil {
-		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group application %s: %s", group.Name)
+		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group application %s", group.Name)
 	}
 
 	if err := deleteGroupProjectByGroup(db, group); err != nil {
-		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group project %s: %s", group.Name)
+		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group project %s", group.Name)
 	}
 
 	if err := deleteGroup(db, group); err != nil {
-		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group %s: %s", group.Name)
+		return sdk.WrapError(err, "deleteGroupAndDependencies: Cannot delete group %s", group.Name)
 	}
 
 	// TODO EVENT Send event for all dependencies
@@ -47,14 +47,14 @@ func AddGroup(db gorp.SqlExecutor, group *sdk.Group) (int64, bool, error) {
 	// check projectKey pattern
 	regexp := sdk.NamePatternRegex
 	if !regexp.MatchString(group.Name) {
-		return 0, false, sdk.WrapError(sdk.ErrInvalidGroupPattern, "AddGroup: Wrong pattern for group name : %s", group.Name)
+		return 0, false, sdk.WrapError(sdk.ErrInvalidGroupPattern, "AddGroup: Wrong pattern for group name: %s", group.Name)
 	}
 
 	// Check that group does not already exists
 	query := `SELECT id FROM "group" WHERE "group".name = $1`
 	rows, errq := db.Query(query, group.Name)
 	if errq != nil {
-		return 0, false, sdk.WrapError(errq, "AddGroup: Cannot check if group %s exists: %s", group.Name)
+		return 0, false, sdk.WrapError(errq, "AddGroup: Cannot check if group %s exists", group.Name)
 	}
 	defer rows.Close()
 
@@ -63,7 +63,7 @@ func AddGroup(db gorp.SqlExecutor, group *sdk.Group) (int64, bool, error) {
 		if err := rows.Scan(&groupID); err != nil {
 			return 0, false, sdk.WrapError(sdk.ErrGroupExists, "AddGroup: Cannot get the ID of the existing group %s (%s)", group.Name, err)
 		}
-		return groupID, false, sdk.WrapError(sdk.ErrGroupExists, "AddGroup: Group %s already exists")
+		return groupID, false, sdk.WrapError(sdk.ErrGroupExists, "AddGroup: Group %s already exists", group.Name)
 	}
 
 	if err := InsertGroup(db, group); err != nil {

engine/api/migrate/migrate_workflow.go

@@ -133,7 +133,7 @@ func ToWorkflow(db gorp.SqlExecutor, store cache.Store, cdTree []sdk.CDPipeline,
 
 func addGroupOnWorkflow(db gorp.SqlExecutor, w *sdk.Workflow, app *sdk.Application) error {
 	if err := application.LoadGroupByApplication(db, app); err != nil {
-		return sdk.WrapError(err, "addGroupOnWorkflow> error while LoadGroupByApplication on application %s", app.ID)
+		return sdk.WrapError(err, "addGroupOnWorkflow> error while LoadGroupByApplication on application %d", app.ID)
 	}
 
 	for _, ag := range app.ApplicationGroups {

engine/api/notification/user.go

@@ -165,7 +165,7 @@ func GetUserWorkflowEvents(db gorp.SqlExecutor, w sdk.Workflow, previousWR *sdk.
 			case sdk.JabberUserNotification:
 				jn, ok := notif.Settings.(*sdk.JabberEmailUserNotificationSettings)
 				if !ok {
-					log.Error("notification.GetUserWorkflowEvents[Jabber]> cannot deal with %s", notif)
+					log.Error("notification.GetUserWorkflowEvents[Jabber]> cannot deal with %v", notif)
 					continue
 				}
 				//Get recipents from groups
@@ -190,7 +190,7 @@ func GetUserWorkflowEvents(db gorp.SqlExecutor, w sdk.Workflow, previousWR *sdk.
 			case sdk.EmailUserNotification:
 				jn, ok := notif.Settings.(*sdk.JabberEmailUserNotificationSettings)
 				if !ok {
-					log.Error("notification.GetUserEvents[Email]> cannot deal with %s", notif)
+					log.Error("notification.GetUserEvents[Email]> cannot deal with %v", notif)
 					continue
 				}
 				//Get recipents from groups

engine/api/pipeline.go

@@ -232,7 +232,7 @@ func (api *API) runPipelineHandlerFunc(ctx context.Context, w http.ResponseWrite
 	// Schedule pipeline for build
 	log.Debug("runPipelineHandler> Scheduling %s/%s/%s[%s] with %d params, version 0",
 		projectKey, app.Name, pipelineName, envDest.Name, len(request.Params))
-	log.Debug("runPipelineHandler> Pipeline trigger by %s - %d", getUser(ctx).ID, request.ParentPipelineID)
+	log.Debug("runPipelineHandler> Pipeline trigger by %d - %d", getUser(ctx).ID, request.ParentPipelineID)
 	trigger := sdk.PipelineBuildTrigger{
 		ManualTrigger:       true,
 		TriggeredBy:         getUser(ctx),

engine/api/pipeline/pipeline_importer.go

@@ -264,7 +264,7 @@ func Import(db gorp.SqlExecutor, store cache.Store, proj *sdk.Project, pip *sdk.
 	//Reload the pipeline
 	pip2, err := LoadPipeline(db, proj.Key, pip.Name, false)
 	if err != nil {
-		return sdk.WrapError(err, "Import> Unable to load imported pipeline", proj.Name, pip.Name)
+		return sdk.WrapError(err, "Import> Unable to load imported pipeline project:%s pipeline:%s", proj.Name, pip.Name)
 	}
 	//Be confident: use the pipeline
 	*pip = *pip2

engine/api/pipeline_group.go

@@ -123,7 +123,7 @@ func (api *API) addGroupInPipelineHandler() service.Handler {
 
 		}
 		if groupInPipeline {
-			return sdk.WrapError(sdk.ErrGroupExists, "addGroupInPipeline: The group is already attached to the pipeline %s: %s", g.Name, p.Name, err)
+			return sdk.WrapError(sdk.ErrGroupExists, "addGroupInPipeline: The group %s is already attached to the pipeline %s: %v", g.Name, p.Name, err)
 		}
 
 		tx, err := api.mustDB().Begin()

engine/api/plugin.go

@@ -208,7 +208,7 @@ func (api *API) updatePluginHandler() service.Handler {
 				return sdk.WrapError(errStore, "updatePluginHandler> Error while uploading to object store %s", ap.Name)
 			}
 
-			return sdk.WrapError(errDB, "updatePluginHandler> Unable to update plugin", ap.Name)
+			return sdk.WrapError(errDB, "updatePluginHandler> Unable to update plugin %s", ap.Name)
 		}
 		if err := tx.Commit(); err != nil {
 			return sdk.WrapError(err, "updatePluginHandler> Cannot commit transaction")
@@ -264,7 +264,7 @@ func (api *API) downloadPluginHandler() service.Handler {
 
 		f, err := objectstore.Fetch(&p)
 		if err != nil {
-			return sdk.WrapError(err, "downloadPluginHandler> Error while fetching plugin", name)
+			return sdk.WrapError(err, "downloadPluginHandler> Error while fetching plugin %s", name)
 		}
 
 		w.Header().Add("Content-Type", "application/octet-stream")

engine/api/poller/executer.go

@@ -220,7 +220,7 @@ func triggerPipelines(tx gorp.SqlExecutor, store cache.Store, projectKey string,
 		}
 
 		if pb != nil {
-			log.Debug("Polling.triggerPipelines> Triggered %s/%s/%s : %s", projectKey, poller.Application.RepositoryFullname, event.Branch, event.Commit.Hash)
+			log.Debug("Polling.triggerPipelines> Triggered %s/%s/%v : %s", projectKey, poller.Application.RepositoryFullname, event.Branch, event.Commit.Hash)
 			e.PipelineBuildVersions[event.Branch.ID+"/"+event.Commit.Hash[:7]] = pb.Version
 			pbs = append(pbs, *pb)
 		}
@@ -234,7 +234,7 @@ func triggerPipelines(tx gorp.SqlExecutor, store cache.Store, projectKey string,
 		}
 
 		if pb != nil {
-			log.Debug("Polling.triggerPipelines> Triggered %s/%s/%s : %s", projectKey, poller.Application.RepositoryFullname, event.Head.Branch, event.Head.Commit.Hash)
+			log.Debug("Polling.triggerPipelines> Triggered %s/%s/%v : %s", projectKey, poller.Application.RepositoryFullname, event.Head.Branch, event.Head.Commit.Hash)
 			e.PipelineBuildVersions[event.Head.Branch.ID+"/"+event.Head.Commit.Hash[:7]] = pb.Version
 			pbs = append(pbs, *pb)
 		}
@@ -247,7 +247,7 @@ func triggerPipelines(tx gorp.SqlExecutor, store cache.Store, projectKey string,
 		}
 
 		if pb != nil {
-			log.Debug("Polling.triggerPipelines> Triggered %s/%s/%s : %s", projectKey, poller.Application.RepositoryFullname, event.Branch, event.Commit.Hash)
+			log.Debug("Polling.triggerPipelines> Triggered %s/%s/%v : %s", projectKey, poller.Application.RepositoryFullname, event.Branch, event.Commit.Hash)
 			e.PipelineBuildVersions[event.Branch.ID+"/"+event.Commit.Hash[:7]] = pb.Version
 			pbs = append(pbs, *pb)
 		}

engine/api/polling.go

@@ -45,7 +45,7 @@ func (api *API) addPollerHandler() service.Handler {
 		//Check if pipeline has been found
 		if pip == nil {
 			log.Warning("addPollerHandler> Cannot load pipeline: %s", pipName)
-			return sdk.WrapError(sdk.ErrPipelineNotFound, "sdk.ErrPipelineNotFound", pipName)
+			return sdk.WrapError(sdk.ErrPipelineNotFound, "sdk.ErrPipelineNotFound %s", pipName)
 		}
 
 		var h sdk.RepositoryPoller

engine/api/project.go

@@ -350,7 +350,7 @@ func (api *API) addProjectHandler() service.Handler {
 
 		// check projectKey pattern
 		if rgxp := regexp.MustCompile(sdk.ProjectKeyPattern); !rgxp.MatchString(p.Key) {
-			return sdk.WrapError(sdk.ErrInvalidProjectKey, "addProjectHandler> Project key %s do not respect pattern %s")
+			return sdk.WrapError(sdk.ErrInvalidProjectKey, "addProjectHandler> Project key %s do not respect pattern %s", p.Key, sdk.ProjectKeyPattern)
 		}
 
 		//check project Name
@@ -464,7 +464,7 @@ func (api *API) addProjectHandler() service.Handler {
 				k.Key = keyTemp
 			}
 			if errK := project.InsertKey(tx, &k); errK != nil {
-				return sdk.WrapError(errK, "addProjectHandler> Cannot add key %s in project %s", k.Name)
+				return sdk.WrapError(errK, "addProjectHandler> Cannot add key %s in project %s", k.Name, p.Name)
 			}
 		}
 

engine/api/project_group.go

@@ -129,7 +129,7 @@ func (api *API) updateGroupRoleOnProjectHandler() service.Handler {
 
 		p, errl := project.Load(tx, api.Cache, key, getUser(ctx), project.LoadOptions.WithGroups)
 		if errl != nil {
-			return sdk.WrapError(errl, "updateGroupRoleHandler: Cannot load %s: %s", key)
+			return sdk.WrapError(errl, "updateGroupRoleHandler: Cannot load project %s", key)
 		}
 
 		g, errlg := group.LoadGroup(tx, groupProject.Group.Name)
@@ -149,7 +149,7 @@ func (api *API) updateGroupRoleOnProjectHandler() service.Handler {
 		}
 
 		if gpInProject.Permission == 0 {
-			return sdk.WrapError(sdk.ErrGroupNotFound, "updateGroupRoleHandler: Group is not attached to this project: %s")
+			return sdk.WrapError(sdk.ErrGroupNotFound, "updateGroupRoleHandler: Group is not attached to this project: %s", key)
 		}
 
 		if group.IsDefaultGroupID(g.ID) && groupProject.Permission > permission.PermissionRead {
@@ -168,7 +168,7 @@ func (api *API) updateGroupRoleOnProjectHandler() service.Handler {
 		}
 
 		if err := tx.Commit(); err != nil {
-			return sdk.WrapError(err, "updateGroupRoleHandler: Cannot start transaction: %s")
+			return sdk.WrapError(err, "updateGroupRoleHandler: Cannot start transaction")
 		}
 
 		newGP := sdk.GroupPermission{

engine/api/repositories_manager.go

@@ -81,9 +81,9 @@ func (api *API) repositoriesManagerAuthorizeHandler() service.Handler {
 			"project_key":          proj.Key,
 			"last_modified":        strconv.FormatInt(time.Now().Unix(), 10),
 			"repositories_manager": rmName,
-			"url":           url,
-			"request_token": token,
-			"username":      getUser(ctx).Username,
+			"url":                  url,
+			"request_token":        token,
+			"username":             getUser(ctx).Username,
 		}
 
 		api.Cache.Set(cache.Key("reposmanager", "oauth", token), data)
@@ -136,7 +136,7 @@ func (api *API) repositoriesManagerOAuthCallbackHandler() service.Handler {
 		}
 
 		if token == "" || secret == "" {
-			return sdk.WrapError(sdk.ErrNoReposManagerClientAuth, "repositoriesManagerAuthorizeCallback> token or secret is empty", err)
+			return sdk.WrapError(sdk.ErrNoReposManagerClientAuth, "repositoriesManagerAuthorizeCallback> token or secret is empty")
 		}
 
 		tx, errT := api.mustDB().Begin()