Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
IOUtil { public static String getPath(String file){ return FilenameUtils.getPath(file); } private IOUtil(); static boolean isFileExist(String filePath); static boolean isFolderExist(String folder); static String addbs(String pathFolder); static InputStream getResourceAsStream(Class clazz, String filePath); static Properties getPropertiesFrom(String filePath); static Properties getPropertiesFrom(File file); static Properties getPropertiesFromResource(Class clazz, String filePath); static String getPath(String file); static String getFullPath(String file); static String getFullPathNoEndSeparator(String file); static String getFileBaseName(String file); static String getFileName(String file); static String getFileExtension(String file); static boolean writeBytesToFile(byte[] byteArray, String filePath); }
@Test public void testGetPath() { System.out.println("getPath"); String file = "c:/src/test/java/org/javabeanstack/util/prueba.xml"; String expResult = "src/test/java/org/javabeanstack/util/"; String result = IOUtil.getPath(file); assertEquals(expResult, result); }
IOUtil { public static String getFullPath(String file){ return FilenameUtils.getFullPath(file); } private IOUtil(); static boolean isFileExist(String filePath); static boolean isFolderExist(String folder); static String addbs(String pathFolder); static InputStream getResourceAsStream(Class clazz, String filePath); static Properties getPropertiesFrom(String filePath); static Properties getPropertiesFrom(File file); static Properties getPropertiesFromResource(Class clazz, String filePath); static String getPath(String file); static String getFullPath(String file); static String getFullPathNoEndSeparator(String file); static String getFileBaseName(String file); static String getFileName(String file); static String getFileExtension(String file); static boolean writeBytesToFile(byte[] byteArray, String filePath); }
@Test public void testGetFullPath() { System.out.println("getFullPath"); String file = "c:/src/test/java/org/javabeanstack/util/prueba.xml"; String expResult = "c:/src/test/java/org/javabeanstack/util/"; String result = IOUtil.getFullPath(file); assertEquals(expResult, result); }
IOUtil { public static String getFullPathNoEndSeparator(String file){ return FilenameUtils.getFullPathNoEndSeparator(file); } private IOUtil(); static boolean isFileExist(String filePath); static boolean isFolderExist(String folder); static String addbs(String pathFolder); static InputStream getResourceAsStream(Class clazz, String filePath); static Properties getPropertiesFrom(String filePath); static Properties getPropertiesFrom(File file); static Properties getPropertiesFromResource(Class clazz, String filePath); static String getPath(String file); static String getFullPath(String file); static String getFullPathNoEndSeparator(String file); static String getFileBaseName(String file); static String getFileName(String file); static String getFileExtension(String file); static boolean writeBytesToFile(byte[] byteArray, String filePath); }
@Test public void testGetFullPathNoEndSeparator() { System.out.println("getFullPathNoEndSeparator"); String file = "c:/src/test/java/org/javabeanstack/util/prueba.xml"; String expResult = "c:/src/test/java/org/javabeanstack/util"; String result = IOUtil.getFullPathNoEndSeparator(file); assertEquals(expResult, result); }
IOUtil { public static String getFileBaseName(String file){ return FilenameUtils.getBaseName(file); } private IOUtil(); static boolean isFileExist(String filePath); static boolean isFolderExist(String folder); static String addbs(String pathFolder); static InputStream getResourceAsStream(Class clazz, String filePath); static Properties getPropertiesFrom(String filePath); static Properties getPropertiesFrom(File file); static Properties getPropertiesFromResource(Class clazz, String filePath); static String getPath(String file); static String getFullPath(String file); static String getFullPathNoEndSeparator(String file); static String getFileBaseName(String file); static String getFileName(String file); static String getFileExtension(String file); static boolean writeBytesToFile(byte[] byteArray, String filePath); }
@Test public void testGetFileBaseName() { System.out.println("getFileBaseName"); String file = "c:/src/test/java/org/javabeanstack/util/prueba.xml"; String expResult = "prueba"; String result = IOUtil.getFileBaseName(file); assertEquals(expResult, result); }
IOUtil { public static String getFileName(String file){ return FilenameUtils.getName(file); } private IOUtil(); static boolean isFileExist(String filePath); static boolean isFolderExist(String folder); static String addbs(String pathFolder); static InputStream getResourceAsStream(Class clazz, String filePath); static Properties getPropertiesFrom(String filePath); static Properties getPropertiesFrom(File file); static Properties getPropertiesFromResource(Class clazz, String filePath); static String getPath(String file); static String getFullPath(String file); static String getFullPathNoEndSeparator(String file); static String getFileBaseName(String file); static String getFileName(String file); static String getFileExtension(String file); static boolean writeBytesToFile(byte[] byteArray, String filePath); }
@Test public void testGetFileName() { System.out.println("getFileName"); String file = "c:/src/test/java/org/javabeanstack/util/prueba.xml"; String expResult = "prueba.xml"; String result = IOUtil.getFileName(file); assertEquals(expResult, result); }
IOUtil { public static String getFileExtension(String file){ return FilenameUtils.getExtension(file); } private IOUtil(); static boolean isFileExist(String filePath); static boolean isFolderExist(String folder); static String addbs(String pathFolder); static InputStream getResourceAsStream(Class clazz, String filePath); static Properties getPropertiesFrom(String filePath); static Properties getPropertiesFrom(File file); static Properties getPropertiesFromResource(Class clazz, String filePath); static String getPath(String file); static String getFullPath(String file); static String getFullPathNoEndSeparator(String file); static String getFileBaseName(String file); static String getFileName(String file); static String getFileExtension(String file); static boolean writeBytesToFile(byte[] byteArray, String filePath); }
@Test public void testGetFileExtension() { System.out.println("getFileExtension"); String file = "c:/src/test/java/org/javabeanstack/util/prueba.xml"; String expResult = "xml"; String result = IOUtil.getFileExtension(file); assertEquals(expResult, result); }
AbstractDataService implements IDataService { @Override public <T extends IDataRow> T findById(Class<T> entityClass, String sessionId, Object id) throws Exception { return dao.findById(entityClass, sessionId, id); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test10FindById() throws Exception { System.out.println("10-DataService - findById"); String sessionid = null; if (error != null) { System.out.println(error); return; } AppUser user = dataService.findById(AppUser.class, sessionid, 1L); assertNotNull(user); user = dataService.findById(AppUser.class, sessionid, 0L); assertNull(user); }
AbstractDataService implements IDataService { @Override public <T extends IDataRow> T findByUk(String sessionId, T ejb) throws Exception { return dao.findByUk(sessionId, ejb); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test11FindByUk() throws Exception { System.out.println("11-DataService - findByUk"); String sessionid = null; if (error != null) { System.out.println(error); return; } AppResource appResource = new AppResource(); appResource.setCode("no se encuentra"); appResource = dataService.findByUk(sessionid, appResource); assertNull(appResource); appResource = new AppResource(); appResource.setCode("clasemaker.xml"); appResource = dataService.findByUk(sessionid, appResource); assertNotNull(appResource); }
AbstractDataService implements IDataService { @Override public <T extends IDataRow> List<T> find(Class<T> entityClass, String sessionId) throws Exception { return dao.find(entityClass, sessionId); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test12Find() throws Exception { System.out.println("12-DataService - find"); String sessionid = null; if (error != null) { System.out.println(error); return; } List<AppUser> users = dataService.find(AppUser.class, sessionid); assertTrue(users.size() > 0); String order = "code desc"; String filter = ""; users = dataService.find(AppUser.class, sessionid, order, filter, null); assertTrue(users.size() > 0); filter = "code = 'Administrador'"; users = dataService.find(AppUser.class, sessionid, order, filter, null); assertTrue(users.size() == 1); filter = "code = :code"; Map<String, Object> params = new HashMap(); params.put("code", "Administrador"); users = dataService.find(AppUser.class, sessionid, order, filter, params); assertTrue(users.size() == 1); users = dataService.find(AppUser.class, sessionid, null, "", null, 0, 4); assertTrue(users.size() == 4); }
AbstractDataService implements IDataService { @Override public <T extends IDataRow> T findByQuery(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { return dao.findByQuery(sessionId, queryString, parameters); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test13FindByQuery() throws Exception { System.out.println("13-DataService - findByQuery"); String sessionid = null; if (error != null) { System.out.println(error); return; } AppUser user = dataService.findByQuery(sessionid, "select o from AppUser o where iduser = 1L", null); assertNotNull(user); user = dataService.findByQuery(sessionid, "select o from AppUser o where iduser = 0L", null); assertNull(user); Map<String, Object> params = new HashMap(); params.put("iduser", 1L); user = dataService.findByQuery(sessionid, "select o from AppUser o where iduser = :iduser", params); assertNotNull(user); }
AbstractDataService implements IDataService { @Override public <T extends IDataRow> List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { return dao.findListByQuery(sessionId, queryString, parameters); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test14FindListByQuery() throws Exception { System.out.println("14-DataService - findListByQuery"); String sessionid = null; if (error != null) { System.out.println(error); return; } List<AppUser> users = dataService.findListByQuery(sessionid, "select o from AppUser o where iduser = 1L", null); assertNotNull(users); users = dataService.findListByQuery(sessionid, "select o from AppUser o where iduser = 0L", null); assertTrue(users.isEmpty()); Map<String, Object> params = new HashMap(); params.put("iduser", 1L); users = dataService.findListByQuery(sessionid, "select o from AppUser o where iduser = :iduser", params); assertNotNull(users); }
AbstractDAO implements IGenericDAO { @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) public <T extends IDataRow> T findById(Class<T> entityClass, String sessionId, Object id) throws Exception { LOGGER.debug(Strings.replicate("-", 50)); LOGGER.debug("find"); LOGGER.debug(entityClass.toString()); IDBLinkInfo dbLinkInfo = sessions.getDBLinkInfo(sessionId); EntityManager em = getEntityManager(getEntityId(dbLinkInfo)); T row = em.find(entityClass, id); if (row == null) { return null; } if (Status.STATUS_NO_TRANSACTION == tsr.getTransactionStatus()) { return row; } List<Field> fields = DataInfo.getLazyMembers(row.getClass()); if (!fields.isEmpty()) { List obj; for (Field field : fields) { field.setAccessible(true); obj = (List) field.get(row); obj.size(); } } return row; } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test02FindById() throws Exception { System.out.println("2-AbstractDAO - findById"); String sessionid = null; if (error != null) { System.out.println(error); return; } AppUser user = dao.findById(AppUser.class, sessionid, 1L); assertNotNull(user); user = dao.findById(AppUser.class, sessionid, 0L); assertNull(user); }
AbstractDataService implements IDataService { @Override public <T extends IDataRow> List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters) throws Exception { return dao.findListByNamedQuery(sessionId, namedQuery, parameters); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test15FindByNamedQuery() throws Exception { System.out.println("15-DataService - findByNamedQuery"); String sessionid = null; if (error != null) { System.out.println(error); return; } List<AppTablesRelation> prueba = dataService.findListByNamedQuery(sessionid, "AppTablesRelation.findAll", null); assertTrue(!prueba.isEmpty()); }
AbstractDataService implements IDataService { @Override public List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { return dao.findByNativeQuery(sessionId, queryString, parameters); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test16FindByNativeQuery() throws Exception { System.out.println("16-DataService - findByNativeQuery"); if (error != null) { System.out.println(error); return; } String sqlSentence = "select * from {schema}.moneda where idmoneda > :id"; Map<String, Object> params = new HashMap(); params.put("id",0); List<Object> query1 = dataService.findByNativeQuery(sessionId, sqlSentence, params); assertTrue(!query1.isEmpty()); query1 = dataService.findByNativeQuery(sessionId, sqlSentence, params,0,10); assertTrue(!query1.isEmpty()); }
AbstractDataService implements IDataService { @Override public Long getCount(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { return dao.getCount(sessionId, queryString, parameters); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test18GetCount() throws Exception { System.out.println("18-DataService - getCount"); String sessionid = null; if (error != null) { System.out.println(error); return; } Long rec = dataService.getCount(sessionid, "select o FROM AppCompany o", null); assertTrue(rec > 0L); }
AbstractDataService implements IDataService { @Override public Long getCount2(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { return dao.getCount2(sessionId, queryString, parameters); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test19GetCount2() throws Exception { System.out.println("19-DataService - getCount2"); String sessionid = null; if (error != null) { System.out.println(error); return; } Long rec = dataService.getCount2(sessionid, "select * FROM {schema}.empresa", null); assertTrue(rec > 0L); }
AbstractDataService implements IDataService { @Override public <T extends IDataRow> List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows) throws Exception { String query = getSelectCmd(sessionId, type, order, filter); if (maxRows == -1) { maxRows = 999999999; } List<T> dataRows; if (maxRows == 0) { dataRows = new ArrayList(); } else { dataRows = (ArrayList<T>) dao.findListByQuery(sessionId, query, params, firstRow, maxRows); } return dataRows; } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test20GetDataRows() throws Exception{ System.out.println("20-DataService - getDataRows"); if (error != null) { System.out.println(error); return; } List<Moneda> monedas = dataService.getDataRows(sessionId, Moneda.class,"" , "", null,0,1000); assertFalse(monedas.isEmpty()); }
AbstractDataService implements IDataService { @Override public Map<String, Object> getEntityManagerProp(String persistUnit) { return dao.getEntityManagerProp(persistUnit); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test29GetEntityManagerProp() throws Exception { System.out.println("29-DataService - getEntityManagerProp"); if (error != null) { System.out.println(error); return; } Map<String, Object> props = dataService.getEntityManagerProp(dataLink.getPersistUnit()); assertNotNull(props); }
AbstractDataService implements IDataService { @Override public Map<String, Object> getPersistUnitProp(String persistUnit) { return dao.getPersistUnitProp(persistUnit); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test30GetPersistUnitProp() throws Exception{ System.out.println("30-DataService - getPersistUnitProp"); if (error != null) { System.out.println(error); return; } Map<String, Object> props = dataService.getPersistUnitProp(dataLink.getPersistUnit()); assertNotNull(props); }
AbstractDataService implements IDataService { @Override public IUserSession getUserSession(String sessionId) { return dao.getUserSession(sessionId); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test31GetUserSession() throws Exception{ System.out.println("31-DataService - getUserSession"); if (error != null) { System.out.println(error); return; } assertNotNull(dataService.getUserSession(sessionId)); } @Test public void test32GetDBLinkInfo() throws Exception{ System.out.println("32-DataService - getDBLinkInfo"); if (error != null) { System.out.println(error); return; } IDBLinkInfo info = new DBLinkInfo(); info.setUserSession(dataService.getUserSession(sessionId)); assertNotNull(info.getUserSession()); }
AbstractDataService implements IDataService { @Override public String getDataEngine(String persistentUnit) { return dao.getDataEngine(persistentUnit); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test33GetDataEngine() throws Exception { System.out.println("33-DataService - getDataEngine"); if (error != null) { System.out.println(error); return; } System.out.println(dataService.getDataEngine("PU1")); String expResult = dataService.getDataEngine("PU1"); assertNotNull(expResult); }
AbstractDAO implements IGenericDAO { @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) public <T extends IDataRow> T findByUk(String sessionId, T ejb) throws Exception { LOGGER.debug(Strings.replicate("-", 50)); LOGGER.debug("findByUk"); LOGGER.debug(ejb.getClass().getSimpleName()); if (ejb.getQueryUK() == null) { return null; } IDBLinkInfo dbLinkInfo = sessions.getDBLinkInfo(sessionId); T row; Query q = getEntityManager(getEntityId(dbLinkInfo)).createQuery(ejb.getQueryUK()); for (Parameter param : q.getParameters()) { q.setParameter(param, ejb.getValue(param.getName())); } try { row = (T) q.getSingleResult(); if (Status.STATUS_NO_TRANSACTION == tsr.getTransactionStatus()) { return row; } List<Field> fields = DataInfo.getLazyMembers(row.getClass()); if (!fields.isEmpty()) { List obj; for (Field field : fields) { field.setAccessible(true); obj = (List) field.get(row); obj.size(); } } } catch (NoResultException exp) { row = null; } return row; } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test03FindByUk() throws Exception { System.out.println("3-AbstractDAO - findByUk"); String sessionid = null; if (error != null) { System.out.println(error); return; } AppResource appResource = new AppResource(); appResource.setCode("no se encuentra"); appResource = dao.findByUk(sessionid, appResource); assertNull(appResource); appResource = new AppResource(); appResource.setCode("clasemaker.xml"); appResource = dao.findByUk(sessionid, appResource); assertNotNull(appResource); }
AbstractDataService implements IDataService { @Override public String getSchema(String persistentUnit) { return dao.getSchema(persistentUnit); } @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override IUserSession getUserSession(String sessionId); @Override Map<String, Object> getEntityManagerProp(String persistUnit); @Override Map<String, Object> getPersistUnitProp(String persistUnit); @Override String getDataEngine(String persistentUnit); @Override String getSchema(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) T setFieldsToCheck(T row); @Override T findById(Class<T> entityClass, String sessionId, Object id); @Override T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(String sessionId, T row); @Override Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override boolean checkUniqueKey(String sessionId, T row); @Override boolean checkForeignKey(String sessionId, T row, String fieldName); @Override Map<String, IErrorReg> checkDataRow(String sessionId, T row); @Override IDataResult save(String sessionId, T row); @Override IDataResult persist(String sessionId, T row); @Override IDataResult merge(String sessionId, T row); @Override IDataResult remove(String sessionId, T row); @Override List<T> getDataRows(String sessionId, Class<T> type, String order, String filter, Map<String, Object> params, int firstRow, int maxRows); @Override String getSelectCmd(String sessionId, Class<T> type, String order, String filter); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); @Deprecated @Override Connection getConnection(String sessionId); @Deprecated @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Deprecated @Override List<T> findAll(Class<T> entityClass, String sessionId); @Deprecated @Override IErrorReg sqlExec(String sessionId, String queryString, Map<String, Object> parameters); @Deprecated @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Deprecated @Override List<T> getData(Query query); @Deprecated @Override List<T> refreshAll(String sessionId, List<T> rows); @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) @Override X copyTo(String sessionId, T source, X target); }
@Test public void test34GetSchema() throws Exception { System.out.println("34-DataService - getSchema"); if (error != null) { System.out.println(error); return; } System.out.println(dataService.getSchema("PU1")); String expResult = dataService.getSchema("PU1"); assertNotNull(expResult); }
AbstractDataLink implements IDataLink, Serializable { @Override public String getPersistUnit() { return persistUnit; } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test01GetPersistUnit() { System.out.println("1-DataLink - getPersistUnit"); if (error != null) { System.out.println(error); return; } String result = dataLinkCat.getPersistUnit(); String expResult = "PU1"; assertNotNull(expResult, result); }
AbstractDataLink implements IDataLink, Serializable { @Override public <T extends IDataRow> T findById(Class<T> entityClass, Object id) throws Exception, SessionError { checkUserSession(); if (id == null){ return null; } return getDao().findById(entityClass, getSessionId(), id); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test02Find() throws Exception { System.out.println("2-DataLink - find"); if (error != null) { System.out.println(error); return; } AppUser user = dataLinkCat.findById(AppUser.class, 1L); assertNotNull(user); }
AbstractDataLink implements IDataLink, Serializable { @Override public <T extends IDataRow> T findByUk(T ejb) throws Exception, SessionError { checkUserSession(); if (ejb == null){ return null; } return getDao().findByUk(getSessionId(), ejb); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test03FindByUk() throws Exception { System.out.println("3-DataLink - findByUk"); if (error != null) { System.out.println(error); return; } AppResource appResource = new AppResource(); appResource.setCode("no se encuentra"); appResource = dataLinkCat.findByUk(appResource); assertNull(appResource); appResource = new AppResource(); appResource.setCode("clasemaker.xml"); appResource = dataLinkCat.findByUk(appResource); assertNotNull(appResource); }
AbstractDataLink implements IDataLink, Serializable { @Override public <T extends IDataRow> T findByQuery(String queryString, Map<String, Object> parameters) throws Exception, SessionError { checkUserSession(); parameters = addParams(queryString, parameters); return getDao().findByQuery(getSessionId(), queryString, parameters); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test04FindByQuery() throws Exception { System.out.println("4-DataLink - findByQuery"); if (error != null) { System.out.println(error); return; } AppUser user = dataLinkCat.findByQuery("select o from AppUser o where iduser = 1L", null); assertNotNull(user); user = dataLinkCat.findByQuery("select o from AppUser o where iduser = 0L", null); assertNull(user); Map<String, Object> params = new HashMap(); params.put("iduser", 1L); user = dataLinkCat.findByQuery("select o from AppUser o where iduser = :iduser", params); assertNotNull(user); }
AbstractDataLink implements IDataLink, Serializable { @Override public <T extends IDataRow> List<T> findListByQuery(String queryString, Map<String, Object> parameters) throws Exception, SessionError { checkUserSession(); parameters = addParams(queryString, parameters); return getDao().findListByQuery(getSessionId(), queryString, parameters); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test05FindListByQuery() throws Exception { System.out.println("5-DataLink - findListByQuery"); if (error != null) { System.out.println(error); return; } List<AppUser> users = dataLinkCat.findListByQuery("select o from AppUser o where iduser = 1L", null); assertNotNull(users); users = dataLinkCat.findListByQuery("select o from AppUser o where iduser = 0L", null); assertTrue(users.isEmpty()); Map<String, Object> params = new HashMap(); params.put("iduser", 1L); users = dataLinkCat.findListByQuery("select o from AppUser o where iduser = :iduser", params); assertNotNull(users); }
AbstractDataLink implements IDataLink, Serializable { @Override public <T extends IDataRow> List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters) throws Exception, SessionError { checkUserSession(); return getDao().findListByNamedQuery(getSessionId(), namedQuery, parameters); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test06FindByNamedQuery() throws Exception { System.out.println("6-DataLink - findByNamedQuery"); if (error != null) { System.out.println(error); return; } List<AppTablesRelation> prueba = dataLinkCat.findListByNamedQuery("AppTablesRelation.findAll", null); assertTrue(!prueba.isEmpty()); }
AbstractDataLink implements IDataLink, Serializable { @Override public List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters) throws Exception, SessionError { checkUserSession(); parameters = addParams(queryString, parameters); return getDao().findByNativeQuery(getSessionId(), queryString, parameters); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test07FindByNativeQuery() throws Exception { System.out.println("7-DataLink - findByNativeQuery"); if (error != null) { System.out.println(error); return; } String sqlSentence = "select * from {schema}.moneda where idmoneda > :id"; Map<String, Object> params = new HashMap(); params.put("id", 0); List<Object> query1 = dataLink.findByNativeQuery(sqlSentence, params); assertTrue(!query1.isEmpty()); query1 = dataLink.findByNativeQuery(sqlSentence, params, 0, 10); assertTrue(!query1.isEmpty()); }
AbstractDataLink implements IDataLink, Serializable { @Override public <T extends IDataRow> IDataResult persist(T ejb) throws SessionError{ ejb.setAction(IDataRow.INSERT); return update(ejb); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test09Persist2() throws Exception { System.out.println("9-DataLink - persist2"); if (error != null) { System.out.println(error); return; } Moneda moneda = new Moneda(); moneda.setCodigo("PYG"); moneda.setNombre("Guarani"); moneda.setCambio(BigDecimal.ONE); moneda.setObservacion("34424"); IDataResult dataResult = dataLink.persist(moneda); Moneda monedaResult = dataResult.getRowUpdated(); List<Moneda> monedasResult = dataResult.getRowsUpdated(); assertNull(monedaResult); assertFalse(monedasResult.get(0).getErrors().isEmpty()); for (Map.Entry<String, IErrorReg> entry : monedasResult.get(0).getErrors().entrySet()) { System.out.println("Key: " + entry.getKey() + " fieldName: " + entry.getValue().getFieldName() + " Msg: " + entry.getValue().getMessage()); } } @Test public void test10Persist3() throws Exception { System.out.println("10-DataLink - persist3"); if (error != null) { System.out.println(error); return; } Moneda moneda = new Moneda(); moneda.setCodigo("PYG"); moneda.setNombre("Guarani"); moneda.setCambio(BigDecimal.ONE); moneda.setObservacion("34424"); moneda.setIdempresa(99L); IDataResult dataResult = dataLink.persist(moneda); Moneda monedaResult = dataResult.getRowUpdated(); List<Moneda> monedasResult = dataResult.getRowsUpdated(); assertNull(monedaResult); assertFalse(monedasResult.get(0).getErrors().isEmpty()); assertFalse(dataResult.getErrorMsg().isEmpty()); for (Map.Entry<String, IErrorReg> entry : monedasResult.get(0).getErrors().entrySet()) { System.out.println("Key: " + entry.getKey() + " fieldName: " + entry.getValue().getFieldName() + " Msg: " + entry.getValue().getMessage()); } }
AbstractDAO implements IGenericDAO { @Override public <T extends IDataRow> List<T> find(Class<T> entityClass, String sessionId) throws Exception { return find(entityClass, sessionId, null, null, null, 0, 0); } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test04Find() throws Exception { System.out.println("4-AbstractDAO - find"); String sessionid = null; if (error != null) { System.out.println(error); return; } List<AppUser> users = dao.find(AppUser.class, sessionid); assertTrue(users.size() > 0); String order = "code desc"; String filter = ""; users = dao.find(AppUser.class, sessionid, order, filter, null); assertTrue(users.size() > 0); filter = "code = 'Administrador'"; users = dao.find(AppUser.class, sessionid, order, filter, null); assertTrue(users.size() == 1); filter = "code = :code"; Map<String, Object> params = new HashMap(); params.put("code", "Administrador"); users = dao.find(AppUser.class, sessionid, order, filter, params); assertTrue(users.size() == 1); users = dao.find(AppUser.class, sessionid, null, "", null, 0, 4); assertTrue(users.size() == 4); }
AbstractDataLink implements IDataLink, Serializable { @Override public Long getCount(String queryString, Map<String, Object> parameters) throws Exception, SessionError { checkUserSession(); parameters = addParams(queryString, parameters); return getDao().getCount(getSessionId(), queryString, parameters); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test21GetCount() throws Exception { System.out.println("21-DataLink - getCount"); if (error != null) { System.out.println(error); return; } Long rec = dataLinkCat.getCount("select o FROM AppCompany o", null); assertTrue(rec > 0L); }
AbstractDataLink implements IDataLink, Serializable { @Override public Long getCount2(String queryString, Map<String, Object> parameters) throws Exception, SessionError { checkUserSession(); parameters = addParams(queryString, parameters); return getDao().getCount2(getSessionId(), queryString, parameters); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test22GetCount2() throws Exception { System.out.println("22-DataLink - getCount2"); if (error != null) { System.out.println(error); return; } Long rec = dataLinkCat.getCount2("select * FROM {schema}.empresa", null); assertTrue(rec > 0L); }
AbstractDataLink implements IDataLink, Serializable { @Override public Map<String, Object> getEntityManagerProp() { return getDao().getEntityManagerProp(persistUnit); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test23GetEntityManagerProp() { System.out.println("23-DataLink - getEntityManagerProp"); if (error != null) { System.out.println(error); return; } Map<String, Object> props = dataLinkCat.getEntityManagerProp(); assertNotNull(props); }
AbstractDataLink implements IDataLink, Serializable { @Override public Map<String, Object> getPersistUnitProp() { return getDao().getPersistUnitProp(persistUnit); } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test24GetPersistUnitProp() { System.out.println("24-DataLink - getPersistUnitProp"); if (error != null) { System.out.println(error); return; } Map<String, Object> props = dataLinkCat.getPersistUnitProp(); assertNotNull(props); }
AbstractDataLink implements IDataLink, Serializable { @Override public IUserSession getUserSession() { return userSession; } @Override abstract IGenericDAO getDao(); @Override abstract void setDao(T dao); @Override abstract T getDataService(); @Override String getPersistUnit(); @Override IDataResult persist(T ejb); @Override IDataResult persist(List<T> ejbs); @Override IDataResult merge(T ejb); @Override IDataResult merge(List<T> ejbs); @Override IDataResult remove(T ejb); @Override IDataResult remove(List<T> ejbs); @Override IDataResult update(T ejb); @Override IDataResult update(List<T> ejbs); @Override IDataResult update(IDataSet dataSet); @Override T find(Class<T> entityClass, Object id); @Override T findById(Class<T> entityClass, Object id); @Override T findByUk(T ejb); @Override T findByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters); @Override List<T> findListByQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T findByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters); @Override List<T> findListByNamedQuery(String namedQuery, Map<String, Object> parameters, int first, int max); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters); @Override List<Object> findByNativeQuery(String queryString, Map<String, Object> parameters, int first, int max); @Override T refreshRow(T row); @Override Long getCount(String queryString, Map<String, Object> parameters); @Override Long getCount2(String queryString, Map<String, Object> parameters); @Override Map<String, Object> getEntityManagerProp(); @Override Map<String, Object> getPersistUnitProp(); @Override IUserSession getUserSession(); @Override void setUserSession(IUserSession userSession); @Override IDataNativeQuery newDataNativeQuery(); @Override String getEntitiesRelation(String entities, String typeRela, String schema); @Override IDBLinkInfo getDBLinkInfo(); @Override String getToken(); @Override void setToken(String token); @Override Long getIdCompany(); }
@Test public void test25GetUserSession() { System.out.println("25-DataLink - getUserSession"); if (error != null) { System.out.println(error); return; } assertNotNull(dataLink.getUserSession()); }
DataRow implements IDataRow, Cloneable { @XmlTransient @Override public Object getValue(String fieldname) { if (fieldsOldValues == null) { this.setOldValues(); } return DataInfo.getFieldValue(this, fieldname); } DataRow(); @Override Object clone(); @Override void setOldValues(); @Override Object getOldValue(String fieldName); @Override int getAction(); @Override String getQueryUK(); @Override String getIdFunctionFind(); @Override boolean isRowChecked(); @Override void setRowChecked(boolean checkrow); @Override boolean isFieldChecked(String fieldName); @Override Map getFieldsChecked(); @Override void setFieldsChecked(Map fieldChecked); @Override void setFieldChecked(String fieldName, boolean checkField); @Override Map<String, IErrorReg> getErrors(); @Override void setErrors(Map<String, IErrorReg> errorReg); @Override void setErrors(IErrorReg errorReg, String fieldName); @Override void setErrors(String errorMsg, String fieldname, int errorNumber); @Override void setAction(int action); @XmlTransient @Override Object getId(); @XmlTransient @Override Object getRowkey(); @XmlTransient @Override Object getValue(String fieldname); @XmlTransient @Override Class getFieldType(String fieldname); @XmlTransient @Override void setId(Object id); @Override void setValue(String fieldname, Object value); @Override boolean delete(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean equivalent(Object o); @XmlTransient @Override boolean isApplyDBFilter(); @Override boolean checkFieldIdcompany(Long idcompany); @Override void onGetter(String fieldName); @Override void onSetter(String fieldName, Object fieldValueNew, Object fieldValueOld); @Override void setDefaults(); }
@Test public void testGetValue() { System.out.println("DataRow - getValue"); String expResult = "codigo nombre"; DataRowPrb row = new DataRowPrb(); String result = (String)row.getValue("codigo"); assertEquals("codigo", result); result = (String)row.getValue("publicCodigoNombre"); assertEquals(expResult, result); result = (String)row.getValue("noexiste"); assertNull(result); result = (String)row.getValue("privateCodigoNombre"); assertNull(result); result = (String)row.getValue("child.publicCodigoNombre"); assertEquals(expResult, result); result = (String)row.getValue("childGetter.publicCodigoNombre"); assertEquals(expResult, result); Object result2 = ((IDataRow)row.getValue("child")).getId(); assertEquals(1L, result2); }
DataRow implements IDataRow, Cloneable { @XmlTransient @Override public Class getFieldType(String fieldname) { Class result = DataInfo.getFieldType(this.getClass(), fieldname); if (result == null) { result = DataInfo.getMethodReturnType(this.getClass(), fieldname, true); } return result; } DataRow(); @Override Object clone(); @Override void setOldValues(); @Override Object getOldValue(String fieldName); @Override int getAction(); @Override String getQueryUK(); @Override String getIdFunctionFind(); @Override boolean isRowChecked(); @Override void setRowChecked(boolean checkrow); @Override boolean isFieldChecked(String fieldName); @Override Map getFieldsChecked(); @Override void setFieldsChecked(Map fieldChecked); @Override void setFieldChecked(String fieldName, boolean checkField); @Override Map<String, IErrorReg> getErrors(); @Override void setErrors(Map<String, IErrorReg> errorReg); @Override void setErrors(IErrorReg errorReg, String fieldName); @Override void setErrors(String errorMsg, String fieldname, int errorNumber); @Override void setAction(int action); @XmlTransient @Override Object getId(); @XmlTransient @Override Object getRowkey(); @XmlTransient @Override Object getValue(String fieldname); @XmlTransient @Override Class getFieldType(String fieldname); @XmlTransient @Override void setId(Object id); @Override void setValue(String fieldname, Object value); @Override boolean delete(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean equivalent(Object o); @XmlTransient @Override boolean isApplyDBFilter(); @Override boolean checkFieldIdcompany(Long idcompany); @Override void onGetter(String fieldName); @Override void onSetter(String fieldName, Object fieldValueNew, Object fieldValueOld); @Override void setDefaults(); }
@Test public void testGetFieldType() { System.out.println("DataRow - getFieldType"); Class expResult = String.class; DataRowPrb row = new DataRowPrb(); Class result = row.getFieldType("codigo"); assertEquals(expResult, result); result = row.getFieldType("publicCodigoNombre"); assertEquals(expResult, result); result = row.getFieldType("noexiste"); assertNull(result); result = row.getFieldType("privateCodigoNombre"); assertNull(result); result = row.getFieldType("publicCodigoNombre"); assertEquals(expResult, result); result = row.getFieldType("child.publicCodigoNombre"); assertEquals(expResult, result); result = row.getFieldType("getChild.getPublicCodigoNombre"); assertEquals(expResult, result); result = row.getFieldType("child.getPublicCodigoNombre"); assertEquals(expResult, result); result = row.getFieldType("childGetter.publicCodigoNombre"); assertEquals(expResult, result); result = row.getFieldType("childGetter.getPublicCodigoNombre"); assertEquals(expResult, result); }
DataRow implements IDataRow, Cloneable { @Override public void setValue(String fieldname, Object value) throws FieldException { if (fieldsOldValues == null) { this.setOldValues(); } Boolean exito = DataInfo.setFieldValue(this, fieldname, value); if (!exito) { LOGGER.error("fieldname: " + fieldname); throw new FieldException("Error en " + fieldname + ", no existe el campo o el tipo es incorrecto"); } if (this.action == 0) { this.action = IDataRow.UPDATE; } } DataRow(); @Override Object clone(); @Override void setOldValues(); @Override Object getOldValue(String fieldName); @Override int getAction(); @Override String getQueryUK(); @Override String getIdFunctionFind(); @Override boolean isRowChecked(); @Override void setRowChecked(boolean checkrow); @Override boolean isFieldChecked(String fieldName); @Override Map getFieldsChecked(); @Override void setFieldsChecked(Map fieldChecked); @Override void setFieldChecked(String fieldName, boolean checkField); @Override Map<String, IErrorReg> getErrors(); @Override void setErrors(Map<String, IErrorReg> errorReg); @Override void setErrors(IErrorReg errorReg, String fieldName); @Override void setErrors(String errorMsg, String fieldname, int errorNumber); @Override void setAction(int action); @XmlTransient @Override Object getId(); @XmlTransient @Override Object getRowkey(); @XmlTransient @Override Object getValue(String fieldname); @XmlTransient @Override Class getFieldType(String fieldname); @XmlTransient @Override void setId(Object id); @Override void setValue(String fieldname, Object value); @Override boolean delete(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean equivalent(Object o); @XmlTransient @Override boolean isApplyDBFilter(); @Override boolean checkFieldIdcompany(Long idcompany); @Override void onGetter(String fieldName); @Override void onSetter(String fieldName, Object fieldValueNew, Object fieldValueOld); @Override void setDefaults(); }
@Test public void testSetValue() throws Exception { System.out.println("DataRow - setValue"); String fieldname = "codigo"; Object value = "codigocambiado"; DataRow row = new DataRowPrb(); row.setValue(fieldname, value); assertEquals("codigocambiado", row.getValue(fieldname)); fieldname = "child.codigo"; value = "codigocambiado"; row.setValue(fieldname, value); assertEquals("codigocambiado", row.getValue(fieldname)); }
DataRow implements IDataRow, Cloneable { @Override public int hashCode() { int hash = 0; hash += (getId() != null ? getId().hashCode() : 0); hash *= getClass().getName().hashCode(); return hash; } DataRow(); @Override Object clone(); @Override void setOldValues(); @Override Object getOldValue(String fieldName); @Override int getAction(); @Override String getQueryUK(); @Override String getIdFunctionFind(); @Override boolean isRowChecked(); @Override void setRowChecked(boolean checkrow); @Override boolean isFieldChecked(String fieldName); @Override Map getFieldsChecked(); @Override void setFieldsChecked(Map fieldChecked); @Override void setFieldChecked(String fieldName, boolean checkField); @Override Map<String, IErrorReg> getErrors(); @Override void setErrors(Map<String, IErrorReg> errorReg); @Override void setErrors(IErrorReg errorReg, String fieldName); @Override void setErrors(String errorMsg, String fieldname, int errorNumber); @Override void setAction(int action); @XmlTransient @Override Object getId(); @XmlTransient @Override Object getRowkey(); @XmlTransient @Override Object getValue(String fieldname); @XmlTransient @Override Class getFieldType(String fieldname); @XmlTransient @Override void setId(Object id); @Override void setValue(String fieldname, Object value); @Override boolean delete(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean equivalent(Object o); @XmlTransient @Override boolean isApplyDBFilter(); @Override boolean checkFieldIdcompany(Long idcompany); @Override void onGetter(String fieldName); @Override void onSetter(String fieldName, Object fieldValueNew, Object fieldValueOld); @Override void setDefaults(); }
@Test public void testHashcode() { System.out.println("DataRow - HashCode"); DataRowPrb row = new DataRowPrb(); row.setId(2L); int hashCode = row.hashCode(); System.out.println(row.hashCode()); for (int i = 0;i<10;i++){ int hashCode2 = row.hashCode(); assertEquals(hashCode, hashCode2); } row.setId(999999999999999L); System.out.println(row.hashCode()); row.setId(-999999999999999L); System.out.println(row.hashCode()); }
DataInfo { public static <T extends IDataRow> boolean isPrimaryKey(Class<T> classType, String fieldname) { try { Field field = DataInfo.getDeclaredField(classType, fieldname); Id id = field.getAnnotation(Id.class); return id != null; } catch (Exception ex) { return false; } } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test01IsPrimaryKey() { System.out.println("1-DataInfo - isPrimaryKey"); boolean expResult = true; boolean result = DataInfo.isPrimaryKey(AppUser.class, "iduser"); assertEquals(expResult, result); result = DataInfo.isPrimaryKey(AppUser.class, "code"); assertEquals(false, result); result = DataInfo.isPrimaryKey(AppUser.class, "noexiste"); assertEquals(false, result); }
AbstractDAO implements IGenericDAO { @Override public <T extends IDataRow> T findByQuery(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { LOGGER.debug(Strings.replicate("-", 50)); LOGGER.debug("findByQuery"); LOGGER.debug(queryString); IDBLinkInfo dbLinkInfo = sessions.getDBLinkInfo(sessionId); EntityManager em = getEntityManager(getEntityId(dbLinkInfo)); Query query = em.createQuery(queryString); if (parameters != null && !parameters.isEmpty()) { populateQueryParameters(query, parameters, queryString); } T result; try { result = (T) query.getSingleResult(); if (Status.STATUS_NO_TRANSACTION == tsr.getTransactionStatus()) { return result; } List<Field> fields = DataInfo.getLazyMembers(result.getClass()); if (!fields.isEmpty()) { List obj; for (Field field : fields) { field.setAccessible(true); obj = (List) field.get(result); obj.size(); } } } catch (NoResultException exp) { result = null; } catch (Exception exp){ ErrorManager.showError(exp, LOGGER); throw exp; } LOGGER.debug("-RESULT-"); LOGGER.debug(result); return result; } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test05FindByQuery() throws Exception { System.out.println("5-AbstractDAO - findByQuery"); String sessionid = null; if (error != null) { System.out.println(error); return; } AppUser user = dao.findByQuery(sessionid, "select o from AppUser o where iduser = 1L", null); assertNotNull(user); user = dao.findByQuery(sessionid, "select o from AppUser o where iduser = 0L", null); assertNull(user); Map<String, Object> params = new HashMap(); params.put("iduser", 1L); user = dao.findByQuery(sessionid, "select o from AppUser o where iduser = :iduser", params); assertNotNull(user); }
DataInfo { public static <T extends IDataRow> boolean isUniqueKey(Class<T> classType, String fieldname) { try { String[] fields = DataInfo.getUniqueFields(classType); if (fields == null) { return false; } for (String field : fields) { if (field.equalsIgnoreCase(fieldname.toLowerCase())) { return true; } } return false; } catch (Exception exp) { return false; } } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test02IsUniqueKey() { System.out.println("2-DataInfo - isUniqueKey"); boolean expResult = true; boolean result = DataInfo.isUniqueKey(AppResource.class, "code"); assertEquals(expResult, result); result = DataInfo.isUniqueKey(AppResource.class, "referencetime"); assertEquals(false, result); result = DataInfo.isUniqueKey(AppResource.class, "noexiste"); assertEquals(false, result); }
DataInfo { public static <T extends IDataRow> boolean isForeignKey(Class<T> classType, String fieldname) { try { Field field = DataInfo.getDeclaredField(classType, fieldname); JoinColumn idforeignkey = field.getAnnotation(JoinColumn.class); return idforeignkey != null; } catch (Exception ex) { return false; } } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test03IsForeignKey() { System.out.println("3-DataInfo - isForeignKey"); boolean expResult = true; boolean result = DataInfo.isForeignKey(AppUserMember.class, "usermember"); assertEquals(expResult, result); result = DataInfo.isForeignKey(AppUserMember.class, "usergroup"); assertEquals(expResult, result); result = DataInfo.isForeignKey(AppUserMember.class, "otro"); assertEquals(false, result); result = DataInfo.isForeignKey(AppUserMember.class, "idusermembar"); assertEquals(false, result); }
DataInfo { public static <T extends IDataRow> boolean isFieldExist(Class<T> classType, String fieldname) { try { Field field = DataInfo.getDeclaredField(classType, fieldname); if (field != null) { return true; } } catch (Exception ex) { ErrorManager.showError(ex, LOGGER); } return false; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test04IsFieldExist() { System.out.println("4-DataInfo - isFieldExist"); boolean expResult = true; boolean result = DataInfo.isFieldExist(AppUser.class, "iduser"); assertEquals(expResult, result); result = DataInfo.isFieldExist(AppUser.class, "noexiste"); assertEquals(false, result); }
DataInfo { public static <T extends IDataRow> boolean isLazyFetch(Class<T> classType, String fieldname) { try { Field field = DataInfo.getDeclaredField(classType, fieldname); OneToMany annotation = field.getAnnotation(OneToMany.class); return annotation.fetch() == FetchType.LAZY; } catch (Exception ex) { return false; } } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test05IsLazyFetch() { System.out.println("5-DataInfo - isLazyFetch"); boolean expResult = true; boolean result = DataInfo.isLazyFetch(AppUserFormView.class, "appUserFormViewColumnList"); assertEquals(expResult, result); result = DataInfo.isLazyFetch(AppUserFormView.class, "usergroup"); assertEquals(false, result); result = DataInfo.isLazyFetch(AppUserFormView.class, "noexiste"); assertEquals(false, result); }
DataInfo { public static <T extends IDataRow> List<Field> getLazyMembers(Class<T> classType) { try { Field[] fields = classType.getDeclaredFields(); List<Field> lazyFields = new ArrayList(); for (Field field : fields) { OneToMany annotation = field.getAnnotation(OneToMany.class); if (annotation != null) { if (annotation.fetch() == FetchType.LAZY) { lazyFields.add(field); } } } return lazyFields; } catch (Exception ex) { ErrorManager.showError(ex, LOGGER); } return new ArrayList(); } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test06GetLazyMembers() { System.out.println("6-DataInfo - getLazyMembers"); List<Field> result = DataInfo.getLazyMembers(AppUserFormView.class); assertTrue(!result.isEmpty()); result = DataInfo.getLazyMembers(AppTablesRelation.class); assertTrue(result.isEmpty()); }
DataInfo { public static <T extends IDataRow> String getTableName(Class<T> classType) { try { Table entity = classType.getAnnotation(Table.class); return entity.name(); } catch (Exception ex) { ErrorManager.showError(ex, LOGGER); } return ""; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test07GetTableName() { System.out.println("7-DataInfo - getTableName"); String expResult = "appuser"; String result = DataInfo.getTableName(AppUser.class); assertEquals(expResult, result); }
DataInfo { public static String createQueryUkCommand(IDataRow ejb) { try { String command = "select o from " + ejb.getClass().getSimpleName() + " o "; if (!ejb.getIdFunctionFind().equals("")) { command = command + " where " + "o." + DataInfo.getIdFieldName(ejb.getClass()) + " = :" + ejb.getIdFunctionFind(); return command; } String uniqueFilter = ""; String separador = ""; String[] uniqueList = DataInfo.getUniqueFields(ejb.getClass()); if (uniqueList == null) { return null; } for (String fieldName : uniqueList) { uniqueFilter = uniqueFilter + separador + " o." + fieldName + " = :" + fieldName; separador = " and "; } command = command + " where " + uniqueFilter; return command; } catch (Exception ex) { ErrorManager.showError(ex, LOGGER); } return null; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test08CreateQueryUkCommand() { System.out.println("8-DataInfo - createQueryUkCommand"); IDataRow ejb = new AppResource(); String expResult = "select o from AppResource o where o.code = :code"; String result = DataInfo.createQueryUkCommand(ejb); assertEquals(expResult, result); }
DataInfo { public static <T extends IDataRow> String getIdFieldName(Class<T> classType) { try { Field[] fields = classType.getDeclaredFields(); for (Field field : fields) { Id id = field.getAnnotation(Id.class); if (id != null) { return field.getName(); } } return null; } catch (SecurityException ex) { ErrorManager.showError(ex, LOGGER); } return null; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test09GetIdFieldName() { System.out.println("9-DataInfo - getIdFieldName"); String expResult = "iduser"; String result = DataInfo.getIdFieldName(AppUser.class); assertEquals(expResult, result); }
DataInfo { public static <T extends IDataRow> String[] getUniqueFields(Class<T> classType) { try { String[] uniqueConst = classType.getAnnotation(Table.class).uniqueConstraints()[0].columnNames(); if (uniqueConst != null) { return uniqueConst; } } catch (Exception ex) { ErrorManager.showError(ex, LOGGER); } return null; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test10GetUniqueFields() { System.out.println("10-DataInfo - getUniqueFields"); String[] expResult = {"code"}; String[] result = DataInfo.getUniqueFields(AppResource.class); assertArrayEquals(expResult, result); }
DataInfo { public static Object getIdvalue(IDataRow ejb) { try { String field = DataInfo.getIdFieldName(ejb.getClass()); if (field != null) { return ejb.getValue(field); } return null; } catch (Exception ex) { ErrorManager.showError(ex, LOGGER); } return null; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test11GetIdvalue() { System.out.println("11-DataInfo - getIdvalue"); AppResource ejb = new AppResource(); ejb.setIdappresource(1L); Object expResult = 1L; Object result = DataInfo.getIdvalue(ejb); assertEquals(expResult, result); }
AbstractDAO implements IGenericDAO { @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) public <T extends IDataRow> List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { return findListByQuery(sessionId, queryString, parameters, 0, 0); } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test06FindListByQuery() throws Exception { System.out.println("6-AbstractDAO - findListByQuery"); String sessionid = null; if (error != null) { System.out.println(error); return; } List<AppUser> users = dao.findListByQuery(sessionid, "select o from AppUser o where iduser = 1L", null); assertNotNull(users); users = dao.findListByQuery(sessionid, "select o from AppUser o where iduser = 0L", null); assertTrue(users.isEmpty()); Map<String, Object> params = new HashMap(); params.put("iduser", 1L); users = dao.findListByQuery(sessionid, "select o from AppUser o where iduser = :iduser", params); assertNotNull(users); }
DataInfo { public static <T extends IDataRow> Object getDefaultValue(T ejb, String fieldname) { Object valor = null; Class<?> classObj = ejb.getClass(); try { Field field = DataInfo.getDeclaredField(classObj, fieldname + "_default"); field.setAccessible(true); valor = field.get(ejb); } catch (SecurityException | IllegalArgumentException | IllegalAccessException | NullPointerException ex) { ErrorManager.showError(ex, LOGGER); } return valor; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test13GetDefaultValue() { System.out.println("13-DataInfo - getDefaultValue"); DataRow ejb = new DataInfoPrb(); String fieldname = "codigo"; Object expResult = "codigodefault"; Object result = DataInfo.getDefaultValue(ejb, fieldname); assertEquals(expResult, result); }
DataInfo { public static <T extends IDataRow> void setDefaultValue(T ejb, String fieldname) { Object valor; Class<?> classObj = ejb.getClass(); try { Field field = DataInfo.getDeclaredField(classObj, fieldname); field.setAccessible(true); valor = DataInfo.getDefaultValue(ejb, fieldname); if (valor != null) { field.set(ejb, valor); if (ejb.getAction() == 0) { ejb.setAction(IDataRow.UPDATE); } } } catch (Exception ex) { ErrorManager.showError(ex, LOGGER); } } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test15SetDefaultValue() { System.out.println("15-DataInfo - setDefaultValue"); DataRow ejb = new DataInfoPrb(); String fieldname = "codigo"; DataInfo.setDefaultValue(ejb, fieldname); Object expResult = "codigodefault"; Object result = ejb.getValue(fieldname); assertEquals(expResult, result); }
DataInfo { public static Class getFieldType(Class classType, String fieldname) { Class cls = null; try { if (fieldname.contains(".")) { String className = fieldname.substring(0, Strings.findString(".", fieldname)); Class classMember = classType.getDeclaredField(className).getType(); fieldname = fieldname.substring(Strings.findString(".", fieldname) + 1); cls = getFieldType(classMember, fieldname); } else { cls = getDeclaredField(classType, fieldname).getType(); } } catch (NoSuchFieldException | NullPointerException ex) { cls = null; } catch (SecurityException ex) { ErrorManager.showError(ex, LOGGER); } return cls; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test16GetFieldType() { System.out.println("16-DataInfo - getFieldType"); Class expResult = Long.class; Class result = DataInfo.getFieldType(AppResource.class, "idappresource"); assertEquals(expResult, result); result = DataInfo.getFieldType(AppResource.class, "noexiste"); assertNull(result); }
DataInfo { public static Object getFieldValue(Object ejb, String fieldname) { Object value = null; try { if (fieldname.contains(".")) { String memberName = fieldname.substring(0, Strings.findString(".", fieldname)); fieldname = fieldname.substring(Strings.findString(".", fieldname) + 1); Field field = getDeclaredField(ejb.getClass(), memberName); if (field != null) { field.setAccessible(true); Object parentValue = field.get(ejb); value = getFieldValue(parentValue, fieldname); } else { Method method = getMethod(ejb.getClass(), "get" + Strings.capitalize(memberName)); if (method != null) { method.setAccessible(true); Object parentValue = method.invoke(ejb); value = getFieldValue(parentValue, fieldname); } } } else { Field field = getDeclaredField(ejb.getClass(), fieldname); if (field != null) { field.setAccessible(true); value = field.get(ejb); } else { Method method = getMethod(ejb.getClass(), "get" + Strings.capitalize(fieldname)); if (method != null) { method.setAccessible(true); value = method.invoke(ejb); } } } } catch (Exception ex) { return null; } return value; } private DataInfo(); static boolean isPrimaryKey(Class<T> classType, String fieldname); static boolean isUniqueKey(Class<T> classType, String fieldname); static boolean isForeignKey(Class<T> classType, String fieldname); static boolean isFieldExist(Class<T> classType, String fieldname); static boolean isMethodExist(Class<T> classType, String methodName); static boolean isLazyFetch(Class<T> classType, String fieldname); static List<Field> getLazyMembers(Class<T> classType); static String getTableName(Class<T> classType); static String createQueryUkCommand(IDataRow ejb); static String getIdFieldName(Class<T> classType); static String[] getUniqueFields(Class<T> classType); static Object getIdvalue(IDataRow ejb); static boolean setIdvalue(IDataRow ejb, Object value); static Object getDefaultValue(T ejb, String fieldname); static void setDefaultValue(T ejb, String fieldname); static T getObjFk(T ejb, String objrelaName); static Field getDeclaredField(Class classType, String fieldname); static Field[] getDeclaredFields(Class classType); static Method getMethod(Class classType, String methodName); static Class getFieldType(Class classType, String fieldname); static Class getMethodReturnType(Class classType, String methodname); static Class getMethodReturnType(Class classType, String methodname, Boolean isGetter); static Object getFieldValue(Object ejb, String fieldname); static Boolean setFieldValue(Object ejb, String fieldname, Object value); }
@Test public void test18GetFieldValue() { System.out.println("18-DataInfo - getFieldValue"); AppTablesRelation ejb = new AppTablesRelation(); ejb.setEntityPK("xx1"); ejb.setEntityFK("xx2"); ejb.setFechacreacion(new Date()); ejb.setFechamodificacion(new Date()); ejb.setFieldsFK("id"); ejb.setFieldsPK("id"); ejb.setIncluded(false); String result = (String) DataInfo.getFieldValue(ejb, "fieldsFK"); assertEquals("id", result); result = (String) DataInfo.getFieldValue(ejb, "noexiste"); assertNull(result); DataInfoPrb infoPrb = new DataInfoPrb(); infoPrb.setCodigo("codigo"); infoPrb.setNombre("nombre"); result = (String) DataInfo.getFieldValue(infoPrb, "publicCodigoNombre"); String expResult = "codigo nombre"; assertEquals(expResult, result); result = (String) DataInfo.getFieldValue(infoPrb, "privateCodigoNombre"); assertNull(result); result = (String) DataInfo.getFieldValue(infoPrb, "protectedCodigoNombre"); assertNull(result); result = (String) DataInfo.getFieldValue(infoPrb, "child.publicCodigoNombre"); assertEquals(expResult, result); result = (String) DataInfo.getFieldValue(infoPrb, "childGetter.publicCodigoNombre"); assertEquals(expResult, result); }
JsonUtil { public static <T extends IDataQueryModel> JsonArray create(List<T> data) { if (data == null){ return null; } Map<String, Object> config = new HashMap(); config.put("javax.json.stream.JsonGenerator.prettyPrinting", true); JsonBuilderFactory factory = Json.createBuilderFactory(config); JsonArrayBuilder builder = factory.createArrayBuilder(); data.forEach((row) -> { for (String columnName : row.getColumnList()) { Object value = row.getColumn(columnName); Class<?> classMember = null; JsonObjectBuilder objectBuilder = Json.createObjectBuilder(); if (row.getColumn(columnName) != null){ classMember = row.getColumn(columnName).getClass(); } if (classMember == null || value == null) { objectBuilder.add(columnName, JsonValue.NULL); } else if (classMember.getSimpleName().equals("String")) { objectBuilder.add(columnName, ((String)value).trim()); } else if (classMember.getSimpleName().equals("BigDecimal")) { objectBuilder.add(columnName, (BigDecimal)value); } else if (classMember.getSimpleName().equals("Long")) { objectBuilder.add(columnName, (Long)value); } else if (classMember.getSimpleName().equals("Date") || classMember.getSimpleName().equals("Timestamp") || classMember.getSimpleName().equals("LocalDateTime")) { value = Dates.toString((Date) row.getColumn(columnName), "yyyy-MM-dd'T'HH:mm:ss"); objectBuilder.add(columnName, (String)value); } else if (classMember.getSimpleName().equals("Short")) { objectBuilder.add(columnName, (Short)value); } else if (classMember.getSimpleName().equals("Integer")) { objectBuilder.add(columnName, (Integer)value); } else if (classMember.getSimpleName().equals("Character")) { objectBuilder.add(columnName, (Character)value); } else if (classMember.getSimpleName().equals("Boolean")) { objectBuilder.add(columnName, (Boolean)value); } else { objectBuilder.add(columnName, value.toString()); } builder.add(objectBuilder.build()); } }); return builder.build(); } static JsonArray create(List<T> data); }
@Test public void testCreate() throws Exception{ System.out.println("1-JsonUtil - create"); if (error != null) { System.out.println(error); return; } DataNativeQuery query = (DataNativeQuery)dataLink.newDataNativeQuery(); List<IDataQueryModel> data = query.select("codigo, nombre, cambio, fechacreacion, fechareplicacion") .from("moneda") .execQuery(); JsonArray model = JsonUtil.create(data); assertFalse(model.toString().isEmpty()); model = JsonUtil.create(null); assertTrue(model == null); model = JsonUtil.create(new ArrayList()); assertTrue(model.toString().equals("[]")); data = query.select("codigo, nombre, noedit") .from("pais") .execQuery(); model = JsonUtil.create(data); assertFalse(model.toString().isEmpty()); data = query.select("codigo, nombre, noedit") .from("ctacte") .execQuery(0,100); model = JsonUtil.create(data); assertFalse(model.toString().isEmpty()); }
DigestAuth { public boolean check(ClientAuth requestAuth) { if (requestAuth.getType().equals(BASIC) && isValidTypeAuth(BASIC)) { return checkBasic(requestAuth); } if (requestAuth.getType().equals(DIGEST) && isValidTypeAuth(DIGEST)) { if (checkMD5(requestAuth)) { serverAuthMap.remove(requestAuth.getNonce()); return true; } if (checkMD5_Sess(requestAuth)) { serverAuthMap.remove(requestAuth.getNonce()); return true; } ServerAuth responseAuth = serverAuthMap.get(requestAuth.getNonce()); if (responseAuth != null) { responseAuth.increment(); if (responseAuth.getNonceCount() > getNumberCanFail()) { serverAuthMap.remove(requestAuth.getNonce()); } } } return false; } DigestAuth(); DigestAuth(String typeAuth, String realm, String qop); String getResponseHeader(ServerAuth responseAuth); ServerAuth createResponseAuth(); ServerAuth createResponseAuth(String typeAuth, String nonce, String realm); void purgeResponseAuth(); ServerAuth getResponseAuth(String nonce); boolean isNonceExist(String nonce); String getOpaque(String nonce); boolean check(ClientAuth requestAuth); boolean checkBasic(ClientAuth clientAuth); boolean checkMD5(ClientAuth clientAuth); boolean checkMD5_Sess(ClientAuth clientAuth); boolean compareServerAndClientAuth(ClientAuth requestAuth, ServerAuth responseAuth); String getType(); void setType(String type); String getRealm(); void setRealm(String realm); String getQop(); void setQop(String qop); int getNumberCanFail(); void setNumberCanFail(int numberCanFail); int getSecondsIdle(); void setSecondsIdle(int secondsIdle); List<String> getTypeAuthValids(); void setTypeAuthValids(List<String> typeAuthValid); List<String> getAlgorithmValids(); void setAlgorithmValids(List<String> algorithmValids); List<String> getQopValids(); void setQopValids(List<String> qopValids); final static String BASIC; final static String DIGEST; }
@Test public void testCheck() throws Exception { System.out.println("check"); boolean expResult = true; DigestAuth auth = new DigestAuth(); String header = "Basic YWRtaW46cGFzc3dvcmQ="; auth.createResponseAuth(DigestAuth.BASIC,"admin",""); auth.getResponseAuth("admin").setUsername("admin"); auth.getResponseAuth("admin").setPassword("password"); ClientAuth requestAuth = new ClientAuth("GET",header,""); boolean result = auth.checkBasic(requestAuth); assertEquals(expResult, result); header = "Digest username=\"admin\", realm=\"ldap\", nonce=\"\", uri=\"/digest-auth\", response=\"885d2f93dceb6077d8167e00d8111902\", opaque=\"\""; auth.createResponseAuth(DigestAuth.DIGEST,"","ldap"); auth.getResponseAuth("").setUsername("admin"); auth.getResponseAuth("").setPassword("password"); requestAuth = new ClientAuth("GET",header,""); result = auth.checkMD5(requestAuth); assertEquals(expResult, result); header = "Digest username=\"admin\", realm=\"ldap\", nonce=\"\", uri=\"/digest-auth\", qop=auth, nc=, cnonce=\"\", response=\"7197e78bdbbf865c75d8d0b0e3e8466f\", opaque=\"\""; requestAuth = new ClientAuth("GET",header,""); result = auth.checkMD5(requestAuth); assertEquals(expResult, result); header = "Digest username=\"admin\", realm=\"ldap\", nonce=\"\", uri=\"/digest-auth\", qop=auth-int, nc=, cnonce=\"\", response=\"d638e3ff4888119971d73d73005759b1\", opaque=\"\""; requestAuth = new ClientAuth("POST",header,"prueba entity body\n"); result = auth.checkMD5(requestAuth); assertEquals(expResult, result); header = "Digest username=\"admin\", realm=\"ldap\", nonce=\"\", uri=\"/rest/v2/all\", nc=, cnonce=\"\", response=\"0f20da8e35fdf53cd4e730edbe4c992f\", opaque=\"\""; requestAuth = new ClientAuth("GET",header,""); result = auth.checkMD5_Sess(requestAuth); assertEquals(expResult, result); header = "Digest username=\"admin\", realm=\"ldap\", nonce=\"\", uri=\"/rest/v2/all\", qop=auth, nc=, cnonce=\"\", response=\"d3a8fb5bb9ed6923a48bf32f8d6a3683\", opaque=\"\""; requestAuth = new ClientAuth("GET",header,""); result = auth.checkMD5_Sess(requestAuth); assertEquals(expResult, result); header = "Digest username=\"admin\", realm=\"ldap\", nonce=\"\", uri=\"/digest-auth\", qop=auth-int, nc=, cnonce=\"\", response=\"976f31cf01fbeca7a277326e0085ec92\", opaque=\"\""; requestAuth = new ClientAuth("POST",header,"prueba entity body\n"); result = auth.checkMD5_Sess(requestAuth); assertEquals(expResult, result); result = auth.check(requestAuth); assertEquals(expResult, result); result = auth.check(requestAuth); assertFalse(result); }
DigestAuth { public boolean checkMD5(ClientAuth clientAuth) { if (!isValidTypeAuth(DIGEST)){ return false; } if (!isValidAlgoritm("MD5")){ return false; } ServerAuth serverAuth = getResponseAuth(clientAuth.getNonce()); if (!compareServerAndClientAuth(clientAuth, serverAuth)) { return false; } String result = ""; String ha1 = DigestUtil.md5(clientAuth.getUsername() + ":" + clientAuth.getRealm() + ":" + serverAuth.getPassword()); String ha2 = DigestUtil.md5(clientAuth.getMethod() + ":" + clientAuth.getUri()); String qop = clientAuth.getQop(); if (clientAuth.getQop().equals("auth-int")) { if (isNullorEmpty(clientAuth.getEntityBody())) { qop = "auth"; } } if (qop.isEmpty()) { result = DigestUtil.md5(ha1 + ":" + clientAuth.getNonce() + ":" + ha2); } else if (qop.equals("auth")) { result = DigestUtil.md5(ha1 + ":" + clientAuth.getNonce() + ":" + clientAuth.getNonceCount() + ":" + clientAuth.getCnonce() + ":" + clientAuth.getQop() + ":" + ha2); } else if (qop.equals("auth-int")) { ha2 = DigestUtil.md5(clientAuth.getMethod() + ":" + clientAuth.getUri() + ":" + DigestUtil.md5(clientAuth.getEntityBody())); result = DigestUtil.md5(ha1 + ":" + clientAuth.getNonce() + ":" + clientAuth.getNonceCount() + ":" + clientAuth.getCnonce() + ":" + clientAuth.getQop() + ":" + ha2); } return clientAuth.getResponse().equals(result); } DigestAuth(); DigestAuth(String typeAuth, String realm, String qop); String getResponseHeader(ServerAuth responseAuth); ServerAuth createResponseAuth(); ServerAuth createResponseAuth(String typeAuth, String nonce, String realm); void purgeResponseAuth(); ServerAuth getResponseAuth(String nonce); boolean isNonceExist(String nonce); String getOpaque(String nonce); boolean check(ClientAuth requestAuth); boolean checkBasic(ClientAuth clientAuth); boolean checkMD5(ClientAuth clientAuth); boolean checkMD5_Sess(ClientAuth clientAuth); boolean compareServerAndClientAuth(ClientAuth requestAuth, ServerAuth responseAuth); String getType(); void setType(String type); String getRealm(); void setRealm(String realm); String getQop(); void setQop(String qop); int getNumberCanFail(); void setNumberCanFail(int numberCanFail); int getSecondsIdle(); void setSecondsIdle(int secondsIdle); List<String> getTypeAuthValids(); void setTypeAuthValids(List<String> typeAuthValid); List<String> getAlgorithmValids(); void setAlgorithmValids(List<String> algorithmValids); List<String> getQopValids(); void setQopValids(List<String> qopValids); final static String BASIC; final static String DIGEST; }
@Test public void testCheckMD5() throws Exception{ String header = "Digest username=\"admin\", realm=\"ldap\", nonce=\"f09cecf114d72dcb1ba99e02ac448687\", " + "uri=\"/digest-auth\", response=\"aac60f90b7712c712735645b9cbbc767\", opaque=\"\""; DigestAuth auth = new DigestAuth(); auth.createResponseAuth(DigestAuth.DIGEST,"f09cecf114d72dcb1ba99e02ac448687","ldap"); auth.getResponseAuth("f09cecf114d72dcb1ba99e02ac448687").setUsername("admin"); auth.getResponseAuth("f09cecf114d72dcb1ba99e02ac448687").setPassword("password"); ClientAuth requestAuth = new ClientAuth("GET",header,""); boolean expResult = true; boolean result = auth.checkMD5(requestAuth); assertEquals(expResult, result); }
DigestAuth { public String getResponseHeader(ServerAuth responseAuth) { String value = ""; value = type; if (type.equalsIgnoreCase("Basic")) { value += " realm=\"Restricted\""; return value; } String opaque = responseAuth.getOpaque(); String nonce = responseAuth.getNonce(); String nc = ((Integer) responseAuth.getNonceCount()).toString(); nc = Strings.leftPad(nc, 8, "0"); value += " realm=\"" + realm + "\" qop=\"" + qop + "\" nonce=\"" + nonce + "\" opaque=\"" + opaque + "\" nc=" + nc; return value; } DigestAuth(); DigestAuth(String typeAuth, String realm, String qop); String getResponseHeader(ServerAuth responseAuth); ServerAuth createResponseAuth(); ServerAuth createResponseAuth(String typeAuth, String nonce, String realm); void purgeResponseAuth(); ServerAuth getResponseAuth(String nonce); boolean isNonceExist(String nonce); String getOpaque(String nonce); boolean check(ClientAuth requestAuth); boolean checkBasic(ClientAuth clientAuth); boolean checkMD5(ClientAuth clientAuth); boolean checkMD5_Sess(ClientAuth clientAuth); boolean compareServerAndClientAuth(ClientAuth requestAuth, ServerAuth responseAuth); String getType(); void setType(String type); String getRealm(); void setRealm(String realm); String getQop(); void setQop(String qop); int getNumberCanFail(); void setNumberCanFail(int numberCanFail); int getSecondsIdle(); void setSecondsIdle(int secondsIdle); List<String> getTypeAuthValids(); void setTypeAuthValids(List<String> typeAuthValid); List<String> getAlgorithmValids(); void setAlgorithmValids(List<String> algorithmValids); List<String> getQopValids(); void setQopValids(List<String> qopValids); final static String BASIC; final static String DIGEST; }
@Test public void testGetResponseHeader() throws Exception{ DigestAuth auth = new DigestAuth(DigestAuth.BASIC, "", ""); String expResult = "Basic realm=\"Restricted\""; ServerAuth serverAuth = auth.createResponseAuth(); String result = auth.getResponseHeader(serverAuth); assertEquals(expResult, result); auth = new DigestAuth(DigestAuth.DIGEST, "ldap", ""); serverAuth = auth.createResponseAuth(); result = auth.getResponseHeader(serverAuth); expResult = "Digest realm=\""+auth.getRealm() + "\" qop=\""+auth.getQop() + "\" nonce=\""+serverAuth.getNonce() + "\" opaque=\""+serverAuth.getOpaque(); assertEquals(expResult, Strings.left(result, expResult.length())); auth = new DigestAuth(DigestAuth.DIGEST, "ldap", "auth,auth-int"); serverAuth = auth.createResponseAuth(); result = auth.getResponseHeader(serverAuth); expResult = "Digest realm=\""+auth.getRealm() + "\" qop=\""+auth.getQop() + "\" nonce=\""+serverAuth.getNonce() + "\" opaque=\""+serverAuth.getOpaque(); assertEquals(expResult, Strings.left(result, expResult.length())); }
DigestAuth { public void purgeResponseAuth() { Date now = DateUtils.addSeconds(Dates.now(), secondsIdle * -1); for (Iterator<Map.Entry<String, ServerAuth>> it = serverAuthMap.entrySet().iterator(); it.hasNext();) { Map.Entry<String, ServerAuth> entry = it.next(); if (entry.getValue().getLastReference().before(now)) { it.remove(); } } } DigestAuth(); DigestAuth(String typeAuth, String realm, String qop); String getResponseHeader(ServerAuth responseAuth); ServerAuth createResponseAuth(); ServerAuth createResponseAuth(String typeAuth, String nonce, String realm); void purgeResponseAuth(); ServerAuth getResponseAuth(String nonce); boolean isNonceExist(String nonce); String getOpaque(String nonce); boolean check(ClientAuth requestAuth); boolean checkBasic(ClientAuth clientAuth); boolean checkMD5(ClientAuth clientAuth); boolean checkMD5_Sess(ClientAuth clientAuth); boolean compareServerAndClientAuth(ClientAuth requestAuth, ServerAuth responseAuth); String getType(); void setType(String type); String getRealm(); void setRealm(String realm); String getQop(); void setQop(String qop); int getNumberCanFail(); void setNumberCanFail(int numberCanFail); int getSecondsIdle(); void setSecondsIdle(int secondsIdle); List<String> getTypeAuthValids(); void setTypeAuthValids(List<String> typeAuthValid); List<String> getAlgorithmValids(); void setAlgorithmValids(List<String> algorithmValids); List<String> getQopValids(); void setQopValids(List<String> qopValids); final static String BASIC; final static String DIGEST; }
@Test public void purgeResponseAuth() throws Exception{ System.out.println("purgeResponseAuth"); DigestAuth auth = new DigestAuth(); auth.setSecondsIdle(1); for (int i = 0;i <= 500;i++){ auth.createResponseAuth(DigestAuth.BASIC,""+i,""); } Thread.sleep(2000); auth.purgeResponseAuth(); for (int i = 0;i <= 500;i++){ ServerAuth serverAuth = auth.getResponseAuth(""+i); if (serverAuth != null){ fail("Error purga"); break; } } for (int i = 0;i <= 500;i++){ auth.createResponseAuth(DigestAuth.DIGEST,"digest "+i,""); } Thread.sleep(2000); auth.purgeResponseAuth(); for (int i = 0;i <= 500;i++){ ServerAuth serverAuth = auth.getResponseAuth("digest "+i); if (serverAuth != null){ fail("Error purga"); break; } } }
OAuthConsumer extends OAuthConsumerBase { @Override public Class<IAppAuthConsumer> getAuthConsumerClass() { try { return (Class<IAppAuthConsumer>) Class.forName("org.javabeanstack.model.appcatalog.AppAuthConsumer"); } catch (ClassNotFoundException ex) { System.out.println(ex.getMessage()); } return null; } @Override Class<IAppAuthConsumer> getAuthConsumerClass(); @Override Class<IAppAuthConsumerToken> getAuthConsumerTokenClass(); @Override IDBFilter getDBFilter(IAppAuthConsumerToken token); }
@Test public void test00InstanceClass() throws InstantiationException, IllegalAccessException{ OAuthConsumerBase instance = new OAuthConsumerImpl(); IAppAuthConsumer consumer = instance.getAuthConsumerClass().newInstance(); assertNotNull(consumer); }
AbstractDAO implements IGenericDAO { @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) public <T extends IDataRow> List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters) throws Exception { return findListByNamedQuery(sessionId, namedQuery, parameters, 0, 0); } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test07FindByNamedQuery() throws Exception { System.out.println("7-AbstractDAO - findByNamedQuery"); String sessionid = null; if (error != null) { System.out.println(error); return; } List<AppTablesRelation> prueba = dao.findListByNamedQuery(sessionid, "AppTablesRelation.findAll", null); assertTrue(!prueba.isEmpty()); }
AbstractDataObject implements IDataObject, Serializable { @Override public Long getIdcompany() { Long idempresa = 0L; if (getDAO().getUserSession() != null) { idempresa = getDAO().getUserSession().getIdCompany(); } return idempresa; } @Override boolean isReadwrite(); @Override abstract IDataLink getDAO(); @Override abstract IDataLink getDAOCatalog(); @Override IDataEvents getDataEvents(); @Override Class<T> getType(); @Override Exception getErrorApp(); @Override String getErrorMsg(boolean all); @Override String getErrorMsg(String fieldName); @Override String getFilter(); @Override String getOrder(); @Override String getFilterExtra(); @Override Map<String, Object> getFilterParams(); @Override List<T> getDataRows(); @Override Map<Integer, T> getDataRowsChanged(); @Override T getRow(); @Override String getSelectCmd(); @Override String getLastQuery(); @Override int getRecno(); @Override boolean isShowDeletedRow(); @Override void setShowDeletedRow(boolean showDeletedRow); @Override int getRowCount(); @Override int getRecStatus(); @Override int getFirstRow(); @Override int getMaxRows(); @Override Long getIdcompany(); @Override Long getIdempresa(); @Override void setReadWrite(boolean valor); @Override void setType(Class type); @Override void setFilter(String filter); @Override void setOrder(String order); @Override void setFilterExtra(String filterExtra); @Override void setFilterParams(Map filterParams); @Override void setFirstRow(int first); @Override void setMaxRows(int maxRows); void setDataRows(List<T> dataRows); @Override boolean open(); @Override boolean open(String order, String filter, boolean readwrite, int maxrows); @Override boolean requery(String filterExtra, Map filterParams); @Override boolean requery(); void openOrRequery(String filter); void openOrRequery(String order, String filter, boolean readwrite, int maxrows); boolean openOrRequery(String fieldName, Object fieldValue, String order, int maxrows); boolean openOrRequeryIf(String fieldName, Object fieldValue, String order, int maxrows); @Override boolean goTo(int rownumber); @Override boolean goTo(int rownumber, int offset); @Override boolean moveFirst(); @Override boolean moveNext(); @Override boolean movePrevious(); @Override boolean moveLast(); static int findRow(List<? extends IDataRow> rowList, String field, Object value, int begin, int end); @Override boolean find(String field, Object value, int begin, int end); @Override boolean find(String field, Object value); @Override boolean findNext(); @Override boolean isEof(); @Override Object getNewValue(String fieldname); @Override Object getFieldDefaultValue(String fieldname); @Override Object getField(String fieldname); @Override Object getField(String objname, String fieldname); @Override Object getFieldOld(String fieldname); @Override IDataRow getFieldObjFK(String fieldname); @Override boolean setField(String fieldname, Object value); @Override boolean setField(String fieldname, Map param); @Override boolean setField(String fieldname, Object newValue, boolean noAfterSetField); @Override boolean isFieldExist(String fieldname); @Override boolean isMethodExist(String methodName); @Override boolean isForeingKey(String fieldname); @Override boolean isOpen(); @Override boolean allowOperation(int operation); @Override Object getPrimaryKeyValue(); @Override boolean setPrimaryKeyValue(Object value); @Override boolean refreshRow(); @Override boolean insertRow(); @Override boolean insertRowFrom(); @Override boolean deleteRow(); @Override void copyFrom(String idcompany, String companyName, String xmlTag, String tableCopy); @Override Map<String, IErrorReg> checkDataRow(); @Override boolean checkData(boolean allRows); @Override boolean update(boolean allRows); @Override boolean update(IDataSet dataSet); @Override boolean revert(); @Override boolean revert(Boolean allRows); @Override boolean revert(IDataSet dataSet); @Override void close(); }
@Test public void test21GetIdcompany() { System.out.println("21-DataObject - getIdcompany"); if (error != null) { System.out.println(error); return; } IDataObject<Region> region = new DataObject(Region.class, null, dataLink, null); assertEquals(dataLink.getUserSession().getIdCompany(),region.getIdcompany()); }
AbstractDataObject implements IDataObject, Serializable { @Override public boolean open() { order = ""; filter = ""; filterExtra = ""; firstRow = 0; maxrows = -1; return this.open("", "", true, -1); } @Override boolean isReadwrite(); @Override abstract IDataLink getDAO(); @Override abstract IDataLink getDAOCatalog(); @Override IDataEvents getDataEvents(); @Override Class<T> getType(); @Override Exception getErrorApp(); @Override String getErrorMsg(boolean all); @Override String getErrorMsg(String fieldName); @Override String getFilter(); @Override String getOrder(); @Override String getFilterExtra(); @Override Map<String, Object> getFilterParams(); @Override List<T> getDataRows(); @Override Map<Integer, T> getDataRowsChanged(); @Override T getRow(); @Override String getSelectCmd(); @Override String getLastQuery(); @Override int getRecno(); @Override boolean isShowDeletedRow(); @Override void setShowDeletedRow(boolean showDeletedRow); @Override int getRowCount(); @Override int getRecStatus(); @Override int getFirstRow(); @Override int getMaxRows(); @Override Long getIdcompany(); @Override Long getIdempresa(); @Override void setReadWrite(boolean valor); @Override void setType(Class type); @Override void setFilter(String filter); @Override void setOrder(String order); @Override void setFilterExtra(String filterExtra); @Override void setFilterParams(Map filterParams); @Override void setFirstRow(int first); @Override void setMaxRows(int maxRows); void setDataRows(List<T> dataRows); @Override boolean open(); @Override boolean open(String order, String filter, boolean readwrite, int maxrows); @Override boolean requery(String filterExtra, Map filterParams); @Override boolean requery(); void openOrRequery(String filter); void openOrRequery(String order, String filter, boolean readwrite, int maxrows); boolean openOrRequery(String fieldName, Object fieldValue, String order, int maxrows); boolean openOrRequeryIf(String fieldName, Object fieldValue, String order, int maxrows); @Override boolean goTo(int rownumber); @Override boolean goTo(int rownumber, int offset); @Override boolean moveFirst(); @Override boolean moveNext(); @Override boolean movePrevious(); @Override boolean moveLast(); static int findRow(List<? extends IDataRow> rowList, String field, Object value, int begin, int end); @Override boolean find(String field, Object value, int begin, int end); @Override boolean find(String field, Object value); @Override boolean findNext(); @Override boolean isEof(); @Override Object getNewValue(String fieldname); @Override Object getFieldDefaultValue(String fieldname); @Override Object getField(String fieldname); @Override Object getField(String objname, String fieldname); @Override Object getFieldOld(String fieldname); @Override IDataRow getFieldObjFK(String fieldname); @Override boolean setField(String fieldname, Object value); @Override boolean setField(String fieldname, Map param); @Override boolean setField(String fieldname, Object newValue, boolean noAfterSetField); @Override boolean isFieldExist(String fieldname); @Override boolean isMethodExist(String methodName); @Override boolean isForeingKey(String fieldname); @Override boolean isOpen(); @Override boolean allowOperation(int operation); @Override Object getPrimaryKeyValue(); @Override boolean setPrimaryKeyValue(Object value); @Override boolean refreshRow(); @Override boolean insertRow(); @Override boolean insertRowFrom(); @Override boolean deleteRow(); @Override void copyFrom(String idcompany, String companyName, String xmlTag, String tableCopy); @Override Map<String, IErrorReg> checkDataRow(); @Override boolean checkData(boolean allRows); @Override boolean update(boolean allRows); @Override boolean update(IDataSet dataSet); @Override boolean revert(); @Override boolean revert(Boolean allRows); @Override boolean revert(IDataSet dataSet); @Override void close(); }
@Test public void test24BeforeOpen() { System.out.println("24-DataObject - beforeOpen"); if (error != null) { System.out.println(error); return; } DataEventsTest dataEvents = new DataEventsTest(); IDataObject<Region> region = new DataObject(Region.class, dataEvents, dataLink, null); region.open(); assertTrue(dataEvents.beforeOpen == 1); } @Test public void test27AfterOpen() { System.out.println("27-DataObject - afterOpen"); if (error != null) { System.out.println(error); return; } DataEventsTest dataEvents = new DataEventsTest(); IDataObject<Region> region = new DataObject(Region.class, dataEvents, dataLink, null); region.open(); assertTrue(dataEvents.afterOpen == 1); } @Test public void test28BeforeDataFill() { System.out.println("28-DataObject - beforeDataFill"); if (error != null) { System.out.println(error); return; } DataEventsTest dataEvents = new DataEventsTest(); IDataObject<Region> region = new DataObject(Region.class, dataEvents, dataLink, null); region.open(); assertTrue(dataEvents.beforeDataFill == 1); }
AbstractDataObject implements IDataObject, Serializable { @Override public boolean isFieldExist(String fieldname) { return DataInfo.isFieldExist(this.getType(), fieldname); } @Override boolean isReadwrite(); @Override abstract IDataLink getDAO(); @Override abstract IDataLink getDAOCatalog(); @Override IDataEvents getDataEvents(); @Override Class<T> getType(); @Override Exception getErrorApp(); @Override String getErrorMsg(boolean all); @Override String getErrorMsg(String fieldName); @Override String getFilter(); @Override String getOrder(); @Override String getFilterExtra(); @Override Map<String, Object> getFilterParams(); @Override List<T> getDataRows(); @Override Map<Integer, T> getDataRowsChanged(); @Override T getRow(); @Override String getSelectCmd(); @Override String getLastQuery(); @Override int getRecno(); @Override boolean isShowDeletedRow(); @Override void setShowDeletedRow(boolean showDeletedRow); @Override int getRowCount(); @Override int getRecStatus(); @Override int getFirstRow(); @Override int getMaxRows(); @Override Long getIdcompany(); @Override Long getIdempresa(); @Override void setReadWrite(boolean valor); @Override void setType(Class type); @Override void setFilter(String filter); @Override void setOrder(String order); @Override void setFilterExtra(String filterExtra); @Override void setFilterParams(Map filterParams); @Override void setFirstRow(int first); @Override void setMaxRows(int maxRows); void setDataRows(List<T> dataRows); @Override boolean open(); @Override boolean open(String order, String filter, boolean readwrite, int maxrows); @Override boolean requery(String filterExtra, Map filterParams); @Override boolean requery(); void openOrRequery(String filter); void openOrRequery(String order, String filter, boolean readwrite, int maxrows); boolean openOrRequery(String fieldName, Object fieldValue, String order, int maxrows); boolean openOrRequeryIf(String fieldName, Object fieldValue, String order, int maxrows); @Override boolean goTo(int rownumber); @Override boolean goTo(int rownumber, int offset); @Override boolean moveFirst(); @Override boolean moveNext(); @Override boolean movePrevious(); @Override boolean moveLast(); static int findRow(List<? extends IDataRow> rowList, String field, Object value, int begin, int end); @Override boolean find(String field, Object value, int begin, int end); @Override boolean find(String field, Object value); @Override boolean findNext(); @Override boolean isEof(); @Override Object getNewValue(String fieldname); @Override Object getFieldDefaultValue(String fieldname); @Override Object getField(String fieldname); @Override Object getField(String objname, String fieldname); @Override Object getFieldOld(String fieldname); @Override IDataRow getFieldObjFK(String fieldname); @Override boolean setField(String fieldname, Object value); @Override boolean setField(String fieldname, Map param); @Override boolean setField(String fieldname, Object newValue, boolean noAfterSetField); @Override boolean isFieldExist(String fieldname); @Override boolean isMethodExist(String methodName); @Override boolean isForeingKey(String fieldname); @Override boolean isOpen(); @Override boolean allowOperation(int operation); @Override Object getPrimaryKeyValue(); @Override boolean setPrimaryKeyValue(Object value); @Override boolean refreshRow(); @Override boolean insertRow(); @Override boolean insertRowFrom(); @Override boolean deleteRow(); @Override void copyFrom(String idcompany, String companyName, String xmlTag, String tableCopy); @Override Map<String, IErrorReg> checkDataRow(); @Override boolean checkData(boolean allRows); @Override boolean update(boolean allRows); @Override boolean update(IDataSet dataSet); @Override boolean revert(); @Override boolean revert(Boolean allRows); @Override boolean revert(IDataSet dataSet); @Override void close(); }
@Test public void test56IsFieldExist() { System.out.println("56-DataObject - isFieldExist"); if (error != null) { System.out.println(error); return; } IDataObject<Region> region = new DataObject(Region.class, null, dataLink, null); assertTrue(region.isFieldExist("codigo")); assertFalse(region.isFieldExist("noexiste")); }
AbstractDataObject implements IDataObject, Serializable { @Override public boolean isForeingKey(String fieldname) { return DataInfo.isForeignKey(this.getType(), fieldname); } @Override boolean isReadwrite(); @Override abstract IDataLink getDAO(); @Override abstract IDataLink getDAOCatalog(); @Override IDataEvents getDataEvents(); @Override Class<T> getType(); @Override Exception getErrorApp(); @Override String getErrorMsg(boolean all); @Override String getErrorMsg(String fieldName); @Override String getFilter(); @Override String getOrder(); @Override String getFilterExtra(); @Override Map<String, Object> getFilterParams(); @Override List<T> getDataRows(); @Override Map<Integer, T> getDataRowsChanged(); @Override T getRow(); @Override String getSelectCmd(); @Override String getLastQuery(); @Override int getRecno(); @Override boolean isShowDeletedRow(); @Override void setShowDeletedRow(boolean showDeletedRow); @Override int getRowCount(); @Override int getRecStatus(); @Override int getFirstRow(); @Override int getMaxRows(); @Override Long getIdcompany(); @Override Long getIdempresa(); @Override void setReadWrite(boolean valor); @Override void setType(Class type); @Override void setFilter(String filter); @Override void setOrder(String order); @Override void setFilterExtra(String filterExtra); @Override void setFilterParams(Map filterParams); @Override void setFirstRow(int first); @Override void setMaxRows(int maxRows); void setDataRows(List<T> dataRows); @Override boolean open(); @Override boolean open(String order, String filter, boolean readwrite, int maxrows); @Override boolean requery(String filterExtra, Map filterParams); @Override boolean requery(); void openOrRequery(String filter); void openOrRequery(String order, String filter, boolean readwrite, int maxrows); boolean openOrRequery(String fieldName, Object fieldValue, String order, int maxrows); boolean openOrRequeryIf(String fieldName, Object fieldValue, String order, int maxrows); @Override boolean goTo(int rownumber); @Override boolean goTo(int rownumber, int offset); @Override boolean moveFirst(); @Override boolean moveNext(); @Override boolean movePrevious(); @Override boolean moveLast(); static int findRow(List<? extends IDataRow> rowList, String field, Object value, int begin, int end); @Override boolean find(String field, Object value, int begin, int end); @Override boolean find(String field, Object value); @Override boolean findNext(); @Override boolean isEof(); @Override Object getNewValue(String fieldname); @Override Object getFieldDefaultValue(String fieldname); @Override Object getField(String fieldname); @Override Object getField(String objname, String fieldname); @Override Object getFieldOld(String fieldname); @Override IDataRow getFieldObjFK(String fieldname); @Override boolean setField(String fieldname, Object value); @Override boolean setField(String fieldname, Map param); @Override boolean setField(String fieldname, Object newValue, boolean noAfterSetField); @Override boolean isFieldExist(String fieldname); @Override boolean isMethodExist(String methodName); @Override boolean isForeingKey(String fieldname); @Override boolean isOpen(); @Override boolean allowOperation(int operation); @Override Object getPrimaryKeyValue(); @Override boolean setPrimaryKeyValue(Object value); @Override boolean refreshRow(); @Override boolean insertRow(); @Override boolean insertRowFrom(); @Override boolean deleteRow(); @Override void copyFrom(String idcompany, String companyName, String xmlTag, String tableCopy); @Override Map<String, IErrorReg> checkDataRow(); @Override boolean checkData(boolean allRows); @Override boolean update(boolean allRows); @Override boolean update(IDataSet dataSet); @Override boolean revert(); @Override boolean revert(Boolean allRows); @Override boolean revert(IDataSet dataSet); @Override void close(); }
@Test public void test57IsForeingKey() { System.out.println("57-DataObject - isForeingKey"); if (error != null) { System.out.println(error); return; } IDataObject<Pais> pais = new DataObject(Pais.class, null, dataLink, null); assertTrue(pais.isForeingKey("region")); assertFalse(pais.isForeingKey("codigo")); assertFalse(pais.isForeingKey("noexiste")); }
CipherUtil { public static String encryptBlowfishToHex(String clearText, String key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException { return encryptToHex(CipherUtil.BLOWFISH, clearText, key); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testEncryptBlowfishToHex() throws Exception { System.out.println("encryptBlowfishToHex"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "123456á"; String expResult = clearText; String encrypted = CipherUtil.encryptBlowfishToHex(clearText, key); String decrypted = CipherUtil.decryptBlowfishFromHex(encrypted, key); assertEquals(expResult, decrypted); }
CipherUtil { public static String decryptBlowfishFromHex(String encrypted, String key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException { return decryptFromHex(CipherUtil.BLOWFISH, encrypted, key); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testDecryptBlowfishFromHex() throws Exception { System.out.println("decryptBlowfishFromHex"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "123456Á"; String expResult = clearText; String encrypted = CipherUtil.encryptBlowfishToHex(clearText, key); String decrypted = CipherUtil.decryptBlowfishFromHex(encrypted, key); assertEquals(expResult, decrypted); }
CipherUtil { public static String encryptBlowfishToBase64(String clearText, String key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException { return encryptToBase64(CipherUtil.BLOWFISH, clearText, key); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testEncryptBlowfishToBase64() throws Exception { System.out.println("encryptBlowfishToBase64"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "123456á"; String expResult = clearText; String encrypted = CipherUtil.encryptBlowfishToBase64(clearText, key); System.out.println(encrypted); String decrypted = CipherUtil.decryptBlowfishFromBase64(encrypted, key); assertEquals(expResult, decrypted); }
CipherUtil { public static String decryptBlowfishFromBase64(String encrypted, String key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException { return decryptFromBase64(CipherUtil.BLOWFISH, encrypted, key); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testDecryptBlowfishFromBase64() throws Exception { System.out.println("decryptBlowfishFromBase64"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "123456á"; String expResult = clearText; String encrypted = CipherUtil.encryptBlowfishToBase64(clearText, key); String decrypted = CipherUtil.decryptBlowfishFromBase64(encrypted, key); assertEquals(expResult, decrypted); }
AbstractDAO implements IGenericDAO { @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) public Long getCount(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { LOGGER.debug(Strings.replicate("-", 50)); LOGGER.debug("getCount"); IDBLinkInfo dbLinkInfo = sessions.getDBLinkInfo(sessionId); Long result; String persistUnit = dbLinkInfo.getPersistUnit(); queryString = Strings.textMerge(queryString, getQueryConstants(persistUnit)); int pos = Strings.findString("from ", queryString.toLowerCase()); int pos2 = Strings.findString(" order by ", queryString.toLowerCase()); if (pos2 <= 0) { queryString = "select count(*) " + queryString.substring(pos); } else { queryString = "select count(*) " + queryString.substring(pos, pos2); } LOGGER.debug(queryString); EntityManager em = getEntityManager(getEntityId(dbLinkInfo)); Query query = em.createQuery(queryString); if (parameters != null && !parameters.isEmpty()) { populateQueryParameters(query, parameters, queryString); } result = ((Number) query.getSingleResult()).longValue(); return result; } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test14GetCount() throws Exception { System.out.println("14-AbstractDAO - getCount"); String sessionid = null; if (error != null) { System.out.println(error); return; } Long rec = dao.getCount(sessionid, "select o FROM AppCompany o", null); assertTrue(rec > 0L); }
CipherUtil { public static byte[] encryptAES(String clearText, String key) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { return encrypt_AES_CBC(clearText, key); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testEncryptAES() throws Exception{ System.out.println("encryptAES"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "012345678901234567890123456789á"; String expResult = clearText; byte[] encrypted = CipherUtil.encryptAES(clearText, key); String decrypted = CipherUtil.decryptAES(encrypted, key); assertEquals(expResult, decrypted); String hex = Fn.bytesToHex(encrypted); Assert.assertArrayEquals(encrypted, Fn.hexToByte(hex)); }
CipherUtil { public static String decryptAES(byte[] encrypted, String key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { return new String(decrypt_AES_CBC(encrypted, key)); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testDecryptAES() throws Exception{ System.out.println("decryptAES"); byte[] text = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZabcdefghijklmnñopqrstuvwxyzáéíóú".getBytes(); String clearText = new String(text); String key = "012345678901234567890123456789á"; String expResult = clearText; byte[] encrypted = CipherUtil.encryptAES(clearText, key); String hex = Fn.bytesToHex(encrypted); byte[] encrypted2 = Fn.hexToByte(hex); String decrypted = CipherUtil.decryptAES(encrypted2, key); assertEquals(expResult, decrypted); }
CipherUtil { public static String encryptAES_ToHex(String clearText, String key) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { return Fn.bytesToHex(encrypt_AES_CBC(clearText, key)); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testEncryptAES_ToHex() throws Exception { System.out.println("encryptAES_ToHex"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "012345678901234567890123456789"; String expResult = clearText; String encrypted = CipherUtil.encryptAES_ToHex(clearText, key); String decrypted = CipherUtil.decryptAES(Fn.hexToByte(encrypted), key); assertEquals(expResult, decrypted); }
CipherUtil { public static String encryptAES_ToBase64(String clearText, String key) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { return Fn.bytesToBase64(encrypt_AES_CBC(clearText, key)); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testEncryptAES_ToBase64() throws Exception { System.out.println("encryptAES_ToBase64"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "012345678901234567890123456789"; String expResult = clearText; String encrypted = CipherUtil.encryptAES_ToBase64(clearText, key); String decrypted = CipherUtil.decryptAES(Fn.base64ToBytes(encrypted), key); assertEquals(expResult, decrypted); }
CipherUtil { public static String decryptAES_FromHex(String encryptedHex, String key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { return new String(decrypt_AES_CBC(Fn.hexToByte(encryptedHex), key)); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testDecryptAES_FromHex() throws Exception { System.out.println("decryptAES_FromHex"); String clearText = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "012345678901234567890123456789"; String expResult = clearText; String encrypted = CipherUtil.encryptAES_ToHex(clearText, key); String decrypted = CipherUtil.decryptAES_FromHex(encrypted, key); assertEquals(expResult, decrypted); }
CipherUtil { public static SecretKey getSecureRandomKey(String algoritm, int keyBitSize) throws NoSuchAlgorithmException { KeyGenerator keyGenerator = KeyGenerator.getInstance(algoritm); SecureRandom secureRandom = new SecureRandom(); keyGenerator.init(keyBitSize, secureRandom); return keyGenerator.generateKey(); } private CipherUtil(); static String encryptBlowfishToHex(String clearText, String key); static String encryptBlowfishToBase64(String clearText, String key); static String decryptBlowfishFromHex(String encrypted, String key); static String decryptBlowfishFromBase64(String encrypted, String key); static byte[] encryptAES(String clearText, String key); static String encryptAES_ToHex(String clearText, String key); static String encryptAES_ToBase64(String clearText, String key); static String decryptAES(byte[] encrypted, String key); static String decryptAES_FromHex(String encryptedHex, String key); static SecretKey getSecureRandomKey(String algoritm, int keyBitSize); static SecretKey getSecureRandomKey(String algoritm); static final String BLOWFISH; static final String AES_CBC; }
@Test public void testGetSecureRandomKey_String_int() throws Exception { System.out.println("getSecureRandomKey"); String algoritm = "AES"; int keyBitSize = 256; SecretKey result = CipherUtil.getSecureRandomKey(algoritm, keyBitSize); assertNotNull(result); } @Test public void testGetSecureRandomKey_String() throws Exception { System.out.println("getSecureRandomKey"); String algoritm = "Blowfish"; SecretKey result = CipherUtil.getSecureRandomKey(algoritm); assertNotNull(result); }
DigestUtil { public static String md5(String msg) { try { return digestToHex("MD5", msg); } catch (NoSuchAlgorithmException | UnsupportedEncodingException ex) { Logger.getLogger(DigestUtil.class).error(ex.getMessage()); } return null; } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testMd5() throws Exception { System.out.println("md5"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String expResult = "5AD6F23DA25B3A54CD5AE716C401732D"; String result = DigestUtil.md5(msg).toUpperCase(); assertEquals(expResult, result); } @Test public void testDigestAuth_MD5() throws Exception { System.out.println("DIGEST AUTH"); String nonce = ""; String cnonce = ""; String ha1 = DigestUtil.md5("admin:ldap:password"); String ha2 = DigestUtil.md5("GET:/basic-auth"); String response = DigestUtil.md5(ha1 + ":" + nonce + ":" + ha2); String expResult = "e99498dd8f94775f92dffdebd06496b3"; assertEquals(expResult, response); } @Test public void testDigestAuth_MD5_auth() throws Exception { String nonce = ""; String cnonce = ""; String nonceCount = ""; String method = "POST"; String ha1 = DigestUtil.md5("admin:ldap:password"); String ha2 = DigestUtil.md5(method + ":/rest/v2/name/eesti"); String response = DigestUtil.md5(ha1 + ":" + nonce + ":" + nonceCount + ":" + cnonce + ":" + "auth" + ":" + ha2); String expResult = "f2d5b80937bc0c8ed717a75ca537572e"; assertEquals(expResult, response); } @Test public void testDigestAuth_MD5_sess_auth() throws Exception { String nonce = ""; String cnonce = ""; String nonceCount = ""; String method = "POST"; String ha1 = DigestUtil.md5(DigestUtil.md5("admin:ldap:password") + ":" + nonce + ":" + cnonce); String ha2 = DigestUtil.md5(method + ":/rest/v2/name/eesti"); String response = DigestUtil.md5(ha1 + ":" + nonce + ":" + nonceCount + ":" + cnonce + ":" + "auth" + ":" + ha2); String expResult = "f71297f4eb46e443d301a101f12e4400"; assertEquals(expResult, response); } @Test public void testDigestAuth_MD5_sess_auth_int() throws Exception { String nonce = ""; String cnonce = ""; String nonceCount = ""; String entityBody = "\"v=1\\r\\n\" +\n" + "\"o=bob 2890844526 2890844526 IN IP4 media.biloxi.com\\r\\n\" +\n" + "\"s=\\r\\n\" +\n" + "\"c=IN IP4 media.biloxi.com\\r\\n\" +\n" + "\"t=0 0\\r\\n\" +\n" + "\"m=audio 49170 RTP/AVP 0\\r\\n\" +\n" + "\"a=rtpmap:0 PCMU/8000\\r\\n\" +\n" + "\"m=video 51372 RTP/AVP 31\\r\\n\" +\n" + "\"a=rtpmap:31 H261/90000\\r\\n\" +\n" + "\"m=video 53000 RTP/AVP 32\\r\\n\" +\n" + "\"a=rtpmap:32 MPV/90000\\r\\n\";"; String response; String method = "POST"; String ha1 = DigestUtil.md5(DigestUtil.md5("admin:ldap:password") + ":" + nonce + ":" + cnonce); if (method.equals("GET")) { String ha2 = DigestUtil.md5(method + ":/rest/v2/name/eesti"); response = DigestUtil.md5(ha1 + ":" + nonce + ":" + nonceCount + ":" + cnonce + ":" + "auth-int" + ":" + ha2); } else { String ha2 = DigestUtil.md5(method + ":/rest/v2/name/eesti" + ":" + entityBody); response = DigestUtil.md5(ha1 + ":" + nonce + ":" + nonceCount + ":" + cnonce + ":" + "auth-int" + ":" + ha2); } String expResult = "e985c39b9966966208529e9f82fc4a44"; System.out.println(expResult); System.out.println(response); assertEquals(expResult, response); }
DigestUtil { public static String sha256(String msg){ try { return digestToHex("SHA-256", msg); } catch (NoSuchAlgorithmException | UnsupportedEncodingException ex) { Logger.getLogger(DigestUtil.class).error(ex.getMessage()); } return null; } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testSha256() throws Exception { System.out.println("sha256"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String expResult = "4D9DC750077F316B7A9D2D5C4890B1D79ABC7B7C4261D7090CBF58501E2F723B"; String result = DigestUtil.sha256(msg).toUpperCase(); System.out.println(result); assertEquals(expResult, result); }
DigestUtil { public static String sha512(String msg) { try { return digestToHex("SHA-512", msg); } catch (NoSuchAlgorithmException | UnsupportedEncodingException ex) { Logger.getLogger(DigestUtil.class).error(ex.getMessage()); } return null; } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testSha512() throws Exception { System.out.println("sha512"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String expResult = "8CABE293B89951C158AC9B56ECDD518060BE89CB760ED7AD04CF72B9F10EB38401A8959E6CFCD3146A6A02AC126D76B3DAD653500239EF8A6BB4106238B9C37C"; String result = DigestUtil.sha512(msg).toUpperCase(); System.out.println(result); assertEquals(expResult, result); }
AbstractDAO implements IGenericDAO { @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) public Long getCount2(String sessionId, String queryString, Map<String, Object> parameters) throws Exception { LOGGER.debug(Strings.replicate("-", 50)); LOGGER.debug("getCount2"); IDBLinkInfo dbLinkInfo = sessions.getDBLinkInfo(sessionId); String persistUnit = dbLinkInfo.getPersistUnit(); queryString = Strings.textMerge(queryString, getQueryConstants(persistUnit)); queryString = "select count(*) from (" + queryString + ") x"; LOGGER.debug(queryString); List<Object> result = this.findByNativeQuery(sessionId, queryString, parameters); return Long.parseLong(result.get(0).toString()); } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test15GetCount2() throws Exception { System.out.println("15-AbstractDAO - getCount2"); String sessionid = null; if (error != null) { System.out.println(error); return; } Long rec = dao.getCount2(sessionid, "select * FROM {schema}.empresa", null); assertTrue(rec > 0L); }
DigestUtil { public static String digestToHex(String algorithm, String msg) throws NoSuchAlgorithmException, UnsupportedEncodingException { MessageDigest digest = MessageDigest.getInstance(algorithm); byte[] digestMessage = digest.digest(msg.getBytes("UTF-8")); return Fn.bytesToHex(digestMessage); } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testDigestToHex() throws Exception { System.out.println("digestToHex"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String expResult = "8DD69CB915630B3DDE248FC13DBA97547BCED31E"; String result = DigestUtil.digestToHex(DigestUtil.SHA1, msg).toUpperCase(); assertEquals(expResult, result); expResult = "5AD6F23DA25B3A54CD5AE716C401732D"; result = DigestUtil.digestToHex(DigestUtil.MD5, msg).toUpperCase(); assertEquals(expResult, result); expResult = "4D9DC750077F316B7A9D2D5C4890B1D79ABC7B7C4261D7090CBF58501E2F723B"; result = DigestUtil.digestToHex(DigestUtil.SHA256, msg).toUpperCase(); assertEquals(expResult, result); expResult = "868333E2AB3B4329D6656EE63B4CD77F03AA58EEB924F4920F5894BBF1340660FB1BEB591CD7D0A67478A0768FD4790A"; result = DigestUtil.digestToHex(DigestUtil.SHA384, msg).toUpperCase(); System.out.println(result); assertEquals(expResult, result); expResult = "8CABE293B89951C158AC9B56ECDD518060BE89CB760ED7AD04CF72B9F10EB38401A8959E6CFCD3146A6A02AC126D76B3DAD653500239EF8A6BB4106238B9C37C"; result = DigestUtil.digestToHex(DigestUtil.SHA512, msg).toUpperCase(); assertEquals(expResult, result); }
DigestUtil { public static String hmacSHA1(String msg, String key) { try { return digestHmacToHex("HmacSHA1", msg, key.getBytes("UTF-8")); } catch (NoSuchAlgorithmException | UnsupportedEncodingException | InvalidKeyException ex) { Logger.getLogger(DigestUtil.class).error(ex.getMessage()); } return null; } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testHmacSha1() throws Exception { System.out.println("sha1"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "añ"; String expResult = "766efadbefecb8313cdd42f3d983b60707e019f7"; String result = DigestUtil.hmacSHA1(msg, key); System.out.println(result); assertEquals(expResult, result); }
DigestUtil { public static String hmacSHA256(String msg, String key) { try { return digestHmacToHex("HmacSHA256", msg, key.getBytes("UTF-8")); } catch (NoSuchAlgorithmException | UnsupportedEncodingException | InvalidKeyException ex) { Logger.getLogger(DigestUtil.class).error(ex.getMessage()); } return null; } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testHmacSha256() throws Exception { System.out.println("sha256"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "añ"; String expResult = "efbc7d9e22c2e7063b929003a7e3b5469259175072c9e115636a86d5c7f198a6"; String result = DigestUtil.hmacSHA256(msg, key); System.out.println(result); assertEquals(expResult, result); }
DigestUtil { public static String hmacSHA512(String msg, String key) { try { return digestHmacToHex("HmacSHA512", msg, key.getBytes("UTF-8")); } catch (NoSuchAlgorithmException | UnsupportedEncodingException | InvalidKeyException ex) { Logger.getLogger(DigestUtil.class).error(ex.getMessage()); } return null; } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testHmacSha512() throws Exception { System.out.println("sha512"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "añ"; String expResult = "873e13ff8d5a20104b2d6ddfbd1de7372f065e7a344cffa729f30b71c54df944416ced9cd7d62e2dad0b87806ed57d230487e5a492c67a5034ee3d4dd900cd5f"; String result = DigestUtil.hmacSHA512(msg, key); System.out.println(result); assertEquals(expResult, result); }
DigestUtil { public static String hmacMD5(String msg, String key) { try { return digestHmacToHex("HmacMD5", msg, key.getBytes("UTF-8")); } catch (NoSuchAlgorithmException | UnsupportedEncodingException | InvalidKeyException ex) { Logger.getLogger(DigestUtil.class).error(ex.getMessage()); } return null; } private DigestUtil(); static String md5(String msg); static String sha256(String msg); static String sha512(String msg); static String digestToHex(String algorithm, String msg); static String digestHmacToHex(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64Url(String algorithm, String msg, byte[] privateKey); static String digestHmacToBase64(String algorithm, String msg, byte[] privateKey); static String hmacMD5(String msg, String key); static String hmacSHA1(String msg, String key); static String hmacSHA1ToBase64(String msg, String key); static String hmacSHA256(String msg, String key); static String hmacSHA256ToBase64(String msg, String key); static String hmacSHA384(String msg, String key); static String hmacSHA384ToBase64(String msg, String key); static String hmacSHA512(String msg, String key); static String hmacSHA512ToBase64(String msg, String key); static final String MD5; static final String SHA1; static final String SHA256; static final String SHA384; static final String SHA512; static final String HMACMD5; static final String HMACSHA1; static final String HMACSHA256; static final String HMACSHA384; static final String HMACSHA512; }
@Test public void testHmacMD5() throws Exception { System.out.println("sha256"); String msg = "abcdefghijklmnñopqrstuvwxyzáéíóú"; String key = "añ"; String expResult = "2eab3f12c1db4b4f253c109281c0d3f8"; String result = DigestUtil.hmacMD5(msg, key); System.out.println(result); assertEquals(expResult, result); }
AbstractDAO implements IGenericDAO { @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) public Map<String, Object> getEntityManagerProp(String persistUnit) { EntityManager em = getEntityManager(getEntityId(persistUnit)); if (em == null) { LOGGER.info("Entity Manager Nulo"); return null; } return em.getProperties(); } AbstractDAO(); @Override IDBLinkInfo getDBLinkInfo(String sessionId); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findAll(Class<T> entityClass, String sessionId); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findById(Class<T> entityClass, String sessionId, Object id); @Override @TransactionAttribute(TransactionAttributeType.REQUIRED) T findByUk(String sessionId, T ejb); @Override List<T> find(Class<T> entityClass, String sessionId); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params); @Override List<T> find(Class<T> entityClass, String sessionId, String order, String filter, Map<String, Object> params, int first, int max); @Override T findByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByQuery(String sessionId, String queryString, int first, int max); @Override T findByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findListByNamedQuery(String sessionId, String namedQuery, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<Object> findByNativeQuery(String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) List<T> findByNativeQuery(Class<T> clazz, String sessionId, String queryString, Map<String, Object> parameters, int first, int max); @Override IErrorReg sqlExec(String sessionId, String sqlString, Map<String, Object> parameters); @Override IDataResult update(String sessionId, T ejb); @Override IDataResult update(String sessionId, IDataObject ejbs); @Override IDataResult update(String sessionId, List<T> ejbs); @Override IDataResult update(String sessionId, IDataSet dataSet); @Override IDataResult persist(String sessionId, T ejb); @Override IDataResult merge(String sessionId, T ejb); @Override IDataResult remove(String sessionId, T ejb); @Override List<T> getData(String sessionId, String queryString, int maxRows, boolean noCache); @Override List<T> getData(Query query); @Override T refreshRow(String sessionId, T row); @Override List<T> refreshAll(String sessionId, List<T> rows); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Long getCount2(String sessionId, String queryString, Map<String, Object> parameters); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getEntityManagerProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) Map<String, Object> getPersistUnitProp(String persistUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getDataEngine(String persistentUnit); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) String getSchema(String persistentUnit); @Override Connection getConnection(String sessionId); @Override Connection getConnection(String sessionId, IDBConnectFactory conn); @Override @TransactionAttribute(TransactionAttributeType.SUPPORTS) IUserSession getUserSession(String sessionId); @Override void checkAuthConsumerData(IOAuthConsumerData data); @Override boolean isCredentialValid(Long iduser, Long idcompany); static final String FALSE; static final String TRUE; }
@Test public void test16GetEntityManagerProp() { System.out.println("16-AbstractDAO - getEntityManagerProp"); if (error != null) { System.out.println(error); return; } Map<String, Object> props = dao.getEntityManagerProp("PU1"); assertNotNull(props); }
IncrementUpdateAction extends SingleFieldUpdateAction implements ResolvedCallback<Boolean> { @Override public void apply(UpdatedToroDocumentBuilder builder) throws UpdateException { for (AttributeReference key : getModifiedField()) { if (increment(new ObjectBuilderCallback(builder), key, delta)) { builder.setUpdated(); return; } } } IncrementUpdateAction(Collection<AttributeReference> modifiedField, KvNumeric<?> delta); KvNumeric<?> getDelta(); @Override void apply(UpdatedToroDocumentBuilder builder); @Override Boolean objectReferenced( BuilderCallback<K> parentBuilder, K key, UpdatedToroDocumentBuilder child ); @Override Boolean arrayReferenced( BuilderCallback<K> parentBuilder, K key, UpdatedToroDocumentArrayBuilder child ); @Override Boolean valueReferenced( BuilderCallback<K> parentBuilder, K key, KvValue<?> child ); @Override Boolean newElementReferenced( BuilderCallback<K> parentBuilder, K key ); @Override R accept(UpdateActionVisitor<R, A> visitor, A arg); }
@Test public void testNormal() throws UpdateException { UpdatedToroDocumentBuilder builder = UpdatedToroDocumentBuilder.create(); builder.newObject("f1") .newArray("f2") .setValue(3, KvInteger.of(3)); new IncrementUpdateAction( Lists.<AttributeReference>newArrayList(new AttributeReference( Lists.<AttributeReference.Key<?>>newArrayList( new AttributeReference.ObjectKey("f1"), new AttributeReference.ObjectKey("f2"), new AttributeReference.ArrayKey(3) ))), KvInteger.of(1) ).apply(builder); assert builder.getObjectBuilder("f1").getArrayBuilder("f2").getValue(3) .equals(KvDouble.of(4)) : builder.getObjectBuilder("f1").getArrayBuilder("f2").getValue(3) + " != 4"; } @Test public void testNonExistingAttribute() throws UpdateException { UpdatedToroDocumentBuilder builder = UpdatedToroDocumentBuilder.create(); builder.newObject("f1") .newArray("f2") .setValue(3, KvInteger.of(3)); new IncrementUpdateAction( Lists.<AttributeReference>newArrayList(new AttributeReference( Lists.<AttributeReference.Key<?>>newArrayList( new AttributeReference.ObjectKey("fake1"), new AttributeReference.ObjectKey("fake2"), new AttributeReference.ArrayKey(2) ))), KvInteger.of(1) ).apply(builder);; assert builder.getObjectBuilder("f1").getArrayBuilder("f2").getValue(3) .equals(KvInteger.of(3)) : builder.getObjectBuilder("f1").getArrayBuilder("f2").getValue(3) + " != 3"; assert builder.contains("fake1"); assert builder.getObjectBuilder("fake1").getArrayBuilder("fake2").getValue(2) .equals(KvInteger.of(1)) : ".fake != 1"; } @Test(expected = UserException.class) public void testNullAttribute1() throws UpdateException { UpdatedToroDocumentBuilder builder = UpdatedToroDocumentBuilder.create(); builder.newObject("f1") .newArray("f2") .setValue(3, KvInteger.of(3)); new IncrementUpdateAction( Lists.<AttributeReference>newArrayList(new AttributeReference( Lists.<AttributeReference.Key<?>>newArrayList( new AttributeReference.ObjectKey("f1"), new AttributeReference.ObjectKey("f2"), new AttributeReference.ArrayKey(2) ))), KvInteger.of(1) ).apply(builder);; } @Test(expected = UserException.class) public void testIllegalPath() throws UpdateException { UpdatedToroDocumentBuilder builder = UpdatedToroDocumentBuilder.create(); builder.newObject("f1") .newArray("f2") .setValue(3, KvInteger.of(3)); new IncrementUpdateAction( Lists.<AttributeReference>newArrayList(new AttributeReference( Lists.<AttributeReference.Key<?>>newArrayList( new AttributeReference.ObjectKey("f1"), new AttributeReference.ArrayKey(2), new AttributeReference.ArrayKey(2) ))), KvInteger.of(1) ).apply(builder);; }
AbstractAnalyzedOp extends AnalyzedOp { @Override public AnalyzedOpType getType() { return type; } AbstractAnalyzedOp(KvValue<?> mongoDocId, AnalyzedOpType type, @Nullable Function<KvDocument, KvDocument> calculateFun); @Override abstract String toString(); @Override AnalyzedOpType getType(); @Override KvValue<?> getMongoDocId(); @Override Status<?> getMismatchErrorMessage(); @Override KvDocument calculateDocToInsert(Function<AnalyzedOp, KvDocument> fetchedDocFun); }
@Test public void requiresToFetchToroIdTest() { AnalyzedOp op = getAnalyzedOp(defaultMongoDocId); assertEquals("", op.getType().requiresToFetchToroId(), op.requiresToFetchToroId()); } @Test public void requiresMatchTest() { AnalyzedOp op = getAnalyzedOp(defaultMongoDocId); assertEquals("", op.getType().requiresMatch(), op.requiresMatch()); } @Test public void requiresFetchTest() { AnalyzedOp op = getAnalyzedOp(defaultMongoDocId); assertEquals("", op.getType().requiresFetch(), op.requiresFetch()); } @Test public void deletesTest() { AnalyzedOp op = getAnalyzedOp(defaultMongoDocId); assertEquals("", op.getType().deletes(), op.deletes()); }
ContinuousOplogFetcher implements OplogFetcher { @Override public OplogBatch fetch() throws StopReplicationException, RollbackReplicationException { if (state.isClosed()) { return FinishedOplogBatch.getInstance(); } try { return retrier.retry(() -> { try { if (state.isClosed()) { return FinishedOplogBatch.getInstance(); } state.prepareToFetch(); MongoCursor<OplogOperation> cursor = state.getLastUsedMongoCursor(); Batch<OplogOperation> batch = cursor.tryFetchBatch(); if (batch == null || !batch.hasNext()) { Thread.sleep(1000); batch = cursor.tryFetchBatch(); if (batch == null || !batch.hasNext()) { return NotReadyForMoreOplogBatch.getInstance(); } } List<OplogOperation> fetchedOps = null; long fetchTime = 0; boolean successful = false; try { fetchedOps = batch.asList(); fetchTime = batch.getFetchTime(); postBatchChecks(cursor, fetchedOps); OplogBatch result = new NormalOplogBatch(fetchedOps, true); successful = true; return result; } finally { if (!successful) { cursor.close(); } else { assert fetchedOps != null; assert fetchTime != 0; state.updateState(fetchedOps, fetchTime); } } } catch (RestartFetchException ex) { state.discardReader(); throw new RollbackException(ex); } catch (DeadCursorException ex) { throw new RollbackException(ex); } catch (StopReplicationException | RollbackReplicationException ex) { throw new RetrierAbortException(ex); } catch (MongoServerException ex) { logger.debug("Found an unwrapped MongodbServerException"); state.discardReader(); throw new RollbackException(ex); } catch (MongoException | MongoRuntimeException ex) { logger.warn("Catched an error while reading the remote " + "oplog: {}", ex.getLocalizedMessage()); state.discardReader(); throw new RollbackException(ex); } }, Hint.CRITICAL, Hint.TIME_SENSIBLE); } catch (RetrierGiveUpException ex) { this.close(); throw new StopReplicationException("Stopping replication after several attepts to " + "fetch the remote oplog", ex); } catch (RetrierAbortException ex) { this.close(); Throwable cause = ex.getCause(); if (cause != null) { if (cause instanceof StopReplicationException) { throw (StopReplicationException) cause; } if (cause instanceof RollbackReplicationException) { throw (RollbackReplicationException) cause; } } throw new StopReplicationException("Stopping replication after a unknown abort " + "exception", ex); } } @Inject ContinuousOplogFetcher(OplogReaderProvider readerProvider, SyncSourceProvider syncSourceProvider, Retrier retrier, @Assisted long lastFetchedHash, @Assisted OpTime lastFetchedOptime, ReplMetrics metrics, LoggerFactory lf); @Override OplogBatch fetch(); @Override void close(); }
@Test(expected = StopReplicationException.class) public void testEmptyOplog() throws Exception { List<OplogOperation> oplog = Collections.emptyList(); oplogSupplier = () -> oplog; ContinuousOplogFetcher fetcher = factory.createFetcher(0, OpTime.EPOCH); fetcher.fetch(); } @Test(expected = RollbackReplicationException.class) public void testOldOplog() throws Exception { int oplogSize = 2; List<OplogOperation> oplog = createInsertStream(this::createSimpleInsert) .limit(oplogSize) .collect(Collectors.toList()); oplogSupplier = () -> oplog; OplogOperation lastOp = oplog.get(oplog.size() - 1); ContinuousOplogFetcher fetcher = factory.createFetcher(0, opTimeFactory.getNextOpTime(lastOp.getOpTime()) ); fetcher.fetch(); } @Test public void testShortOplog() throws Exception { int oplogSize = 2; List<OplogOperation> oplog = createInsertStream(this::createSimpleInsert) .limit(oplogSize) .collect(Collectors.toList()); oplogSupplier = () -> oplog; OplogOperation firstOp = oplog.get(0); ContinuousOplogFetcher fetcher = factory.createFetcher(firstOp.getHash(), firstOp.getOpTime()); List<OplogOperation> recivedOplog = new ArrayList<>(oplogSize); OplogBatch batch = null; while (batch == null || !(batch.isLastOne() || batch.isReadyForMore())) { batch = fetcher.fetch(); recivedOplog.addAll(batch.getOps()); } assertEquals("Unexpected number of oplog entries fetched: ", oplog.size() - 1, recivedOplog .size()); assertEquals(oplog.subList(1, oplog.size()), recivedOplog); } @Test public void testMediumOplog() throws Exception { int oplogSize = 1000; List<OplogOperation> oplog = createInsertStream(this::createSimpleInsert) .limit(oplogSize) .collect(Collectors.toList()); oplogSupplier = () -> oplog; OplogOperation firstOp = oplog.get(0); ContinuousOplogFetcher fetcher = factory.createFetcher(firstOp.getHash(), firstOp.getOpTime()); List<OplogOperation> recivedOplog = new ArrayList<>(oplogSize); OplogBatch batch = null; while (batch == null || !(batch.isLastOne() || batch.isReadyForMore())) { batch = fetcher.fetch(); recivedOplog.addAll(batch.getOps()); } assertEquals("Unexpected number of oplog entries fetched: ", oplog.size() - 1, recivedOplog .size()); assertEquals(oplog.subList(1, oplog.size()), recivedOplog); } @Test public void testBigOplog() throws Exception { int oplogSize = 100000; List<OplogOperation> oplog = createInsertStream(this::createSimpleInsert) .limit(oplogSize) .collect(Collectors.toList()); oplogSupplier = () -> oplog; OplogOperation firstOp = oplog.get(0); ContinuousOplogFetcher fetcher = factory.createFetcher(firstOp.getHash(), firstOp.getOpTime()); List<OplogOperation> recivedOplog = new ArrayList<>(oplogSize); OplogBatch batch = null; while (batch == null || !(batch.isLastOne() || !batch.isReadyForMore())) { batch = fetcher.fetch(); recivedOplog.addAll(batch.getOps()); } assertEquals("Unexpected number of oplog entries fetched: ", oplog.size() - 1, recivedOplog .size()); assertEquals(oplog.subList(1, oplog.size()), recivedOplog); }
AbstractMongoOplogReader implements OplogReader { @Override public MongoCursor<OplogOperation> queryGte(OpTime lastFetchedOpTime) throws MongoException { BsonDocument query = DefaultBsonValues.newDocument( "ts", DefaultBsonValues.newDocument("$gte", lastFetchedOpTime.getTimestamp()) ); EnumSet<QueryOption> flags = EnumSet.of( QueryOption.AWAIT_DATA, QueryOption.TAILABLE_CURSOR ); return query(query, flags, NATURAL_ORDER_SORT); } @Override MongoCursor<OplogOperation> queryGte(OpTime lastFetchedOpTime); @Override OplogOperation getLastOp(); @Override OplogOperation getFirstOp(); @Override MongoCursor<OplogOperation> between( OpTime from, boolean includeFrom, OpTime to, boolean includeTo); MongoCursor<OplogOperation> query(BsonDocument query, EnumSet<QueryOption> flags, BsonDocument sortBy); }
@Test public void testQueryGTE() throws Exception { }
AbstractMongoOplogReader implements OplogReader { @Override public OplogOperation getLastOp() throws OplogStartMissingException, OplogOperationUnsupported, MongoException { return getFirstOrLastOp(false); } @Override MongoCursor<OplogOperation> queryGte(OpTime lastFetchedOpTime); @Override OplogOperation getLastOp(); @Override OplogOperation getFirstOp(); @Override MongoCursor<OplogOperation> between( OpTime from, boolean includeFrom, OpTime to, boolean includeTo); MongoCursor<OplogOperation> query(BsonDocument query, EnumSet<QueryOption> flags, BsonDocument sortBy); }
@Test public void testGetLastOp() throws Exception { }
AbstractMongoOplogReader implements OplogReader { @Override public OplogOperation getFirstOp() throws OplogStartMissingException, OplogOperationUnsupported, MongoException { return getFirstOrLastOp(true); } @Override MongoCursor<OplogOperation> queryGte(OpTime lastFetchedOpTime); @Override OplogOperation getLastOp(); @Override OplogOperation getFirstOp(); @Override MongoCursor<OplogOperation> between( OpTime from, boolean includeFrom, OpTime to, boolean includeTo); MongoCursor<OplogOperation> query(BsonDocument query, EnumSet<QueryOption> flags, BsonDocument sortBy); }
@Test public void testGetFirstOp() throws Exception { }
AbstractMongoOplogReader implements OplogReader { @Override public MongoCursor<OplogOperation> between( OpTime from, boolean includeFrom, OpTime to, boolean includeTo) throws MongoException { BsonArrayBuilder conditions = new BsonArrayBuilder(); conditions.add( DefaultBsonValues.newDocument( "ts", DefaultBsonValues.newDocument(includeFrom ? "$gte" : "$gt", from.getTimestamp()) ) ); conditions.add( DefaultBsonValues.newDocument( "ts", DefaultBsonValues.newDocument(includeTo ? "$lte" : "$lt", to.getTimestamp()) ) ); EnumSet<QueryOption> flags = EnumSet.noneOf(QueryOption.class); return query( DefaultBsonValues.newDocument("$and", conditions.build()), flags, NATURAL_ORDER_SORT); } @Override MongoCursor<OplogOperation> queryGte(OpTime lastFetchedOpTime); @Override OplogOperation getLastOp(); @Override OplogOperation getFirstOp(); @Override MongoCursor<OplogOperation> between( OpTime from, boolean includeFrom, OpTime to, boolean includeTo); MongoCursor<OplogOperation> query(BsonDocument query, EnumSet<QueryOption> flags, BsonDocument sortBy); }
@Test public void testBetween() throws Exception { }
AbstractMongoOplogReader implements OplogReader { public MongoCursor<OplogOperation> query(BsonDocument query, EnumSet<QueryOption> flags, BsonDocument sortBy) throws MongoException { Preconditions.checkState(!isClosed(), "You have to connect this client before"); MongoConnection connection = consumeConnection(); MongoCursor<BsonDocument> cursor = connection.query( DATABASE, COLLECTION, query, 0, 0, new QueryOptions(flags), sortBy, null ); return new MyCursor<>( connection, TransformationMongoCursor.create( cursor, OplogOperationParser.asFunction() ) ); } @Override MongoCursor<OplogOperation> queryGte(OpTime lastFetchedOpTime); @Override OplogOperation getLastOp(); @Override OplogOperation getFirstOp(); @Override MongoCursor<OplogOperation> between( OpTime from, boolean includeFrom, OpTime to, boolean includeTo); MongoCursor<OplogOperation> query(BsonDocument query, EnumSet<QueryOption> flags, BsonDocument sortBy); }
@Test public void testQuery() throws Exception { }
SimpleRegExpDecoder { public static Pattern decode(String simpleRegExp) { StringBuilder resultPatternBuilder = new StringBuilder(); boolean quoted = false; final int length = simpleRegExp.length(); for (int index = 0; index < length; index++) { char simpleRegExpChar = simpleRegExp.charAt(index); if (simpleRegExpChar == ANY_CHARACTER) { if (quoted) { resultPatternBuilder.append("\\E"); quoted = false; } resultPatternBuilder.append(".*"); } else { if (!quoted) { resultPatternBuilder.append("\\Q"); quoted = true; } if (simpleRegExpChar == DELIMITER) { index++; simpleRegExpChar = simpleRegExp.charAt(index); } resultPatternBuilder.append(simpleRegExpChar); } } if (quoted) { resultPatternBuilder.append("\\E"); } return Pattern.compile(resultPatternBuilder.toString()); } static Pattern decode(String simpleRegExp); }
@Test public void decodeTest() { Assert .assertEquals("\\Qmine_and_your\\E", SimpleRegExpDecoder.decode("mine_and_your").pattern()); Assert.assertEquals("\\Qmine_\\E.*\\Q_your\\E", SimpleRegExpDecoder.decode("mine_*_your") .pattern()); Assert.assertEquals("\\Qmine_*_your\\E", SimpleRegExpDecoder.decode("mine_\\*_your").pattern()); Assert.assertEquals("\\Qmine_\\\\E.*\\Q_your\\E", SimpleRegExpDecoder.decode( "min\\e_\\\\*_yo\\ur").pattern()); Assert.assertEquals(".*\\Q_and_your\\E", SimpleRegExpDecoder.decode("*_and_your").pattern()); Assert.assertEquals("\\Qmine_and_\\E.*", SimpleRegExpDecoder.decode("mine_and_*").pattern()); Assert.assertEquals("\\Q*_and_your\\E", SimpleRegExpDecoder.decode("\\*_and_your").pattern()); Assert.assertEquals("\\Qmine_and_*\\E", SimpleRegExpDecoder.decode("mine_and_\\*").pattern()); }
BatchMetaDocPart implements MutableMetaDocPart { @Override public ImmutableMetaField addMetaField(String name, String identifier, FieldType type) throws IllegalArgumentException { ImmutableMetaField newMetaField = delegate.addMetaField(name, identifier, type); fieldsChangesOnBatch.add(newMetaField); changeConsumer.accept(this); return newMetaField; } BatchMetaDocPart(MutableMetaDocPart delegate, Consumer<BatchMetaDocPart> changeConsumer, boolean createdOnCurrentBatch); boolean isCreatedOnCurrentBatch(); void setCreatedOnCurrentBatch(boolean createdOnCurrentBatch); @DoNotChange Iterable<ImmutableMetaField> getOnBatchModifiedMetaFields(); @DoNotChange Iterable<ImmutableMetaScalar> getOnBatchModifiedMetaScalars(); @Override ImmutableMetaField addMetaField(String name, String identifier, FieldType type); @Override ImmutableMetaScalar addMetaScalar(String identifier, FieldType type); @Override ImmutableMetaField getMetaFieldByNameAndType(String fieldName, FieldType type); @Override Stream<? extends ImmutableMetaField> streamMetaFieldByName(String fieldName); @Override ImmutableMetaField getMetaFieldByIdentifier(String fieldId); @Override Stream<? extends ImmutableMetaField> streamFields(); @Override Stream<? extends ImmutableMetaField> streamAddedMetaFields(); @Override ImmutableMetaField getAddedFieldByIdentifier(String identifier); @Override ImmutableMetaDocPart immutableCopy(); @Override TableRef getTableRef(); @Override String getIdentifier(); @Override Stream<? extends ImmutableMetaScalar> streamAddedMetaScalars(); @Override Stream<? extends MetaScalar> streamScalars(); @Override Stream<? extends MetaIdentifiedDocPartIndex> streamIndexes(); @Override MetaIdentifiedDocPartIndex getMetaDocPartIndexByIdentifier(String indexId); @Override MutableMetaDocPartIndex addMetaDocPartIndex(boolean unique); @Override @SuppressWarnings("checkstyle:LineLength") Stream<ChangedElement<ImmutableMetaIdentifiedDocPartIndex>> streamModifiedMetaDocPartIndexes(); @Override Iterable<MutableMetaDocPartIndex> getAddedMutableMetaDocPartIndexes(); @Override boolean removeMetaDocPartIndexByIdentifier(String indexId); @Override MutableMetaDocPartIndex getOrCreatePartialMutableDocPartIndexForMissingIndexAndNewField( MetaIndex missingIndex, List<String> identifiers, MetaField newField); @Override String toString(); }
@Test public void testAddMetaField() { String fieldName = "aFieldName"; String fieldId = "aFieldID"; FieldType fieldType = FieldType.INTEGER; assertNull(delegate.getMetaFieldByIdentifier(fieldId)); assertNull(delegate.getMetaFieldByNameAndType(fieldName, fieldType)); assertNull(docPart.getMetaFieldByIdentifier(fieldId)); assertNull(docPart.getMetaFieldByNameAndType(fieldName, fieldType)); docPart.addMetaField(fieldName, fieldId, fieldType); assertNotNull(delegate.getMetaFieldByIdentifier(fieldId)); assertNotNull(delegate.getMetaFieldByNameAndType(fieldName, fieldType)); assertNotNull(docPart.getMetaFieldByIdentifier(fieldId)); assertNotNull(docPart.getMetaFieldByNameAndType(fieldName, fieldType)); assertFalse(!docPart.streamAddedMetaFields().findAny().isPresent()); assertFalse(!delegate.streamAddedMetaFields().findAny().isPresent()); assertFalse(Iterables.isEmpty(docPart.getOnBatchModifiedMetaFields())); verify(testChangeConsumer).accept(docPart); verifyNoMoreInteractions(testChangeConsumer); }