Unify json parsing code in WKRemoteDataStoreController (#8557)

Author: fm3

app/controllers/WKRemoteDataStoreController.scala

@@ -29,15 +29,15 @@ import models.team.TeamDAO
 import models.user.{MultiUserDAO, User, UserDAO, UserService}
 import net.liftweb.common.Full
 import play.api.i18n.{Messages, MessagesProvider}
-import play.api.libs.json.{JsError, JsSuccess, JsValue, Json}
+import play.api.libs.json.Json
 import play.api.mvc.{Action, AnyContent, PlayBodyParsers}
 import security.{WebknossosBearerTokenAuthenticatorService, WkSilhouetteEnvironment}
 import telemetry.SlackNotificationService
 import utils.WkConf
 
 import scala.concurrent.duration.DurationInt
 import javax.inject.Inject
-import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.ExecutionContext
 
 class WKRemoteDataStoreController @Inject()(
     datasetService: DatasetService,
@@ -175,21 +175,17 @@ class WKRemoteDataStoreController @Inject()(
                                         s"For organization: ${organization.name}. <$resultLink|Result>")
     } yield ()
 
-  def statusUpdate(name: String, key: String): Action[JsValue] = Action.async(parse.json) { implicit request =>
-    dataStoreService.validateAccess(name, key) { _ =>
-      request.body.validate[DataStoreStatus] match {
-        case JsSuccess(status, _) =>
-          logger.debug(s"Status update from data store '$name'. Status: " + status.ok)
-          for {
-            _ <- dataStoreDAO.updateUrlByName(name, status.url)
-            _ <- dataStoreDAO.updateReportUsedStorageEnabledByName(name,
-                                                                   status.reportUsedStorageEnabled.getOrElse(false))
-          } yield Ok
-        case e: JsError =>
-          logger.error("Data store '$name' sent invalid update. Error: " + e)
-          Future.successful(JsonBadRequest(JsError.toJson(e)))
+  def statusUpdate(name: String, key: String): Action[DataStoreStatus] = Action.async(validateJson[DataStoreStatus]) {
+    implicit request =>
+      dataStoreService.validateAccess(name, key) { _ =>
+        val okLabel = if (request.body.ok) "ok" else "not ok"
+        logger.debug(s"Status update from data store '$name'. Status $okLabel")
+        for {
+          _ <- dataStoreDAO.updateUrlByName(name, request.body.url)
+          _ <- dataStoreDAO.updateReportUsedStorageEnabledByName(name,
+                                                                 request.body.reportUsedStorageEnabled.getOrElse(false))
+        } yield Ok
       }
-    }
   }
 
   def updateAll(name: String, key: String): Action[List[InboxDataSource]] =
@@ -209,37 +205,23 @@ class WKRemoteDataStoreController @Inject()(
       }
     }
 
-  def updateOne(name: String, key: String): Action[JsValue] = Action.async(parse.json) { implicit request =>
-    dataStoreService.validateAccess(name, key) { dataStore =>
-      request.body.validate[InboxDataSource] match {
-        case JsSuccess(dataSource, _) =>
-          for {
-            _ <- datasetService.updateDataSources(dataStore, List(dataSource))(GlobalAccessContext)
-          } yield {
-            JsonOk
-          }
-        case e: JsError =>
-          logger.warn("Data store reported invalid json for data source.")
-          Fox.successful(JsonBadRequest(JsError.toJson(e)))
+  def updateOne(name: String, key: String): Action[InboxDataSource] =
+    Action.async(validateJson[InboxDataSource]) { implicit request =>
+      dataStoreService.validateAccess(name, key) { dataStore =>
+        for {
+          _ <- datasetService.updateDataSources(dataStore, List(request.body))(GlobalAccessContext)
+        } yield Ok
       }
     }
-  }
 
-  def updatePaths(name: String, key: String): Action[JsValue] = Action.async(parse.json) { implicit request =>
-    dataStoreService.validateAccess(name, key) { _ =>
-      request.body.validate[List[DataSourcePathInfo]] match {
-        case JsSuccess(infos, _) =>
-          for {
-            _ <- datasetService.updateRealPaths(infos)(GlobalAccessContext)
-          } yield {
-            JsonOk
-          }
-        case e: JsError =>
-          logger.warn("Data store reported invalid json for data source paths.")
-          Fox.successful(JsonBadRequest(JsError.toJson(e)))
+  def updatePaths(name: String, key: String): Action[List[DataSourcePathInfo]] =
+    Action.async(validateJson[List[DataSourcePathInfo]]) { implicit request =>
+      dataStoreService.validateAccess(name, key) { _ =>
+        for {
+          _ <- datasetService.updateRealPaths(request.body)(GlobalAccessContext)
+        } yield Ok
       }
     }
-  }
 
   def deleteDataset(name: String, key: String): Action[DataSourceId] = Action.async(validateJson[DataSourceId]) {
     implicit request =>