README.md

 * Launch the [Postman](https://chrome.google.com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop?hl=en) app and enter the URI `http://localhost:8080/polls` and hit Send.
 * Because we don’t have any polls created yet, this command should result in an empty collection.
 * If your application cannot run because something is occupying a port, use this command with the respective port number specified:
-	* ``kill -kill `lsof -t -i tcp:8080` ``
+	* ``npx kill-port 8080``
 
 
 
 
 
 
-## Part 5.4 - Validating domain entities
+## Part 5.5 - Validating domain entities
 
 Now it's time to make sure that all objects persisted to the database actually contain valid values. Use the `org.hibernate.validator.constraints.NotEmpty` and `javax.validation.constraints.Size` and `javax.validation.Valid` annotations for validation.
 
   - `question` should be `@NotEmpty`
 - To enforce these validations, add `@Valid` annotations to Poll objects in `RequestMapping`-annotated controller methods (there should be 2)
 
-## Part 5.5 - Customizing validation errors
+## Part 5.6 - Customizing validation errors
 
 In order to customize validation errors we'll need a class for error information. Create a `ValidationError` class in `io.zipcoder.tc_spring_poll_application.dto.error` with the following fields and appropriate getters and setters:
 
 We also need a new field in the `ErrorDetail` class to hold errors. There may be multiple validation errors associated with a request, sometimes more than one of the same type, so this field will be a collection, specifically a `Map<String, List<ValidationError>> errors` field.
 
 
-## Part 5.6 - Create a validation error handler
+## Part 5.7 - Create a validation error handler
 
 - add below handler to `RestExceptionHandler`
 
 ```java
 @ExceptionHandler(MethodArgumentNotValidException.class)
 public ResponseEntity<?>
-handleValidationError(  MethodArgumentNotValidException manve,
+handleValidationError(MethodArgumentNotValidException manve,
 						HttpServletRequest request){...}
 ```
 
 }
 ```
 
-## Part 5.7 - Externalize strings in a messages.properties file
+- Use an autowired `MessageSource` object in the `RestExceptionHandler` to set the message on ValidationError objects (ie: `setMessage(messageSource.getMessage(fe,null));` )
+  - This object will be autowired (or injected) the same way your `CRUDRepository` instances are.
+
+## Part 5.8 - Externalize strings in a messages.properties file
 
 Commonly used strings in your Java program can be removed from the source code and placed in a separate file. This is called externalizing, and is useful for allowing changes to text displayed without impacting actual program logic. One example of where this is done is in internationalization, the practice of providing multilingual support in an application, allowing users to use an application in their native language.
 
 - Create a `messages.properties` file in the `src/main/resources` directory with the given properties below
   - `messages.properties` is a key-value file stored in plain text. Your IDE may have a table-based view or show the contents as text
   - `.properties` files are a common idiom in Java applications; they contain additional information the application uses that doesn't impact the actual source code.
-- Use an autowired `MessageSource` object in the `RestExceptionHandler` to set the message on ValidationError objects (ie: `setMessage(messageSource.getMessage(fe,null));` )
-  - This object will be autowired (or injected) the same way your `CRUDRepository` instances are.
+
 
 **`messages.properties` content**:
 
 ## Part 6.2 - Spring's Built-in Pagination
 
 * Make use of Spring's built-in page number pagination support by researching `org.springframework.data.repository.PagingAndSortingRepository`.
-* Modify respective `Controller` methods to handle `Pageable` arguments.
+* Modify respective `Controller` methods to handle `Pageable` arguments and `Page<T>` return-types.
+* Modify respective `Repository` methods to handle `Page<T>` objects.
 * Send a `GET` request to `http://localhost:8080/polls?page=0&size=2` via Postman.
 * Ensure the response is a `JSON` object with pagination-specific information.

src/main/java/io/zipcoder/tc_spring_poll_application/controller/ComputeResultController.java

 
 import io.zipcoder.tc_spring_poll_application.domain.Vote;
 import io.zipcoder.tc_spring_poll_application.domain.repositories.VoteRepository;
+import io.zipcoder.tc_spring_poll_application.dtos.OptionCount;
 import io.zipcoder.tc_spring_poll_application.dtos.VoteResult;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.ArrayList;
+
 @RestController
 public class ComputeResultController {
 
 
     @Autowired
     public ComputeResultController(VoteRepository voteRepository) {
+
         this.voteRepository = voteRepository;
     }
 
 
     public ResponseEntity<?> computeResult(@RequestParam Long pollId) {
         VoteResult voteResult = new VoteResult();
+        voteResult.setResults(new ArrayList<OptionCount>());
         Iterable<Vote> allVotes = voteRepository.findVotesByPoll(pollId);
+        for(Vote vote : allVotes){
+                       OptionCount optionCount = new OptionCount();
+                       optionCount.setCount(1);
+                     optionCount.setOptionId(vote.getOption().getId());
+
+                                if(voteResult.getOptionCount(optionCount) != null){
+                               OptionCount optionCount1 = voteResult.getOptionCount(optionCount);
+                             int amount = optionCount1.getCount();
+                              amount = amount + 1;
+                               optionCount1.setCount(amount);
+                             int votes = voteResult.getTotalVotes();
+                            votes = votes + 1;
+                           voteResult.setTotalVotes(votes);
+                        } else {
+                              voteResult.addOptionCount(optionCount);
+                              voteResult.setTotalVotes(1);
+                        }
+                  }
+
+                       return new ResponseEntity<VoteResult>(voteResult, HttpStatus.OK);
+         }
+
+
 
-        //TODO: Implement algorithm to count votes
-        return new ResponseEntity<VoteResult>(voteResult, HttpStatus.OK);
-    }
 }

src/main/java/io/zipcoder/tc_spring_poll_application/controller/PollController.java

 import io.zipcoder.tc_spring_poll_application.domain.repositories.PollRepository;
 import io.zipcoder.tc_spring_poll_application.exception.ResourceNotFoundException;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
 
+import javax.validation.Valid;
 import java.net.URI;
 
 /*
 public class PollController {
 
 
-    PollRepository pollRepository;
+    private PollRepository pollRepository;
+
+
+    //    @Autowired
+//    public PollController(PollRepository pollRepository1) {
+//        this.pollRepository = pollRepository1;
+//
+//    }
+//
+//    @RequestMapping(value = "/polls", method = RequestMethod.GET)
+//    public ResponseEntity<Iterable<Poll>> getAllPolls() {
+//        Iterable<Poll> allPolls = pollRepository.findAll();
+//        return new ResponseEntity<>(allPolls, HttpStatus.OK);
+//    }
+//
+//    @RequestMapping(value = "/polls", method = RequestMethod.POST)
+//
+//    public ResponseEntity<?> createPoll(@RequestBody Poll poll) {
+//        poll = pollRepository.save(poll);
+//
+//        URI newPollUri = ServletUriComponentsBuilder
+//                .fromCurrentRequest()
+//                .path("/{id}")
+//                .buildAndExpand(poll.getId())
+//                .toUri();
+//
+//        return new ResponseEntity<>(null, HttpStatus.CREATED);
+//    }
+//
+//    @RequestMapping(value = "/polls/{pollId}", method = RequestMethod.GET)
+//    public ResponseEntity<?> getPoll(@PathVariable Long pollId) {
+//        Poll p = pollRepository.findOne(pollId);
+//        return new ResponseEntity<>(p, HttpStatus.OK);
+//    }
+//
+//    @RequestMapping(value = "/polls/{pollId}", method = RequestMethod.PUT)
+//    public ResponseEntity<?> updatePoll(@RequestBody Poll poll, @PathVariable Long pollId) {
+//        // Save the entity
+//        Poll p = pollRepository.save(poll);
+//        return new ResponseEntity<>(HttpStatus.OK);
+//    }
+//
+//    @RequestMapping(value = "/polls/{pollId}", method = RequestMethod.DELETE)
+//    public ResponseEntity<?> deletePoll(@PathVariable Long pollId) {
+//        pollRepository.delete(pollId);
+//        return new ResponseEntity<>(HttpStatus.OK);
+//    }
+//
+////    public void verifypoll() throws ResourceNotFoundException {
+////        throw new ResourceNotFoundException();
+////    }
+//}
+    public void pollExists(Long pollId) throws ResourceNotFoundException {
+        if (pollRepository.findOne(pollId) == null) {
+            throw new ResourceNotFoundException("The poll specified does not exist.");
+        }
 
+    }
 
     @Autowired
-    public PollController(PollRepository pollRepository1) {
-        this.pollRepository = pollRepository1;
-
+    public PollController(PollRepository pollRepository) {
+        this.pollRepository = pollRepository;
     }
 
-    @RequestMapping(value = "/polls", method = RequestMethod.GET)
-    public ResponseEntity<Iterable<Poll>> getAllPolls() {
+    @GetMapping("/polls")
+    public ResponseEntity<Iterable<Poll>> getPolls() {
         Iterable<Poll> allPolls = pollRepository.findAll();
         return new ResponseEntity<>(allPolls, HttpStatus.OK);
     }
 
-    @RequestMapping(value = "/polls", method = RequestMethod.POST)
-
-    public ResponseEntity<?> createPoll(@RequestBody Poll poll) {
-        poll = pollRepository.save(poll);
-
-        URI newPollUri = ServletUriComponentsBuilder
-                .fromCurrentRequest()
-                .path("/{id}")
-                .buildAndExpand(poll.getId())
-                .toUri();
-
-        return new ResponseEntity<>(null, HttpStatus.CREATED);
-    }
-
-    @RequestMapping(value = "/polls/{pollId}", method = RequestMethod.GET)
-    public ResponseEntity<?> getPoll(@PathVariable Long pollId) {
-        Poll p = pollRepository.findOne(pollId);
-        return new ResponseEntity<>(p, HttpStatus.OK);
-    }
+    @GetMapping("/polls/{size}/{pageNum}")
+    public ResponseEntity<Page<Poll>> getPollsPaged(@PathVariable int size, @PathVariable int pageNum) {
 
-    @RequestMapping(value = "/polls/{pollId}", method = RequestMethod.PUT)
-    public ResponseEntity<?> updatePoll(@RequestBody Poll poll, @PathVariable Long pollId) {
-        // Save the entity
-        Poll p = pollRepository.save(poll);
-        return new ResponseEntity<>(HttpStatus.OK);
-    }
+        PageRequest pageRequest = new PageRequest(pageNum, size);
+        Page<Poll> page = pollRepository.findAll(pageRequest);
 
-    @RequestMapping(value = "/polls/{pollId}", method = RequestMethod.DELETE)
-    public ResponseEntity<?> deletePoll(@PathVariable Long pollId) {
-        pollRepository.delete(pollId);
-        return new ResponseEntity<>(HttpStatus.OK);
+        return new ResponseEntity<>(page, HttpStatus.OK);
     }
-
-    public void verifypoll() throws ResourceNotFoundException {
-        throw new ResourceNotFoundException();
+        @PostMapping("/polls")
+        @Valid
+        public ResponseEntity<?> createPoll (@RequestBody Poll poll){
+            poll = pollRepository.save(poll);
+            HttpHeaders httpHeaders = new HttpHeaders();
+            httpHeaders.setLocation(ServletUriComponentsBuilder
+                    .fromCurrentRequest()
+                    .path("/{id}")
+                    .buildAndExpand(poll.getId())
+                    .toUri());
+            return new ResponseEntity<>(null, HttpStatus.CREATED);
+        }
+
+        @GetMapping("/polls/{pollId}")
+        public ResponseEntity<?> getPoll (@PathVariable Long pollId){
+            Poll p = pollRepository.findOne(pollId);
+            return new ResponseEntity<>(p, HttpStatus.OK);
+
+        }
+
+        @PutMapping("/polls/{pollId}")
+        @Valid
+        public ResponseEntity<?> updatePoll (@RequestBody Poll poll, @PathVariable Long pollId){
+            Poll p = pollRepository.save(poll);
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        @DeleteMapping("/polls/{pollId}")
+        public ResponseEntity<?> deletePoll (@PathVariable Long pollId){
+            pollRepository.delete(pollId);
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
     }
-}
 
 

src/main/java/io/zipcoder/tc_spring_poll_application/domain/Poll.java

     @OneToMany(cascade = CascadeType.ALL)
 		 @JoinColumn(name = "POLL_ID")
 		@OrderBy
+       @Size(min=2,max=6)
       private  Set<Option> options;
 
 
 
         this.question = question;
     }
-    @Size(min=2, max = 6)
+
     public Set<Option> getOptions() {
         return options;
     }

src/main/java/io/zipcoder/tc_spring_poll_application/domain/Vote.java

 @Entity
 public class Vote {
     @Id
-    @GeneratedValue
+    @GeneratedValue(strategy = GenerationType.AUTO )
     @Column (name="VOTE_ID")
     private Long id;
 
     @ManyToOne
             @JoinColumn (name="OPTION_ID")
-    Option option;
+    private Option option;
 
 
     public Long getId() {

src/main/java/io/zipcoder/tc_spring_poll_application/domain/repositories/PollRepository.java

 
 import io.zipcoder.tc_spring_poll_application.domain.Poll;
 import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.stereotype.Repository;
 
 @Repository
-public interface PollRepository extends CrudRepository<Poll, Long> {
+public interface PollRepository extends CrudRepository<Poll, Long>, PagingAndSortingRepository<Poll, Long> {
 
 }

src/main/java/io/zipcoder/tc_spring_poll_application/dtos/ErrorDetail.java

 import java.util.Map;
 
 public class ErrorDetail {
-    String title;
-    int status;
-    String detail;
-    Long timeStamp;
-    String developerMessage;
+   private String title;
+  private  int status;
+  private  String detail;
+  private  Long timeStamp;
+ private   String developerMessage;
+ private Map<String, List<ValidationError>> errors;
+
+    public ErrorDetail() {
+    }
+
+    public ErrorDetail(String title, int status, String detail, Long timestamp, String developerMessage, Map<String, List<ValidationError>> errors) {
+                this.title = title;
+              this.status = status;
+              this.detail = detail;
+             this.timeStamp = timestamp;
+             this.developerMessage = developerMessage;
+               this.errors = errors;
+        }
+
 
     public String getTitle() {
         return title;
         this.developerMessage = developerMessage;
     }
 
-    public Map<String, List<ValidationError>> getErrors() {
-        return null;
+    public Map<String, List<ValidationError>> getErrors()
+    {
+        return  errors;
+    }
+    public  void setErrors (Map<String, List<ValidationError>> errors){
+        this.errors =errors ;
     }
 }

src/main/java/io/zipcoder/tc_spring_poll_application/dtos/OptionCount.java

         private int count;
 
         public Long getOptionId() {
+
             return optionId;
         }
 
         public void setOptionId(Long optionId) {
+
             this.optionId = optionId;
         }
 
         public int getCount() {
+
             return count;
         }
 
         public void setCount(int count) {
+
             this.count = count;
         }
 

src/main/java/io/zipcoder/tc_spring_poll_application/dtos/RestExceptionHandler.java

 package io.zipcoder.tc_spring_poll_application.dtos;
 
+import io.zipcoder.tc_spring_poll_application.error.ValidationError;
 import io.zipcoder.tc_spring_poll_application.exception.ResourceNotFoundException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 
 import javax.servlet.http.HttpServletRequest;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
 
 @ControllerAdvice
 public class RestExceptionHandler {
+    @Autowired
+
+    MessageSource messageSource;
+
+    @ExceptionHandler(ResourceNotFoundException.class)
+
+            public ResponseEntity<?> handleResourceNotFoundException(ResourceNotFoundException rnfe, HttpServletRequest request){
+               ErrorDetail errorDetail = new ErrorDetail();
+
+                  errorDetail.setDetail(rnfe.getCause().toString());
+               errorDetail.setTitle(rnfe.getMessage());
+             errorDetail.setDeveloperMessage(rnfe.getLocalizedMessage());
+             errorDetail.setTimeStamp(new Date().getTime());
+              return new ResponseEntity<>(errorDetail, HttpStatus.NOT_FOUND);
+           }
+   @ExceptionHandler(MethodArgumentNotValidException.class)
+           public ResponseEntity<?> handleValidationError(MethodArgumentNotValidException manve, HttpServletRequest request) {
+             ErrorDetail errorDetail = new ErrorDetail();
+
+                      List<FieldError> fieldErrors = manve.getBindingResult().getFieldErrors();
+              for (FieldError fe : fieldErrors) {
+                      List<ValidationError> validationErrorList = errorDetail.getErrors().get(fe.getField());
+                      if (validationErrorList == null) {
+                              validationErrorList = new ArrayList<>();
+                            errorDetail.getErrors().put(fe.getField(), validationErrorList);
+                          }
+                      ValidationError validationError = new ValidationError();
+                    validationError.setCode(fe.getCode());
+                   validationError.setMessage(messageSource.getMessage(fe, null));
+                       validationErrorList.add(validationError);
+                }
+             return new ResponseEntity<>(errorDetail, HttpStatus.BAD_REQUEST);
+          }
+}
 
-    @ExceptionHandler(ResourceNotFoundException .class)
-    public ResponseEntity<?> handleResourceNotFoundException(ResourceNotFoundException rnfe, HttpServletRequest request) {
-        return new ResponseEntity<>(null,  HttpStatus.NOT_FOUND );
-    }
-    }
 

src/main/java/io/zipcoder/tc_spring_poll_application/dtos/VoteResult.java

     }
 
     public void setResults(Collection<OptionCount> results) {
+
         this.results = results;
     }
+    public OptionCount getOptionCount(OptionCount optionCount){
+               if(results.size() > 0) {
+                      for (OptionCount optionCount1 : results) {
+                          if (optionCount.getOptionId().equals(optionCount1.getOptionId())) {
+                                    return optionCount1;
+                               }
+                        }
+                 }
+             return null;
+          }
+
+           public void addOptionCount(OptionCount optionCount){
+            results.add(optionCount);
+         }
 }

src/main/java/io/zipcoder/tc_spring_poll_application/error/MethodAr1gumentNotValidException.java

 package io.zipcoder.tc_spring_poll_application.error;
 
 public class MethodAr1gumentNotValidException extends Throwable {
-}
+
+}

src/main/java/io/zipcoder/tc_spring_poll_application/error/RestExceptionHandler.java

 package io.zipcoder.tc_spring_poll_application.error;
 
-public @interface RestExceptionHandler {
+import io.zipcoder.tc_spring_poll_application.dtos.ErrorDetail;
+import io.zipcoder.tc_spring_poll_application.exception.ResourceNotFoundException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+@RestController
+public class RestExceptionHandler {
+
+    @Autowired
+   private  MessageSource messageSource;
+
+   @ExceptionHandler(ResourceNotFoundException.class)
+    public ResponseEntity<?> handleResourceNotFoundException(ResourceNotFoundException rnfe, HttpServletRequest request){
+            ErrorDetail errorDetail = new ErrorDetail();
+              errorDetail.setDetail(rnfe.getCause().toString());
+              errorDetail.setTitle(rnfe.getMessage());
+               errorDetail.setDeveloperMessage(rnfe.getLocalizedMessage());
+               errorDetail.setTimeStamp(new Date().getTime());
+               return new ResponseEntity<>(errorDetail, HttpStatus.NOT_FOUND);
+          }
+   @ExceptionHandler(MethodArgumentNotValidException.class)
+           public ResponseEntity<?> handleValidationError(  MethodArgumentNotValidException manve, HttpServletRequest request) {
+              ErrorDetail errorDetail = new ErrorDetail();
+              List<FieldError> fieldErrors = manve.getBindingResult().getFieldErrors();
+               for (FieldError fe : fieldErrors) {
+                      List<ValidationError> validationErrorList = errorDetail.getErrors().get(fe.getField());
+                     if (validationErrorList == null) {
+                           validationErrorList = new ArrayList<>();
+                              errorDetail.getErrors().put(fe.getField(), validationErrorList);
+                          }
+                     ValidationError validationError = new ValidationError();
+                      validationError.setCode(fe.getCode());
+                     validationError.setMessage(messageSource.getMessage(fe, null));
+                     validationErrorList.add(validationError);
+                 }
+               return new ResponseEntity<>(errorDetail, HttpStatus.BAD_REQUEST);
+          }
 }

src/main/java/io/zipcoder/tc_spring_poll_application/error/Validationerrorhandler.java

 
 //@RestExceptionHandler
 public class Validationerrorhandler<RestExceptionHandler> {
-    @Autowired
-
-    private  MessageSource  messageSource ;
-    @ExceptionHandler(MethodAr1gumentNotValidException.class)
-
-
-
-
-    public ResponseEntity<?>
-    handleValidationError(  MethodArgumentNotValidException manve,
-                            HttpServletRequest request){
-
-
-
-        List<FieldError> fieldErrors =  manve .getBindingResult().getFieldErrors();
-        for(FieldError fe : fieldErrors) {
-
-            ErrorDetail  errorDetail=new ErrorDetail() ;
-
-            List<ValidationError> validationErrorList = errorDetail.getErrors().get(fe.getField());
-
-            if(validationErrorList == null) {
-                validationErrorList = new ArrayList<>();
-
-                errorDetail.getErrors().put(fe.getField(), validationErrorList);
-            }
-
-            ValidationError validationError = new ValidationError();
-            validationError.setCode(fe.getCode());
-            validationError.setMessage(messageSource.getMessage(fe, null));
-            validationErrorList.add(validationError);
-        }
-        ResponseEntity responseEntity = new ResponseEntity<>( HttpStatus.BAD_REQUEST);
-        return responseEntity;
-    }
+//    @Autowired
+//
+//    private  MessageSource  messageSource ;
+//    @ExceptionHandler(MethodAr1gumentNotValidException.class)
+//
+//
+//
+//
+//    public ResponseEntity<?>
+//    handleValidationError(  MethodArgumentNotValidException manve,
+//                            HttpServletRequest request){
+//
+//
+//
+//        List<FieldError> fieldErrors =  manve .getBindingResult().getFieldErrors();
+//        for(FieldError fe : fieldErrors) {
+//
+//            ErrorDetail  errorDetail=new ErrorDetail() ;
+//
+//            List<ValidationError> validationErrorList = errorDetail.getErrors().get(fe.getField());
+//
+//            if(validationErrorList == null) {
+//                validationErrorList = new ArrayList<>();
+//
+//                errorDetail.getErrors().put(fe.getField(), validationErrorList);
+//            }
+//
+//            ValidationError validationError = new ValidationError();
+//            validationError.setCode(fe.getCode());
+//            validationError.setMessage(messageSource.getMessage(fe, null));
+//            validationErrorList.add(validationError);
+//        }
+//        ResponseEntity responseEntity = new ResponseEntity<>( HttpStatus.BAD_REQUEST);
+//        return responseEntity;
+//    }
     }
 
 

src/main/resources/import.sql

+insert into poll (poll_id, question) values (1, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (1, 'Red', 1);
+
+
+
+insert into poll (poll_id, question) values (2, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (2, 'Red', 2);
+
+
+insert into poll (poll_id, question) values (3, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (3, 'Red', 3);
+
+insert into poll (poll_id, question) values (4, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (4, 'Red', 4);
+
+insert into poll (poll_id, question) values (5, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (5, 'Red', 5);
+
+insert into poll (poll_id, question) values (6, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (6, 'Red', 6);
+
+insert into poll (poll_id, question) values (7, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (7, 'Red', 7);
+
+insert into poll (poll_id, question) values (8, 'What is your favorite color?');
+
+insert into option (option_id, option_value, poll_id) values (8, 'Red', 8);

src/main/resources/message.properties

 spring.datasource.url=jdbc:h2:mem:testdb;Mode=Oracle
 spring.datasource.platform=h2
 spring.jpa.hibernate.ddl-auto=none
-spring.datasource.continue-on-error=true
+spring.datasource.continue-on-error=true
+
+NotEmpty.poll.question=Question is a required field
+
+Size.poll.options=Options must be greater than {2} and less than {1}