public static void update(Long idGroup, List<SqlRow> gpms) {
Group group = Group.findById(idGroup);
if (group == null) return;
Ebean.beginTransaction();
try {
deleteForGroup(idGroup);
Integer i = 1;
for (SqlRow man : gpms) {
Profile prof = Profile.lastProfileByGpmId(man.getLong("gpm"));
if (prof == null) continue;
CacheClassifier cc =
new CacheClassifier(
group,
i++,
prof.gpm.idGpm,
prof.name,
prof.image,
(prof.gender == null) ? null : prof.gender.value,
(prof.relationshipStatus == null) ? null : prof.relationshipStatus.status,
prof.nFollowers);
if (cc.name == null || cc.name.isEmpty())
cc.name = Profile.getLastNotEmptyField(prof.gpm.id, "name");
cc.save();
}
Ebean.commitTransaction();
} finally {
Ebean.endTransaction();
}
}
/**
* Mark the specified action as completed
*
* @param transactionId the unique transaction id for this action
* @param scheduledActionUuid the unique name of an action
*/
private void markAsCompleted(String transactionId, String scheduledActionUuid) {
try {
Ebean.beginTransaction();
SchedulerState schedulerState =
SchedulerState.getRunningSchedulerStateFromTransactionId(transactionId);
if (schedulerState == null) {
log.error(
String.format(
"Strange ... No running scheduled action for %s with transaction id %s while one was running and mark as completed is requested",
scheduledActionUuid, transactionId));
} else {
schedulerState.isRunning = false;
schedulerState.save();
if (log.isDebugEnabled()) {
log.debug(
String.format(
"Scheduled action for %s with transaction id %s completed",
scheduledActionUuid, transactionId));
}
}
Ebean.commitTransaction();
} catch (Exception e) {
log.error("Failed to mark as complete", e);
rollbackTransactionSilent();
} finally {
endTransactionSilent();
}
}
@Override
public void deleteCarouselImage(Long id) throws NotFoundException {
// We use explicit transactions, since we are going to execute more than
// 1 query in the same transaction
Ebean.beginTransaction();
try {
// We see if the carouselImage really exists
if (finder.byId(id) == null)
throw new NotFoundException("La imagen no existe asi que no se puede borrar");
// We delete it
finder.byId(id).delete();
// Now we need to reorder all the carouselImages
for (CarouselImage ci : finder.orderBy("id").findList()) {
if (ci.getId() > id) {
// We insert a copy of the ci in the previous position
CarouselImage ciCopy = (CarouselImage) ci._ebean_createCopy();
ciCopy.setId(ci.getId() - 1);
ciCopy.save();
// Then we delete the ci
ci.delete();
}
}
Ebean.commitTransaction();
} finally {
Ebean.endTransaction();
}
}
@Override
public void addCarouselImage(CarouselImage carouselImage) {
// We use explicit transactions, since we are going to execute more than
// 1 query in the same transaction
Ebean.beginTransaction();
try {
// We set atomatically the caroueselImage id, in order to be the
// first one
carouselImage.setId((long) 1);
List<CarouselImage> carouselImages = finder.orderBy().desc("id").findList();
for (CarouselImage ci : carouselImages) {
// We insert a copy of the ci in the next position
CarouselImage ciCopy = (CarouselImage) ci._ebean_createCopy();
ciCopy.setId(ci.getId() + 1);
ciCopy.save();
// Then we delete the ci
ci.delete();
}
// Then we save
carouselImage.save();
Ebean.commitTransaction();
} finally {
Ebean.endTransaction();
}
}
@Test
public void testGetForValidId() throws IOException {
final UUID uuid = UUID.randomUUID();
Assert.assertFalse(exprRepo.get(uuid, Organization.DEFAULT).isPresent());
final models.ebean.Expression ebeanExpression = TestBeanFactory.createEbeanExpression();
ebeanExpression.setUuid(uuid);
ebeanExpression.setOrganization(
models.ebean.Organization.findByOrganization(Organization.DEFAULT));
try (Transaction transaction = Ebean.beginTransaction()) {
Ebean.save(ebeanExpression);
transaction.commit();
}
final Optional<Expression> expected = exprRepo.get(uuid, Organization.DEFAULT);
Assert.assertTrue(expected.isPresent());
Assert.assertTrue(isExpressionEbeanEquivalent(expected.get(), ebeanExpression));
}
@Test
public void testGetExpressionCountWithMultipleExpr() throws IOException {
Assert.assertEquals(0, exprRepo.getExpressionCount(Organization.DEFAULT));
try (Transaction transaction = Ebean.beginTransaction()) {
final models.ebean.Expression ebeanExpression1 = TestBeanFactory.createEbeanExpression();
ebeanExpression1.setUuid(UUID.randomUUID());
ebeanExpression1.setOrganization(
models.ebean.Organization.findByOrganization(Organization.DEFAULT));
Ebean.save(ebeanExpression1);
final models.ebean.Expression ebeanExpression2 = TestBeanFactory.createEbeanExpression();
ebeanExpression2.setUuid(UUID.randomUUID());
ebeanExpression2.setOrganization(
models.ebean.Organization.findByOrganization(Organization.DEFAULT));
Ebean.save(ebeanExpression2);
transaction.commit();
}
Assert.assertEquals(2, exprRepo.getExpressionCount(Organization.DEFAULT));
}
@Test
public void addOrUpdateExpressionUpdateCase() throws IOException {
final UUID uuid = UUID.randomUUID();
final models.ebean.Organization organization;
try (Transaction transaction = Ebean.beginTransaction()) {
final models.ebean.Expression ebeanExpression = TestBeanFactory.createEbeanExpression();
ebeanExpression.setUuid(uuid);
organization = ebeanExpression.getOrganization();
Ebean.save(ebeanExpression);
transaction.commit();
}
final Expression actual =
TestBeanFactory.createExpressionBuilder().setId(uuid).setCluster("new-cluster").build();
exprRepo.addOrUpdateExpression(actual, TestBeanFactory.organizationFrom(organization));
final Expression expected =
exprRepo.get(uuid, TestBeanFactory.organizationFrom(organization)).get();
Assert.assertEquals(expected, actual);
}
@Test(expected = PersistenceException.class)
public void testThrowsExceptionWhenQueryFails() {
final UUID uuid = UUID.randomUUID();
exprRepo.addOrUpdateExpression(
TestBeanFactory.createExpressionBuilder().setId(uuid).setCluster("new-cluster").build(),
Organization.DEFAULT);
models.ebean.Expression ebeanExpression1 =
Ebean.find(models.ebean.Expression.class).where().eq("uuid", uuid).findUnique();
models.ebean.Expression ebeanExpression2 =
Ebean.find(models.ebean.Expression.class).where().eq("uuid", uuid).findUnique();
try (Transaction transaction = Ebean.beginTransaction()) {
ebeanExpression1.setCluster("new-cluster1");
ebeanExpression2.setCluster("new-cluster2");
ebeanExpression2.save();
ebeanExpression1.save();
transaction.commit();
} catch (final IOException e) {
// Do Nothing
}
}
@Override
protected Result hook_call(Context ctx) throws Throwable {
// TODO make it possible to get an extra transaction (either nested, or separate)
// TODO allow for transactions across multiple requests
boolean successful = false;
try {
Ebean.beginTransaction();
Result result = delegate.call(ctx);
successful = true;
return result;
} finally {
// if running tests, don't commit
if (AppContext.Mode.isRunningTests() || !successful) {
Ebean.rollbackTransaction();
} else {
// TODO do retry logic
Ebean.commitTransaction();
}
}
}
@Test
public void test() {
LoggedSqlCollector.start();
Transaction txn = Ebean.beginTransaction();
try {
txn.setBatch(PersistBatch.ALL);
EdParent parent = new EdParent();
parent.setName("MyComputer");
EdChild child = new EdChild();
child.setName("Harddisk 123");
child.setParent(parent);
ArrayList<EdChild> children = new ArrayList<EdChild>();
children.add(child);
parent.setChildren(children);
Ebean.save(parent);
// nothing flushed yet
List<String> loggedSql0 = LoggedSqlCollector.start();
assertEquals(0, loggedSql0.size());
parent.setName("MyDesk");
Ebean.save(parent);
// nothing flushed yet
assertEquals(0, LoggedSqlCollector.start().size());
Ebean.commitTransaction();
// insert statements for EdExtendedParent
List<String> loggedSql2 = LoggedSqlCollector.start();
assertEquals(2, loggedSql2.size());
} finally {
Ebean.endTransaction();
}
}
/**
* Mark the specified action as completed
*
* @param transactionId the unique transaction id for this action
* @param scheduledActionUuid the unique name of an action
*/
private void markAsStarted(String transactionId, String scheduledActionUuid) {
try {
Ebean.beginTransaction();
SchedulerState schedulerState = new SchedulerState();
schedulerState.actionUuid = scheduledActionUuid;
schedulerState.transactionId = transactionId;
schedulerState.isRunning = true;
schedulerState.save();
if (log.isDebugEnabled()) {
log.debug(
String.format(
"Scheduled action for %s with transaction id %s started",
scheduledActionUuid, transactionId));
}
Ebean.commitTransaction();
} catch (Exception e) {
log.error("Failed to mark as started", e);
rollbackTransactionSilent();
} finally {
endTransactionSilent();
}
}
@Test
public void test_countUsingForegound() throws ExecutionException, InterruptedException {
ResetBasicData.reset();
PagedList<Order> pagedList = Ebean.find(Order.class).findPagedList(0, 6);
LoggedSqlCollector.start();
// kinda not normal but just wrap in a transaction to assert
// the background fetch does not occur (which explicitly creates
// its own transaction) ... so a bit naughty with the test here
Ebean.beginTransaction();
try {
List<Order> orders = pagedList.getList();
int totalRowCount = pagedList.getTotalRowCount();
// invoke it again but cached...
int totalRowCountAgain = pagedList.getTotalRowCount();
List<String> loggedSql = LoggedSqlCollector.stop();
assertTrue(orders.size() < totalRowCount);
assertEquals(2, loggedSql.size());
assertEquals(totalRowCount, totalRowCountAgain);
String firstTxn = loggedSql.get(0).substring(0, 10);
String secTxn = loggedSql.get(1).substring(0, 10);
assertEquals(firstTxn, secTxn);
} finally {
Ebean.endTransaction();
}
}
