BrmoFramework.java

  1. package nl.b3p.brmo.loader;

  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.math.BigInteger;
  8. import java.sql.Connection;
  9. import java.sql.SQLException;
  10. import java.util.Date;
  11. import java.util.List;
  12. import java.util.zip.ZipEntry;
  13. import java.util.zip.ZipInputStream;
  14. import javax.sql.DataSource;
  15. import javax.xml.bind.JAXBException;
  16. import nl.b3p.brmo.loader.checks.AfgifteChecker;
  17. import nl.b3p.brmo.loader.entity.Bericht;
  18. import nl.b3p.brmo.loader.entity.LaadProces;
  19. import nl.b3p.brmo.loader.updates.UpdateProcess;
  20. import nl.b3p.brmo.loader.util.BrmoDuplicaatLaadprocesException;
  21. import nl.b3p.brmo.loader.util.BrmoException;
  22. import nl.b3p.brmo.loader.util.BrmoLeegBestandException;
  23. import nl.b3p.brmo.loader.util.TopNLRsgbTransformer;
  24. import nl.b3p.jdbc.util.converter.GeometryJdbcConverter;
  25. import nl.b3p.jdbc.util.converter.GeometryJdbcConverterFactory;
  26. import nl.b3p.topnl.TopNLType;
  27. import org.apache.commons.dbutils.DbUtils;
  28. import org.apache.commons.dbutils.QueryRunner;
  29. import org.apache.commons.dbutils.handlers.ScalarHandler;
  30. import org.apache.commons.io.input.CloseShieldInputStream;
  31. import org.apache.commons.io.input.CountingInputStream;
  32. import org.apache.commons.logging.Log;
  33. import org.apache.commons.logging.LogFactory;

  35. /**
  36.  * BRMO framework.
  37.  *
  38.  * @author Matthijs Laan
  39.  */
  40. public class BrmoFramework {

  42.   private static final Log log = LogFactory.getLog(BrmoFramework.class);

  44.   public static final String BR_BRK2 = "brk2";
  45.   public static final String BR_NHR = "nhr";
  46.   public static final String BR_TOPNL = "topnl";
  47.   public static final String BR_BRP = "brp";
  48.   public static final String BR_GBAV = "gbav";
  49.   public static final String BR_WOZ = "woz";

  51.   public static final String XSL_BRK2 = "/xsl/brk2-snapshot-to-rsgb-xml.xsl";
  52.   public static final String XSL_NHR = "/xsl/nhr-to-rsgb-xml-3.0.xsl";
  53.   public static final String XSL_BRP = "/xsl/brp-to-rsgb-xml.xsl";
  54.   public static final String XSL_GBAV = "/xsl/gbav-to-rsgb-xml.xsl";
  55.   public static final String XSL_WOZ = "/xsl/woz-to-rsgb.xsl";

  57.   public static final String LAADPROCES_TABEL = "laadproces";
  58.   public static final String BERICHT_TABLE = "bericht";
  59.   public static final String JOB_TABLE = "job";
  60.   public static final String BRMO_METADATA_TABEL = "brmo_metadata";

  62.   private StagingProxy stagingProxy = null;
  63.   private final DataSource dataSourceRsgb;
  64.   private final DataSource dataSourceRsgbBrk;
  65.   private DataSource dataSourceRsgbBgt = null;
  66.   private final DataSource dataSourceStaging;
  67.   private DataSource dataSourceTopNL = null;
  68.   private boolean enablePipeline = false;
  69.   private Integer pipelineCapacity;
  70.   private boolean renewConnectionAfterCommit = false;
  71.   private boolean orderBerichten = true;
  72.   private String errorState = null;

  74.   public BrmoFramework(
  75.       DataSource dataSourceStaging, DataSource dataSourceRsgb, DataSource dataSourceRsgbBrk)
  76.       throws BrmoException {
  77.     if (dataSourceStaging != null) {
  78.       try {
  79.         stagingProxy = new StagingProxy(dataSourceStaging);
  80.       } catch (SQLException ex) {
  81.         throw new BrmoException(ex);
  82.       }
  83.     }
  84.     this.dataSourceStaging = dataSourceStaging;
  85.     this.dataSourceRsgb = dataSourceRsgb;
  86.     this.dataSourceRsgbBrk = dataSourceRsgbBrk;
  87.   }

  89.   public BrmoFramework(
  90.       DataSource dataSourceStaging,
  91.       DataSource dataSourceRsgb,
  92.       DataSource dataSourceRsgbBgt,
  93.       DataSource dataSourceTopNL,
  94.       DataSource dataSourceRsgbBrk)
  95.       throws BrmoException {
  96.     if (dataSourceStaging != null) {
  97.       try {
  98.         stagingProxy = new StagingProxy(dataSourceStaging);
  99.       } catch (SQLException ex) {
  100.         throw new BrmoException(ex);
  101.       }
  102.     }
  103.     this.dataSourceRsgb = dataSourceRsgb;
  104.     this.dataSourceRsgbBgt = dataSourceRsgbBgt;
  105.     this.dataSourceStaging = dataSourceStaging;
  106.     this.dataSourceTopNL = dataSourceTopNL;
  107.     this.dataSourceRsgbBrk = dataSourceRsgbBrk;
  108.   }

  110.   public void setDataSourceRsgbBgt(DataSource dataSourceRsgbBgt) {
  111.     this.dataSourceRsgbBgt = dataSourceRsgbBgt;
  112.   }

  114.   public void setDataSourceTopNL(DataSource dataSourceTopNL) {
  115.     this.dataSourceTopNL = dataSourceTopNL;
  116.   }

  118.   public String getStagingVersion() {
  119.     try {
  120.       return getVersion(dataSourceStaging);
  121.     } catch (SQLException ex) {
  122.       log.error("Versienummer kon niet uit de STAGING database worden gelezen.", ex);
  123.       return "";
  124.     }
  125.   }

  127.   public String getRsgbVersion() {
  128.     try {
  129.       return getVersion(dataSourceRsgb);
  130.     } catch (SQLException ex) {
  131.       log.error("Versienummer kon niet uit de RSGB database worden gelezen.", ex);
  132.       return "";
  133.     }
  134.   }

  136.   public String getRsgbBgtVersion() {
  137.     try {
  138.       return getVersion(dataSourceRsgbBgt);
  139.     } catch (SQLException ex) {
  140.       log.error("Versienummer kon niet uit de RSGBBGT database worden gelezen.", ex);
  141.       return "";
  142.     }
  143.   }

  145.   public String getRsgbBrkVersion() {
  146.     try {
  147.       return getVersion(dataSourceRsgbBrk);
  148.     } catch (SQLException ex) {
  149.       log.error("Versienummer kon niet uit de RSGB BRK database worden gelezen.", ex);
  150.       return "";
  151.     }
  152.   }

  154.   private String getVersion(DataSource dataSource) throws SQLException {
  155.     String sql =
  156.         "SELECT waarde FROM " + BrmoFramework.BRMO_METADATA_TABEL + " WHERE naam = 'brmoversie'";
  157.     final Connection c = dataSource.getConnection();
  158.     GeometryJdbcConverter geomToJdbc = GeometryJdbcConverterFactory.getGeometryJdbcConverter(c);
  159.     String o = new QueryRunner(geomToJdbc.isPmdKnownBroken()).query(c, sql, new ScalarHandler<>());
  160.     DbUtils.closeQuietly(c);
  161.     return o;
  162.   }

  164.   public void setEnablePipeline(boolean enablePipeline) {
  165.     this.enablePipeline = enablePipeline;
  166.   }

  168.   public void setRenewConnectionAfterCommit(boolean renewConnectionAfterCommit) {
  169.     this.renewConnectionAfterCommit = renewConnectionAfterCommit;
  170.   }

  172.   public void setTransformPipelineCapacity(int pipelineCapacity) {
  173.     this.pipelineCapacity = pipelineCapacity;
  174.   }

  176.   public void setBatchCapacity(int batchCapacity) {
  177.     if (stagingProxy != null) {
  178.       stagingProxy.setBatchCapacity(batchCapacity);
  179.     }
  180.   }

  182.   public void setLimitStandBerichtenToTransform(Integer limitStandBerichtenToTransform) {
  183.     if (stagingProxy != null) {
  184.       stagingProxy.setLimitStandBerichtenToTransform(limitStandBerichtenToTransform);
  185.     }
  186.   }

  188.   /**
  189.    * stel bericht sortering van berichten in.
  190.    *
  191.    * @param orderBerichten {@code false} voor stand, {@code true} voor mutaties
  192.    */
  193.   public void setOrderBerichten(boolean orderBerichten) {
  194.     this.orderBerichten = orderBerichten;
  195.   }

  197.   public boolean isOrderBerichten() {
  198.     return this.orderBerichten;
  199.   }

  201.   public void setErrorState(String errorState) {
  202.     this.errorState = errorState;
  203.   }

  205.   public void closeBrmoFramework() {
  206.     if (stagingProxy != null) {
  207.       stagingProxy.closeStagingProxy();
  208.     }
  209.     // rsgbProxy is thread and will be closed in thread
  210.   }

  212.   public Thread toRsgb() throws BrmoException {
  213.     return toRsgb((ProgressUpdateListener) null);
  214.   }

  216.   public Thread toRsgb(ProgressUpdateListener listener) throws BrmoException {
  217.     return toRsgb(Bericht.STATUS.STAGING_OK, listener);
  218.   }

  220.   public Thread toRsgb(Bericht.STATUS status, ProgressUpdateListener listener)
  221.       throws BrmoException {
  222.     RsgbProxy rsgbProxy =
  223.         new RsgbProxy(dataSourceRsgb, dataSourceRsgbBrk, stagingProxy, status, listener);
  224.     rsgbProxy.setEnablePipeline(enablePipeline);
  225.     if (pipelineCapacity != null) {
  226.       rsgbProxy.setPipelineCapacity(pipelineCapacity);
  227.     }
  228.     rsgbProxy.setRenewConnectionAfterCommit(renewConnectionAfterCommit);
  229.     rsgbProxy.setOrderBerichten(orderBerichten);
  230.     rsgbProxy.setErrorState(errorState);
  231.     Thread t = new Thread(rsgbProxy);
  232.     t.start();
  233.     return t;
  234.   }

  236.   /**
  237.    * @param mode geeft aan wat ids zijn (laadprocessen of berichten)
  238.    * @param ids array van ids
  239.    * @param listener voortgangs listener
  240.    * @return running transformatie thread
  241.    * @throws BrmoException if any
  242.    */
  243.   public Thread toRsgb(
  244.       RsgbProxy.BerichtSelectMode mode, long[] ids, ProgressUpdateListener listener)
  245.       throws BrmoException {
  246.     String soort = "";
  247.     if (mode == RsgbProxy.BerichtSelectMode.BY_LAADPROCES) {
  248.       try {
  249.         soort = stagingProxy.getLaadProcesById(ids[0]).getSoort();
  250.       } catch (SQLException ex) {
  251.         throw new BrmoException(ex);
  252.       }
  253.     }

  255.     Runnable worker;
  256.     if (TopNLType.isTopNLType(soort)) {
  257.       try {
  258.         worker = new TopNLRsgbTransformer(dataSourceTopNL, stagingProxy, ids, listener);
  259.       } catch (JAXBException | SQLException ex) {
  260.         throw new BrmoException("Probleem met TopNL parser initialiseren: ", ex);
  261.       }
  262.     } else {
  263.       worker = new RsgbProxy(dataSourceRsgb, dataSourceRsgbBrk, stagingProxy, mode, ids, listener);
  264.       ((RsgbProxy) worker).setEnablePipeline(enablePipeline);
  265.       if (pipelineCapacity != null) {
  266.         ((RsgbProxy) worker).setPipelineCapacity(pipelineCapacity);
  267.       }
  268.       ((RsgbProxy) worker).setRenewConnectionAfterCommit(renewConnectionAfterCommit);
  269.       ((RsgbProxy) worker).setOrderBerichten(orderBerichten);
  270.       ((RsgbProxy) worker).setErrorState(errorState);
  271.     }
  272.     Thread t = new Thread(worker);
  273.     t.start();
  274.     return t;
  275.   }

  277.   public Thread toRsgb(UpdateProcess updateProcess, ProgressUpdateListener listener)
  278.       throws BrmoException {
  279.     RsgbProxy rsgbProxy =
  280.         new RsgbProxy(dataSourceRsgb, dataSourceRsgbBrk, stagingProxy, updateProcess, listener);
  281.     rsgbProxy.setEnablePipeline(enablePipeline);
  282.     if (pipelineCapacity != null) {
  283.       rsgbProxy.setPipelineCapacity(pipelineCapacity);
  284.     }
  285.     rsgbProxy.setRenewConnectionAfterCommit(renewConnectionAfterCommit);
  286.     rsgbProxy.setOrderBerichten(orderBerichten);
  287.     rsgbProxy.setErrorState(errorState);
  288.     Thread t = new Thread(rsgbProxy);
  289.     t.start();
  290.     return t;
  291.   }

  293.   public void delete(Long id) throws BrmoException {
  294.     if (id != null) {
  295.       try {
  296.         stagingProxy.deleteByLaadProcesId(id);
  297.       } catch (SQLException ex) {
  298.         throw new BrmoException(ex);
  299.       }
  300.     }
  301.   }

  303.   public List<LaadProces> listLaadProcessen() throws BrmoException {
  304.     try {
  305.       return stagingProxy.getLaadProcessen();
  306.     } catch (SQLException ex) {
  307.       throw new BrmoException(ex);
  308.     }
  309.   }

  311.   public List<Bericht> listBerichten() throws BrmoException {
  312.     try {
  313.       return stagingProxy.getBerichten();
  314.     } catch (SQLException ex) {
  315.       throw new BrmoException(ex);
  316.     }
  317.   }

  319.   /**
  320.    * @param type basis registratie type
  321.    * @param fileName bestand
  322.    * @throws BrmoException als er een fout optreed tijdens verwerking
  323.    * @deprecated gebruik van de variant met automatischProces ID heeft de voorkeur
  324.    * @see #loadFromFile(java.lang.String, java.lang.String, java.lang.Long)
  325.    */
  326.   @Deprecated
  327.   public void loadFromFile(String type, String fileName) throws BrmoException {
  328.     loadFromFile(type, fileName, null);
  329.   }

  331.   /**
  332.    * @see #loadFromFile(java.lang.String, java.lang.String,
  333.    *     nl.b3p.brmo.loader.ProgressUpdateListener, Long)
  334.    * @param type basis registratie type
  335.    * @param fileName bestand
  336.    * @param automatischProces id van automatisch proces dat deze functie aanroept
  337.    * @throws BrmoException als er een fout optreed tijdens verwerking
  338.    */
  339.   public void loadFromFile(String type, String fileName, Long automatischProces)
  340.       throws BrmoException {
  341.     try {
  342.       loadFromFile(type, fileName, null, automatischProces);
  343.     } catch (Exception e) {
  344.       if (e instanceof BrmoException) {
  345.         throw (BrmoException) e;
  346.       } else {
  347.         throw new BrmoException("Fout bij loaden basisregistratie gegevens", e);
  348.       }
  349.     }
  350.   }

  352.   /**
  353.    * laden van BR data uit een bestand. <br>
  354.    * NB na gebruik zelf de database verbinding sluiten / opruimen met {@link #closeBrmoFramework()}.
  355.    *
  356.    * @param type basis registratie type
  357.    * @param fileName bestand
  358.    * @param listener voortgangsmonitor
  359.    * @param automatischProces id van automatisch proces dat deze functie aanroept
  360.    * @throws BrmoException als er een fout optreed tijdens verwerking
  361.    */
  362.   public void loadFromFile(
  363.       String type, String fileName, final ProgressUpdateListener listener, Long automatischProces)
  364.       throws BrmoException {
  365.     try {
  366.       if (fileName.toLowerCase().endsWith(".zip")) {
  367.         log.info("Openen ZIP bestand " + fileName);
  368.         ZipInputStream zip = null;
  369.         try {
  370.           File f = new File(fileName);
  371.           if (listener != null) {
  372.             listener.total(f.length());
  373.           }
  374.           CountingInputStream zipCis =
  375.               new CountingInputStream(new FileInputStream(f)) {
  376.                 @Override
  377.                 protected synchronized void afterRead(int n) throws IOException {
  378.                   super.afterRead(n);
  379.                   if (listener != null) {
  380.                     listener.progress(getByteCount());
  381.                   }
  382.                 }
  383.               };
  384.           zip = new ZipInputStream(zipCis);
  385.           ZipEntry entry = zip.getNextEntry();
  386.           while (entry != null) {
  387.             if (!entry.getName().toLowerCase().endsWith(".xml")) {
  388.               log.warn("Overslaan zip entry geen XML: " + entry.getName());
  389.             } else {
  390.               log.info("Lezen XML bestand uit zip: " + entry.getName());
  391.               stagingProxy.loadBr(
  392.                   CloseShieldInputStream.wrap(zip),
  393.                   type,
  394.                   fileName + "/" + entry.getName(),
  395.                   null,
  396.                   null,
  397.                   automatischProces);
  398.             }
  399.             entry = zip.getNextEntry();
  400.           }
  401.         } finally {
  402.           if (zip != null) {
  403.             zip.close();
  404.           }
  405.         }
  406.         log.info("Klaar met ZIP bestand " + fileName);
  407.       } else {
  408.         File f = new File(fileName);
  409.         if (listener != null) {
  410.           listener.total(f.length());
  411.         }

  413.         try (FileInputStream fis = new FileInputStream(fileName)) {
  414.           stagingProxy.loadBr(fis, type, fileName, null, listener, automatischProces);
  415.         }
  416.       }
  417.     } catch (Exception e) {
  418.       if (e instanceof BrmoException) {
  419.         throw (BrmoException) e;
  420.       } else {
  421.         throw new BrmoException("Fout bij loaden basisregistratie gegevens", e);
  422.       }
  423.     }
  424.   }

  426.   /**
  427.    * laden van BR data uit een stream.
  428.    *
  429.    * @param type type registratie, bijv. {@value BrmoFramework#BR_BRK2}
  430.    * @param stream datastream
  431.    * @param fileName te gebruiken bestandsnaam om laadproces te identificeren
  432.    * @throws BrmoException als er een algemene fout optreed
  433.    * @throws BrmoDuplicaatLaadprocesException als het "bestand" {@code fileName} al geladen is
  434.    * @throws BrmoLeegBestandException als het "bestand" {@code fileName} leeg is
  435.    * @deprecated probeer de variant met automatischProces argument te gebruiken
  436.    * @see #loadFromStream(String, InputStream, String, Long)
  437.    */
  438.   @Deprecated
  439.   public void loadFromStream(String type, InputStream stream, String fileName)
  440.       throws BrmoException, BrmoDuplicaatLaadprocesException, BrmoLeegBestandException {
  441.     this.loadFromStream(type, stream, fileName, (Long) null);
  442.   }

  444.   /**
  445.    * laden van BR data uit een stream.
  446.    *
  447.    * @param type type registratie, bijv. {@value BrmoFramework#BR_BRK2}
  448.    * @param stream datastream
  449.    * @param fileName te gebruiken bestandsnaam om laadproces te identificeren
  450.    * @param automatischProces id van automatisch proces dat deze functie aanroept
  451.    * @throws BrmoException als er een algemene fout optreed
  452.    * @throws BrmoDuplicaatLaadprocesException als het "bestand" {@code fileName} al geladen is
  453.    * @throws BrmoLeegBestandException als het "bestand" {@code fileName} leeg is
  454.    */
  455.   public void loadFromStream(
  456.       String type, InputStream stream, String fileName, Long automatischProces)
  457.       throws BrmoException, BrmoDuplicaatLaadprocesException, BrmoLeegBestandException {
  458.     try {
  459.       stagingProxy.loadBr(stream, type, fileName, null, null, automatischProces);
  460.     } catch (Exception e) {
  461.       if (e instanceof BrmoDuplicaatLaadprocesException) {
  462.         throw (BrmoDuplicaatLaadprocesException) e;
  463.       }
  464.       if (e instanceof BrmoLeegBestandException) {
  465.         throw (BrmoLeegBestandException) e;
  466.       }
  467.       throw new BrmoException("Fout bij laden " + type + " berichten uit bestand " + fileName, e);
  468.     }
  469.   }

  471.   /**
  472.    * laden van BR data uit een stream.
  473.    *
  474.    * @param type type registratie, bijv. {@value BrmoFramework#BR_BRK2}
  475.    * @param stream datastream
  476.    * @param fileName te gebruiken bestandsnaam om laadproces te identificeren
  477.    * @param d bestandsdatum
  478.    * @throws BrmoException als er een algemene fout optreed
  479.    * @throws BrmoDuplicaatLaadprocesException als het "bestand" {@code fileName} al geladen is
  480.    * @throws BrmoLeegBestandException als het "bestand" {@code fileName} leeg is
  481.    * @deprecated Gebruik {@link #loadFromStream(String, InputStream, String, Date, Long)}
  482.    */
  483.   @Deprecated
  484.   public void loadFromStream(String type, InputStream stream, String fileName, Date d)
  485.       throws BrmoException, BrmoDuplicaatLaadprocesException, BrmoLeegBestandException {
  486.     loadFromStream(type, stream, fileName, d, null);
  487.   }

  489.   /**
  490.    * laden van BR data uit een stream.
  491.    *
  492.    * @param type type registratie, bijv. {@value BrmoFramework#BR_BRK2}
  493.    * @param stream datastream
  494.    * @param fileName te gebruiken bestandsnaam om laadproces te identificeren
  495.    * @param d bestandsdatum
  496.    * @param automatischProces id van automatisch proces dat deze functie aanroept
  497.    * @throws BrmoException als er een algemene fout optreed
  498.    * @throws BrmoDuplicaatLaadprocesException als het "bestand" {@code fileName} al geladen is
  499.    * @throws BrmoLeegBestandException als het "bestand" {@code fileName} leeg is
  500.    */
  501.   public void loadFromStream(
  502.       String type, InputStream stream, String fileName, Date d, Long automatischProces)
  503.       throws BrmoException, BrmoDuplicaatLaadprocesException, BrmoLeegBestandException {
  504.     try {
  505.       stagingProxy.loadBr(stream, type, fileName, d, null, automatischProces);
  506.     } catch (Exception e) {
  507.       if (e instanceof BrmoDuplicaatLaadprocesException) {
  508.         throw (BrmoDuplicaatLaadprocesException) e;
  509.       }
  510.       if (e instanceof BrmoLeegBestandException) {
  511.         throw (BrmoLeegBestandException) e;
  512.       }
  513.       throw new BrmoException("Fout bij laden " + type + " berichten uit bestand " + fileName, e);
  514.     }
  515.   }

  517.   /**
  518.    * laden van BR data uit een stream.
  519.    *
  520.    * @param type type registratie, bijv. {@value BrmoFramework#BR_BRK2}
  521.    * @param stream datastream
  522.    * @param fileName te gebruiken bestandsnaam om laadproces te identificeren
  523.    * @param listener mag {@code null} zijn
  524.    * @param automatischProces id van automatisch proces dat deze functie aanroept
  525.    * @throws BrmoException als er een algemene fout optreed
  526.    * @throws BrmoDuplicaatLaadprocesException als het "bestand" {@code fileName} al geladen is
  527.    * @throws BrmoLeegBestandException als het "bestand" {@code fileName} leeg is
  528.    */
  529.   public void loadFromStream(
  530.       String type,
  531.       InputStream stream,
  532.       String fileName,
  533.       ProgressUpdateListener listener,
  534.       Long automatischProces)
  535.       throws BrmoException, BrmoDuplicaatLaadprocesException, BrmoLeegBestandException {
  536.     try {
  537.       stagingProxy.loadBr(stream, type, fileName, null, listener, automatischProces);
  538.     } catch (Exception e) {
  539.       if (e instanceof BrmoDuplicaatLaadprocesException) {
  540.         throw (BrmoDuplicaatLaadprocesException) e;
  541.       }
  542.       if (e instanceof BrmoLeegBestandException) {
  543.         throw (BrmoLeegBestandException) e;
  544.       }
  545.       throw new BrmoException("Fout bij laden " + type + " berichten uit bestand " + fileName, e);
  546.     }
  547.   }

  549.   public void emptyStagingDb() throws BrmoException {
  550.     try {
  551.       stagingProxy.emptyStagingDb();
  552.     } catch (SQLException ex) {
  553.       throw new BrmoException(ex);
  554.     }
  555.   }

  557.   public Long getLaadProcesIdByFileName(String name) throws BrmoException {
  558.     Long id = null;
  559.     LaadProces lp;
  560.     try {
  561.       lp = stagingProxy.getLaadProcesByFileName(name);
  562.     } catch (SQLException ex) {
  563.       throw new BrmoException(ex);
  564.     }

  566.     if (lp != null) {
  567.       id = lp.getId();
  568.     }

  570.     return id;
  571.   }

  573.   public Bericht getBerichtById(long id) throws BrmoException {
  574.     try {
  575.       return stagingProxy.getBerichtById(id);
  576.     } catch (SQLException ex) {
  577.       throw new BrmoException(ex);
  578.     }
  579.   }

  581.   public LaadProces getLaadProcesById(long id) throws BrmoException {
  582.     try {
  583.       return stagingProxy.getLaadProcesById(id);
  584.     } catch (SQLException ex) {
  585.       throw new BrmoException(ex);
  586.     }
  587.   }

  589.   public List<Bericht> getBerichten(
  590.       int page,
  591.       int start,
  592.       int limit,
  593.       String sort,
  594.       String dir,
  595.       String filterSoort,
  596.       String filterStatus)
  597.       throws BrmoException {

  599.     try {
  600.       return stagingProxy.getBerichten(page, start, limit, sort, dir, filterSoort, filterStatus);
  601.     } catch (SQLException ex) {
  602.       throw new BrmoException(ex);
  603.     }
  604.   }

  606.   public List<LaadProces> getLaadprocessen(
  607.       int page,
  608.       int start,
  609.       int limit,
  610.       String sort,
  611.       String dir,
  612.       String filterSoort,
  613.       String filterStatus)
  614.       throws BrmoException {

  616.     try {
  617.       return stagingProxy.getLaadprocessen(
  618.           page, start, limit, sort, dir, filterSoort, filterStatus);
  619.     } catch (SQLException ex) {
  620.       throw new BrmoException(ex);
  621.     }
  622.   }

  624.   public Long[] getLaadProcessenIds(
  625.       String sort, String dir, String filterSoort, String filterStatus) throws BrmoException {
  626.     try {
  627.       return stagingProxy.getLaadProcessenIds(sort, dir, filterSoort, filterStatus);
  628.     } catch (SQLException ex) {
  629.       throw new BrmoException(ex);
  630.     }
  631.   }

  633.   public long getCountBerichten(String filterSoort, String filterStatus) throws BrmoException {
  634.     try {
  635.       return stagingProxy.getCountBerichten(filterSoort, filterStatus);
  636.     } catch (SQLException ex) {
  637.       throw new BrmoException(ex);
  638.     }
  639.   }

  641.   public long getCountLaadProcessen(String filterSoort, String filterStatus) throws BrmoException {
  642.     try {
  643.       return stagingProxy.getCountLaadProces(filterSoort, filterStatus);
  644.     } catch (SQLException ex) {
  645.       throw new BrmoException(ex);
  646.     }
  647.   }

  649.   public long getCountJob() throws BrmoException {
  650.     try {
  651.       return stagingProxy.getCountJob();
  652.     } catch (SQLException ex) {
  653.       throw new BrmoException(ex);
  654.     }
  655.   }

  657.   /**
  658.    * update laadproces (GDS2 afgifte) metadata.
  659.    *
  660.    * @param lpId laadproces id
  661.    * @param klantafgiftenummer klantafgiftenummer
  662.    * @param contractafgiftenummer contractafgiftenummer
  663.    * @param artikelnummer artikelnummer
  664.    * @param contractnummer contractnummer
  665.    * @param afgifteid afgifteid
  666.    * @param afgiftereferentie afgiftereferentie
  667.    * @param bestandsreferentie bestandsreferentie
  668.    * @param beschikbaar_tot beschikbaar_tot
  669.    * @throws BrmoException if any
  670.    */
  671.   public void updateLaadProcesMeta(
  672.       Long lpId,
  673.       BigInteger klantafgiftenummer,
  674.       BigInteger contractafgiftenummer,
  675.       String artikelnummer,
  676.       String contractnummer,
  677.       String afgifteid,
  678.       String afgiftereferentie,
  679.       String bestandsreferentie,
  680.       Date beschikbaar_tot)
  681.       throws BrmoException {
  682.     try {
  683.       stagingProxy.updateLaadProcesMeta(
  684.           lpId,
  685.           klantafgiftenummer,
  686.           contractafgiftenummer,
  687.           artikelnummer,
  688.           contractnummer,
  689.           afgifteid,
  690.           afgiftereferentie,
  691.           bestandsreferentie,
  692.           beschikbaar_tot);
  693.     } catch (SQLException ex) {
  694.       throw new BrmoException(ex);
  695.     }
  696.   }

  698.   public File checkAfgiftelijst(String bestandsnaam, String output) throws IOException {
  699.     File f = new File(bestandsnaam);
  700.     return checkAfgiftelijst(bestandsnaam, new FileInputStream(f), new File(output));
  701.   }

  703.   public File checkAfgiftelijst(String bestandsnaam, InputStream is, File output)
  704.       throws IOException {
  705.     AfgifteChecker checker = new AfgifteChecker();
  706.     checker.init(is, stagingProxy);
  707.     checker.check();
  708.     return checker.getResults(bestandsnaam, output);
  709.   }
  710. }
Created with JaCoCo 0.8.12.202403310830