pull request to show code

Readme.txt

@@ -0,0 +1,13 @@
+To build and run run build.sh
+
+To run scenario
+cd scenario
+./scenario.sh
+
+When sending third http request in curl one can use ticket types as follows:
+adult: 1,
+student: 2,
+child: 3
+
+Assumptions:
+- I assumed, that reservation expiration date is equal to movie screening start time

build.gradle

@@ -1,11 +1,27 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
+    id "org.jetbrains.kotlin.kapt" version "1.8.21"
     id 'org.springframework.boot' version '3.0.6'
     id 'io.spring.dependency-management' version '1.1.0'
     id 'org.jetbrains.kotlin.jvm' version '1.7.22'
     id 'org.jetbrains.kotlin.plugin.spring' version '1.7.22'
+    id "org.jetbrains.kotlin.plugin.noarg" version "1.8.21"
     id 'org.jetbrains.kotlin.plugin.jpa' version '1.7.22'
+
+    id "org.jetbrains.kotlin.plugin.allopen" version "1.8.21"
+}
+
+noArg {
+  annotation("jakarta.persistence.Entity")
+  annotation("jakarta.persistence.Embeddable")
+  annotation("jakarta.persistence.MappedSuperclass")
+}
+
+allOpen {
+    annotation("jakarta.persistence.Entity")
+    annotation("jakarta.persistence.Embeddable")
+    annotation("jakarta.persistence.MappedSuperclass")
 }
 
 group = 'com.example'
@@ -21,9 +37,13 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'com.fasterxml.jackson.module:jackson-module-kotlin'
     implementation 'org.jetbrains.kotlin:kotlin-reflect'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
     runtimeOnly 'com.h2database:h2'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
+    testImplementation 'org.jetbrains.kotlin:kotlin-test-junit:1.8.21'
+
+    kapt "org.hibernate:hibernate-jpamodelgen:6.2.2.Final"
 }
 
 tasks.withType(KotlinCompile) {

build.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+./gradlew bootRun

scenario/reservationRequest.json

@@ -0,0 +1,11 @@
+{
+  "movieScreeningId": 1,
+  "name": "Pawel",
+  "surname": "Czajka",
+  "seats": [
+    {
+      "seatId": 1,
+      "ticketType": 1
+    }
+  ]
+}

scenario/scenario.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+curl -H "Content-Type: application/json" 'http://localhost:8080/api/screenings?minimalStartTime=2100-01-01T07:00:00.000%2B00:00&maximalEndTime=2100-01-02T23:40:00.000%2B00:00&offset=0&limit=1000' | json_pp
+
+echo ''
+echo ''
+
+curl -H "Content-Type: application/json" 'http://localhost:8080/api/screening?screeningId=1' | json_pp
+
+echo ''
+echo ''
+
+curl -H "Content-Type: application/json" -d "@reservationRequest.json" -X POST 'http://localhost:8080/api/createReservation' | json_pp
+
+echo ''
+echo ''

src/main/kotlin/com/example/ticketbookingapp/TicketBookingAppApplication.kt

@@ -1,10 +1,39 @@
 package com.example.ticketbookingapp
 
+import com.example.ticketbookingapp.config.CustomConfigProperties
+import com.example.ticketbookingapp.databaseInitialization.DatabaseInitializationForTest
+import com.example.ticketbookingapp.databaseInitialization.DatabaseInitializationService
+import org.springframework.boot.CommandLineRunner
 import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.context.properties.EnableConfigurationProperties
 import org.springframework.boot.runApplication
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Profile
 
+@EnableConfigurationProperties(CustomConfigProperties::class)
 @SpringBootApplication
-class TicketBookingAppApplication
+class TicketBookingAppApplication {
+
+    @Bean
+    @Profile("default")
+    fun dataLoader(
+        databaseInitializationService: DatabaseInitializationService
+    ): CommandLineRunner {
+        return CommandLineRunner {
+            databaseInitializationService.initializeDatabase()
+        }
+    }
+
+    @Bean
+    @Profile("test")
+    fun dataLoaderTest(
+        databaseInitializationForTest: DatabaseInitializationForTest
+    ): CommandLineRunner {
+        return CommandLineRunner {
+            databaseInitializationForTest.initializeDatabase()
+        }
+    }
+}
 
 fun main(args: Array<String>) {
     runApplication<TicketBookingAppApplication>(*args)

src/main/kotlin/com/example/ticketbookingapp/config/CustomConfigProperties.kt

@@ -0,0 +1,8 @@
+package com.example.ticketbookingapp.config
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties(prefix = "custom")
+data class CustomConfigProperties(
+    val minimalTimeBetweenBookingAndScreeningStart: Int
+)

src/main/kotlin/com/example/ticketbookingapp/databaseInitialization/DatabaseInitializationForTest.kt

@@ -0,0 +1,114 @@
+package com.example.ticketbookingapp.databaseInitialization
+
+import com.example.ticketbookingapp.domain.*
+import com.example.ticketbookingapp.service.MovieReservationService
+import com.example.ticketbookingapp.service.SeatAndTicketType
+import jakarta.persistence.EntityManager
+import jakarta.persistence.PersistenceContext
+import org.springframework.transaction.annotation.Transactional
+import org.springframework.stereotype.Service
+import java.math.BigDecimal
+import java.time.LocalDateTime
+import java.time.ZoneOffset
+
+@Service
+class DatabaseInitializationForTest(
+    private val reservationService: MovieReservationService,
+    private val databaseInitializationUtils: DatabaseInitializationUtils,
+) {
+    @PersistenceContext
+    private lateinit var entityManager: EntityManager
+
+    @Transactional(rollbackFor = [Exception::class])
+    fun initializeDatabase() {
+        val adultTicketType = databaseInitializationUtils.initializeTicketType("adult", BigDecimal("25"))
+        val studentTicketType = databaseInitializationUtils.initializeTicketType("student", BigDecimal("18"))
+        val childTicketType = databaseInitializationUtils.initializeTicketType("child", BigDecimal("12.5"))
+
+        val room1 = databaseInitializationUtils.initializeRoom("room 1", 5, 5)
+        val room2 = databaseInitializationUtils.initializeRoom("room 2", 10, 10)
+        val room3 = databaseInitializationUtils.initializeRoom("room 3", 15, 15)
+
+        val movie1 = databaseInitializationUtils.initializeMovie("Schindler's List", 90)
+        val movie2 = databaseInitializationUtils.initializeMovie("The Shawshank Redemption", 90)
+        val movie3 = databaseInitializationUtils.initializeMovie("The Lord of the Rings: The Return of the King", 90)
+
+        val screening_1_1 = initializeScreening(room1, movie1, 10)
+        val screening_1_2 = initializeScreening(room1, movie2, 20)
+
+        val screening_2_2 = initializeScreening(room2, movie2, 9)
+        databaseInitializationUtils.initializeScreening(
+                room1,
+                movie1,
+                LocalDateTime.of(2100, 1, 1, 0, 0, 0),
+                30
+            )
+        initializeScreening(room2, movie3, 21)
+
+        initializeScreening(room3, movie3, 11)
+        initializeScreening(room3, movie1, 19)
+
+        // to make sure ids of movie screenings are accessible
+        entityManager.flush()
+
+        val instantInThePast = LocalDateTime.of(1999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC)
+
+        reservationService.createReservation(
+            screening_1_1,
+            User("Name", "Surname"),
+            screening_1_1.screeningRoom.seats
+                .filter { seat -> seat.columnName == "1" }
+                .map { e -> SeatAndTicketType(e, studentTicketType) },
+            instantInThePast
+        )
+
+        reservationService.createReservation(
+            screening_1_1,
+            User(
+                "Namee",
+                "Surnamee",
+            ),
+            screening_1_1.screeningRoom.seats
+                .filter { seat -> seat.columnName == "4" }
+                .map { e -> SeatAndTicketType(e, adultTicketType) },
+            instantInThePast
+        )
+
+        reservationService.createReservation(
+            screening_1_2,
+            User(
+                "Nameee",
+                "Surnameee",
+            ),
+            screening_1_2.screeningRoom.seats
+                .filter { seat -> seat.columnName == "5" }
+                .map { e -> SeatAndTicketType(e, childTicketType) },
+            instantInThePast
+        )
+
+        reservationService.createReservation(
+            screening_2_2,
+            User(
+                "Nameee",
+                "Surnameee",
+            ),
+            screening_2_2.screeningRoom.seats
+                .filter { seat -> seat.columnName == "2" }
+                .map { e -> SeatAndTicketType(e, childTicketType) },
+            instantInThePast
+        )
+    }
+
+    private fun initializeScreening(
+        screeningRoom: ScreeningRoom,
+        movie: Movie,
+        hour: Int,
+    ): MovieScreening {
+        return databaseInitializationUtils.initializeScreening(
+            screeningRoom,
+            movie,
+            LocalDateTime.of(2000, 1, 1, hour, 0, 0),
+            30
+        )
+    }
+}

src/main/kotlin/com/example/ticketbookingapp/databaseInitialization/DatabaseInitializationService.kt

@@ -0,0 +1,57 @@
+package com.example.ticketbookingapp.databaseInitialization
+
+import com.example.ticketbookingapp.domain.*
+import jakarta.persistence.EntityManager
+import jakarta.persistence.PersistenceContext
+import org.springframework.transaction.annotation.Transactional
+import org.springframework.stereotype.Service
+import java.math.BigDecimal
+import java.time.LocalDateTime
+
+@Service
+class DatabaseInitializationService(
+    private val databaseInitializationUtils: DatabaseInitializationUtils,
+) {
+    @PersistenceContext
+    private lateinit var entityManager: EntityManager
+
+    @Transactional(rollbackFor = [Exception::class])
+    fun initializeDatabase() {
+        databaseInitializationUtils.initializeTicketType("adult", BigDecimal("25"))
+        databaseInitializationUtils.initializeTicketType("student", BigDecimal("18"))
+        databaseInitializationUtils.initializeTicketType("child", BigDecimal("12.5"))
+
+        val room1 = databaseInitializationUtils.initializeRoom("room 1", 3, 3)
+        val room2 = databaseInitializationUtils.initializeRoom("room 2", 15, 15)
+        val room3 = databaseInitializationUtils.initializeRoom("room 3", 20, 20)
+
+        val movie1 = databaseInitializationUtils.initializeMovie("Schindler's List ęóąśłżźćń", 100)
+        val movie2 = databaseInitializationUtils.initializeMovie("The Shawshank Redemption", 120)
+        val movie3 = databaseInitializationUtils.initializeMovie("The Lord of the Rings: The Return of the King", 140)
+
+        initializeScreening(room1, movie1, 10)
+        initializeScreening(room1, movie2, 20)
+
+        initializeScreening(room2, movie2, 9)
+        initializeScreening(room2, movie3, 21)
+
+        initializeScreening(room3, movie3, 11)
+        initializeScreening(room3, movie1, 19)
+
+        // to make sure ids of movie screenings are accessible
+        entityManager.flush()
+    }
+
+    private fun initializeScreening(
+        screeningRoom: ScreeningRoom,
+        movie: Movie,
+        hour: Int
+    ): MovieScreening {
+        return databaseInitializationUtils.initializeScreening(
+            screeningRoom,
+            movie,
+            LocalDateTime.of(2100, 1, 1, hour, 0, 0),
+            30
+        )
+    }
+}

src/main/kotlin/com/example/ticketbookingapp/databaseInitialization/DatabaseInitializationUtils.kt

@@ -0,0 +1,72 @@
+package com.example.ticketbookingapp.databaseInitialization
+
+import com.example.ticketbookingapp.domain.*
+import com.example.ticketbookingapp.repositories.*
+import org.springframework.stereotype.Service
+import java.math.BigDecimal
+import java.time.LocalDateTime
+import java.time.ZoneOffset
+
+@Service
+class DatabaseInitializationUtils(
+    private val movieRepository: MovieRepository,
+    private val screeningRoomRepository: ScreeningRoomRepository,
+    private val seatRepository: SeatRepository,
+    private val movieScreeningRepository: MovieScreeningRepository,
+    private val ticketTypeRepository: TicketTypeRepository,
+) {
+    fun initializeTicketType(name: String, price: BigDecimal): TicketType {
+        return TicketType(name, price).let { ticketTypeRepository.save(it) }
+    }
+
+    fun initializeRoom(roomName: String, numberOfRows: Int, numberOfColumns: Int): ScreeningRoom {
+        val screeningRoom = ScreeningRoom(roomName).let { screeningRoomRepository.save(it) }
+        val rowNames = ('A'..'Z').toList()
+        val seatsArray = buildList {
+            repeat(numberOfRows) { row ->
+                add(buildList {
+                    repeat(numberOfColumns) { column ->
+                        add(
+                            Seat(
+                                screeningRoom,
+                                rowNames[row].toString(),
+                                (column + 1).toString()
+                            ).let { seatRepository.save(it) }
+                        )
+                    }
+                })
+            }
+        }
+
+        for (row in seatsArray) {
+            for ((rowIndex, seat) in row.withIndex()) {
+                seat.seatToLeft = row.getOrNull(rowIndex - 1)
+                seat.seatToRight = row.getOrNull(rowIndex + 1)
+            }
+        }
+
+        return screeningRoom
+    }
+
+    fun initializeMovie(
+        movieName: String, movieLengthInMinutes: Int
+    ): Movie {
+        return Movie(movieName, movieLengthInMinutes)
+            .let { movieRepository.save(it) }
+    }
+
+    fun initializeScreening(
+        screeningRoom: ScreeningRoom,
+        movie: Movie,
+        dateTimeOfStart: LocalDateTime,
+        commercialsLengthInMinutes: Int,
+    ): MovieScreening {
+        val instantOfStart = dateTimeOfStart
+            .toInstant(ZoneOffset.UTC)
+        val instantOfEnd =
+            instantOfStart.plusSeconds((commercialsLengthInMinutes + movie.lengthInMinutes).toLong() * 60)
+
+        return MovieScreening(movie, screeningRoom, instantOfStart, instantOfEnd)
+            .let { movieScreeningRepository.save(it) }
+    }
+}