diff --git a/app/calculator.R b/app/calculator.R index 2924d8a..fb80654 100644 --- a/app/calculator.R +++ b/app/calculator.R @@ -35,7 +35,8 @@ calculatorUI <- function(id){ htmlOutput("selected_var"), htmlOutput("var"), br(), - plotlyOutput("wykres") + plotlyOutput("wykres"), + uiOutput("calculatorSave") ) )%>% tagAppendAttributes(id = 'column-content') ) %>% tagAppendAttributes(id = 'row-content'), @@ -51,7 +52,8 @@ calculatorUI <- function(id){ } calculatorServer <- function(input, output, session) { - + calculatorRV <-reactiveValues(value=NULL) + calculatorTV <-reactiveValues(value=NULL) output$report <- downloadHandler( # For PDF output, change this to "report.pdf" @@ -90,9 +92,11 @@ calculatorServer <- function(input, output, session) { } z=-5.3718+0.0354*as.numeric(isolate(input$slider1))+1.6159*as.numeric(isolate(input$select1))+1.1768*as.numeric(isolate(input$select2))+0.0697*p+0.9586*as.numeric(isolate(input$select3))-2.9486*as.numeric(isolate(input$select4)) x=round(1/(1+exp(-z)),3) + calculatorRV$value<-x if(as.numeric(input$update)>0){ paste("Surowa wartość predyktora (im niższa, tym lepiej): ", strong(x)) } + }) output$var <- renderText({ @@ -106,8 +110,10 @@ calculatorServer <- function(input, output, session) { if(as.numeric(input$update)>0){ if(x>0.1){ paste("Klasa guza: ",strong("złośliwy")) + calculatorTV$value<-paste("Klasa guza: ",strong("złośliwy")) } else { paste("Klasa guza: ",strong("łagodny")) + calculatorTV$value <- paste("Klasa guza: ",strong("łagodny")) } } }) @@ -135,5 +141,62 @@ calculatorServer <- function(input, output, session) { }) + + output$calculatorSave<-renderUI({ + if(as.numeric(input$update)>0){ + + actionButton("calculatorSubmit","Zapisz") + } + + + }) + + observeEvent(input$calculatorSubmit, { + + + calculatorSave<-data.frame(slider1<-input$slider1, + select1<-input$select1, + select2<-input$select2, + slider2<-input$slider2, + select3<-input$select3, + select4<-input$select4) + + + + + calculatorParameterInts = list(list(name="parameter1",value = calculatorSave$slider1), + list(name="parameter2",value = calculatorSave$select1), + list(name="parameter3",value = calculatorSave$select2), + list(name="parameter4",value = calculatorSave$slider2), + list(name="parameter5",value = calculatorSave$select3), + list(name="parameter6",value = calculatorSave$select4)) + + prediction = list( + name = "IOTA", + parameterInts = calculatorParameterInts, + resultValue = calculatorRV$value, + resultText = calculatorTV$value + ) + + + r<-httr::POST("http://localhost:8080/api/prediction/save/ind",add_headers(Authorization=paste("Bearer",input$token,sep=" ")),body=prediction,encode = 'json') + + # SPRAWDZENIE POBIERANIA JEDNEGO I WIELU POMIAROW + # r<-httr::GET("http://localhost:8080/api/prediction/get/13",add_headers(Authorization=paste("Bearer",input$token,sep=" ")),encode = 'json') + # r<-httr::GET("http://localhost:8080/api/prediction/usersPredictions/ind",add_headers(Authorization=paste("Bearer",input$token,sep=" ")),encode = 'json') + + if (r$status_code==200){ + TRUE + }else{ + FALSE + } + print(toJSON(content(r,as = "parsed"))) + + + + + }) + + } diff --git a/app/www/style.css b/app/www/style.css index 83077bb..7448ecc 100644 --- a/app/www/style.css +++ b/app/www/style.css @@ -286,7 +286,14 @@ text-align:center; display: flex; justify-content: center; } - +#calculatorSubmit{ + align-self:center; + background-color:#028090; + color:white; + font-weight:bold; + border:none; + box-shadow: 0px 4px 4px rgb(255 255 255 / 25%); +} #submit,#loginBtn,#editSubmit{ margin-top:20px; align-self:center; diff --git a/backend/src/main/java/project/DTO/AlgorithmDTO.java b/backend/src/main/java/project/DTO/AlgorithmDTO.java new file mode 100644 index 0000000..f399c6b --- /dev/null +++ b/backend/src/main/java/project/DTO/AlgorithmDTO.java @@ -0,0 +1,23 @@ +package project.DTO; + +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.Column; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import java.io.Serializable; + +public class AlgorithmDTO implements Serializable { + + @Getter + @Setter + private int id; + + @Getter + @Setter + private String name; + + public AlgorithmDTO(){} +} diff --git a/backend/src/main/java/project/DTO/PredictionDTO.java b/backend/src/main/java/project/DTO/PredictionDTO.java new file mode 100644 index 0000000..8aae569 --- /dev/null +++ b/backend/src/main/java/project/DTO/PredictionDTO.java @@ -0,0 +1,79 @@ +package project.DTO; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import lombok.Getter; +import lombok.Setter; +import project.model.ParameterDouble; +import project.model.ParameterInt; +import project.model.Prediction; +import project.model.User; + +import javax.persistence.*; +import java.io.Serializable; +import java.time.LocalDateTime; +import java.util.List; + +public class PredictionDTO implements Serializable { + + @Getter + @Setter + private int id; + + @Getter + @Setter + private String name; + + @Getter + @Setter + private int user; + + @Getter + @Setter + private List parameterDoubles; + + @Getter + @Setter + private List parameterInts; + + @Getter + @Setter + private double resultValue; + + @Getter + @Setter + private String resultText; + + + @Getter + @Setter + private LocalDateTime localDateTime; + + public PredictionDTO(){}; + + public PredictionDTO(PredictionDTO predictionDTO){ + this.id = predictionDTO.getId(); + this.name = predictionDTO.getName(); + this.user = predictionDTO.getUser(); + this.parameterDoubles = predictionDTO.getParameterDoubles(); + this.parameterInts = predictionDTO.getParameterInts(); + this.resultValue = predictionDTO.getResultValue(); + this.resultText = predictionDTO.getResultText(); + this.localDateTime = predictionDTO.getLocalDateTime(); + + + } + + public PredictionDTO(Prediction prediction){ + this.id = prediction.getId(); + this.name = prediction.getName(); + this.user = prediction.getUser().getId(); + this.parameterDoubles = prediction.getParameterDoubles(); + this.parameterInts = prediction.getParameterInts(); + this.resultValue = prediction.getResultValue(); + this.resultText = prediction.getResultText(); + this.localDateTime = prediction.getLocalDateTime(); + + + } + +} diff --git a/backend/src/main/java/project/config/SecurityConfiguration.java b/backend/src/main/java/project/config/SecurityConfiguration.java index 53f792b..24d3ab6 100644 --- a/backend/src/main/java/project/config/SecurityConfiguration.java +++ b/backend/src/main/java/project/config/SecurityConfiguration.java @@ -1,8 +1,10 @@ package project.config; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.PropertySource; import org.springframework.http.HttpMethod; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; @@ -23,6 +25,8 @@ import java.util.Arrays; @EnableGlobalMethodSecurity(prePostEnabled = true) @EnableWebSecurity @Configuration +@EnableConfigurationProperties +@PropertySource("classpath:remote.properties") public class SecurityConfiguration extends WebSecurityConfigurerAdapter { @Autowired diff --git a/backend/src/main/java/project/controllers/PredictionController.java b/backend/src/main/java/project/controllers/PredictionController.java new file mode 100644 index 0000000..3d11144 --- /dev/null +++ b/backend/src/main/java/project/controllers/PredictionController.java @@ -0,0 +1,166 @@ +package project.controllers; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.web.bind.annotation.*; +import project.DTO.PredictionDTO; +import project.DTO.UserDTO; +import project.config.TokenHelper; +import project.model.Prediction; +import project.model.User; +import project.services.GeneratorDTO; +import project.services.PredictionService; +import project.services.UserService; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.validation.Valid; +import javax.validation.constraints.NotNull; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +@RestController +@RequestMapping("/api/prediction") +public class PredictionController { + + + @Autowired + private PredictionService predictionService; + @Autowired + private UserService userService; + + @Autowired + private GeneratorDTO generatorDTO; + + @Autowired + private TokenHelper tokenHelper; + + + + + @PreAuthorize("hasAnyAuthority('IND')") + @RequestMapping(value = "/save/ind",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE) + @ResponseBody + public Map addPrediction(@RequestBody @Valid @NotNull PredictionDTO predictionDTO, + HttpServletRequest request, + HttpServletResponse httpServletResponse){ + + + Map map = new HashMap<>(); + UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal(); + Optional user = userService.getUsersByLogin(userDetails.getUsername()); + + if (user.isPresent()) { + User currentUser = user.get(); + + Object token = request.getAttribute("token"); + + map.put("token", tokenHelper.refreshToken(token.toString())); + + predictionDTO.setUser(currentUser.getId()); + + Prediction predictionSaved = this.predictionService.savePrediction(predictionDTO); + if (predictionSaved!=null){ + map.put("prediction", new PredictionDTO(predictionSaved)); + httpServletResponse.setStatus(200); + }else{ + map.put("prediction", null); + httpServletResponse.setStatus(400); + } + + } + + else { + + map.put("message", "Błąd autoryzacji"); + httpServletResponse.setStatus(401); + + } + return map; + } + + @PreAuthorize("hasAnyAuthority('COMP','IND')") + @RequestMapping(value = "/get/{id}",method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity> getPrediction(@PathVariable int id, + HttpServletRequest request, + HttpServletResponse httpServletResponse){ + + + Map map = new HashMap<>(); + UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal(); + Optional user = userService.getUsersByLogin(userDetails.getUsername()); + + if (user.isPresent()) { + User currentUser = user.get(); + + Object token = request.getAttribute("token"); + + map.put("token", tokenHelper.refreshToken(token.toString())); + + Prediction prediction = this.predictionService.getPrediction(id); + if (prediction!=null){ + map.put("prediction", new PredictionDTO(prediction)); + return new ResponseEntity>(map, HttpStatus.ACCEPTED); + }else{ + map.put("prediction", null); + return new ResponseEntity>(map, HttpStatus.BAD_REQUEST); + } + + } + + else { + + map.put("message", "Błąd autoryzacji"); + return new ResponseEntity>(map, HttpStatus.UNAUTHORIZED); + + } + + } + + @PreAuthorize("hasAnyAuthority('IND')") + @RequestMapping(value = "/usersPredictions/ind",method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity> getUsersPredictions(HttpServletRequest request, + HttpServletResponse httpServletResponse){ + + Map map = new HashMap<>(); + UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal(); + Optional user = userService.getUsersByLogin(userDetails.getUsername()); + + if (user.isPresent()) { + User currentUser = user.get(); + + Object token = request.getAttribute("token"); + + map.put("token", tokenHelper.refreshToken(token.toString())); + + List predictions = this.predictionService.getAllPredictionsForUser(currentUser.getId()); + if (predictions!=null){ + map.put("predictions", this.generatorDTO.generatePredictionsDTO(predictions)); + return new ResponseEntity>(map, HttpStatus.ACCEPTED); + }else{ + map.put("predictions", null); + return new ResponseEntity>(map, HttpStatus.BAD_REQUEST); + } + + } + + else { + + map.put("message", "Błąd autoryzacji"); + return new ResponseEntity>(map, HttpStatus.UNAUTHORIZED); + + } + + + } + + + +} diff --git a/backend/src/main/java/project/model/Algorithm.java b/backend/src/main/java/project/model/Algorithm.java new file mode 100644 index 0000000..5833250 --- /dev/null +++ b/backend/src/main/java/project/model/Algorithm.java @@ -0,0 +1,26 @@ +package project.model; + +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.*; +import java.io.Serializable; + +@Entity +@Table(name="Algorithm") +public class Algorithm implements Serializable { + + @Getter + @Setter + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name="id",nullable=false) + private int id; + + @Getter + @Setter + @Column(name="name") + private String name; + + public Algorithm(){} +} diff --git a/backend/src/main/java/project/model/ParameterDouble.java b/backend/src/main/java/project/model/ParameterDouble.java new file mode 100644 index 0000000..182a31f --- /dev/null +++ b/backend/src/main/java/project/model/ParameterDouble.java @@ -0,0 +1,44 @@ +package project.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.*; +import java.io.Serializable; + +@Entity +@Table(name="ParameterDouble") +public class ParameterDouble implements Serializable { + + @Getter + @Setter + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name="id",nullable=false) + private int id; + + @Getter + @Setter + @Column(name="value",nullable=false) + private double value; + + @Getter + @Setter + @ManyToOne + @JoinColumn(name = "prediction",referencedColumnName = "id") +// @JsonIgnoreProperties({"name", "user","parameterDoubles","parameterInts","resultValue","resultText"}) + @JsonIgnore + private Prediction prediction; + + public ParameterDouble(double value){ + this.value=value; + } + public ParameterDouble(Prediction prediction,double value){ + this.prediction=prediction; + this.value=value; + } + public ParameterDouble(){} + +} diff --git a/backend/src/main/java/project/model/ParameterInt.java b/backend/src/main/java/project/model/ParameterInt.java new file mode 100644 index 0000000..88d334e --- /dev/null +++ b/backend/src/main/java/project/model/ParameterInt.java @@ -0,0 +1,41 @@ +package project.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.*; +import java.io.Serializable; + +@Entity +@Table(name="ParameterInt") +public class ParameterInt implements Serializable { + + @Getter + @Setter + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name="id",nullable=false) + private int id; + + @Getter + @Setter + @Column(name="value",nullable=false) + private int value; + + @Getter + @Setter + @ManyToOne + @JoinColumn(name="prediction",referencedColumnName = "id") +// @JsonIgnoreProperties({"name", "user","parameterDoubles","parameterInts","resultValue","resultText"}) + @JsonIgnore + private Prediction prediction; + + public ParameterInt(int value){ + this.value=value; + } + + public ParameterInt(){} + +} diff --git a/backend/src/main/java/project/model/Prediction.java b/backend/src/main/java/project/model/Prediction.java new file mode 100644 index 0000000..f89c6e3 --- /dev/null +++ b/backend/src/main/java/project/model/Prediction.java @@ -0,0 +1,77 @@ +package project.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import lombok.Getter; +import lombok.Setter; +import project.DTO.PredictionDTO; + +import javax.persistence.*; +import java.io.Serializable; +import java.time.LocalDateTime; +import java.util.Date; +import java.util.List; + +@Entity +@Table(name="Prediction") +public class Prediction implements Serializable { + + @Getter + @Setter + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name="id",nullable = false) + private int id; + + @Getter + @Setter + @Column(name="name",nullable=false) + private String name; + + @Getter + @Setter + @ManyToOne + @JoinColumn(name = "user_id", referencedColumnName = "id") + private User user; + + + @Getter + @Setter + @OneToMany(mappedBy = "prediction",orphanRemoval = true, cascade = CascadeType.PERSIST) + @JsonIgnore + private List parameterDoubles; + + + @Getter + @Setter + @OneToMany(mappedBy = "prediction",orphanRemoval = true, cascade = CascadeType.PERSIST) + @JsonIgnore + private List parameterInts; + + @Getter + @Setter + @Column(name="resultValue",nullable = false) + private double resultValue; + + @Getter + @Setter + @Column(name="date",nullable = false) + private LocalDateTime localDateTime; + + + @Getter + @Setter + @Column(name="resultText",nullable = false) + private String resultText; + + public Prediction(){}; + public Prediction(PredictionDTO predictionDTO){ + this.name = predictionDTO.getName(); + this.parameterDoubles = predictionDTO.getParameterDoubles(); + this.parameterInts = predictionDTO.getParameterInts(); + this.resultValue = predictionDTO.getResultValue(); + this.resultText = predictionDTO.getResultText(); + } + + + +} diff --git a/backend/src/main/java/project/model/User.java b/backend/src/main/java/project/model/User.java index 7e47c56..5bdd3d3 100644 --- a/backend/src/main/java/project/model/User.java +++ b/backend/src/main/java/project/model/User.java @@ -73,6 +73,12 @@ public class User implements Serializable { @JoinColumn(name = "role",nullable=false) private Role role; + @Getter + @Setter + @OneToMany(mappedBy = "user",orphanRemoval = true,cascade = CascadeType.PERSIST) + @JsonIgnore + private List predictions; + public User(){ } @@ -97,6 +103,7 @@ public class User implements Serializable { this.login = user.getLogin(); this.password = user.getPassword(); this.role = user.getRole(); + this.predictions = user.getPredictions(); } diff --git a/backend/src/main/java/project/repositories/ParameterDoubleRepository.java b/backend/src/main/java/project/repositories/ParameterDoubleRepository.java new file mode 100644 index 0000000..e83044d --- /dev/null +++ b/backend/src/main/java/project/repositories/ParameterDoubleRepository.java @@ -0,0 +1,10 @@ +package project.repositories; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; +import project.model.ParameterDouble; +import project.model.Role; + +@Repository +public interface ParameterDoubleRepository extends JpaRepository { +} diff --git a/backend/src/main/java/project/repositories/ParameterIntRepository.java b/backend/src/main/java/project/repositories/ParameterIntRepository.java new file mode 100644 index 0000000..35fdad3 --- /dev/null +++ b/backend/src/main/java/project/repositories/ParameterIntRepository.java @@ -0,0 +1,10 @@ +package project.repositories; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; +import project.model.ParameterInt; +import project.model.Role; + +@Repository +public interface ParameterIntRepository extends JpaRepository { +} diff --git a/backend/src/main/java/project/repositories/PredictionRepository.java b/backend/src/main/java/project/repositories/PredictionRepository.java new file mode 100644 index 0000000..0da4ac4 --- /dev/null +++ b/backend/src/main/java/project/repositories/PredictionRepository.java @@ -0,0 +1,20 @@ +package project.repositories; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; +import project.model.Prediction; +import project.model.Role; +import project.model.User; + +import java.util.List; +import java.util.Optional; + +@Repository +public interface PredictionRepository extends JpaRepository { + + @Query(value="SELECT * FROM prediction p WHERE p.user_id=:userId", nativeQuery = true) + public Optional> findByUserId(@Param("userId") int userId); + +} diff --git a/backend/src/main/java/project/services/GeneratorDTO.java b/backend/src/main/java/project/services/GeneratorDTO.java index d69263f..edd035c 100644 --- a/backend/src/main/java/project/services/GeneratorDTO.java +++ b/backend/src/main/java/project/services/GeneratorDTO.java @@ -2,11 +2,15 @@ package project.services; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import project.DTO.PredictionDTO; import project.DTO.RoleDTO; import project.DTO.UserDTO; +import project.model.Prediction; import project.model.User; import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; @Service public class GeneratorDTO implements Serializable { @@ -19,4 +23,13 @@ public class GeneratorDTO implements Serializable { return userDTO; } + public List generatePredictionsDTO( + List predictionList){ + List predictionDTOS = new ArrayList<>(); + for (Prediction prediction:predictionList) { + predictionDTOS.add(new PredictionDTO(prediction)); + } + + return predictionDTOS; + } } diff --git a/backend/src/main/java/project/services/PredictionService.java b/backend/src/main/java/project/services/PredictionService.java new file mode 100644 index 0000000..59452ff --- /dev/null +++ b/backend/src/main/java/project/services/PredictionService.java @@ -0,0 +1,13 @@ +package project.services; + +import project.DTO.PredictionDTO; +import project.model.Prediction; + +import java.util.List; + +public interface PredictionService { + + public Prediction savePrediction(PredictionDTO predictionDTO); + public Prediction getPrediction(int id); + public List getAllPredictionsForUser(int userId); +} diff --git a/backend/src/main/java/project/services/PredictionServiceImpl.java b/backend/src/main/java/project/services/PredictionServiceImpl.java new file mode 100644 index 0000000..ff08840 --- /dev/null +++ b/backend/src/main/java/project/services/PredictionServiceImpl.java @@ -0,0 +1,87 @@ +package project.services; + + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import project.DTO.PredictionDTO; +import project.model.ParameterDouble; +import project.model.ParameterInt; +import project.model.Prediction; +import project.repositories.ParameterDoubleRepository; +import project.repositories.ParameterIntRepository; +import project.repositories.PredictionRepository; + +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +@Service +public class PredictionServiceImpl implements PredictionService { + + @Autowired + private PredictionRepository predictionRepository; + + @Autowired + private ParameterIntRepository parameterIntRepository; + + @Autowired + private ParameterDoubleRepository parameterDoubleRepository; + + @Autowired + private UserServiceImpl userService; + + public Prediction savePrediction(PredictionDTO predictionDTO){ + Prediction prediction = new Prediction(predictionDTO); + prediction.setParameterDoubles(null); + prediction.setParameterInts(null); + + prediction.setLocalDateTime(LocalDateTime.now()); + + prediction.setUser(userService.getUserById(predictionDTO.getUser())); + Prediction savedPrediction = this.predictionRepository.save(prediction); + + List parameterInts = new ArrayList<>(); + List parameterDoubles = new ArrayList<>(); + + List parameterIntsDTO = predictionDTO.getParameterInts(); + List parameterDoublesDTO = predictionDTO.getParameterDoubles(); + if(parameterIntsDTO !=null){ + for (ParameterInt x:predictionDTO.getParameterInts()) { + x.setPrediction(savedPrediction); + parameterInts.add(parameterIntRepository.save(x)); + } + } + + savedPrediction.setParameterInts(parameterInts); + + if(parameterDoublesDTO != null){ + for (ParameterDouble x:predictionDTO.getParameterDoubles()) { + x.setPrediction(savedPrediction); + parameterDoubles.add(parameterDoubleRepository.save(x)); + } + } + + + savedPrediction.setParameterDoubles(parameterDoubles); +// return prediction; + return this.predictionRepository.save(savedPrediction); + + + } + public Prediction getPrediction(int id){ + Optional predictionOptional= this.predictionRepository.findById(id); + if(predictionOptional.isPresent()){ + return predictionOptional.get(); + } + return null; + } + public List getAllPredictionsForUser(int userId){ + Optional> optionalPredictions = predictionRepository.findByUserId(userId); + if(optionalPredictions.isPresent()){ + return optionalPredictions.get(); + } + return null; + } + +} diff --git a/backend/src/main/java/project/services/UserService.java b/backend/src/main/java/project/services/UserService.java index 7090978..f54f92d 100644 --- a/backend/src/main/java/project/services/UserService.java +++ b/backend/src/main/java/project/services/UserService.java @@ -1,6 +1,7 @@ package project.services; import project.DTO.UserDTO; +import project.model.Prediction; import project.model.User; import javax.servlet.http.HttpServletRequest; @@ -19,4 +20,5 @@ public interface UserService { public boolean checkIfCorrect(UserDTO userDTO,boolean edit); + } diff --git a/backend/src/main/java/project/services/UserServiceImpl.java b/backend/src/main/java/project/services/UserServiceImpl.java index d8058ce..00d2d16 100644 --- a/backend/src/main/java/project/services/UserServiceImpl.java +++ b/backend/src/main/java/project/services/UserServiceImpl.java @@ -13,6 +13,7 @@ import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.stereotype.Service; import project.DTO.UserDTO; import project.model.CustomUserDetails; +import project.model.Prediction; import project.model.User; import project.repositories.UserRepository; @@ -104,4 +105,6 @@ public class UserServiceImpl implements UserService,UserDetailsService { } + + } diff --git a/backend/src/main/resources/local.properties b/backend/src/main/resources/local.properties new file mode 100644 index 0000000..17ee235 --- /dev/null +++ b/backend/src/main/resources/local.properties @@ -0,0 +1,26 @@ +## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties) +spring.datasource.url = jdbc:postgresql://localhost:5432/takecareapp?hibernate?useUnicode=yes&characterEncoding=UTF-8 +#spring.jpa.generate-ddl=true + +#hibernate?useUnicode=yes&characterEncoding=UTF-8 + +spring.datasource.username = postgres +spring.datasource.password = postgres + +#useSSL=false + +## Hibernate Properties +# The SQL dialect makes Hibernate generate better SQL for the chosen database +spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect +spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults = false +# Hibernate ddl auto (create, create-drop, validate, update) +spring.jpa.hibernate.ddl-auto = update + + + +#Tomcat session timeout nir moze byc mniejszy niz 1 minuta +#server.servlet.session.timeout=60s + +#spring.session.store-type=jdbc +#spring.session.jdbc.initialize-schema=always +#spring.session.timeout.seconds=10 diff --git a/backend/src/main/resources/application.properties b/backend/src/main/resources/remote.properties similarity index 93% rename from backend/src/main/resources/application.properties rename to backend/src/main/resources/remote.properties index 8cbb832..ceb32c6 100644 --- a/backend/src/main/resources/application.properties +++ b/backend/src/main/resources/remote.properties @@ -6,8 +6,7 @@ spring.datasource.url = jdbc:postgresql://ec2-52-208-138-246.eu-west-1.compute.a spring.datasource.username = nxpxoyywdkzdgy spring.datasource.password = 4b0a06a3be25b34d0bf40a3be2049f779f5602e1793944643871a9a146557966 -#spring.datasource.username = postgres -#spring.datasource.password = postgres + #useSSL=false diff --git a/backend/src/test/java/project/TakeCareAppTest.java b/backend/src/test/java/project/TakeCareAppTest.java new file mode 100644 index 0000000..5a8bfc7 --- /dev/null +++ b/backend/src/test/java/project/TakeCareAppTest.java @@ -0,0 +1,4 @@ +package project; + +public class TakeCareAppTest { +} diff --git a/backend/src/test/java/project/services/PredictionServiceImplTest.java b/backend/src/test/java/project/services/PredictionServiceImplTest.java new file mode 100644 index 0000000..2c1e602 --- /dev/null +++ b/backend/src/test/java/project/services/PredictionServiceImplTest.java @@ -0,0 +1,84 @@ +package project.services; + +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.junit4.SpringRunner; +import project.DTO.PredictionDTO; +import project.DTO.UserDTO; +import project.model.ParameterDouble; +import project.model.ParameterInt; +import project.model.Prediction; +import project.repositories.PredictionRepository; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +@RunWith(SpringRunner.class) +@SpringBootTest +public class PredictionServiceImplTest { + + @Autowired + private PredictionServiceImpl predictionService; + + + public PredictionDTO generatePredictionDTO(){ + PredictionDTO predictionDTO = new PredictionDTO(); + predictionDTO.setName("Przykład"); + predictionDTO.setUser(1); + List parameterDoubles = new ArrayList<>(); + List parameterInts = new ArrayList<>(); + double[] tableDouble = {1.2,1.5,8.5,6.3,9.9,25.1}; + int[] tableInt = {7,54,3,6,8,4,33,66,85,44,1001}; + for (double x:tableDouble) { + parameterDoubles.add(new ParameterDouble(x)); + } + for (int x:tableInt) { + parameterInts.add(new ParameterInt(x)); + } + predictionDTO.setParameterInts(parameterInts); + predictionDTO.setParameterDoubles(parameterDoubles); + predictionDTO.setResultValue(0.98); + predictionDTO.setResultText("Otrzymany wynik świadczy o b. wysokim prawdopodobieństwie zachorowalności."); + + return predictionDTO; + } + + @Test + public void saveTest(){ + + PredictionDTO predictionDTO = generatePredictionDTO(); + + Prediction prediction = predictionService.savePrediction(predictionDTO); + System.out.println(prediction.getParameterInts()); + Assert.assertTrue(prediction!=null); + } + + @Test + public void getTest(){ + Prediction prediction = predictionService.getPrediction(8); + Assert.assertTrue(prediction.getName()!=null); + Assert.assertTrue(prediction.getUser()!=null); + Assert.assertTrue(prediction.getParameterDoubles()!=null); + Assert.assertTrue(prediction.getParameterInts()!=null); + Object d = prediction.getResultValue(); + Object t = prediction.getResultText(); + Assert.assertTrue(d instanceof Double); + Assert.assertTrue(t instanceof String); + + + } + + @Test + public void getAllTest(){ + List predictions = predictionService.getAllPredictionsForUser(1); + Assert.assertTrue(predictions!=null); + Assert.assertTrue(predictions.size()!=0); + + } + + +} diff --git a/backend/src/test/java/project/services/UserServiceImplTest.java b/backend/src/test/java/project/services/UserServiceImplTest.java new file mode 100644 index 0000000..1a5203e --- /dev/null +++ b/backend/src/test/java/project/services/UserServiceImplTest.java @@ -0,0 +1,36 @@ +package project.services; + +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; +import project.DTO.UserDTO; +import project.repositories.UserRepository; + +@RunWith(SpringRunner.class) +@SpringBootTest +public class UserServiceImplTest { + + @Autowired + public UserServiceImpl userServiceImpl; + + public UserDTO generateUserDTO(){ + UserDTO userDTO = new UserDTO(); + userDTO.setName(" "); + userDTO.setSurname(" "); + userDTO.setEmail(" "); + return userDTO; + } + + @Test + public void checkIfCorrectTest(){ + UserDTO userDTO = generateUserDTO(); + UserServiceImpl userService = new UserServiceImpl(); + boolean response = userService.checkIfCorrect(userDTO,false); + + Assert.assertTrue(response==false); + } +}