refactor(target,operators): renamed Target into TargetOperators and associate all possible operators for the given target

Author: fchiron

app/models/AlertRepository.scala

@@ -119,7 +119,7 @@ object AlertRepository {
     val operatorConfiguration = (triggerCreate.operator - "name").toString()
 
     // Find which target corresponds to the given target value, if no target is found, an exception is raised and the transaction rolled back
-    val targetModel = Target.findTargetTypeForTargetValue(triggerCreate.target, possibleTargets).ensuring(_.isDefined, s"Invalid target value ${triggerCreate.target}").get
+    val targetModel = TargetOperators.findTargetTypeForTargetValue(triggerCreate.target, possibleTargets).ensuring(_.isDefined, s"Invalid target value ${triggerCreate.target}").get
 
     SQL"""
           INSERT INTO trigger (trigger_id, operator_id, alert_id, target_id, target_value, operator_configuration, "createdAt", "updatedAt")

app/models/Target.scala renamed to app/models/TargetOperators.scala

@@ -3,24 +3,25 @@ package models
 import play.api.libs.json.{Format, Json}
 
 /**
- * Represents a target-operator pair, for example "data.foo" with operator "threshold_min"
+ * Represents a target and the operators that can be applied to it,
+ * for example "data.foo" with operators "equal", "threshold_min", "threshold_max", etc.
  * @param target Target data or metadata field (e.g. "data.foo")
- * @param operator Associated operator
+ * @param operators Associated operators
  */
-case class Target(target: String, operator: OperatorModel)
+case class TargetOperators(target: String, operators: Seq[OperatorModel])
 
-object Target {
-  implicit val jsonFormat: Format[Target] = Json.format[Target]
+object TargetOperators {
+  implicit val jsonFormat: Format[TargetOperators] = Json.format[TargetOperators]
 
   /**
-   * Shortcut for calling Target(Target.substituteWildcard(..., ...), operator)
+   * Shortcut for calling Target(Target.substituteWildcard(..., ...), operators)
    * @param wildcardTargetId
    * @param targetField
-   * @param operator
+   * @param operators
    * @return
    */
-  def withWildcardTargetId(wildcardTargetId: String, targetField: String, operator: OperatorModel): Target = {
-    Target(Target.substituteWildcard(wildcardTargetId, targetField), operator)
+  def withWildcardTargetId(wildcardTargetId: String, targetField: String, operators: Seq[OperatorModel]): TargetOperators = {
+    TargetOperators(TargetOperators.substituteWildcard(wildcardTargetId, targetField), operators)
   }
 
   def findTargetTypeForTargetValue(targetValue: String, targetTypes: Seq[TargetModel]): Option[TargetModel] = {

app/models/TargetRepository.scala

@@ -15,16 +15,16 @@ object TargetRepository {
    * @param dataFields Data fields (e.g. "foo", "bar")
    * @return
    */
-  def getByTargetFields(dataFields: Seq[String]): Seq[Target] = DB.withConnection {
+  def getByTargetFields(dataFields: Seq[String]): Seq[TargetOperators] = DB.withConnection {
     implicit connection =>
-      getTargetsAndOperators() map {
+      getTargetsAndOperators().toSeq map {
         // If the target is a wildcard, associate that target for all given dataFields
-        case (TargetModel(target_id, true), operator) =>
-          dataFields.map(dataField => Target.withWildcardTargetId(target_id, dataField, operator))
+        case (TargetModel(target_id, true), operators) =>
+          dataFields.map(dataField => TargetOperators.withWildcardTargetId(target_id, dataField, operators))
 
         // If the target is not a wildcard (e.g. "data"), use it as-is
-        case (TargetModel(target_id, false), operator) =>
-          Seq(Target(target_id, operator))
+        case (TargetModel(target_id, false), operators) =>
+          Seq(TargetOperators(target_id, operators))
       } flatten
   }
 
@@ -37,11 +37,11 @@ object TargetRepository {
    * @param connection SQL connection
    * @return
    */
-  def getTargetsAndOperators()(implicit connection: Connection): Seq[(TargetModel, OperatorModel)] = {
+  def getTargetsAndOperators()(implicit connection: Connection): Map[TargetModel, Seq[OperatorModel]] = {
     SQL"""
           SELECT * FROM target
           JOIN operator_target USING(target_id)
           JOIN operator USING(operator_id)
-       """ as(((TargetModel.simple ~ OperatorModel.simple) map flatten) *)
+       """ as(((TargetModel.simple ~ OperatorModel.simple) map flatten) *) groupBy(_._1) mapValues(_.unzip._2)
   }
 }