<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">package usda.weru.weps.reports.query;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.sql.Date;
import java.sql.SQLException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.h2.tools.SimpleResultSet;

/**
 *
 * @author joelevin
 */
public abstract class WepsResultSet extends SimpleResultSet {
    
    private boolean olderRunCheck;
    
    public WepsResultSet () {
        super();
        olderRunCheck = false;
        this.setAutoClose(false);
        WepsResultSet.dateWepsLogger = (WepsResultSet.dateWepsLogger == null) ? LogManager.getLogger(WepsResultSet.class) : WepsResultSet.dateWepsLogger;
   }


    public abstract void fill() throws SQLException;
    public abstract String getName();

    @Override
    public void close() {
        try {
            beforeFirst();
        } catch (SQLException e) {
        }
    }
    
    @Override
    public boolean next () throws SQLException {
        boolean b = super.next();
        if (!b) {
            super.beforeFirst();
        }
        return b;
    }
    
    public void dispose() {
        super.close();
    }

    /**
     * Creates a new Object array the size of the resultset getColumnCount().
     * @param add If true, the row will be added to the resultset
     * @return an empty object array.
     * @throws SQLException Upon an unexpected error. This should be very rare.
     */
    protected Object[] createNewRow(boolean add) throws SQLException {
        Object[] row = new Object[getColumnCount()];
        if (add) {
            addRow(row);
        }
        return row;
    }
    
    public void setOlderRunCheck(boolean b) {
        olderRunCheck = b;
    }

    public boolean getOlderRunCheck() {
        return olderRunCheck;
    }

    /**
     * Convenience method for adding values based on their column names. Slight
     * performance hit is to be expected, but helps prevent programming errors
     * due to future column reordering.
     * @param row
     * @param columnName column label to be resolved to the 0 based index.
     * @param value Object to store
     * @throws java.sql.SQLException
     */
    protected void setRowValue(Object[] row, String columnName, Object value) throws SQLException {
        int index = findColumn(columnName) - 1;
        row[index] = value;
    }

    protected &lt;T&gt; T getRowValue(T[] row, String columnName) throws SQLException {
        int index = findColumn(columnName) - 1;
        return row[index];
    }

    @Override
    public void addColumn(String name, int sqlType, int precision, int scale) {
        super.addColumn(name, sqlType, precision, scale);
    }

    @Override
    public void addColumn(String name, int sqlType, String sqlTypeName, int precision, int scale) {
        super.addColumn(name, sqlType, sqlTypeName, precision, scale);
    }
    
    
    public static final DateFormat parseDateFormat = new SimpleDateFormat("dd/MM/yyyy");
    public static final int parseDateBaseYear = 2000;
    private static Logger dateWepsLogger = null;
    
    public static java.util.Date parseDateWeps (String dateStr) throws ParseException {
        return WepsResultSet.parseDateWeps(dateStr, parseDateFormat);
    }
    
    public static java.util.Date parseDateWeps (String dateStr, DateFormat format) throws ParseException {
        Calendar myCal = format.getCalendar();
        java.util.Date retDate = format.parse(dateStr);
        myCal.setTime(retDate);
        if (myCal.get(Calendar.YEAR) &lt; parseDateBaseYear) {
            myCal.add(Calendar.YEAR, parseDateBaseYear);
        }
        retDate = myCal.getTime();
        return retDate;
    }
    
    public static java.sql.Date getSqlDateWeps (String dateStr) throws ParseException {
        return WepsResultSet.getSqlDateWeps(parseDateWeps(dateStr));
    }
    
    public static java.sql.Date getSqlDateWeps (java.util.Date date) {
        Calendar myCal = parseDateFormat.getCalendar();
        myCal.setTime(date);
int day_in = myCal.get(Calendar.DAY_OF_MONTH);
        if (myCal.get(Calendar.YEAR) &lt; parseDateBaseYear) {
            myCal.add(Calendar.YEAR, parseDateBaseYear);
        }
        java.sql.Date newDate = new java.sql.Date(myCal.getTimeInMillis());
        
        myCal.setTime(newDate);
        int day_out = myCal.get(Calendar.DAY_OF_MONTH);
        dateWepsLogger.info("getSqlDateWeps 1: date in:"+date.toString()+" date out:"+newDate.toString());
        if (day_in != day_out) {
            Error e = new Error();
            e.fillInStackTrace();
            ByteArrayOutputStream bs = new ByteArrayOutputStream();
            e.printStackTrace(new PrintStream(bs));
            dateWepsLogger.error("    Day mismatch, stacktrace\n"+bs.toString());
        }
        
        return newDate;
    }
    
    public static java.sql.Date getSqlDateWeps (int year, int month, int day) {
        if (year &lt; parseDateBaseYear) {
            year += parseDateBaseYear;
        }
        Calendar myCal = parseDateFormat.getCalendar();
        myCal.set(year, month, day);
        
        java.sql.Date newDate = new java.sql.Date(myCal.getTimeInMillis());
        
        myCal.setTime(newDate);
//        int day_out = myCal.get(Calendar.DAY_OF_MONTH);
//        dateWepsLogger.info("getSqlDateWeps 2: date in: y:"+year+" m:"+month+" d:"+day+" date out:"+newDate.toString());
//        if (day != day_out) {
//            Error e = new Error();
//            e.fillInStackTrace();
//            ByteArrayOutputStream bs = new ByteArrayOutputStream();
//            e.printStackTrace(new PrintStream(bs));
//            dateWepsLogger.error("    Day mismatch, stacktrace\n"+bs.toString());
//        }
        
        return new java.sql.Date(myCal.getTimeInMillis());
    }
}
</pre></body></html>