diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java index b30a252..d442d01 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java @@ -29,7 +29,7 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("test password", savedAccount.getPassword()); - assertTrue(savedAccount.isAdministratorStatus()); + assertTrue(savedAccount.getAdministratorStatus()); savedAccount.setPassword("Test Update"); @@ -37,7 +37,7 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); - assertTrue(savedAccount.isAdministratorStatus()); + assertTrue(savedAccount.getAdministratorStatus()); assertEquals(updatedAccount.getId(), id); accountsRepository.delete(accountDto); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java index 25f5368..2f60c56 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java @@ -14,6 +14,8 @@ import org.springframework.web.bind.annotation.*; import javax.validation.Valid; import javax.validation.groups.Default; +import java.time.Duration; +import java.time.Instant; import java.util.List; import java.util.Optional; @@ -73,6 +75,35 @@ public class AccountController { ); } + @GetMapping("/{username}") + public @ResponseBody + ResponseEntity getAccountByUsername(@PathVariable("username") final String username) { + LOG.info("Received request to query for account with username " + username); + if (username == null) { + LOG.error("ERROR: username was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for account with username " + username); + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional account = accountsRepository.findByUsername(username); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + return account.map(accountDto -> { + LOG.info("Returning account with username " + username); + return new ResponseEntity<>(accountDto, HttpStatus.OK); + }).orElseGet( + () -> { + LOG.warn("No account was found with username " + username); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + ); + } + @PostMapping("/") @Validated({AccountDto.Insert.class, Default.class}) public @ResponseBody ResponseEntity insertAccount( @@ -89,6 +120,21 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } + LOG.info("Checking for any existing users with username {}", accountDto.getUsername()); + + final Instant start = Instant.now(); + + LOG.debug("Querying for existing accounts"); + + final Optional existingAccount = accountsRepository.findByUsername(accountDto.getUsername()); + + LOG.debug("Received response from the server: query took {} ms", Duration.between(start, Instant.now()).toMillis()); + + if (existingAccount.isPresent()) { + LOG.warn("An account already exists with username {}", accountDto.getUsername()); + return new ResponseEntity<>(HttpStatus.CONFLICT); + } + LOG.debug("Saving new account"); final StopWatch stopWatch = new StopWatch(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java index 35b8a86..b68bad1 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java @@ -7,5 +7,5 @@ import org.springframework.stereotype.Component; @Component @AllArgsConstructor public class NotationController { - final private NotationRepository notationRepository; + private final NotationRepository notationRepository; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index 51e5d25..e52b209 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -7,5 +7,5 @@ import org.springframework.stereotype.Component; @Component @AllArgsConstructor public class ProofController { - final private ProofRepository proofRepository; + private final ProofRepository proofRepository; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index a75a76a..4ba293d 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -67,19 +67,19 @@ public class TheoremController { @GetMapping("/{proven_status}") public @ResponseBody - ResponseEntity> getAllTheoremsByBranch(@PathVariable("proven_status") final Boolean proven_status) { - LOG.info("Received request to query for theorems whose proven status is " + proven_status); - if (proven_status == null) { + ResponseEntity> getAllTheoremsByBranch(@PathVariable("proven_status") final Boolean provenStatus) { + LOG.info("Received request to query for theorems whose proven status is " + provenStatus); + if (provenStatus == null) { LOG.error("ERROR: branch was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Querying for theorems with proven status " + proven_status); + LOG.debug("Querying for theorems with proven status " + provenStatus); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findByProven_status(proven_status); + final List listOfTheorems = theoremRepository.findByProvenStatus(provenStatus); stopWatch.stop(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java index e253e22..0f24842 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java @@ -1,5 +1,6 @@ package edu.msudenver.tsp.persistence.dto; +import com.fasterxml.jackson.annotation.JsonProperty; import lombok.Data; import lombok.EqualsAndHashCode; import org.springframework.data.jpa.domain.support.AuditingEntityListener; @@ -18,15 +19,35 @@ import java.util.Date; public class AccountDto extends BaseDto implements Serializable { @NotBlank(groups = Insert.class, message = "A username must be specified") @Size(max = 50) private String username; @NotBlank(groups = Insert.class, message = "A password must be specified") @Size(max = 256) private String password; - @NotNull private boolean administrator_status; - @Temporal(TemporalType.DATE) private Date last_login; + @NotNull private boolean administratorStatus; + @Temporal(TemporalType.DATE) private Date lastLogin; private static final long serialVersionUID = 7095627971593953734L; + @JsonProperty("administrator_status") + public boolean getAdministratorStatus() { + return administratorStatus; + } + + @JsonProperty("administrator_status") + public void setAdministratorStatus(final boolean administratorStatus) { + this.administratorStatus = administratorStatus; + } + + @JsonProperty("last_login") + public Date getLastLogin() { + return lastLogin; + } + + @JsonProperty("last_login") + public void setLastLogin(final Date lastLogin) { + this.lastLogin = lastLogin; + } + public interface Insert {} @PrePersist public void prePersist() { - last_login = new Date(); + lastLogin = new Date(); } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index c6b6a31..e28a5e3 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -1,5 +1,6 @@ package edu.msudenver.tsp.persistence.dto; +import com.fasterxml.jackson.annotation.JsonProperty; import lombok.Data; import lombok.EqualsAndHashCode; import org.hibernate.annotations.Type; @@ -20,11 +21,41 @@ import java.util.List; @EqualsAndHashCode(callSuper = true) public class TheoremDto extends BaseDto implements Serializable { @NotBlank @Size(min = 1, max = 512, message = "theorem name must be between 1 and 512 characters") private String name; - @NotNull private TheoremType theorem_type; + @NotNull private TheoremType theoremType; @NotNull(message = "a branch of mathematics that this theorem is associated with must be specified") private String branch; - @Type(type = "json") @Column(columnDefinition = "jsonb") private List referenced_definitions; - @Type(type = "json") @Column(columnDefinition = "jsonb") private List referenced_theorems; - @NotNull private boolean proven_status; + @Type(type = "json") @Column(columnDefinition = "jsonb") private List referencedDefinitions; + @Type(type = "json") @Column(columnDefinition = "jsonb") private List referencedTheorems; + @NotNull private boolean provenStatus; + + @JsonProperty("theorem_type") + public TheoremType getTheoremType() { + return theoremType; + } + + @JsonProperty("theorem_type") + public void setTheoremType(final TheoremType theoremType) { + this.theoremType = theoremType; + } + + @JsonProperty("referenced_definitions") + public List getReferencedDefinitions() { + return referencedDefinitions; + } + + @JsonProperty("referenced_definitions") + public void setReferencedDefinitions(final List referencedDefinitions) { + this.referencedDefinitions = referencedDefinitions; + } + + @JsonProperty("referenced_theorems") + public List getReferencedTheorems() { + return referencedTheorems; + } + + @JsonProperty("referenced_theorems") + public void setReferencedTheorems(final List referencedTheorems) { + this.referencedTheorems = referencedTheorems; + } private static final long serialVersionUID = 1545568391140364425L; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java index 454cd77..add1182 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java @@ -4,6 +4,9 @@ import edu.msudenver.tsp.persistence.dto.AccountDto; import org.springframework.data.repository.CrudRepository; import org.springframework.stereotype.Repository; +import java.util.Optional; + @Repository public interface AccountsRepository extends CrudRepository { + Optional findByUsername(String username); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 2561bc9..75df2ee 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -11,5 +11,5 @@ public interface TheoremRepository extends JpaRepository { List findByBranch(String branch); - List findByProven_status(Boolean proven_status); + List findByProvenStatus(Boolean provenStatus); } diff --git a/persistence/src/main/resources/application.properties b/persistence/src/main/resources/application.properties index 0068dff..c7ecc80 100644 --- a/persistence/src/main/resources/application.properties +++ b/persistence/src/main/resources/application.properties @@ -1,6 +1,6 @@ spring.jpa.hibernate.ddl-auto = none spring.jpa.database=mysql -spring.datasource.url=jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false +spring.datasource.url=jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false&serverTimezone=UTC spring.datasource.username=panda spring.datasource.password=secret spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java index 0b88630..a66a12a 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java @@ -87,10 +87,48 @@ public class AccountControllerTest { verify(accountsRepository).findById(anyInt()); } + @Test + public void testGetAccountByUsername() { + final AccountDto accountDto = createAccount(); + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.ofNullable(accountDto)); + + final ResponseEntity responseEntity = accountController.getAccountByUsername("Test username"); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(accountDto, responseEntity.getBody()); + verify(accountsRepository).findByUsername(anyString()); + } + + @Test + public void testGetAccountById_nullUsername() { + final ResponseEntity responseEntity = accountController.getAccountByUsername(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + @Test + public void testGetAccountByUsername_noAccountFound() { + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = accountController.getAccountByUsername("Test username"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + verify(accountsRepository).findByUsername(anyString()); + } + @Test public void testInsertAccount() { final AccountDto accountDto = createAccount(); when(accountsRepository.save(any(AccountDto.class))).thenReturn(accountDto); + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.empty()); final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); @@ -102,6 +140,20 @@ public class AccountControllerTest { verify(accountsRepository).save(any(AccountDto.class)); } + @Test + public void testInsertAccount_usernameAlreadyExists() { + final AccountDto accountDto = createAccount(); + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.of(accountDto)); + + final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.CONFLICT, responseEntity.getStatusCode()); + verify(accountsRepository).findByUsername(anyString()); + verify(accountsRepository, times(0)).save(any(AccountDto.class)); + } + @Test public void testInsertAccount_accountsDtoIsNull() { final ResponseEntity responseEntity = accountController.insertAccount(null, bindingResult); diff --git a/services/build.gradle b/services/build.gradle index a53319f..05efbeb 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -19,6 +19,10 @@ repositories { dependencies { compile project(':persistence') - testCompile group: 'junit', name: 'junit', version: '4.12' + compile group: 'org.apache.httpcomponents', name: 'httpcore', version: '4.4.11' + compile group: 'org.apache.httpcomponents', name: 'fluent-hc', version: '4.5.7' + compile group: 'com.google.code.gson', name: 'gson', version: '2.7' compile fileTree(dir: 'lib', include: '**/*.jar') + + testCompile group: 'junit', name: 'junit', version: '4.12' } diff --git a/services/src/main/java/edu/msudenver/tsp/services/RestService.java b/services/src/main/java/edu/msudenver/tsp/services/RestService.java new file mode 100644 index 0000000..78f0cb9 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/RestService.java @@ -0,0 +1,100 @@ +package edu.msudenver.tsp.services; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import edu.msudenver.tsp.services.factory.RequestFactory; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.apache.http.HttpResponse; +import org.apache.http.client.fluent.Request; +import org.apache.http.util.EntityUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; + +@Slf4j +@Service +public class RestService { + private static final Gson GSON = new Gson(); + private final RequestFactory requestFactory; + + @Autowired + public RestService(final RequestFactory requestFactory) { + this.requestFactory = requestFactory; + } + + public boolean delete(final String uri, final Integer connectionTimeout, final Integer socketTimeout, final HttpStatus httpStatus) { + LOG.info("Sending DELETE {}", uri); + final Optional response = send(requestFactory.delete(uri), null, connectionTimeout, socketTimeout); + + return response.isPresent() && response.get().getStatusLine().getStatusCode() == httpStatus.value(); + } + + Optional get(final String uri, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout, final String auth) { + LOG.info("Sending GET {}", uri); + return send(requestFactory.get(uri), auth, connectionTimeout, socketTimeout, type); + } + + Optional post(final String uri, final String requestJson, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout) { + LOG.info("Sending POST {} with body: {}", uri, requestJson); + return send(requestFactory.post(uri, requestJson), null, connectionTimeout, socketTimeout, type); + } + + Optional post(final String uri, final String requestJson, final Integer connectionTimeout, final Integer socketTimeout) { + LOG.info("Sending POST {} with body: {}", uri, requestJson); + return send(requestFactory.post(uri, requestJson), null, connectionTimeout, socketTimeout); + } + + Optional put(final String uri, final String requestJson, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout, final String auth) { + LOG.info("Sending PUT {} with body: {}", uri, requestJson); + return send(requestFactory.put(uri, requestJson), auth, connectionTimeout, socketTimeout, type); + } + + private Optional send(final Request request, final String auth, final Integer connectionTimeout, final Integer socketTimeout, final TypeToken type) { + try { + final Optional optionalHttpResponse = send(request, auth, connectionTimeout, socketTimeout); + if (optionalHttpResponse.isPresent()) { + final HttpResponse httpResponse = optionalHttpResponse.get(); + LOG.info("Received {} response", httpResponse.getStatusLine().getStatusCode()); + + final String jsonResponse = httpResponse.getEntity() == null ? null : EntityUtils.toString(httpResponse.getEntity()); + if (StringUtils.isNotBlank(jsonResponse)) { + final T responses = GSON.fromJson(jsonResponse, type.getType()); + if (responses instanceof List) { + LOG.info("Found {} responses.", ((List) responses).size()); + if (((List) responses).isEmpty()) { + return Optional.empty(); + } + } + + return Optional.ofNullable(responses); + } + } + } catch (final Exception e) { + LOG.error("Could not send request", e); + } + + return Optional.empty(); + } + + private Optional send(final Request request, final String auth, final Integer connectionTimeout, final Integer socketTimeout) { + if (StringUtils.isNotBlank(auth)) { + request.addHeader("Authorization", "Basic " + auth); + } + + try { + return Optional.ofNullable(request.connectTimeout(connectionTimeout) + .socketTimeout(socketTimeout) + .execute() + .returnResponse()); + } catch (final Exception e) { + LOG.error("Could not send request", e); + return Optional.empty(); + } + } +} + + diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java new file mode 100644 index 0000000..f119441 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -0,0 +1,57 @@ +package edu.msudenver.tsp.services; + +import com.google.gson.GsonBuilder; +import com.google.gson.reflect.TypeToken; +import edu.msudenver.tsp.services.dto.Account; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; + +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; + +@Slf4j +@Service +public class UserService { + private final RestService restService; + @Value("${persistence.api.connection.timeout.milliseconds}") private int connectionTimeoutMilliseconds; + @Value("${persistence.api.socket.timeout.milliseconds}") private int socketTimeoutMilliseconds; + @Value("${persistence.api.base.url}") private String persistenceApiBaseUrl; + + @Autowired + public UserService(final RestService restService) { + this.restService = restService; + } + + public Optional createNewAccount(final Account account) { + if (account == null) { + LOG.error("Given null account, returning {}"); + return Optional.empty(); + } + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken() {}; + final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "/accounts/", + new GsonBuilder().create().toJson(account), + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to create new account {}", account.toString()); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error creating new account {}", e); + return Optional.empty(); + } finally { + LOG.info("Create new account request took {} ms", Duration.between(start, Instant.now()).toMillis()); + } + } +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java new file mode 100644 index 0000000..c82731a --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java @@ -0,0 +1,22 @@ +package edu.msudenver.tsp.services.dto; + +import com.google.gson.annotations.SerializedName; +import edu.msudenver.tsp.persistence.dto.AccountDto; + +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.Date; + +public class Account extends BaseDto implements Serializable { + @NotBlank(groups = AccountDto.Insert.class, message = "A username must be specified") @Size(max = 50) private String username; + @NotBlank(groups = AccountDto.Insert.class, message = "A password must be specified") @Size(max = 256) private String password; + @NotNull @SerializedName("administrator_status") private boolean administratorStatus; + @Temporal(TemporalType.DATE) @SerializedName("last_login") private Date lastLogin; + + private static final long serialVersionUID = 7095627971593953734L; + +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/BaseDto.java b/services/src/main/java/edu/msudenver/tsp/services/dto/BaseDto.java new file mode 100644 index 0000000..4dc5dfd --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/BaseDto.java @@ -0,0 +1,13 @@ +package edu.msudenver.tsp.services.dto; + +import lombok.Data; + +import java.io.Serializable; + +@Data +public class BaseDto implements Serializable { + private int id; + private Integer version; + + private static final long serialVersionUID = 5343705942114910963L; +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java new file mode 100644 index 0000000..726b9a8 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java @@ -0,0 +1,25 @@ +package edu.msudenver.tsp.services.factory; + +import org.apache.commons.lang3.StringUtils; +import org.apache.http.client.fluent.Request; +import org.apache.http.entity.ContentType; +import org.springframework.stereotype.Service; + +@Service +public class RequestFactory { + public Request delete(final String uri) { + return Request.Delete(uri); + } + + public Request get(final String uri) { + return Request.Get(uri); + } + + public Request post(final String uri, final String requestJson) { + return StringUtils.isNotBlank(requestJson) ? Request.Post(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Post(uri); + } + + public Request put(final String uri, final String requestJson) { + return StringUtils.isNotBlank(requestJson) ? Request.Put(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Put(uri); + } +} \ No newline at end of file diff --git a/services/src/main/resources/application.properties b/services/src/main/resources/application.properties new file mode 100644 index 0000000..ff86c7e --- /dev/null +++ b/services/src/main/resources/application.properties @@ -0,0 +1,3 @@ +persistence.api.connection.timeout.milliseconds = 5000 +persistence.api.socket.timeout.milliseconds = 10000 +persistence.api.base.url = http://localhost:8090/ \ No newline at end of file