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

ItEr35S12CUCreacionUnidadesPlanificacionItEr34S12: Removing old scheduling mechanism

Browse source
This commit is contained in:
Óscar González Fernández 2009-11-17 12:14:27 +01:00
parent aefacfdace
commit 43860ce5f9
5 changed files with 2 additions and 336 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -22,12 +22,12 @@ package org.navalplanner.web.orders;
import java.util.List;
import java.util.Map;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.labels.entities.Label;
import org.navalplanner.business.orders.entities.IOrderLineGroup;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionType;
@ -46,10 +46,6 @@ public interface IOrderModel {
*/
void addLabel(Label label);
TaskElement convertToInitialSchedule(OrderElement order);
void convertToScheduleAndSave(Order order);
/**
* Returns a list of {@link Label}
*
@ -78,8 +74,6 @@ public interface IOrderModel {
List<Order> getOrders();
boolean isAlreadyScheduled(Order order);
void initEdit(Order order);
void prepareForCreate();
@ -88,8 +82,6 @@ public interface IOrderModel {
void save() throws ValidationException;
void schedule(Order order);
void setOrder(Order order);
}

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

@ -272,29 +272,7 @@ public class OrderCRUDController extends GenericForwardComposer {
messagesForUser.showMessage(Level.INFO, _("Removed {0}", order.getName()));
}
public void confirmSchedule(Order order) {
if (orderModel.isAlreadyScheduled(order)) {
goToShedulingView(order);
return;
}
try {
int status = Messagebox.show(_("Confirm scheduling {0}. Are you sure?", order.getName()), "Schedule",
Messagebox.OK | Messagebox.CANCEL, Messagebox.QUESTION);
if (Messagebox.OK == status) {
schedule(order);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void schedule(Order order) {
orderModel.schedule(order);
goToShedulingView(order);
}
private void goToShedulingView(Order order) {
planningControllerEntryPoints.goToScheduleOf(order);
}

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

@ -32,7 +32,6 @@ import java.util.Map;
import java.util.Set;
import org.apache.commons.lang.Validate;
import org.joda.time.LocalDate;
import org.navalplanner.business.advance.entities.AdvanceMeasurement;
import org.navalplanner.business.advance.entities.DirectAdvanceAssignment;
import org.navalplanner.business.advance.entities.IndirectAdvanceAssignment;
@ -46,12 +45,7 @@ import org.navalplanner.business.orders.entities.HoursGroup;
import org.navalplanner.business.orders.entities.IOrderLineGroup;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.orders.entities.OrderLineGroup;
import org.navalplanner.business.planner.daos.ITaskElementDAO;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
import org.navalplanner.business.resources.daos.ICriterionDAO;
import org.navalplanner.business.resources.daos.ICriterionTypeDAO;
@ -91,9 +85,6 @@ public class OrderModel implements IOrderModel {
@Autowired
private ICriterionDAO criterionDAO;
@Autowired
private ITaskElementDAO taskElementDAO;
@Autowired
private ILabelDAO labelDAO;
@ -325,18 +316,6 @@ public class OrderModel implements IOrderModel {
return orderElementModel;
}
@Override
@Transactional
public void schedule(Order order) {
convertToScheduleAndSave(getFromDB(order));
}
@Override
@Transactional(readOnly = true)
public boolean isAlreadyScheduled(Order order) {
return getFromDB(order).isSomeTaskElementScheduled();
}
@Override
public List<Criterion> getCriterionsFor(CriterionType criterionType) {
return mapCriterions.get(criterionType);
@ -347,64 +326,4 @@ public class OrderModel implements IOrderModel {
this.order = order;
}
@Override
public TaskElement convertToInitialSchedule(OrderElement order) {
TaskElement result;
if (order instanceof OrderLineGroup) {
OrderLineGroup group = (OrderLineGroup) order;
result = convertToTaskGroup(group);
} else {
OrderLine line = (OrderLine) order;
if (line.getHoursGroups().isEmpty()) {
throw new IllegalArgumentException(_(
"The line must have at least one {0} associated",
HoursGroup.class.getSimpleName()));
}
result = line.getHoursGroups().size() > 1 ? convertToTaskGroup(line)
: convertToTask(line);
}
if (order.getDeadline() != null) {
result.setDeadline(new LocalDate(order.getDeadline()));
}
if (result instanceof Task) {
order.applyStartConstraintIfNeededTo((Task) result);
}
return result;
}
private TaskGroup convertToTaskGroup(OrderLine line) {
TaskGroup result = TaskGroup.create();
result.setOrderElement(line);
for (HoursGroup hoursGroup : line.getHoursGroups()) {
result.addTaskElement(taskFrom(line, hoursGroup));
}
return result;
}
private Task convertToTask(OrderLine line) {
HoursGroup hoursGroup = line.getHoursGroups().get(0);
return taskFrom(line, hoursGroup);
}
private Task taskFrom(OrderLine line, HoursGroup hoursGroup) {
Task result = Task.createTask(hoursGroup);
result.setOrderElement(line);
return result;
}
private TaskGroup convertToTaskGroup(OrderLineGroup group) {
TaskGroup result = TaskGroup.create();
result.setOrderElement(group);
for (OrderElement orderElement : group.getChildren()) {
result.addTaskElement(convertToInitialSchedule(orderElement));
}
return result;
}
@Override
@Transactional
public void convertToScheduleAndSave(Order order) {
taskElementDAO.save(convertToInitialSchedule(order));
}
}

2
navalplanner-webapp/src/main/webapp/orders/_list.zul
View file

@ -62,7 +62,7 @@
image="/common/img/ico_planificador1.png"
hoverImage="/common/img/ico_planificador.png"
tooltiptext="${i18n:_('Schedule')}"
onClick="controller.confirmSchedule(self.parent.parent.value);" />
onClick="controller.schedule(self.parent.parent.value);" />
</hbox>
</row>
</rows>

223
navalplanner-webapp/src/test/java/org/navalplanner/web/orders/OrderModelTest.java
View file

@ -21,10 +21,7 @@
package org.navalplanner.web.orders;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
@ -42,10 +39,8 @@ import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.joda.time.LocalDate;
import org.junit.Before;
import org.junit.Test;
import org.junit.matchers.JUnitMatchers;
import org.junit.runner.RunWith;
import org.navalplanner.business.IDataBootstrap;
import org.navalplanner.business.common.IAdHocTransactionService;
@ -58,10 +53,6 @@ import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.orders.entities.OrderLineGroup;
import org.navalplanner.business.planner.entities.StartConstraintType;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.requirements.entities.CriterionRequirement;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
import org.navalplanner.business.resources.daos.ICriterionTypeDAO;
@ -175,51 +166,6 @@ public class OrderModelTest {
assertFalse(orderDAO.exists(order.getId()));
}
@Test
@NotTransactional
public void removingOrderWithAssociatedTasksDeletesThem()
throws ValidationException, InstanceNotFoundException {
final Long orderId = adHocTransaction
.runOnTransaction(new IOnTransaction<Long>() {
@Override
public Long execute() {
Order order = createValidOrder();
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("00000000");
orderLine.setWorkHours(10);
order.add(orderLine);
orderModel.setOrder(order);
try {
orderModel.save();
} catch (ValidationException e) {
throw new RuntimeException(e);
}
orderModel.convertToScheduleAndSave(order);
getSession().flush();
return order.getId();
}
});
adHocTransaction.runOnTransaction(new IOnTransaction<Void>() {
@Override
public Void execute() {
try {
Order reloaded = orderDAO.find(orderId);
OrderElement e = reloaded.getOrderElements().iterator()
.next();
assertThat(e.getTaskElements().size(), equalTo(1));
orderModel.remove(reloaded);
assertFalse(orderDAO.exists(orderId));
return null;
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
});
}
@Test(expected = ValidationException.class)
public void shouldSendValidationExceptionIfEndDateIsBeforeThanStartingDate()
throws ValidationException {
@ -467,179 +413,10 @@ public class OrderModelTest {
orderModel.save();
}
@Test
public void aOrderLineGroupIsConvertedToATaskGroup() {
OrderLineGroup orderLineGroup = OrderLineGroup.create();
orderLineGroup.setName("foo");
orderLineGroup.setCode("000000000");
TaskElement task = orderModel.convertToInitialSchedule(orderLineGroup);
assertThat(task, is(TaskGroup.class));
TaskGroup group = (TaskGroup) task;
assertThat(group.getOrderElement(),
equalTo((OrderElement) orderLineGroup));
}
@Test
public void aOrderLineWithOneHourGroupIsConvertedToATask() {
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
final int hours = 30;
HoursGroup hoursGroup = createHoursGroup(hours);
orderLine.addHoursGroup(hoursGroup);
TaskElement taskElement = orderModel
.convertToInitialSchedule(orderLine);
assertThat(taskElement, is(Task.class));
Task group = (Task) taskElement;
assertThat(group.getOrderElement(), equalTo((OrderElement) orderLine));
assertThat(group.getHoursGroup(), equalTo(hoursGroup));
assertThat(taskElement.getWorkHours(), equalTo(hours));
}
@Test
public void theDeadlineIsCopied() {
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
final int hours = 30;
HoursGroup hoursGroup = createHoursGroup(hours);
orderLine.addHoursGroup(hoursGroup);
orderLine.setDeadline(year(2007));
TaskElement task = orderModel.convertToInitialSchedule(orderLine);
assertThat(task.getDeadline(), equalTo(new LocalDate(year(2007))));
}
@Test
public void ifNoParentWithStartDateTheStartConstraintIsSoonAsPossible() {
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
HoursGroup hoursGroup = createHoursGroup(30);
orderLine.addHoursGroup(hoursGroup);
Task task = (Task) orderModel
.convertToInitialSchedule(orderLine);
assertThat(task.getStartConstraint().getStartConstraintType(),
equalTo(StartConstraintType.AS_SOON_AS_POSSIBLE));
assertThat(task.getStartConstraint().getConstraintDate(), nullValue());
}
@Test
public void ifSomeParentHasInitDateTheStartConstraintIsNotEarlierThan() {
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
final Date initDate = year(2008);
orderLine.setInitDate(initDate);
HoursGroup hoursGroup = createHoursGroup(30);
orderLine.addHoursGroup(hoursGroup);
Task task = (Task) orderModel
.convertToInitialSchedule(orderLine);
assertThat(task.getStartConstraint().getStartConstraintType(),
equalTo(StartConstraintType.START_NOT_EARLIER_THAN));
assertThat(task.getStartConstraint().getConstraintDate(),
equalTo(initDate));
}
@Test
public void unlessTheOnlyParentWithInitDateNotNullIsTheOrder() {
Order order = Order.create();
final Date initDate = year(2008);
order.setInitDate(initDate);
OrderLine orderLine = OrderLine.create();
order.add(orderLine);
orderLine.setName("bla");
orderLine.setCode("000000000");
HoursGroup hoursGroup = createHoursGroup(30);
orderLine.addHoursGroup(hoursGroup);
Task task = (Task) orderModel.convertToInitialSchedule(orderLine);
assertThat(task.getStartConstraint().getStartConstraintType(),
equalTo(StartConstraintType.AS_SOON_AS_POSSIBLE));
assertThat(task.getStartConstraint().getConstraintDate(), nullValue());
}
@Test
public void theSublinesOfAnOrderLineGroupAreConverted() {
OrderLineGroup orderLineGroup = OrderLineGroup.create();
orderLineGroup.setName("foo");
orderLineGroup.setCode("000000000");
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
HoursGroup hoursGroup = createHoursGroup(30);
orderLine.addHoursGroup(hoursGroup);
orderLineGroup.add(orderLine);
TaskElement task = orderModel.convertToInitialSchedule(orderLineGroup);
assertThat(task, is(TaskGroup.class));
TaskGroup group = (TaskGroup) task;
assertThat(group.getOrderElement(),
equalTo((OrderElement) orderLineGroup));
assertThat(group.getChildren().size(), equalTo(1));
assertThat(group.getChildren().get(0).getOrderElement(),
equalTo((OrderElement) orderLine));
}
@Test
public void theWorkHoursOfATaskGroupAreTheSameThanTheTaskElement() {
OrderLineGroup orderLineGroup = OrderLineGroup.create();
orderLineGroup.setName("foo");
orderLineGroup.setCode("000000000");
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
orderLine.addHoursGroup(createHoursGroup(20));
orderLine.addHoursGroup(createHoursGroup(30));
orderLineGroup.add(orderLine);
TaskElement task = orderModel.convertToInitialSchedule(orderLineGroup);
assertThat(task.getWorkHours(), equalTo(orderLineGroup.getWorkHours()));
}
@Test(expected = IllegalArgumentException.class)
public void aOrderLineWithNoHoursIsRejected() {
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
orderModel.convertToInitialSchedule(orderLine);
}
private HoursGroup createHoursGroup(int hours) {
HoursGroup result = new HoursGroup();
result.setWorkingHours(hours);
return result;
}
@Test
public void aOrderLineWithMoreThanOneHourIsConvertedToATaskGroup() {
OrderLine orderLine = OrderLine.create();
orderLine.setName("bla");
orderLine.setCode("000000000");
HoursGroup hours1 = createHoursGroup(30);
orderLine.addHoursGroup(hours1);
HoursGroup hours2 = createHoursGroup(10);
orderLine.addHoursGroup(hours2);
TaskElement taskElement = orderModel
.convertToInitialSchedule(orderLine);
assertThat(taskElement, is(TaskGroup.class));
TaskGroup group = (TaskGroup) taskElement;
assertThat(group.getOrderElement(), equalTo((OrderElement) orderLine));
assertThat(group.getChildren().size(), equalTo(2));
Task child1 = (Task) group.getChildren().get(0);
Task child2 = (Task) group.getChildren().get(1);
assertThat(child1.getOrderElement(), equalTo((OrderElement) orderLine));
assertThat(child2.getOrderElement(), equalTo((OrderElement) orderLine));
assertThat(child1.getHoursGroup(), not(equalTo(child2.getHoursGroup())));
assertThat(child1.getHoursGroup(), JUnitMatchers
.either(equalTo(hours1)).or(equalTo(hours2)));
assertThat(child2.getHoursGroup(), JUnitMatchers
.either(equalTo(hours1)).or(equalTo(hours2)));
}
}