Sign upLogin

timoth-y/kicksware-api

View on GitHub
Star

Showing 60 of 60 total issues

Method referenceSyncService.sync has 5 return statements (exceeds 4 allowed).
Open

func (s *referenceSyncService) sync(query interface{}, params *meta.RequestParams) (err error) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    refs := make([]*model.SneakerReference, 0)
Severity: Major
Found in services/search/usecase/business/referenceSyncService.go - About 35 mins to fix

    Method repository.Fetch has 5 return statements (exceeds 4 allowed).
    Open

    func (r *repository) Fetch(codes []string, params *meta.RequestParams) ([]*model.Order, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    query := r.buildQueryPipeline(bson.M{"unique_id": bson.M{"$in": codes}}, params)
    Severity: Major
    Found in services/orders/usecase/storage/mongo/repository.go - About 35 mins to fix

      Method repository.FetchQuery has 5 return statements (exceeds 4 allowed).
      Open

      func (r *repository) FetchQuery(query meta.RequestQuery, params *meta.RequestParams) ([]*model.User, error) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    users := make([]*model.User, 0)
    where, err := query.ToSql(); if err != nil {
      Severity: Major
      Found in services/users/usecase/storage/postgres/repository.go - About 35 mins to fix

        Method repository.FetchOne has 5 return statements (exceeds 4 allowed).
        Open

        func (r *repository) FetchOne(userID string) (*model.User, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()
    query := r.buildQueryPipeline(bson.M{"unique_id": userID}, nil)
    cursor, err := r.collection.Aggregate(ctx, query); if err != nil {
        Severity: Major
        Found in services/users/usecase/storage/mongo/repository.go - About 35 mins to fix

          Method repository.FetchQuery has 5 return statements (exceeds 4 allowed).
          Open

          func (r *repository) FetchQuery(query meta.RequestQuery, params *meta.RequestParams) ([]*model.Order, error) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    orders := make([]*model.Order, 0)
    where, err := query.ToSql(); if err != nil {
          Severity: Major
          Found in services/orders/usecase/storage/postgres/repository.go - About 35 mins to fix

            Method repository.FetchOne has 5 return statements (exceeds 4 allowed).
            Open

            func (r *repository) FetchOne(code string, params *meta.RequestParams) (*model.Order, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    query := r.buildQueryPipeline(bson.M{"unique_id": code}, params)
            Severity: Major
            Found in services/orders/usecase/storage/mongo/repository.go - About 35 mins to fix

              Method repository.Fetch has 5 return statements (exceeds 4 allowed).
              Open

              func (r *repository) Fetch(codes []string, params *meta.RequestParams) ([]*model.SneakerProduct, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()
    filter := bson.M{"uniqueid": bson.M{"$in": codes}}
              Severity: Major
              Found in services/products/usecase/storage/mongo/repository.go - About 35 mins to fix

                Method Handler.UploadImages has 5 return statements (exceeds 4 allowed).
                Open

                func (h *Handler) UploadImages(ctx context.Context, input *proto.UploadImageRequest) (*proto.ProductResponse, error) {
    productID := input.ProductID; if len(input.ProductID) == 0 {
        return nil, status.Error(codes.InvalidArgument, business.ErrProductNotFound.Error())
    }
                Severity: Major
                Found in services/products/api/gRPC/handler.go - About 35 mins to fix

                  Method repository.FetchQuery has 5 return statements (exceeds 4 allowed).
                  Open

                  func (r *repository) FetchQuery(query meta.RequestQuery, params *meta.RequestParams) ([]*model.SneakerReference, error) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    sneakerReferences := make([]*model.SneakerReference, 0)
    where, err := query.ToSql(); if err != nil {
                  Severity: Major
                  Found in services/references/usecase/storage/postgres/repository.go - About 35 mins to fix

                    Method AuthClientInterceptor.requestAccessToken has 5 return statements (exceeds 4 allowed).
                    Open

                    func (i *AuthClientInterceptor) requestAccessToken(ctx context.Context) (*meta.AuthToken, error) {
    if i.accessToken != nil {
        if !i.accessToken.Expires.IsZero() && i.accessToken.Expires.Nanosecond() <= time.Now().Nanosecond() {
            newToken, err := i.authClient.Refresh(ctx, proto.AuthToken{}.FromNative(i.accessToken)); if err == nil {
                i.accessToken = newToken.ToNative()
                    Severity: Major
                    Found in shared/api/gRPC/authClientInterceptor.go - About 35 mins to fix

                      Method repository.FetchQuery has 5 return statements (exceeds 4 allowed).
                      Open

                      func (r *repository) FetchQuery(query meta.RequestQuery, params *meta.RequestParams) ([]*model.SneakerProduct, error) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    sneakerProducts := make([]*model.SneakerProduct, 0)
    where, err := query.ToSql(); if err != nil {
                      Severity: Major
                      Found in services/products/usecase/storage/postgres/repository.go - About 35 mins to fix

                        Method repository.Fetch has 5 return statements (exceeds 4 allowed).
                        Open

                        func (r *repository) Fetch(codes []string, params *meta.RequestParams) ([]*model.Rating, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    query := r.buildQueryPipeline(bson.M{"entity_id": bson.M{"$in": codes}}, params)
                        Severity: Major
                        Found in services/rating/usecase/storage/mongo/repository.go - About 35 mins to fix

                          Method repository.FetchAll has 5 return statements (exceeds 4 allowed).
                          Open

                          func (r *repository) FetchAll(params *meta.RequestParams) ([]*model.User, error) {
    keys := r.client.Keys("user*").Val()
    if len(keys) == 0 {
        return nil, errors.Wrap(business.ErrUserNotFound, "repository.User.FetchAll")
    }
                          Severity: Major
                          Found in services/users/usecase/storage/redis/repository.go - About 35 mins to fix

                            Method TokenManager.Verify has 5 return statements (exceeds 4 allowed).
                            Open

                            func (m *TokenManager) Verify(accessToken string) (*meta.AuthClaims, error) {
    token, err := jwt.ParseWithClaims(
        accessToken,
        &meta.AuthClaims{},
        func(token *jwt.Token) (interface{}, error) {
                            Severity: Major
                            Found in shared/api/jwt/jwtManager.go - About 35 mins to fix

                              Method Broker.Consume has 5 return statements (exceeds 4 allowed).
                              Open

                              func (b *Broker) Consume(
    queueName,
    routingKey string,
    handler func(d amqp.Delivery) bool,
    concurrency int) error {
                              Severity: Major
                              Found in shared/api/events/consume.go - About 35 mins to fix

                                Method repository.FetchQuery has 5 return statements (exceeds 4 allowed).
                                Open

                                func (r *repository) FetchQuery(query meta.RequestQuery, params *meta.RequestParams) ([]*model.Order, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    filter, err := query.ToBson(); if err != nil {
                                Severity: Major
                                Found in services/orders/usecase/storage/mongo/repository.go - About 35 mins to fix

                                  Method repository.FetchOne has 5 return statements (exceeds 4 allowed).
                                  Open

                                  func (r *repository) FetchOne(code string, params *meta.RequestParams) (*model.SneakerReference, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    query := r.buildQueryPipeline(bson.M{"uniqueid": code}, params)
                                  Severity: Major
                                  Found in services/references/usecase/storage/mongo/repository.go - About 35 mins to fix

                                    Method repository.Fetch has 5 return statements (exceeds 4 allowed).
                                    Open

                                    func (r *repository) Fetch(codes []string, params *meta.RequestParams) ([]*model.SneakerReference, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    query := r.buildQueryPipeline(bson.M{"uniqueid": bson.M{"$in": codes}}, params)
                                    Severity: Major
                                    Found in services/references/usecase/storage/mongo/repository.go - About 35 mins to fix

                                      Method repository.FetchOne has 5 return statements (exceeds 4 allowed).
                                      Open

                                      func (r *repository) FetchOne(code string, params *meta.RequestParams) (*model.Rating, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    query := r.buildQueryPipeline(bson.M{"entity_id": code}, params)
                                      Severity: Major
                                      Found in services/rating/usecase/storage/mongo/repository.go - About 35 mins to fix

                                        Method repository.FetchQuery has 5 return statements (exceeds 4 allowed).
                                        Open

                                        func (r *repository) FetchQuery(query meta.RequestQuery, params *meta.RequestParams) ([]*model.Rating, error) {
    ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    filter, err := query.ToBson(); if err != nil {
                                        Severity: Major
                                        Found in services/rating/usecase/storage/mongo/repository.go - About 35 mins to fix
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language