Sign upLogin

timoth-y/kicksware-api

View on GitHub
Star

Showing 35 of 60 total issues

Method repository.buildQueryPipeline has 84 lines of code (exceeds 50 allowed). Consider refactoring.
Open

func (r *repository) buildQueryPipeline(matchQuery bson.M, param *meta.RequestParams) mongo.Pipeline {
    pipe := mongo.Pipeline{}
    pipe = append(pipe, bson.D{{"$match", matchQuery}})

    pipe = append(pipe, bson.D{
Severity: Major
Found in services/references/usecase/storage/mongo/repository.go - About 2 hrs to fix

    Function toBson has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring.
    Open

    func toBson(v interface{}) (m bson.M, err error) {
    dict, err := toMap(v)
    if err != nil {
        return
    }
    Severity: Minor
    Found in shared/core/meta/requestQuery.go - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method communicator.PostMessage has 7 return statements (exceeds 4 allowed).
    Open

    func (c *communicator) PostMessage(endpoint string, query interface{}, response interface{}, params ...*meta.RequestParams) error {
    url := fmt.Sprintf(c.endpointFormat, endpoint)
    body, err := json.Marshal(query); if err != nil {
        return err
    }
    Severity: Major
    Found in shared/api/rest/innerServiceCommunicator.go - About 45 mins to fix

      Function trySendMail has 7 return statements (exceeds 4 allowed).
      Open

      func trySendMail(config env.MailConfig, subject string, msg string, to string) error {
    client, err := mailClient(config); if err != nil {
        return err
    }
      Severity: Major
      Found in services/users/usecase/business/mailService.go - About 45 mins to fix

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

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

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

          Method communicator.GetMessage has 6 return statements (exceeds 4 allowed).
          Open

          func (c *communicator) GetMessage(endpoint string, response interface{}, params ...*meta.RequestParams) error {
    url := fmt.Sprintf(c.endpointFormat, endpoint)
    req, err := http.NewRequest("GET", url, nil); if err != nil {
        return err
    }
          Severity: Major
          Found in shared/api/rest/innerServiceCommunicator.go - About 40 mins to fix

            Method authService.Remote has 6 return statements (exceeds 4 allowed).
            Open

            func (s *authService) Remote(user *model.User) (*meta.AuthToken, error) {
    if user == nil || len(user.UniqueID) == 0 {
        return nil, service.ErrInvalidRemoteID
    } else if len(user.Provider) == 0 || user.Provider == model.Internal {
        return nil, service.ErrInvalidRemoteProvider
            Severity: Major
            Found in services/users/usecase/business/authServiceJTW.go - About 40 mins to fix

              Method Handler.DeleteOrder has 6 return statements (exceeds 4 allowed).
              Open

              func (h *Handler) DeleteOrder(ctx context.Context, filter *proto.OrderFilter) (resp *proto.OrderResponse, err error) {
    orderIDs := filter.OrderID; orderID := orderIDs[0]; if len(orderIDs) == 0 || len(orderID) == 0 {
        return nil, business.ErrOrderNotFound
    }
              Severity: Major
              Found in services/orders/api/gRPC/handler.go - About 40 mins to fix

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

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

    filter := bson.M{"unique_id": bson.M{"$in": usernames}}
                Severity: Major
                Found in services/users/usecase/storage/mongo/repository.go - About 40 mins to fix

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

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

    filter, err := query.ToBson()
                  Severity: Major
                  Found in services/users/usecase/storage/mongo/repository.go - About 40 mins to fix

                    Method serviceContainer.Resolve has 6 return statements (exceeds 4 allowed).
                    Open

                    func (c *serviceContainer) Resolve(receiver interface{}) error {
    receiverType := reflect.TypeOf(receiver); if receiverType == nil {
        return ErrReceiverNotValid
    }
                    Severity: Major
                    Found in shared/container/serviceContainer.go - About 40 mins to fix

                      Function NewHandler has 5 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                      func NewHandler(service service.UserService, auth service.AuthService, mail service.MailService,
    interact service.InteractService, config config.CommonConfig) *Handler {
                      Severity: Minor
                      Found in services/users/api/rest/handler.go - About 35 mins to fix

                        Function ProvideRESTGatewayHandler has 5 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                        func ProvideRESTGatewayHandler(service service.UserService, authService service.AuthService, mailService service.MailService,
    interactService service.InteractService, config env.ServiceConfig) *rest.Handler {
                        Severity: Minor
                        Found in services/users/container/factory/gatewayHandlerFactory.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.WithTimeout(context.Background(), r.timeout)
    defer cancel()

    filter, err := query.ToBson(); if err != nil {
                          Severity: Major
                          Found in services/references/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.SneakerProduct, error) {
    keys := r.client.Keys("sneakerProduct*").Val()
    if len(keys) == 0 {
        return nil, errors.Wrap(business.ErrProductNotFound, "repository.SneakerProduct.FetchAll")
    }
                            Severity: Major
                            Found in services/products/usecase/storage/redis/repository.go - About 35 mins to fix

                              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
                                        Severity
                                        Category
                                        Status
                                        Source
                                        Language