386 datasetlastmodifieddate is not updated

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## Unreleased
 
 ## Fixed
+- Updated lastModifiesDate when updating file or metadata to a dataset, added lastModified to UI  [386](https://github.com/clowder-framework/clowder/issues/386)
 - Disabled button while create dataset ajax call is still going on [#311](https://github.com/clowder-framework/clowder/issues/311)
 
 ## 1.21.0 - 2022-08-23

app/api/Datasets.scala

@@ -882,6 +882,7 @@ class  Datasets @Inject()(
 
         datasets.index(id)
         Ok(toJson(Map("status" -> "success")))
+
       }
       case None => Logger.error(s"Error getting dataset $id"); NotFound(toJson(s"Error getting dataset $id"))
     }
@@ -928,6 +929,7 @@ class  Datasets @Inject()(
                 events.addObjectEvent(request.user, id, x.name, EventType.ADD_METADATA_DATASET.toString)
 
                 datasets.index(id)
+
                 Ok(toJson("Metadata successfully added to db"))
               }
               case e: JsError => {

app/controllers/Datasets.scala

@@ -8,7 +8,8 @@ import play.api.Logger
 import play.api.Play.current
 import play.api.libs.json.Json._
 import services._
-import util.{FileUtils, Formatters, RequiredFieldsConfig, SortingUtils }
+import util.{FileUtils, Formatters, RequiredFieldsConfig, SortingUtils}
+
 import scala.collection.immutable._
 import scala.collection.mutable.ListBuffer
 import play.api.i18n.Messages
@@ -728,7 +729,6 @@ class Datasets @Inject() (
     implicit val user = request.user
 
     Logger.debug("------- in Datasets.submit ---------")
-
     val folder = folderId.flatMap(id => folders.get(UUID(id)))
     val retMap = request.body.asFormUrlEncoded.get("datasetid").flatMap(_.headOption) match {
       case Some(ds) => {

app/services/mongodb/MongoDBDatasetService.scala

@@ -729,12 +729,12 @@ class MongoDBDatasetService @Inject() (
           if (file.isInstanceOf[models.File]) {
             val theFile = file.asInstanceOf[models.File]
             if (!theFile.thumbnail_id.isEmpty) {
-              Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> theFile.thumbnail_id.get), false, false, WriteConcern.Safe)
+              Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> theFile.thumbnail_id.get, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
               return
             }
           }
         }
-        Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> None), false, false, WriteConcern.Safe)
+        Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> None, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
       }
       case None => Logger.debug(s"Dataset $datasetId not found")
     }
@@ -749,12 +749,12 @@ class MongoDBDatasetService @Inject() (
           if (file.isInstanceOf[File]) {
             val theFile = file.asInstanceOf[File]
             if (!theFile.thumbnail_id.isEmpty) {
-              Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> theFile.thumbnail_id.get), false, false, WriteConcern.Safe)
+              Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> theFile.thumbnail_id.get, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
               return
             }
           }
         }
-        Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> None), false, false, WriteConcern.Safe)
+        Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> None, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
       }
       case None => Logger.debug("No dataset found with id " + datasetId)
     }
@@ -929,13 +929,13 @@ class MongoDBDatasetService @Inject() (
     val md = JSON.parse(json).asInstanceOf[DBObject]
     Dataset.dao.collection.findOne(MongoDBObject("_id" -> new ObjectId(id.stringify)), MongoDBObject("metadata" -> 1)) match {
       case None => {
-        Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("metadata" -> md), false, false, WriteConcern.Safe)
+        Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("metadata" -> md, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
       }
       case Some(x) => {
         x.getAs[DBObject]("metadata") match {
           case Some(map) => {
             val union = map.asInstanceOf[DBObject] ++ md
-            Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("metadata" -> union), false, false, WriteConcern.Safe)
+            Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("metadata" -> union, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
           }
           case None => Map.empty
         }
@@ -947,44 +947,46 @@ class MongoDBDatasetService @Inject() (
     Logger.debug("Adding XML metadata to dataset " + id + " from file " + fileId + ": " + json)
     val md = JsonUtil.parseJSON(json).asInstanceOf[java.util.LinkedHashMap[String, Any]].toMap
     Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-      $addToSet("datasetXmlMetadata" -> DatasetXMLMetadata.toDBObject(models.DatasetXMLMetadata(md, fileId.stringify))), false, false, WriteConcern.Safe)
+      $addToSet("datasetXmlMetadata" -> DatasetXMLMetadata.toDBObject(models.DatasetXMLMetadata(md, fileId.stringify)))
+        ++ $set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def removeXMLMetadata(id: UUID, fileId: UUID) {
     Logger.debug("Removing XML metadata belonging to file " + fileId + " from dataset " + id + ".")
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $pull("datasetXmlMetadata" -> MongoDBObject("fileId" -> fileId.stringify)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $pull("datasetXmlMetadata" -> MongoDBObject("fileId" -> fileId.stringify))
+      ++ $set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def addUserMetadata(id: UUID, json: String) {
     Logger.debug("Adding/modifying user metadata to dataset " + id + " : " + json)
     val md = com.mongodb.util.JSON.parse(json).asInstanceOf[DBObject]
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("userMetadata" -> md), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("userMetadata" -> md, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   /** Change the metadataCount field for a dataset */
   def incrementMetadataCount(id: UUID, count: Long) = {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $inc("metadataCount" -> count), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $inc("metadataCount" -> count) ++ $set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   /**
    * Implementation of updateInformation defined in services/DatasetService.scala.
    */
   def updateInformation(id: UUID, description: String, name: String) {
       val result = Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-          $set("description" -> description, "name" -> name),
+          $set("description" -> description, "name" -> name, "lastModifiedDate" -> new Date()),
           false, false, WriteConcern.Safe)
   }
 
   def updateName(id: UUID, name: String) {
     events.updateObjectName(id, name)
     val result = Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-      $set("name" -> name),
+      $set("name" -> name, "lastModifiedDate" -> new Date()),
       false, false, WriteConcern.Safe)
   }
 
   def updateDescription(id: UUID, description: String){
     val result = Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-      $set("description" -> description),
+      $set("description" -> description, "lastModifiedDate" -> new Date()),
       false, false, WriteConcern.Safe)
   }
 
@@ -995,7 +997,7 @@ class MongoDBDatasetService @Inject() (
     //Don't allow duplicates
     if (Dataset.dao.find(MongoDBObject("_id" -> new ObjectId(id.stringify)) ++ MongoDBObject("creators" -> creator)).length == 0) {
       val result = Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-        $push("creators" -> creator),
+        $push("creators" -> creator) ++ $set("lastModifiedDate" -> new Date()),
         false, false, WriteConcern.Safe)
     }
   }
@@ -1005,7 +1007,7 @@ class MongoDBDatasetService @Inject() (
    */
   def removeCreator(id: UUID, creator: String) {
     Dataset.dao.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-      $pull("creators" -> creator), false, false, WriteConcern.Safe)
+      $pull("creators" -> creator) ++ $set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   /**
@@ -1016,8 +1018,8 @@ class MongoDBDatasetService @Inject() (
     if (Dataset.dao.find(MongoDBObject("_id" -> new ObjectId(id.stringify)) ++ MongoDBObject("creators" -> creator)).length != 0) {
       removeCreator(id, creator);
       Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-        $push("creators" -> MongoDBObject("$each" -> MongoDBList(creator), "$position" -> position)),
-        false, false, WriteConcern.Safe)
+        $push("creators" -> MongoDBObject("$each" -> MongoDBList(creator), "$position" -> position))
+        ++ $set("lastModifiedDate" -> new Date()),false, false, WriteConcern.Safe)
     }
   }
 
@@ -1032,7 +1034,7 @@ class MongoDBDatasetService @Inject() (
   def updateLicense(id: UUID, licenseType: String, rightsHolder: String, licenseText: String, licenseUrl: String, allowDownload: String) {
       val licenseData = models.LicenseData(m_licenseType = licenseType, m_rightsHolder = rightsHolder, m_licenseText = licenseText, m_licenseUrl = licenseUrl, m_allowDownload = allowDownload.toBoolean)
       val result = Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-          $set("licenseData" -> LicenseData.toDBObject(licenseData)),
+          $set("licenseData" -> LicenseData.toDBObject(licenseData), "lastModifiedDate" -> new Date()),
           false, false, WriteConcern.Safe)
   }
 
@@ -1056,14 +1058,14 @@ class MongoDBDatasetService @Inject() (
       if (!existingTags.contains(shortTag)) {
         val tagObj = models.Tag(name = shortTag, userId = userIdStr, extractor_id = eid, created = createdDate)
         tagsAdded += tagObj
-        Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $addToSet("tags" -> Tag.toDBObject(tagObj)), false, false, WriteConcern.Safe)
+        Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $addToSet("tags" -> Tag.toDBObject(tagObj)) ++ $set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
       }
     })
     tagsAdded.toList
   }
 
   def setUserMetadataWasModified(id: UUID, wasModified: Boolean) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("userMetadataWasModified" -> Some(wasModified)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("userMetadataWasModified" -> Some(wasModified), "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def findMetadataChangedDatasets(): List[Dataset] = {
@@ -1083,7 +1085,8 @@ class MongoDBDatasetService @Inject() (
 
   def removeTag(id: UUID, tagId: UUID) {
     Logger.debug("Removing tag " + tagId)
-    val result = Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $pull("tags" -> MongoDBObject("_id" -> new ObjectId(tagId.stringify))), false, false, WriteConcern.Safe)
+    val result = Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $pull("tags" -> MongoDBObject("_id" -> new ObjectId(tagId.stringify)))
+    ++ $set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def removeTags(id: UUID, tags: List[String]) {
@@ -1094,12 +1097,13 @@ class MongoDBDatasetService @Inject() (
     // Only remove existing tags.
     tags.intersect(existingTags).map {
       tag =>
-        Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $pull("tags" -> MongoDBObject("name" -> tag)), false, false, WriteConcern.Safe)
+        Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $pull("tags" -> MongoDBObject("name" -> tag))
+          ++ $set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
     }
   }
 
   def removeAllTags(id: UUID) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("tags" -> List()), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)), $set("tags" -> List(), "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   // ---------- Tags related code ends ------------------
@@ -1349,28 +1353,28 @@ class MongoDBDatasetService @Inject() (
   }
 
   def addFile(datasetId: UUID, file: File) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $addToSet("files" -> new ObjectId(file.id.stringify)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $addToSet("files" -> new ObjectId(file.id.stringify)) ++$set("lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def addFolder(datasetId: UUID, folderId: UUID) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $addToSet("folders" -> new ObjectId(folderId.stringify)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $addToSet("folders" -> new ObjectId(folderId.stringify)) ++$set( "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def addCollection(datasetId: UUID, collectionId: UUID) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $addToSet("collections" -> new ObjectId(collectionId.stringify)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $addToSet("collections" -> new ObjectId(collectionId.stringify)) ++$set( "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def removeCollection(datasetId: UUID, collectionId: UUID) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $pull("collections" -> new ObjectId(collectionId.stringify)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $pull("collections" -> new ObjectId(collectionId.stringify)) ++$set( "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def removeFile(datasetId: UUID, fileId: UUID) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $pull("files" -> new ObjectId(fileId.stringify)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $pull("files" -> new ObjectId(fileId.stringify)) ++$set( "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
     removeXMLMetadata(datasetId, fileId)
   }
 
   def removeFolder(datasetId: UUID, folderId: UUID) {
-    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $pull("folders" -> new ObjectId(folderId.stringify)), false, false, WriteConcern.Safe)
+    Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $pull("folders" -> new ObjectId(folderId.stringify)) ++$set( "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
   }
 
   def newThumbnail(datasetId: UUID) {
@@ -1381,12 +1385,12 @@ class MongoDBDatasetService @Inject() (
           if (file.isInstanceOf[models.File]) {
             val theFile = file.asInstanceOf[models.File]
             if (!theFile.thumbnail_id.isEmpty) {
-              Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> theFile.thumbnail_id.get), false, false, WriteConcern.Safe)
+              Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> theFile.thumbnail_id.get, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
               return
             }
           }
         }
-        Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> None), false, false, WriteConcern.Safe)
+        Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)), $set("thumbnail_id" -> None, "lastModifiedDate" -> new Date()), false, false, WriteConcern.Safe)
       }
       case None =>
     }
@@ -1452,27 +1456,27 @@ class MongoDBDatasetService @Inject() (
   def addToSpace(datasetId: UUID, spaceId: UUID): Unit = {
     val result = Dataset.update(
       MongoDBObject("_id" -> new ObjectId(datasetId.stringify)),
-      $addToSet("spaces" -> Some(new ObjectId(spaceId.stringify))),
+      $addToSet("spaces" -> Some(new ObjectId(spaceId.stringify))) ++$set( "lastModifiedDate" -> new Date()),
       false, false)
     if (get(datasetId).exists(_.isTRIAL == true) && spaces.get(spaceId).exists(_.isTrial == false)) {
       Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)),
-        $set("status" -> DatasetStatus.DEFAULT.toString),
+        $set("status" -> DatasetStatus.DEFAULT.toString, "lastModifiedDate" -> new Date()),
         false, false)
     }
   }
 
   def removeFromSpace(datasetId: UUID, spaceId: UUID): Unit = {
     val result = Dataset.update(
       MongoDBObject("_id" -> new ObjectId(datasetId.stringify)),
-      $pull("spaces" -> Some(new ObjectId(spaceId.stringify))),
+      $pull("spaces" -> Some(new ObjectId(spaceId.stringify))) ++$set("lastModifiedDate" -> new Date()),
       false, false)
 
     if (play.Play.application().configuration().getBoolean("verifySpaces")) {
 
       get(datasetId) match {
         case Some(d) if !d.spaces.map(s => spaces.get(s)).flatten.exists(_.isTrial == false) =>
           Dataset.update(MongoDBObject("_id" -> new ObjectId(datasetId.stringify)),
-            $set("status" -> DatasetStatus.TRIAL.toString),
+            $set("status" -> DatasetStatus.TRIAL.toString, "lastModifiedDate" -> new Date()),
             false, false)
         case _ =>
       }
@@ -1646,13 +1650,13 @@ class MongoDBDatasetService @Inject() (
   def incrementDownloads(id: UUID, user: Option[User]) = {
     Logger.debug("updating downloads for dataset "+id.toString)
     Dataset.update(MongoDBObject("_id" -> new ObjectId(id.stringify)),
-      $inc("stats.downloads" -> 1) ++ $set("stats.last_downloaded" -> new Date), true, false, WriteConcern.Safe)
+      $inc("stats.downloads" -> 1) ++ $set("stats.last_downloaded" -> new Date, "lastModifiedDate" -> new Date()), true, false, WriteConcern.Safe)
 
     user match {
       case Some(u) => {
         Logger.debug("updating downloads for user "+u.toString)
         DatasetStats.update(MongoDBObject("user_id" -> new ObjectId(u.id.stringify), "resource_id" -> new ObjectId(id.stringify), "resource_type" -> "dataset"),
-          $inc("downloads" -> 1) ++ $set("last_downloaded" -> new Date), true, false, WriteConcern.Safe)
+          $inc("downloads" -> 1) ++ $set("last_downloaded" -> new Date, "lastModifiedDate" -> new Date()), true, false, WriteConcern.Safe)
       }
       case None => {}
     }

app/views/dataset.scala.html

@@ -372,6 +372,7 @@ <h4>Statistics</h4>
                     <tr><td><b>Last viewed:</b></td><td> @view._2.format("MMM dd, yyyy HH:mm:ss")</td></tr>
                     <tr><td><b>Downloads:</b></td><td> @dataset.stats.downloads</td></tr>
                     <tr><td><b>Last downloaded:</b></td><td> @if(dataset.stats.last_downloaded.isDefined){@dataset.stats.last_downloaded.get.format("MMM dd, yyyy HH:mm:ss")}else{Never}</td></tr>
+                    <tr><td><b>Last Modified:</b></td><td> @dataset.lastModifiedDate.format("MMM dd, yyyy HH:mm:ss")</td></tr>
                 </table>
             </div>
             @spaces.spaceAllocation(dataset.id, ResourceRef.dataset,datasetSpaces_canRemove.getOrElse(Map.empty),None)