Code after demo

pom.xml

@@ -101,11 +101,11 @@
 			<scope>test</scope>
 		</dependency>
 
-		<!-- <dependency>
-			<groupId>org.springdoc</groupId>
-			<artifactId>springdoc-openapi-ui</artifactId>
-			<version>1.6.4</version>
-		</dependency> -->
+		<dependency>
+			<groupId>org.apache.poi</groupId>
+			<artifactId>poi-ooxml</artifactId>
+			<version>4.1.2</version>
+		</dependency>
 
 	</dependencies>
 

src/main/java/com/nisum/task/controller/BPNController.java

 package com.nisum.task.controller;
 
-import com.nisum.task.entity.ActionEnum;
 import com.nisum.task.entity.BPN;
 import com.nisum.task.service.BPNService;
+import com.nisum.task.service.FileUploadService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import java.io.IOException;
+
 @CrossOrigin(origins = "*")
 @Slf4j
 @RestController
@@ -18,6 +23,9 @@ public class BPNController {
     @Autowired
     private BPNService bPNService;
 
+    @Autowired
+    private FileUploadService fileUploadService;
+
     @PostMapping("/createBPN")
     public Mono<BPN> saveBPN(@RequestBody BPN bpn) {
         log.info("saveBPN {}",bpn);
@@ -43,6 +51,42 @@ public class BPNController {
         return bPNService.processBPN(bpn);
     }
 
+    //@PostMapping(value  ="/uploadFile",consumes="multipart/form-data")
+//    @RequestMapping(value = "/upload", method = RequestMethod.PUT) // Or POST
+//    @ResponseStatus(HttpStatus.OK)
+//    public Flux<BPN> uploadFile(@RequestParam("file") MultipartFile file) throws IOException {
+//        log.info("file upload");
+//        return fileUploadService.uploadFile(file);
+//    }
+
+    @RequestMapping(value = "/upload", method = RequestMethod.PUT,consumes="multipart/form-data")
+    @ResponseStatus(HttpStatus.OK)
+    public Flux<BPN> uploadFile(@RequestParam("file") MultipartFile file) throws IOException {
+        log.info("file upload");
+
+        // Log details of the file
+        log.info("File Name: {}", file.getOriginalFilename());
+        log.info("Content Type: {}", file.getContentType());
+        log.info("File Size: {}", file.getSize());
+
+        return fileUploadService.uploadFile(file);
+    }
+
+
+    @PostMapping("/uploadFile")
+    public ResponseEntity<BPN> uploadFiles(@RequestParam("file") MultipartFile file) {
+        String message = "";
+        try {
+            fileUploadService.save(file);
+
+            message = "Uploaded the file successfully: " + file.getOriginalFilename();
+            return ResponseEntity.status(HttpStatus.OK).body(new BPN());
+        } catch (Exception e) {
+            message = "Could not upload the file: " + file.getOriginalFilename() + ". Error: " + e.getMessage();
+            return ResponseEntity.status(HttpStatus.EXPECTATION_FAILED).body(new BPN());
+        }
+    }
+
 
 
 }

src/main/java/com/nisum/task/controller/FileUploadController.java

 package com.nisum.task.controller;
 
+
+import com.nisum.task.entity.BPN;
+import com.nisum.task.service.FileUploadService;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import reactor.core.publisher.Flux;
+
+import java.io.IOException;
+
+@CrossOrigin(origins = "*")
+@RestController
+@RequestMapping("/file")
 public class FileUploadController {
+
+    @Autowired
+    private FileUploadService fileUploadService;
+
+//    @PostMapping("/uploadFile")
+//    public Flux<BPN> uploadFile(@RequestParam("file") MultipartFile file) throws IOException {
+//        log.info("file upload");
+//        return fileUploadService.uploadFile(file);
+//    }
+
+    private static final Logger log = LoggerFactory.getLogger(FileUploadController.class);
+
+    @PostMapping("/import")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity<String> importFile(@RequestParam("file") MultipartFile file) {
+        log.info("Received file: {}", file.getOriginalFilename());
+
+        // You can perform further operations with the file, e.g., save it to the server
+        // For demonstration purposes, just log the file details
+
+        try {
+            byte[] fileBytes = file.getBytes();
+            // Perform operations with fileBytes as needed
+
+            return ResponseEntity.ok("File uploaded successfully!");
+        } catch (IOException e) {
+            log.error("Error processing the file: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Error processing the file.");
+        }
+    }
 }

src/main/java/com/nisum/task/controller/SmicController.java

+package com.nisum.task.controller;
+
+import com.nisum.task.entity.SMIC;
+import com.nisum.task.service.SmicService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+
+@CrossOrigin(origins = "*")
+@Slf4j
+@RestController
+@RequestMapping("/smic")
+public class SmicController {
+
+    @Autowired
+    private SmicService smicService;
+
+    @PostMapping("/createSMIC")
+    public Mono<SMIC> saveSMIC(@RequestBody SMIC smic) {
+        log.info("save SMIC {}",smic);
+        return smicService.saveSMIC(smic);
+    }
+
+    @GetMapping("/findById/{smicID}")
+    public Mono<SMIC> getSMIC(@PathVariable String bpnID) {
+        log.info("getSMIC {}",bpnID);
+        return smicService.findById(Long.valueOf(bpnID));
+    }
+
+    @GetMapping("/findAll")
+    public Flux<SMIC> findAllSMICs() {
+        log.info("find all");
+        return smicService.findAll();
+    }
+
+}

src/main/java/com/nisum/task/entity/BPN.java

@@ -25,5 +25,9 @@ public class BPN {
     private Date lasttEffectiveDate;
     private String bpnStatus;
     private String bpnProcessMessage;
+    private Date createdTime;
+    private Date updatedTime;
+    private String createdBy;
+    private String updatedBy;
 
 }

src/main/java/com/nisum/task/entity/SMIC.java

+package com.nisum.task.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.bson.types.ObjectId;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+import java.util.Date;
+
+
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Document
+@Data
+public class SMIC {
+    private ObjectId id;
+    private String group;
+    private String category;
+    private String smicClass ;
+    private String subClass;
+        private String fac;
+    private String forceOptCd;
+    private Date firstEffectiveDate;
+    private Date lasttEffectiveDate;
+    private Date smicDescription;
+    private Date comment;
+    private String createdBy;
+    private String updatedBy;
+    private Date createdTime;
+    private Date updatedTime;
+
+}

src/main/java/com/nisum/task/repository/SmicRepository.java

+package com.nisum.task.repository;
+
+import com.nisum.task.entity.SMIC;
+import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
+import reactor.core.publisher.Mono;
+
+public interface SmicRepository extends ReactiveMongoRepository<SMIC,Long> {
+
+    Mono<SMIC> findByGroup(String group);
+}

src/main/java/com/nisum/task/service/BPNService.java

@@ -2,8 +2,8 @@ package com.nisum.task.service;
 
 import com.nisum.task.entity.ActionEnum;
 import com.nisum.task.entity.BPN;
-import com.nisum.task.entity.BPNStatusEnum;
 import com.nisum.task.repository.BPNRepository;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
@@ -12,16 +12,25 @@ import reactor.core.publisher.Mono;
 import java.util.Date;
 
 @Service
+@Slf4j
 public class BPNService {
 
+    private static final String DELETE = "Deleted";
+    private static final String BLOCK = "block";
+    private static final String FORCE = "force";
+    private static final String RECALL = "recall";
+    private static final String ACTIVE = "Active";
+    private static final String IN_ACTIVE = "In Active";
+
     @Autowired
     private BPNRepository bpnRepository;
 
     public Mono<BPN> saveBPN(BPN bpn) {
-        bpn.setBpnStatus("Active");
         bpn.setFirstEffectiveDate(new Date());
-        bpn.setLasttEffectiveDate(new Date());
-        return processBPN(bpn).then(bpnRepository.save(bpn));
+        bpn.setCreatedTime(new Date());
+        bpn.setUpdatedTime(new Date());
+        log.info("bpn {} ", bpn);
+        return processBPN(bpn).flatMap(bpn1 -> bpnRepository.save(bpn1));
     }
 
     public Mono<BPN> findById(Long bpnId) {
@@ -37,29 +46,42 @@ public class BPNService {
         return Mono.just(bpnObject).flatMap(bpn2 -> {
             if (bpn2.getForceOptCd().equalsIgnoreCase(ActionEnum.BLOCK.name())) {
                 return bpnRepository.findByBpn(bpn2.getBpn())
-                        .flatMap(bpn1 -> {
-                            if (bpn2.getForceOptCd().equalsIgnoreCase(BPNStatusEnum.DELETED.name())) {
-                                bpn1.setBpnProcessMessage("BPN is Deleted already, Can't block it");
-                                return Mono.just(bpn1);
-                            } else {
-                                bpn1.setBpnProcessMessage("Blocked Successfully");
-                                return Mono.just(bpn1);
-                            }
-                        });
+                        .flatMap(bpn1 -> Mono.just(setAllFields(bpn1, bpn2, "BPN Blocked successfully", bpn2.getForceOptCd())))
+                        .switchIfEmpty(Mono.defer(() -> {
+                            bpn2.setBpnProcessMessage("Blocked Successfully");
+                            bpn2.setBpnStatus(bpn2.getForceOptCd());
+                            return Mono.just(bpn2);
+                        }));
             } else if (bpn2.getForceOptCd().equalsIgnoreCase(ActionEnum.FORCE.name())) {
                 return bpnRepository.findByBpn(bpn2.getBpn())
-                        .flatMap(bpn1 -> {
-                            if (bpn2.getForceOptCd().equalsIgnoreCase(BPNStatusEnum.DELETED.name())) {
-                                bpn1.setBpnProcessMessage("BPN is Deleted already, Can't block it");
-                                return Mono.just(bpn1);
-                            } else {
-                                bpn1.setBpnProcessMessage("BPN Forced successfully");
-                                return Mono.just(bpn1);
-                            }
-                        });
+                        .flatMap(bpn1 -> Mono.just(setAllFields(bpn1, bpn2, "BPN Forced successfully", bpn2.getForceOptCd())))
+                        .switchIfEmpty(Mono.defer(() -> {
+                            bpn2.setBpnProcessMessage("BPN Forced successfully");
+                            bpn2.setBpnStatus(bpn2.getForceOptCd());
+                            return Mono.just(bpn2);
+                        }));
+            } else if (bpn2.getForceOptCd().equalsIgnoreCase(ActionEnum.RECALL.name())) {
+                return bpnRepository.findByBpn(bpn2.getBpn()).
+                        flatMap(bpn -> Mono.just(setAllFields(bpn, bpn2, "BPN Recalled successfully", bpn2.getForceOptCd())))
+                        .switchIfEmpty(Mono.defer(() -> {
+                            bpn2.setBpnProcessMessage("BPN Recalled successfully");
+                            bpn2.setBpnStatus(bpn2.getForceOptCd());
+                            return Mono.just(bpn2);
+                        }));
             } else {
                 return Mono.just(bpn2);
             }
         });
     }
+
+    private BPN setAllFields(BPN bpnDB, BPN uiBPN, String message, String status) {
+        bpnDB.setBpnStatus(status);
+        bpnDB.setLasttEffectiveDate(uiBPN.getLasttEffectiveDate());
+        bpnDB.setUpdatedTime(new Date());
+        bpnDB.setFac(uiBPN.getFac());
+        bpnDB.setForceOptCd(uiBPN.getForceOptCd());
+        bpnDB.setBpnProcessMessage(message);
+        log.info("bpnDB {}", bpnDB);
+        return bpnDB;
+    }
 }

src/main/java/com/nisum/task/service/FileUploadService.java

+package com.nisum.task.service;
+
+import com.nisum.task.entity.BPN;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.xssf.usermodel.XSSFRow;
+import org.apache.poi.xssf.usermodel.XSSFSheet;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import reactor.core.publisher.Flux;
+
+import java.io.IOException;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+@Slf4j
+public class FileUploadService {
+
+    @Autowired
+    private BPNService bpnService;
+    private final Path root = Paths.get("uploads");
+
+
+    public Flux<BPN> uploadFile(MultipartFile file) throws IOException {
+
+        List<BPN> tempBPNList = new ArrayList<>();
+        XSSFWorkbook workbook = new XSSFWorkbook(file.getInputStream());
+        XSSFSheet worksheet = workbook.getSheetAt(0);
+
+        for (int i = 1; i < worksheet.getPhysicalNumberOfRows(); i++) {
+            BPN tempBPN = new BPN();
+
+            XSSFRow row = worksheet.getRow(i);
+            tempBPN.setBpn(String.valueOf(row.getCell(0)));
+            tempBPN.setForceOptCd(String.valueOf(row.getCell(1)));
+            tempBPNList.add(tempBPN);
+        }
+        log.info("Data {}",tempBPNList);
+        return Flux.empty();
+    }
+
+    public void save(MultipartFile file) {
+        try {
+            Files.createDirectories(root);
+
+            Files.copy(file.getInputStream(), this.root.resolve(file.getOriginalFilename()));
+        } catch (Exception e) {
+            if (e instanceof FileAlreadyExistsException) {
+                throw new RuntimeException("A file of that name already exists.");
+            }
+
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+
+}

src/main/java/com/nisum/task/service/SmicService.java

+package com.nisum.task.service;
+
+import com.nisum.task.entity.SMIC;
+import com.nisum.task.repository.SmicRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Date;
+
+@Service
+public class SmicService {
+
+    private static final String DELETE = "Deleted";
+    private static final String BLOCK = "block";
+    private static final String FORCE = "force";
+    private static final String RECALL = "recall";
+
+    @Autowired
+    private SmicRepository smicRepository;
+
+    public Mono<SMIC> saveSMIC(SMIC smic) {
+        smic.setFirstEffectiveDate(new Date());
+        smic.setCreatedTime(new Date());
+        smic.setUpdatedTime(new Date());
+        return smicRepository.save(smic);
+    }
+
+    public Mono<SMIC> findById(Long bpnId) {
+        return smicRepository.findById(bpnId);
+    }
+
+    public Flux<SMIC> findAll() {
+        return smicRepository.findAll();
+    }
+
+    private SMIC setAllFields(SMIC smicDB, SMIC uiSMIC, String message) {
+        smicDB.setLasttEffectiveDate(uiSMIC.getLasttEffectiveDate());
+        smicDB.setUpdatedTime(new Date());
+        smicDB.setFac(uiSMIC.getFac());
+        smicDB.setForceOptCd(uiSMIC.getForceOptCd());
+        return smicDB;
+    }
+}

src/main/resources/application.properties

@@ -16,3 +16,11 @@ database.host = mongodb://localhost:27017/
 #springdoc.api-docs.path=/swagger-doc/v3/api-docs
 
 #spring.main.web-application-type=none
+
+spring.http.multipart.file-size-threshold:20MB
+spring.http.multipart.location:""
+spring.http.multipart.max-file-size:20MB
+spring.http.multipart.max-request-size:20MB
+
+spring.servlet.multipart.max-file-size=1MB
+spring.servlet.multipart.max-request-size=1MB