@Override public Report generateReport(String fileInput) throws CalculateIncomeTaxException { Reader in = null; List<InputRawData> inputRawData = new ArrayList<InputRawData>(); try { in = new FileReader(fileInput); Iterable<CSVRecord> records = CSVFormat.EXCEL.withHeader().withIgnoreEmptyLines().parse(in); for (CSVRecord record : records) { String firstName = record.get("FirstName"); String lastName = record.get("LastName"); String annualSalary = record.get("AnnualSalary"); String superRate = record.get("SuperRate"); String paymentMonth = record.get("PaymentMonth"); inputRawData.add( new InputRawData(firstName, lastName, annualSalary, superRate, paymentMonth)); } } catch (FileNotFoundException fileNotFound) { fileNotFound.printStackTrace(); } catch (IOException ioException) { ioException.printStackTrace(); } finally { try { in.close(); } catch (IOException e) { e.printStackTrace(); } } return reportFactory.create(inputRawData); }
/** * Translates the given CSV content into a List of objects. * * <p>Translation of each row into its representative object is handled by the {@link * RowTranslator} provided during construction. This class only handles the generic iteration * logic and global error handling. * * <p><strong>Warning:</strong> the given CSV content is read completely into memory while * parsing. This method does not therefore support very large CSV files (i.e., 50MB+). * * @param csvReader a Reader providing the CSV content. This method will close the reader when * done. */ public TabularParseResult<T> readObjects(final Reader csvReader) { final ArrayList<TabularUploadError> errors = new ArrayList<>(); try { final List<CSVRecord> records = CSVFormat.EXCEL.parse(csvReader).getRecords(); LOGGER.debug("The CSV file has {} rows.", records.size()); if (records.isEmpty()) { errors.add(TabularUploadError.global(ValidationCodes.NO_VALUE, null, "no records")); } else { return readProcedures(records, errors); } } catch (final IOException ex) { errors.add( TabularUploadError.global( ValidationCodes.INVALID_CONTENTS, null, "Could not parse the CSV content.")); } finally { try { csvReader.close(); } catch (final IOException ex) { LOGGER.warn("Failed to close the CSV reader.", ex); } } return new TabularParseResult<>(Collections.<T>emptyList(), errors); }
public synchronized EnrichmentResultWriter open() { LOG.info("Opening result writer on file: " + outFile.getAbsolutePath()); if (outFile.exists()) { throw new RuntimeException("File already exists, stopping: " + outFile.getAbsolutePath()); } checkIfWritable(outFile); final FileWriter fileWriter; try { fileWriter = new FileWriter(outFile, true); } catch (IOException e) { throw new RuntimeException(e); } try { this.printer = new CSVPrinter( fileWriter, CSVFormat.EXCEL .withDelimiter(';') .withHeader("idRef", "isbn", "userEmail", "resultStatus", "errorMessage")); } catch (IOException e) { throw new RuntimeException("Unable to write results to CSV: " + outFile.getAbsolutePath(), e); } return this; }
/** * Returns a <code>CSVParser</code> object to access the contents of an open file, possibly * without a header row and a different data delimiter than a comma. * * <p>Each line of the file should be formatted as data separated by the delimiter passed as a * parameter and with/without a header row to describe the column names. This is useful if the * data is separated by some character other than a comma. * * @param withHeader uses first row of data as a header row only if true * @param delimiter a single character that separates one field of data from another * @return a <code>CSVParser</code> that can provide access to the records in the file one at a * time * @throws exception if this file does not represent a CSV formatted data * @throws exception if <code>delimiter.length() != 1</code> */ public CSVParser getCSVParser(boolean withHeader, String delimiter) { if (delimiter == null || delimiter.length() != 1) { throw new ResourceException( "FileResource: CSV delimiter must be a single character: " + delimiter); } try { char delim = delimiter.charAt(0); Reader input = new StringReader(mySource); if (withHeader) { return new CSVParser(input, CSVFormat.EXCEL.withHeader().withDelimiter(delim)); } else { return new CSVParser(input, CSVFormat.EXCEL.withDelimiter(delim)); } } catch (Exception e) { throw new ResourceException("FileResource: cannot read " + myPath + " as a CSV file."); } }
/** * Executa carregamento da matriz de adjacência por um arquivo CSV * * @param file Arquivo CSV * @throws IOException Problema no momento da leitura do arquivo CSV */ public void loadCsv(File file) throws IOException { Reader in = new FileReader(file); Iterable<CSVRecord> records = CSVFormat.EXCEL.parse(in); for (CSVRecord record : records) { List<Integer> linha = new ArrayList<>(); Iterator<String> linhaCsv = record.iterator(); while (linhaCsv.hasNext()) { try { linha.add(Integer.parseInt(linhaCsv.next())); } catch (NumberFormatException e) { throw new RuntimeException("Não foi possivel converter arquivo!", e); } } mapa.add(linha); } }
// obter as masterRules de cada site para cada atributo private String getMasterRule(Site site, Attribute attribute) { try (Reader in = new FileReader(Paths.PATH_INTRASITE + "/" + site.getPath() + "/result.csv")) { try (CSVParser parser = new CSVParser(in, CSVFormat.EXCEL.withHeader())) { for (CSVRecord record : parser) { if (record.get("ATTRIBUTE").equals(attribute.getAttributeID())) { if (record.get("RULE").equals("Attribute not found")) { return null; } return record.get("RULE"); } } } } catch (FileNotFoundException ex) { Logger.getLogger(CheckDistanceExpectedMapping.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(CheckDistanceExpectedMapping.class.getName()).log(Level.SEVERE, null, ex); } return null; }
public void processCsvFile(String csvFile) throws IOException { if (csvFile != null && !csvFile.isEmpty()) { fileName = csvFile; } File f = new File(getCsvPath()); CSVParser parser = CSVParser.parse(f, Charset.forName("UTF-8"), CSVFormat.EXCEL.withHeader()); for (CSVRecord record : parser) { String serialNumber = record.get("Serial Number"); boolean success = false; if (matchOnly) { MobileDeviceMatch match = findMobileDevice(serialNumber); if (match != null) { success = true; } } else { String deviceName = record.get("iPad Name"); String assetTag = record.get("Asset Tag"); String building = record.get("Building"); String room = record.get("Room"); String department = record.get("Department"); if (serialNumber != null && !serialNumber.isEmpty() && assetTag != null && !assetTag.isEmpty() && deviceName != null && !deviceName.isEmpty()) { success = updateMobileDevice(serialNumber, deviceName, assetTag, building, room, department); } else { System.out.println("bad record at line " + String.valueOf(record.getRecordNumber())); continue; } } System.out.println(serialNumber + "\t" + String.valueOf(success)); } }
public LinkedList<IRule> loadFromCsv() throws IOException { InputStream ins = this.getClass().getClassLoader().getResourceAsStream(ruleCsvPath); InputStreamReader inr = new InputStreamReader(ins); CSVParser parser = new CSVParser(inr, CSVFormat.EXCEL.withHeader()); Iterable<CSVRecord> records = parser.getRecords(); LinkedList<IRule> lst = new LinkedList<IRule>(); for (CSVRecord record : records) { Rule rule = new Rule(); RuleConditionScript ruleCondition = new RuleConditionScript(); // set conditions ruleCondition.setExpression(record.get(COLUMN_EXPRESSION)); rule.setiCondition(ruleCondition); rule.setRuleName(record.get(COLUMN_RULE_NAME)); rule.setRuleGroup(record.get(COLUMN_GROUP_NAME)); // set action RuleActionScript action = new RuleActionScript(); rule.setiAction(action); // add rule lst.add(rule); } return lst; }