adds transformation errors

src/main/kotlin/unibz.cs.semint.kprime/adapter/strategy/TransformationStrategyYesAdapter.kt

 package unibz.cs.semint.kprime.adapter.strategy
 
 import unibz.cs.semint.kprime.domain.TransformationStrategy
+import unibz.cs.semint.kprime.usecase.TransformerUseCase
 
 class TransformationStrategyYesAdapter : TransformationStrategy {
+    override fun choose(transformersApplicable: List<TransformerUseCase>): List<TransformerUseCase> {
+        return listOf(transformersApplicable.first())
+    }
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/domain/Transformation.kt

@@ -2,5 +2,13 @@ package unibz.cs.semint.kprime.domain
 
 import unibz.cs.semint.kprime.domain.ddl.Database
 import unibz.cs.semint.kprime.domain.dml.ChangeSet
+import java.time.LocalDateTime
 
-data class Transformation(val changeset : ChangeSet, val newdb : Database)
\ No newline at end of file
+data class Transformation(val changeset: ChangeSet, val newdb: Database, val message: String) {
+    val timestamp = LocalDateTime.now()
+    override fun toString(): String {
+        return "Transformation(timestamp=$timestamp, changeset=$changeset, newdb=$newdb, message='$message')"
+    }
+
+
+}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/domain/TransformationStrategy.kt

 package unibz.cs.semint.kprime.domain
 
+import unibz.cs.semint.kprime.usecase.TransformerUseCase
+
 interface TransformationStrategy {
+    fun choose(transformersApplicable: List<TransformerUseCase>): List<TransformerUseCase>
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/domain/dml/ChangeSet.kt

@@ -57,4 +57,9 @@ class ChangeSet() {
     infix fun minus(dropconstraint:DropConstraint) = apply {
         this.dropConstraint.add(dropconstraint)
     }
+
+    fun size(): Int {
+        return createView.size +createTable.size + createConstraint.size
+            + dropView.size + dropTable.size + dropConstraint.size
+    }
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/OptimusUseCase.kt

@@ -4,10 +4,6 @@ import unibz.cs.semint.kprime.domain.Applicability
 import unibz.cs.semint.kprime.domain.Transformation
 import unibz.cs.semint.kprime.domain.TransformationStrategy
 import unibz.cs.semint.kprime.domain.ddl.Database
-import unibz.cs.semint.kprime.usecase.current.TransformerHUseCase
-import unibz.cs.semint.kprime.usecase.current.TransformerVUseCase
-import unibz.cs.semint.kprime.usecase.service.FileIOService
-import unibz.cs.semint.kprime.usecase.service.IXMLSerializerService
 import java.util.*
 import kotlin.collections.ArrayList
 import kotlin.collections.mapOf
@@ -23,84 +19,28 @@ class OptimusUseCase(transformationStrategy: TransformationStrategy) {
         return this
     }
 
-    fun transfom(db: Database):List<Transformation> {
+    fun transfom(db: Database, params: Map<String, Any>):List<Transformation> {
         if (transfomers.size==0) {
             println("Required at least one transformer. Use addTrasnsformers().")
         }
-        val transformationPath = transfomers
-                .filter { t -> t.decomposeApplicable(db,transformationStrategy).ok }
-                .map { t ->
-                    val params = mapOf(
-                            "workingDir" to ""
-                    )
-                    t.decompose(db, params)
-                }.toList()
-        return transformationPath
-    }
-
-
-    // FIXME deprecated
-    private fun oldtransfom(db: Database):Database {
-        var dbTrasformable = db
-        var moreTrasformable = true
-        while (moreTrasformable) {
-            moreTrasformable = false
-            val pair = tryUseAnyTransfomers(db, dbTrasformable, moreTrasformable)
-            dbTrasformable = pair.first
-            moreTrasformable = pair.second
-        }
-        return dbTrasformable
-    }
-
-    // FIXME deprecated
-    private fun tryUseAnyTransfomers(db: Database, dbTrasformable: Database, trasformable: Boolean): Pair<Database, Boolean> {
-        var dbTrasformable1 = dbTrasformable
-        var moreTrasformable = trasformable
-        for (transfomer in transfomers) {
-            val pair = checkDecomposabilityUserAknowledgeAndTransform(
-                    transfomer, db, dbTrasformable1, moreTrasformable)
-            dbTrasformable1 = pair.first
-            moreTrasformable = pair.second
-        }
-        return Pair(dbTrasformable1, moreTrasformable)
-    }
-
-    // FIXME deprecated
-    private fun checkDecomposabilityUserAknowledgeAndTransform(
-            transfomer: TransformerUseCase, db: Database, dbTrasformable1: Database, trasformable1: Boolean): Pair<Database, Boolean> {
-        var dbTrasformable11 = dbTrasformable1
-        var moreTrasformable = trasformable1
-        val decomposability : Applicability = transfomer.decomposeApplicable(db,transformationStrategy)
-        moreTrasformable = decomposability.ok
-        if (decomposability.ok) {
-            if (mockedUserAknowledge(decomposability.message)) {
-                val params = mapOf(
-                        "" to ""
-                )
-                val transformation: Transformation = transfomer.decompose(db, params)
-                print(transformation.changeset)
-                print(transformation.newdb)
-                dbTrasformable11 = transformation.newdb
+        var totalTransformationPath = mutableListOf<Transformation>()
+        var tryMoreSteps = true
+        while(tryMoreSteps) {
+            val transformersApplicable = transfomers
+                    .filter { t -> t.decomposeApplicable(db, transformationStrategy).ok }
+            println("transformersApplicable : $transformersApplicable ")
+            val transfomersChoosed: List<TransformerUseCase> = transformationStrategy.choose(transformersApplicable)
+            println("transfomersChoosed : $transfomersChoosed ")
+            val transformationPath = transfomersChoosed
+                    .map { t -> t.decompose(db, params) }.toList()
+            println("transformationPath : $transformationPath ")
+            totalTransformationPath.addAll(transformationPath)
+            tryMoreSteps = false
+            for (transformation in transformationPath) {
+                if (transformation.changeset.size()>0) tryMoreSteps = true
             }
         }
-        return Pair(dbTrasformable11, moreTrasformable)
+        return totalTransformationPath
     }
 
-    // FIXME deprecated by strategy
-    private fun userAknowledge(message: String): Boolean {
-        println()
-        println(message)
-        println("Y/N")
-        val reader = Scanner(System.`in`)
-        val response = reader.next()
-        return response.toUpperCase().equals("Y")
-    }
-
-    // FIXME deprecated
-    private fun mockedUserAknowledge(message: String): Boolean {
-        println()
-        println(message)
-        println("Y/N")
-        return true
-    }
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/TransformerUseCase.kt

@@ -4,10 +4,14 @@ import unibz.cs.semint.kprime.domain.Applicability
 import unibz.cs.semint.kprime.domain.Transformation
 import unibz.cs.semint.kprime.domain.TransformationStrategy
 import unibz.cs.semint.kprime.domain.ddl.Database
+import unibz.cs.semint.kprime.domain.dml.ChangeSet
 
 interface TransformerUseCase {
     fun decompose(db: Database, params:Map<String,Any>): Transformation
     fun compose(db: Database, params:Map<String,Any>): Transformation
     fun decomposeApplicable(db: Database, transformationStrategy : TransformationStrategy): Applicability
     fun composeApplicable(db: Database, transformationStrategy : TransformationStrategy): Applicability
+    fun errorTransformation(db: Database, message: String): Transformation {
+        return Transformation(ChangeSet(),db,message)
+    }
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/current/TransformerHUseCase.kt

@@ -10,12 +10,12 @@ import unibz.cs.semint.kprime.usecase.TransformerUseCase
 class TransformerHUseCase : TransformerUseCase {
     override fun decompose(db: Database, params:Map<String,Any>): Transformation {
         // TODO("not implemented")
-        return Transformation(ChangeSet(), Database())
+        return Transformation(ChangeSet(), Database(), "TransformerHUseCase.decompose")
     }
 
     override fun compose(db: Database, params:Map<String,Any>): Transformation {
         // TODO("not implemented")
-        return Transformation(ChangeSet(), Database())
+        return Transformation(ChangeSet(), Database(), "TransformerHUseCase.compose")
     }
 
     override fun decomposeApplicable(db: Database, transformationStrategy: TransformationStrategy): Applicability {
@@ -30,4 +30,9 @@ class TransformerHUseCase : TransformerUseCase {
         return Applicability(false, "TransformerHUseCase.composeApplicable", tranformerParmeters)
     }
 
+    override fun toString(): String {
+        return "TransformerHUseCase()"
+    }
+
+
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/current/TransformerVUseCase.kt

@@ -17,9 +17,12 @@ class TransformerVUseCase(serializer: IXMLSerializerService, fileIOAdapter: File
 
     override fun decompose(db: Database, params:Map<String,Any>): Transformation {
         val tranformerParmeters = mutableMapOf<String,Any>()
-        tranformerParmeters["originTable"]=params["originTable"]!!
-        tranformerParmeters["targetTable1"]=params["targetTable1"]!!
-        tranformerParmeters["targetTable2"]=params["targetTable2"]!!
+        tranformerParmeters.putAll(params)
+
+        if (tranformerParmeters["originTable"]==null) return errorTransformation(db,"ERROR: TransformerVUseCase originTable null")
+        if (tranformerParmeters["targetTable1"]==null) return errorTransformation(db,"ERROR: TransformerVUseCase targetTable1 null")
+        if (tranformerParmeters["targetTable2"]==null) return errorTransformation(db,"ERROR: TransformerVUseCase targetTable2 null")
+        if (params["workingDir"]==null) return errorTransformation(db,"ERROR: TransformerVUseCase workingDir null")
         val workingDir = params["workingDir"] as String
         val changeSet = XPathTransformUseCase().compute(fileIOAdapter.writeOnWorkingFilePath(serializer.prettyDatabase(db), workingDir+"db.xml"),
                 "vertical",
@@ -27,13 +30,13 @@ class TransformerVUseCase(serializer: IXMLSerializerService, fileIOAdapter: File
                 "1",
                 tranformerParmeters,
                 StringWriter())
-        return Transformation(changeSet, ApplyChangeSetUseCase(serializer).apply(db,changeSet))
+        return Transformation(changeSet, ApplyChangeSetUseCase(serializer).apply(db,changeSet), "TransformerVUseCase.decompose")
     }
 
     override fun compose(db: Database, params: Map<String,Any>): Transformation {
         val changeSet = VJoinUseCase().compute(db)
         val newdb = ApplyChangeSetUseCase(serializer).apply(db, changeSet)
-        return Transformation(changeSet, newdb)
+        return Transformation(changeSet, newdb, "TransformerVUseCase.compose")
     }
 
     override fun decomposeApplicable(db: Database, transformationStrategy: TransformationStrategy): Applicability {
@@ -55,4 +58,7 @@ class TransformerVUseCase(serializer: IXMLSerializerService, fileIOAdapter: File
         return Applicability(true, "TransformerVUseCase.composeApplicable", tranformerParmeters)
     }
 
+    override fun toString(): String {
+        return "TransformerVUseCase"
+    }
 }
\ No newline at end of file

src/test/kotlin/unibz.cs.semint.kprime/usecase/OptimusUseCaseTI.kt

@@ -42,6 +42,10 @@ class OptimusUseCaseTI {
         database.schema
                 .addFunctionals("film","film_id --> replacement_cost, rental_duration, rental_rate")
 
+        val params = mapOf(
+                "workingDir" to ""
+        )
+
         // when
         val serializerService = XMLSerializerJacksonAdapter()
         val fileIOService = FileIOAdapter()
@@ -50,14 +54,16 @@ class OptimusUseCaseTI {
         ).addTrasnsformers(listOf(
                 TransformerHUseCase(),
                 TransformerVUseCase(serializerService,fileIOService)
-        )).transfom(database)
+        )).transfom(database, params)
         // then
         assertNotNull(transformationPath)
+        println(transformationPath)
         doPhysicalTransformation(sakilaDataSource(), transformationPath)
+
     }
 
     private fun doPhysicalTransformation(sakilaDataSource: DataSource, transformationPath: List<Transformation>) {
-        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+        // TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
     }
 
 }