Merge pull request #139 from SwevenSoftware/develop

Incr-Utilizzo

Author: nR3D

.env

@@ -9,5 +9,8 @@ export KEYSTORE_TYPE=
 export KEYSTORE=
 export KEYSTORE_PASSWORD=
 export KEYSTORE_ALIAS=
-export SSL_ENABLED=false
+export SSL_ENABLED=0
 export SERVER_PORT=8091
+export REPORT_DIR=./reports
+# This should be commented when deploying on a real netork
+export spring_profiles_active=ganache

README.md

@@ -25,9 +25,10 @@ requests are handled properly. **Without a valid keystore the server will fail t
 #### Blockchain
 In order to save the hashes of generated reports on a blockchain network you need to:
 * Select a network to deploy your contract: you can simply use the provided *containered* solution and test the server
-  behavior trough *ganache*. Otherwise, there are a number of ethereum test network such as [Infura](https://infura.io/)
+  behavior trough *ganache*. Otherwise, you should have an endpoint to communicate to the selected ethereum network, 
+  such as [Infura](https://infura.io/);
 
-* Open an account on that particular network
+* Open an account on that particular network.
 
 once you have such information compile the file `.env`.
 An example could be the following (also included in the project)
@@ -49,8 +50,14 @@ export KEYSTORE_PASSWORD=
 export KEYSTORE_ALIAS=
 export SSL_ENABLED=false
 # server port, this will only affect the container exposed port,
-# not he internal port
+# not the internal port
 export SERVER_PORT=8091
+# existing directory where reports will be saved
+export REPORT_DIR=
+# This should be commented when deploying on a real network,
+# specifies the active profile of the application, the ganache profile is made
+# specifically to interact with ganache  
+export spring_profiles_active=ganache
 ```
 
 ### Building
@@ -66,8 +73,7 @@ Once all the prerequisites are satisfied, and the artifact is built the applicat
 #### Test container start
 This way you can test the application with a container version of mongodb and ganache cli
 ```shell
-sudo docker-compose build && \
-sudo docker-compose up
+sudo docker-compose up --build
 ```
 The containers will then be created and started. Eventually when the run ends you can dismantle the built containers 
 with

docker-compose.yml

@@ -6,6 +6,9 @@ networks:
   blockchain-net:
     driver: "bridge"
 
+volumes:
+  reports:
+
 services:
 
   mongo:
@@ -32,3 +35,7 @@ services:
     networks:
       - db-net
       - blockchain-net
+    volumes:
+      - type: bind
+        source: ${REPORT_DIR}
+        target: /reports

src/main/java/it/sweven/blockcovid/blockchain/assemblers/ReportInformationAssembler.java

@@ -0,0 +1,35 @@
+package it.sweven.blockcovid.blockchain.assemblers;
+
+import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo;
+import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.methodOn;
+
+import it.sweven.blockcovid.blockchain.controllers.ListReportsController;
+import it.sweven.blockcovid.blockchain.dto.ReportInformation;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+import org.springframework.hateoas.CollectionModel;
+import org.springframework.hateoas.EntityModel;
+import org.springframework.hateoas.server.RepresentationModelAssembler;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ReportInformationAssembler
+    implements RepresentationModelAssembler<ReportInformation, EntityModel<ReportInformation>> {
+  @Override
+  public EntityModel<ReportInformation> toModel(ReportInformation entity) {
+    return EntityModel.of(
+        entity,
+        linkTo(methodOn(ListReportsController.class).listReports(null))
+            .withRel("list_all_reports"));
+  }
+
+  @Override
+  public CollectionModel<EntityModel<ReportInformation>> toCollectionModel(
+      Iterable<? extends ReportInformation> entities) {
+    return CollectionModel.of(
+        StreamSupport.stream(entities.spliterator(), true)
+            .map(this::toModel)
+            .collect(Collectors.toList()),
+        linkTo(methodOn(ListReportsController.class).listReports(null)).withSelfRel());
+  }
+}

src/main/java/it/sweven/blockcovid/blockchain/controllers/AutomaticCleanerController.java

@@ -0,0 +1,49 @@
+package it.sweven.blockcovid.blockchain.controllers;
+
+import it.sweven.blockcovid.blockchain.services.DocumentService;
+import it.sweven.blockcovid.blockchain.services.SignRegistrationService;
+import it.sweven.blockcovid.rooms.services.RoomService;
+import java.io.IOException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Controller;
+import org.web3j.protocol.core.methods.response.TransactionReceipt;
+
+@Controller
+public class AutomaticCleanerController {
+  private final SignRegistrationService signRegistrationService;
+  private final DocumentService documentService;
+  private final RoomService roomService;
+  private final Logger logger = LoggerFactory.getLogger(AutomaticCleanerController.class);
+
+  @Autowired
+  public AutomaticCleanerController(
+      SignRegistrationService signRegistrationService,
+      DocumentService documentService,
+      RoomService roomService) {
+    this.signRegistrationService = signRegistrationService;
+    this.documentService = documentService;
+    this.roomService = roomService;
+  }
+
+  @Scheduled(cron = "0 0 0 * * *")
+  public void run() throws Exception {
+    String savedPath = documentService.generateCleanerReport(roomService.getAllRooms());
+    try {
+      TransactionReceipt receipt =
+          signRegistrationService.registerString(documentService.hashOf(savedPath));
+      String newPath = documentService.setAsVerified(savedPath);
+      logger.info(
+          "registered file "
+              + savedPath
+              + " (now "
+              + newPath
+              + ") on the blockchain on block "
+              + receipt.getBlockNumber().toString());
+    } catch (IOException exception) {
+      logger.error("Unable to open file stream for file at path: " + savedPath);
+    }
+  }
+}

src/main/java/it/sweven/blockcovid/blockchain/controllers/AutomaticUsageController.java

@@ -0,0 +1,54 @@
+package it.sweven.blockcovid.blockchain.controllers;
+
+import it.sweven.blockcovid.blockchain.services.DocumentService;
+import it.sweven.blockcovid.blockchain.services.SignRegistrationService;
+import it.sweven.blockcovid.reservations.servicies.ReservationService;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Controller;
+import org.web3j.protocol.core.methods.response.TransactionReceipt;
+
+@Controller
+public class AutomaticUsageController {
+  private final SignRegistrationService signRegistrationService;
+  private final DocumentService documentService;
+  private final ReservationService reservationService;
+  private final Logger logger = LoggerFactory.getLogger(AutomaticUsageController.class);
+
+  @Autowired
+  public AutomaticUsageController(
+      DocumentService documentService,
+      SignRegistrationService signRegistrationService,
+      ReservationService reservationService) {
+    this.signRegistrationService = signRegistrationService;
+    this.documentService = documentService;
+    this.reservationService = reservationService;
+  }
+
+  @Scheduled(cron = "0 0 0 * * *")
+  public void run() throws Exception {
+    String savedPath =
+        documentService.generateUsageReport(
+            reservationService.findByTimeInterval(
+                LocalDateTime.now().minusDays(1), LocalDateTime.now()));
+
+    try {
+      TransactionReceipt receipt =
+          signRegistrationService.registerString(documentService.hashOf(savedPath));
+      String newPath = documentService.setAsVerified(savedPath);
+      logger.info(
+          "registered file "
+              + savedPath
+              + " (now "
+              + newPath
+              + ") on the blockchain on block "
+              + receipt.getBlockNumber().toString());
+    } catch (IOException exception) {
+      logger.error("Unable to open file stream for file at path: " + savedPath);
+    }
+  }
+}

src/main/java/it/sweven/blockcovid/blockchain/controllers/BlockchainController.java

@@ -1,16 +1,17 @@
 package it.sweven.blockcovid.blockchain.controllers;
 
+import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
-import it.sweven.blockcovid.blockchain.services.BlockchainService;
-import it.sweven.blockcovid.blockchain.services.DocumentContractService;
 import it.sweven.blockcovid.blockchain.services.DocumentService;
+import it.sweven.blockcovid.blockchain.services.SignRegistrationService;
 import it.sweven.blockcovid.rooms.services.RoomService;
 import it.sweven.blockcovid.users.entities.User;
-import java.io.FileInputStream;
 import java.io.IOException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -20,29 +21,22 @@
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.server.ResponseStatusException;
-import org.web3j.crypto.Credentials;
-import org.web3j.documentcontract.DocumentContract;
 
 @RestController
-public class AdminCleanerReportController implements ReportsController {
+public class CleanerReportController implements ReportsController {
   private final RoomService roomService;
   private final DocumentService documentService;
-  private final BlockchainService blockchainService;
-  private final DocumentContractService documentContractService;
-  private final Credentials blockchainCredentials;
+  private final SignRegistrationService signRegistrationService;
+  private final Logger logger = LoggerFactory.getLogger(CleanerReportController.class);
 
   @Autowired
-  public AdminCleanerReportController(
+  public CleanerReportController(
       RoomService roomService,
       DocumentService documentService,
-      BlockchainService blockchainService,
-      DocumentContractService documentContractService,
-      Credentials blockchainCredentials) {
+      SignRegistrationService signRegistrationService) {
     this.roomService = roomService;
     this.documentService = documentService;
-    this.blockchainService = blockchainService;
-    this.documentContractService = documentContractService;
-    this.blockchainCredentials = blockchainCredentials;
+    this.signRegistrationService = signRegistrationService;
   }
 
   @GetMapping(value = "/cleaner", produces = MediaType.APPLICATION_PDF_VALUE)
@@ -59,20 +53,25 @@ public AdminCleanerReportController(
         content = @Content(schema = @Schema(implementation = void.class)))
   })
   @PreAuthorize("#submitter.isAdmin()")
-  public byte[] report(@AuthenticationPrincipal User submitter) {
+  public byte[] report(@Parameter(hidden = true) @AuthenticationPrincipal User submitter) {
     try {
       String path = documentService.generateCleanerReport(roomService.getAllRooms());
-      DocumentContract contract =
-          documentContractService.getContractByAccount(blockchainCredentials);
-      blockchainService.registerReport(contract, new FileInputStream(path));
+      logger.info("file saved at path " + path);
+      Thread registrationThread =
+          new Thread(
+              () -> {
+                try {
+                  signRegistrationService.registerString(documentService.hashOf(path));
+                  documentService.setAsVerified(path);
+                } catch (Exception exception) {
+                  logger.error("Unable to open file stream for file at path: " + path);
+                }
+              });
+      registrationThread.start();
       return documentService.readReport(path);
     } catch (IOException e) {
       throw new ResponseStatusException(
           HttpStatus.INTERNAL_SERVER_ERROR, "An error occurred while creating the report");
-    } catch (Exception e) {
-      throw new ResponseStatusException(
-          HttpStatus.INTERNAL_SERVER_ERROR,
-          "An error occurred while registering the document on the provided blockchain");
     }
   }
 }