final void init(PluginLoader loader, Server server, PluginDescriptionFile description, File dataFolder, File file, ClassLoader classLoader) { this.loader = loader; this.server = server; this.file = file; this.description = description; this.dataFolder = dataFolder; this.classLoader = classLoader; this.configFile = new File(dataFolder, "config.yml"); this.logger = new PluginLogger(this); if (description.isDatabaseEnabled()) { ServerConfig db = new ServerConfig(); db.setDefaultServer(false); db.setRegister(false); db.setClasses(getDatabaseClasses()); db.setName(description.getName()); server.configureDbConfig(db); DataSourceConfig ds = db.getDataSourceConfig(); ds.setUrl(replaceDatabaseString(ds.getUrl())); dataFolder.mkdirs(); ClassLoader previous = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(classLoader); ebean = EbeanServerFactory.create(db); Thread.currentThread().setContextClassLoader(previous); } }
@Override public SqlUpdate createSqlUpdate(String sql) { methodCalls.add(MethodCall.of("createSqlUpdate").with("sql", sql)); return delegate.createSqlUpdate(sql); }
@Override public Transaction beginTransaction(TxIsolation isolation) { methodCalls.add(MethodCall.of("beginTransaction").with("isolation", isolation)); return delegate.beginTransaction(isolation); }
/** * Return an unparsed RawSqlBuilder. Unlike a parsed one this query can not be * modified - so no additional WHERE or HAVING expressions can be added to * this query. */ public static RawSqlBuilder unparsed(String sql) { Sql s = new Sql(sql); return new RawSqlBuilder(s, new ColumnMapping()); }
@Override public Transaction currentTransaction() { methodCalls.add(MethodCall.of("currentTransaction")); return delegate.currentTransaction(); }
@Override public <T> CsvReader<T> createCsvReader(Class<T> beanType) { methodCalls.add(MethodCall.of("createCsvReader").with("beanType", beanType)); return delegate.createCsvReader(beanType); }
/** * Less Than or Equal to - property less than or equal to the given value. */ public static Expression le(String propertyName, Object value) { return Ebean.getExpressionFactory().le(propertyName, value); }
/** * Create the query by Example expression specifying more options. */ public static ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType) { return Ebean.getExpressionFactory().exampleLike(example, caseInsensitive, likeType); }
/** * Case insensitive Contains - property like %value%. Typically uses a lower() * function to make the expression case insensitive. */ public static Expression icontains(String propertyName, String value) { return Ebean.getExpressionFactory().icontains(propertyName, value); }
@Override public ServerCacheManager getServerCacheManager() { methodCalls.add(MethodCall.of("getServerCacheManager")); return delegate.getServerCacheManager(); }
@Override public void markAsDirty(Object bean) { methodCalls.add(MethodCall.of("markAsDirty").with("bean", bean)); delegate.markAsDirty(bean); }
@Override public <T> T createEntityBean(Class<T> beanType) { methodCalls.add(MethodCall.of("createEntityBean").with("beanType", beanType)); return delegate.createEntityBean(beanType); }
@Override public Transaction createTransaction(TxIsolation isolation) { methodCalls.add(MethodCall.of("createTransaction").with("isolation", isolation)); return delegate.createTransaction(isolation); }
@Override public Transaction createTransaction() { methodCalls.add(MethodCall.of("createTransaction")); return delegate.createTransaction(); }
@Override public Transaction beginTransaction(TxScope scope) { methodCalls.add(MethodCall.of("beginTransaction").with("scope", scope)); return delegate.beginTransaction(scope); }