Sign upLogin

horizoncd/horizon

View on GitHub
Star

Showing 676 of 677 total issues

Method controller.GetChildren has 5 return statements (exceeds 4 allowed).
Open

func (c *controller) GetChildren(ctx context.Context, id uint, pageNumber, pageSize int) (
    []*service.Child, int64, error) {
    var parent *models.Group
    var full *service.Full
    if id > 0 {
Severity: Major
Found in core/controller/group/controller.go - About 35 mins to fix

    Method controller.CreateBadge has 5 return statements (exceeds 4 allowed).
    Open

    func (c *controller) CreateBadge(ctx context.Context, resourceType string,
        resourceID uint, badge *Create) (*Badge, error) {
        if err := c.checkResource(ctx, resourceType, resourceID); err != nil {
            return nil, err
        }
    Severity: Major
    Found in core/controller/badge/controller.go - About 35 mins to fix

      Method controller.LoginWithPasswd has 5 return statements (exceeds 4 allowed).
      Open

      func (c *controller) LoginWithPasswd(ctx context.Context, request *LoginRequest) (*models.User, error) {
          users, err := c.userMgr.ListByEmail(ctx, []string{request.Email})
          if err != nil {
              return nil, nil
          }
      Severity: Major
      Found in core/controller/user/controller.go - About 35 mins to fix

        Method API.CreatePipelineRun has 5 return statements (exceeds 4 allowed).
        Open

        func (a *API) CreatePipelineRun(c *gin.Context) {
            op := "cluster: create pipeline run"
            clusterIDStr := c.Param(common.ParamClusterID)
            clusterID, err := strconv.ParseUint(clusterIDStr, 10, 0)
            if err != nil {
        Severity: Major
        Found in core/http/api/v2/cluster/apis_basic.go - About 35 mins to fix

          Method API.Rollback has 5 return statements (exceeds 4 allowed).
          Open

          func (a *API) Rollback(c *gin.Context) {
              op := "cluster: rollback"
              clusterIDStr := c.Param(common.ParamClusterID)
              clusterID, err := strconv.ParseUint(clusterIDStr, 10, 0)
              if err != nil {
          Severity: Major
          Found in core/http/api/v2/cluster/apis_operation.go - About 35 mins to fix

            Method controller.Update has 5 return statements (exceeds 4 allowed).
            Open

            func (c *controller) Update(ctx context.Context, resourceType string, resourceID uint, r *UpdateRequest) (err error) {
                const op = "cluster tag controller: update"
                defer wlog.Start(ctx, op).StopPrint()
             
                tags := r.toTags(resourceType, resourceID)
            Severity: Major
            Found in core/controller/tag/controller.go - About 35 mins to fix

              Method controller.GetSubGroups has 5 return statements (exceeds 4 allowed).
              Open

              func (c *controller) GetSubGroups(ctx context.Context, id uint, pageNumber, pageSize int) (
                  []*service.Child, int64, error) {
                  var parent *models.Group
                  var full *service.Full
                  if id > 0 {
              Severity: Major
              Found in core/controller/group/controller.go - About 35 mins to fix

                Method API.Update has 5 return statements (exceeds 4 allowed).
                Open

                func (a *API) Update(c *gin.Context) {
                    op := "user: update by id"
                    uid := c.Param(_userIDParam)
                    var (
                        userID uint64
                Severity: Major
                Found in core/http/api/v2/user/apis.go - About 35 mins to fix

                  Method controller.updatePrStatus has 5 return statements (exceeds 4 allowed).
                  Open

                  func (c *controller) updatePrStatus(ctx context.Context, checkrun *prmodels.CheckRun) error {
                      pipelinerun, err := c.prMgr.PipelineRun.GetByID(ctx, checkrun.PipelineRunID)
                      if err != nil {
                          return err
                      }
                  Severity: Major
                  Found in core/controller/pipelinerun/controller.go - About 35 mins to fix

                    Method API.Update has 5 return statements (exceeds 4 allowed).
                    Open

                    func (a *API) Update(c *gin.Context) {
                        const op = "application: update v2"
                        var request *application.CreateOrUpdateApplicationRequestV2
                        if err := c.ShouldBindJSON(&request); err != nil {
                            response.AbortWithRPCError(c, rpcerror.ParamError.WithErrMsg(fmt.Sprintf("invalid request body, err: %s",
                    Severity: Major
                    Found in core/http/api/v2/application/apis.go - About 35 mins to fix

                      Method API.Delete has 5 return statements (exceeds 4 allowed).
                      Open

                      func (a *API) Delete(c *gin.Context) {
                          const op = "application: delete"
                          appIDStr := c.Param(common.ParamApplicationID)
                          appID, err := strconv.ParseUint(appIDStr, 10, 0)
                          if err != nil {
                      Severity: Major
                      Found in core/http/api/v2/application/apis.go - About 35 mins to fix

                        Function parseContext has 5 return statements (exceeds 4 allowed).
                        Open

                        func parseContext(c *gin.Context) *q.Query {
                            keywords := make(map[string]interface{})
                         
                            userIDStr := c.Query(common.ClusterQueryByUser)
                            if userIDStr != "" {
                        Severity: Major
                        Found in core/http/api/v2/cluster/apis_basic.go - About 35 mins to fix

                          Method API.LoginWithPassword has 5 return statements (exceeds 4 allowed).
                          Open

                          func (a *API) LoginWithPassword(c *gin.Context) {
                              var request *user.LoginRequest
                              if err := c.ShouldBindJSON(&request); err != nil ||
                                  request.Password == "" ||
                                  request.Email == "" {
                          Severity: Major
                          Found in core/http/api/v2/user/apis.go - About 35 mins to fix

                            Method controller.validateCreate has 5 return statements (exceeds 4 allowed).
                            Open

                            func (c *controller) validateCreate(r *CreateClusterRequest) error {
                                if err := validateClusterName(r.Name); err != nil {
                                    return err
                                }
                                if r.Git == nil || r.Git.Ref() == "" || r.Git.RefType() == "" {
                            Severity: Major
                            Found in core/controller/cluster/controller_basic.go - About 35 mins to fix

                              Method controller.Review has 5 return statements (exceeds 4 allowed).
                              Open

                              func (c *controller) Review(ctx context.Context, apis []API) (map[string]map[string]*ReviewResult, error) {
                                  reviewResponse := make(map[string]map[string]*ReviewResult)
                                  // get user info
                                  currentUser, err := common.UserFromContext(ctx)
                                  if err != nil {
                              Severity: Major
                              Found in core/controller/access/controller.go - About 35 mins to fix

                                Function handleGetSchema has 5 return statements (exceeds 4 allowed).
                                Open

                                func handleGetSchema(c *gin.Context, mgr *managerparam.Manager, r *gin.Engine,
                                    authRecord auth.AttributesRecord, requestInfo *auth.RequestInfo) {
                                    template, err := mgr.TemplateMgr.GetByName(c, authRecord.Name)
                                    if err != nil {
                                        if e, ok := perror.Cause(err).(*herrors.HorizonErrNotFound); ok && e.Source == herrors.TemplateInDB {
                                Severity: Major
                                Found in core/middleware/prehandle/prehandle.go - About 35 mins to fix

                                  Method API.ExecuteAction has 5 return statements (exceeds 4 allowed).
                                  Open

                                  func (a *API) ExecuteAction(c *gin.Context) {
                                      const op = "cluster: execute action"
                                      clusterIDStr := c.Param(common.ParamClusterID)
                                      clusterID, err := strconv.ParseUint(clusterIDStr, 10, 0)
                                      if err != nil {
                                  Severity: Major
                                  Found in core/http/api/v2/cluster/apis_operation.go - About 35 mins to fix

                                    Method API.PodEvents has 5 return statements (exceeds 4 allowed).
                                    Open

                                    func (a *API) PodEvents(c *gin.Context) {
                                        op := "cluster: pod events"
                                        clusterIDStr := c.Param(common.ParamClusterID)
                                        clusterID, err := strconv.ParseUint(clusterIDStr, 10, 0)
                                        if err != nil {
                                    Severity: Major
                                    Found in core/http/api/v2/cluster/apis_operation.go - About 35 mins to fix

                                      Method API.UpdateMember has 5 return statements (exceeds 4 allowed).
                                      Open

                                      func (a *API) UpdateMember(c *gin.Context) {
                                          memberIDStr := c.Param(_paramMemberID)
                                          uintID, err := strconv.ParseUint(memberIDStr, 10, 0)
                                          if err != nil {
                                              response.AbortWithRequestError(c, common.InvalidRequestParam,
                                      Severity: Major
                                      Found in core/http/api/v2/member/apis.go - About 35 mins to fix

                                        Method controller.CreateResourceAccessToken has 5 return statements (exceeds 4 allowed).
                                        Open

                                        func (c *controller) CreateResourceAccessToken(ctx context.Context, request CreateResourceAccessTokenRequest,
                                            resourceType string, resourceID uint) (*CreateResourceAccessTokenResponse, error) {
                                            var (
                                                userID uint
                                            )
                                        Severity: Major
                                        Found in core/controller/accesstoken/controller.go - About 35 mins to fix
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language