clean up readme formatting

README.md

 
 
-# Part 1 - Domain Implementation<br>
+# Part 1 - Domain Implementation
+
 * _Domain objects_ are the backbone for an application and contain the [business logic](https://en.wikipedia.org/wiki/Business_logic).
 * Create a sub package of `io.zipcoder.tc_spring_poll_application` named `domain`.
 
 
--
 ## Part 1.1 - Create class `Option`
+
 * Create an `Option` class in the `domain` sub-package.
 * `Option` class signature is annotated with `@Entity`
 * `Option` has an `id` instance variable of type `Long`
 * Create a `getter` and `setter` for each of the respective instance variables.
 
 
--
 ## Part 1.2 - Create class `Poll`
+
 * Create a `Poll` class in the `domain` sub-package.
 * `Poll` class signature is annotated with `@Entity`
 * `Poll` has an `id` instance variable of type `Long`
 * Create a `getter` and `setter` for each of the respective instance variables.
 
 
-
--
 ## Part 1.3 - Create class `Vote`
+
 * Create a `Vote` class in the `domain` sub-package.
 * `Vote` class signature is annotated with `@Entity`
 * `Vote` has an `id` instance variable of type `Long`
 * Create a `getter` and `setter` for each of the respective instance variables.
 
 
-
-
--
--
 # Part 2 - Repository Implementation
+
 * _Repositories_ or [Data Access Objects (DAO)](https://en.wikipedia.org/wiki/Data_access_object), provide an abstraction for interacting with _datastores_.
 * Typically DAOs include an interface that provides a set of finder methods such as `findById`, `findAll`, for retrieving data, and methods to persist and delete data.
 * It is customary to have one `Repository` per `domain` object.
 * Create a sub-package of `io.zipcoder.tc_spring_poll_application` named `repositories`.
 
 
--
 ## Part 2.1 - Create interface `OptionRepository`
+
 * Create an `OptionRepository` interface in the `repositories` subpackage.
 * `OptionRepository` extends `CrudRepository<Option, Long>`
 
--
+
 ## Part 2.2 - Create interface `PollRepository`
+
 * Create a `PollRepository` interface in the `repositories` subpackage.
 * `PollRepository` extends `CrudRepository<Poll, Long>`
 
--
+
 ## Part 2.3 - Create interface `VoteRepository`
+
 * Create a `VoteRepository` interface in the `repositories` subpackage.
 * `VoteRepository` extends `CrudRepository<Vote, Long>`
 
-
-
-
-
-
--
--
 # Part 3 - Controller Implementation
+
 * _Controllers_ provides all of the necessary [endpoints](https://en.wikipedia.org/wiki/Web_API#Endpoints) to access and manipulate respective domain objects.
 	*  REST resources are identified using URI endpoints.
 * Create a sub package of `io.zipcoder.tc_spring_poll_application` named `controller`.
 
 
--
 ## Part 3.1 - Create class `PollController`
+
 * Create a `PollController` class in the `controller` sub package.
 	* `PollController` signature should be `annotated` with `@RestController`
 
 * `PollController` has a `pollRepository` instance variable of type `PollRepository`
 	* `pollRepository` should be `annotated` with `@Inject`
 
--
+
 ### Part 3.1.1 - Create `GET` request method
+
 * The method definition below supplies a `GET` request on the `/polls` endpoint which provides a collection of all of the polls available in the QuickPolls application. Copy and paste this into your `PollController` class.
 
 ```java
 
 
 
-
--
 ### Part 3.1.2 - Testing via Postman
+
 * Ensure that the `start-class` tag in your `pom.xml` encapsulates `io.zipcoder.springdemo.QuickPollApplication`
 * Open a command line and navigate to the project's root directory and run this command:
 	* `mvn spring-boot:run`
 
 
 
-
--
 ### Part 3.1.3 - Create `POST` request method
+
 * We accomplish the capability to add new polls to the `PollController` by implementing the `POST` verb functionality in a `createPoll` method:
 
 ```java
 
 
 
-
--
 ### Part 3.1.4 - Modify `createPoll`
+
 * Best practice is to convey the URI to the newly created resource using the Location HTTP header via Spring's `ServletUriComponentsBuilder` utility class. This will ensure that the client has some way of knowing the URI of the newly created Poll.
 
 ```java
 
 
 
-
--
 ### Part 3.1.5 - Create `GET` request method
+
 * The code snippet below enables us to access an individual poll.
 * The _value attribute_ in the `@RequestMapping` takes a URI template `/polls/{pollId}`.
 * The placeholder `{pollId}` along with `@PathVarible` annotation allows Spring to examine the request URI path and extract the `pollId` parameter value.
 ```
 
 
-
-
--
 ### Part 3.1.6 - Create `UPDATE` request method
+
 * The code snippet below enables us to update a poll.
 
 ```java
 ```
 
 
-
--
 ### Part 3.1.7 - Create `DELETE` request method.
 
 * The code snippet below enables us to delete a poll.
 ```
 
 
-
-
--
 ### Part 3.1.8 - Test
+
 * Restart the QuickPoll application.
 * Use Postman to execute a `POST` to `http://localhost:8080/polls/` whose request body is the `JSON` object below.
 * You can modify the request body in Postman by navigating to the `Body` tab, selecting the `raw` radio button, and selecting the `JSON` option from the text format dropdown.
 ```
 
 
--
 ## Part 3.2 - Create class `VoteController`
+
 * Following the principles used to create `PollController`, we implement the `VoteController` class.
 * Below is the code for the `VoteController` class along with the functionality to create a vote.
 * The `VoteController` uses an injected instance of `VoteRepository` to perform `CRUD` operations on Vote instances.
 ```
 
 ### Part 3.2.1 - Testing `VoteController`
+
 * To test the voting capabilities, `POST` a new Vote to the `/polls/1/votes` endpoint with the option object expressed in `JSON` below.
 * On successful request execution, you will see a Location response header with value http://localhost:8080/polls/1/votes/1.
 
 ```
 
 
-
-
--
 ### Part 3.2.2 - Modify `VoteRepository`
+
 * The method `findAll` in the `VoteRepository` retrieves all votes in a Database rather than a given poll.
 * To ensure we can get votes for a given poll, we must add the code below to our `VoteRepository`.
 
 * At runtime, Spring Data JPA replaces the `?1` placeholder with the passed-in `pollId` parameter value.
 
 
-
--
 ### Part 3.2.3 - Modify `VoteController`
+
 * Create a `getAllVotes` method in the `VoteController`
 
 
 }
 ```
 
--
--
+
 # Part 4 - Data Transfer Object (DTO) Implementation
+
 * The final piece remaining for us is the implementation of the ComputeResult resource.
 * Because we don’t have any domain objects that can directly help generate this resource representation, we implement two Data Transfer Objects or DTOs—OptionCount and VoteResult
 * Create a sub package of `java` named `dtos`
 
--
+
 ## Part 4.1 - Create class `OptionCount`
+
 * The `OptionCount` DTO contains the `ID` of the option and a count of votes casted for that option.
 
 ```java
 }
 ```
 
+
 ## Part 4.2 - Create class `VoteResult`
+
 * The `VoteResult` DTO contains the total votes cast and a collection of `OptionCount` instances.
 
 ```java
 
 
 ## Part 4.3 - Create class `ComputeResultController`
+
 * Following the principles used in creating the `PollController` and `VoteController`, we create a new `ComputeResultController` class
 
 ```java
 
 
 ## Part 4.4 - Test via Postman
+
 * Start/restart the `QuickPoll` application.
 * Using the earlier Postman requests, create a poll and cast votes on its options.
 * Ensure a JSON file with a `status` of `200` is returned by executing a `GET` request of `http://localhost:8080/computeresults?pollId=1` via Postman
 ```
 
 
-
 # Part 6 - Pagination
+
 * To optimize performance, it is important to limit the amount of data returned, especially in the case of a mobile client.
 * REST services have the ability to give clients access large datasets in manageable chunks, by splitting the data into discrete pages or _paging data_. 
 * For this lab, we will approach this by implementing the _page number pagination pattern_.
 
--
+
 ### Get Data From Page 
+
 * For example, a client wanting a blog post in page 3 of a hypothetical blog service can use a `GET` method resembling the following:
 `http://blog.example.com/posts?page=3`
 
--
+
 ### Limit Data Retrieved From Page
+
 * It is possible for the client to override the default page size by passing in a page-size parameter:
 `http://blog.example.com/posts?page=3&size=20`
 
--
+
 ### Pagination Data
+
 * Pagination-specific information includes
 	* total number of records
 	* total number of pages
     "totalRecords": 90
 }
 ```
+
 * Read more about REST pagination in Spring by clicking [here](https://dzone.com/articles/rest-pagination-spring).
 
 
--
+
 ## Part 6.1 - Load Dummy Poll Data
 
 * Create a `src/main/resource/import.sql` file with _DML statements_ for populating the database upon bootstrap. The `import.sql` should insert at least 15 polls, each with 3 or more options.
 * Restart your application.
 * Use Postman to ensure database is populated by `import.sql`.
 
--
+
 ## 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.
 * Send a `GET` request to `http://localhost:8080/polls?page=0&size=2` via Postman.