move usecaseresult to usecase pacakge, adds key columns to target key...

move usecaseresult to usecase pacakge, adds key columns to target key constraint to don't leave empty

src/main/kotlin/unibz.cs.semint.kprime/adapter/repository/MetaSchemaJdbcAdapter.kt

@@ -110,6 +110,7 @@ class MetaSchemaJdbcAdapter : IMetaSchemaRepository {
                 val colSource = Column()
                 colSource.name=primaryKeys.getString("COLUMN_NAME")
                 constr.source.columns.add(colSource)
+                constr.target.columns.add(colSource)
                 //constr.target= Target()
                 db.schema.constraints.add(constr)
             }

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

@@ -7,7 +7,9 @@ import java.time.LocalDateTime
 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')"
+        var flag = ""
+        if (changeset==null || changeset.size()==0) flag = "EMPTY"
+        return "Transformation(timestamp=$timestamp, $flag changeset=$changeset, newdb=$newdb, message='$message')"
     }
 
 

src/main/kotlin/unibz.cs.semint.kprime/domain/ddl/Schema.kt

@@ -64,6 +64,7 @@ class Schema () {
         primaryConstraint.name="primaryKey.$tableName"
         primaryConstraint.source.table="$tableName"
         primaryConstraint.source.columns.addAll(k)
+        primaryConstraint.target.columns.addAll(k)
         primaryConstraint.type= Constraint.TYPE.PRIMARY_KEY.name
         constraints.add(primaryConstraint)
     }

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

@@ -4,6 +4,7 @@ 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
 import java.util.*
 import kotlin.collections.ArrayList
 import kotlin.collections.mapOf
@@ -21,11 +22,13 @@ class OptimusUseCase(transformationStrategy: TransformationStrategy) {
 
     fun transfom(db: Database, params: Map<String, Any>):List<Transformation> {
         if (transfomers.size==0) {
-            println("Required at least one transformer. Use addTrasnsformers().")
+            return listOf(errorTransformation(db, "Required at least one transformer. Use addTrasnsformers()."))
         }
         var totalTransformationPath = mutableListOf<Transformation>()
         var tryMoreSteps = true
-        while(tryMoreSteps) {
+        var maxSteps = 10
+        var steps = 0
+        while(tryMoreSteps && steps < maxSteps) {
             val transformersApplicable = transfomers
                     .filter { t -> t.decomposeApplicable(db, transformationStrategy).ok }
             println("transformersApplicable : $transformersApplicable ")
@@ -39,8 +42,14 @@ class OptimusUseCase(transformationStrategy: TransformationStrategy) {
             for (transformation in transformationPath) {
                 if (transformation.changeset.size()>0) tryMoreSteps = true
             }
+            steps++
         }
         return totalTransformationPath
     }
 
+    private 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/domain/UseCaseResult.kt → src/main/kotlin/unibz.cs.semint.kprime/usecase/UseCaseResult.kt

-package unibz.cs.semint.kprime.domain
+package unibz.cs.semint.kprime.usecase
 
 data class UseCaseResult<T>(val message : String, val ok : T?, val ko : Any = Unit) {}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/common/MetaSchemaReadUseCase.kt

@@ -2,6 +2,7 @@ package unibz.cs.semint.kprime.usecase.common
 
 import unibz.cs.semint.kprime.domain.*
 import unibz.cs.semint.kprime.domain.ddl.Database
+import unibz.cs.semint.kprime.usecase.UseCaseResult
 import unibz.cs.semint.kprime.usecase.repository.IMetaSchemaRepository
 import unibz.cs.semint.kprime.usecase.service.IXMLSerializerService
 import java.util.*
@@ -35,7 +36,7 @@ class MetaSchemaReadUseCase() {
         val tokens = tokenize(line)
         if (tokens.size<2) { return UseCaseResult("Usage:" + usage(), null);}
         if (tokens[1] == "?") { return UseCaseResult(oneline(), null);}
-        if (tokens[1] == "??") { return UseCaseResult(description(),null);}
+        if (tokens[1] == "??") { return UseCaseResult(description(), null);}
         lateinit var db : Database
         if (tokens[0] == name()) {
             val sourceName = tokens[1]
@@ -45,7 +46,7 @@ class MetaSchemaReadUseCase() {
             db = metaSchemaRepository.metaDatabase(datasource)
             print(xmlSerializer.prettyDatabase(db))
         }
-        return UseCaseResult("${name()} done.",db)
+        return UseCaseResult("${name()} done.", db)
     }
 
     fun tokenize(line: String): List<String> {

src/main/kotlin/unibz.cs.semint.kprime/usecase/common/XMLSerializeUseCase.kt

@@ -5,6 +5,7 @@ import unibz.cs.semint.kprime.domain.ddl.Constraint
 import unibz.cs.semint.kprime.domain.ddl.Database
 import unibz.cs.semint.kprime.domain.ddl.Table
 import unibz.cs.semint.kprime.domain.dml.ChangeSet
+import unibz.cs.semint.kprime.usecase.UseCaseResult
 import unibz.cs.semint.kprime.usecase.service.IXMLSerializerService
 
 class XMLSerializeUseCase(val xmlSerializerService: IXMLSerializerService) {
@@ -13,63 +14,63 @@ class XMLSerializeUseCase(val xmlSerializerService: IXMLSerializerService) {
     // table
 
     fun serializeTable(table: Table): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.serializeTable(table))
+        return UseCaseResult("done", xmlSerializerService.serializeTable(table))
     }
 
     fun deserializeTable(table: String): UseCaseResult<Table> {
-        return UseCaseResult("done",xmlSerializerService.deserializeTable(table))
+        return UseCaseResult("done", xmlSerializerService.deserializeTable(table))
     }
 
     fun prettyTable(table: Table): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.prettyTable(table))
+        return UseCaseResult("done", xmlSerializerService.prettyTable(table))
     }
 
     // database
 
     fun serializeDatabase(db: Database): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.serializeDatabase(db))
+        return UseCaseResult("done", xmlSerializerService.serializeDatabase(db))
     }
 
     fun deserializeDatabase(db: String): UseCaseResult<Database> {
-        return UseCaseResult("done",xmlSerializerService.deserializeDatabase(db))
+        return UseCaseResult("done", xmlSerializerService.deserializeDatabase(db))
     }
 
     fun prettyDatabase(db: Database): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.prettyDatabase(db))
+        return UseCaseResult("done", xmlSerializerService.prettyDatabase(db))
     }
 
     // constraint
 
     fun serializeConstraint(constraint: Constraint): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.serializeConstraint(constraint))
+        return UseCaseResult("done", xmlSerializerService.serializeConstraint(constraint))
     }
 
     fun deserializeConstraint(constraint: String): UseCaseResult<Constraint> {
-        return UseCaseResult("done",xmlSerializerService.deserializeConstraint(constraint))
+        return UseCaseResult("done", xmlSerializerService.deserializeConstraint(constraint))
     }
 
     // changeset
 
     fun serializeChangeSet(changeset: ChangeSet): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.serializeChangeSet(changeset))
+        return UseCaseResult("done", xmlSerializerService.serializeChangeSet(changeset))
     }
 
     fun deserializeChangeSet(changeset: String): UseCaseResult<ChangeSet> {
-        return UseCaseResult("done",xmlSerializerService.deserializeChangeSet(changeset))
+        return UseCaseResult("done", xmlSerializerService.deserializeChangeSet(changeset))
     }
 
     fun prettyChangeSet(changeset: ChangeSet): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.prettyChangeSet(changeset))
+        return UseCaseResult("done", xmlSerializerService.prettyChangeSet(changeset))
     }
 
     // trasnfomer
 
     fun serializeTransformer(transformer: Transformer): UseCaseResult<String> {
-        return UseCaseResult("done",xmlSerializerService.serializeTransfomer(transformer))
+        return UseCaseResult("done", xmlSerializerService.serializeTransfomer(transformer))
     }
 
     fun deserializeTransformer(transformerXml: String): UseCaseResult<Transformer> {
-        return UseCaseResult("done",xmlSerializerService.deserializeTransformer(transformerXml))
+        return UseCaseResult("done", xmlSerializerService.deserializeTransformer(transformerXml))
     }
 
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/common/XSLTrasformUseCase.kt

 package unibz.cs.semint.kprime.usecase.common
 
-import unibz.cs.semint.kprime.domain.UseCaseResult
+import unibz.cs.semint.kprime.usecase.UseCaseResult
 import unibz.cs.semint.kprime.usecase.service.IXSLTransformerService
 
 class XSLTrasformUseCase (val transformer:IXSLTransformerService){
 
-    fun transform(xsl: String, xml: String, out: String):UseCaseResult<Unit> {
-        return UseCaseResult("done",transformer.trasform(xsl,xml,out))
+    fun transform(xsl: String, xml: String, out: String): UseCaseResult<Unit> {
+        return UseCaseResult("done", transformer.trasform(xsl, xml, out))
     }
 }
\ No newline at end of file

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

 package unibz.cs.semint.kprime.usecase.current
 
 import unibz.cs.semint.kprime.adapter.service.XMLSerializerJacksonAdapter
-import unibz.cs.semint.kprime.domain.*
 import unibz.cs.semint.kprime.domain.ddl.Column
 import unibz.cs.semint.kprime.domain.ddl.Constraint
 import unibz.cs.semint.kprime.domain.ddl.Database
 import unibz.cs.semint.kprime.domain.ddl.Table
+import unibz.cs.semint.kprime.usecase.UseCaseResult
 import unibz.cs.semint.kprime.usecase.common.SQLizeUseCase
 import unibz.cs.semint.kprime.usecase.common.XMLSerializeUseCase
 
@@ -45,10 +45,10 @@ class HSplitUseCase {
                 dbDetected.schema.tables.add(table)
             }
         }
-        return UseCaseResult("done detect",dbDetected)
+        return UseCaseResult("done detect", dbDetected)
     }
 
-    private fun apply(personMetadata: Database, detected: UseCaseResult<Database>): UseCaseResult<Database>{
+    private fun apply(personMetadata: Database, detected: UseCaseResult<Database>): UseCaseResult<Database> {
         // pure person
         val table = Table()
         table.name= "pure_person"

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

@@ -43,7 +43,10 @@ class OptimusUseCaseTI {
                 .addFunctionals("film","film_id --> replacement_cost, rental_duration, rental_rate")
 
         val params = mapOf(
-                "workingDir" to ""
+                "workingDir" to "/home/nipe/Temp/",
+                "originTable" to "film",
+                "targetTable1" to "film_core",
+                "targetTable2" to "film_rental"
         )
 
         // when