v0.0.5: db update, API customer_information

introducing AOP

src/main/kotlin/com/aitrainer/api/controller/ApplicationProperties.kt

@@ -0,0 +1,45 @@
+package com.aitrainer.api.controller
+
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping()
+class ApplicationProperties {
+
+    @Value("\${application.version}")
+    private lateinit var version: String
+
+    @Value("\${spring.datasource.url}")
+    private lateinit var datasourceUrl: String
+
+    @Value("\${spring.datasource.username}")
+    private lateinit var datasourceUsername: String
+
+    @Value("\${spring.datasource.password}")
+    private lateinit var datasourcePassword: String
+
+
+
+    @GetMapping("/version")
+    fun getVersion(): String {
+        return this.version
+    }
+
+    @GetMapping("/datasourceUrl")
+    fun getDatasourceUrl(): String {
+        return this.datasourceUrl
+    }
+
+    @GetMapping("/datasourceUsername")
+    fun getDatasourceUsername(): String {
+        return this.datasourceUsername
+    }
+
+    @GetMapping("/datasourcePassword")
+    fun getDatasourcePassword(): String {
+        return this.datasourcePassword
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/ConfigurationController.kt

@@ -0,0 +1,27 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.model.Configuration
+
+import com.aitrainer.api.repository.ConfigurationRepository
+import org.springframework.web.bind.annotation.RestController
+import java.time.LocalDateTime
+
+@RestController
+class ConfigurationController ( private val configurationRepository: ConfigurationRepository) {
+
+    fun getConfiguration(key: String): Configuration =
+            configurationRepository.findByConfigKey(key)
+
+    fun updateConfiguration( newConfiguration: Configuration): Configuration {
+        val existingConfiguration: Configuration = configurationRepository.findByConfigKey(newConfiguration.configKey)
+            val updatedConfiguration: Configuration = existingConfiguration.copy(
+                    configKey = newConfiguration.configKey,
+                    configValue = newConfiguration.configValue,
+                    //dateAdd = newConfiguration.dateAdd,
+                    dateChange = LocalDateTime.now().toString())
+
+            configurationRepository.save(updatedConfiguration)
+        return existingConfiguration
+    }
+
+}

src/main/kotlin/com/aitrainer/api/controller/CustomerControllerAspect.kt

@@ -0,0 +1,34 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.ApiApplication
+import com.aitrainer.api.repository.ConfigurationRepository
+import org.aspectj.lang.annotation.Around
+import org.aspectj.lang.annotation.Aspect
+import org.aspectj.lang.annotation.Before
+import org.aspectj.lang.annotation.Pointcut
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.stereotype.Component
+
+
+@Suppress("unused")
+@Aspect
+@Component
+class CustomerControllerAspect {
+    private val logger = LoggerFactory.getLogger(ApiApplication::class.simpleName)
+
+    @Autowired
+    private lateinit var configurationRepository: ConfigurationRepository
+    @Autowired
+    private lateinit var properties: ApplicationProperties
+
+    @Suppress("unused")
+    @Pointcut("execution(* com.aitrainer.api.controller.CustomerController.*())")
+    fun customerControllerAspect() {
+    }
+
+    @Before("customerControllerAspect()")
+    fun loggingAop() {
+        Singleton.checkDBUpdate(configurationRepository, properties)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/CustomerInformationController.kt

@@ -0,0 +1,18 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.model.CustomerInformation
+import com.aitrainer.api.repository.CustomerInformationRepository
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import java.time.LocalDateTime
+
+@RestController
+@RequestMapping("/api")
+class CustomerInformationController( private val customerInformationRepository: CustomerInformationRepository ) {
+
+    @GetMapping("/customer_information")
+    fun getCustomerInformation(dateTime: String): List<CustomerInformation> =
+            customerInformationRepository.findByDisplayBeginLessThanAndDisplayEndGreaterThan(dateTime, dateTime )
+
+}

src/main/kotlin/com/aitrainer/api/controller/DatabaseCheckSingleton.kt

@@ -0,0 +1,105 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.ApiApplication
+import com.aitrainer.api.model.Configuration
+import com.aitrainer.api.repository.ConfigurationRepository
+import org.hibernate.Hibernate.isInitialized
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.web.bind.annotation.RestController
+import java.io.File
+import java.sql.Connection
+import java.sql.DriverManager
+import java.sql.ResultSet
+import java.util.Properties
+
+@RestController
+object Singleton {
+
+    private lateinit var connection: Connection
+    private lateinit var configurationRepository: ConfigurationRepository
+    private lateinit var properties: ApplicationProperties
+
+    private var initialized: Boolean = false
+
+    private val logger = LoggerFactory.getLogger(ApiApplication::class.simpleName)
+
+    // to use the singleton functionality avoiding the db access before each request
+    private var dbVersion: String = ""
+    private var appVersion: String = ""
+
+    fun checkDBUpdate(configurationRepository: ConfigurationRepository, properties: ApplicationProperties) {
+
+        if ( dbVersion.isNotEmpty() && appVersion.isNotEmpty())  {
+            // no db access
+            //println("DB up-to-date, no DB access")
+            return
+        }
+
+        this.configurationRepository = configurationRepository
+        this.properties = properties
+
+        val dbConfig: Configuration = configurationRepository.findByConfigKey("db_version")
+        val applicationVersion: String = properties.getVersion()
+
+        this.dbVersion = dbConfig.configValue
+        this.appVersion = applicationVersion
+
+        if ( dbConfig.configValue != applicationVersion ) {
+
+            try {
+
+
+                val versionNumber: String = applicationVersion.replace(".", "_")
+                val fileName = "update_$versionNumber.sql"
+                val path = "./data/db/"
+                val file2Update = path+fileName
+
+                var sqlRows = ""
+                File(file2Update).forEachLine {
+                    sqlRows += it
+                    if ( sqlRows.contains(";") ) {
+                        execSQL(sqlRows)
+                        sqlRows = ""
+                    }
+                }
+                this.connection.commit()
+                logger.info("Database has been updated to $applicationVersion" )
+            } catch (exception: Exception) {
+                logger.info("Database exception of $applicationVersion: " + exception.message )
+                this.connection.rollback()
+            }
+        }
+
+    }
+
+    fun execSQL( sql: String ) {
+
+        if (! this.initialized ) {
+            this.getConnection()
+        }
+
+        with(this.connection) {
+            createStatement().execute(sql)
+            //commit()
+        }
+    }
+
+    fun execQuery( sql: String ): ResultSet {
+        if (! this.initialized ) {
+            this.getConnection()
+        }
+
+        return connection.createStatement().executeQuery(sql)
+    }
+
+    private fun  getConnection(): Connection {
+        val connectionProps = Properties()
+        connectionProps["user"] = this.properties.getDatasourceUsername()
+        connectionProps["password"] = this.properties.getDatasourcePassword()
+        this.connection = DriverManager.getConnection(this.properties.getDatasourceUrl(), connectionProps)
+        this.connection.autoCommit = false
+        this.initialized = true
+        return this.connection
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/ExerciseController.kt

@@ -8,7 +8,7 @@ import javax.validation.Valid
 
 @RestController
 @RequestMapping("/api")
-class ExerciesController(private val exercisesRepository: ExercisesRepository) {
+class ExerciseController(private val exercisesRepository: ExercisesRepository) {
 
     @GetMapping("/exercises/{id}")
     fun getExerciseById(@PathVariable(value = "id") exerciseId: Long): ResponseEntity<Exercises> {
@@ -33,7 +33,7 @@ class ExerciesController(private val exercisesRepository: ExercisesRepository) {
             val updatedExercises: Exercises = existingExercises.copy(
                     exerciseTypeId = newExercises.exerciseTypeId,
                     customerId = newExercises.customerId,
-                    datetimeExercise = newExercises.datetimeExercise,
+                    dateAdd = newExercises.dateAdd,
                     quantity = newExercises.quantity,
                     restTime = newExercises.restTime
             )

src/main/kotlin/com/aitrainer/api/controller/ExerciseControllerAspect.kt

@@ -0,0 +1,35 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.ApiApplication
+import com.aitrainer.api.repository.ConfigurationRepository
+import org.aspectj.lang.annotation.Aspect
+import org.aspectj.lang.annotation.Before
+import org.aspectj.lang.annotation.Pointcut
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.stereotype.Component
+
+@Component
+@Suppress("unused")
+@Aspect
+class ExerciseControllerAspect {
+
+    private val logger = LoggerFactory.getLogger(ApiApplication::class.simpleName)
+
+    @Autowired
+    private lateinit var configurationRepository: ConfigurationRepository
+    @Autowired
+    private lateinit var properties: ApplicationProperties
+
+    @Suppress("unused")
+    @Pointcut("execution(* com.aitrainer.api.controller.ExerciseController.*())")
+    fun exerciseControllerAspect() {
+    }
+
+    @Before("exerciseControllerAspect()")
+    fun loggingAop() {
+        Singleton.checkDBUpdate(configurationRepository, properties)
+    }
+
+
+}

src/main/kotlin/com/aitrainer/api/controller/ExerciseTypeControllerAspect.kt

@@ -0,0 +1,34 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.ApiApplication
+import com.aitrainer.api.repository.ConfigurationRepository
+import org.aspectj.lang.annotation.Around
+import org.aspectj.lang.annotation.Aspect
+import org.aspectj.lang.annotation.Before
+import org.aspectj.lang.annotation.Pointcut
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.stereotype.Component
+
+@Suppress("unused")
+@Aspect
+@Component
+class ExerciseTypeControllerAspect {
+    private val logger = LoggerFactory.getLogger(ApiApplication::class.simpleName)
+
+    @Autowired
+    private lateinit var configurationRepository: ConfigurationRepository
+    @Autowired
+    private lateinit var properties: ApplicationProperties
+
+    @Suppress("unused")
+    @Pointcut("execution(* com.aitrainer.api.controller.ExerciseTypeController.*())")
+    fun exerciseTypeControllerAspect() {
+    }
+
+    @Before("exerciseTypeControllerAspect()")
+    fun loggingAop() {
+        Singleton.checkDBUpdate(configurationRepository, properties)
+    }
+
+}