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

ItEr21S04ArquitecturaServidorItEr20S04: Removed TaskElementService and its test. Moved remainder methods to OrderModel and OrderModelTest.

Browse source
This commit is contained in:
Manuel Rego Casasnovas 2009-08-11 09:47:12 +02:00 • committed by Óscar González Fernández
parent 24839d8499
commit 94cf70d61f
6 changed files with 188 additions and 271 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
navalplanner-business/src/main/java/org/navalplanner/business/planner/services/ITaskElementService.java
View file

@ -1,16 +0,0 @@
package org.navalplanner.business.planner.services;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.planner.entities.TaskElement;
/**
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface ITaskElementService {
TaskElement convertToInitialSchedule(OrderElement order);
void convertToScheduleAndSave(Order order);
}

85
navalplanner-business/src/main/java/org/navalplanner/business/planner/services/TaskElementService.java
View file

@ -1,85 +0,0 @@
package org.navalplanner.business.planner.services;
import java.util.List;
import org.navalplanner.business.orders.entities.HoursGroup;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@Service
@Scope(BeanDefinition.SCOPE_SINGLETON)
@Transactional
public class TaskElementService implements ITaskElementService {
@Autowired
private ITaskElementDAO taskElementDao;
@Override
public TaskElement convertToInitialSchedule(OrderElement order) {
if (order instanceof OrderLineGroup) {
OrderLineGroup group = (OrderLineGroup) order;
return convertToTaskGroup(group);
} else {
OrderLine line = (OrderLine) order;
if (line.getHoursGroups().isEmpty())
throw new IllegalArgumentException(
"the line must have at least one "
+ HoursGroup.class.getSimpleName()
+ " associated");
return line.getHoursGroups().size() > 1 ? convertToTaskGroup(line)
: convertToTask(line);
}
}
private TaskGroup convertToTaskGroup(OrderLine line) {
TaskGroup result = new TaskGroup();
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 = new TaskGroup();
result.setOrderElement(group);
for (OrderElement orderElement : group.getChildren()) {
result.addTaskElement(convertToInitialSchedule(orderElement));
}
return result;
}
@Override
public void convertToScheduleAndSave(Order order) {
List<OrderElement> orderElements = order.getOrderElements();
for (OrderElement orderElement : orderElements) {
taskElementDao.save(convertToInitialSchedule(orderElement));
}
}
}

156
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/services/TaskElementServiceTest.java
View file

@ -1,156 +0,0 @@
package org.navalplanner.business.test.planner.services;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertThat;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
import org.junit.Test;
import org.junit.matchers.JUnitMatchers;
import org.junit.runner.RunWith;
import org.navalplanner.business.orders.entities.HoursGroup;
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.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.planner.services.ITaskElementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { BUSINESS_SPRING_CONFIG_FILE,
BUSINESS_SPRING_CONFIG_TEST_FILE })
@Transactional
public class TaskElementServiceTest {
@Autowired
private ITaskElementService taskElementService;
@Test
public void aOrderLineGroupIsConvertedToATaskGroup() {
OrderLineGroup orderLineGroup = OrderLineGroup.create();
orderLineGroup.setName("foo");
orderLineGroup.setCode("000000000");
TaskElement task = taskElementService
.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 = taskElementService
.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 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 = taskElementService
.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 = taskElementService
.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");
taskElementService.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 = taskElementService
.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)));
}
}

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

@ -6,6 +6,7 @@ import org.navalplanner.business.common.exceptions.ValidationException;
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;
/**
* Contract for {@link OrderModel}<br />
@ -39,4 +40,8 @@ public interface IOrderModel {
void setOrder(Order order);
TaskElement convertToInitialSchedule(OrderElement order);
void convertToScheduleAndSave(Order order);
}

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

@ -12,10 +12,16 @@ 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.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.planner.services.ITaskElementService;
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.resources.daos.ICriterionDAO;
import org.navalplanner.business.resources.daos.ICriterionTypeDAO;
import org.navalplanner.business.resources.entities.Criterion;
@ -62,13 +68,7 @@ public class OrderModel implements IOrderModel {
private ICriterionDAO criterionDAO;
@Autowired
private ITaskElementService taskElementService;
@Autowired
public OrderModel(ITaskElementService taskElementService) {
Validate.notNull(taskElementService);
this.taskElementService = taskElementService;
}
private ITaskElementDAO taskElementDAO;
@Override
@Transactional(readOnly = true)
@ -176,7 +176,7 @@ public class OrderModel implements IOrderModel {
@Override
@Transactional
public void schedule() {
taskElementService.convertToScheduleAndSave(getFromDB(order));
convertToScheduleAndSave(getFromDB(order));
}
@Override
@ -194,4 +194,59 @@ public class OrderModel implements IOrderModel {
this.order = order;
}
@Override
public TaskElement convertToInitialSchedule(OrderElement order) {
if (order instanceof OrderLineGroup) {
OrderLineGroup group = (OrderLineGroup) order;
return convertToTaskGroup(group);
} else {
OrderLine line = (OrderLine) order;
if (line.getHoursGroups().isEmpty())
throw new IllegalArgumentException(
"the line must have at least one "
+ HoursGroup.class.getSimpleName()
+ " associated");
return line.getHoursGroups().size() > 1 ? convertToTaskGroup(line)
: convertToTask(line);
}
}
private TaskGroup convertToTaskGroup(OrderLine line) {
TaskGroup result = new TaskGroup();
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 = new TaskGroup();
result.setOrderElement(group);
for (OrderElement orderElement : group.getChildren()) {
result.addTaskElement(convertToInitialSchedule(orderElement));
}
return result;
}
@Override
@Transactional
public void convertToScheduleAndSave(Order order) {
List<OrderElement> orderElements = order.getOrderElements();
for (OrderElement orderElement : orderElements) {
taskElementDAO.save(convertToInitialSchedule(orderElement));
}
}
}

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

@ -1,6 +1,8 @@
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.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
@ -18,6 +20,7 @@ import java.util.UUID;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.Test;
import org.junit.matchers.JUnitMatchers;
import org.junit.runner.RunWith;
import org.navalplanner.business.common.IAdHocTransactionService;
import org.navalplanner.business.common.IOnTransaction;
@ -31,7 +34,7 @@ import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.orders.entities.OrderLineGroup;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.services.ITaskElementService;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionType;
import org.navalplanner.business.resources.services.ICriterionService;
@ -74,9 +77,6 @@ public class OrderModelTest {
@Autowired
private IOrderModel orderModel;
@Autowired
private ITaskElementService taskElementService;
@Autowired
private ICriterionService criterionService;
@ -131,7 +131,7 @@ public class OrderModelTest {
order.add(orderLine);
orderModel.setOrder(order);
orderModel.save();
taskElementService.convertToScheduleAndSave(order);
orderModel.convertToScheduleAndSave(order);
getSession().flush();
getSession().evict(order);
Order reloaded = orderDAO.find(order.getId());
@ -356,4 +356,118 @@ 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 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)));
}
}