API 1.0.24 ExerciseAbility, AppPackage, AppCustomerPackage, Tracking

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

@@ -0,0 +1,72 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.model.*
+import com.aitrainer.api.repository.*
+import com.google.gson.GsonBuilder
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api")
+class CustomerPackageController( private val customerRepository: CustomerRepository,
+                                 private val customerExerciseDeviceRepository: CustomerExerciseDeviceRepository,
+                                 private val exercisesRepository: ExercisesRepository,
+                                 private val productTestRepository: ProductTestRepository,
+                                 private val purchaseRepository: PurchaseRepository,
+                                 private val customerPropertyRepository: CustomerPropertyRepository,
+                                 private val exerciseResultRepository: ExerciseResultRepository) {
+
+    @GetMapping("/app_customer_package/{id}")
+    fun getCustomerPackageData(@PathVariable(value = "id") customerId: Long): ResponseEntity<String> {
+
+        if (customerId <= 0) {
+            return ResponseEntity.notFound().build()
+        }
+
+        val gson = GsonBuilder()
+            .excludeFieldsWithoutExposeAnnotation()
+            .setPrettyPrinting()
+            .create()
+
+        val customer: Customer = customerRepository.findById(customerId).orElse(null)
+            ?: return ResponseEntity.notFound().build()
+        val customerJson: String = gson.toJson(customer)
+
+        val listCustomerExerciseDevices = customerExerciseDeviceRepository.findByCustomerId(customerId)
+        val listCustomerExerciseDeviceJson = gson.toJson(listCustomerExerciseDevices)
+
+        val listExercises = exercisesRepository.getAllByCustomerIdOrderByDateAddDesc(customerId)
+        val listExercisesJson = gson.toJson(listExercises)
+
+        val listProductTest = productTestRepository.findByCustomerId(customerId)
+        val listProductTestJson = gson.toJson(listProductTest)
+
+        val listPurchase = purchaseRepository.findByCustomerId(customerId)
+        val listPurchaseJson = gson.toJson(listPurchase)
+
+        val listCustomerProperty = customerPropertyRepository.findAllByCustomerId(customerId)
+        val listCustomerPropertyJson = gson.toJson(listCustomerProperty)
+
+        val listExerciseResult = exerciseResultRepository.getAllByCustomerId(customerId)
+        val listExerciseResultJson = gson.toJson(listExerciseResult)
+
+        val packageJson: String =
+            getClassRecord(Customer::class.simpleName, customerJson) +
+                    "|||" +  getClassRecord(CustomerExerciseDevice::class.simpleName, listCustomerExerciseDeviceJson) +
+                    "|||" +  getClassRecord(Exercises::class.simpleName, listExercisesJson) +
+                    "|||" +  getClassRecord(ProductTest::class.simpleName, listProductTestJson) +
+                    "|||" +  getClassRecord(Purchase::class.simpleName, listPurchaseJson) +
+                    "|||" +  getClassRecord(CustomerProperty::class.simpleName, listCustomerPropertyJson) +
+                    "|||" +  getClassRecord(ExerciseResult::class.simpleName, listExerciseResultJson)
+
+                    return if (packageJson.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(packageJson)
+    }
+
+    fun getClassRecord(className: String?, json: String): String {
+        return "$className***$json"
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.model.ExerciseAbility
+import com.aitrainer.api.model.ExerciseDevice
+import com.aitrainer.api.repository.ExerciseAbilityRepository
+import com.aitrainer.api.repository.ExerciseDeviceRepository
+import org.slf4j.LoggerFactory
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api")
+class ExerciseAbilityController(private val exerciseAbilityRepository: ExerciseAbilityRepository) {
+    private val logger = LoggerFactory.getLogger(javaClass)
+
+    @GetMapping("/exercise_ability")
+    fun getAbilities(): ResponseEntity<List<ExerciseAbility>> {
+        val list = exerciseAbilityRepository.findAll()
+
+        logger.info(" -- Get All ExerciseAbility $list")
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

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

@@ -51,8 +51,7 @@ class ExerciseTypeController ( private val exerciseTypeRepository: ExerciseTypeR
         return exerciseTypeRepository.findById(exerciseTypeId).map { existingExerciseType ->
             val updatedExerciseType: ExerciseType = existingExerciseType
                     .copy(name = newExerciseType.name, 
-                        description = newExerciseType.description,
-                        treeId = newExerciseType.treeId)
+                        description = newExerciseType.description)
             ResponseEntity.ok().body(exerciseTypeRepository.save(updatedExerciseType))
         }.orElse(ResponseEntity.notFound().build())
 

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

@@ -0,0 +1,71 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.model.*
+import com.aitrainer.api.repository.*
+import org.slf4j.LoggerFactory
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import com.google.gson.GsonBuilder
+
+
+@RestController
+@RequestMapping("/api")
+class PackageController(private val exerciseAbilityRepository: ExerciseAbilityRepository,
+                        private val exerciseTypeRepository: ExerciseTypeRepository,
+                        private val exerciseTreeRepository: ExerciseTreeRepository,
+                        private val propertyRepository: PropertyRepository,
+                        private val productRepository: ProductRepository,
+                        private val exerciseDeviceRepository: ExerciseDeviceRepository,
+                        private val exerciseTreeParentsRepository: ExerciseTreeParentsRepository
+) {
+    private val logger = LoggerFactory.getLogger(javaClass)
+
+    @GetMapping("/app_package")
+    fun getPackageData(): ResponseEntity<String> {
+
+        val gson = GsonBuilder()
+            .excludeFieldsWithoutExposeAnnotation()
+            .setPrettyPrinting()
+            .create()
+
+        val listDevices: List<ExerciseDevice> = exerciseDeviceRepository.getExerciseDevices()
+        val listDevicesJson: String = gson.toJson(listDevices)
+
+        val listProducts = productRepository.findAll()
+        val listProductsJson: String = gson.toJson(listProducts)
+
+        val listProperty:List<Property> = propertyRepository.getProperties()
+        val listPropertyJson: String = gson.toJson(listProperty)
+
+        val listExerciseTree = exerciseTreeRepository.getActiveMenu()
+        val listExerciseTreeJson: String = gson.toJson(listExerciseTree)
+
+        val listExerciseType = exerciseTypeRepository.getActiveExerciseTypes()
+        val listExerciseTypeJson = gson.toJson(listExerciseType)
+
+        val listExerciseAbility = exerciseAbilityRepository.findAll()
+        val listExerciseAbilityJson: String = gson.toJson(listExerciseAbility)
+
+        val listExerciseTreeParents = exerciseTreeParentsRepository.findAll()
+        val listExerciseTreeParentsJson: String = gson.toJson(listExerciseTreeParents)
+
+
+        val packageJson: String =
+                    getClassRecord(ExerciseDevice::class.simpleName, listDevicesJson) +
+           "|||" +  getClassRecord(Product::class.simpleName, listProductsJson) +
+           "|||" +  getClassRecord(Property::class.simpleName, listPropertyJson) +
+           "|||" +  getClassRecord(ExerciseTree::class.simpleName, listExerciseTreeJson) +
+           "|||" +  getClassRecord(ExerciseType::class.simpleName, listExerciseTypeJson) +
+           "|||" +  getClassRecord(ExerciseAbility::class.simpleName, listExerciseAbilityJson) +
+           "|||" +  getClassRecord(ExerciseTreeParents::class.simpleName, listExerciseTreeParentsJson)
+
+        return if (packageJson.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(packageJson)
+    }
+
+    fun getClassRecord(className: String?, json: String): String {
+        return "$className***$json"
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.model.Tracking
+import com.aitrainer.api.repository.TrackingRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import javax.validation.Valid
+
+@RestController
+@RequestMapping("/api")
+class TrackingController(private val trackingRepository: TrackingRepository) {
+
+    @PostMapping("/tracking")
+    fun createNewTracking(@Valid @RequestBody tracking: Tracking): ResponseEntity<Tracking> {
+        return ResponseEntity.ok().body(trackingRepository.save(tracking))
+    }
+
+}