RenJuan/TASKPM
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ItEr60S04ValidacionEProbasFuncionaisItEr59S04: [Bug #514] Fix deleted entity would be resaved by cascade.

Browse source 
Also refactorings and when the order has no versions left it's removed.
This commit is contained in:
Óscar González Fernández 2010-06-22 19:55:42 +02:00
parent 5b5375e577
commit defb0ae34e
5 changed files with 97 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java
View file

@ -495,8 +495,19 @@ public class Order extends OrderLineGroup {
scenarios.put(currentScenario, orderVersion);
}
public void removeOrderVersionForScenario(Scenario scenario) {
scenarios.remove(scenario);
/**
* Disassociates this order and its children from the scenario
*
* @param scenario
* @return <code>null</code> if there is no order version for the scenario;
* the order version associated to the supplied scenario
*/
public OrderVersion disassociateFrom(Scenario scenario) {
OrderVersion existentVersion = scenarios.remove(scenario);
if (existentVersion != null) {
removeVersion(existentVersion);
}
return existentVersion;
}
public OrderVersion getOrderVersionFor(Scenario current) {
@ -507,4 +518,17 @@ public class Order extends OrderLineGroup {
public void setOrderVersion(Scenario scenario, OrderVersion newOrderVersion) {
scenarios.put(scenario, newOrderVersion);
}
public boolean hasNoVersions() {
return scenarios.isEmpty();
}
public boolean isVersionUsed(OrderVersion orderVersion) {
for (OrderVersion each : getScenarios().values()) {
if (each.getId().equals(orderVersion.getId())) {
return true;
}
}
return false;
}
}

7
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
View file

@ -115,6 +115,13 @@ public abstract class OrderElement extends IntegrationEntity implements
private Map<OrderVersion, SchedulingDataForVersion> schedulingDatasForVersion = new HashMap<OrderVersion, SchedulingDataForVersion>();
protected void removeVersion(OrderVersion orderVersion) {
schedulingDatasForVersion.remove(orderVersion);
for (OrderElement each : getChildren()) {
each.removeVersion(orderVersion);
}
}
private SchedulingDataForVersion.Data current = null;
public SchedulingDataForVersion.Data getCurrentSchedulingData() {

12
navalplanner-business/src/main/java/org/navalplanner/business/scenarios/entities/Scenario.java
View file

@ -25,11 +25,13 @@ import static org.navalplanner.business.i18n.I18nHelper._;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.Validate;
import org.hibernate.validator.AssertTrue;
@ -84,6 +86,16 @@ public class Scenario extends BaseEntity {
this.predecessor = predecessor;
}
public void removeVersion(OrderVersion orderVersion) {
Iterator<OrderVersion> iterator = orders.values().iterator();
while (iterator.hasNext()) {
OrderVersion each = iterator.next();
if (ObjectUtils.equals(orderVersion, each)) {
iterator.remove();
}
}
}
public OrderVersion addOrder(Order order) {
addOrder(order, OrderVersion.createInitialVersion(this));
return orders.get(order);

87
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderModel.java
View file

@ -643,45 +643,60 @@ public class OrderModel implements IOrderModel {
@Override
@Transactional
public void remove(Order order) {
if (order.getScenarios().size() == 1) {
try {
orderDAO.remove(order.getId());
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
} else {
orderDAO.save(order);
public void remove(Order detachedOrder) {
Order order = orderDAO.findExistingEntity(detachedOrder.getId());
removeVersions(order);
if (order.hasNoVersions()) {
removeOrderFromDB(order);
}
}
Scenario scenario = scenarioManager.getCurrent();
OrderVersion currentOrderVersion = scenario.getOrderVersion(order);
order.removeOrderVersionForScenario(scenario);
private void removeVersions(Order order) {
Map<Long, OrderVersion> versionsRemovedById = new HashMap<Long, OrderVersion>();
List<Scenario> currentAndDerived = currentAndDerivedScenarios();
for (Scenario each : currentAndDerived) {
OrderVersion versionRemoved = order.disassociateFrom(each);
if (versionRemoved != null) {
versionsRemovedById.put(versionRemoved.getId(), versionRemoved);
}
}
for (OrderVersion each : versionsRemovedById.values()) {
if (!order.isVersionUsed(each)) {
removeOrderVersionAt(each, currentAndDerived);
removeOrderVersionFromDB(each);
}
}
}
derivedScenarios = scenarioDAO.getDerivedScenarios(scenario);
for (Scenario derivedScenario : derivedScenarios) {
OrderVersion orderVersion = order
.getOrderVersionFor(derivedScenario);
if ((orderVersion != null)
&& (orderVersion.getId()
.equals(currentOrderVersion.getId()))) {
order.removeOrderVersionForScenario(derivedScenario);
}
}
private void removeOrderVersionAt(OrderVersion orderVersion,
Collection<? extends Scenario> currentAndDerived) {
for (Scenario each : currentAndDerived) {
each.removeVersion(orderVersion);
}
}
boolean orderVersionNotUsed = true;
for (OrderVersion orderVersion : order.getScenarios().values()) {
if (orderVersion.getId().equals(currentOrderVersion.getId())) {
orderVersionNotUsed = false;
break;
}
}
if (orderVersionNotUsed) {
try {
orderVersionDAO.remove(currentOrderVersion.getId());
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
private List<Scenario> currentAndDerivedScenarios() {
List<Scenario> scenariosToBeDisassociatedFrom = new ArrayList<Scenario>();
Scenario currentScenario = scenarioManager.getCurrent();
scenariosToBeDisassociatedFrom.add(currentScenario);
scenariosToBeDisassociatedFrom.addAll(scenarioDAO
.getDerivedScenarios(currentScenario));
return scenariosToBeDisassociatedFrom;
}
private void removeOrderVersionFromDB(OrderVersion currentOrderVersion) {
try {
orderVersionDAO.remove(currentOrderVersion.getId());
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
private void removeOrderFromDB(Order order) {
try {
orderDAO.remove(order.getId());
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}

2
navalplanner-webapp/src/main/java/org/navalplanner/web/scenarios/ScenarioModel.java
View file

@ -149,7 +149,7 @@ public class ScenarioModel implements IScenarioModel {
}
}
} else {
order.removeOrderVersionForScenario(scenario);
order.disassociateFrom(scenario);
orderDAO.save(order);
}
}