RemoteService

cloud/src/main/java/edu/prlab/tyler/iotgateway/cloud/services/CrudService.java

@@ -14,13 +14,13 @@ public abstract class CrudService<T, ID> {
     public Optional<T> add(T pojo) {
         System.out.println("save" + pojo.toString());
         return Optional.of(repository.save(pojo));
-        }
+    }
 
-public Optional<T> read(ID id) {
+    public Optional<T> read(ID id) {
         return repository.findById(id);
-        }
+    }
 
-public Iterable<T> readll() {
+    public Iterable<T> readll() {
         return repository.findAll();
-        }
-        }
+    }
+}

cloud/src/main/java/edu/prlab/tyler/iotgateway/cloud/services/SensitiveUserService.java

@@ -8,7 +8,7 @@ import org.springframework.stereotype.Service;
 import java.util.Optional;
 
 @Service
-public class SensitiveUserService  {
+public class SensitiveUserService {
     private SensitiveUserRepository repository;
 
     @Autowired
@@ -17,6 +17,6 @@ public class SensitiveUserService  {
     }
 
     public Optional<User> add(User pojo) {
-        return Optional.of(repository.saveAndFlush(pojo));
+        return Optional.of(repository.save(pojo));
     }
 }

gateway/src/main/java/edu/prlab/tyler/iotgateway/gateway/controllers/GatewayController.java

@@ -58,7 +58,7 @@ public class GatewayController {
     //設定隱私選擇
     @PostMapping("/choice")
     public ResponseEntity<PrivacyChoiceResponse> setPrivacyChoice(@RequestBody PrivacyChoice privacyChoice) {
-        return privacyService.setPrivacyPolicyChoice(privacyChoice)
+        return privacyService.setPrivacyChoice(privacyChoice)
                 .map(ResponseEntity::ok)
                 .orElseGet(() -> ResponseEntity.noContent().build());
     }
@@ -68,7 +68,7 @@ public class GatewayController {
     //暫時從DB撈，無特定使用者
     @GetMapping("/choice")
     public ResponseEntity<Iterable<PrivacyChoiceResponse>> readPrivacyChoiceRecordsByUser() {
-        return Optional.of(privacyService.getPrivacyPolicyChoices())
+        return privacyService.getPrivacyPolicyChoices()
                 .map(ResponseEntity::ok)
                 .orElseGet(() -> ResponseEntity.noContent().build());
     }

gateway/src/main/java/edu/prlab/tyler/iotgateway/gateway/model/PrivacyChoiceResponse.java

 package edu.prlab.tyler.iotgateway.gateway.model;
 
-import edu.prlab.tyler.iotgateway.cloud.pojo.privacy.PrivacyContent;
+import edu.prlab.tyler.iotgateway.cloud.pojo.privacy.PrivacyChoice;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -15,5 +15,5 @@ import java.time.LocalDateTime;
 public class PrivacyChoiceResponse {
     private long id;
     private LocalDateTime localDateTime;
-    private PrivacyContent privacyContent;
+    private PrivacyChoice privacyChoice;
 }

gateway/src/main/java/edu/prlab/tyler/iotgateway/gateway/services/DeviceService.java

 package edu.prlab.tyler.iotgateway.gateway.services;
 
 import edu.prlab.tyler.iotgateway.cloud.pojo.device.Device;
-import edu.prlab.tyler.iotgateway.gateway.pojo.DeviceIndex;
 import edu.prlab.tyler.iotgateway.gateway.repositories.DeviceIndexRepository;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.core.ParameterizedTypeReference;
-import org.springframework.http.HttpMethod;
 import org.springframework.stereotype.Service;
-import org.springframework.web.client.RestTemplate;
 
 import java.util.Optional;
 
 @Service
 public class DeviceService {
-    private RestTemplate template;
 
-    DeviceIndexRepository deviceIndexRepository;
-    private String cloudAddress;
+    private DeviceIndexRepository deviceIndexRepository;
+    private RemoteService remoteService;
 
     @Autowired
-    public DeviceService(DeviceIndexRepository deviceIndexRepository,
-                         RestTemplate template) {
+    public DeviceService(DeviceIndexRepository deviceIndexRepository, RemoteService remoteService) {
         this.deviceIndexRepository = deviceIndexRepository;
-        this.template = template;
-    }
-
-    @Value("${iotgateway.cloud.address}")
-    private void setCloudAddress(String cloudAddress) {
-        this.cloudAddress = cloudAddress;
+        this.remoteService = remoteService;
     }
 
     //TODO bind and read from blockchain
     public Optional<Device> bindDeviceAndGateway(String udn) {
-        return Optional.ofNullable(template.getForObject(cloudAddress + "/device/" + udn, Device.class));
-//                .map(device -> deviceIndexRepository.save(DeviceIndex.builder().udn(udn).build()));
+        return remoteService.readDevice(udn);
     }
 
     public Optional<Iterable<Device>> readDevices() {
-        return Optional.ofNullable(template.exchange(cloudAddress + "/device", HttpMethod.GET,null,
-                new ParameterizedTypeReference<Iterable<Device>>() { }).getBody());
+        return remoteService.readDevices();
     }
 
 }
\ No newline at end of file

gateway/src/main/java/edu/prlab/tyler/iotgateway/gateway/services/PrivacyService.java

@@ -6,43 +6,32 @@ import edu.prlab.tyler.iotgateway.gateway.model.PrivacyChoiceResponse;
 import edu.prlab.tyler.iotgateway.gateway.pojo.PrivacyChoiceIndex;
 import edu.prlab.tyler.iotgateway.gateway.repositories.PrivacyChoiceIndexRepository;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.core.ParameterizedTypeReference;
-import org.springframework.http.HttpMethod;
 import org.springframework.stereotype.Service;
-import org.springframework.web.client.RestTemplate;
 
 import java.time.LocalDateTime;
 import java.util.Optional;
+import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
 @Service
 public class PrivacyService {
-    private RestTemplate template;
     private PrivacyChoiceIndexRepository privacyChoiceIndexRepository;
-
-    private String cloudAddress;
+    private RemoteService remoteService;
 
     @Autowired
-    public PrivacyService(PrivacyChoiceIndexRepository privacyChoiceIndexRepository,
-                          RestTemplate template) {
-        this.template = template;
+    public PrivacyService(PrivacyChoiceIndexRepository privacyChoiceIndexRepository, RemoteService remoteService) {
         this.privacyChoiceIndexRepository = privacyChoiceIndexRepository;
-    }
-
-    @Value("${iotgateway.cloud.address}")
-    private void setCloudAddress(String cloudAddress) {
-        this.cloudAddress = cloudAddress;
+        this.remoteService = remoteService;
     }
 
     public Optional<PrivacyPolicyReport> getRelatedPrivacyPolicies(String udn) {
-        return Optional.ofNullable(template.getForObject(cloudAddress + "/privacy/" + udn, PrivacyPolicyReport.class));
+        return remoteService.readRelatedPrivacyPolicies(udn);
     }
 
-    public Optional<PrivacyChoiceResponse> setPrivacyPolicyChoice(PrivacyChoice privacyChoice) {
+    public Optional<PrivacyChoiceResponse> setPrivacyChoice(PrivacyChoice privacyChoice) {
         System.out.println("setPrivacyPolicyChoice : " + privacyChoice.toString());
         return Optional.of(privacyChoice)
-                .map(choice -> template.postForObject(cloudAddress + "/choice", choice, PrivacyChoice.class))
+                .flatMap(choice -> remoteService.setPrivacyChoice(choice))
                 .flatMap(choice -> Optional.of(privacyChoiceIndexRepository.save(PrivacyChoiceIndex.builder()
                         .id(choice.getId())
                         .localDateTime(LocalDateTime.now())
@@ -50,7 +39,7 @@ public class PrivacyService {
                         .map(choiceIndex -> PrivacyChoiceResponse.builder()
                                 .id(choice.getId())
                                 .localDateTime(LocalDateTime.now())
-                                .privacyContent(choice.getPrivacyContent())
+                                .privacyChoice(choice)
                                 .build()));
     }
 
@@ -59,32 +48,16 @@ public class PrivacyService {
 //                new ParameterizedTypeReference<Iterable<PrivacyChoice>>() { }).getBody());
 //    }
 
-    public Iterable<PrivacyChoiceResponse> getPrivacyPolicyChoices() {
-        return () -> StreamSupport.stream(
-                template.exchange(cloudAddress + "/choice", HttpMethod.GET, null,
-                        new ParameterizedTypeReference<Iterable<PrivacyChoice>>() {
-                        }).getBody().spliterator(),
-                false)
-                .map(choice -> privacyChoiceIndexRepository.findById(choice.getId())
-                        .map(choiceIndex -> PrivacyChoiceResponse.builder()
-                                .id(choiceIndex.getId())
-                                .localDateTime(choiceIndex.getLocalDateTime())
-                                .privacyContent(choice.getPrivacyContent())
-                                .build())
-                        .orElseGet(() -> new PrivacyChoiceResponse())
-                ).iterator();
+    public Optional<Iterable<PrivacyChoiceResponse>> getPrivacyPolicyChoices() {
+        return remoteService.readPrivacyChoices()
+                .map(choices -> StreamSupport.stream(choices.spliterator(), false)
+                        .map(choice -> privacyChoiceIndexRepository.findById(choice.getId())
+                                .map(choiceIndex -> PrivacyChoiceResponse.builder()
+                                        .id(choiceIndex.getId())
+                                        .localDateTime(choiceIndex.getLocalDateTime())
+                                        .privacyChoice(choice)
+                                        .build())
+                                .orElseGet(() -> new PrivacyChoiceResponse()))
+                        .collect(Collectors.toList()));
     }
-
-//    private PrivacyChoiceResponse getPrivacyChoiceResponse(PrivacyChoice choice) {
-//        return privacyChoiceIndexRepository.findById(choice.getId())
-//                .map(choiceIndex -> PrivacyChoiceResponse.builder()
-//                        .id(choiceIndex.getId())
-//                        .localDateTime(choiceIndex.getLocalDateTime())
-//                        .privacyContent(choice.getPrivacyContent())
-//                        .build())
-//                .orElseGet(() -> {
-//                    System.out.println(choice.getId() + "is not found");
-//                    return new PrivacyChoiceResponse();
-//                });
-//    }
 }

gateway/src/main/java/edu/prlab/tyler/iotgateway/gateway/services/RemoteService.java

+package edu.prlab.tyler.iotgateway.gateway.services;
+
+import edu.prlab.tyler.iotgateway.cloud.pojo.device.Device;
+import edu.prlab.tyler.iotgateway.cloud.pojo.privacy.PrivacyChoice;
+import edu.prlab.tyler.iotgateway.cloud.pojo.privacy.PrivacyPolicyReport;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+
+import java.util.Optional;
+
+@Service
+public class RemoteService {
+    private RestTemplate template;
+    private String cloudAddress;
+
+    public RemoteService(RestTemplate template) {
+        this.template = template;
+    }
+
+    @Value("${iotgateway.cloud.address}")
+    private void setCloudAddress(String cloudAddress) {
+        this.cloudAddress = cloudAddress;
+    }
+
+    public Optional<Device> readDevice(String udn) {
+        try {
+            return Optional.of(template.exchange(cloudAddress + "/device/" + udn, HttpMethod.GET, null, Device.class).getBody());
+        } catch (Exception e) {
+            System.out.println("Read device error");
+            return Optional.empty();
+        }
+    }
+
+    public Optional<Iterable<Device>> readDevices() {
+        try {
+            return Optional.of(template.exchange(cloudAddress + "/device", HttpMethod.GET, null,
+                    new ParameterizedTypeReference<Iterable<Device>>() {
+                    }).getBody());
+        } catch (Exception e) {
+            System.out.println("Read devices error");
+            return Optional.empty();
+        }
+    }
+
+    public Optional<PrivacyPolicyReport> readRelatedPrivacyPolicies(String udn) {
+        try {
+            return Optional.of(template.exchange(cloudAddress + "/privacy/" + udn, HttpMethod.GET, null,
+                    PrivacyPolicyReport.class).getBody());
+        } catch (Exception e) {
+            System.out.println("Read privacyPolicyReport error");
+            return Optional.empty();
+        }
+    }
+
+    public Optional<PrivacyChoice> setPrivacyChoice(PrivacyChoice choice) {
+        try {
+            return Optional.of(template.exchange(cloudAddress + "/choice", HttpMethod.POST, new HttpEntity(choice), PrivacyChoice.class).getBody());
+        } catch (Exception e) {
+            System.out.println("Set privacyChoice error");
+            return Optional.empty();
+        }
+    }
+
+    public Optional<Iterable<PrivacyChoice>> readPrivacyChoices() {
+        try {
+            return Optional.of(template.exchange(cloudAddress + "/choice", HttpMethod.GET, null,
+                    new ParameterizedTypeReference<Iterable<PrivacyChoice>>() {
+                    }).getBody());
+        } catch (Exception e) {
+            System.out.println("Read privacyChoice error");
+            return Optional.empty();
+        }
+    }
+}