Ludwig Joabson Lundborg

.gitignore

@@ -36,3 +36,6 @@ out/
 
 ### VS Code ###
 .vscode/
+
+src/main/resources/application.yml
+

build.gradle

@@ -21,7 +21,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	developmentOnly 'org.springframework.boot:spring-boot-devtools'
-	runtimeOnly 'org.postgresql:postgresql'
+	implementation 'org.postgresql:postgresql:42.7.3'
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }

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/controllers/CustomerController.java

@@ -0,0 +1,94 @@
+package com.booleanuk.api.cinema.controllers;
+
+import com.booleanuk.api.cinema.models.Customer;
+import com.booleanuk.api.cinema.repository.CustomerRepository;
+import com.booleanuk.api.cinema.response.CustomerListResponse;
+import com.booleanuk.api.cinema.response.CustomerResponse;
+import com.booleanuk.api.cinema.response.ErrorResponse;
+import com.booleanuk.api.cinema.response.Response;
+import org.springframework.beans.factory.annotation.Autowired;
+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("customers")
+public class CustomerController {
+
+    private CustomerListResponse customerListResponse = new CustomerListResponse();
+    private CustomerResponse customerResponse = new CustomerResponse();
+
+    @Autowired
+    private CustomerRepository customerRepository;
+
+    @GetMapping
+    public ResponseEntity<Response<?>> getAllCustomers () {
+        List<Customer> customers = customerRepository.findAll();
+        this.customerListResponse.set(customers);
+
+        return ResponseEntity.ok(customerListResponse);
+    }
+
+    @PostMapping
+    public ResponseEntity<Response<?>> createCustomer(@RequestBody Customer customer){
+
+        if (customer.getName() == null || customer.getEmail() == null || customer.getPhone() == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("Could not create a new customer, please check all fields are correct");
+
+            return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+        }
+
+        customer.setCreatedAt(LocalDateTime.now());
+        customer.setUpdatedAt(LocalDateTime.now());
+        this.customerResponse.set(customer);
+        this.customerRepository.save(customer);
+
+        return new ResponseEntity<>(customerResponse, HttpStatus.CREATED);
+    }
+
+    @PutMapping("{id}")
+    public ResponseEntity<Response<?>> updateCustomer(@PathVariable int id, @RequestBody Customer customer){
+
+        if (customer.getName() == null || customer.getEmail() == null || customer.getPhone() == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("Could not create a new customer, please check all fields are correct");
+            return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+        }
+
+        Customer customerToUpdate = customerRepository.findById(id).orElse(null);
+        if(customerToUpdate == null){
+                ErrorResponse error = new ErrorResponse();
+                error.set("No customer with that ID found");
+                return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        customerToUpdate.setName(customer.getName());
+        customerToUpdate.setEmail(customer.getEmail());
+        customerToUpdate.setPhone(customer.getPhone());
+        customerToUpdate.setUpdatedAt(LocalDateTime.now());
+        this.customerResponse.set(customerToUpdate);
+        this.customerRepository.save(customerToUpdate);
+
+        return new ResponseEntity<>(customerResponse, HttpStatus.CREATED);
+    }
+
+    @DeleteMapping("{id}")
+    public ResponseEntity<Response<?>> deleteCustomer(@PathVariable int id){
+
+        Customer customerToDelete = this.customerRepository.findById(id).orElse(null);
+        if (customerToDelete == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("No customer with that ID found");
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        this.customerResponse.set(customerToDelete);
+        this.customerRepository.delete(customerToDelete);
+
+        return ResponseEntity.ok(customerResponse);
+    }
+}

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

@@ -0,0 +1,97 @@
+package com.booleanuk.api.cinema.controllers;
+
+import com.booleanuk.api.cinema.models.Movie;
+import com.booleanuk.api.cinema.repository.MovieRepository;
+import com.booleanuk.api.cinema.repository.ScreeningRepository;
+import com.booleanuk.api.cinema.response.ErrorResponse;
+import com.booleanuk.api.cinema.response.MovieListResponse;
+import com.booleanuk.api.cinema.response.MovieResponse;
+import com.booleanuk.api.cinema.response.Response;
+import org.springframework.beans.factory.annotation.Autowired;
+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 {
+
+    @Autowired
+    private MovieRepository movieRepository;
+
+    @Autowired
+    private ScreeningRepository screeningRepository;
+
+    private MovieResponse movieResponse = new MovieResponse();
+    private MovieListResponse movieListResponse = new MovieListResponse();
+
+    @GetMapping
+    public ResponseEntity<Response<?>> getAllMovies(){
+        List<Movie> movies = this.movieRepository.findAll();
+        this.movieListResponse.set(movies);
+
+        return ResponseEntity.ok(movieListResponse);
+    }
+
+    @PostMapping
+    public ResponseEntity<Response<?>> createMovie(@RequestBody Movie movie){
+        if (movie.getTitle() == null || movie.getRating() == null || movie.getDescription() == null || movie.getRuntimeMins() <= 0){
+            ErrorResponse error = new ErrorResponse();
+            error.set("Could not create a new movie, please check all fields are correct");
+            return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+        }
+
+        movie.setCreatedTime(LocalDateTime.now());
+        movie.setUpdatedTime(LocalDateTime.now());
+
+        this.movieRepository.save(movie);
+        this.movieResponse.set(movie);
+
+        return new ResponseEntity<>(movieResponse, HttpStatus.CREATED);
+    }
+
+    @PutMapping("{id}")
+    public ResponseEntity<Response<?>> updateMovie(@PathVariable int id, @RequestBody Movie movie){
+        if (movie.getTitle() == null || movie.getRating() == null || movie.getDescription() == null || movie.getRuntimeMins() <= 0){
+            ErrorResponse error = new ErrorResponse();
+            error.set("Could not create a new movie, please check all fields are correct");
+            return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+        }
+
+        Movie movieToUpdate = this.movieRepository.findById(id).orElse(null);
+        if (movieToUpdate == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("No movie with that id found");
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        movieToUpdate.setTitle(movie.getTitle());
+        movieToUpdate.setRating(movie.getRating());
+        movieToUpdate.setDescription(movie.getDescription());
+        movieToUpdate.setRuntimeMins(movie.getRuntimeMins());
+
+        this.movieRepository.save(movieToUpdate);
+        this.movieResponse.set(movieToUpdate);
+
+        return new ResponseEntity<>(movieResponse, HttpStatus.CREATED);
+    }
+
+    @DeleteMapping("{id}")
+    public ResponseEntity<Response<?>> deleteMovie(@PathVariable int id){
+        Movie movieToDelete = this.movieRepository.findById(id).orElse(null);
+        if (movieToDelete == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("No movie with that id found");
+
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        this.movieRepository.delete(movieToDelete);
+        this.movieResponse.set(movieToDelete);
+
+        return ResponseEntity.ok(movieResponse);
+    }
+}

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

@@ -0,0 +1,80 @@
+package com.booleanuk.api.cinema.controllers;
+
+import com.booleanuk.api.cinema.models.Movie;
+import com.booleanuk.api.cinema.models.Screening;
+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.response.ErrorResponse;
+import com.booleanuk.api.cinema.response.Response;
+import com.booleanuk.api.cinema.response.ScreeningListResponse;
+import com.booleanuk.api.cinema.response.ScreeningResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+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/{id}/screenings")
+public class ScreeningController {
+
+    @Autowired
+    private ScreeningRepository screeningRepository;
+
+    @Autowired
+    private MovieRepository movieRepository;
+
+    @Autowired
+    private TicketRepository ticketRepository;
+
+    private ScreeningResponse screeningResponse = new ScreeningResponse();
+    private ScreeningListResponse screeningListResponse = new ScreeningListResponse();
+
+    @GetMapping
+    public ResponseEntity<Response<?>> getAllScreening(@PathVariable int id) {
+        Movie movie = this.movieRepository.findById(id).orElse(null);
+        if (movie == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("No movie with that id found");
+
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        List<Screening> screeningsList = this.screeningRepository.findByMovie(movie);
+        this.screeningListResponse.set(screeningsList);
+
+        return ResponseEntity.ok(screeningListResponse);
+    }
+
+    @PostMapping
+    public ResponseEntity<Response<?>> createScreening(@PathVariable int id, @RequestBody Screening screening){
+        if (screening.getScreenNumber() <= 0 || screening.getCapacity() <= 0 || screening.getStartsAt() == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("Could not create a screening for the specified movie, please check all fields are correct");
+
+            return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+        }
+
+        Movie movie = this.movieRepository.findById(id).orElse(null);
+        if (movie == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("No movie with that id found");
+
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        screening.setMovie(movie);
+        screening.setCreatedAt(LocalDateTime.now());
+        screening.setUpdatedAt(LocalDateTime.now());
+        movie.addScreening(screening);
+
+        this.screeningRepository.save(screening);
+        this.screeningResponse.set(screening);
+
+        return new ResponseEntity<>(screeningResponse, HttpStatus.CREATED);
+    }
+
+}

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

@@ -0,0 +1,85 @@
+package com.booleanuk.api.cinema.controllers;
+
+import com.booleanuk.api.cinema.models.Customer;
+import com.booleanuk.api.cinema.models.Screening;
+import com.booleanuk.api.cinema.models.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.response.ErrorResponse;
+import com.booleanuk.api.cinema.response.Response;
+import com.booleanuk.api.cinema.response.TicketListResponse;
+import com.booleanuk.api.cinema.response.TicketResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+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("customers")
+public class TicketController {
+
+    @Autowired
+    private TicketRepository ticketRepository;
+
+    @Autowired
+    private ScreeningRepository screeningRepository;
+
+    @Autowired
+    private CustomerRepository customerRepository;
+
+    private TicketResponse ticketResponse = new TicketResponse();
+    private TicketListResponse ticketListResponse = new TicketListResponse();
+
+    @PostMapping("{customerId}/screenings/{screeningId}")
+        public ResponseEntity<Response<?>> createTicket(@PathVariable(name = "customerId") int customerId, @PathVariable(name = "screeningId") int screeningId, @RequestBody Ticket ticket){
+
+            Customer customer = this.customerRepository.findById(customerId).orElse(null);
+            Screening screening = this.screeningRepository.findById(screeningId).orElse(null);
+
+            if (customer == null || screening == null){
+                ErrorResponse error = new ErrorResponse();
+                error.set("No customer or screening with those ids found");
+
+                new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+            }
+
+            ticket.setCustomer(customer);
+            ticket.setScreening(screening);
+            ticket.setCreatedAt(LocalDateTime.now());
+            ticket.setUpdatedAt(LocalDateTime.now());
+
+            this.ticketRepository.save(ticket);
+            this.ticketResponse.set(ticket);
+
+            return new ResponseEntity<>(ticketResponse, HttpStatus.CREATED);
+    }
+
+    @GetMapping("{customerId}/screenings/{screeningId}")
+    public ResponseEntity<Response<?>> getAllTickets (@PathVariable(name = "customerId") int customerId, @PathVariable(name = "screeningId") int screeningId){
+
+        Customer customer = this.customerRepository.findById(customerId).orElse(null);
+        Screening screening = this.screeningRepository.findById(screeningId).orElse(null);
+        if (customer == null || screening == null){
+            ErrorResponse error = new ErrorResponse();
+            error.set("No customer or screening with those ids found");
+
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        List<Ticket> ticketList = this.ticketRepository.findAllByCustomerIdAndScreeningId(customer.getId(), screening.getId());
+        if (ticketList.isEmpty()){
+            ErrorResponse error = new ErrorResponse();
+            error.set("No ticket found for the customer and screening with those ids found");
+
+            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
+        }
+
+        this.ticketListResponse.set(ticketList);
+        return ResponseEntity.ok(ticketListResponse);
+    }
+
+}