1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
public static void main(String[] args) { Map<String, Integer> fieldMapping = Map.of( "therapyType", 0, "state", 1, "age", 2 ); RuleMapper<Rule> ruleMapper = new RuleMapper<>(); // Assuming you have raw data (e.g., from an Excel file) InputStream inputStream = /* ... */; List<Rule> rules = ruleMapper.mapDataToObjects(inputStream, Rule.class, fieldMapping); // Now you have a list of Rule objects populated with data } // Define your generic Rule class class Rule { private String therapyType; private String state; private int age; // Constructors, getters, setters, etc. } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
import org.apache.poi.ss.usermodel.*; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.List; import java.util.function.Function; public class RuleMapper<T> { public List<T> mapDataToObjects(InputStream inputStream, Class<T> objectType, Map<String, Integer> fieldMapping) { List<T> objects = new ArrayList<>(); try (Workbook workbook = new XSSFWorkbook(inputStream)) { // Use XSSFWorkbook for .xlsx files FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator(); Sheet sheet = workbook.getSheetAt(0); // Assuming data is in the first sheet for (Row row : sheet) { T object = createObjectFromRow(row, objectType, fieldMapping); objects.add(object); } } catch (IOException e) { e.printStackTrace(); // Handle exceptions (e.g., invalid file format, missing columns) } return objects; } private T createObjectFromRow(Row row, Class<T> objectType, Map<String, Integer> fieldMapping) { try { T object = objectType.getDeclaredConstructor().newInstance(); for (Map.Entry<String, Integer> entry : fieldMapping.entrySet()) { String fieldName = entry.getKey(); int columnIndex = entry.getValue(); setFieldValue(object, fieldName, getStringCellValue(row, columnIndex)); } return object; } catch (Exception e) { e.printStackTrace(); // Handle exceptions (e.g., reflection errors) return null; } } private void setFieldValue(T object, String fieldName, String value) { try { object.getClass().getDeclaredField(fieldName).set(object, value); } catch (Exception e) { e.printStackTrace(); // Handle exceptions (e.g., field not found) } } private String getStringCellValue(Row row, int columnIndex) { Cell cell = row.getCell(columnIndex, Row.MissingCellPolicy.RETURN_BLANK_AS_NULL); return (cell != null) ? cell.getStringCellValue() : ""; } } |
1 2 3 4 5 6 7 8 |
{ ruleIdentifier: "rule1", fieldMappings: { therapyType: "type1", state: "state1", age: "age1" } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 |
// Rule.java (Model) public class Rule { private String therapyType; private String state; private int age; // Getters and setters } // BulkUploadConfig.java (Model for template mapping) public class BulkUploadConfig { private String ruleIdentifier; private Map<String, String> fieldMappings; // Getters and setters } // RuleRepository.java public interface RuleRepository extends MongoRepository<Rule, String> { // Custom database operations if needed } // BulkUploadConfigRepository.java public interface BulkUploadConfigRepository extends MongoRepository<BulkUploadConfig, String> { Optional<BulkUploadConfig> findByRuleIdentifier(String ruleIdentifier); } // BulkUploadRuleService.java @Service public class BulkUploadRuleService { private final RuleRepository ruleRepository; private final BulkUploadConfigRepository bulkUploadConfigRepository; @Autowired public BulkUploadRuleService(RuleRepository ruleRepository, BulkUploadConfigRepository bulkUploadConfigRepository) { this.ruleRepository = ruleRepository; this.bulkUploadConfigRepository = bulkUploadConfigRepository; } public String processFile(MultipartFile file, String ruleIdentifier) { // Fetch the template mapping from the database BulkUploadConfig config = bulkUploadConfigRepository.findByRuleIdentifier(ruleIdentifier) .orElseThrow(() -> new RuntimeException("No template mapping found for the provided rule identifier.")); // Parse the file and convert it into a List of Rule objects List<Rule> rules; try { rules = parseFile(file); } catch (Exception e) { return "Error: Failed to parse the file."; } // Validate the fields against the fieldMappings if (!validateFields(rules, config.getFieldMappings())) { return "Error: The fields in the uploaded file do not match the expected template mapping. Process aborted."; } // Save all rules to the database ruleRepository.saveAll(rules); return "Success: All rules have been uploaded successfully."; } private List<Rule> parseFile(MultipartFile file) { // Implement file parsing logic // This should return a List<Rule> after parsing the Excel file return new ArrayList<>(); } private boolean validateFields(List<Rule> rules, Map<String, String> fieldMappings) { for (Rule rule : rules) { String compositeKey = rule.getTherapyType() + "|" + rule.getState() + "|" + rule.getAge(); String[] fields = compositeKey.split("\\|"); if (fields.length != fieldMappings.size() || !fields[0].equals(rule.getTherapyType()) || !fields[1].equals(rule.getState()) || !fields[2].equals(String.valueOf(rule.getAge()))) { return false; // Fields do not match } } return true; // All fields match } } // BulkUploadRuleController.java @RestController public class BulkUploadRuleController { private final BulkUploadRuleService bulkUploadRuleService; @Autowired public BulkUploadRuleController(BulkUploadRuleService bulkUploadRuleService) { this.bulkUploadRuleService = bulkUploadRuleService; } @PostMapping("/api/rules/upload") public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file, @RequestParam("ruleIdentifier") String ruleIdentifier) { String result = bulkUploadRuleService.processFile(file, ruleIdentifier); if (result.startsWith("Error")) { return ResponseEntity.badRequest().body(result); } return ResponseEntity.ok(result); } } |