Merge branch 'master' of https://github.com/eugeis/ee

ee-design/src/main/kotlin/ee/design/DesignUtils.kt

@@ -186,7 +186,7 @@ fun EntityI<*>.hasNoEvents() = events().isEmpty() && created().isEmpty() && upda
 fun EntityI<*>.hasNoCommands() =
     commands().isEmpty() && createBys().isEmpty() && updateBys().isEmpty() && deleteBys().isEmpty()
 
-fun StructureUnitI<*>.renameControllersAccordingParentType() {
+fun StructureUnitI<*>.renameArtifactsAccordingParentType() {
     findDownByType(ControllerI::class.java).forEach { item ->
         item.extendAdapt {
             val parent = findParent(CompilationUnitI::class.java)
@@ -255,7 +255,7 @@ fun StructureUnitI<*>.addDefaultReturnValuesForQueries() {
 }
 
 fun StructureUnitI<*>.addCommandsAndEventsForAggregates() {
-    findDownByType(EntityI::class.java).filter { !it.isVirtual() }.extend {
+    findDownByType(EntityI::class.java).filter { it.isAggregate() }.extend {
 
         if (isDefaultCommands()) {
             commandCreate()
@@ -366,7 +366,8 @@ fun StructureUnitI<*>.addAggregateHandler() {
     findDownByType(EntityI::class.java).filter { !it.isVirtual() && it.handlers().isEmpty() }.extend {
         handler {
             name("Handler")
-            val initial = state { name("initial") }
+            val initial = state { name("Initial") }
+            defaultState(initial)
         }
     }
 }
@@ -475,6 +476,10 @@ fun <T : CompilationUnitI<*>> T.propagateItemToSubtypes(item: CompilationUnitI<*
 
 const val PROP_DELETED_AT = "deletedAt"
 
+fun EntityI<*>.isAggregate(): Boolean {
+    return !isVirtual() && belongsToAggregate().isEMPTY() && derivedAsType().isEmpty()
+}
+
 fun EntityI<*>.addPropDeletedAt(): AttributeI<*> {
     return prop {
         key(true).type(n.Date).name(PROP_DELETED_AT)

ee-design/src/main/kotlin/ee/design/gen/angular/DesignAngularGenerator.kt

@@ -1,20 +1,24 @@
 package ee.design.gen.angular
 
-import ee.design.gen.DesignGeneratorFactory
-import ee.lang.StructureUnitI
-import ee.lang.gen.ts.prepareForTsGeneration
+import ee.design.*
+import ee.design.gen.ts.DesignTsContextFactory
+import ee.design.gen.ts.DesignTsTemplates
+import ee.design.gen.ts.DesignTypeScriptGenerator
+import ee.lang.*
+import ee.lang.gen.ts.*
 import java.nio.file.Path
 
 open class DesignAngularGenerator(val model: StructureUnitI<*>) {
 
-    fun generate(target: Path) {
+    companion object {
+        fun buildTsContextFactoryAngular() = DesignTsContextFactory(false)
+    }
 
-        val generatorFactory = DesignGeneratorFactory()
-        model.prepareForTsGeneration()
+    fun generate(target: Path) {
 
-        val generatorApiBase = generatorFactory.typeScriptApiBase("", model).generator
-        val generatorAngular = generatorFactory.angular("", model).generator
-        val generatorAngularTranslate = generatorFactory.angularTranslate("", model).generator
+        val generatorApiBase = DesignTypeScriptGenerator(model).typeScriptApiBase("", model).generator
+        val generatorAngular = angular("", model).generator
+        val generatorAngularTranslate = angularTranslate("", model).generator
 
         /*val generatorContextsComponent = generatorFactory.angularTypeScriptComponent("", model)
         val generatorComponent = generatorContextsComponent.generator
@@ -40,4 +44,227 @@ open class DesignAngularGenerator(val model: StructureUnitI<*>) {
         generatorModule.generate(target, model)
         generatorHtmlAndScss.generate(target, model)*/
     }
+
+    open fun angular(fileNamePrefix: String = "", model: StructureUnitI<*>): GeneratorContexts<StructureUnitI<*>> {
+        val angularTemplates = DesignAngularTemplates(itemNameAsTsFileName)
+        val tsTemplates = DesignTsTemplates(itemNameAsTsFileName)
+        val tsContextFactory = buildTsContextFactoryAngular()
+
+        val components: StructureUnitI<*>.() -> List<CompI<*>> = {
+            if (this is CompI<*>) listOf(this) else findDownByType(CompI::class.java)
+        }
+        val modules: StructureUnitI<*>.() -> List<ModuleI<*>> = {
+            if (this is ModuleI<*>) listOf(this) else findDownByType(ModuleI::class.java)
+        }
+
+        val commands: StructureUnitI<*>.() -> List<CommandI<*>> = { findDownByType(CommandI::class.java) }
+        val commandEnums: StructureUnitI<*>.() -> List<EnumTypeI<*>> = {
+            findDownByType(EnumTypeI::class.java).filter {
+                it.parent() is ControllerI<*> && it.name().endsWith("CommandType")
+            }
+        }
+
+        val events: StructureUnitI<*>.() -> List<EventI<*>> = { findDownByType(EventI::class.java) }
+        val eventEnums: StructureUnitI<*>.() -> List<EnumTypeI<*>> = {
+            findDownByType(EnumTypeI::class.java).filter {
+                it.parent() is ControllerI<*> && it.name().endsWith("EventType")
+            }
+        }
+
+        val enums: StructureUnitI<*>.() -> List<EnumTypeI<*>> = {
+            findDownByType(EnumTypeI::class.java).filter {
+                it.parent() is StructureUnitI<*> && it.derivedAsType().isEmpty()
+            }.sortedBy { it.name() }
+        }
+
+        val values: StructureUnitI<*>.() -> List<ValuesI<*>> = {
+            findDownByType(ValuesI::class.java).filter { it.derivedAsType().isEmpty() }
+                .sortedBy { "${it.javaClass.simpleName} ${name()}" }
+        }
+
+        val basics: StructureUnitI<*>.() -> List<BasicI<*>> = {
+            findDownByType(BasicI::class.java).filter { it.derivedAsType().isEmpty() }
+                .sortedBy { "${it.javaClass.simpleName} ${name()}" }
+        }
+
+        val entities: StructureUnitI<*>.() -> List<EntityI<*>> = {
+            findDownByType(EntityI::class.java).filter { it.derivedAsType().isEmpty() }
+                .sortedBy { "${it.javaClass.simpleName} ${name()}" }
+        }
+
+        val aggregateEntities: StructureUnitI<*>.() -> List<EntityI<*>> = {
+            findDownByType(EntityI::class.java).filter {
+                it.belongsToAggregate().derivedAsType().isEmpty() && it.belongsToAggregate().isNotEMPTY() }
+                .sortedBy { "${it.belongsToAggregate().javaClass.simpleName} ${name()}" }.map { it.belongsToAggregate() }
+        }
+
+        val moduleGenerators = mutableListOf<GeneratorI<StructureUnitI<*>>>()
+        val generator = GeneratorGroup(
+            "Angular",
+            listOf(GeneratorGroupItems("AngularModules", items = modules, generators = moduleGenerators))
+        )
+
+        // View Component for Modules
+        val moduleViewComponentContextBuilder = tsContextFactory.buildForImplOnly("/components/view")
+        moduleGenerators.add(
+            GeneratorItems("AngularModuleViewComponent",
+            contextBuilder = moduleViewComponentContextBuilder, items = modules,
+
+            templates = {
+                listOf(
+                    tsTemplates.moduleTypeScript(angularModuleViewComponent.ts),
+                    angularTemplates.moduleHTML(angularModuleViewComponent.html),
+                    angularTemplates.moduleSCSS(angularModuleViewComponent.scss),
+                ) })
+        )
+
+        // Module & Routing Component for Modules
+        val moduleModulesContextBuilder = tsContextFactory.buildForImplOnly()
+        moduleGenerators.add(
+            GeneratorItems("AngularModules",
+            contextBuilder = moduleModulesContextBuilder, items = modules,
+
+            templates = {
+                listOf(
+                    angularTemplates.angularModule(angularModule.ts, components.invoke(model)),
+                    angularTemplates.angularRoutingModule(angularRoutingModule.ts),
+                ) })
+        )
+
+        // Module Service
+        val moduleServiceContextBuilder = tsContextFactory.buildForImplOnly("/service")
+        moduleGenerators.add(
+            GeneratorItems("AngularModulesService",
+            contextBuilder = moduleServiceContextBuilder, items = modules,
+
+            templates = {
+                listOf(
+                    tsTemplates.moduleService(modules.invoke(model), angularModuleService.ts)
+                ) })
+        )
+
+        // View, List, Form, Service Components for Entities
+        val entityComponentContextBuilder = tsContextFactory.buildForImplOnly()
+        moduleGenerators.add(
+            GeneratorItems("AngularEntityComponent",
+            contextBuilder = entityComponentContextBuilder, items = entities,
+
+            templates = {
+                listOf(
+                    tsTemplates.entityViewTypeScript(angularEntityViewComponent.ts),
+                    angularTemplates.entityViewHTML(entities.invoke(model), angularEntityViewComponent.html),
+                    angularTemplates.entityViewSCSS(angularEntityViewComponent.scss),
+
+                    tsTemplates.entityFormTypeScript(angularEntityFormComponent.ts),
+                    angularTemplates.entityFormHTML(angularEntityFormComponent.html),
+                    angularTemplates.entityFormSCSS(angularEntityFormComponent.scss),
+
+                    tsTemplates.entityListTypeScript(angularEntityListComponent.ts),
+                    angularTemplates.entityListHTML(angularEntityListComponent.html, aggregateEntities.invoke(model), entities.invoke(model)),
+                    angularTemplates.entityListSCSS(angularEntityListComponent.scss),
+
+                    tsTemplates.entityDataService(entities.invoke(model), angularEntityService.ts)
+                ) })
+        )
+
+        // View, List, Form Components for Aggregate Entity
+        val aggregateEntityComponentContextBuilder = tsContextFactory.buildForImplOnly()
+        moduleGenerators.add(
+            GeneratorItems("AngularAggregateEntityComponent",
+            contextBuilder = aggregateEntityComponentContextBuilder, items = aggregateEntities,
+
+            templates = {
+                listOf(
+                    tsTemplates.entityAggregateViewTypeScript(angularAggregateEntityComponent.ts),
+                    angularTemplates.entityAggregateViewHTML(angularAggregateEntityComponent.html),
+                    angularTemplates.entityAggregateViewSCSS(angularAggregateEntityComponent.scss),
+                ) })
+        )
+
+        // View, List, Form, Service Components for Values
+        val valuesComponentContextBuilder = tsContextFactory.buildForImplOnly()
+        moduleGenerators.add(
+            GeneratorItems("AngularValuesComponent",
+            contextBuilder = valuesComponentContextBuilder, items = values,
+
+            templates = {
+                listOf(
+                    tsTemplates.valueViewTypeScript(angularEntityViewComponent.ts),
+                    angularTemplates.entityViewHTML(entities.invoke(model), angularEntityViewComponent.html),
+                    angularTemplates.entityViewSCSS(angularEntityViewComponent.scss),
+
+                    tsTemplates.valueFormTypeScript(angularEntityFormComponent.ts),
+                    angularTemplates.entityFormHTML(angularEntityFormComponent.html),
+                    angularTemplates.entityFormSCSS(angularEntityFormComponent.scss),
+
+                    tsTemplates.valueListTypeScript(angularEntityListComponent.ts),
+                    angularTemplates.entityListHTML(angularEntityListComponent.html, aggregateEntities.invoke(model), entities.invoke(model)),
+                    angularTemplates.entityListSCSS(angularEntityListComponent.scss),
+
+                    tsTemplates.entityDataService(entities.invoke(model), angularEntityService.ts)
+                ) })
+        )
+
+        // Basics Components
+        val basicsContextBuilder = tsContextFactory.buildForImplOnly("/basics")
+        moduleGenerators.add(
+            GeneratorItems("AngularBasics",
+            contextBuilder = basicsContextBuilder, items = basics,
+
+            templates = {
+                listOf(
+                    tsTemplates.basicTypeScript(angularBasicComponent.ts),
+                    angularTemplates.basicHTML(angularBasicComponent.html),
+                    angularTemplates.basicSCSS(angularBasicComponent.scss),
+                ) })
+        )
+
+        // Enums Components
+        val enumsContextBuilder = tsContextFactory.buildForImplOnly("/enums")
+        moduleGenerators.add(
+            GeneratorItems("AngularEnums",
+            contextBuilder = enumsContextBuilder, items = enums,
+
+            templates = {
+                listOf(
+                    tsTemplates.enumTypeScript(angularEnumComponent.ts),
+                    angularTemplates.enumHTML(angularEnumComponent.html),
+                    angularTemplates.enumSCSS(angularEnumComponent.scss),
+                ) })
+        )
+
+        return GeneratorContexts(generator, moduleViewComponentContextBuilder, moduleModulesContextBuilder, moduleServiceContextBuilder,
+            entityComponentContextBuilder, aggregateEntityComponentContextBuilder, basicsContextBuilder, enumsContextBuilder,)
+    }
+
+    open fun angularTranslate(fileNamePrefix: String = "", model: StructureUnitI<*>): GeneratorContexts<StructureUnitI<*>> {
+        val tsTemplates = DesignTsTemplates(itemNameAsJsonFileName)
+        val tsContextFactory = buildTsContextFactoryAngular()
+
+        val components: StructureUnitI<*>.() -> List<CompI<*>> = {
+            if (this is CompI<*>) listOf(this) else findDownByType(CompI::class.java)
+        }
+
+        val moduleGenerators = mutableListOf<GeneratorI<StructureUnitI<*>>>()
+        val generator = GeneratorGroup(
+            "AngularTranslate",
+            listOf(GeneratorGroupItems("AngularTranslate", items = components, generators = moduleGenerators))
+        )
+
+        val angularTranslateFileContextFactory = tsContextFactory.buildForImplOnly("/assets/i18n")
+        moduleGenerators.add(
+            GeneratorItems("AngularTranslate",
+            contextBuilder = angularTranslateFileContextFactory, items = components,
+
+            templates = {
+                listOf(
+                    tsTemplates.translateJson(english.json),
+                    tsTemplates.translateJson(germany.json),
+                    tsTemplates.translateJson(france.json),
+                    tsTemplates.translateJson(spain.json),
+                ) })
+        )
+
+        return GeneratorContexts(generator, angularTranslateFileContextFactory)
+    }
 }

ee-design/src/main/kotlin/ee/design/gen/angular/DesignAngularPojos.kt

@@ -301,7 +301,7 @@ a {
 """
 }
 
-fun <T : CompilationUnitI<*>> T.toAngularEntityListHTMLComponent(c: GenerationContext, DataService: String = AngularDerivedType.DataService, isAggregateView: Boolean = false, containAggregateProp: Boolean = false, entities: List<EntityI<*>>): String {
+fun <T : CompilationUnitI<*>> T.toAngularEntityListHTMLComponent(c: GenerationContext, DataService: String = AngularDerivedType.DataService, isAggregateView: Boolean = false, containAggregateProp: Boolean = false, entities: List<EntityI<*>> = emptyList()): String {
     val serviceName = if(this.parent().name().equals(this.name(), true)) {this.parent().name().toCamelCase()
             .replaceFirstChar { it.lowercase(Locale.getDefault()) }} else {this.parent().name().toCamelCase()
             .replaceFirstChar { it.lowercase(Locale.getDefault()) } + this.name().toCamelCase().replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}

ee-design/src/main/kotlin/ee/design/gen/doc/DesignDocGenerator.kt

@@ -1,20 +1,57 @@
 package ee.design.gen.doc
 
-import ee.design.gen.DesignGeneratorFactory
-import ee.lang.StructureUnitI
+import ee.design.CompI
+import ee.lang.*
+import ee.lang.gen.doc.markdownClassDiagram
 import ee.lang.gen.doc.prepareForMarkdownGeneration
+import ee.lang.gen.ts.itemNameAsTsFileName
 import java.nio.file.Path
 
-open class DesignDocGenerator(val model: StructureUnitI<*>) {
+open class DesignDocGenerator(val model: StructureUnitI<*>, private val targetAsSingleModule: Boolean = true) {
+
+    fun buildDocContextFactory() = DesignDocContextFactory(targetAsSingleModule)
+    fun buildDocTemplates() = DesignDocTemplates(itemNameAsTsFileName)
 
     fun generate(target: Path) {
 
-        val generatorFactory = DesignGeneratorFactory()
         model.prepareForMarkdownGeneration()
 
-        val generatorClassDiagram = generatorFactory.docMarkDown("", model).generator
+        val generatorClassDiagram = docMarkDown("", model).generator
 
         generatorClassDiagram.delete(target, model)
         generatorClassDiagram.generate(target, model)
     }
+
+
+    open fun docMarkDown(fileNamePrefix: String = "", model: StructureUnitI<*>): GeneratorContexts<StructureUnitI<*>> {
+        val docTemplates = buildDocTemplates()
+        val docContextFactory = buildDocContextFactory()
+
+        val components: StructureUnitI<*>.() -> List<CompI<*>> = {
+            if (this is CompI<*>) listOf(this) else findDownByType(CompI::class.java)
+        }
+
+        val compilationUnit: StructureUnitI<*>.() -> List<CompilationUnitI<*>> = {
+            if (this is CompilationUnitI<*>) listOf(this) else findDownByType(CompilationUnitI::class.java)
+        }
+
+        val moduleGenerators = mutableListOf<GeneratorI<StructureUnitI<*>>>()
+        val generator = GeneratorGroup(
+            "doc",
+            listOf(GeneratorGroupItems("doc", items = components, generators = moduleGenerators))
+        )
+
+        val docContextBuilder = docContextFactory.buildForImplOnly("")
+        moduleGenerators.add(
+            GeneratorItems("PlantUmlClassDiagram",
+            contextBuilder = docContextBuilder, items = components,
+
+            templates = {
+                listOf(
+                    docTemplates.generatePlantUmlClassDiagramComponent(markdownClassDiagram.puml)
+                ) })
+        )
+
+        return GeneratorContexts(generator, docContextBuilder)
+    }
 }