API 1.2 Diet tables, Open AI API

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

@@ -1,12 +1,14 @@
 package com.aitrainer.api.controller
 
 import org.springframework.beans.factory.annotation.Value
+import org.springframework.stereotype.Component
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
 
 @RestController
 @RequestMapping
+@Component
 class ApplicationProperties {
 
     @Value("\${application.version}")
@@ -21,7 +23,8 @@ class ApplicationProperties {
     @Value("\${spring.datasource.password}")
     private lateinit var datasourcePassword: String
 
-
+    @Value("\${openai.key}")
+    private lateinit var apiKey: String
 
     @GetMapping("/version")
     fun getVersion(): String {
@@ -42,4 +45,11 @@ class ApplicationProperties {
     fun getDatasourcePassword(): String {
         return this.datasourcePassword
     }
+
+    @GetMapping("/openAIKey")
+    fun getOpenAIKey(): String {
+        return this.apiKey
+    }
+
+
 }

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

@@ -12,13 +12,9 @@ import org.springframework.http.HttpHeaders
 import org.springframework.http.ResponseEntity
 import org.springframework.security.access.annotation.Secured
 import org.springframework.web.bind.annotation.*
-import java.io.ByteArrayOutputStream
-import java.nio.charset.StandardCharsets.UTF_8
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
 import java.util.*
-import java.util.zip.GZIPInputStream
-import java.util.zip.GZIPOutputStream
 import javax.validation.Valid
 
 
@@ -159,15 +155,6 @@ class CustomerController ( private val customerRepository: CustomerRepository) {
     @PostMapping("/club_registration")
     fun clubRegistration(@Valid @RequestBody json: String): ResponseEntity<*> {
 
-        fun gzip(content: String): String {
-            val bos = ByteArrayOutputStream()
-            GZIPOutputStream(bos).bufferedWriter(UTF_8).use { it.write(content) }
-            return bos.toByteArray().toString()
-        }
-
-        fun unzip(content: ByteArray): String =
-            GZIPInputStream(content.inputStream()).bufferedReader(UTF_8).use { it.readText() }
-
         val newUser: ClubUser = ClubUser().fromJson(json)
 
         if ( newUser.email.isEmpty()) {
@@ -252,7 +239,7 @@ class CustomerController ( private val customerRepository: CustomerRepository) {
         if ( emailTemplateService == null ) {
             emailTemplateService = EmailTemplateService()
         }
-        val html = emailTemplateService!!.getEmailBody(newUser.firstname, activationLink)
+        val html = emailTemplateService!!.getEmailBody(newUser.firstname, activationLink, "registration_email")
         val subject = emailTemplateService!!.getSubject()
 
         // send email

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

@@ -0,0 +1,25 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.model.CustomerConversation
+import com.aitrainer.api.repository.CustomerConversationRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+
+
+@RestController
+@RequestMapping("/api")
+class CustomerConversationController (private val customerConversationRepository: CustomerConversationRepository
+) {
+
+    @PostMapping("/customer_conversation")
+    fun insert(@RequestBody customerConversation: CustomerConversation): ResponseEntity<CustomerConversation> {
+        return ResponseEntity.ok().body(customerConversationRepository.save(customerConversation))
+    }
+
+    @GetMapping("/customer_conversation/{customerId}")
+    fun getByCustomerId(@PathVariable customerId: Long): ResponseEntity<List<CustomerConversation>> {
+        val list =  customerConversationRepository.findByCustomerId(customerId)
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

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

@@ -2,7 +2,9 @@ package com.aitrainer.api.controller
 
 import com.aitrainer.api.model.*
 import com.aitrainer.api.model.CustomerMembership
+import com.aitrainer.api.model.diet.*
 import com.aitrainer.api.repository.*
+import com.aitrainer.api.repository.diet.*
 import com.google.gson.GsonBuilder
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
@@ -21,8 +23,73 @@ class CustomerPackageController( private val customerRepository: CustomerReposit
                                  private val customerActivityRepository: CustomerActivityRepository,
                                  private val customerTrainingPlanRepository: CustomerTrainingPlanRepository,
                                  private val customerMembership: CustomerMembershipRepository,
+                                    private val dietRepository: DietRepository,
+                                    private val dietRawMaterialRepository: DietRawMaterialRepository,
+                                    private val dietUserConsumptionRepository: DietUserConsumptionRepository,
+                                    private val dietUserRepository: DietUserRepository,
+                                    private val dietUserPreferenceRepository: DietUserPreferenceRepository,
+                                    private val dietUserSensitivityRepository: DietUserSensitivityRepository
+
 ) {
 
+    @GetMapping("/diet_customer_package/{id}")
+    fun getDietCustomerPackageData(@PathVariable(value = "id") dietUserId: Long): ResponseEntity<String> {
+        if (dietUserId <= 0) {
+            return ResponseEntity.notFound().build()
+        }
+
+        val gson = GsonBuilder()
+            .excludeFieldsWithoutExposeAnnotation()
+            .setPrettyPrinting()
+            .create()
+
+        val dietUser: DietUser = dietUserRepository.findByDietUserId(dietUserId)
+            ?: return ResponseEntity.notFound().build()
+
+        val customerId = dietUser.customerId
+        val customer: Customer = customerRepository.findByCustomerIdAndActive(customerId, "Y")
+            ?: return ResponseEntity.notFound().build()
+
+        val customerJson: String = gson.toJson(customer)
+        val dietUserJson: String = gson.toJson(dietUser)
+
+        val listCustomerProperty = customerPropertyRepository.findLastPropertiesByCustomerId(customerId)
+        val listCustomerPropertyJson = gson.toJson(listCustomerProperty)
+
+        val listMembership = customerMembership.findAllByCustomer(customer)
+        val listMembershipJson = gson.toJson(listMembership)
+
+        val listDiet = dietRepository.findByDietUserId(dietUserId)
+        val listDietJson = gson.toJson(listDiet)
+
+        val listDietRawMaterial = dietRawMaterialRepository.findByDietId(dietUserId)
+        val listDietRawMaterialJson = gson.toJson(listDietRawMaterial)
+
+        val listDietUserConsumption = dietUserConsumptionRepository.findByDietUserId(dietUserId)
+        val listDietUserConsumptionJson = gson.toJson(listDietUserConsumption)
+
+        val listDietUserPreference = dietUserPreferenceRepository.findByDietUserId(dietUserId)
+        val listDietUserPreferenceJson = gson.toJson(listDietUserPreference)
+
+        val listDietUserSensitivity = dietUserSensitivityRepository.findByDietUserId(dietUserId)
+        val listDietUserSensitivityJson = gson.toJson(listDietUserSensitivity)
+
+        val packageJson: String =
+            getClassRecord(Customer::class.simpleName, customerJson) +
+                    "|||" +  getClassRecord(DietUser::class.simpleName, dietUserJson)
+                    "|||" +  getClassRecord(CustomerProperty::class.simpleName, listCustomerPropertyJson)
+                    "|||" +  getClassRecord(CustomerMembership::class.simpleName, listMembershipJson)
+                    "|||" +  getClassRecord(Diet::class.simpleName, listDietJson)
+                    "|||" +  getClassRecord(DietRawMaterial::class.simpleName, listDietRawMaterialJson)
+                    "|||" +  getClassRecord(DietUserConsumption::class.simpleName, listDietUserConsumptionJson)
+                    "|||" +  getClassRecord(DietUserPreference::class.simpleName, listDietUserPreferenceJson)
+                    "|||" +  getClassRecord(DietUserSensitivity::class.simpleName, listDietUserSensitivityJson)
+
+
+        return if (packageJson.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(packageJson)
+    }
+
     @GetMapping("/club_customer_package/{id}")
     fun getCustomerClubPackageData(@PathVariable(value = "id") customerId: Long): ResponseEntity<String> {
         if (customerId <= 0) {

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

@@ -1,10 +1,7 @@
 package com.aitrainer.api.controller
 
 import com.aitrainer.api.model.Evaluation
-import com.aitrainer.api.model.ExerciseTree
 import com.aitrainer.api.repository.EvaluationRepository
-import com.aitrainer.api.repository.ExerciseTreeParentsRepository
-import com.aitrainer.api.repository.ExerciseTreeRepository
 import org.slf4j.LoggerFactory
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping

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

@@ -0,0 +1,30 @@
+package com.aitrainer.api.controller
+
+import com.aitrainer.api.openai.OpenAIService
+import kotlinx.coroutines.*
+import org.slf4j.LoggerFactory
+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 OpenAIController() {
+    private val logger = LoggerFactory.getLogger(javaClass)
+
+    @OptIn(DelicateCoroutinesApi::class)
+    @GetMapping("/openai/completion")
+    fun getOpenAIResponse(question: String) : String {
+        var result = ""
+        val openAIService = OpenAIService()
+        val deferred = GlobalScope.async {
+            openAIService.completion(question)
+        }
+        runBlocking {
+            result = deferred.await()
+            //println("Result: $result" )
+        }
+        return result
+    }
+}
+

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

@@ -1,7 +1,12 @@
 package com.aitrainer.api.controller
 
 import com.aitrainer.api.model.*
+import com.aitrainer.api.model.diet.DietSensitivity
+import com.aitrainer.api.model.diet.RawMaterial
+import com.aitrainer.api.model.diet.Recipe
+import com.aitrainer.api.model.diet.Store
 import com.aitrainer.api.repository.*
+import com.aitrainer.api.repository.diet.*
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestMapping
@@ -29,9 +34,50 @@ class PackageController(private val exerciseAbilityRepository: ExerciseAbilityRe
                         private val trainingPlanDayRepository: TrainingPlanDayRepository,
                         private val appTextRepository: AppTextRepository,
                         private val trainingProgramRepository: TrainingProgramRepository,
-                        private val membershipRepository: MembershipRepository
+                        private val membershipRepository: MembershipRepository,
+                        private val storeRepository: StoreRepository,
+                        private val recipeRepository: RecipeRepository,
+                        private val rawMaterialRepository: RawMaterialRepository,
+                        private val dietSensitivityRepository: DietSensitivityRepository
 ) {
 
+    @GetMapping("/diet_package")
+    fun getDietPackageData(): ResponseEntity<String> {
+        val gson = GsonBuilder()
+            .excludeFieldsWithoutExposeAnnotation()
+            .setPrettyPrinting()
+            .create()
+
+        val listProperty:List<Property> = propertyRepository.getProperties()
+        val listPropertyJson: String = gson.toJson(listProperty)
+
+        val listMembership = membershipRepository.findAll()
+        val listMembershipJson = gson.toJson(listMembership)
+
+        val listStore = storeRepository.findAll()
+        val listStoreJson = gson.toJson(listStore)
+
+        val listRecipe = recipeRepository.findAll()
+        val listRecipeJson = gson.toJson(listRecipe)
+
+        val listRawMaterial = rawMaterialRepository.findAll()
+        val listRawMaterialJson = gson.toJson(listRawMaterial)
+
+        val listDietSensitivity = dietSensitivityRepository.findAll()
+        val listDietSensitivityJson = gson.toJson(listDietSensitivity)
+
+        val packageJson: String =
+            getClassRecord(Property::class.simpleName, listPropertyJson) +
+                    "|||" +  getClassRecord(Membership::class.simpleName, listMembershipJson) +
+                    "|||" +  getClassRecord(Store::class.simpleName, listStoreJson) +
+                    "|||" +  getClassRecord(Recipe::class.simpleName, listRecipeJson) +
+                    "|||" +  getClassRecord(RawMaterial::class.simpleName, listRawMaterialJson) +
+                    "|||" +  getClassRecord(DietSensitivity::class.simpleName, listDietSensitivityJson)
+
+        return if (packageJson.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(packageJson)
+    }
+
     @GetMapping("/club_package")
     fun getClubPackageData(): ResponseEntity<String> {
 

src/main/kotlin/com/aitrainer/api/controller/diet/DietController.kt

@@ -0,0 +1,24 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.Diet
+import com.aitrainer.api.repository.diet.DietRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import java.util.*
+
+@RestController
+@RequestMapping("/api")
+class DietController(private val dietRepository: DietRepository) {
+
+    @PostMapping("/diet")
+    fun insert(@RequestBody diet: Diet): ResponseEntity<*> {
+        return ResponseEntity.ok().body(dietRepository.save(diet))
+    }
+
+    @GetMapping("/diet/{dietUserId}")
+    fun getByDietUserId(@PathVariable dietUserId: Long): ResponseEntity<List<Diet>> {
+        val list = dietRepository.findByDietUserId(dietUserId)
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/DietCustomerController.kt

@@ -0,0 +1,142 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.Customer
+import com.aitrainer.api.model.CustomerMembership
+import com.aitrainer.api.model.CustomerPropertyProperty
+import com.aitrainer.api.model.diet.DietCustomer
+import com.aitrainer.api.model.diet.DietUser
+import com.aitrainer.api.repository.CustomerRepository
+import com.aitrainer.api.repository.diet.DietUserRepository
+import com.aitrainer.api.service.Email
+import com.aitrainer.api.service.EmailTemplateService
+import com.aitrainer.api.service.Firebase
+import com.aitrainer.api.service.ServiceBeans
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.util.*
+
+@RestController
+@RequestMapping("/api")
+class DietCustomerController(private val dietUserRepository: DietUserRepository, private val customerRepository: CustomerRepository) {
+
+    @Autowired
+    var serviceBeans: ServiceBeans? = null
+
+    @Autowired
+    private var emailTemplateService: EmailTemplateService? = null
+
+    @PostMapping("/diet_registration")
+    fun insert(@RequestBody dietCustomerJson: String): ResponseEntity<*> {
+        val newDietCustomer: DietCustomer = DietCustomer().fromJson(dietCustomerJson)
+
+        if ( newDietCustomer.email.isEmpty()) {
+            return ResponseEntity.badRequest().body("No Email")
+        }
+
+        val current = LocalDateTime.now()
+        val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
+        val nowFormatted = current.format(formatter)
+
+        val stringCharacters = ('0'..'z').toList().toTypedArray()
+        val genPassword = (1..10).map { stringCharacters.random() }.joinToString("")
+
+        val idToken: String?
+
+        var existingCustomer: Customer? = customerRepository.findByEmailAndActive(newDietCustomer.email, "Y")
+
+        if (existingCustomer == null ) {
+            val firebase = Firebase()
+            val signupResponse = firebase.signUp(newDietCustomer.email, genPassword)
+                ?: return ResponseEntity.badRequest().body("Firebase exception ${firebase.error}")
+            idToken = signupResponse.idToken
+
+            val savingCustomer = Customer()
+
+            if ( serviceBeans == null ) {
+                serviceBeans = ServiceBeans()
+            }
+            with (savingCustomer) {
+                email = newDietCustomer.email
+                password = serviceBeans!!.passwordEncoder().encode(genPassword)
+                firebaseRegToken = signupResponse.idToken
+                firebaseUid = signupResponse.localId
+                dateAdd = nowFormatted
+                firstname = newDietCustomer.firstname
+                name = ""
+                goal = newDietCustomer.goal
+                fitnessLevel = newDietCustomer.fitnessLevel
+                birthYear = newDietCustomer.birthYear
+                sex = newDietCustomer.sex
+            }
+
+            val newCustomer = customerRepository.save(savingCustomer)
+
+            if ( newDietCustomer.weight != 0.0 ) {
+                val property = CustomerPropertyProperty()
+                with (property) {
+                    propertyId = 1
+                    propertyValue = newDietCustomer.weight
+                    dateAdd= nowFormatted
+                    goal = false
+                    customer = newCustomer
+                }
+                newCustomer.properties.add(property)
+            }
+            if ( newDietCustomer.height != 0.0 ) {
+                val property = CustomerPropertyProperty()
+                with (property) {
+                    propertyId = 2
+                    propertyValue = newDietCustomer.height
+                    dateAdd = nowFormatted
+                    goal = false
+                    customer = newCustomer
+                }
+                newCustomer.properties.add(property)
+            }
+
+            val newMembershipId = newDietCustomer.membershipId
+            if ( newMembershipId != 0L) {
+                val membership = CustomerMembership()
+                with(membership) {
+                    customer = newCustomer
+                    membershipId = newMembershipId
+                    startDate = nowFormatted
+                }
+                newCustomer.memberships.add(membership)
+            }
+
+            customerRepository.save(newCustomer)
+            existingCustomer = newCustomer
+        } else {
+            val existingDietUser = dietUserRepository.findByCustomerId(existingCustomer.customerId)
+            if ( existingDietUser != null ) {
+                return ResponseEntity.badRequest().body("DietCustomer exists")
+            } else {
+                val newDietUser = DietUser(
+                    customerId = existingCustomer.customerId
+                )
+                dietUserRepository.save(newDietUser)
+
+            }
+            idToken = existingCustomer.firebaseRegToken!!
+        }
+
+        // create email link
+        val activationLink = "https://diet4you.andio.hu/welcome/id=$idToken"
+        if ( emailTemplateService == null ) {
+            emailTemplateService = EmailTemplateService()
+        }
+        val html = emailTemplateService!!.getEmailBody(newDietCustomer.firstname, activationLink, "diet_registration_email")
+        val subject = emailTemplateService!!.getSubjectDiet()
+
+        // send email
+        val email = Email()
+        email.send(newDietCustomer.email, html, subject)
+
+        return ResponseEntity.ok().body(existingCustomer)
+    }
+
+}

src/main/kotlin/com/aitrainer/api/controller/diet/DietRawMaterialController.kt

@@ -0,0 +1,24 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.DietRawMaterial
+import com.aitrainer.api.repository.diet.DietRawMaterialRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import java.util.*
+
+@RestController
+@RequestMapping("/api")
+class DietRawMaterialController(private val dietRawMaterialRepository: DietRawMaterialRepository) {
+
+    @PostMapping("/diet_raw_material")
+    fun insert(@RequestBody dietRawMaterial: DietRawMaterial): ResponseEntity<*> {
+        return ResponseEntity.ok().body(dietRawMaterialRepository.save(dietRawMaterial))
+    }
+
+    @GetMapping("/diet_raw_material/{dietId}")
+    fun getByDietUserId(@PathVariable dietId: Long): ResponseEntity<List<DietRawMaterial>> {
+        val list = dietRawMaterialRepository.findByDietId(dietId)
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/DietSensitivityController.kt

@@ -0,0 +1,24 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.DietSensitivity
+import com.aitrainer.api.repository.diet.DietSensitivityRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("api")
+class DietSensitivityController(private val dietSensitivityRepository: DietSensitivityRepository) {
+
+    @PostMapping ("/diet_sensitivity")
+    fun insert(@RequestBody dietSensitivity: DietSensitivity): ResponseEntity<DietSensitivity> {
+        val newDietSensitivity = dietSensitivityRepository.save(dietSensitivity)
+        return ResponseEntity.ok().body(newDietSensitivity)
+    }
+
+    @GetMapping("/diet_sensitivity")
+    fun getAll(): ResponseEntity<List<DietSensitivity>> {
+        val list = dietSensitivityRepository.findAll()
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/DietUserConsumptionController.kt

@@ -0,0 +1,43 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.DietUserConsumption
+import com.aitrainer.api.repository.diet.DietUserConsumptionRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import java.util.*
+
+@RestController
+@RequestMapping("/api")
+class DietUserConsumptionController(private val dietUserConsumptionRepository: DietUserConsumptionRepository) {
+
+    @PostMapping("/diet_user_consumption")
+    fun insert(@RequestBody dietUserConsumption: DietUserConsumption): ResponseEntity<*> {
+        return ResponseEntity.ok().body(dietUserConsumptionRepository.save(dietUserConsumption))
+    }
+
+    @PostMapping("/diet_user_consumption/{id}")
+    fun update(@PathVariable(value = "id") id: Long, @RequestBody dietUserConsumption: DietUserConsumption): ResponseEntity<*> {
+        return dietUserConsumptionRepository.findById(id).map { existingConsumption ->
+            val updatedConsumption: DietUserConsumption = existingConsumption.copy(
+                rawMaterialId = dietUserConsumption.rawMaterialId,
+                dateConsumption = dietUserConsumption.dateConsumption,
+                name = dietUserConsumption.name,
+                quantity = dietUserConsumption.quantity,
+                quantityUnit = dietUserConsumption.quantityUnit,
+                cal = dietUserConsumption.cal,
+                protein = dietUserConsumption.protein,
+                fat = dietUserConsumption.fat,
+                ch = dietUserConsumption.ch,
+                sugar = dietUserConsumption.sugar
+            )
+            ResponseEntity.ok().body(dietUserConsumptionRepository.save(updatedConsumption))
+        }.orElse(ResponseEntity.notFound().build())
+    }
+
+    @GetMapping("/diet_user_consumption/{dietUserId}")
+    fun getByDietUserId(@PathVariable dietUserId: Long): ResponseEntity<List<DietUserConsumption>> {
+        val list = dietUserConsumptionRepository.findByDietUserId(dietUserId)
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/DietUserController.kt

@@ -0,0 +1,24 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.DietUser
+import com.aitrainer.api.repository.diet.DietUserRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("api")
+class DietUserController(private val dietUserRepository: DietUserRepository) {
+
+    @PostMapping ("/diet_user")
+    fun insert(@RequestBody dietUser: DietUser): ResponseEntity<DietUser> {
+        val newDietUser = dietUserRepository.save(dietUser)
+        return ResponseEntity.ok().body(newDietUser)
+    }
+
+    @GetMapping("/diet_user/{customerId}")
+    fun getByCustomerId(@PathVariable customerId: Long): ResponseEntity<DietUser> {
+        val dietUser = dietUserRepository.findByCustomerId(customerId)
+        return if (dietUser == null) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(dietUser)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/DietUserPreferenceController.kt

@@ -0,0 +1,24 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.DietUserPreference
+import com.aitrainer.api.repository.diet.DietUserPreferenceRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import java.util.*
+
+@RestController
+@RequestMapping("/api")
+class DietUserPreferenceController(private val dietUserPreferenceRepository: DietUserPreferenceRepository) {
+
+    @PostMapping("/diet_user_preference")
+    fun insert(@RequestBody dietUserPreference: DietUserPreference): ResponseEntity<*> {
+        return ResponseEntity.ok().body(dietUserPreferenceRepository.save(dietUserPreference))
+    }
+
+    @GetMapping("/diet_user_preference/{dietUserId}")
+    fun getByDietUserId(@PathVariable dietUserId: Long): ResponseEntity<List<DietUserPreference>> {
+        val list = dietUserPreferenceRepository.findByDietUserId(dietUserId)
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/DietUserSensitivityController.kt

@@ -0,0 +1,24 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.DietUserSensitivity
+import com.aitrainer.api.repository.diet.DietUserSensitivityRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import java.util.*
+
+@RestController
+@RequestMapping("/api")
+class DietUserSensitivityController(private val dietUserSensitivityRepository: DietUserSensitivityRepository) {
+
+    @PostMapping("/diet_user_sensitivity")
+    fun insert(@RequestBody dietUserSensitivity: DietUserSensitivity): ResponseEntity<*> {
+        return ResponseEntity.ok().body(dietUserSensitivityRepository.save(dietUserSensitivity))
+    }
+
+    @GetMapping("/diet_user_sensitivity/{dietUserId}")
+    fun getByDietUserId(@PathVariable dietUserId: Long): ResponseEntity<List<DietUserSensitivity>> {
+        val list = dietUserSensitivityRepository.findByDietUserId(dietUserId)
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/RawMaterialController.kt

@@ -0,0 +1,31 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.RawMaterial
+import com.aitrainer.api.repository.diet.RawMaterialRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("api")
+class RawMaterialController(private val rawMaterialRepository: RawMaterialRepository) {
+
+    @PostMapping ("/raw_material")
+    fun insert(@RequestBody rawMaterial: RawMaterial): ResponseEntity<RawMaterial> {
+        val newRawMaterial = rawMaterialRepository.save(rawMaterial)
+        return ResponseEntity.ok().body(newRawMaterial)
+    }
+
+    @GetMapping("/raw_material")
+    fun getAll(): ResponseEntity<List<RawMaterial>> {
+        val list = rawMaterialRepository.findAll()
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+
+    @GetMapping("/raw_material/{id}")
+    fun getByRawMaterialId(@PathVariable id: Long): ResponseEntity<RawMaterial> {
+        val rawMaterial = rawMaterialRepository.findByRawMaterialId(id)
+        return if (rawMaterial == null) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(rawMaterial)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/RecipeController.kt

@@ -0,0 +1,58 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.Recipe
+import com.aitrainer.api.repository.diet.RecipeRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("api")
+class RecipeController(private val recipeRepository: RecipeRepository) {
+
+    @PostMapping ("/recipe")
+    fun insert(@RequestBody recipe: Recipe): ResponseEntity<Recipe> {
+        val newRecipe = recipeRepository.save(recipe)
+        return ResponseEntity.ok().body(newRecipe)
+    }
+
+    @PostMapping("/recipe/{id}")
+    fun update(@PathVariable(value = "id") id: Long, @RequestBody recipe: Recipe): ResponseEntity<Recipe> {
+        val existingRecipe = recipeRepository.findByRecipeId(id) ?: return ResponseEntity.notFound().build()
+
+        val updatedRecipe: Recipe = existingRecipe.copy(
+            name = recipe.name,
+            description = recipe.description,
+            cal = recipe.cal,
+            ch = recipe.ch,
+            fat = recipe.fat,
+            protein = recipe.protein,
+            dietUserId = recipe.dietUserId
+        )
+        recipe.rawMaterials.forEach {
+            it.recipe = recipe
+            updatedRecipe.rawMaterials.add(it)
+        }
+        return ResponseEntity.ok().body(recipeRepository.save(updatedRecipe))
+    }
+
+    @GetMapping("/recipe")
+    fun getAll(): ResponseEntity<List<Recipe>> {
+        val list = recipeRepository.findAll()
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+
+    @GetMapping("/recipe/{dietUserId}")
+    fun getByDietUserId(@PathVariable dietUserId: Long): ResponseEntity<List<Recipe>> {
+        val list = recipeRepository.findByDietUserId(dietUserId)
+        return if (list == null) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+
+    @GetMapping("/recipe/name/{name}")
+    fun getByName(@PathVariable name: String): ResponseEntity<List<Recipe>> {
+        val list = recipeRepository.findByName(name)
+        return if (list == null) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/RecipeRawMaterialController.kt

@@ -0,0 +1,17 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.RecipeRawMaterial
+import com.aitrainer.api.repository.diet.RecipeRawMaterialRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("api")
+class RecipeRawMaterialController(private val recipeRawMaterialRepository: RecipeRawMaterialRepository) {
+
+    @PostMapping ("/recipe_raw_material")
+    fun insert(@RequestBody recipeRawMaterial: RecipeRawMaterial): ResponseEntity<RecipeRawMaterial> {
+        val newRecipe = recipeRawMaterialRepository.save(recipeRawMaterial)
+        return ResponseEntity.ok().body(recipeRawMaterial)
+    }
+}

src/main/kotlin/com/aitrainer/api/controller/diet/StoreController.kt

@@ -0,0 +1,32 @@
+package com.aitrainer.api.controller.diet
+
+import com.aitrainer.api.model.diet.Store
+import com.aitrainer.api.repository.diet.StoreRepository
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("api")
+class StoreController(private val storeRepository: StoreRepository) {
+
+    @PostMapping ("/store")
+    fun insert(@RequestBody store: Store): ResponseEntity<Store> {
+        val newStore = storeRepository.save(store)
+        return ResponseEntity.ok().body(newStore)
+    }
+
+    @GetMapping("/store")
+    fun getAll(): ResponseEntity<List<Store>> {
+        val list = storeRepository.findAll()
+        return if (list.isEmpty()) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(list)
+    }
+
+    @GetMapping("/store/{name}/{country}")
+    fun getByNameAndCountry(@PathVariable name: String, @PathVariable country: String ): ResponseEntity<Store> {
+        val store = storeRepository.findByNameAndCountry(name, country)
+        return if (store == null) ResponseEntity.notFound().build() else
+            ResponseEntity.ok().body(store)
+    }
+
+}