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

[Bug #1227] Order authorizations are saved now in SaveCommand

Browse source 
PlanningState manage the list of order authorizations and the controller
and model for order authorizations have been adapted to work against
PlanningState instead of DB.

FEA: ItEr75S04BugFixing
This commit is contained in:
Manuel Rego Casasnovas 2011-10-25 08:02:09 +02:00
parent 4f66d8018d
commit 7259c83ea6
8 changed files with 110 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IOrderModel.java
View file

@ -126,4 +126,6 @@ public interface IOrderModel extends IIntegrationEntityModel {
void useSchedulingDataForCurrentScenario(Order order);
PlanningState getPlanningState();
}

6
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderCRUDController.java
View file

@ -666,9 +666,11 @@ public class OrderCRUDController extends GenericForwardComposer {
.getFellowIfAny("orderElementAuthorizations");
final Order order = (Order) orderModel.getOrder();
if (order.isNewObject()) {
orderAuthorizationController.initCreate(order);
orderAuthorizationController.initCreate(orderModel
.getPlanningState());
} else {
orderAuthorizationController.initEdit(order);
orderAuthorizationController
.initEdit(orderModel.getPlanningState());
}
Util.createBindingsFor(orderElementAuthorizations);
Util.reloadBindings(orderElementAuthorizations);

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

@ -826,4 +826,9 @@ public class OrderModel extends IntegrationEntityModel implements IOrderModel {
return this.planningState.getOrder();
}
@Override
public PlanningState getPlanningState() {
return planningState;
}
}

53
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/PlanningStateCreator.java
View file

@ -74,6 +74,10 @@ import org.navalplanner.business.scenarios.daos.IOrderVersionDAO;
import org.navalplanner.business.scenarios.daos.IScenarioDAO;
import org.navalplanner.business.scenarios.entities.OrderVersion;
import org.navalplanner.business.scenarios.entities.Scenario;
import org.navalplanner.business.users.daos.IOrderAuthorizationDAO;
import org.navalplanner.business.users.entities.OrderAuthorization;
import org.navalplanner.business.users.entities.ProfileOrderAuthorization;
import org.navalplanner.business.users.entities.UserOrderAuthorization;
import org.navalplanner.web.calendars.BaseCalendarModel;
import org.navalplanner.web.planner.TaskElementAdapter;
import org.springframework.beans.factory.annotation.Autowired;
@ -161,6 +165,9 @@ public class PlanningStateCreator {
@Autowired
private SaveCommandBuilder saveCommandBuilder;
@Autowired
private IOrderAuthorizationDAO orderAuthorizationDAO;
void synchronizeWithSchedule(Order order, IOptionalPersistence persistence) {
List<TaskSourceSynchronization> synchronizationsNeeded = order
.calculateSynchronizationsNeeded();
@ -668,6 +675,10 @@ public class PlanningStateCreator {
private final IScenarioInfo scenarioInfo;
private List<OrderAuthorization> orderAuthorizations;
private List<OrderAuthorization> orderAuthorizationsAddition = new ArrayList<OrderAuthorization>();
private List<OrderAuthorization> orderAuthorizationsRemoval = new ArrayList<OrderAuthorization>();
public PlanningState(Order order,
Collection<? extends Resource> initialResources,
Scenario currentScenario) {
@ -679,6 +690,23 @@ public class PlanningStateCreator {
this.resources = OrderPlanningModel
.loadRequiredDataFor(new HashSet<Resource>(initialResources));
associateWithScenario(this.resources);
this.orderAuthorizations = loadOrderAuthorizations();
}
private List<OrderAuthorization> loadOrderAuthorizations() {
List<OrderAuthorization> orderAuthorizations = orderAuthorizationDAO
.listByOrder(order);
for (OrderAuthorization each : orderAuthorizations) {
if (each instanceof UserOrderAuthorization) {
((UserOrderAuthorization) each).getUser().getLoginName();
}
if (each instanceof ProfileOrderAuthorization) {
((ProfileOrderAuthorization) each).getProfile()
.getProfileName();
}
}
return orderAuthorizations;
}
void onRetrieval() {
@ -991,6 +1019,31 @@ public class PlanningStateCreator {
return result;
}
public List<OrderAuthorization> getOrderAuthorizations() {
return Collections.unmodifiableList(orderAuthorizations);
}
public List<OrderAuthorization> getOrderAuthorizationsAddition() {
return Collections.unmodifiableList(orderAuthorizationsAddition);
}
public List<OrderAuthorization> getOrderAuthorizationsRemoval() {
return Collections.unmodifiableList(orderAuthorizationsRemoval);
}
public void addOrderAuthorization(OrderAuthorization orderAuthorization) {
orderAuthorizations.add(orderAuthorization);
orderAuthorizationsAddition.add(orderAuthorization);
}
public void removeOrderAuthorization(
OrderAuthorization orderAuthorization) {
orderAuthorizations.remove(orderAuthorization);
orderAuthorizationsAddition.remove(orderAuthorization);
if (!orderAuthorization.isNewObject()) {
orderAuthorizationsRemoval.add(orderAuthorization);
}
}
}
public interface IAllocationCriteria {

22
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/SaveCommandBuilder.java
View file

@ -80,6 +80,8 @@ import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueue
import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
import org.navalplanner.business.scenarios.daos.IScenarioDAO;
import org.navalplanner.business.scenarios.entities.Scenario;
import org.navalplanner.business.users.daos.IOrderAuthorizationDAO;
import org.navalplanner.business.users.entities.OrderAuthorization;
import org.navalplanner.web.common.concurrentdetection.ConcurrentModificationHandling;
import org.navalplanner.web.planner.TaskElementAdapter;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
@ -194,6 +196,9 @@ public class SaveCommandBuilder {
@Autowired
private IAdHocTransactionService transactionService;
@Autowired
private IOrderAuthorizationDAO orderAuthorizationDAO;
private class SaveCommand implements ISaveCommand {
private PlanningState state;
@ -344,6 +349,23 @@ public class SaveCommandBuilder {
loadDependenciesCollectionsForTaskRoot(state.getRootTask());
}
subcontractedTaskDataDAO.removeOrphanedSubcontractedTaskData();
saveOrderAuthorizations();
}
private void saveOrderAuthorizations() {
for (OrderAuthorization each : state
.getOrderAuthorizationsAddition()) {
orderAuthorizationDAO.save(each);
}
for (OrderAuthorization each : state
.getOrderAuthorizationsRemoval()) {
try {
orderAuthorizationDAO.remove(each.getId());
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
}
private void createAdvancePercentagesIfRequired(Order order) {

6
navalplanner-webapp/src/main/java/org/navalplanner/web/users/IOrderAuthorizationModel.java
View file

@ -23,13 +23,13 @@ package org.navalplanner.web.users;
import java.util.List;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.users.entities.OrderAuthorization;
import org.navalplanner.business.users.entities.OrderAuthorizationType;
import org.navalplanner.business.users.entities.Profile;
import org.navalplanner.business.users.entities.ProfileOrderAuthorization;
import org.navalplanner.business.users.entities.User;
import org.navalplanner.business.users.entities.UserOrderAuthorization;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
/**
* Model for UI operations related to {@link OrderAuthorization}
@ -38,9 +38,9 @@ import org.navalplanner.business.users.entities.UserOrderAuthorization;
*/
public interface IOrderAuthorizationModel {
void initCreate(Order order);
void initCreate(PlanningState planningState);
void initEdit(Order order);
void initEdit(PlanningState planningState);
void confirmSave();

10
navalplanner-webapp/src/main/java/org/navalplanner/web/users/OrderAuthorizationController.java
View file

@ -26,7 +26,6 @@ import static org.navalplanner.web.I18nHelper._;
import java.util.ArrayList;
import java.util.List;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.users.entities.OrderAuthorization;
import org.navalplanner.business.users.entities.OrderAuthorizationType;
import org.navalplanner.business.users.entities.Profile;
@ -36,6 +35,7 @@ import org.navalplanner.business.users.entities.UserOrderAuthorization;
import org.navalplanner.web.common.IMessagesForUser;
import org.navalplanner.web.common.Level;
import org.navalplanner.web.common.Util;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
@ -66,13 +66,13 @@ public class OrderAuthorizationController extends GenericForwardComposer{
this.window = comp;
}
public void initCreate(Order order) {
orderAuthorizationModel.initCreate(order);
public void initCreate(PlanningState planningState) {
orderAuthorizationModel.initCreate(planningState);
Util.reloadBindings(window);
}
public void initEdit(Order order) {
orderAuthorizationModel.initEdit(order);
public void initEdit(PlanningState planningState) {
orderAuthorizationModel.initEdit(planningState);
Util.reloadBindings(window);
}

79
navalplanner-webapp/src/main/java/org/navalplanner/web/users/OrderAuthorizationModel.java
View file

@ -21,17 +21,11 @@
package org.navalplanner.web.users;
import static org.navalplanner.web.I18nHelper._;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.validator.InvalidValue;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.daos.IOrderDAO;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.users.daos.IOrderAuthorizationDAO;
import org.navalplanner.business.users.daos.IUserDAO;
import org.navalplanner.business.users.entities.OrderAuthorization;
import org.navalplanner.business.users.entities.OrderAuthorizationType;
@ -39,6 +33,7 @@ import org.navalplanner.business.users.entities.Profile;
import org.navalplanner.business.users.entities.ProfileOrderAuthorization;
import org.navalplanner.business.users.entities.User;
import org.navalplanner.business.users.entities.UserOrderAuthorization;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.security.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
@ -63,15 +58,11 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
private List<OrderAuthorization> orderAuthorizationRemovalList;
@Autowired
private IOrderAuthorizationDAO dao;
@Autowired
private IOrderDAO orderDAO;
@Autowired
private IUserDAO userDAO;
private PlanningState planningState;
@Override
public List<OrderAuthorizationType> addProfileOrderAuthorization(
Profile profile, List<OrderAuthorizationType> authorizations) {
@ -88,6 +79,7 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
createProfileOrderAuthorization(order, profile);
orderAuthorization.setAuthorizationType(type);
profileOrderAuthorizationList.add(orderAuthorization);
planningState.addOrderAuthorization(orderAuthorization);
}
}
return duplicated.isEmpty()? null : duplicated;
@ -109,6 +101,7 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
createUserOrderAuthorization(order, user);
orderAuthorization.setAuthorizationType(type);
userOrderAuthorizationList.add(orderAuthorization);
planningState.addOrderAuthorization(orderAuthorization);
}
}
return duplicated.isEmpty()? null : duplicated;
@ -117,29 +110,7 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
@Override
@Transactional
public void confirmSave() {
try {
if(order.isNewObject()) {
//if it was new, we reload the order from the DAO
Order newOrder = orderDAO.find(order.getId());
replaceOrder(newOrder);
}
}catch (InstanceNotFoundException e) {
InvalidValue invalidValue = new InvalidValue(_("Project does not exist"),
OrderAuthorization.class, "order", order, null);
throw new ValidationException(invalidValue);
}
for(OrderAuthorization authorization : profileOrderAuthorizationList) {
dao.save(authorization);
}
for(OrderAuthorization authorization : userOrderAuthorizationList) {
dao.save(authorization);
}
for(OrderAuthorization authorization : orderAuthorizationRemovalList) {
try {
dao.remove(authorization.getId());
}
catch(InstanceNotFoundException e) {}
}
// Do nothing
}
@Override
@ -154,8 +125,9 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
@Override
@Transactional(readOnly = true)
public void initCreate(Order order) {
this.order = order;
public void initCreate(PlanningState planningState) {
this.planningState = planningState;
this.order = planningState.getOrder();
initializeLists();
//add write authorization for current user
try {
@ -164,6 +136,7 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
createUserOrderAuthorization(order, user);
orderAuthorization.setAuthorizationType(OrderAuthorizationType.WRITE_AUTHORIZATION);
userOrderAuthorizationList.add(orderAuthorization);
planningState.addOrderAuthorization(orderAuthorization);
}
catch(InstanceNotFoundException e) {
//this case shouldn't happen, because it would mean that there isn't a logged user
@ -172,12 +145,13 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
@Override
@Transactional(readOnly = true)
public void initEdit(Order order) {
this.order = order;
public void initEdit(PlanningState planningState) {
this.planningState = planningState;
this.order = planningState.getOrder();
initializeLists();
//Retrieve the OrderAuthorizations associated with this order
for(OrderAuthorization authorization : dao.listByOrder(order)) {
forceLoadEntities(authorization);
for (OrderAuthorization authorization : planningState
.getOrderAuthorizations()) {
if(authorization instanceof UserOrderAuthorization) {
userOrderAuthorizationList.add(
(UserOrderAuthorization) authorization);
@ -198,16 +172,6 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
new ArrayList<OrderAuthorization>();
}
private void forceLoadEntities(OrderAuthorization authorization) {
authorization.getOrder().getName();
if(authorization instanceof UserOrderAuthorization) {
((UserOrderAuthorization)authorization).getUser().getLoginName();
}
if(authorization instanceof ProfileOrderAuthorization) {
((ProfileOrderAuthorization)authorization).getProfile().getProfileName();
}
}
@Override
public void removeOrderAuthorization(OrderAuthorization orderAuthorization) {
if(orderAuthorization instanceof UserOrderAuthorization) {
@ -221,6 +185,7 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
if(!orderAuthorization.isNewObject()) {
orderAuthorizationRemovalList.add(orderAuthorization);
}
planningState.removeOrderAuthorization(orderAuthorization);
}
private ProfileOrderAuthorization createProfileOrderAuthorization(
@ -241,18 +206,6 @@ public class OrderAuthorizationModel implements IOrderAuthorizationModel {
return orderAuthorization;
}
private void replaceOrder(Order newOrder) {
for(OrderAuthorization authorization : profileOrderAuthorizationList) {
authorization.setOrder(newOrder);
dao.save(authorization);
}
for(OrderAuthorization authorization : userOrderAuthorizationList) {
authorization.setOrder(newOrder);
dao.save(authorization);
}
this.order = newOrder;
}
private List<UserOrderAuthorization> listAuthorizationsByUser(User user) {
List<UserOrderAuthorization> list = new ArrayList<UserOrderAuthorization>();
for(UserOrderAuthorization authorization : userOrderAuthorizationList) {