Matilda Sönnergaard

build.gradle

@@ -1,7 +1,7 @@
 plugins {
 	id 'java'
-	id 'org.springframework.boot' version '3.3.1'
-	id 'io.spring.dependency-management' version '1.1.5'
+	id 'org.springframework.boot' version '3.4.1'
+	id 'io.spring.dependency-management' version '1.1.7'
 }
 
 group = 'com.booleanuk'
@@ -13,19 +13,28 @@ java {
 	}
 }
 
+configurations {
+	compileOnly {
+		extendsFrom annotationProcessor
+	}
+}
+
 repositories {
 	mavenCentral()
 }
 
 dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
 	implementation 'org.springframework.boot:spring-boot-starter-web'
+//	compileOnly 'org.projectlombok:lombok'
 	developmentOnly 'org.springframework.boot:spring-boot-devtools'
-	runtimeOnly 'org.postgresql:postgresql'
+//	runtimeOnly 'org.postgresql:postgresql'
+	implementation 'org.postgresql:postgresql:42.7.4'
+//	annotationProcessor 'org.projectlombok:lombok'
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 
 tasks.named('test') {
 	useJUnitPlatform()
-}
+}

src/main/java/com/booleanuk/api/cinema/Main.java

@@ -0,0 +1,11 @@
+package com.booleanuk.api.cinema;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Main {
+    public static void main(String[] args) {
+        SpringApplication.run(Main.class, args);
+    }
+}

src/main/java/com/booleanuk/api/cinema/controller/CustomerController.java

@@ -0,0 +1,119 @@
+package com.booleanuk.api.cinema.controller;
+
+import com.booleanuk.api.cinema.model.Customer;
+import com.booleanuk.api.cinema.model.Screening;
+import com.booleanuk.api.cinema.model.Ticket;
+import com.booleanuk.api.cinema.repository.CustomerRepository;
+import com.booleanuk.api.cinema.repository.ScreeningRepository;
+import com.booleanuk.api.cinema.repository.TicketRepository;
+import com.booleanuk.api.cinema.responses.ErrorResponse;
+import com.booleanuk.api.cinema.responses.Response;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@RestController
+@RequestMapping("/customers")
+public class CustomerController {
+    private CustomerRepository customerRepository;
+    private TicketRepository ticketRepository;
+    private ScreeningRepository screeningRepository;
+
+    public CustomerController(CustomerRepository customerRepository, TicketRepository ticketRepository, ScreeningRepository screeningRepository) {
+        this.customerRepository = customerRepository;
+        this.ticketRepository = ticketRepository;
+        this.screeningRepository = screeningRepository;
+    }
+
+    @PostMapping
+    public ResponseEntity<Response<?>> create(@RequestBody Customer customer) {
+        Customer addedCustomer = customerRepository.save(customer);
+        if (addedCustomer == null) {
+            return new ResponseEntity<>(new ErrorResponse("bad request"), HttpStatus.BAD_REQUEST);
+        }
+        return new ResponseEntity<>(new Response<>("success", addedCustomer), HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Response<?>> getOne(@PathVariable int id) {
+//        return ResponseEntity.ok(customerRepository.findById(id).orElseThrow(
+//                () -> new ResponseStatusException(HttpStatus.NOT_FOUND, "No customer with that ID was found.")
+//        ));
+        Customer customer = customerRepository.findById(id).orElse(null);
+        if (customer == null) {
+            ErrorResponse error = new ErrorResponse("not found");
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+        Response<Customer> response = new Response<>();
+        response.set(customer);
+        return ResponseEntity.ok(response);
+    }
+
+    @GetMapping
+    public ResponseEntity<Response<?>> getAll() {
+        return ResponseEntity.ok(new Response<>("success", customerRepository.findAll()));
+
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Response<?>> update(@PathVariable int id, @RequestBody Customer customer) {
+        Customer customerToUpdate = customerRepository.findById(id).orElse(null);
+        if (customerToUpdate == null) {
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        }
+        if (customer.getName() != null)
+            customerToUpdate.setName(customer.getName());
+        if (customer.getEmail() != null)
+            customerToUpdate.setEmail(customer.getEmail());
+        if (customer.getPhone() != null)
+            customerToUpdate.setPhone(customer.getPhone());
+        customerToUpdate.setUpdatedAt(LocalDateTime.now());
+        // todo error 400
+        return new ResponseEntity<>(new Response<>(customerRepository.save(customerToUpdate)), HttpStatus.CREATED);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Response<?>> deleteCustomer(@PathVariable int id) {
+        Customer customer = customerRepository.findById(id).orElse(null);
+        if (customer == null) {
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        }
+
+        customerRepository.deleteById(id);
+        return ResponseEntity.ok(new Response<>("success", customer));
+    }
+
+    @PostMapping("/{c_id}/screenings/{s_id}")
+    public ResponseEntity<Response<?>> bookTicket(@PathVariable(name = "c_id") int customerId, @PathVariable(name = "s_id") int screeningId, @RequestBody Ticket ticket) {
+        Customer customer = customerRepository.findById(customerId).orElse(null);
+        Screening screening = screeningRepository.findById(screeningId).orElse(null);
+
+        if (customer == null || screening == null) {
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        }
+
+        ticket.setCustomer(customer);
+        ticket.setScreening(screening);
+        ticket.setCreatedAt(LocalDateTime.now());
+        ticket.setUpdatedAt(LocalDateTime.now());
+        return new ResponseEntity<>(new Response<>("success", ticketRepository.save(ticket)), HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{c_id}/screenings/{s_id}")
+    public ResponseEntity<Response<?>> getAllTickets(@PathVariable(name = "c_id") int customerId, @PathVariable(name = "s_id") int screeningId) {
+        Customer customer = customerRepository.findById(customerId).orElse(null);
+        Screening screening = screeningRepository.findById(screeningId).orElse(null);
+
+        if (customer == null || screening == null) {
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        }
+
+        return new ResponseEntity<>(new Response<>("success", ticketRepository.findAll().stream().filter(
+                t -> t.getCustomerId() == customer.getId() && t.getScreeningId() == screening.getId()
+        ).toList()), HttpStatus.OK);
+    }
+}

src/main/java/com/booleanuk/api/cinema/controller/MovieController.java

@@ -0,0 +1,118 @@
+package com.booleanuk.api.cinema.controller;
+
+import com.booleanuk.api.cinema.model.Movie;
+import com.booleanuk.api.cinema.model.Screening;
+import com.booleanuk.api.cinema.repository.MovieRepository;
+import com.booleanuk.api.cinema.repository.ScreeningRepository;
+import com.booleanuk.api.cinema.responses.ErrorResponse;
+import com.booleanuk.api.cinema.responses.Response;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@RestController
+@RequestMapping("/movies")
+public class MovieController {
+    private MovieRepository movieRepository;
+    private ScreeningRepository screeningRepository;
+
+    public MovieController(MovieRepository movieRepository, ScreeningRepository screeningRepository) {
+        this.movieRepository = movieRepository;
+        this.screeningRepository = screeningRepository;
+    }
+
+    private record MovieWithScreenings(String title, String rating, String description, int runtimeMins, List<Screening> screenings) {};
+
+    @PostMapping
+    public ResponseEntity<Response<?>> createMovie(@RequestBody MovieWithScreenings movieWithScreenings) {
+        Movie movie = new Movie(movieWithScreenings.title, movieWithScreenings.rating, movieWithScreenings.description, movieWithScreenings.runtimeMins);
+        Movie createdMovie = movieRepository.save(movie);
+        if (createdMovie == null) {
+            return new ResponseEntity<>(new ErrorResponse("bad request"), HttpStatus.BAD_REQUEST);
+        }
+        if (movieWithScreenings.screenings != null) {
+            for (Screening s : movieWithScreenings.screenings) {
+                s.setMovie(createdMovie);
+                screeningRepository.save(s);
+            }
+        }
+        return new ResponseEntity<>(new Response<>("success", createdMovie), HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Response<?>> getOne(@PathVariable int id) {
+        Movie movie = movieRepository.findById(id).orElse(null);
+        if (movie == null) {
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        }
+        return new ResponseEntity<>(new Response<>("success", movie), HttpStatus.OK);
+    }
+
+    @GetMapping
+    public ResponseEntity<Response<?>> getAll() {
+        return new ResponseEntity<>(new Response<>("success", movieRepository.findAll()), HttpStatus.OK);
+    }
+
+    @PostMapping("{id}/screenings")
+    public ResponseEntity<Response<?>> createScreening(@PathVariable(name = "id") int movieId, @RequestBody Screening screening) {
+        Movie movie = movieRepository.findById(movieId).orElse(null);
+        if (movie == null) {
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        }
+
+        screening.setMovie(movie);
+        screening.setCreatedAt(LocalDateTime.now());
+        screening.setUpdatedAt(LocalDateTime.now());
+        Screening createdScreening = screeningRepository.save(screening);
+
+        if (createdScreening == null) {
+            return new ResponseEntity<>(new ErrorResponse("bad request"), HttpStatus.BAD_REQUEST);
+        }
+        return new ResponseEntity<>(new Response<>("success", createdScreening), HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{id}/screenings")
+    public ResponseEntity<Response<?>> getAllScreenings(@PathVariable(name = "id") int movieId) {
+        Movie movie = movieRepository.findById(movieId).orElse(null);
+        if (movie == null)
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+
+        return new ResponseEntity<>(new Response<>("success", screeningRepository.findAll().stream().filter(
+                s -> s.getMovieId() == movie.getId()).toList()), HttpStatus.OK);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Response<?>> updateMovie(@PathVariable int id, @RequestBody Movie movie) {
+        Movie movieToUpdate = movieRepository.findById(id).orElse(null);
+        if (movieToUpdate == null) {
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        }
+
+        if (movie.getTitle() != null)
+            movieToUpdate.setTitle(movie.getTitle());
+        if (movie.getRating() != null)
+            movieToUpdate.setRating(movie.getRating());
+        if (movie.getDescription() != null)
+            movieToUpdate.setDescription(movie.getDescription());
+        if (movie.getRuntimeMins() > 0)
+            movieToUpdate.setRuntimeMins(movie.getRuntimeMins());
+        movieToUpdate.setUpdatedAt(LocalDateTime.now());
+
+        if (movieRepository.save(movieToUpdate) == null) {
+            return new ResponseEntity<>(new ErrorResponse("bad request"), HttpStatus.BAD_REQUEST);
+        }
+        return new ResponseEntity<>(new Response<>("success", movieToUpdate), HttpStatus.CREATED);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Response<?>> deleteMovie(@PathVariable int id) {
+        Movie movie = movieRepository.findById(id).orElse(null);
+        if (movie == null)
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        movieRepository.deleteById(id);
+        return ResponseEntity.ok(new Response<>("success", movie));
+    }
+}

src/main/java/com/booleanuk/api/cinema/controller/ScreeningController.java

@@ -0,0 +1,30 @@
+package com.booleanuk.api.cinema.controller;
+
+import com.booleanuk.api.cinema.model.Screening;
+import com.booleanuk.api.cinema.repository.MovieRepository;
+import com.booleanuk.api.cinema.repository.ScreeningRepository;
+import com.booleanuk.api.cinema.responses.ErrorResponse;
+import com.booleanuk.api.cinema.responses.Response;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/screenings")
+public class ScreeningController {
+    ScreeningRepository screeningRepository;
+    MovieRepository movieRepository;
+
+    public ScreeningController(ScreeningRepository screeningRepository, MovieRepository movieRepository) {
+        this.screeningRepository = screeningRepository;
+        this.movieRepository = movieRepository;
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Response<?>> getOne(@PathVariable(name = "id") int id) {
+        Screening screening = screeningRepository.findById(id).orElse(null);
+        if (screening == null)
+            return new ResponseEntity<>(new ErrorResponse("not found"), HttpStatus.NOT_FOUND);
+        return ResponseEntity.ok(new Response<>("success", screening));
+    }
+}

src/main/java/com/booleanuk/api/cinema/controller/TicketController.java

@@ -0,0 +1,33 @@
+package com.booleanuk.api.cinema.controller;
+
+import com.booleanuk.api.cinema.model.Ticket;
+import com.booleanuk.api.cinema.repository.MovieRepository;
+import com.booleanuk.api.cinema.repository.ScreeningRepository;
+import com.booleanuk.api.cinema.repository.TicketRepository;
+import com.booleanuk.api.cinema.responses.Response;
+import org.springframework.http.HttpStatus;
+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 java.util.List;
+
+@RestController
+@RequestMapping("/tickets")
+public class TicketController {
+    private TicketRepository ticketRepository;
+    private MovieRepository movieRepository;
+    private ScreeningRepository screeningRepository;
+
+    public TicketController(TicketRepository ticketRepository, MovieRepository movieRepository, ScreeningRepository screeningRepository) {
+        this.ticketRepository = ticketRepository;
+        this.movieRepository = movieRepository;
+        this.screeningRepository = screeningRepository;
+    }
+
+    @GetMapping
+    public ResponseEntity<Response<?>> getAll() {
+        return new ResponseEntity<>(new Response<>("success", ticketRepository.findAll()), HttpStatus.OK);
+    }
+}