Automatically import defaultLabels from extractor_info.json

Author: bodom0015

app/api/Extractions.scala

@@ -475,7 +475,26 @@ class Extractions @Inject()(
       },
       info => {
         extractors.updateExtractorInfo(info) match {
-          case Some(u) => Ok(Json.obj("status" -> "OK", "message" -> ("Extractor info updated. ID = " + u.id)))
+          case Some(u) => {
+            // Create/assign any default labels for this extractor
+            u.defaultLabels.foreach(labelName => {
+              extractors.getExtractorsLabel(labelName) match {
+                case None => {
+                  // Label does not exist - create then assign it
+                  val createdLabel = extractors.createExtractorsLabel(labelName, Some("Default"), List[String](u.name))
+                }
+                case Some(lbl) => {
+                  // Label already exists, assign it
+                  if (!lbl.extractors.contains(u.name)) {
+                    val label = ExtractorsLabel(lbl.id, lbl.name, lbl.category, lbl.extractors ++ List[String](u.name))
+                    val updatedLabel = extractors.updateExtractorsLabel(label)
+                  }
+                }
+              }
+            })
+
+            Ok(Json.obj("status" -> "OK", "message" -> ("Extractor info updated. ID = " + u.id)))
+          }
           case None => BadRequest(Json.obj("status" -> "KO", "message" -> "Error updating extractor info"))
         }
       }
@@ -691,9 +710,7 @@ class Extractions @Inject()(
           Ok(Json.toJson(label))
         }
       }
-
     }
-
   }
 
   def updateExtractorsLabel(id: UUID) = ServerAdminAction(parse.json) { implicit request =>
@@ -712,15 +729,13 @@ class Extractions @Inject()(
             Conflict("Label name is already in use: " + lbl.name)
           } else {
             // Update the label
-            val label = ExtractorsLabel(id, name, category, assignedExtractors)
-            val updatedLabel = extractors.updateExtractorsLabel(label)
+            val updatedLabel = extractors.updateExtractorsLabel(ExtractorsLabel(id, name, category, assignedExtractors))
             Ok(Json.toJson(updatedLabel))
           }
         }
         case None => {
           // Update the label
-          val label = ExtractorsLabel(id, name, category, assignedExtractors)
-          val updatedLabel = extractors.updateExtractorsLabel(label)
+          val updatedLabel = extractors.updateExtractorsLabel(ExtractorsLabel(id, name, category, assignedExtractors))
           Ok(Json.toJson(updatedLabel))
         }
       }

app/controllers/Extractors.scala

@@ -69,8 +69,8 @@ class Extractors  @Inject() (extractions: ExtractionService,
     request.getQueryString("labelFilter") match {
       case None => {}
       case Some(lblName) => allLabels.find(lbl => lblName == lbl.name) match {
-        case Some(label) => runningExtractors = runningExtractors.filter(re => label.extractors.contains(re.name))
         case None => {}
+        case Some(label) => runningExtractors = runningExtractors.filter(re => label.extractors.contains(re.name))
       }
     }
 

app/models/Extraction.scala

@@ -72,6 +72,10 @@ case class ExtractorDetail(
  * @param external_services external services used by the extractor
  * @param libraries libraries on which the code depends
  * @param bibtex bibtext formatted citation of relevant papers
+ * @param maturity indicates whether this extractor is ready for public consumption
+ *             * For example: "Development" (default), "Staging", or "Production"
+ * @param defaultLabels the categorization labels that were imported by default
+ *             * For example: "Development" (default), "Staging", or "Production"
  * @param process events that should trigger this extractor to process
  * @param categories list of categories that apply to the extractor
  * @param parameters JSON schema representing allowed parameters
@@ -94,6 +98,7 @@ case class ExtractorInfo(
   libraries: List[String],
   bibtex: List[String],
   maturity: String = "Development",
+  defaultLabels: List[String] = List[String](),
   process: ExtractorProcessTriggers = new ExtractorProcessTriggers(),
   categories: List[String] = List[String](ExtractorCategory.EXTRACT.toString),
   parameters: JsValue = JsObject(Seq())
@@ -146,6 +151,7 @@ object ExtractorInfo {
       (JsPath \ "libraries").read[List[String]].orElse(Reads.pure(List.empty)) and
       (JsPath \ "bibtex").read[List[String]].orElse(Reads.pure(List.empty)) and
       (JsPath \ "maturity").read[String].orElse(Reads.pure("Development")) and
+      (JsPath \ "labels").read[List[String]].orElse(Reads.pure(List.empty)) and
       (JsPath \ "process").read[ExtractorProcessTriggers].orElse(Reads.pure(new ExtractorProcessTriggers())) and
       (JsPath \ "categories").read[List[String]].orElse(Reads.pure(List[String](ExtractorCategory.EXTRACT.toString))) and
       (JsPath \ "parameters").read[JsValue].orElse(Reads.pure(JsObject(Seq())))
@@ -208,4 +214,14 @@ object ExtractorsLabel {
       (JsPath \ "category").readNullable[String] and
       (JsPath \ "extractors").read[List[String]].orElse(Reads.pure(List.empty))
     )(ExtractorsLabel.apply _)
+}
+
+case class LabelAssignment (
+                            extractorId: UUID,
+                            labelId: UUID
+                          )
+
+object LabelAssignment {
+  implicit val writes = Json.writes[LabelAssignment]
+  implicit val reads = Json.reads[LabelAssignment]
 }

app/services/ExtractorService.scala

@@ -49,7 +49,7 @@ trait ExtractorService {
 
   def getExtractorsLabel(id: UUID): Option[ExtractorsLabel]
 
-  def createExtractorsLabel(name: String, category: Option[String], extractors: List[String]): ExtractorsLabel
+  def createExtractorsLabel(name: String, category: Option[String], assignedExtractors:List[String]): ExtractorsLabel
 
   def updateExtractorsLabel(label: ExtractorsLabel): ExtractorsLabel
 

app/services/RabbitmqPlugin.scala

@@ -1252,7 +1252,28 @@ class ExtractorsHeartbeats(channel: Channel, queue: String) extends Actor {
               }
             }
             case None => {
-              extractorsService.updateExtractorInfo(info)
+              extractorsService.updateExtractorInfo(info) match {
+                case None => {}
+                case Some(eInfo) => {
+                  // Create (if needed) and assign default labels
+                  eInfo.defaultLabels.foreach(labelName => {
+                    extractorsService.getExtractorsLabel(labelName) match {
+                      case None => {
+                        // Label does not exist - create then assign it
+                        val createdLabel = extractorsService.createExtractorsLabel(labelName, Some("Default"), List[String](eInfo.name))
+                      }
+                      case Some(lbl) => {
+                        // Label already exists, assign it
+                        if (!lbl.extractors.contains(eInfo.name)) {
+                          val label = ExtractorsLabel(lbl.id, lbl.name, lbl.category, lbl.extractors ++ List[String](eInfo.name))
+                          val updatedLabel = extractorsService.updateExtractorsLabel(label)
+                        }
+                      }
+                    }
+                  })
+                }
+              }
+
               Logger.info(s"New extractor ${info.name} registered from heartbeat")
             }
           }

app/services/mongodb/MongoDBExtractorService.scala

@@ -215,7 +215,6 @@ class MongoDBExtractorService extends ExtractorService {
       case None => {
         Logger.info("No extractor found with name: " + extractorName)
       }
-
     }
   }
 
@@ -246,7 +245,20 @@ class MongoDBExtractorService extends ExtractorService {
   }
 
   def getLabelsForExtractor(extractorName: String): List[ExtractorsLabel] = {
-    ExtractorsLabelDAO.findAll().filter(_.extractors.contains(extractorName)).toList
+    var results = List[ExtractorsLabel]()
+    ExtractorInfoDAO.findOne(MongoDBObject("name"->extractorName)) match {
+      case Some(info) => {
+        val assignments = LabelAssignmentDAO.find(MongoDBObject("extractorId"->info.id)).toList
+        for(assignment <- assignments) {
+          ExtractorsLabelDAO.findOne(MongoDBObject("_id" -> assignment.labelId.stringify)) match {
+            case Some(label) => {
+              results = results.::(label)
+            }
+          }
+        }
+      }
+    }
+    results
   }
 }
 
@@ -298,6 +310,13 @@ object ExtractorsLabelDAO extends ModelCompanion[ExtractorsLabel, ObjectId] {
   }
 }
 
+object LabelAssignmentDAO extends ModelCompanion[LabelAssignment, ObjectId] {
+  val dao = current.plugin[MongoSalatPlugin] match {
+    case None => throw new RuntimeException("No MongoSalatPlugin");
+    case Some(x) => new SalatDAO[LabelAssignment, ObjectId](collection = x.collection("extractors.labels.assignments")) {}
+  }
+}
+
 object ExtractorsForInstanceDAO extends ModelCompanion[ExtractorsForInstance, ObjectId] {
   val dao = current.plugin[MongoSalatPlugin] match {
     case None => throw new RuntimeException("No MongoSalatPlugin");

app/views/extractorLabels.scala.html

@@ -39,7 +39,7 @@ <h2>Extractor Labels</h2>
                 @for(label <- labels) {
                     <tr>
                         <td>@label.name</td>
-                        <td>@label.category.getOrElse("")</td>
+                        <td>@label.category.getOrElse("Other")</td>
                         <td>
                             <ul>
                             @for(extractorName <- label.extractors) {

app/views/updateExtractors.scala.html

@@ -348,14 +348,16 @@ <h1>Extractor Catalog</h1>
             function submitFilters(labelName, context) {
                 // Grab existing query string values
                 var currentParams = new URLSearchParams(window.location.search);
-                var targets = context.formAction.split('@routes.Extractors.selectExtractors()')
+                var targets = context.formAction.split('@routes.Extractors.selectExtractors()');
+
+                // If same filter selected twice, de-select it
+                var currentLabel = currentParams.get('labelFilter');
+                var newLabelName = labelName === currentLabel ? null : (labelName || currentLabel);
 
                 // Set new query strings parameters based on form value
                 var newParams = new URLSearchParams(targets[1]);
-                var newLabelName = labelName || currentParams.get('labelFilter')
-                if (newLabelName) {
-                    newParams.set('labelFilter', newLabelName);
-                }
+                newLabelName ? newParams.set('labelFilter', newLabelName) : newParams.delete('labelFilter');
+
                 window.location.search = newParams.toString();
             }