Correlations: Add UpdateCorrelation HTTP API (#52444)

* Correlations: add UpdateCorrelation HTTP API

* handle correlation not found

* add tests

* fix lint errors

* add bad request to API spec

* change casing

* fix casing in docs

* fix tests

* update spec

pkg/services/correlations/api.go

@@ -21,6 +21,7 @@ func (s *CorrelationsService) registerAPIEndpoints() {
 	s.RouteRegister.Group("/api/datasources/uid/:uid/correlations", func(entities routing.RouteRegister) {
 		entities.Post("/", middleware.ReqSignedIn, authorize(ac.ReqOrgAdmin, ac.EvalPermission(datasources.ActionWrite, uidScope)), routing.Wrap(s.createHandler))
 		entities.Delete("/:correlationUID", middleware.ReqSignedIn, authorize(ac.ReqOrgAdmin, ac.EvalPermission(datasources.ActionWrite, uidScope)), routing.Wrap(s.deleteHandler))
+		entities.Patch("/:correlationUID", middleware.ReqSignedIn, authorize(ac.ReqOrgAdmin, ac.EvalPermission(datasources.ActionWrite, uidScope)), routing.Wrap(s.updateHandler))
 	})
 }
 
@@ -127,3 +128,66 @@ type DeleteCorrelationResponse struct {
 	// in: body
 	Body DeleteCorrelationResponseBody `json:"body"`
 }
+
+// swagger:route PATCH /datasources/uid/{sourceUID}/correlations/{correlationUID} correlations updateCorrelation
+//
+// Updates a correlation.
+//
+// Responses:
+// 200: updateCorrelationResponse
+// 400: badRequestError
+// 401: unauthorisedError
+// 403: forbiddenError
+// 404: notFoundError
+// 500: internalServerError
+func (s *CorrelationsService) updateHandler(c *models.ReqContext) response.Response {
+	cmd := UpdateCorrelationCommand{}
+	if err := web.Bind(c.Req, &cmd); err != nil {
+		return response.Error(http.StatusBadRequest, "bad request data", err)
+	}
+
+	cmd.UID = web.Params(c.Req)[":correlationUID"]
+	cmd.SourceUID = web.Params(c.Req)[":uid"]
+	cmd.OrgId = c.OrgId
+
+	correlation, err := s.UpdateCorrelation(c.Req.Context(), cmd)
+	if err != nil {
+		if errors.Is(err, ErrUpdateCorrelationEmptyParams) {
+			return response.Error(http.StatusBadRequest, "At least one of label, description is required", err)
+		}
+
+		if errors.Is(err, ErrSourceDataSourceDoesNotExists) {
+			return response.Error(http.StatusNotFound, "Data source not found", err)
+		}
+
+		if errors.Is(err, ErrCorrelationNotFound) {
+			return response.Error(http.StatusNotFound, "Correlation not found", err)
+		}
+
+		if errors.Is(err, ErrSourceDataSourceReadOnly) {
+			return response.Error(http.StatusForbidden, "Data source is read only", err)
+		}
+
+		return response.Error(http.StatusInternalServerError, "Failed to update correlation", err)
+	}
+
+	return response.JSON(http.StatusOK, UpdateCorrelationResponseBody{Message: "Correlation updated", Result: correlation})
+}
+
+// swagger:parameters updateCorrelation
+type UpdateCorrelationParams struct {
+	// in:path
+	// required:true
+	DatasourceUID string `json:"sourceUID"`
+	// in:path
+	// required:true
+	CorrelationUID string `json:"correlationUID"`
+	// in: body
+	Body UpdateCorrelationCommand `json:"body"`
+}
+
+//swagger:response updateCorrelationResponse
+type UpdateCorrelationResponse struct {
+	// in: body
+	Body UpdateCorrelationResponseBody `json:"body"`
+}

pkg/services/correlations/correlations.go

@@ -52,6 +52,10 @@ func (s CorrelationsService) DeleteCorrelation(ctx context.Context, cmd DeleteCo
 	return s.deleteCorrelation(ctx, cmd)
 }
 
+func (s CorrelationsService) UpdateCorrelation(ctx context.Context, cmd UpdateCorrelationCommand) (Correlation, error) {
+	return s.updateCorrelation(ctx, cmd)
+}
+
 func (s CorrelationsService) DeleteCorrelationsBySourceUID(ctx context.Context, cmd DeleteCorrelationsBySourceUIDCommand) error {
 	return s.deleteCorrelationsBySourceUID(ctx, cmd)
 }

pkg/services/correlations/database.go

@@ -77,6 +77,61 @@ func (s CorrelationsService) deleteCorrelation(ctx context.Context, cmd DeleteCo
 	})
 }
 
+func (s CorrelationsService) updateCorrelation(ctx context.Context, cmd UpdateCorrelationCommand) (Correlation, error) {
+	correlation := Correlation{
+		UID:       cmd.UID,
+		SourceUID: cmd.SourceUID,
+	}
+
+	err := s.SQLStore.WithTransactionalDbSession(ctx, func(session *sqlstore.DBSession) error {
+		query := &datasources.GetDataSourceQuery{
+			OrgId: cmd.OrgId,
+			Uid:   cmd.SourceUID,
+		}
+		if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
+			return ErrSourceDataSourceDoesNotExists
+		}
+
+		if query.Result.ReadOnly {
+			return ErrSourceDataSourceReadOnly
+		}
+
+		if cmd.Label == nil && cmd.Description == nil {
+			return ErrUpdateCorrelationEmptyParams
+		}
+		update := Correlation{}
+		if cmd.Label != nil {
+			update.Label = *cmd.Label
+			session.MustCols("label")
+		}
+		if cmd.Description != nil {
+			update.Description = *cmd.Description
+			session.MustCols("description")
+		}
+
+		updateCount, err := session.Where("uid = ? AND source_uid = ?", correlation.UID, correlation.SourceUID).Limit(1).Update(update)
+		if updateCount == 0 {
+			return ErrCorrelationNotFound
+		}
+		if err != nil {
+			return err
+		}
+
+		found, err := session.Get(&correlation)
+		if !found {
+			return ErrCorrelationNotFound
+		}
+
+		return err
+	})
+
+	if err != nil {
+		return Correlation{}, err
+	}
+
+	return correlation, nil
+}
+
 func (s CorrelationsService) deleteCorrelationsBySourceUID(ctx context.Context, cmd DeleteCorrelationsBySourceUIDCommand) error {
 	return s.SQLStore.WithDbSession(ctx, func(session *sqlstore.DBSession) error {
 		_, err := session.Delete(&Correlation{SourceUID: cmd.SourceUID})

pkg/services/correlations/models.go

@@ -9,8 +9,8 @@ var (
 	ErrSourceDataSourceDoesNotExists      = errors.New("source data source does not exist")
 	ErrTargetDataSourceDoesNotExists      = errors.New("target data source does not exist")
 	ErrCorrelationFailedGenerateUniqueUid = errors.New("failed to generate unique correlation UID")
-	ErrCorrelationIdentifierNotSet        = errors.New("source identifier and org id are needed to be able to edit correlations")
 	ErrCorrelationNotFound                = errors.New("correlation not found")
+	ErrUpdateCorrelationEmptyParams       = errors.New("not enough parameters to edit correlation")
 )
 
 // Correlation is the model for correlations definitions
@@ -72,6 +72,28 @@ type DeleteCorrelationCommand struct {
 	OrgId     int64
 }
 
+// swagger:model
+type UpdateCorrelationResponseBody struct {
+	Result Correlation `json:"result"`
+	// example: Correlation updated
+	Message string `json:"message"`
+}
+
+// UpdateCorrelationCommand is the command for updating a correlation
+type UpdateCorrelationCommand struct {
+	// UID of the correlation to be deleted.
+	UID       string `json:"-"`
+	SourceUID string `json:"-"`
+	OrgId     int64  `json:"-"`
+
+	// Optional label identifying the correlation
+	// example: My label
+	Label *string `json:"label"`
+	// Optional description of the correlation
+	// example: Logs to Traces
+	Description *string `json:"description"`
+}
+
 type DeleteCorrelationsBySourceUIDCommand struct {
 	SourceUID string
 }